Packman Build Service PMBS

Changes of Revision 35

gpac.changes Changed

@@ -1,4 +1,56 @@
 -------------------------------------------------------------------
+Mon Dec 19 17:04:17 UTC 2022 - Luigi Baldoni <aloisio@gmx.com>
+
+- Update to version 2.2.0
+ Media Formats:
+ * 2-pass encoding for FFmpeg codecs other than libx264
+ * Conversion filters for VTT, TXG3 and TTML
+ * SubstationAlpha subtitle import (basic)
+ * DVB subpictures in M2TS mux and demux
+ * FFMPEG (mostly for Matroska) subtitle import and export
+ (SRT/SSA to TX3G, TX3G to SRT, WebVTT and DVB subpictures)
+ * EC3+Atmos signaling support
+ * ALAC support
+ * Improved DolbyVision muxing
+ Media player:
+ * subtitle delay and position adjustment
+ * audio delay adjustment
+ MP4Box:
+ * allow numbers and media types as identifiers for track
+ actions
+ * dlba option to update atmos+ec3 signaling
+ Filters:
+ * UTC-based range extraction in reframer
+ * Thumbnail generator filter
+ * Added unframer filter
+ * FFMPEG bitstream filters support
+ * initseg support in mp4dmx filter
+ * Access to GPU textures of decoders in Python and JSF
+ bindings (glpush filter for tests)
+ * Chapters editing and original timestamp dispatch in reformer
+ range extraction
+ * dual in-band and out-of-band parameter set support in dasher
+ * non-blocking IO for RTSP and HTTP servers/clients
+ * RTSP over HTTP in rtsp server
+ * Source-Specific multicast for udp and rtp inputs
+ * User Authentication for HTTP and RTSP servers
+ * TLS support for RTSP client and server
+ * Per-filter buffering options
+ Encryption:
+ * ClearKey support in dasher and decryption
+ Misc:
+ * QT metadata tags in MP4Box and qt muxer
+ * support for some packet properties in URL templates
+ DEPRECATED:
+ * Removed GF_Terminal API
+ * Removed MP4Client, merged old behaviour in gpac -mp4c
+ * Removed filemode option from dash demure
+- Switch build from sdl to sdl2
+- Raise sover to 12
+- Add gpac-rpath.patch and gpac-doxygen_195.patch
+- Drop gpac-rpmlintrc
+
+-------------------------------------------------------------------
 Sat Mar 5 12:24:04 UTC 2022 - Bjørn Lie <zaitor@opensuse.org>
 
 - No longer force the package to build against ffmpeg-3.x.

gpac.spec Changed

@@ -17,21 +17,24 @@
 #
 
 
-%define sover   11
+%define sover   12
 Name:           gpac
-Version:        2.0.0
+Version:        2.2.0
 Release:        0
 Summary:        A multimedia framework covering MPEG-4, VRML/X3D and SVG
 License:        LGPL-2.1-or-later
 Group:          Productivity/Multimedia/Video/Editors and Convertors
 Url:            http://gpac.io
 Source:         https://github.com/gpac/%{name}/archive/v%{version}.tar.gz#/%{name}-%{version}.tar.gz
-Source90:       %{name}-rpmlintrc
 #PATCH-FIX-UPSTREAM i@marguerite.su - fix SVGGen ldflags
 Patch2:         gpac-0.7.1-SVGGen_abuild.patch
 #PATCH-FIX-UPSTREAM wengxuetian@gmail.com - fix E: 64bit-portability-issue
 Patch3:         gpac-1.0.0-64bit-portability.patch
 Patch12:        gpac.ssl.patch
+#PATCH-FIX-OPENSUSE gpac-rpath.patch aloisio@gmx.com - fix rpath error
+Patch13:        gpac-rpath.patch
+#PATCH-FIX-OPENSUSE gpac-doxygen_195.patch aloisio@gmx.com - do not fail on warnings
+Patch14:        gpac-doxygen_195.patch
 BuildRequires:  Mesa-devel
 BuildRequires:  dos2unix
 BuildRequires:  doxygen
@@ -64,7 +67,7 @@
 BuildRequires:  pkgconfig(libpng)
 BuildRequires:  pkgconfig(libpulse)
 BuildRequires:  pkgconfig(librsvg-2.0)
-BuildRequires:  pkgconfig(sdl)
+BuildRequires:  pkgconfig(sdl2)
 BuildRequires:  pkgconfig(theora)
 BuildRequires:  pkgconfig(vorbis)
 BuildRequires:  pkgconfig(zlib)
@@ -153,6 +156,10 @@
 mkdir -pv %{buildroot}%{_mandir}/man1
 install -m0644 share/doc/man/* -t %{buildroot}%{_mandir}/man1
 
+# install html documentation
+mkdir -pv %{buildroot}%{_defaultdocdir}/libgpac-devel
+cp -a share/doc/html-libgpac %{buildroot}%{_defaultdocdir}/libgpac-devel/
+
 # fix categories
 %suse_update_desktop_file -r %{name} 'AudioVideo;Player;'
 
@@ -170,10 +177,8 @@
 
 %files
 %doc Changelog README.md
-%doc share/doc/configuration.html
 %license COPYING
 %{_bindir}/MP4Box
-%{_bindir}/MP4Client
 %{_bindir}/MPEG4Gen
 %{_bindir}/X3DGen
 %{_bindir}/SVGGen
@@ -185,7 +190,6 @@
 %{_mandir}/man1/gpac.1%{?ext_man}
 %{_mandir}/man1/gpac-filters.1%{?ext_man}
 %{_mandir}/man1/mp4box.1%{?ext_man}
-%{_mandir}/man1/mp4client.1%{?ext_man}
 
 %files -n libgpac%{sover}
 %{_libdir}/libgpac.so.%{sover}
@@ -193,6 +197,7 @@
 
 %files -n libgpac-devel
 %doc share/doc/CODING_STYLE share/doc/ipmpx_syntax.bt
+%doc share/doc/html-libgpac
 %{_includedir}/%{name}/
 %{_libdir}/libgpac.so
 %{_libdir}/pkgconfig/%{name}.pc

gpac-doxygen_195.patch Added

gpac-rpath.patch Added

@@ -0,0 +1,26 @@
+Index: gpac-2.2.0/applications/gpac/Makefile
+===================================================================
+--- gpac-2.2.0.orig/applications/gpac/Makefile
++++ gpac-2.2.0/applications/gpac/Makefile
+@@ -39,7 +39,7 @@ LINKFLAGS+=-lgpac
+ ifeq ($(CONFIG_DARWIN),yes)
+ #LINKFLAGS+= -Wl,-rpath,'@loader_path'
+ else
+-LINKFLAGS+= -Wl,-rpath,'$$ORIGIN' -Wl,-rpath-link,../../bin/gcc
++#LINKFLAGS+= -Wl,-rpath,'$$ORIGIN' -Wl,-rpath-link,../../bin/gcc
+ endif
+ endif
+ 
+Index: gpac-2.2.0/applications/mp4box/Makefile
+===================================================================
+--- gpac-2.2.0.orig/applications/mp4box/Makefile
++++ gpac-2.2.0/applications/mp4box/Makefile
+@@ -18,7 +18,7 @@ LINKFLAGS=-L../../bin/gcc -L../../extra_
+ ifeq ($(CONFIG_DARWIN),yes)
+ #LINKFLAGS+= -Wl,-rpath,'@loader_path'
+ else
+-LINKFLAGS+= -Wl,-rpath,'$$ORIGIN' -Wl,-rpath-link,../../bin/gcc
++#LINKFLAGS+= -Wl,-rpath,'$$ORIGIN' -Wl,-rpath-link,../../bin/gcc
+ endif
+ 
+ ifeq ($(STATIC_BUILD),yes)

gpac-2.0.0.tar.gz/applications/gpac/main.c Deleted

@@ -1,4847 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2017-2022
- *					All rights reserved
- *
- * This file is part of GPAC / gpac application
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <gpac/main.h>
-#include <gpac/filters.h>
-#include <gpac/thread.h>
-
-static GF_SystemRTInfo rti;
-static GF_FilterSession *session=NULL;
-static u32 list_filters = 0;
-static Bool dump_stats = GF_FALSE;
-static Bool dump_graph = GF_FALSE;
-static u32 print_filter_info = 0;
-static Bool print_meta_filters = GF_FALSE;
-static Bool load_test_filters = GF_FALSE;
-static s32 nb_loops = 0;
-static s32 runfor = 0;
-static Bool runfor_exit = GF_FALSE;
-static u32 exit_mode = 0;
-static Bool enable_prompt = GF_FALSE;
-static u32 enable_reports = 0;
-static char *report_filter = NULL;
-static Bool do_unit_tests = GF_FALSE;
-static Bool use_step_mode = GF_FALSE;
-static int alias_argc = 0;
-static char **alias_argv = NULL;
-static GF_List *args_used = NULL;
-static GF_List *args_alloc = NULL;
-static u32 gen_doc = 0;
-static u32 help_flags = 0;
-static u32 loops_done = 0;
-
-//coverage for FileIO
-static const char *make_fileio(const char *inargs, const char **out_arg, Bool is_input, GF_Err *e);
-static void cleanup_file_io();
-
-//coverage for custom filters
-static GF_Filter *load_custom_filter(GF_FilterSession *sess, char *opts, GF_Err *e);
-
-static FILE *sidebar_md=NULL;
-static FILE *helpout = NULL;
-
-static const char *auto_gen_md_warning = "\n";
-
-//uncomment to check argument description matches our conventions - see filter.h
-#define CHECK_DOC
-
-//the default set of separators
-static char separator_set7 = GF_FS_DEFAULT_SEPS;
-#define SEP_LINK	5
-#define SEP_FRAG	2
-#define SEP_LIST	3
-
-static Bool print_filters(int argc, char **argv, GF_FilterSession *session, GF_SysArgMode argmode);
-static void dump_all_props(char *pname);
-static void dump_all_colors(void);
-static void dump_all_audio_cicp(void);
-static void dump_all_codec(GF_FilterSession *session);
-static void write_filters_options(GF_FilterSession *fsess);
-static void write_core_options();
-static void write_file_extensions();
-static int gpac_make_lang(char *filename);
-static Bool gpac_expand_alias(int argc, char **argv);
-static u32 gpac_unit_tests(GF_MemTrackerType mem_track);
-
-static Bool revert_cache_file(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info);
-
-
-
-#ifndef GPAC_DISABLE_DOC
-const char *gpac_doc =
-"# General\n"
-"Filters are configurable processing units consuming and producing data packets. These packets are carried "
-"between filters through a data channel called __PID__. A PID is in charge of allocating/tracking data packets, "
-"and passing the packets to the destination filter(s). A filter output PID may be connected to zero or more filters. "
-"This fan-out is handled internally by GPAC (no such thing as a tee filter in GPAC).\n"
-"Note: When a PID cannot be connected to any filter, a warning is thrown and all packets dispatched on "
-"this PID will be destroyed. The session may however still run, unless -full-link(CORE) is set.\n"
-" \nEach output PID carries a set of properties describing the data it delivers (e.g. __width__, __height__, __codec__, ...). Properties "
-"can be built-in (see gpac -h props(filters_properties) ), or user-defined. Each PID tracks "
-"its properties changes and triggers filter reconfiguration during packet processing. This allows the filter chain to be "
-"reconfigured at run time, potentially reloading part of the chain (e.g. unload a video decoder when switching from compressed "
-"to uncompressed sources).\n"
-" \nEach filter exposes a set of argument to configure itself, using property types and values described as strings formatted with "
-"separators. This help is given with default separator sets `:=#,@` to specify filters, properties and options. Use -seps(GPAC) to change them.\n"
-"# Property and filter option format\n"
-"- boolean: formatted as `yes`,`true`,`1` or `no`,`false`,`0`\n"
-"- enumeration (for filter arguments only): must use the syntax given in the argument description, otherwise value `0` (first in enum) is assumed.\n"
-"- 1-dimension (numbers, floats, ints...): formatted as `valueunit`, where `unit` can be `k`,`K` (x 1000) or `m`,`M` (x 1000000) or `g`,`G` (x 1000000000) or `sec` (x 1000) or `min` (x 60000). `+I` means max float/int/uint value, `-I` min float/int/uint value.\n"
-"- fraction: formatted as `num/den` or `num-den` or `num`, in which case the denominator is 1 if `num` is an integer, or 1000000 if `num` is a floating-point value.\n"
-"- unsigned 32 bit integer: formatted as number or hexadecimal using the format `0xAABBCCDD`.\n"
-"- N-dimension (vectors): formatted as `DIM1xDIM2xDIM3xDIM4` values, without unit multiplier.\n"
-"- string: formatted as:\n"
-" - `value`: copies value to string.\n"
-" - `file@FILE`: load string from local `FILE` (opened in binary mode).\n"
-" - `bxml@FILE`: binarize XML from local `FILE` and set property type to data - see https://wiki.gpac.io/NHML-Format.\n"
-"- data: formatted as:\n"
-" - `size@address`: constant data block, not internally copied; `size` gives the size of the block, `address` the data pointer.\n"
-" - `0xBYTESTRING`: data block specified in hexadecimal, internally copied.\n"
-" - `file@FILE`: load data from local `FILE` (opened in binary mode).\n"
-" - `bxml@FILE`: binarize XML from local `FILE` - see https://wiki.gpac.io/NHML-Format.\n"
-" - `b64@DATA`: load data from base-64 encoded `DATA`.\n"
-"- pointer: pointer address as formatted by `%p` in C.\n"
-"- string lists: formatted as `val1,val2,...`. Each value can also use `file@FILE` syntax.\n"
-"- integer lists: formatted as `val1,val2,...`\n"
-"Note: The special characters in property formats (0x,/,-,+I,-I,x) cannot be configured.\n"
-"# Filter declaration __FILTER__\n"
-"## Generic declaration\n"
-"Each filter is declared by its name, with optional filter arguments appended as a list of colon-separated `name=value` pairs. Additional syntax is provided for:\n"
-"- boolean: `value` can be omitted, defaulting to `true` (e.g. `:noedit`). Using `!` before the name negates the result (e.g. `:!moof_first`)\n"
-"- enumerations: name can be omitted, e.g. `:disp=pbo` is equivalent to `:pbo`.\n"
-"\n \n"
-"When string parameters are used (e.g. URLs), it is recommended to escape the string using the keyword `gpac`. \n"
-"EX filter:ARG=http://foo/bar?yes:gpac:opt=VAL\n"
-"This will properly extract the URL.\n"
-"EX filter:ARG=http://foo/bar?yes:opt=VAL\n"
-"This will fail to extract it and keep `:opt=VAL` as part of the URL.\n"
-"The escape mechanism is not needed for local source, for which file existence is probed during argument parsing. "
-"It is also not needed for builtin protocol handlers (`avin://`, `video://`, `audio://`, `pipe://`)\n"
-"For `tcp://` and `udp://` protocols, the escape is not needed if a trailing `/` is appended after the port number.\n"
-"EX -i tcp://127.0.0.1:1234:OPT\n"
-"This will fail to extract the URL and options.\n"
-"EX -i tcp://127.0.0.1:1234/:OPT\n"
-"This will extract the URL and options.\n"
-"Note: one trick to avoid the escape sequence is to declare the URLs option at the end, e.g. `f1:opt1=foo:url=http://bar`, provided you have only one URL parameter to specify on the filter.\n"
-"\n"
-"It is possible to disable option parsing (for string options) by duplicating the separator.\n"
-"EX filter::opt1=UDP://IP:PORT/:someopt=VAL::opt2=VAL2\n"
-"This will pass `UDP://IP:PORT/:someopt=VAL` to `opt1` without inspecting it, and `VAL2` to `opt2`.\n"
-" \n"
-"## Source and Sink filters\n"
-"Source and sink filters do not need to be addressed by the filter name, specifying `src=` or `dst=` instead is enough. "
-"You can also use the syntax `-src URL` or `-i URL` for sources and `-dst URL` or `-o URL` for destination, this allows prompt completion in shells.\n"
-"EX \"src=file.mp4\" or \"-src file.mp4\" or \"-i file.mp4\"\n"
-"This will find a filter (for example `fin`) able to load `file.mp4`. The same result can be achieved by using `fin:src=file.mp4`.\n"
-"EX \"dst=dump.yuv\" or \"-dst dump.yuv\" or \"-o dump.yuv\"\n"
-"This will dump the video content in `dump.yuv`. The same result can be achieved by using `fout:dst=dump.yuv`.\n"
-"\n"
-"Specific source or sink filters may also be specified using `filterName:src=URL` or `filterName:dst=URL`.\n"
-"\n"
-"The `src=` and `dst=` syntaxes can also be used in alias for dynamic argument cloning (see `gpac -hx alias`).\n"
-"\n"
-"## Forcing specific filters\n"
-"There is a special option called `gfreg` which allows specifying preferred filters to use when handling URLs.\n"
-"EX src=file.mp4:gfreg=ffdmx,ffdec\n"
-"This will use __ffdmx__ to read `file.mp4` and __ffdec__ to decode it.\n"
-"This can be used to test a specific filter when alternate filter chains are possible.\n"
-"## Specifying encoders and decoders\n"
-"By default filters chain will be resolved without any decoding/encoding if the destination accepts the desired format. "
-"Otherwise, decoders/encoders will be dynamically loaded to perform the conversion, unless dynamic resolution is disabled. "
-"There is a special shortcut filter name for encoders `enc` allowing to match a filter providing the desired encoding. "
-"The parameters for `enc` are:\n"
-"- c=NAME: identifies the desired codec. `NAME` can be the GPAC codec name or the encoder instance for ffmpeg/others\n"
-"- b=UINT, rate=UINT, bitrate=UINT: indicates the bitrate in bits per second\n"
-"- g=UINT, gop=UINT: indicates the GOP size in frames\n"
-"- pfmt=NAME: indicates the target pixel format name (see properties (-h props)(filters_properties) ) of the source, if supported by codec\n"
-"- all_intra=BOOL: indicates all frames should be intra frames, if supported by codec\n"
-"\n"
-"Other options will be passed to the filter if it accepts generic argument parsing (as is the case for ffmpeg).\n"
-"The shortcut syntax `c=TYPE` (e.g. `c=aac:opts`) is also supported.\n"
-"\n"
-"EX gpac -i dump.yuv:size=320x240:fps=25 enc:c=avc:b=150000:g=50:cgop=true:fast=true -o raw.264\n"
-"This creates a 25 fps AVC at 175kbps with a gop duration of 2 seconds, using closed gop and fast encoding settings for ffmpeg.\n"
-"\n"
-"The inverse operation (forcing a decode to happen) is possible using the __reframer__ filter.\n"
-"EX gpac -i file.mp4 reframer:raw=av -o null\n"
-"This will force decoding media from `file.mp4` and trash (send to `null`) the result (doing a decoder benchmark for example).\n"
-"\n"
-"## Escaping option separators\n"
-"When a filter uses an option defined as a string using the same separator character as gpac, you can either "
-"modify the set of separators, or escape the separator by duplicating it. The options enclosed by duplicated "
-"separator are not parsed. This is mostly used for meta filters, such as ffmpeg, to pass options to sub-filters "
-"such as libx264 (cf `x264opts` parameter).\n"
-"EX f:a=foo:b=bar\n"
-"This will set option `a` to `foo` and option `b` to `bar` on the filter.\n"
-"EX f::a=foo:b=bar\n"
-"This will set option `a` to `foo:b=bar` on the filter.\n"
-"EX f:a=foo::b=bar:c::d=fun\n"
-"This will set option `a` to `foo`, `b` to `bar:c` and the option `d` to `fun` on the filter.\n"
-"\n"
-"# Filter linking __LINK__\n"
-"\n"
-"Each filter exposes one or more sets of capabilities, called __capability bundle__, which are property type and values "
-"that must be matched or excluded by connecting PIDs.\n"
-"To check the possible sources and destination for a filter `FNAME`, use `gpac -h links FNAME`\n"
-"\n"
-"The filter graph resolver uses this information together with the PID properties to link the different filters.\n"
-"\n"
-"Link directives, when provided, specify which source a filter can accept connections from.\n"
-"__They do not specify which destination a filter can connect to.__\n"
-"\n"
-"## Default filter linking\n"
-"When no link instructions are given (see below), the default linking strategy used is either __implicit mode__ (default in `gpac`) or __complete mode__ (if -cl(GPAC) is set).\n"
-"Each PID is checked for possible connection to all defined filters, in their declaration order.\n"
-"For each filter `DST` accepting a connection from the PID, directly or with intermediate filters:\n"
-"- if `DST` filter has link directives, use them to allow or reject PID connection.\n"
-"- otherwise, if __complete mode__ is enabled, allow connection.\n"
-"- otherwise (__implicit mode__):\n"
-" - if `DST` is not a sink and is the first matching filter with no link directive, allow connection.\n"
-" - otherwise, if `DST` is not a sink and is not the first matching filter with no link directive, reject connection.\n"
-" - otherwise (`DST` is a sink) and no previous connections to a non-sink filter, allow connection.\n"
-"\n"
-"EX gpac -i file.mp4 c=avc -o output\n"
-"With this setup in __implicit mode__:\n"
-"- if the file has a video PID, it will connect to `enc` but not to `output`. The output PID of `enc` will connect to `output`.\n"
-"- if the file has other PIDs than video, they will connect to `output`, since this `enc` filter accepts only video.\n"
-"\n"
-"EX gpac -cl -i file.mp4 c=avc -o output\n"
-"With this setup in __complete mode__:\n"
-"- if the file has a video PID, it will connect both to `enc` and to `output`, and the output PID of `enc` will connect to `output`.\n"
-"- if the file has other PIDs than video, they will connect to `output`.\n"
-"\n"
-"Furthermore in __implicit mode__, filter connections are restricted to filters defined between the last source and the sink(s).\n"
-"EX gpac -i video1 reframer:saps=1 -i video2 ffsws:osize=128x72 -o output\n"
-"This will connect:\n"
-"- `video1` to `reframer` then `reframer` to `output` but will prevent `reframer` to `ffsws` connection.\n"
-"- `video2` to `ffsws` then `ffsws` to `output` but will prevent `video2` to `reframer` connection.\n"
-"\n"
-"EX gpac -i video1 -i video2 reframer:saps=1 ffsws:osize=128x72 -o output\n"
-"This will connect `video1` AND `video2` to `reframer->ffsws->output`\n"
-"\n"
-"The __implicit mode__ allows specifying linear processing chains (no PID fan-out except for final output(s)) without link directives, simplifying command lines for common cases.\n"
-"Warning: Argument order really matters in implicit mode!\n"
-"\n"
-"EX gpac -i file.mp4 c=avc c=aac -o output\n"
-"If the file has a video PID, it will connect to `c=avc` but not to `output`. The output PID of `c=avc` will connect to `output`.\n"
-"If the file has an audio PID, it will connect to `c=aac` but not to `output`. The output PID of `c=aac` will connect to `output`.\n"
-"If the file has other PIDs than audio or video, they will connect to `output`.\n"
-"\n"
-"EX gpac -i file.mp4 ffswf=osize:128x72 c=avc resample=osr=48k c=aac -o output\n"
-"This will force:\n"
-"- `SRC(video)->ffsws->enc(video)->output` and prevent `SRC(video)->output`, `SRC(video)->enc(video)` and `ffsws->output` connections which would happen in __complete mode__.\n"
-"- `SRC(audio)->resample->enc(audio)->output` and prevent `SRC(audio)->output`, `SRC(audio)->enc(audio)` and `resample->output` connections which would happen in __complete mode__.\n"
-"\n"
-"## Quick links\n"
-"Link between filters may be manually specified. The syntax is an `@` character optionally followed by an integer (0 if omitted).\n"
-"This indicates that the following filter specified at prompt should be linked only to a previous listed filter.\n"
-"The optional integer is a 0-based index to the previous filter declarations, 0 indicating the previous filter declaration, 1 the one before the previous declaration, ...).\n"
-"If `@@` is used instead of `@`, the optional integer gives the filter index starting from the first filter (index 0) specified in command line.\n"
-"Several link directives can be given for a filter.\n"
-"EX fA fB @1 fC\n"
-"This indicates that `fC` only accepts inputs from `fA`.\n"
-"EX fA fB fC @1 @0 fD\n"
-"This indicates that `fD` only accepts inputs from `fB` and `fC`.\n"
-"EX fA fB fC ... @@1 fZ\n"
-"This indicates that `fZ` only accepts inputs from `fB`.\n"
-"\n"
-"## Complex links\n"
-"The `@` link directive is just a quick shortcut to set the following filter arguments:\n"
-"- FID=name: assigns an identifier to the filter\n"
-"- SID=name1,name2...: sets a list of filter identifiers, or __sourceIDs__, restricting the list of possible inputs for a filter.\n"
-"\n"
-"EX fA fB @1 fC\n"
-"This is equivalent to `fA:FID=1 fB fC:SID=1`.\n"
-"EX fA:FID=1 fB fC:SID=1\n"
-"This indicates that `fC` only accepts input from `fA`, but `fB` might accept inputs from `fA`.\n"
-"EX fA:FID=1 fB:FID=2 fC:SID=1 fD:SID=1,2\n"
-"This indicates that `fD` only accepts input from `fA` and `fB` and `fC` only from `fA`\n"
-"Note: A filter with sourceID set cannot get input from filters with no IDs.\n"
-"\n"
-"A sourceID name can be further extended using fragment identifier (`#` by default):\n"
-"- name#PIDNAME: accepts only PID(s) with name `PIDNAME`\n"
-"- name#TYPE: accepts only PIDs of matching media type. TYPE can be `audio`, `video`, `scene`, `text`, `font`, `meta`\n"
-"- name#TYPEN: accepts only `N` (1-based index) PID of matching type from source (e.g. `video2` to only accept second video PID)\n"
-"- name#TAG=VAL: accepts the PID if its parent filter has no tag or a tag matching `VAL`\n"
-"- name#P4CC=VAL: accepts only PIDs with builtin property of type `P4CC` and value `VAL`.\n"
-"- name#PName=VAL: same as above, using the builtin name corresponding to the property.\n"
-"- name#AnyName=VAL: same as above, using the name of a non built-in property.\n"
-"- name#Name=OtherPropName: compares the value with the value of another property of the PID. The matching will fail if the value to compare to is not present or different from the value to check. The property to compare with shall be a built-in property.\n"
-"If the property is not defined on the PID, the property is matched. Otherwise, its value is checked against the given value.\n"
-"\n"
-"The following modifiers for comparisons are allowed (for any fragment format using `=`):\n"
-"- name#P4CC=!VAL: accepts only PIDs with property NOT matching `VAL`.\n"
-"- name#P4CC-VAL: accepts only PIDs with property strictly less than `VAL` (only for 1-dimension number properties).\n"
-"- name#P4CC+VAL: accepts only PIDs with property strictly greater than `VAL` (only for 1-dimension number properties).\n"
-"\n"
-"A sourceID name can also use wildcard or be empty to match a property regardless of the source filter.\n"
-"EX fA fB:SID=*#ServiceID=2\n"
-"EX fA fB:SID=#ServiceID=2\n"
-"This indicates to match connection between `fA` and `fB` only for PIDs with a `ServiceID` property of `2`.\n"
-"These extensions also work with the __LINK__ `@` shortcut.\n"
-"EX fA fB @1#video fC\n"
-"This indicates that `fC` only accepts inputs from `fA`, and of type video.\n"
-"EX gpac -i img.heif @#ItemID=200 vout\n"
-"This indicates to connect to `vout` only PIDs with `ItemID` property equal to `200`.\n"
-"EX gpac -i vid.mp4 @#PID=1 vout\n"
-"This indicates to connect to `vout` only PIDs with `ID` property equal to `1`.\n"
-"EX gpac -i vid.mp4 @#Width=640 vout\n"
-"This indicates to connect to `vout` only PIDs with `Width` property equal to `640`.\n"
-"EX gpac -i vid.mp4 @#Width-640 vout\n"
-"This indicates to connect to `vout` only PIDs with `Width` property less than `640`\n"
-"EX gpac -i vid.mp4 @#ID=ItemID#ItemNumber=1 vout\n"
-"This will connect to `vout` only PID with an ID property equal to ItemID property (keep items, discard tracks) and an Item number of 1 (first item).\n"
-"\n"
-"Multiple fragment can be specified to check for multiple PID properties.\n"
-"EX gpac -i vid.mp4 @#Width=640#Height+380 vout\n"
-"This indicates to connect to `vout` only PIDs with `Width` property equal to `640` and `Height` greater than `380`.\n"
-"\n"
-"Warning: If a PID directly connects to one or more explicitly loaded filters, no further dynamic link resolution will "
-"be done to connect it to other filters with no sourceID set. Link directives should be carefully setup.\n"
-"EX fA @ reframer fB\n"
-"If `fB` accepts inputs provided by `fA` but `reframer` does not, this will link `fA` PID to `fB` filter since `fB` has no sourceID.\n"
-"Since the PID is connected, the filter engine will not try to solve a link between `fA` and `reframer`.\n"
-"\n"
-"An exception is made for local files: by default, a local file destination will force a remultiplex of input PIDs from a local file.\n"
-"EX gpac -i file.mp4 -o dump.mp4\n"
-"This will prevent direct connection of PID of type `file` to dst `file.mp4`, remultiplexing the file.\n"
-"\n"
-"The special option `nomux` is used to allow direct connections (ignored for non-sink filters).\n"
-"EX gpac -i file.mp4 -o dump.mp4:nomux\n"
-"This will result in a direct file copy.\n"
-"\n"
-"This only applies to local files destination. For pipes, sockets or other file outputs (HTTP, ROUTE):\n"
-"- direct copy is enabled by default\n"
-"- `nomux=0` can be used to force remultiplex\n"
-"\n"
-"## Sub-session tagging\n"
-"Filters may be assigned to a sub-session using `:FS=N`, with `N` a positive integer.\n"
-"Filters belonging to different sub-sessions may only link to each-other:\n"
-"- if explicitly allowed through sourceID directives (`@` or `SID`)\n"
-"- or if they have the same sub-session identifier\n"
-"\n"
-"This is mostly used for __implicit mode__ in `gpac`: each first source filter specified after a sink filter will trigger a new sub-session.\n"
-"EX gpac -i in1.mp4 -i in2.mp4 -o out1.mp4 -o out2.mp4\n"
-"This will result in both inputs multiplexed in both outputs.\n"
-"EX gpac -i in1.mp4 -o out1.mp4 -i in2.mp4 -o out2.mp4\n"
-"This will result in in1 mixed to out1 and in2 mixed to out2, these last two filters belonging to a different sub-session.\n"
-"\n"
-"# Arguments inheriting\n"
-"Unless explicitly disabled (see -max-chain(CORE)), the filter engine will resolve implicit or explicit (__LINK__) connections "
-"between filters and will allocate any filter chain required to connect the filters. "
-"In doing so, it loads new filters with arguments inherited from both the source and the destination.\n"
-"EX gpac -i file.mp4:OPT -o file.aac -o file.264\n"
-"This will pass the `:OPT` to all filters loaded between the source and the two destinations.\n"
-"EX gpac -i file.mp4 -o file.aac:OPT -o file.264\n"
-"This will pass the `:OPT` to all filters loaded between the source and the file.aac destination.\n"
-"Note: the destination arguments inherited are the arguments placed **AFTER** the `dst=` option.\n"
-"EX gpac -i file.mp4 fout:OPTFOO:dst=file.aac:OPTBAR\n"
-"This will pass the `:OPTBAR` to all filters loaded between `file.mp4` source and `file.aac` destination, but not `OPTFOO`.\n"
-"Arguments inheriting can be stopped by using the keyword `gfloc`: arguments after the keyword will not be inherited.\n"
-"EX gpac -i file.mp4 -o file.aac:OPTFOO:gfloc:OPTBAR -o file.264\n"
-"This will pass `:OPTFOO` to all filters loaded between `file.mp4` source and `file.aac` destination, but not `OPTBAR`\n"
-"Arguments are by default tracked to check if they were used by the filter chain, and a warning is thrown if this is not the case.\n"
-"It may be useful to specify arguments which may not be consumed depending on the graph resolution; the specific keyword `gfopt` indicates that arguments after the keyword will not be tracked.\n"
-"EX gpac -i file.mp4 -o file.aac:OPTFOO:gfopt:OPTBAR -o file.264\n"
-"This will warn if `OPTFOO` is not consumed, but will not track `OPTBAR`.\n"
-" \n"
-"A filter may be assigned a name (for inspection purposes, not inherited) using `:N=name` option. This name is not used in link resolution and may be changed at runtime by the filter instance.\n"
-" \n"
-"A filter may be assigned a tag (any string) using `:TAG=name` option. This tag does not need to be unique, and can be used to exclude filter in link resolution. Tags are not inherited, therefore dynamically loaded filters never have a tag.\n"
-" \n"
-"# URL templating\n"
-"Destination URLs can be dynamically constructed using templates. Pattern `$KEYWORD$` is replaced in the template with the "
-"resolved value and `$KEYWORD%%0Nd$` is replaced in the template with the resolved integer, padded with up to N zeros if needed.\n"
-"`KEYWORD` is **case sensitive**, and may be present multiple times in the string. Supported `KEYWORD`:\n"
-"- num: replaced by file number if defined, 0 otherwise\n"
-"- PID: ID of the source PID\n"
-"- URL: URL of source file\n"
-"- File: path on disk for source file; if not found, use URL if set, or PID name otherwise\n"
-"- Type: name of stream type of PID (`video`, `audio` ...)\n"
-"- p4cc=ABCD: uses PID property with 4CC value `ABCD`\n"
-"- pname=VAL: uses PID property with name `VAL`\n"
-"- OTHER: locates property 4CC for the given name, or property name if no 4CC matches.\n"
-" \n"
-"`$$` is an escape for $\n"
-"\n"
-"Templating can be useful when encoding several qualities in one pass.\n"
-"EX gpac -i dump.yuv:size=640x360 vcrop:wnd=0x0x320x180 c=avc:b=1M @2 c=avc:b=750k -o dump_$CropOrigin$x$Width$x$Height$.264:clone\n"
-"This will create a cropped version of the source, encoded in AVC at 1M, and a full version of the content in AVC at 750k. "
-"Outputs will be `dump_0x0x320x180.264` for the cropped version and `dump_0x0x640x360.264` for the non-cropped one.\n"
-"# Cloning filters\n"
-"When a filter accepts a single connection and has a connected input, it is no longer available for dynamic resolution. "
-"There may be cases where this behavior is undesired. Take a HEIF file with N items and do:\n"
-"EX gpac -i img.heif -o dump_$ItemID$.jpg\n"
-"In this case, only one item (likely the first declared in the file) will connect to the destination.\n"
-"Other items will not be connected since the destination only accepts one input PID.\n"
-"There is a special option `clone` allowing filters to be cloned with the same arguments. The cloned filters have the same ID as the original one.\n"
-"EX gpac -i img.heif -o dump_$ItemID$.jpg:clone\n"
-"In this case, the destination will be cloned for each item, and all will be exported to different JPEGs thanks to URL templating.\n"
-"EX gpac -i vid.mpd c=avc:FID=1:clone -o transcode.mpd:SID=1\n"
-"In this case, the encoder will be cloned for each video PIDs in the source, and the destination will only use PIDs coming from the encoders.\n"
-"\n"
-"When implicit linking is enabled, all filters are by default clonable. This allows duplicating the processing for each PIDs of the same type.\n"
-"EX gpac -i dual_audio resample:osr=48k c=aac -o dst\n"
-"The `resampler` filter will be cloned for each audio PID, and the encoder will be cloned for each resampler output.\n"
-"You can explicitly deactivate the cloning instructions:\n"
-"EX gpac -i dual_audio resample:osr=48k:clone=0 c=aac -o dst\n"
-"The first audio will connect to the `resample` filter, the second to the `enc` filter and the `resample` output will connect to a clone of the `enc` filter.\n"
-"\n"
-"# Templating filter chains\n"
-"There can be cases where the number of desired outputs depends on the source content, for example dumping a multiplex of N services into N files. When the destination involves multiplexing the input PIDs, the `:clone` option is not enough since the multiplexer will always accept the input PIDs.\n"
-"To handle this, it is possible to use a PID property name in the sourceID of a filter with the value `*` or an empty value. In this case, whenever a new PID with a new value for the property is found, the filter with such sourceID will be dynamically cloned.\n"
-"Warning: This feature should only be called with a single property set to `*` (or empty) per source ID, results are undefined otherwise.\n"
-"EX gpac -i source.ts -o file_$ServiceID$.mp4:SID=*#ServiceID=*\n"
-"EX gpac -i source.ts -o file_$ServiceID$.mp4:SID=#ServiceID=\n"
-"In this case, each new `ServiceID` value found when connecting PIDs to the destination will create a new destination file.\n"
-"\n"
-"Cloning in implicit linking mode applies to output as well:\n"
-"EX gpac -i dual_audio -o dst_$PID$.aac\n"
-"Each audio track will be dumped to aac (potentially reencoding if needed).\n"
-"\n"
-"# Assigning PID properties\n"
-"It is possible to define properties on output PIDs that will be declared by a filter. This allows tagging parts of the "
-"graph with different properties than other parts (for example `ServiceID`). "
-"The syntax is the same as filter option, and uses the fragment separator to identify properties, e.g. `#Name=Value`.\n"
-"This sets output PIDs property (4cc, built-in name or any name) to the given value. Value can be omitted for boolean "
-"(defaults to true, e.g. `:#Alpha`).\n"
-"Non built-in properties are parsed as follows:\n"
-"- `file@FOO` will be declared as string with a value set to the content of `FOO`.\n"
-"- `bxml@FOO` will be declared as data with a value set to the binarized content of `FOO`.\n"
-"- `FOO` will be declared as string with a value set to `FOO`.\n"
-"- `TYPE@FOO` will be parsed according to `TYPE`. If the type is not recognized, the entire value is copied as string. See `gpac -h props` for defined types.\n"
-"\n"
-"User-assigned PID properties on filter `fA` will be inherited by all filters dynamically loaded to solve `fA -> fB` connection.\n"
-"If `fB` also has user-assigned PID properties, these only apply starting from `fB` in the chain and are not inherited by filters between `fA` and `fB`.\n"
-"\n"
-"Warning: Properties are not filtered and override the properties of the filter's output PIDs, be careful not to break "
-"the session by overriding core properties such as width/height/samplerate/... !\n"
-"EX gpac -i v1.mp4:#ServiceID=4 -i v2.mp4:#ServiceID=2 -o dump.ts\n"
-"This will multiplex the streams in `dump.ts`, using `ServiceID` 4 for PIDs from `v1.mp4` and `ServiceID` 2 for PIDs from `v2.mp4`.\n"
-"\n"
-"PID properties may be conditionally assigned by checking other PID properties. The syntax uses parenthesis (not configurable) after the property assignment sign:\n"
-"`#Prop=(CP=CV)VAL`\n"
-"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV`.\n"
-"`#Prop=(CP=CV)VAL,(CP2=CV2)VAL2`\n"
-"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV`, and to `VAL2` for PIDs with property `CP2` equal to `CV2`.\n"
-"`#Prop=(CP=CV)(CP2=CV2)VAL`\n"
-"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV` and property `CP2` equal to `CV2`.\n"
-"`#Prop=(CP=CV)VAL,()DEFAULT`\n"
-"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV`, or to `DEFAULT` for other PIDs.\n"
-"The condition syntax is the same as source ID fragment syntax.\n"
-"Note: When set, the default value (empty condition) always matches the PID, therefore it should be placed last in the list of conditions.\n"
-"EX gpac -i source.mp4:#MyProp=(audio)\"Super Audio\",(video)\"Super Video\"\n"
-"This will assign property `MyProp` to `Super Audio` for audio PIDs and to `Super Video` for video PIDs.\n"
-"EX gpac -i source.mp4:#MyProp=(audio1)\"Super Audio\"\n"
-"This will assign property `MyProp` to `Super Audio` for first audio PID declared.\n"
-"EX gpac -i source.mp4:#MyProp=(Width+1280)HD\n"
-"This will assign property `MyProp` to `HD` for PIDs with property `Width` greater than 1280.\n"
-"# Using option files\n"
-"It is possible to use a file to define options of a filter, by specifying the target file name as an option without value, i.e. `:myopts.txt`.\n"
-"Warning: Only local files are allowed.\n"
-"An option file is a simple text file containing one or more options or PID properties on one or more lines.\n"
-"A line beginning with \"//\" is a comment and is ignored.\n"
-"Options in an option file may point to other option files, with a maximum redirection level of 5.\n"
-"An option file declaration (`filter:myopts.txt`) follows the same inheritance rules as regular options.\n"
-"EX gpac -i source.mp4:myopts.txt:foo=bar -o dst\n"
-"Any filter loaded between `source.mp4` and `dst` will inherit both `myopts.txt` and `foo` options and will resolve options and PID properties given in `myopts.txt`.\n"
-"# Specific filter options\n"
-"Some specific keywords are replaced when processing filter options.\n"
-"Warning: These keywords do not apply to PID properties. Multiple keywords cannot be defined for a single option.\n"
-"Defined keywords:\n"
-"- $GSHARE: replaced by system path to GPAC shared directory (e.g. /usr/share/gpac)\n"
-"- $GJS: replaced by the first path from global share directory and paths set through -js-dirs(CORE) that contains the file name following the macro, e.g. $GJS/source.js\n"
-"- $GLANG: replaced by the global config language option -lang(CORE)\n"
-"- $GUA: replaced by the global config user agent option -user-agent(CORE)\n"
-"- $GINC(init_val,inc): replaced by `init_val` and increment `init_val` by `inc` (positive or negative number, 1 if not specified) each time a new filter using this string is created.\n"
-"\n"
-"The `$GINC` construct can be used to dynamically assign numbers in filter chains:\n"
-"EX gpac -i source.ts tssplit @#ServiceID= -o dump_$GINC(10,2).ts\n"
-"This will dump first service in dump_10.ts, second service in dump_12.ts, etc...\n"
-"\n"
-"As seen previously, the following options may be set on any filter, but are not visible in individual filter help:\n"
-"- FID: filter identifier\n"
-"- SID: filter source(s)\n"
-"- N: filter name\n"
-"- FS: sub-session identifier\n"
-"- TAG: filter tag\n"
-"- clone: filter cloning flag\n"
-"- nomux: enable/disable direct file copy\n"
-"- gfreg: preferred filter registry names for link solving\n"
-"- gfloc: following options are local to filter declaration (not inherited)\n"
-"- gfopt: following options are not tracked\n"
-"- gpac: argument separator for URLs\n"
-"\n"
-"# External filters\n"
-"GPAC comes with a set of built-in filters in libgpac. It may also load external filters in dynamic libraries, located in "
-"default module folder or folders listed in -mod-dirs(CORE) option. The files shall be named `gf_*` and shall export"
-" a single function `RegisterFilter` returning a filter register - see libgpac documentation(https://doxygen.gpac.io/) for more details.\n"
-"\n";
-#endif
-
-static void gpac_filter_help(void)
-{
-	gf_sys_format_help(helpout, help_flags,
-"Usage: gpac options FILTER LINK FILTER ... \n"
-#ifndef GPAC_DISABLE_DOC
-	"%s", gf_sys_localized("gpac", "doc", gpac_doc)
-#else
-	"GPAC compiled without built-in doc.\n"
-#endif
-	);
-
-}
-
-#include <gpac/modules/video_out.h>
-#include <gpac/modules/audio_out.h>
-#include <gpac/modules/compositor_ext.h>
-#include <gpac/modules/hardcoded_proto.h>
-#include <gpac/modules/font.h>
-
-static void gpac_modules_help(void)
-{
-	u32 i;
-	gf_sys_format_help(helpout, help_flags, "Available modules:\n");
-	for (i=0; i<gf_modules_count(); i++) {
-		char *str = (char *) gf_modules_get_file_name(i);
-		if (!str) continue;
-		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s: implements ", str);
-		if (!strncmp(str, "gm_", 3) || !strncmp(str, "gsm_", 4)) {
-			GF_BaseInterface *ifce = gf_modules_load_by_name(str, GF_VIDEO_OUTPUT_INTERFACE);
-			if (ifce) {
-				gf_sys_format_help(helpout, help_flags, "VideoOutput ");
-				gf_modules_close_interface(ifce);
-			}
-			ifce = gf_modules_load_by_name(str, GF_AUDIO_OUTPUT_INTERFACE);
-			if (ifce) {
-				gf_sys_format_help(helpout, help_flags, "AudioOutput ");
-				gf_modules_close_interface(ifce);
-			}
-			ifce = gf_modules_load_by_name(str, GF_FONT_READER_INTERFACE);
-			if (ifce) {
-				gf_sys_format_help(helpout, help_flags, "FontReader ");
-				gf_modules_close_interface(ifce);
-			}
-			ifce = gf_modules_load_by_name(str, GF_COMPOSITOR_EXT_INTERFACE);
-			if (ifce) {
-				gf_sys_format_help(helpout, help_flags, "CompositorExtension ");
-				gf_modules_close_interface(ifce);
-			}
-			ifce = gf_modules_load_by_name(str, GF_HARDCODED_PROTO_INTERFACE);
-			if (ifce) {
-				gf_sys_format_help(helpout, help_flags, "HardcodedProto ");
-				gf_modules_close_interface(ifce);
-			}
-		} else {
-			gf_sys_format_help(helpout, help_flags, "Filter ");
-		}
-		gf_sys_format_help(helpout, help_flags, "\n");
-	}
-	gf_sys_format_help(helpout, help_flags, "\n");
-}
-
-#ifndef GPAC_DISABLE_DOC
-const char *gpac_alias =
-"The gpac command line can become quite complex when many sources or filters are used. In order to simplify this, an alias system is provided.\n"
-"\n"
-"To assign an alias, use the syntax `gpac -alias=\"NAME VALUE\"`.\n"
-"- `NAME`: shall be a single string, with no space.\n"
-"- `VALUE`: the list of argument this alias replaces. If not set, the alias is destroyed\n"
-"\n"
-"When parsing arguments, the alias will be replace by its value.\n"
-"EX gpac -alias=\"output aout vout\"\n"
-"This allows later audio and video playback using `gpac -i src.mp4 output`\n"
-"\n"
-"Aliases can use arguments from the command line. The allowed syntaxes are:\n"
-"- `@{a}`: replaced by the value of the argument with index `a` after the alias\n"
-"- `@{a,b}`: replaced by the value of the arguments with index `a` and `b`\n"
-"- `@{a:b}`: replaced by the value of the arguments between index `a` and `b`\n"
-"- `@{-a,b}`: replaced by the value of the arguments with index `a` and `b`, inserting a list separator (comma by default) between them\n"
-"- `@{-a:b}`: replaced by the value of the arguments between index `a` and `b`, inserting a list separator (comma by default) between them\n"
-"- `@{+a,b}`: clones the parent word in the alias for `a` and `b`, replacing this pattern in each clone by the corresponding argument\n"
-"- `@{+a:b}`: clones the parent word in the alias for each argument between index `a` and `b`, replacing this pattern in each clone by the corresponding argument\n"
-"\n"
-"The specified index can be:\n"
-"- forward index: a strictly positive integer, 1 being the first argument after the alias\n"
-"- backward index: the value 'n' (or 'N') to indicate the last argument on the command line. This can be followed by `-x` to rewind arguments (e.g. `@{n-1}` is the before last argument)\n"
-"\n"
-"Before solving aliases, all option arguments are moved at the beginging of the command line. This implies that alias arguments cannot be options.\n"
-"Arguments not used by any aliases are kept on the command line, other ones are removed\n"
-"\n"
-"EX -alias=\"foo src=@{N} dst=test.mp4\"\n"
-"The command `gpac foo f1 f2` expands to `gpac src=f2 dst=test.mp4 f1`\n"
-"EX -alias=\"list: inspect src=@{+:N}\"\n"
-"The command `gpac list f1 f2 f3` expands to `gpac inspect src=f1 src=f2 src=f3`\n"
-"EX -alias=\"list inspect src=@{+2:N}\"\n"
-"The command `gpac list f1 f2 f3` expands to `gpac inspect src=f2 src=f3 f1`\n"
-"EX -alias=\"plist aout vout flist:srcs=@{-,N}\"\n"
-"The command `gpac plist f1 f2 f3` expands to `gpac aout vout flist:srcs=\"f1,f2,f3\"` \n"
-"\n"
-"Alias documentation can be set using `gpac -aliasdoc=\"NAME VALUE\"`, with `NAME` the alias name and `VALUE` the documentation.\n"
-"Alias documentation will then appear in gpac help.\n"
-"\n";
-#endif
-
-static void gpac_alias_help(GF_SysArgMode argmode)
-{
-	u32 i, count;
-
-	if (argmode >= GF_ARGMODE_EXPERT) {
-
-#ifndef GPAC_DISABLE_DOC
-		gf_sys_format_help(helpout, help_flags, "%s", gf_sys_localized("gpac", "alias", gpac_alias) );
-#else
-		gf_sys_format_help(helpout, help_flags, "%s", "GPAC compiled without built-in doc.\n");
-#endif
-		if (argmode == GF_ARGMODE_EXPERT) {
-			return;
-		}
-	}
-
-	count = gf_opts_get_key_count("gpac.alias");
-	if (count) {
-		if (argmode < GF_ARGMODE_EXPERT) {
-			gf_sys_format_help(helpout, help_flags, "Available aliases (use 'gpac -hx alias' for more info on aliases):\n");
-		} else {
-			gf_sys_format_help(helpout, help_flags, "Available aliases:\n");
-		}
-		for (i=0; i<count; i++) {
-			const char *alias = gf_opts_get_key_name("gpac.alias", i);
-			const char *alias_doc = gf_opts_get_key("gpac.aliasdoc", alias);
-			const char *alias_value = gf_opts_get_key("gpac.alias", alias);
-
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s", alias);
-			if (argmode>=GF_ARGMODE_ADVANCED)
-				gf_sys_format_help(helpout, help_flags, " (%s)", alias_value);
-
-			if (alias_doc)
-				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_OPT_DESC, ": %s", gf_sys_localized("gpac", "aliasdoc", alias_doc));
-			else if (argmode<GF_ARGMODE_ADVANCED) {
-				gf_sys_format_help(helpout, help_flags, " (%s)", alias_value);
-			}
-
-			gf_sys_format_help(helpout, help_flags, "\n");
-		}
-	} else {
-		gf_sys_format_help(helpout, help_flags, "No aliases defined - use 'gpac -hx alias' for more info on aliases\n");
-	}
-}
-
-
-static void gpac_core_help(GF_SysArgMode mode, Bool for_logs)
-{
-	u32 mask;
-	gf_sys_format_help(helpout, help_flags, "# libgpac %s options:\n", for_logs ? "logs" : "core");
-	if (for_logs) {
-		mask = GF_ARG_SUBSYS_LOG;
-	} else {
-		mask = 0xFFFFFFFF;
-		mask &= ~GF_ARG_SUBSYS_LOG;
-		mask &= ~GF_ARG_SUBSYS_FILTERS;
-	}
-	gf_sys_print_core_help(helpout, help_flags, mode, mask);
-}
-
-static GF_GPACArg gpac_args =
-{
-#ifdef GPAC_MEMORY_TRACKING
- 	GF_DEF_ARG("mem-track", NULL, "enable memory tracker", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
- 	GF_DEF_ARG("mem-track-stack", NULL, "enable memory tracker with stack dumping", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-#endif
-	GF_DEF_ARG("ltf", NULL, "load test-unit filters (used for for unit tests only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("sloop", NULL, "loop execution of session, creating a session at each loop, mainly used for testing. If no value is given, loops forever", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
- 	GF_DEF_ARG("runfor", NULL, "run for the given amount of milliseconds", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
- 	GF_DEF_ARG("runforx", NULL, "run for the given amount of milliseconds and exit with no cleanup", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
- 	GF_DEF_ARG("runfors", NULL, "run for the given amount of milliseconds and exit with segfault (tests)", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
- 	GF_DEF_ARG("runforl", NULL, "run for the given amount of milliseconds and wait forever at end (tests)", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
-
-	GF_DEF_ARG("stats", NULL, "print stats after execution", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("graph", NULL, "print graph after execution", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("k", NULL, "enable keyboard interaction from command line", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("r", NULL, "enable reporting\n"
-			"- r: runtime reporting\n"
-			"- r=FA,FB: runtime reporting but only print given filters, e.g. `r=mp4mx` for ISOBMFF multiplexer only\n"
-			"- r=: only print final report"
-			, NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("seps", NULL, "set the default character sets used to separate various arguments\n"
-		"- the first char is used to separate argument names\n"
-		"- the second char, if present, is used to separate names and values\n"
-		"- the third char, if present, is used to separate fragments for PID sources\n"
-		"- the fourth char, if present, is used for list separators (__sourceIDs__, __gfreg__, ...)\n"
-		"- the fifth char, if present, is used for boolean negation\n"
-		"- the sixth char, if present, is used for LINK directives (see filters help (-h doc)(filters_general))", GF_FS_DEFAULT_SEPS, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
-
-	GF_DEF_ARG("i", "src", "specify an input file - see filters help (-h doc)(filters_general)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("o", "dst", "specify an output file - see filters help (-h doc)(filters_general)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("ib", NULL, "specify an input file to wrap as GF_FileIO object (testing of GF_FileIO)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("ob", NULL, "specify an output file to wrap as GF_FileIO object (testing of GF_FileIO)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("cl", NULL, "force complete mode when no link directive are set - see filters help (-h doc)(filters_general)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("step", NULL, "test step mode in non-blocking session", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("h", "help,-ha,-hx,-hh", "print help. Use `-help` or `-h` for basic options, `-ha` for advanced options, `-hx` for expert options and `-hh` for all. \nNote: The `@` character can be used in place of the `*` character. String parameter can be:\n"
-			"- empty: print command line options help\n"
-			"- doc: print the general filter info\n"
-			"- alias: print the gpac alias syntax\n"
-			"- log: print the log system help\n"
-			"- core: print the supported libgpac core options. Use -ha/-hx/-hh for advanced/expert options\n"
-			"- cfg: print the GPAC configuration help\n"
-			"- prompt: print the GPAC prompt help when running in interactive mode (see -k(GPAC) )\n"
-			"- modules: print available modules\n"
-			"- filters: print name of all available filters\n"
-			"- filters:*: print name of all available filters, including meta filters\n"
-			"- codecs: print the supported builtin codecs\n"
-			"- props: print the supported builtin PID and packet properties\n"
-			"- props PNAME: print the supported builtin PID and packet properties mentioning `PNAME`\n"
-			"- colors: print the builtin color names and their values\n"
-			"- layouts: print the builtin CICP audio channel layout names and their values\n"
-			"- links: print possible connections between each supported filters (use -hx to view src->dst cap bundle detail)\n"
-			"- links FNAME: print sources and sinks for filter `FNAME` (either builtin or JS filter)\n"
-			"- FNAME: print filter `FNAME` info (multiple FNAME can be given)\n"
-			" - For meta-filters, use `FNAME:INST`, e.g. `ffavin:avfoundation`\n"
-			" - Use `*` to print info on all filters (__big output!__), `*:*` to print info on all filters including meta filter instances (__really big output!__)\n"
-			" - By default only basic filter options and description are shown. Use `-ha` to show advanced options capabilities, `-hx` for expert options, `-hh` for all options and filter capabilities including on filters disabled in this build\n"
-			"- FNAME.OPT: print option `OPT` in filter `FNAME`\n"
-			"- OPT: look in filter names and options for `OPT` and suggest possible matches if none found. Use `-hx` to look for keyword in all option descriptions\n"
-		, NULL, NULL, GF_ARG_STRING, 0),
-
- 	GF_DEF_ARG("p", NULL, "use indicated profile for the global GPAC config. If not found, config file is created. If a file path is indicated, this will load profile from that file. Otherwise, this will create a directory of the specified name and store new config there. Reserved name `0` means a new profile, not stored to disk. Appending `:reload` to the profile name will force recreating a new configuration file", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
- 	GF_DEF_ARG("alias", NULL, "assign a new alias or remove an alias. Can be specified several times. See alias usage (-h alias)(#using-aliases)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
- 	GF_DEF_ARG("aliasdoc", NULL, "assign documentation for a given alias (optional). Can be specified several times", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
-
- 	GF_DEF_ARG("uncache", NULL, "revert all items in GPAC cache directory to their original name and server path", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
-	GF_DEF_ARG("js", NULL, "specify javascript file to use as controller of filter session", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
-
-	GF_DEF_ARG("wc", NULL, "write all core options in the config file unless already set", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("we", NULL, "write all file extensions in the config file unless already set (useful to change some default file extensions)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("wf", NULL, "write all filter options in the config file unless already set", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("wfx", NULL, "write all filter options and all meta filter arguments in the config file unless already set (__large config file !__)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("unit-tests", NULL, "enable unit tests of some functions otherwise not covered by gpac test suite", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_HIDE),
-	GF_DEF_ARG("genmd", NULL, "generate markdown doc", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_HIDE),
-	GF_DEF_ARG("xopt", NULL, "unrecognized options and filters declaration following this option are ignored - used to pass arguments to GUI", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	{0}
-};
-
-
-static void gpac_usage(GF_SysArgMode argmode)
-{
-	u32 i=0;
-	if ((argmode != GF_ARGMODE_ADVANCED) && (argmode != GF_ARGMODE_EXPERT) ) {
-		if (gen_doc!=2)
-			gf_sys_format_help(helpout, help_flags, "Usage: gpac options FILTER LINK FILTER ... \n");
-
-		gf_sys_format_help(helpout, help_flags, "gpac is GPAC's command line tool for setting up and running filter chains.\n\n"
-		"__FILTER__: a single filter declaration (e.g., `-i file`, `-o dump`, `inspect`, ...), see %s.\n"
-		"__LINK__: a link instruction (e.g., `@`, `@2`, `@2#StreamType=Visual`, ...), see %s.\n"
-		"__options__: one or more option strings, each starting with a `-` character.\n"
-		" - an option using a single `-` indicates an option of gpac (see %s) or of libgpac (see %s)\n"
-		" - an option using `--` indicates a global filter or meta-filter (e.g. FFMPEG) option, e.g. `--block_size=1000` or `--profile=Baseline` (see %s)\n"
-		" \n"
-		"Filter declaration order may impact the link resolver which will try linking in declaration order. Most of the time for simple graphs, this has no impact. However, for complex graphs with no link declarations, this can lead to different results. \n"
-		"Options do not require any specific order, and may be present anywhere, including between link statements or filter declarations. \n"
-		"Boolean values do not need any value specified. Other types shall be formatted as `opt=val`, except -i(), `-src`, -o(), `-dst` and -h() options.\n\n"
-		"\n"
-		"The session can be interrupted at any time using `ctrl+c`, which can also be used to toggle global reporting.\n"
-		"\n"
-		"The possible options for gpac are:\n\n",
-			(gen_doc==1) ? "gpac -h doc(filters_general#filter-declaration-filter)" : "`gpac -h doc`",
-			(gen_doc==1) ? "gpac -h doc(filters_general#explicit-links-between-filters-link)" : "`gpac -h doc`",
-			(gen_doc==1) ? "gpac -hx(gpac_general#h)" : "`gpac -hx`",
-			(gen_doc==1) ? "gpac -hx core(core_options)" : "`gpac -hx core`",
-			(gen_doc==1) ? "gpac -h doc(core_config#global-filter-options)" : "`gpac -h doc`",
-			(gen_doc==1) ? "gpac -h doc(core_config#global-filter-options)" : "`gpac -h doc`"
-		);
-	}
-
-	while (gpac_argsi.name) {
-		GF_GPACArg *arg = &gpac_argsi;
-		i++;
-
-		if (argmode!=GF_ARGMODE_ALL) {
-			if ((argmode==GF_ARGMODE_EXPERT) && !(arg->flags & GF_ARG_HINT_EXPERT)) continue;
-			if ((argmode==GF_ARGMODE_ADVANCED) && !(arg->flags & GF_ARG_HINT_ADVANCED)) continue;
-			else if ((argmode==GF_ARGMODE_BASE) && (arg->flags & (GF_ARG_HINT_ADVANCED| GF_ARG_HINT_EXPERT)) ) continue;
-		}
-
-		gf_sys_print_arg(helpout, help_flags, arg, "gpac");
-	}
-
-	if (argmode>=GF_ARGMODE_ADVANCED) {
-		gf_sys_format_help(helpout, help_flags, "\n \nThe following libgpac core options allow customizing the filter session:\n \n" );
-		gf_sys_print_core_help(helpout, help_flags, argmode, GF_ARG_SUBSYS_FILTERS);
-	}
-
-	if (argmode==GF_ARGMODE_BASE) {
-		if ( gf_opts_get_key_count("gpac.aliasdoc")) {
-			gf_sys_format_help(helpout, help_flags, "\n");
-			gpac_alias_help(GF_ARGMODE_BASE);
-		}
-
-		gf_sys_format_help(helpout, help_flags, "\ngpac - GPAC command line filter engine - version %s\n%s\n", gf_gpac_version(), gf_gpac_copyright_cite() );
-	}
-}
-
-#ifndef GPAC_DISABLE_DOC
-static const char *gpac_config =
-{
-"# Configuration file\n"
-"GPAC uses a configuration file to modify default options of libgpac and filters. This configuration file is located in `$HOME/.gpac/GPAC.cfg`.\n"
-"Applications in GPAC can also specify a different configuration file through the -p(GPAC) option to indicate a profile. "
-"This allows different configurations for different usages and simplifies command line typing.\n"
-"EX gpac -p=foo \n"
-"This will load configuration from $HOME/.gpac/foo/GPAC.cfg, creating it if needed.\n"
-"The reserved name `0` is used to disable configuration file writing.\n"
-"By default the configuration file only holds a few system specific options and directories. It is possible to serialize "
-"the entire set of options to the configuration file, using -wc(GPAC) -wf(GPAC). This should be avoided as the resulting "
-"configuration file size will be quite large, hence larger memory usage for the applications.\n"
-"The options specified in the configuration file may be overridden by the values in __restrict.cfg__ file located in GPAC share system directory (e.g. /usr/share/gpac), "
-"if present; this allows enforcing system-wide configuration values.\n"
-"Note: The methods describe in this section apply to any application in GPAC transferring their arguments "
-"to libgpac. This is the case for __gpac__, __MP4Box__, __MP4Client/Osmo4__.\n"
-"# Core options\n"
-"The options from libgpac core can also be assigned though the config file from section __core__ using "
-"option name **without initial dash** as key name.\n"
-"EX corethreads=2\n"
-"Setting this in the config file is equivalent to using `-threads=2`.\n"
-"The options specified at prompt overrides the value of the config file.\n"
-"# Filter options in configuration\n"
-"It is possible to alter the default value of a filter option by modifying the configuration file. Filter __foo__ options are stored in section "
-"`filter@foo`, using option name and value as key-value pair. Options specified through the configuration file do not take precedence over "
-"options specified at prompt or through alias.\n"
-"EX filter@rtpininterleave=yes\n"
-"This will force the rtp input filter to always request RTP over RTSP by default.\n"
-"To generate a configuration file with all filters options serialized, use -wf(GPAC).\n"
-"# Global filter options\n"
-"It is possible to specify options global to multiple filters using `--OPTNAME=VAL`. Global options do not override filter options but "
-"take precedence over options loaded from configuration file.\n"
-"This will set option `OPTNAME`, when present, to `VAL` in any loaded filter.\n"
-"EX --buffer=100 -i file vout aout\n"
-"This is equivalent to specifying `vout:buffer=100 aout:buffer=100`.\n"
-"EX --buffer=100 -i file vout aout:buffer=10\n"
-"This is equivalent to specifying `vout:buffer=100 aout:buffer=10`.\n"
-"Warning: This syntax only applies to regular filter options. It cannot be used with builtin shortcuts (gfreg, enc, ...).\n"
-"Meta-filter options can be set in the same way using the syntax `--OPT_NAME=VAL`.\n"
-"EX --profile=Baseline -i file.cmp -o dump.264\n"
-"This is equivalent to specifying `-o dump.264:profile=Baseline`.\n"
-" \n"
-"For both syntax, it is possible to specify the filter registry name of the option, using `--FNAME:OPTNAME=VAL` or `--FNAME@OPTNAME=VAL`.\n"
-"In this case the option will only be set for filters which are instances of registry FNAME. This is used when several registries use same option names.\n"
-"EX --flist@timescale=100 -i plist1 -i plist2 -o live.mpd\n"
-"This will set the timescale option on the playlists filters but not on the dasher filter.\n"
-};
-#endif
-
-static void gpac_config_help()
-{
-
-#ifndef GPAC_DISABLE_DOC
-		gf_sys_format_help(helpout, help_flags, "%s", gf_sys_localized("gpac", "config", gpac_config) );
-#else
-		gf_sys_format_help(helpout, help_flags, "%s", "GPAC compiled without built-in doc.\n");
-#endif
-}
-
-
-static Bool logs_to_file=GF_FALSE;
-
-#define DEF_LOG_ENTRIES	10
-
-struct _logentry
-{
-	u32 tool, level;
-	u32 nb_repeat;
-	u64 clock;
-	char *szMsg;
-} *static_logs;
-static u32 nb_log_entries = DEF_LOG_ENTRIES;
-
-static u32 log_write=0;
-
-static char *log_buf = NULL;
-static u32 log_buf_size=0;
-static void gpac_on_logs(void *cbck, GF_LOG_Level log_level, GF_LOG_Tool log_tool, const char* fmt, va_list vlist)
-{
-	va_list vlist_tmp;
-	va_copy(vlist_tmp, vlist);
-	u32 len = vsnprintf(NULL, 0, fmt, vlist_tmp);
-	va_end(vlist_tmp);
-	if (log_buf_size < len+2) {
-		log_buf_size = len+2;
-		log_buf = gf_realloc(log_buf, log_buf_size);
-	}
-	vsprintf(log_buf, fmt, vlist);
-
-	if (log_write && static_logslog_write-1.szMsg) {
-		if (!strcmp(static_logslog_write-1.szMsg, log_buf)) {
-			static_logslog_write-1.nb_repeat++;
-			return;
-		}
-	}
-
-	static_logslog_write.level = log_level;
-	static_logslog_write.tool = log_tool;
-	if (static_logslog_write.szMsg) gf_free(static_logslog_write.szMsg);
-	static_logslog_write.szMsg = gf_strdup(log_buf);
-	static_logslog_write.clock = gf_net_get_utc();
-
-	log_write++;
-	if (log_write==nb_log_entries) {
-		log_write = nb_log_entries - 1;
-		gf_free(static_logs0.szMsg);
-		memmove(&static_logs0, &static_logs1, sizeof (struct _logentry) * (nb_log_entries-1) );
-		memset(&static_logslog_write, 0, sizeof(struct _logentry));
-	}
-}
-
-static u64 last_report_clock_us = 0;
-static void print_date(u64 time)
-{
-	time_t gtime;
-	struct tm *t;
-	u32 sec;
-	u32 ms;
-	gtime = time / 1000;
-	sec = (u32)(time / 1000);
-	ms = (u32)(time - ((u64)sec) * 1000);
-	t = gf_gmtime(&gtime);
-//	fprintf(stderr, "%d-%02d-%02dT%02d:%02d:%02d.%03dZ", 1900 + t->tm_year, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, ms);
-	fprintf(stderr, "%02d:%02d:%02d.%03dZ ", t->tm_hour, t->tm_min, t->tm_sec, ms);
-}
-
-static Bool in_sig_handler = GF_FALSE;
-static void gpac_print_report(GF_FilterSession *fsess, Bool is_init, Bool is_final)
-{
-	u32 i, count, nb_active;
-	u64 now;
-
-	if (in_sig_handler) return;;
-
-	if (is_init) {
-		if (enable_reports==2)
-			gf_sys_set_console_code(stderr, GF_CONSOLE_SAVE);
-
-		logs_to_file = gf_log_use_file();
-		if (!logs_to_file && (enable_reports==2) ) {
-			if (!nb_log_entries) nb_log_entries = 1;
-			static_logs = gf_malloc(sizeof(struct _logentry) * nb_log_entries);
-			memset(static_logs, 0, sizeof(struct _logentry) * nb_log_entries);
-			gf_log_set_callback(fsess, gpac_on_logs);
-		}
-		last_report_clock_us = gf_sys_clock_high_res();
-		return;
-	}
-
-	now = gf_sys_clock_high_res();
-	if ( (now - last_report_clock_us < 200000) && !is_final)
-		return;
-
-	last_report_clock_us = now;
-	if (!is_final)
-		gf_sys_set_console_code(stderr, GF_CONSOLE_CLEAR);
-
-	gf_sys_get_rti(100, &rti, 0);
-	gf_sys_set_console_code(stderr, GF_CONSOLE_CYAN);
-	print_date(gf_net_get_utc());
-	fprintf(stderr, "GPAC Session Status: ");
-	gf_sys_set_console_code(stderr, GF_CONSOLE_RESET);
-	fprintf(stderr, "mem % 10"LLD_SUF" kb CPU % 2d", rti.gpac_memory/1000, rti.process_cpu_time);
-	fprintf(stderr, "\n");
-
-	gf_fs_lock_filters(fsess, GF_TRUE);
-	nb_active = count = gf_fs_get_filters_count(fsess);
-	for (i=0; i<count; i++) {
-		GF_FilterStats stats;
-		gf_fs_get_filter_stats(fsess, i, &stats);
-		if (stats.done || stats.filter_alias) {
-			nb_active--;
-			continue;
-		}
-		if (report_filter && (!strstr(report_filter, stats.reg_name)))
-			continue;
-
-		gf_sys_set_console_code(stderr, GF_CONSOLE_GREEN);
-		fprintf(stderr, "%s", stats.name ? stats.name : stats.reg_name);
-		gf_sys_set_console_code(stderr, GF_CONSOLE_RESET);
-		if (stats.name && strcmp(stats.name, stats.reg_name))
-			fprintf(stderr, " (%s)", stats.reg_name);
-		fprintf(stderr, ": ");
-
-		if (stats.status) {
-			fprintf(stderr, "%s\n", stats.status);
-		} else {
-			if (stats.stream_type)
-				fprintf(stderr, "%s ", gf_stream_type_name(stats.stream_type));
-			if (stats.codecid)
-			 	fprintf(stderr, "(%s) ", gf_codecid_name(stats.codecid) );
-
-			if ((stats.nb_pid_in == stats.nb_pid_out) && (stats.nb_pid_in==1)) {
-				Double pck_per_sec = (Double) (stats.nb_hw_pck_sent ? stats.nb_hw_pck_sent : stats.nb_pck_sent);
-				pck_per_sec *= 1000000;
-				pck_per_sec /= (stats.time_process+1);
-
-				fprintf(stderr, "% 10"LLD_SUF" pck %02.02f FPS ", (s64) stats.nb_out_pck, pck_per_sec);
-			} else {
-				if (stats.nb_pid_in)
-					fprintf(stderr, "%d input PIDs % 10"LLD_SUF" pck ", stats.nb_pid_in, (s64)stats.nb_in_pck);
-				if (stats.nb_pid_out)
-					fprintf(stderr, "%d output PIDs % 10"LLD_SUF" pck ", stats.nb_pid_out, (s64) stats.nb_out_pck);
-			}
-			if (stats.in_eos)
-				fprintf(stderr, "- EOS");
-			fprintf(stderr, "\n");
-		}
-	}
-	fprintf(stderr, "Active filters: %d\n", nb_active);
-
-	if (static_logs) {
-		if (is_final && (!log_write || !static_logslog_write-1.szMsg))
-			return;
-
-		fprintf(stderr, "\nLogs:\n");
-		for (i=0; i<log_write; i++) {
-			if (static_logsi.level==GF_LOG_ERROR) gf_sys_set_console_code(stderr, GF_CONSOLE_RED);
-			else if (static_logsi.level==GF_LOG_WARNING) gf_sys_set_console_code(stderr, GF_CONSOLE_YELLOW);
-			else if (static_logsi.level==GF_LOG_INFO) gf_sys_set_console_code(stderr, GF_CONSOLE_GREEN);
-			else gf_sys_set_console_code(stderr, GF_CONSOLE_CYAN);
-
-			print_date(static_logsi.clock);
-
-			if (static_logsi.nb_repeat)
-				fprintf(stderr, "repeated %d ", static_logsi.nb_repeat);
-
-			fprintf(stderr, "%s", static_logsi.szMsg);
-			gf_sys_set_console_code(stderr, GF_CONSOLE_RESET);
-		}
-		fprintf(stderr, "\n");
-	}
-	gf_fs_lock_filters(fsess, GF_FALSE);
-	fflush(stderr);
-}
-
-static Bool gpac_event_proc(void *opaque, GF_Event *event)
-{
-	GF_FilterSession *fsess = (GF_FilterSession *)opaque;
-	if (event->type==GF_EVENT_PROGRESS) {
-		if (event->progress.progress_type==3) {
-			gpac_print_report(fsess, GF_FALSE, GF_FALSE);
-		}
-	}
-	else if (event->type==GF_EVENT_QUIT) {
-		gf_fs_abort(fsess, GF_FS_FLUSH_ALL);
-	}
-	return GF_FALSE;
-}
-
-
-typedef enum
-{
-	GPAC_COM_UNDEF = 0,
-	GPAC_QUIT,
-	GPAC_EXIT,
-	GPAC_PRINT_STATS,
-	GPAC_PRINT_GRAPH,
-	GPAC_SEND_UPDATE,
-	GPAC_LIST_FILTERS,
-	GPAC_INSERT_FILTER,
-	GPAC_REMOVE_FILTER,
-	GPAC_PRINT_HELP
-} GPAC_Command;
-
-static struct _gpac_key
-{
-	u8 char_code;
-	GPAC_Command cmd_type;
-	const char *cmd_help;
-	u32 flags;
-} GPAC_Keys = {
-	{'q', GPAC_QUIT, "flush all streams and exit", 0},
-	{'x', GPAC_EXIT, "exit with no flush (may break output files)", 0},
-	{'s', GPAC_PRINT_STATS, "print statistics", 0},
-	{'g', GPAC_PRINT_GRAPH, "print filter graph", 0},
-	{'l', GPAC_LIST_FILTERS, "list filters", 0},
-	{'u', GPAC_SEND_UPDATE, "update argument of filter", 0},
-	{'i', GPAC_INSERT_FILTER, "insert a filter in the chain", 0},
-	{'r', GPAC_REMOVE_FILTER, "remove a filter from the chain", 0},
-	{'h', GPAC_PRINT_HELP, "print this help", 0},
-	{0}
-};
-
-static GPAC_Command get_cmd(u8 char_code)
-{
-	u32 i=0;
-	while (GPAC_Keysi.char_code) {
-		if (GPAC_Keysi.char_code == char_code)
-			return GPAC_Keysi.cmd_type;
-		i++;
-	}
-	return GPAC_COM_UNDEF;
-}
-
-static void gpac_fsess_task_help()
-{
-	gf_sys_format_help(helpout, help_flags, "Available runtime options/keys:\n");
-
-	u32 i=0;
-	while (GPAC_Keysi.char_code) {
-		gf_sys_format_help(helpout, help_flags, "- %c: %s\n", GPAC_Keysi.char_code, GPAC_Keysi.cmd_help);
-		i++;
-	}
-}
-
-static char szFilter100;
-static char szCom2048;
-static u64 run_start_time = 0;
-static Bool gpac_fsess_task(GF_FilterSession *fsess, void *callback, u32 *reschedule_ms)
-{
-	if (enable_prompt && gf_prompt_has_input()) {
-		u32 i, count;
-		GF_Filter *filter;
-		const GF_Filter *link_from=NULL;
-		GF_Err e;
-		char *link_args = NULL;
-		GPAC_Command c = get_cmd(gf_prompt_get_char());
-		switch (c) {
-		case GPAC_QUIT:
-			gf_fs_abort(fsess, GF_FS_FLUSH_ALL);
-			nb_loops = 0;
-			return GF_FALSE;
-		case GPAC_EXIT:
-			gf_fs_abort(fsess, GF_FS_FLUSH_NONE);
-			nb_loops = 0;
-			return GF_FALSE;
-		case GPAC_PRINT_STATS:
-			gf_fs_print_stats(fsess);
-			break;
-		case GPAC_PRINT_GRAPH:
-			gf_fs_print_connections(fsess);
-			break;
-		case GPAC_PRINT_HELP:
-			gpac_fsess_task_help();
-			break;
-		case GPAC_SEND_UPDATE:
-			fprintf(stderr, "Sending filter update - enter the target filter ID, name, registry name or #N with N the 0-based index in loaded filter list:\n");
-
-			if (1 > scanf("%99s", szFilter)) {
-				fprintf(stderr, "Cannot read the filter ID, aborting.\n");
-				break;
-			}
-			e = GF_OK;
-			if (szFilter0=='#') {
-				GF_FilterStats stats;
-				u32 idx = atoi(szFilter+1);
-				gf_fs_lock_filters(fsess, GF_TRUE);
-				e = gf_fs_get_filter_stats(fsess, idx, &stats);
-				gf_fs_lock_filters(fsess, GF_FALSE);
-				if (e==GF_OK)
-					strncpy(szFilter, stats.filter_id ? stats.filter_id : stats.name, 99);
-			}
-			if (e) {
-				fprintf(stderr, "Cannot get filter for ID %s, aborting.\n", szFilter);
-				break;
-			}
-			fprintf(stderr, "Enter the command to send\n");
-			if (1 > scanf("%2047s", szCom)) {
-				fprintf(stderr, "Cannot read the command, aborting.\n");
-				break;
-			}
-			gf_fs_send_update(fsess, szFilter, NULL, szCom, NULL, 0);
-			break;
-		case GPAC_LIST_FILTERS:
-			gf_fs_lock_filters(fsess, GF_TRUE);
-			count = gf_fs_get_filters_count(fsess);
-			fprintf(stderr, "Loaded filters:\n");
-			for (i=0; i<count; i++) {
-				GF_FilterStats stats;
-				gf_fs_get_filter_stats(fsess, i, &stats);
-				if (stats.filter_id)
-					fprintf(stderr, "%s (%s) ID %s\n", stats.name, stats.reg_name, stats.filter_id);
-				else
-					fprintf(stderr, "%s (%s)\n", stats.name, stats.reg_name);
-			}
-			gf_fs_lock_filters(fsess, GF_FALSE);
-			break;
-		case GPAC_INSERT_FILTER:
-		case GPAC_REMOVE_FILTER:
-			fprintf(stderr, "%s filter ID, name, registry name or #N with N the 0-based index in loaded filter list:\n",
-					(c==GPAC_INSERT_FILTER) ? "Inserting filter - enter the source" : "Removing filter - enter the");
-
-			if (1 > scanf("%99s", szFilter)) {
-				fprintf(stderr, "Cannot read the filter ID or index, aborting.\n");
-				break;
-			}
-			link_args = strchr(szFilter, separator_setSEP_LINK);
-			if (link_args) {
-				link_args0 = 0;
-				link_args++;
-			}
-			if (szFilter0=='#') {
-				GF_FilterStats stats;
-				u32 idx = atoi(szFilter+1);
-				gf_fs_lock_filters(fsess, GF_TRUE);
-				gf_fs_get_filter_stats(fsess, idx, &stats);
-				gf_fs_lock_filters(fsess, GF_FALSE);
-				link_from = stats.filter;
-			} else {
-				const GF_Filter *link_from_by_reg=NULL;
-				gf_fs_lock_filters(fsess, GF_TRUE);
-				count = gf_fs_get_filters_count(fsess);
-				for (i=0; i<count; i++) {
-					GF_FilterStats stats;
-					gf_fs_get_filter_stats(fsess, i, &stats);
-					if (!strcmp(stats.name, szFilter)) {
-						link_from = stats.filter;
-						break;
-					}
-					if (!link_from_by_reg && !strcmp(stats.reg_name, szFilter)) {
-						link_from_by_reg = stats.filter;
-					}
-				}
-				gf_fs_lock_filters(fsess, GF_FALSE);
-				if (!link_from)
-					link_from = link_from_by_reg;
-			}
-			if (!link_from) {
-				fprintf(stderr, "Failed to get filter %s, not found\n", szFilter);
-				break;
-			}
-
-			if (c==GPAC_REMOVE_FILTER) {
-				gf_filter_remove((GF_Filter *) link_from);
-				break;
-			}
-
-			fprintf(stderr, "Enter the filter to insert\n");
-			if (1 > scanf("%2047s", szCom)) {
-				fprintf(stderr, "Cannot read the filter to insert, aborting.\n");
-				break;
-			}
-
-			if (!strncmp(szCom, "src=", 4)) {
-				filter = gf_fs_load_source(fsess, szCom+4, NULL, NULL, &e);
-			} else if (!strncmp(szCom, "dst=", 4)) {
-				filter = gf_fs_load_destination(fsess, szCom+4, NULL, NULL, &e);
-			} else {
-				filter = gf_fs_load_filter(fsess, szCom, &e);
-			}
-
-			if (!filter) {
-				fprintf(stderr, "Cannot load filter %s: %s\n", szCom, gf_error_to_string(e));
-				break;
-			}
-			gf_filter_set_source(filter, (GF_Filter *) link_from, link_args);
-			//reconnect outputs of source
-			gf_filter_reconnect_output((GF_Filter *) link_from);
-			break;
-		default:
-			break;
-		}
-	}
-	if (runfor>0) {
-		u64 now = gf_sys_clock_high_res();
-		if (!run_start_time) {
-			run_start_time = now;
-		} else if (now - run_start_time > runfor) {
-			//segfault requested
-			if (exit_mode==1) {
-				exit(127);
-			}
-			//deadlock requested
-			else if (exit_mode==2) {
-				while(1) {
-					gf_sleep(1);
-				}
-			}
-			if (nb_loops || loops_done) {
-				gf_fs_abort(fsess, runfor_exit ? GF_FS_FLUSH_NONE : GF_FS_FLUSH_ALL);
-				run_start_time = 0;
-			} else {
-				if (runfor_exit)
-					exit(0);
-				gf_fs_abort(fsess, GF_FS_FLUSH_ALL);
-			}
-			return GF_FALSE;
-		}
-	}
-
-	if (gf_fs_is_last_task(fsess))
-		return GF_FALSE;
-	//check every 50 ms
-	*reschedule_ms = 50;
-	return GF_TRUE;
-}
-
-static Bool prev_was_cmd=GF_FALSE;
-static Bool signal_catched=GF_FALSE;
-static Bool signal_processed=GF_FALSE;
-#ifdef WIN32
-#include <windows.h>
-static BOOL WINAPI gpac_sig_handler(DWORD sig)
-{
-	if (sig == CTRL_C_EVENT) {
-		Bool is_inter = GF_TRUE;
-#else
-#include <signal.h>
-static void gpac_sig_handler(int sig)
-{
-	if ((sig == SIGINT) || (sig == SIGTERM) || (sig == SIGABRT)) {
-		Bool is_inter = (sig == SIGINT) ? GF_TRUE : GF_FALSE;
-#endif
-		nb_loops = 0;
-		if (session) {
-			char input=0;
-			int res;
-			if (signal_catched) {
-				if (signal_processed) {
-					fprintf(stderr, "catched SIGINT|SIGTERM twice and session not responding, forcing exit.\n");
-				}
-				exit(1);
-			}
-
-			signal_catched = GF_TRUE;
-			if (is_inter) {
-				in_sig_handler = GF_TRUE;
-				fprintf(stderr, "\nToggle reports (r) or flush session before exit (Y/f/n) ? \n");
-rescan:
-				res = scanf("%c", &input);
-				if (res!=1) input=0;
-				switch (input) {
-				case 'Y':
-				case 'y':
-					signal_processed = GF_TRUE;
-					gf_fs_abort(session, GF_FS_FLUSH_FAST);
-					break;
-				case 'F':
-				case 'f':
-					signal_processed = GF_TRUE;
-					gf_fs_abort(session, GF_FS_FLUSH_ALL);
-					break;
-				case 0:
-					break;
-				case '\n':
-					//prev was a command, flush \n
-					if (prev_was_cmd) {
-						prev_was_cmd = GF_FALSE;
-						goto rescan;
-					}
-					break;
-
-				case 'R':
-				case 'r':
-					prev_was_cmd = GF_TRUE;
-					if (!enable_reports) {
-						enable_reports = 2;
-						report_filter = NULL;
-						gf_fs_set_ui_callback(session, gpac_event_proc, session);
-						gf_fs_enable_reporting(session, GF_TRUE);
-						in_sig_handler = GF_FALSE;
-						gpac_print_report(session, GF_TRUE, GF_FALSE);
-					} else {
-						enable_reports = 0;
-						gf_fs_enable_reporting(session, GF_FALSE);
-						gf_sys_set_console_code(stderr, GF_CONSOLE_CLEAR);
-						gf_sys_set_console_code(stderr, GF_CONSOLE_RESTORE);
-					}
-					signal_catched = GF_FALSE;
-					signal_processed = GF_FALSE;
-					break;
-				default:
-					signal_processed = GF_TRUE;
-					gf_fs_abort(session, GF_FS_FLUSH_NONE);
-					break;
-				}
-				in_sig_handler = GF_FALSE;
-			} else {
-				signal_processed = GF_TRUE;
-				gf_fs_abort(session, GF_FS_FLUSH_NONE);
-			}
-		}
-	}
-#ifdef WIN32
-	return TRUE;
-#endif
-}
-
-static void parse_sep_set(const char *arg, Bool *override_seps)
-{
-	if (!arg) return;
-	u32 len = (u32) strlen(arg);
-	if (!len) return;
-	*override_seps = GF_TRUE;
-	if (len>=1) separator_set0 = arg0;
-	if (len>=2) separator_set1 = arg1;
-	if (len>=3) separator_set2 = arg2;
-	if (len>=4) separator_set3 = arg3;
-	if (len>=5) separator_set4 = arg4;
-	if (len>=6) separator_set5 = arg5;
-}
-
-
-static int gpac_exit_fun(int code, char **alias_argv, int alias_argc)
-{
-	u32 i;
-	if (code>=0) {
-		for (i=1; i<gf_sys_get_argc(); i++) {
-			if (!gf_sys_is_arg_used(i)) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Warning: argument %s set but not used\n", gf_sys_get_arg(i) ));
-			}
-		}
-	} else {
-		//negative code is unrecognized option, don't print unused arguments
-		code = 1;
-	}
-
-	if (alias_argv) {
-		while (gf_list_count(args_alloc)) {
-			gf_free(gf_list_pop_back(args_alloc));
-		}
-		gf_list_del(args_alloc);
-		gf_list_del(args_used);
-		gf_free(alias_argv);
-	}
-	if (log_buf) gf_free(log_buf);
-	if ((helpout != stdout) && (helpout != stderr)) {
-		if (gen_doc==2) {
-			fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/Filters\n");
-			fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
-			".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
-			".br\nbuild: %s\n"
-			".br\nCopyright: %s\n.br\n"
-			".SH SEE ALSO\n"
-			".LP\ngpac(1), MP4Client(1), MP4Box(1)\n", gf_gpac_version(), gf_gpac_copyright());
-		}
-		gf_fclose(helpout);
-	}
-
-	if (sidebar_md)
-		gf_fclose(sidebar_md);
-
-	if (static_logs) {
-		for (i=0; i<nb_log_entries; i++) {
-			if (static_logsi.szMsg)
-				gf_free(static_logsi.szMsg);
-		}
-		gf_free(static_logs);
-	}
-	gf_sys_close();
-	if (code) return code;
-
-#ifdef GPAC_MEMORY_TRACKING
-	if (gf_memory_size() || gf_file_handles_count() ) {
-		gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
-		gf_memory_print();
-		return 2;
-	}
-#endif
-	return 0;
-}
-
-#define gpac_exit(_code) return gpac_exit_fun(_code, alias_argv, alias_argc)
-
-#include <gpac/network.h>
-static void gpac_load_suggested_filter_args()
-{
-	u32 i, count, k;
-	GF_Config *opts = NULL;
-	GF_FilterSession *fsess;
-	const char *version, *cfg_path;
-	char *all_opts;
-
-	if (gf_opts_get_bool("core", "no-argchk"))
-		return;
-
-	cfg_path = gf_opts_get_filename();
-	all_opts = gf_url_concatenate(cfg_path, "all_opts.txt");
-
-	opts = gf_cfg_force_new("probe", all_opts);
-	gf_free(all_opts);
-
-	version = gf_cfg_get_key(opts, "version", "version");
-	if (version && !strcmp(version, gf_gpac_version()) ) {
-		gf_cfg_del(opts);
-		return;
-	}
-	gf_cfg_del_section(opts, "allopts");
-	gf_cfg_set_key(opts, "version", "version", gf_gpac_version());
-
-	gf_sys_format_help(stderr, 0, "__Refreshing all options registry, this may take some time ... ");
-
-	fsess = gf_fs_new(0, GF_FS_SCHEDULER_LOCK_FREE, GF_FS_FLAG_LOAD_META, NULL);
-	if (!fsess) {
-		gf_sys_format_help(stderr, 0, "\nWarning: Error creating session\n");
-		gf_cfg_del(opts);
-		return;
-	}
-
-	count = gf_fs_filters_registers_count(fsess);
-	for (i=0; i<count; i++) {
-		const GF_FilterRegister *freg = gf_fs_get_filter_register(fsess, i);
-
-		k=0;
-		while (freg->args) {
-			const char *old_val;
-			char *argn=NULL;
-			const GF_FilterArgs *arg = &freg->argsk;
-			if (!arg || !arg->arg_name) {
-				break;
-			}
-			k++;
-			if (arg->flags & GF_FS_ARG_HINT_HIDE) continue;
-
-			if (arg->flags & GF_FS_ARG_META) {
-				gf_dynstrcat(&argn, "-+", NULL);
-			} else {
-				gf_dynstrcat(&argn, "--", NULL);
-			}
-			gf_dynstrcat(&argn, arg->arg_name, NULL);
-			if ((arg->arg_type==GF_PROP_UINT) && arg->min_max_enum && strchr(arg->min_max_enum, '|')) {
-				gf_dynstrcat(&argn, arg->min_max_enum, "@");
-			}
-
-			old_val = gf_cfg_get_key(opts, "allopts", argn);
-			if (old_val) {
-				char *newval = gf_strdup(freg->name);
-				gf_dynstrcat(&newval, old_val, " ");
-				gf_cfg_set_key(opts, "allopts", argn, newval);
-				gf_free(newval);
-			} else {
-				gf_cfg_set_key(opts, "allopts", argn, freg->name);
-			}
-			gf_free(argn);
-		}
-	}
-	gf_fs_del(fsess);
-	gf_cfg_del(opts);
-	gf_sys_format_help(stderr, 0, "done\n");
-}
-
-
-static void gpac_suggest_arg(char *aname)
-{
-	u32 k;
-	const GF_GPACArg *args;
-	if (!aname) return;
-	Bool found=GF_FALSE;
-	for (k=0; k<2; k++) {
-		u32 i=0;
-		if (k==0) args = gpac_args;
-		else args = gf_sys_get_options();
-
-		while (argsi.name) {
-			const GF_GPACArg *arg = &argsi;
-			i++;
-			if (gf_sys_word_match(aname, arg->name)) {
-				if (!found) {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unrecognized option \"%s\", did you mean:\n", aname));
-					found = GF_TRUE;
-				}
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("\t-%s (see gpac -hx%s)\n", arg->name, k ? " core" : ""));
-			}
-		}
-	}
-	//look in alias
-	u32 nb_alias = gf_opts_get_key_count("gpac.alias");
-	for (k=0; k<nb_alias; k++) {
-		const char *key = gf_opts_get_key_name("gpac.alias", k);
-		if (gf_sys_word_match(aname, key)) {
-			if (!found) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unrecognized option \"%s\", did you mean:\n", aname));
-				found = GF_TRUE;
-			}
-			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("\t%s (see gpac -h)\n", key));
-		}
-	}
-
-	if (!found) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unrecognized option \"%s\", check usage \"gpac -h\"\n", aname));
-	}
-}
-
-static void gpac_suggest_filter(char *fname, Bool is_help, Bool filter_only)
-{
-	Bool found = GF_FALSE;
-	Bool first = GF_FALSE;
-	u32 i, count, pass_exact = GF_TRUE;
-	if (!fname) return;
-
-	if (filter_only || !is_help) pass_exact = GF_FALSE;
-
-redo_pass:
-
-	count = gf_fs_filters_registers_count(session);
-	if (!pass_exact) {
-		for (i=0; i<count; i++) {
-			const GF_FilterRegister *freg = gf_fs_get_filter_register(session, i);
-
-			if (gf_sys_word_match(fname, freg->name)) {
-				if (!first) {
-					first = GF_TRUE;
-					if (!found) {
-						GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
-						found = GF_TRUE;
-					}
-					GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest filter names: \n"));
-				}
-				GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("- %s\n", freg->name));
-			}
-		}
-	}
-
-	if (is_help) {
-		if (!pass_exact) {
-			const char *doc_helps = {
-				"log", "core", "modules", "doc", "alias", "props", "colors", "layouts", "cfg", "prompt", "codecs", "links", "bin", "filters", "filters:*", "filters:@", NULL
-			};
-			first = GF_FALSE;
-			i=0;
-			while (doc_helpsi) {
-				if (gf_sys_word_match(fname, doc_helpsi)) {
-					if (!first) {
-						first = GF_TRUE;
-						if (!found) {
-							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
-							found = GF_TRUE;
-						}
-						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest help commands: \n"));
-					}
-					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("-h %s\n", doc_helpsi));
-				}
-				i++;
-			}
-		}
-
-		if (!filter_only) {
-			u32 nb_alias = gf_opts_get_key_count("gpac.alias");
-			first = GF_FALSE;
-			for (i=0; i<nb_alias; i++) {
-				const char *alias = gf_opts_get_key_name("gpac.alias", i);
-
-				if (pass_exact) {
-					if (!strcmp(fname, alias+1)) {
-						const char *doc = gf_opts_get_key("gpac.aliasdoc", alias);
-						if (!doc) doc = "Not documented";
-						GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s: %s\n", alias, doc));
-						found = GF_TRUE;
-					}
-				}
-				else if (gf_sys_word_match(fname, alias)) {
-					if (!first) {
-						first = GF_TRUE;
-						if (!found) {
-							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
-							found = GF_TRUE;
-						}
-						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest alias: \n"));
-					}
-					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s\n", alias));
-				}
-			}
-			//check in libgpac core opts
-			first = GF_FALSE;
-			i=0;
-			const GF_GPACArg *core_opts = gf_sys_get_options();
-			while (core_opts && core_optsi.name) {
-				const GF_GPACArg *arg = &core_optsi;
-				i++;
-
-				if (gf_sys_word_match(fname, arg->name)) {
-					if (!first) {
-						first = GF_TRUE;
-						if (!found) {
-							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
-							found = GF_TRUE;
-						}
-						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest core option: \n"));
-					}
-					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("-%s: %s\n", arg->name, arg->description));
-				}
-			}
-
-			//check filters
-			first = GF_FALSE;
-			for (i=0; i<count; i++) {
-				u32 j=0;
-				const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
-
-				while (reg->args) {
-					const GF_FilterArgs *arg = &reg->argsj;
-					if (!arg || !arg->arg_name) break;
-					j++;
-
-					if (pass_exact) {
-						if (!strcmp(fname, arg->arg_name)) {
-							gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s %s\n", reg->name, arg->arg_name, arg->arg_desc);
-							found = GF_TRUE;
-						}
-						continue;
-					}
-					if (!gf_sys_word_match(fname, arg->arg_name)) continue;
-
-					if (!first) {
-						first = GF_TRUE;
-						if (!found) {
-							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
-							found = GF_TRUE;
-						}
-						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest matching filter options:\n", fname));
-					}
-					gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s \n", reg->name, arg->arg_name);
-				}
-			}
-		}
-	}
-	if (!found) {
-		if (pass_exact) {
-			pass_exact = GF_FALSE;
-			goto redo_pass;
-		}
-
-		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No filter%swith similar name found, see gpac -h filters%s\n",
-			is_help ? ", option or help command " : " ",
-			is_help ? ", gpac -h or search all help using gpac -hx" : ""
-		));
-	}
-}
-
-static void gpac_suggest_filter_arg(GF_Config *opts, char *argname, u32 atype)
-{
-	char *keyname;
-	const char *keyval;
-	u32 i, count, len, nb_filters, j;
-	Bool f_found = GF_FALSE;
-	char szSep2;
-
-	if (gf_opts_get_bool("core", "no-argchk"))
-		return;
-
-	szSep0 = separator_set0;
-	szSep1 = 0;
-
-	len = (u32) strlen(argname);
-	keyname = gf_malloc(sizeof(char)*(len+3));
-	sprintf(keyname, "-%c%s", (atype==2) ? '+' : '-', argname);
-	keyval = gf_cfg_get_key(opts, "allopts", keyname);
-	gf_free(keyname);
-	if (keyval) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Argument \"%s%s\" was set but not used by any filter\n",
-		(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
-		return;
-	}
-
-	nb_filters = gf_fs_get_filters_count(session);
-	count = gf_cfg_get_key_count(opts, "allopts");
-	for (i=0; i<count; i++) {
-		Bool ffound = GF_FALSE;
-		char *enum_vals=NULL;
-		const char *arg = gf_cfg_get_key_name(opts, "allopts", i);
-		const char *aval = gf_cfg_get_key(opts, "allopts", arg);
-		if ((arg1=='+') && (atype!=2)) continue;
-		if ((arg1=='-') && (atype==2)) continue;
-
-		arg += 2;
-		char *sep = strchr(arg, '@');
-		if (sep) {
-			sep0 = 0;
-			enum_vals = strstr(sep+1, argname);
-			if (enum_vals) {
-				if (!f_found) {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unknown argument \"%s%s\" set but not used by any filter - possible matches\n",
-						(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
-					f_found = GF_TRUE;
-				}
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("- %s (%s) in filters %s\n", arg, sep+1, aval));
-				sep0 = '@';
-				continue;
-			}
-		}
-		u32 alen = (u32) strlen(arg);
-		if (alen>2*len) {
-			if (sep) sep0 = '@';
-			continue;
-		}
-
-		for (j=0; j<nb_filters; j++) {
-			GF_FilterStats stats;
-			stats.reg_name = NULL;
-			gf_fs_get_filter_stats(session, j, &stats);
-
-			if (stats.reg_name && strstr(aval, stats.reg_name)) {
-				ffound = GF_TRUE;
-				break;
-			}
-		}
-		if (!ffound) {
-			if (sep) sep0 = '@';
-			continue;
-		}
-		if (gf_sys_word_match(argname, arg)) {
-			if (!f_found) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unknown argument \"%s%s\" set but not used by any filter - possible matches\n",
-					(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
-				f_found = GF_TRUE;
-			}
-			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("- %s in filters %s\n", arg, aval));
-		}
-		if (sep) sep0 = '@';
-	}
-	if (!f_found) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unknown argument \"%s%s\" set but not used by any filter - no matching argument found\n",
-			(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
-	}
-}
-
-static void gpac_check_session_args()
-{
-	GF_Config *opts = NULL;
-	u32 idx = 0;
-	char *argname;
-	u32 argtype;
-
-	while (1) {
-		if (gf_fs_enum_unmapped_options(session, &idx, &argname, &argtype)==GF_FALSE)
-			break;
-
-		if (!opts) {
-			const char *cfg_path = gf_opts_get_filename();
-			char *all_opts = gf_url_concatenate(cfg_path, "all_opts.txt");
-			opts = gf_cfg_new(NULL, all_opts);
-			gf_free(all_opts);
-		}
-		if (!opts) {
-			break;
-		}
-		gpac_suggest_filter_arg(opts, argname, argtype);
-	}
-	if (opts) gf_cfg_del(opts);
-}
-
-static int gpac_main(int argc, char **argv)
-{
-	GF_Err e=GF_OK;
-	int i;
-	const char *profile=NULL;
-	const char *session_js=NULL;
-	u32 sflags=0;
-	Bool override_seps=GF_FALSE;
-	Bool write_profile=GF_FALSE;
-	Bool write_core_opts=GF_FALSE;
-	Bool write_extensions=GF_FALSE;
-	GF_List *links_directive=NULL;
-	GF_List *loaded_filters=NULL;
-	GF_SysArgMode argmode = GF_ARGMODE_BASE;
-	u32 nb_filters = 0;
-	Bool nothing_to_do = GF_TRUE;
-	GF_MemTrackerType mem_track=GF_MemTrackerNone;
-	char *view_conn_for_filter = NULL;
-	Bool view_filter_conn = GF_FALSE;
-	Bool dump_codecs = GF_FALSE;
-	Bool has_alias = GF_FALSE;
-	Bool alias_set = GF_FALSE;
-	GF_FilterSession *tmp_sess;
-	Bool alias_is_play = GF_FALSE;
-	Bool prev_filter_is_sink;
-	Bool prev_filter_is_not_source;
-	u32 current_subsession_id;
-	u32 current_source_id;
-	Bool has_xopt = GF_FALSE;
-
-	helpout = stdout;
-
-	//look for mem track and profile, and check for link directives
-	for (i=1; i<argc; i++) {
-		char *arg = argvi;
-		if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
-#ifdef GPAC_MEMORY_TRACKING
- mem_track = !strcmp(arg, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
-#else
-			fprintf(stderr, "WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", arg);
-#endif
-		} else if (!strncmp(arg, "-p=", 3)) {
-			profile = arg+3;
-		} else if (!strncmp(arg, "-mkl=", 5)) {
-			return gpac_make_lang(arg+5);
-		}
-	}
-
-	gf_sys_init(mem_track, profile);
-
-//	gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_WARNING);
-	gf_log_set_tool_level(GF_LOG_APP, GF_LOG_INFO);
-
-	if (gf_opts_get_key_count("gpac.alias")) {
-		for (i=1; i<argc; i++) {
-			char *arg = argvi;
-			if (gf_opts_get_key("gpac.alias", arg) != NULL) {
-				has_alias = GF_TRUE;
-				if (!strcmp(arg, "-play"))
-					alias_is_play = GF_TRUE;
-				break;
-			}
-		}
-		if (has_alias) {
-			if (! gpac_expand_alias(argc, argv) ) {
-				gpac_exit(1);
-			}
-			argc = alias_argc;
-			argv = alias_argv;
-		}
-	}
-
-
-	//this will parse default args
-	e = gf_sys_set_args(argc, (const char **) argv);
-	if (e) {
-		fprintf(stderr, "Error assigning libgpac arguments: %s\n", gf_error_to_string(e) );
-		gpac_exit(1);
-	}
-
-	if (!profile || strcmp(profile, "0") )
-		gpac_load_suggested_filter_args();
-
-#ifndef GPAC_DISABLE_LOG
-	if (gf_log_tool_level_on(GF_LOG_APP, GF_LOG_DEBUG)) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_APP, ("GPAC args: "));
-		for (i=1; i<argc; i++) {
-			char *arg = argvi;
-			GF_LOG(GF_LOG_DEBUG, GF_LOG_APP, ("%s ", arg));
-		}
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_APP, ("\n"));
-	}
-#endif
-
-	for (i=1; i<argc; i++) {
-		char *arg = argvi;
-		char *arg_val = strchr(arg, '=');
-		if (arg_val) {
-			arg_val0=0;
-			arg_val++;
-		}
-
-		gf_sys_mark_arg_used(i, GF_TRUE);
-
-		if ((!has_xopt && !strcmp(arg, "-h")) || !strcmp(arg, "-help") || !strcmp(arg, "-ha") || !strcmp(arg, "-hx") || !strcmp(arg, "-hh")) {
-			if (!strcmp(arg, "-ha")) argmode = GF_ARGMODE_ADVANCED;
-			else if (!strcmp(arg, "-hx")) argmode = GF_ARGMODE_EXPERT;
-			else if (!strcmp(arg, "-hh")) argmode = GF_ARGMODE_ALL;
-
-			gf_opts_set_key("temp", "gpac-help", arg+1);
-
-			if (i+1<argc)
-				gf_sys_mark_arg_used(i+1, GF_TRUE);
-
-			if ((i+1==argc) || (argvi+10=='-')) {
-				gpac_usage(argmode);
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "log")) {
-				gpac_core_help(GF_ARGMODE_ALL, GF_TRUE);
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "core")) {
-				gpac_core_help(argmode, GF_FALSE);
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "modules")) {
-				gpac_modules_help();
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "doc")) {
-				gpac_filter_help();
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "alias")) {
-				gpac_alias_help(argmode);
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "props")) {
-				if (i+2<argc) {
-					gf_sys_mark_arg_used(i+2, GF_TRUE);
-					dump_all_props(argvi+2);
-				} else {
-					dump_all_props(NULL);
-				}
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "colors")) {
-				dump_all_colors();
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "layouts")) {
-				dump_all_audio_cicp();
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "cfg")) {
-				gpac_config_help();
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "prompt")) {
-				gpac_fsess_task_help();
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "codecs")) {
-				dump_codecs = GF_TRUE;
-				sflags |= GF_FS_FLAG_LOAD_META | GF_FS_FLAG_NO_GRAPH_CACHE;
-				i++;
-			} else if (!strcmp(argvi+1, "links")) {
-				view_filter_conn = GF_TRUE;
-				if ((i+2<argc)	&& (argvi+20 != '-')) {
-					view_conn_for_filter = argvi+2;
-					gf_sys_mark_arg_used(i+2, GF_TRUE);
-					i++;
-				}
-
-				i++;
-			} else if (!strcmp(argvi+1, "bin")) {
-				gf_sys_format_help(helpout, help_flags, "GPAC binary information:\n"
-					"Version: %s\n"
-					"Compilation configuration: " GPAC_CONFIGURATION "\n"
-					"Enabled features: %s\n"
-	 		"Disabled features: %s\n", gf_gpac_version(), gf_sys_features(GF_FALSE), gf_sys_features(GF_TRUE)
-				);
-				gpac_exit(0);
-			} else if (!strcmp(argvi+1, "filters")) {
-				list_filters = 1;
-				sflags |= GF_FS_FLAG_NO_GRAPH_CACHE;
-				i++;
-			} else if (!strcmp(argvi+1, "filters:*") || !strcmp(argvi+1, "filters:@")) {
-				list_filters = 2;
-				sflags |= GF_FS_FLAG_NO_GRAPH_CACHE;
-				i++;
-			} else {
-				print_filter_info = 1;
-				if (!strcmp(argvi+1, "*:*") || !strcmp(argvi+1, "@:@"))
-					print_filter_info = 2;
-				sflags |= GF_FS_FLAG_NO_GRAPH_CACHE;
-			}
-		}
-		else if (has_xopt && !strcmp(arg, "-h")) {
-			gf_opts_set_key("temp", "gpac-help", "yes");
-		}
-		else if (!strcmp(arg, "-genmd") || !strcmp(arg, "-genman")) {
-			argmode = GF_ARGMODE_ALL;
-			if (!strcmp(arg, "-genmd")) {
-				gf_opts_set_key("temp", "gendoc", "yes");
-				gen_doc = 1;
-				help_flags = GF_PRINTARG_MD;
-				helpout = gf_fopen("gpac_general.md", "w");
-				fprintf(helpout, "**HOME**(Home) » **Filters**(Filters) » Usage\n");
-				fprintf(helpout, "%s", auto_gen_md_warning);
-				fprintf(helpout, "# General Usage of gpac\n");
-			} else {
-				gf_opts_set_key("temp", "gendoc", "yes");
-				gen_doc = 2;
-				help_flags = GF_PRINTARG_MAN;
-				helpout = gf_fopen("gpac.1", "w");
-	 			fprintf(helpout, ".TH gpac 1 2019 gpac GPAC\n");
-				fprintf(helpout, ".\n.SH NAME\n.LP\ngpac \\- GPAC command-line filter session manager\n"
-				".SH SYNOPSIS\n.LP\n.B gpac\n"
-				".RI options FILTER LINK FILTER ...\n.br\n.\n");
-			}
-			gpac_usage(GF_ARGMODE_ALL);
-
-			if (gen_doc==1) {
-				fprintf(helpout, "# Using Aliases\n");
-			} else {
-				fprintf(helpout, ".SH Using Aliases\n.PL\n");
-			}
-			gpac_alias_help(GF_ARGMODE_EXPERT);
-
-			if (gen_doc==1) {
-				gf_fclose(helpout);
-				helpout = gf_fopen("core_config.md", "w");
-				fprintf(helpout, "**HOME**(Home) » **Filters**(Filters) » Configuration\n");
-				fprintf(helpout, "%s", auto_gen_md_warning);
-			}
-			gpac_config_help();
-
-			if (gen_doc==1) {
-				gf_fclose(helpout);
-				helpout = gf_fopen("core_options.md", "w");
-				fprintf(helpout, "**HOME**(Home) » **Filters**(Filters) » Core Options\n");
-				fprintf(helpout, "%s", auto_gen_md_warning);
-				fprintf(helpout, "# GPAC Core Options\n");
-			}
-			gpac_core_help(argmode, GF_FALSE);
-
-			if (gen_doc==1) {
-				gf_fclose(helpout);
-				helpout = gf_fopen("core_logs.md", "w");
-				fprintf(helpout, "**HOME**(Home) » **Filters**(Filters) » Logging System\n");
-				fprintf(helpout, "%s", auto_gen_md_warning);
-				fprintf(helpout, "# GPAC Log System\n");
-			}
-			gpac_core_help(argmode, GF_TRUE);
-
-			if (gen_doc==1) {
-				gf_fclose(helpout);
-				helpout = gf_fopen("filters_general.md", "w");
-				fprintf(helpout, "**HOME**(Home) » **Filters**(Filters) » General Concepts\n");
-				fprintf(helpout, "%s", auto_gen_md_warning);
-			}
-			gf_sys_format_help(helpout, help_flags, "%s", gpac_doc);
-
-			if (gen_doc==1) {
-				gf_fclose(helpout);
-				helpout = gf_fopen("filters_properties.md", "w");
-				fprintf(helpout, "**HOME**(Home) » **Filters**(Filters) » Built-in Properties\n");
-				fprintf(helpout, "%s", auto_gen_md_warning);
-			}
-			gf_sys_format_help(helpout, help_flags, "# GPAC Built-in properties\n");
-			dump_all_props(NULL);
-//			dump_codecs = GF_TRUE;
-
-			if (gen_doc==2) {
-				fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/Filters\n");
-				fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
-				".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
-				".br\nbuild: %s\n"
-				".br\nCopyright: %s\n.br\n"
-				".SH SEE ALSO\n"
-				".LP\ngpac-filters(1), MP4Client(1), MP4Box(1)\n", gf_gpac_version(), gf_gpac_copyright());
-				gf_fclose(helpout);
-
-				helpout = gf_fopen("gpac-filters.1", "w");
-	 			fprintf(helpout, ".TH gpac 1 2019 gpac GPAC\n");
-				fprintf(helpout, ".\n.SH NAME\n.LP\ngpac \\- GPAC command-line filter session manager\n"
-				".SH SYNOPSIS\n.LP\n.B gpac\n"
-				".RI options FILTER LINK FILTER ...\n.br\n.\n"
-				".SH DESCRIPTION\n.LP"
-				"\nThis page describes all filters usually present in GPAC\n"
-				"\nTo check for help on a filter not listed here, use gpac -h myfilter\n"
-				"\n"
-				);
-			}
-
-			list_filters = 1;
-		}
-		else if (!strcmp(arg, "-ltf")) {
-			load_test_filters = GF_TRUE;
-		} else if (!strncmp(arg, "-lcf", 4)) {
-		} else if (!strcmp(arg, "-stats")) {
-			dump_stats = GF_TRUE;
-		} else if (!strcmp(arg, "-graph")) {
-			dump_graph = GF_TRUE;
-		} else if (strstr(arg, ":*") || strstr(arg, ":@")) {
-			if (list_filters)
-				list_filters = 3;
-			else
-				print_meta_filters = GF_TRUE;
-		} else if (!strcmp(arg, "-wc")) {
-			write_core_opts = GF_TRUE;
-		} else if (!strcmp(arg, "-we")) {
-			write_extensions = GF_TRUE;
-		} else if (!strcmp(arg, "-wf")) {
-			write_profile = GF_TRUE;
-		} else if (!strcmp(arg, "-wfx")) {
-			write_profile = GF_TRUE;
-			sflags |= GF_FS_FLAG_LOAD_META;
-		} else if (!strcmp(arg, "-sloop")) {
-			nb_loops = -1;
-			if (arg_val) nb_loops = atoi(arg_val);
-			if (nb_loops) {
-				gf_opts_set_key("temp", "peristent-jsrt", "true");
-			}
-		} else if (!strcmp(arg, "-runfor")) {
-			if (arg_val) runfor = 1000*atoi(arg_val);
-		} else if (!strcmp(arg, "-runforx")) {
-			if (arg_val) runfor = 1000*atoi(arg_val);
-			runfor_exit = GF_TRUE;
-		} else if (!strcmp(arg, "-runfors")) {
-			if (arg_val) runfor = 1000*atoi(arg_val);
-			exit_mode = 1;
-		} else if (!strcmp(arg, "-runforl")) {
-			if (arg_val) runfor = 1000*atoi(arg_val);
-			exit_mode = 2;
-		} else if (!strcmp(arg, "-uncache")) {
-			const char *cache_dir = gf_opts_get_key("core", "cache");
-			gf_enum_directory(cache_dir, GF_FALSE, revert_cache_file, NULL, ".txt");
-			fprintf(stderr, "GPAC Cache dir %s flattened\n", cache_dir);
-			gpac_exit(0);
-		} else if (!strcmp(arg, "-cfg")) {
-			nothing_to_do = GF_FALSE;
-		}
-
-		else if (!strcmp(arg, "-alias") || !strcmp(arg, "-aliasdoc")) {
-			char *alias_val;
-			Bool exists;
-			if (!arg_val) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("-alias does not have any argument, check usage \"gpac -h\"\n"));
-				gpac_exit(1);
-			}
-			alias_val = arg_val ? strchr(arg_val, ' ') : NULL;
-			if (alias_val) alias_val0 = 0;
-
-			session = gf_fs_new_defaults(sflags);
-			exists = gf_fs_filter_exists(session, arg_val);
-			gf_fs_del(session);
-			if (exists) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("alias %s has the same name as an existing filter, not allowed\n", arg_val));
-				if (alias_val) alias_val0 = ' ';
-				gpac_exit(1);
-			}
-
-			gf_opts_set_key(!strcmp(arg, "-alias") ? "gpac.alias" : "gpac.aliasdoc", arg_val, alias_val ? alias_val+1 : NULL);
-			fprintf(stderr, "Set %s for %s to %s\n", arg, arg_val, alias_val ? alias_val+1 : "NULL");
-			if (alias_val) alias_val0 = ' ';
-			alias_set = GF_TRUE;
-		}
-		else if (!strncmp(arg, "-seps", 5)) {
-			parse_sep_set(arg_val, &override_seps);
-		} else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
-
-		} else if (!strcmp(arg, "-k")) {
-			enable_prompt = GF_TRUE;
-		} else if (!strcmp(arg, "-js")) {
-			session_js = arg_val;
-		} else if (!strcmp(arg, "-r")) {
-			enable_reports = 2;
-			if (arg_val && !strlen(arg_val)) {
-				enable_reports = 1;
-			} else {
-				report_filter = arg_val;
-			}
-		} else if (!strcmp(arg, "-unit-tests")) {
-			do_unit_tests = GF_TRUE;
-		} else if (!strcmp(arg, "-cl")) {
-			sflags |= GF_FS_FLAG_NO_IMPLICIT;
-		} else if (!strcmp(arg, "-step")) {
-			use_step_mode = GF_TRUE;
-			sflags |= GF_FS_FLAG_NON_BLOCKING;
-		} else if (!strcmp(arg, "-xopt")) {
-			has_xopt = GF_TRUE;
-		} else if (arg0=='-') {
-			if (!strcmp(arg, "-i") || !strcmp(arg, "-src")
-				|| !strcmp(arg, "-o") || !strcmp(arg, "-dst")
-				|| !strcmp(arg, "-ib") || !strcmp(arg, "-ob")
-			) {
-				//skip next arg: input or output, could start with '-'
-				i++;
-				gf_sys_mark_arg_used(i, GF_TRUE);
-			}
-			//profile already processed, and global options (--) handled by libgpac, not this app
-			else if (!strcmp(arg, "-p") || !strcmp(arg, "-")
-			) {
-			}
-			else if (!gf_sys_is_gpac_arg(arg) ) {
-				if (!has_xopt) {
-					gpac_suggest_arg(arg);
-					gpac_exit(-1);
-				} else {
-					gf_sys_mark_arg_used(i, GF_FALSE);
-				}
-			}
-		}
-
-		if (arg_val) {
-			arg_val--;
-			arg_val0='=';
-		}
-	}
-
-	if (do_unit_tests) {
-		gpac_exit( gpac_unit_tests(mem_track) );
-	}
-
-	if (alias_set) {
-		gpac_exit(0);
-	}
-
-	if (dump_stats && gf_sys_get_rti(0, &rti, 0) ) {
-		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("System info: %d MB RAM - %d cores - main thread ID %d\n", (u32) (rti.physical_memory/1024/1024), rti.nb_cores, gf_th_id() ));
-	}
-	if ((list_filters>=2) || print_meta_filters || dump_codecs || print_filter_info) sflags |= GF_FS_FLAG_LOAD_META;
-
-	if (view_filter_conn || list_filters || (print_filter_info && (argmode == GF_ARGMODE_ALL)) )
-		gf_opts_set_key("temp", "gendoc", "yes");
-
-	if (list_filters || print_filter_info)
-		gf_opts_set_key("temp", "helponly", "yes");
-
-restart:
-	prev_filter_is_sink = 0;
-	current_subsession_id = 0;
-	prev_filter_is_not_source = 0;
-	current_source_id = 0;
-
-	if (view_conn_for_filter && argmode>=GF_ARGMODE_EXPERT)
-		sflags |= GF_FS_FLAG_PRINT_CONNECTIONS;
-
-	session = gf_fs_new_defaults(sflags);
-
-	if (!session) {
-		gpac_exit(1);
-	}
-	if (override_seps) gf_fs_set_separators(session, separator_set);
-	if (load_test_filters) gf_fs_register_test_filters(session);
-
-	if (gf_fs_get_max_resolution_chain_length(session) <= 1 ) {
-		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("\nDynamic resolution of filter connections disabled\n\n"));
-	}
-
-	if (list_filters || print_filter_info) {
-		if (print_filters(argc, argv, session, argmode)==GF_FALSE)
-			e = GF_FILTER_NOT_FOUND;
-		goto exit;
-	}
-	if (view_filter_conn) {
-		gf_fs_print_all_connections(session, view_conn_for_filter, gf_sys_format_help);
-		goto exit;
-	}
-	if (dump_codecs) {
-		dump_all_codec(session);
-		goto exit;
-	}
-	if (write_profile || write_extensions || write_core_opts) {
-		if (write_core_opts)
-			write_core_options();
-		if (write_extensions)
-			write_file_extensions();
-		if (write_profile)
-			write_filters_options(session);
-		goto exit;
-	}
-
-	if (session_js) {
-		e = gf_fs_load_script(session, session_js);
-		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Failed to load JS for session: %s\n", gf_error_to_string(e) ));
-			goto exit;
-		}
-	}
-
-	//all good to go, load filters
-	has_xopt = GF_FALSE;
-	links_directive = gf_list_new();
-	loaded_filters = gf_list_new();
-	for (i=1; i<argc; i++) {
-		GF_Filter *filter=NULL;
-		Bool is_simple=GF_FALSE;
-		Bool f_loaded = GF_FALSE;
-		char *arg = argvi;
-
-		if (!strcmp(arg, "-src") || !strcmp(arg, "-i") || !strcmp(arg, "-ib") ) {
-			if (!strcmp(arg, "-ib")) {
-				const char *fargs=NULL;
-				const char *fio_url = make_fileio(argvi+1, &fargs, GF_TRUE, &e);
-				if (fio_url)
-					filter = gf_fs_load_source(session, fio_url, fargs, NULL, &e);
-			} else {
-				filter = gf_fs_load_source(session, argvi+1, NULL, NULL, &e);
-			}
-			arg = argvi+1;
-			i++;
-			f_loaded = GF_TRUE;
-		} else if (!strcmp(arg, "-dst") || !strcmp(arg, "-o") || !strcmp(arg, "-ob") ) {
-			if (!strcmp(arg, "-ob")) {
-				const char *fargs=NULL;
-				const char *fio_url = make_fileio(argvi+1, &fargs, GF_FALSE, &e);
-				if (fio_url)
-					filter = gf_fs_load_destination(session, fio_url, fargs, NULL, &e);
-			} else {
-				filter = gf_fs_load_destination(session, argvi+1, NULL, NULL, &e);
-			}
-			arg = argvi+1;
-			i++;
-			f_loaded = GF_TRUE;
-		}
-		else if (!strncmp(arg, "-lcf", 4)) {
-			f_loaded = GF_TRUE;
-			filter = load_custom_filter(session, arg+4, &e);
-		}
-		//appart from the above src/dst, other args starting with - are not filters
-		else if (arg0=='-') {
-			if (!strcmp(arg, "-xopt")) has_xopt = GF_TRUE;
-			continue;
-		}
-		if (!f_loaded && !has_xopt) {
-			if (arg0== separator_setSEP_LINK ) {
-				gf_list_add(links_directive, arg);
-				continue;
-			}
-
-			if (!strncmp(arg, "src=", 4) ) {
-				filter = gf_fs_load_source(session, arg+4, NULL, NULL, &e);
-			} else if (!strncmp(arg, "dst=", 4) ) {
-				filter = gf_fs_load_destination(session, arg+4, NULL, NULL, &e);
-			} else {
-				e = GF_EOS;
-				char *need_gfio = strstr(arg, "@gfi://");
-				if (!need_gfio) need_gfio = strstr(arg, "@gfo://");
-				if (need_gfio) {
-					const char *fargs=NULL;
-					const char *fio_url;
-					char *updated_args;
-					u32 len = (u32) (need_gfio - arg);
-					updated_args = gf_malloc(sizeof(char)*(len+1));
-					strncpy(updated_args, arg, len);
-					updated_argslen=0;
-
-					fio_url = make_fileio(need_gfio+7, &fargs, need_gfio3=='i' ? GF_TRUE : GF_FALSE, &e);
-					if (fio_url) {
-						gf_dynstrcat(&updated_args, fio_url, NULL);
-						if (fargs)
-							gf_dynstrcat(&updated_args, fargs, NULL);
-
-						filter = gf_fs_load_filter(session, updated_args, &e);
-					}
-					gf_free(updated_args);
-				} else {
-					filter = gf_fs_load_filter(session, arg, &e);
-				}
-				is_simple=GF_TRUE;
-				if (!filter && has_xopt)
-					continue;
-			}
-		}
-
-		if (!filter) {
-			if (has_xopt)
-				continue;
-			if (!e) e = GF_FILTER_NOT_FOUND;
-
-			if (e!=GF_FILTER_NOT_FOUND) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Failed to load filter%s \"%s\": %s\n", is_simple ? "" : " for", arg, gf_error_to_string(e) ));
-			} else {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Failed to find filter%s \"%s\"\n", is_simple ? "" : " for", arg));
-
-				gpac_suggest_filter(arg, GF_FALSE, GF_TRUE);
-				nb_filters=0;
-			}
-			goto exit;
-		}
-		nb_filters++;
-
-		if (!(sflags & GF_FS_FLAG_NO_IMPLICIT))
-			gf_filter_tag_subsession(filter, current_subsession_id, current_source_id);
-
-		while (gf_list_count(links_directive)) {
-			char *link_prev_filter_ext = NULL;
-			GF_Filter *link_from;
-			Bool reverse_order = GF_FALSE;
-			s32 link_filter_idx = -1;
-			char *link = gf_list_pop_front(links_directive);
-			char *ext = strchr(link, separator_setSEP_FRAG);
-			if (ext) {
-				ext0 = 0;
-				link_prev_filter_ext = ext+1;
-			}
-			if (strlen(link)>1) {
-				if (link1 == separator_setSEP_LINK ) {
-					reverse_order = GF_TRUE;
-					link++;
-				}
-				link_filter_idx = atoi(link+1);
-				if (link_filter_idx < 0) {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Wrong filter index %d, must be positive\n", link_filter_idx));
-					e = GF_BAD_PARAM;
-					goto exit;
-				}
-			} else {
-				link_filter_idx = 0;
-			}
-			if (ext) ext0 = separator_setSEP_FRAG;
-
-			if (reverse_order)
-				link_from = gf_list_get(loaded_filters, link_filter_idx);
-			else
-				link_from = gf_list_get(loaded_filters, gf_list_count(loaded_filters)-1-link_filter_idx);
-
-			if (!link_from) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Wrong filter index @%d\n", link_filter_idx));
-				e = GF_BAD_PARAM;
-				goto exit;
-			}
-			gf_filter_set_source(filter, link_from, link_prev_filter_ext);
-		}
-
-		gf_list_add(loaded_filters, filter);
-
-		//implicit mode, check changes of source and sinks
-		if (!(sflags & GF_FS_FLAG_NO_IMPLICIT)) {
-			if (gf_filter_is_source(filter)) {
-				if (prev_filter_is_not_source) {
-					current_source_id++;
-					gf_filter_tag_subsession(filter, current_subsession_id, current_source_id);
-				}
-				prev_filter_is_not_source = 0;
-			} else {
-				prev_filter_is_not_source = 1;
-			}
-
-			if (gf_filter_is_sink(filter)) {
-				prev_filter_is_sink = GF_TRUE;
-			}
-			else if (prev_filter_is_sink && gf_filter_is_source(filter)) {
-				prev_filter_is_sink = GF_FALSE;
-				current_subsession_id++;
-				current_source_id=0;
-				prev_filter_is_not_source = 0;
-				gf_filter_tag_subsession(filter, current_subsession_id, current_source_id);
-			}
-		}
-	}
-	if (!gf_list_count(loaded_filters) && !session_js) {
-		if (nothing_to_do && !gen_doc) {
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Nothing to do, check usage \"gpac -h\"\ngpac - GPAC command line filter engine - version %s\n%s\n", gf_gpac_version(), gf_gpac_copyright_cite()));
-			e = GF_BAD_PARAM;
-		} else {
-			e = GF_EOS;
-		}
-		goto exit;
-	}
-	if (enable_reports) {
-		if (enable_reports==2)
-			gf_fs_set_ui_callback(session, gpac_event_proc, session);
-
-		gf_fs_enable_reporting(session, GF_TRUE);
-	}
-	if (gf_list_count(links_directive)) {
-		GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Link separators specified but no following filter, ignoring links "));
-		while (gf_list_count(links_directive)) {
-			const char *ld = gf_list_pop_front(links_directive);
-			GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\"%s\"", ld));
-		}
-		GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\n"));
-	}
-
-	if (enable_prompt || (runfor>0)) {
-		if (enable_prompt && !loops_done) {
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Running session, press 'h' for help\n"));
-		}
-		gf_fs_post_user_task(session, gpac_fsess_task, NULL, "gpac_fsess_task");
-	}
-	if (!enable_prompt) {
-#ifdef WIN32
-		SetConsoleCtrlHandler((PHANDLER_ROUTINE)gpac_sig_handler, TRUE);
-#else
-		signal(SIGINT, gpac_sig_handler);
-		signal(SIGTERM, gpac_sig_handler);
-#endif
-	}
-
-	if (enable_reports) {
-		gpac_print_report(session, GF_TRUE, GF_FALSE);
-	}
-
-	if (!session_js) {
-		u32 j;
-		Bool has_vout = GF_FALSE;
-		Bool has_compositor = GF_FALSE;
-		for (j=0; j<gf_list_count(loaded_filters); j++) {
-			GF_FilterStats stats;
-			GF_Filter *f = gf_list_get(loaded_filters, j);
-			gf_filter_get_stats(f, &stats);
-			if (!stats.reg_name) continue;
-			if (!strcmp(stats.reg_name, "vout")) has_vout=GF_TRUE;
-			//if compositor in player mode, don't load script
-			else if (!strcmp(stats.reg_name, "compositor")) {
-				GF_PropertyValue p;
-				gf_filter_get_arg(f, "player", &p);
-				if (p.value.uint!=0)
-					has_compositor=GF_TRUE;
-			}
-		}
-		if (has_vout && !has_compositor) {
-			session_js = "$GSHARE/scripts/vout.js";
-			gf_fs_load_script(session, session_js);
-		}
-	}
-
-	if (use_step_mode) {
-		do {
-			gf_fs_run(session);
-		} while (!gf_fs_is_last_task(session));
-
-	} else {
-		e = gf_fs_run(session);
-		if (e>0) e = GF_OK;
-	}
-
-	if (e) {
-		fprintf(stderr, "session error %s\n", gf_error_to_string(e) );
-	} else {
-		e = gf_fs_get_last_connect_error(session);
-		if (e<0) fprintf(stderr, "session last connect error %s\n", gf_error_to_string(e) );
-
-		if (!e) {
-			e = gf_fs_get_last_process_error(session);
-			if (e<0) fprintf(stderr, "session last process error %s\n", gf_error_to_string(e) );
-		}
-		gpac_check_session_args();
-	}
-
-	if (enable_reports) {
-		if (enable_reports==2) {
-			gf_sys_set_console_code(stderr, GF_CONSOLE_RESTORE);
-		}
-		gpac_print_report(session, GF_FALSE, GF_TRUE);
-	}
-	gf_fs_print_non_connected_ex(session, alias_is_play);
-
-exit:
-	if (enable_reports==2) {
-		gf_log_set_callback(session, NULL);
-	}
-
-	if (e && nb_filters) {
-		gf_fs_run(session);
-	}
-	if (dump_stats)
-		gf_fs_print_stats(session);
-	if (dump_graph)
-		gf_fs_print_connections(session);
-
-
-	tmp_sess = session;
-	session = NULL;
-	gf_fs_del(tmp_sess);
-	if (loaded_filters) gf_list_del(loaded_filters);
-	if (links_directive) gf_list_del(links_directive);
-
-	cleanup_file_io();
-
-	if (!e && nb_loops) {
-		if (nb_loops>0) nb_loops--;
-		loops_done++;
-		fprintf(stderr, "session done, restarting (loop %d)\n", loops_done);
-		fflush(stderr);
-		gf_log_reset_file();
-		goto restart;
-	}
-
-#ifdef GPAC_HAS_QJS
-	if (loops_done) {
-		void gf_js_delete_runtime();
-		gf_js_delete_runtime();
-	}
-#endif
-
-	gpac_exit(e<0 ? 1 : 0);
-}
-
-GF_MAIN_FUNC(gpac_main)
-
-
-/*********************************************************
-		Filter and property info/dump functions
-*********************************************************/
-
-static void dump_caps(u32 nb_caps, const GF_FilterCapability *caps)
-{
-	u32 i;
-	for (i=0;i<nb_caps; i++) {
-		const char *szName;
-		const char *szVal;
-		char szDumpGF_PROP_DUMP_ARG_SIZE;
-		const GF_FilterCapability *cap = &capsi;
-		if (!(cap->flags & GF_CAPFLAG_IN_BUNDLE) && i+1==nb_caps) break;
-		if (!i) gf_sys_format_help(helpout, help_flags, "Capabilities Bundle:\n");
-		else if (!(cap->flags & GF_CAPFLAG_IN_BUNDLE) ) {
-			gf_sys_format_help(helpout, help_flags, "Capabilities Bundle:\n");
-			continue;
-		}
-
-		szName = cap->name ? cap->name : gf_props_4cc_get_name(cap->code);
-		if (!szName) szName = gf_4cc_to_str(cap->code);
-		gf_sys_format_help(helpout, help_flags, "\t Flags:");
-		if (cap->flags & GF_CAPFLAG_INPUT) gf_sys_format_help(helpout, help_flags, " Input");
-		if (cap->flags & GF_CAPFLAG_OUTPUT) gf_sys_format_help(helpout, help_flags, " Output");
-		if (cap->flags & GF_CAPFLAG_EXCLUDED) gf_sys_format_help(helpout, help_flags, " Exclude");
-		if (cap->flags & GF_CAPFLAG_LOADED_FILTER) gf_sys_format_help(helpout, help_flags, " LoadedFilterOnly");
-
-		//dump some interesting predefined ones which are not mapped to types
-		if (cap->code==GF_PROP_PID_STREAM_TYPE) szVal = gf_stream_type_name(cap->val.value.uint);
-		else if (cap->code==GF_PROP_PID_CODECID) szVal = (const char *) gf_codecid_name(cap->val.value.uint);
-		else szVal = gf_props_dump_val(&cap->val, szDump, GF_PROP_DUMP_DATA_NONE, NULL);
-
-		gf_sys_format_help(helpout, help_flags, " %s=\"%s\"", szName, szVal);
-		if (cap->priority) gf_sys_format_help(helpout, help_flags, ", priority=%d", cap->priority);
-		gf_sys_format_help(helpout, help_flags, "\n");
-	}
-}
-
-static void print_filter_arg(const GF_FilterArgs *a, u32 gen_doc)
-{
-	Bool is_enum = GF_FALSE;
-
-	if ((a->arg_type==GF_PROP_UINT) && a->min_max_enum && strchr(a->min_max_enum, '|')) {
-		is_enum = GF_TRUE;
-	}
-
-	if (gen_doc==1) {
-		gf_sys_format_help(helpout, help_flags, "<a id=\"%s\">", a->arg_name);
-		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s", a->arg_name);
-		gf_sys_format_help(helpout, help_flags, "</a> (%s", is_enum ? "enum" : gf_props_get_type_name(a->arg_type));
-	} else {
-		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s (%s", a->arg_name, is_enum ? "enum" : gf_props_get_type_name(a->arg_type));
-	}
-	if (a->arg_default_val) {
-		if (!strcmp(a->arg_default_val, "2147483647"))
-			gf_sys_format_help(helpout, help_flags, ", default: __+I__");
-		else if (!strcmp(a->arg_default_val, "-2147483648"))
-			gf_sys_format_help(helpout, help_flags, ", default: __-I__");
-		else
-			gf_sys_format_help(helpout, help_flags, ", default: __%s__", a->arg_default_val);
-	} else {
-//		gf_sys_format_help(helpout, help_flags, ", no default");
-	}
-	if (a->min_max_enum && !is_enum) {
-		if (!strcmp(a->min_max_enum, "-2147483648-I"))
-			gf_sys_format_help(helpout, help_flags, ", %s: -I-I", /*strchr(a->min_max_enum, '|') ? "Enum" : */"minmax");
-		else
-			gf_sys_format_help(helpout, help_flags, ", %s: %s", /*strchr(a->min_max_enum, '|') ? "Enum" : */"minmax", a->min_max_enum);
-	}
-	if (a->flags & GF_FS_ARG_UPDATE) gf_sys_format_help(helpout, help_flags, ", updatable");
-//		if (a->flags & GF_FS_ARG_META) gf_sys_format_help(helpout, help_flags, ", meta");
-
-	if (is_enum && a->arg_desc && !strchr(a->arg_desc, '\n')) {
-		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_OPT_DESC, "): %s (%s)\n", a->arg_desc, a->min_max_enum);
-	} else {
-		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_OPT_DESC, "): %s\n", a->arg_desc);
-	}
-
-	//check syntax
-	if (gen_doc) {
-		GF_GPACArg _a;
-		memset(&_a, 0, sizeof(GF_GPACArg));
-		_a.name = a->arg_name;
-		_a.description = a->arg_desc;
-		_a.flags = GF_ARG_HINT_HIDE;
-		gf_sys_print_arg(NULL, 0, &_a, "");
-	}
-
-	if (a->min_max_enum && strchr(a->min_max_enum, '|'))
-		gf_sys_format_help(helpout, help_flags, "\n");
-	else if (!a->min_max_enum && a->arg_desc && strstr(a->arg_desc, "\n- "))
-		gf_sys_format_help(helpout, help_flags, "\n");
-}
-
-static void print_filter_single_opt(const GF_FilterRegister *reg, char *optname, GF_Filter *filter_inst)
-{
-	u32 idx=0;
-	Bool found = GF_FALSE;
-	const GF_FilterArgs *args = NULL;
-	if (filter_inst)
-		args = gf_filter_get_args(filter_inst);
-	else if (reg)
-		args = reg->args;
-
-	if (!args) return;
-
-	while (1) {
-		const GF_FilterArgs *a = & argsidx;
-		if (!a || !a->arg_name) break;
-		idx++;
-		if (strcmp(a->arg_name, optname)) continue;
-
-		print_filter_arg(a, 0);
-		found = GF_TRUE;
-		break;
-	}
-	if (found) return;
-
-	idx = 0;
-	while (1) {
-		const GF_FilterArgs *a = & argsidx;
-		if (!a || !a->arg_name) break;
-		idx++;
-		if (gf_sys_word_match(optname, a->arg_name)
-			|| (a->arg_desc && strstr(a->arg_desc, optname))
-		) {
-			if (!found) {
-				found = GF_TRUE;
-				fprintf(stderr, "No such option %s for filter %s - did you mean:\n", optname, filter_inst ? gf_filter_get_name(filter_inst) : reg->name);
-			}
-			fprintf(stderr, " - %s: %s\n", a->arg_name, a->arg_desc);
-		}
-	}
-	if (found) return;
-
-	fprintf(stderr, "No such option %s for filter %s\n", optname, filter_inst ? gf_filter_get_name(filter_inst) : reg->name);
-}
-
-static void print_filter(const GF_FilterRegister *reg, GF_SysArgMode argmode, GF_Filter *filter_inst, char *inst_name)
-{
-	u32 idx=0;
-	const GF_FilterArgs *args = NULL;
-	const char *reg_name, *reg_desc;
-#ifndef GPAC_DISABLE_DOC
-	const char *reg_help;
-#endif
-	Bool jsmod_help = (argmode>GF_ARGMODE_ALL) ? GF_TRUE : GF_FALSE;
-
-	if (filter_inst) {
-		reg_name = inst_name;
-		reg_desc = gf_filter_get_description(filter_inst);
-#ifndef GPAC_DISABLE_DOC
-		reg_help = gf_filter_get_help(filter_inst);
-#endif
-	} else if (reg) {
-		reg_name = reg->name;
-		reg_desc = reg->description;
-#ifndef GPAC_DISABLE_DOC
-		reg_help = reg->help;
-#endif
-	} else {
-		return;
-	}
-
-	//happens on some meta filter or JS filters
-	if (!reg_desc) {
-		reg_desc = "No description available";
-	}
-
-	if (gen_doc==1) {
-		char szName1024;
-		sprintf(szName, "%s.md", reg_name);
-		if (gen_doc==1) {
-			gf_fclose(helpout);
-			helpout = gf_fopen(szName, "w");
-			fprintf(helpout, "**HOME**(Home) » **Filters**(Filters) » %s\n", reg_desc);
-			fprintf(helpout, "%s", auto_gen_md_warning);
-
-			if (!sidebar_md) {
-				char *sbbuf = NULL;
-				if (gf_file_exists("_Sidebar.md")) {
-					char szLine1024;
-					u32 end_pos=0;
-					sidebar_md = gf_fopen("_Sidebar.md", "r");
-					gf_fseek(sidebar_md, 0, SEEK_SET);
-					while (!feof(sidebar_md)) {
-						char *read = gf_fgets(szLine, 1024, sidebar_md);
-						if (!read) break;
-						if (!strncmp(szLine, "**Filters Help**", 16)) {
-							end_pos = (u32) gf_ftell(sidebar_md);
-							break;
-						}
-					}
-					if (!end_pos) end_pos = (u32) gf_ftell(sidebar_md);
-					if (end_pos) {
-						sbbuf = gf_malloc(end_pos+1);
-						gf_fseek(sidebar_md, 0, SEEK_SET);
-						end_pos = (u32) gf_fread(sbbuf, end_pos, sidebar_md);
-						sbbufend_pos=0;
-						gf_fclose(sidebar_md);
-					}
-				}
-				sidebar_md = gf_fopen("_Sidebar.md", "w");
-				if (sbbuf) {
-					fprintf(sidebar_md, "%s\n \n", sbbuf);
-					gf_free(sbbuf);
-				}
-			}
-			fprintf(sidebar_md, "%s (%s)|%s \n", reg_desc, reg_name, reg_name);
-#ifndef GPAC_DISABLE_DOC
-
-			if (!reg_help) {
-				fprintf(stderr, "filter %s without help, forbidden\n", reg_name);
-				exit(1);
-			}
-#endif
-		}
-
-#ifndef GPAC_DISABLE_DOC
-		gf_sys_format_help(helpout, help_flags, "# %s\n", reg_desc);
-#endif
-		gf_sys_format_help(helpout, help_flags, "Register name used to load filter: **%s**\n", reg_name);
-		if (filter_inst) {
-			gf_sys_format_help(helpout, help_flags, "This is a JavaScript filter, not checked during graph resolution and needs explicit loading.\n");
-		} else {
-			if (reg->flags & GF_FS_REG_EXPLICIT_ONLY) {
-				gf_sys_format_help(helpout, help_flags, "This filter is not checked during graph resolution and needs explicit loading.\n");
-			} else {
-				gf_sys_format_help(helpout, help_flags, "This filter may be automatically loaded during graph resolution.\n");
-			}
-			if (reg->flags & GF_FS_REG_REQUIRES_RESOLVER) {
-				gf_sys_format_help(helpout, help_flags, "This filter requires the graph resolver to be activated.\n");
-			}
-			if (reg->flags & GF_FS_REG_ALLOW_CYCLIC) {
-				gf_sys_format_help(helpout, help_flags, "Filters of this class can connect to each-other.\n");
-			}
-		}
-	} else if (!jsmod_help) {
-		gf_sys_format_help(helpout, help_flags, "# %s\n", reg_name);
-		gf_sys_format_help(helpout, help_flags, "Description: %s\n", reg_desc );
-
-		if (filter_inst) {
-			const char *version = gf_filter_get_version(filter_inst);
-			if (version)
-				gf_sys_format_help(helpout, help_flags, "Version: %s\n", version );
-		} else {
-			if (reg->version) {
-				if (!strncmp(reg->version, "! ", 2)) {
-					if (!gen_doc)
-						gf_sys_format_help(helpout, help_flags, "%s\n", reg->version+2);
-				} else {
-					gf_sys_format_help(helpout, help_flags, "Version: %s\n", reg->version);
-				}
-			}
-		}
-	}
-
-	if (filter_inst) {
-		const char *str;
-		if (!jsmod_help) {
-			str = gf_filter_get_author(filter_inst);
-			if (str)
-				gf_sys_format_help(helpout, help_flags, "%s: %s\n", (str0=='-') ? "Configuration" : "Author", str );
-		}
-		str = gf_filter_get_help(filter_inst);
-		if (str)
-			gf_sys_format_help(helpout, help_flags, "\n%s\n\n", str);
-	} else if (reg) {
-#ifndef GPAC_DISABLE_DOC
-		if (reg->author) {
-			if (reg->author0=='-') {
-				if (! (help_flags & (GF_PRINTARG_MD|GF_PRINTARG_MAN))) {
-					gf_sys_format_help(helpout, help_flags, "Configuration: %s\n", reg->author);
-				}
-			} else {
-				gf_sys_format_help(helpout, help_flags, "Author: %s\n", reg->author);
-			}
-		}
-		if (reg->help) {
-			u32 hf = help_flags;
-			if (gen_doc==1) hf |= GF_PRINTARG_ESCAPE_XML;
-			gf_sys_format_help(helpout, hf, "\n%s\n\n", reg->help);
-		}
-#else
-		gf_sys_format_help(helpout, help_flags, "GPAC compiled without built-in doc\n");
-#endif
-	}
-
-	if (reg && (argmode==GF_ARGMODE_EXPERT)) {
-		if (reg->max_extra_pids==(u32) -1) gf_sys_format_help(helpout, help_flags, "Max Input PIDs: any\n");
-		else gf_sys_format_help(helpout, help_flags, "Max Input PIDs: %d\n", 1 + reg->max_extra_pids);
-
-		gf_sys_format_help(helpout, help_flags, "Flags:");
-		if (reg->flags & GF_FS_REG_EXPLICIT_ONLY) gf_sys_format_help(helpout, help_flags, " ExplicitOnly");
-		if (reg->flags & GF_FS_REG_MAIN_THREAD) gf_sys_format_help(helpout, help_flags, " MainThread");
-		if (reg->flags & GF_FS_REG_CONFIGURE_MAIN_THREAD) gf_sys_format_help(helpout, help_flags, " ConfigureMainThread");
-		if (reg->flags & GF_FS_REG_HIDE_WEIGHT) gf_sys_format_help(helpout, help_flags, " HideWeight");
-		if (reg->flags & GF_FS_REG_REQUIRES_RESOLVER) gf_sys_format_help(helpout, help_flags, " RequireResolver");
-		if (reg->flags & GF_FS_REG_ALLOW_CYCLIC) gf_sys_format_help(helpout, help_flags, " CyclicAllowed");
-		if (reg->probe_url) gf_sys_format_help(helpout, help_flags, " URLMimeProber");
-		if (reg->probe_data) gf_sys_format_help(helpout, help_flags, " DataProber");
-		if (reg->reconfigure_output) gf_sys_format_help(helpout, help_flags, " ReconfigurableOutput");
-
-		gf_sys_format_help(helpout, help_flags, "\nPriority %d", reg->priority);
-
-		gf_sys_format_help(helpout, help_flags, "\n");
-	}
-
-	if (filter_inst) args = gf_filter_get_args(filter_inst);
-	else args = reg->args;
-
-	u32 nb_opts=0;
-	idx=0;
-	while (1) {
-		const GF_FilterArgs *a = & argsidx;
-		if (!a || !a->arg_name) break;
-		idx++;
-		if (a->flags & GF_FS_ARG_HINT_HIDE) continue;
-		nb_opts++;
-	}
-	if (!nb_opts)
-		args = NULL;
-
-	if (args && !jsmod_help) {
-		idx=0;
-		if (gen_doc==1) {
-			gf_sys_format_help(helpout, help_flags, "# Options \n");
-		} else {
-			switch (argmode) {
-			case GF_ARGMODE_ALL:
-			case GF_ARGMODE_EXPERT:
-				gf_sys_format_help(helpout, help_flags, "# Options (expert):\n");
-				break;
-			case GF_ARGMODE_ADVANCED:
-				gf_sys_format_help(helpout, help_flags, "# Options (advanced):\n");
-				break;
-			case GF_ARGMODE_BASE:
-				gf_sys_format_help(helpout, help_flags, "# Options (basic):\n");
-				break;
-			}
-		}
-
-		while (1) {
-			const GF_FilterArgs *a = & argsidx;
-			if (!a || !a->arg_name) break;
-			idx++;
-
-			if (a->flags & GF_FS_ARG_HINT_HIDE) continue;
-
-			switch (argmode) {
-			case GF_ARGMODE_ALL:
-			case GF_ARGMODE_EXPERT:
-			 	break;
-			case GF_ARGMODE_ADVANCED:
-			 	if (a->flags & GF_FS_ARG_HINT_EXPERT) continue;
-			 	break;
-			case GF_ARGMODE_BASE:
-			 	if (a->flags & (GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_HINT_ADVANCED)) continue;
-			 	break;
-			}
-
-			print_filter_arg(a, gen_doc);
-
-			if (!gen_doc) continue;
-
-#ifdef CHECK_DOC
-			if (a->flags & GF_FS_ARG_META) continue;
-
-			u8 achar;
-			u32 j=0;
-			char szArg100;
-			sprintf(szArg, " %s ", a->arg_name);
-			char *quoted = reg_help ? strstr(reg_help, szArg) : NULL;
-			if (quoted) {
-				fprintf(stderr, "\nWARNING: filter %s bad help, uses arg %s without link: \"... %s\"\n", reg_name, a->arg_name, quoted);
-				exit(1);
-			}
-			while (1) {
-				const GF_FilterArgs *anarg = & argsj;
-				if (!anarg || !anarg->arg_name) break;
-				j++;
-				if (a == anarg) continue;
-				if (reg_help && strstr(reg_help, szArg)) {
-					fprintf(stderr, "\nWARNING: filter %s bad description for argument %s, uses arg %s without link\n", reg_name, anarg->arg_name, a->arg_name);
-					exit(1);
-				}
-			}
-
-			if (a->min_max_enum) {
-				//check format
- if ((a->arg_type!=GF_PROP_UINT_LIST) && !(a->flags&GF_FS_ARG_META) && strchr(a->min_max_enum, '|') && (!a->arg_default_val || strcmp(a->arg_default_val, "-1")) ) {
-					const char *a_val = a->min_max_enum;
-					while (a_val0 == '|') a_val++;
-					if (strstr(a->arg_desc, "see filter "))
-						a_val = NULL;
-					while (a_val) {
-						char szName100;
-						const char *a_sep = strchr(a_val, '|');
-						u32 len = a_sep ? (u32)(a_sep - a_val) : (u32)strlen(a_val);
-						strcpy(szName, "- ");
-						strncat(szName, a_val, MIN(sizeof(szName)-3,len));
-						szName2+len=0;
-						strcat(szName, ": ");
-
-						if (!strstr(a->arg_desc, szName)) {
-							fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, missing list bullet \"%s\"\n", reg_name, a->arg_name, szName);
-							exit(1);
-						}
-						if (!a_sep) break;
-						a_val = a_sep+1;
-					}
-					if (a_val && !strstr(a->arg_desc, "- ")) {
- 	fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, missing list bullet \"- \"\n", reg_name, a->arg_name);
- 	exit(1);
-					}
-					if (a_val && strstr(a->arg_desc, ":\n")) {
- 	fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should not use \":\\n\"\n", reg_name, a->arg_name);
- 	exit(1);
-					}
- } else if (!(a->flags&GF_FS_ARG_META) && strchr(a->arg_desc, '\n')) {
-					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should not contain \"\\n\"\n", reg_name, a->arg_name);
-					exit(1);
-				}
-			}
- if (!(a->flags&GF_FS_ARG_META)) {
-				char *sep;
-
-				achar = a->arg_descstrlen(a->arg_desc)-1;
-				if (achar == '\n') {
-					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should not end with \"\\n\"\n", reg_name, a->arg_name);
-					exit(1);
-				}
-
-				achar = a->arg_desc0;
-				if ((achar >= 'A') && (achar <= 'Z')) {
-					achar = a->arg_desc1;
-					if ((achar < 'A') || (achar > 'Z')) {
-						fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should start with lowercase\n", reg_name, a->arg_name);
-						exit(1);
-					}
-				}
-				if (a->arg_desc0 == ' ') {
-					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, first character should not be space\n", reg_name, a->arg_name);
-					exit(1);
-				}
-				sep = strchr(a->arg_desc+1, ' ');
-				if (sep) sep--;
-				if (sep && (sep0 == 's') && (sep-1 != 's')) {
-					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, first word should be infinitive\n", reg_name, a->arg_name);
-					exit(1);
-				}
-			}
-#endif
-		}
-	} else if (!args) {
-		gf_sys_format_help(helpout, help_flags, "No options\n");
-	}
-
-	if (!gen_doc && (argmode==GF_ARGMODE_ALL)) {
-		if (filter_inst) {
-			u32 nb_caps = 0;
-			const GF_FilterCapability *caps = gf_filter_get_caps(filter_inst, &nb_caps);
-			dump_caps(nb_caps, caps);
-		} else if (reg->nb_caps) {
-			dump_caps(reg->nb_caps, reg->caps);
-		}
-	}
-	gf_sys_format_help(helpout, help_flags, "\n");
-}
-
-static Bool strstr_nocase(const char *text, const char *subtext, u32 subtext_len)
-{
-	if (!*text || !subtext || !subtext_len)
-		return GF_FALSE;
-
-	while (*text) {
-		if (tolower(*text) == *subtext) {
-			if (!strnicmp(text, subtext, subtext_len))
-				return GF_TRUE;
-
-		}
-		text++;
-	}
-	return GF_FALSE;
-}
-
-struct __jsenum_info
-{
-	GF_FilterSession *session;
-	GF_SysArgMode argmode;
-	Bool print_filter_info;
-	const char *path;
-	char *js_dir;
-};
-
-static Bool jsinfo_enum(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
-{
-	struct __jsenum_info *jsi = (struct __jsenum_info *)cbck;
-	GF_Filter *f;
-	if (jsi->js_dir && strcmp(item_name, "init.js")) {
-		return GF_FALSE;
-	}
-	f = gf_fs_load_filter(jsi->session, item_path, NULL);
-	if (f) {
-		char szPathGF_MAX_PATH;
-		char *ext;
-		if (jsi->js_dir) {
-			strcpy(szPath, jsi->js_dir);
-		} else {
-			strcpy(szPath, item_name);
-		}
-		ext = gf_file_ext_start(szPath);
-		if (ext) ext0 = 0;
-		if (jsi->print_filter_info || gen_doc)
-			print_filter(NULL, jsi->argmode, f, szPath);
-		else
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s: %s\n", szPath, gf_filter_get_description(f));
-	}
-	return GF_FALSE;
-}
-static Bool jsinfo_dir_enum(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
-{
-	char szPathGF_MAX_PATH;
-	struct __jsenum_info *jsi = (struct __jsenum_info *)cbck;
-	jsi->js_dir = item_name;
-
-	strcpy(szPath, jsi->path);
-	strcat(szPath, item_name);
-	strcat(szPath, "/");
-	gf_enum_directory(szPath, GF_FALSE, jsinfo_enum, jsi, ".js");
-	jsi->js_dir = NULL;
-	return GF_FALSE;
-}
-
-static Bool print_filters(int argc, char **argv, GF_FilterSession *session, GF_SysArgMode argmode)
-{
-	Bool found = GF_FALSE;
-	Bool print_all = GF_FALSE;
-	char *fname = NULL;
-	char *l_fname = NULL;
-	u32 lf_len = 0;
-	u32 i, count = gf_fs_filters_registers_count(session);
-
-	if (!gen_doc && list_filters) gf_sys_format_help(helpout, help_flags, "Listing %d supported filters%s:\n", count, (list_filters==2) ? " including meta-filters" : "");
-
-	if (print_filter_info != 1) {
-		for (i=0; i<count; i++) {
-			const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
-			if (gen_doc) {
-				print_filter(reg, argmode, NULL, NULL);
-			} else if (print_filter_info) {
-				print_filter(reg, argmode, NULL, NULL);
-			} else {
-#ifndef GPAC_DISABLE_DOC
-				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s: %s\n", reg->name, reg->description);
-#else
-				gf_sys_format_help(helpout, help_flags, "%s (compiled without built-in doc)\n", reg->name);
-#endif
-			}
-		}
-		found = GF_TRUE;
-	}
-	//print a specific filter info, browse args
-	else {
-		u32 k;
-		//all good to go, load filters
-		for (k=1; k<(u32) argc; k++) {
-			char *arg = argvk;
-			char *sepe;
-			Bool found_freg = GF_FALSE;
-			char *optname = NULL;
-			if (arg0=='-') continue;
-
-			sepe = gf_file_basename(arg);
-			if (sepe) sepe = strchr(sepe, '.');
-			if (sepe) {
-				if (!strncmp(sepe, ".js.", 4)) sepe = strchr(sepe+1, '.');
-				else if (!strcmp(sepe, ".js")) sepe = NULL;
-				if (sepe) {
-					sepe0 = 0;
-					optname = sepe+1;
-				}
-			}
-			fname = arg;
-			for (i=0; i<count; i++) {
-				const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
-				//exact match
-				if (!strcmp(arg, reg->name) ) {
-					if (optname)
-						print_filter_single_opt(reg, optname, NULL);
-					else
-						print_filter(reg, argmode, NULL, NULL);
-					found_freg = GF_TRUE;
-				}
-				//search for name:*, also accept *:*
-				else {
-					char *sepo = strchr(arg, ':');
-
-					if (!strcmp(arg, "*:*") || !strcmp(arg, "@:@")
-						|| (!sepo && (!strcmp(arg, "*") || !strcmp(arg, "@")) )
-						|| (sepo && (!strcmp(sepo, ":*") || !strcmp(sepo, ":@")) && !strncmp(reg->name, arg, 1+sepo - arg) )
-					) {
-						if (optname)
-							print_filter_single_opt(reg, optname, NULL);
-						else
-							print_filter(reg, argmode, NULL, NULL);
-						found_freg = GF_TRUE;
-						if (!strcmp(arg, "*")) print_all = GF_TRUE;
-					}
-				}
-			}
-			if (found_freg) {
-				found = GF_TRUE;
-			} else /*if (!strchr(arg, ':')) */ {
-				GF_SysArgMode _argmode = argmode;
-				char *js_opt = strchr(arg, ':');
-				if (js_opt) {
-					js_opt0 = 0;
-					gf_opts_set_key("temp", "gpac-js-help", js_opt+1);
-					_argmode = GF_ARGMODE_ALL+1;
-				}
-				//try to load the filter (JS)
-				GF_Filter *f = gf_fs_load_filter(session, arg, NULL);
-				const GF_FilterRegister *reg = f ? gf_filter_get_register(f) : NULL;
-				if (!reg || !(reg->flags & GF_FS_REG_SCRIPT))
-					f = NULL;
-
-				if (f) {
-					char *ext;
-					char szPathGF_MAX_PATH;
-					strcpy(szPath, gf_file_basename(arg) );
-					ext = gf_file_ext_start(szPath);
-					if (ext) ext0 = 0;
-					if (optname) {
-						print_filter_single_opt(NULL, optname, f);
-					} else {
-						print_filter(NULL, _argmode, f, szPath);
-					}
-					found = GF_TRUE;
-				}
-				if (js_opt) {
-					js_opt0 = ':';
-					gf_opts_set_key("temp", "gpac-js-help", NULL);
-				}
-			}
-			if (sepe) sepe0 = '.';
-		}
-	}
-
-	if (print_all || !print_filter_info || gen_doc) {
-		const char *js_dirs = gf_opts_get_key("core", "js-dirs");
-		char szPathGF_MAX_PATH;
-		struct __jsenum_info jsi;
-		jsi.argmode = argmode;
-		jsi.session = session;
-		jsi.print_filter_info = print_filter_info;
-
-		gf_log_set_tools_levels("console@error", GF_FALSE);
-
-		if (gf_opts_default_shared_directory(szPath)) {
-			strcat(szPath, "/scripts/jsf/");
-			jsi.path = szPath;
-			gf_enum_directory(szPath, GF_FALSE, jsinfo_enum, &jsi, ".js");
-			gf_enum_directory(szPath, GF_TRUE, jsinfo_dir_enum, &jsi, NULL);
-		}
-		while (js_dirs && js_dirs0) {
-			char *sep = strchr(js_dirs, ',');
-			if (sep) {
-				u32 cplen = (u32) (sep-js_dirs);
-				if (cplen>=GF_MAX_PATH) cplen = GF_MAX_PATH-1;
-				strncpy(szPath, js_dirs, cplen);
-				szPathcplen=0;
-				js_dirs = sep+1;
-			} else {
-				strcpy(szPath, js_dirs);
-			}
-			//pre 1.1, $GJS was inserted by default
-			if (strcmp(szPath, "$GJS")) {
-				u32 len = (u32) strlen(szPath);
-				if (len && (szPathlen-1!='/') && (szPathlen-1!='\\'))
-					strcat(szPath, "/");
-				gf_enum_directory(szPath, GF_FALSE, jsinfo_enum, &jsi, ".js");
-			}
-			if (!sep) break;
-		}
-		return GF_TRUE;
-	}
-
-
-	if (found) return GF_TRUE;
-	if (!fname) return GF_FALSE;
-	if (!print_filter_info) return GF_FALSE;
-	if (gen_doc) return GF_FALSE;
-
-	if (argmode==GF_ARGMODE_EXPERT) {
-		l_fname = gf_strdup(fname);
-		strlwr(l_fname);
-		lf_len = (u32) strlen(l_fname);
-	}
-
-	for (i=0; i<count; i++) {
-		u32 j=0;
-		const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
-
-		while (reg->args) {
-			const GF_FilterArgs *arg = &reg->argsj;
-			if (!arg || !arg->arg_name) break;
-			j++;
-			if (argmode==GF_ARGMODE_EXPERT) {
-				if (!arg->arg_desc || !strstr_nocase(arg->arg_desc, l_fname, lf_len)) continue;
-				if (!found) {
-					GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\"%s\" is mentioned in the following filters options:\n", fname));
-					found = GF_TRUE;
-				}
-				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s \n", reg->name, arg->arg_name);
-#if 0
-
-			} else {
-				if (strcmp(arg->arg_name, fname)) continue;
-				if (!found) {
-					GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("No such filter \"%s\" but found filters with matching options:\n", fname));
-					found = GF_TRUE;
-				}
-				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s: %s\n", reg->name, arg->arg_name, arg->arg_desc);
-#endif
-			}
-		}
-	}
-	if (l_fname) gf_free(l_fname);
-
-
-	if (found) return GF_TRUE;
-
-	gpac_suggest_filter(fname, GF_TRUE, GF_FALSE);
-	return GF_FALSE;
-}
-
-static void dump_all_props(char *pname)
-{
-	u32 i=0, pname_len = pname ? (u32) strlen(pname) : 0;
-	const GF_BuiltInProperty *prop_info;
-
-	if (gen_doc==1) {
-		gf_sys_format_help(helpout, help_flags, "## Built-in property types\n"
-		" \n");
-
-		gf_sys_format_help(helpout, help_flags, "Name | Description \n");
-		gf_sys_format_help(helpout, help_flags, "--- | --- \n");
-		for (i=GF_PROP_FORBIDEN+1; i<GF_PROP_LAST_DEFINED; i++) {
-			if (i==GF_PROP_STRING_NO_COPY) continue;
-			if (i==GF_PROP_DATA_NO_COPY) continue;
-			if ((i>=GF_PROP_LAST_NON_ENUM) && (i<GF_PROP_FIRST_ENUM)) continue;
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s \n", gf_props_get_type_name(i), gf_props_get_type_desc(i) );
-		}
-
-		gf_sys_format_help(helpout, help_flags, "## Built-in properties for PIDs and packets, pixel formats and audio formats\n"
-		" \n"
-		"Flags can be:\n"
-		"- D: droppable property, see GSF multiplexer(gsfmx) filter help for more info\n"
-		"- P: property applying to packet\n"
-		" \n");
-		gf_sys_format_help(helpout, help_flags, "Name | type | Flags | Description | 4CC \n");
-		gf_sys_format_help(helpout, help_flags, "--- | --- | --- | --- | --- \n");
-	} else if (pname) {
-		gf_sys_format_help(helpout, help_flags, "Built-in properties matching `%s` for PIDs and packets listed as `Name (4CC type FLAGS): description`\n`FLAGS` can be D (droppable - see GSF multiplexer filter help), P (packet property)\n", pname);
-	} else {
-		gf_sys_format_help(helpout, help_flags, "Built-in property types\n");
-		for (i=GF_PROP_FORBIDEN+1; i<GF_PROP_LAST_DEFINED; i++) {
-			if (i==GF_PROP_STRING_NO_COPY) continue;
-			if (i==GF_PROP_DATA_NO_COPY) continue;
-			if ((i>=GF_PROP_LAST_NON_ENUM) && (i<GF_PROP_FIRST_ENUM)) continue;
-
-			if (gen_doc==2) {
-				gf_sys_format_help(helpout, help_flags, ".TP\n.B %s\n%s\n", gf_props_get_type_name(i), gf_props_get_type_desc(i));
-			} else {
-				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s : %s\n", gf_props_get_type_name(i), gf_props_get_type_desc(i) );
-			}
-		}
-		gf_sys_format_help(helpout, help_flags, "\n\n");
-
-		gf_sys_format_help(helpout, help_flags, "Built-in properties for PIDs and packets listed as `Name (4CC type FLAGS): description`\n`FLAGS` can be D (droppable - see GSF multiplexer filter help), P (packet property)\n");
-	}
-	i=0;
-	while ((prop_info = gf_props_get_description(i))) {
-		i++;
-		char szFlags10;
-		if (! prop_info->name) continue;
-
-		if (gen_doc==1) {
-			strcpy(szFlags, "");
-			if (prop_info->flags & GF_PROP_FLAG_GSF_REM) strcat(szFlags, "D");
-			if (prop_info->flags & GF_PROP_FLAG_PCK) strcat(szFlags, "P");
-
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s | %s | %s | %s \n", prop_info->name, gf_props_get_type_name(prop_info->data_type),
-				szFlags,
-			 	prop_info->description,
-			 	gf_4cc_to_str(prop_info->type)
-			);
-		} else if (gen_doc==2) {
-			gf_sys_format_help(helpout, help_flags, ".TP\n.B %s (%s,%s,%s%s)\n%s\n", prop_info->name, gf_4cc_to_str(prop_info->type), gf_props_get_type_name(prop_info->data_type),
-			 	(prop_info->flags & GF_PROP_FLAG_GSF_REM) ? "D" : " ",
-			 	(prop_info->flags & GF_PROP_FLAG_PCK) ? "P" : " ",
-				prop_info->description);
-		} else {
-			u32 len;
-			const char *ptype;
-
-			if (pname) {
-				if (gf_sys_word_match(prop_info->name, pname)) {}
-				else if (gf_strnistr(prop_info->description, pname, pname_len)) {}
-				else continue;
-			}
-			szFlags0=0;
-			if (prop_info->flags & GF_PROP_FLAG_GSF_REM) strcat(szFlags, "D");
-			if (prop_info->flags & GF_PROP_FLAG_PCK) strcat(szFlags, "P");
-
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s", prop_info->name);
-			len = (u32) strlen(prop_info->name);
-			while (len<16) {
-				gf_sys_format_help(helpout, help_flags, " ");
-				len++;
-			}
-			ptype = gf_props_get_type_name(prop_info->data_type);
-			gf_sys_format_help(helpout, help_flags, " (%s %s %s):", gf_4cc_to_str(prop_info->type), ptype, szFlags);
-			len += (u32) strlen(ptype) + (u32) strlen(szFlags);
-			while (len<24) {
-				gf_sys_format_help(helpout, help_flags, " ");
-				len++;
-			}
-
-			gf_sys_format_help(helpout, help_flags, "%s", prop_info->description);
-
-			if (prop_info->data_type==GF_PROP_PIXFMT) {
-				gf_sys_format_help(helpout, help_flags, "\n\tNames: %s\n\tFile extensions: %s", gf_pixel_fmt_all_names(), gf_pixel_fmt_all_shortnames() );
-			} else if (prop_info->data_type==GF_PROP_PCMFMT) {
-				gf_sys_format_help(helpout, help_flags, "\n\tNames: %s\n\tFile extensions: %s", gf_audio_fmt_all_names(), gf_audio_fmt_all_shortnames() );
-			} else if (gf_props_type_is_enum(prop_info->data_type)) {
-				gf_sys_format_help(helpout, help_flags, "\n\tNames: %s\n\t", gf_props_enum_all_names(prop_info->data_type) );
-			}
-			gf_sys_format_help(helpout, help_flags, "\n");
-		}
-	}
-	if (gen_doc==1) {
-		u32 idx=0;
-		u32 cicp;
-		u64 layout;
-		GF_PixelFormat pfmt;
-		const char *name, *fileext, *desc;
-		gf_sys_format_help(helpout, help_flags, "# Pixel formats\n");
-		gf_sys_format_help(helpout, help_flags, "Name | File extensions | QT 4CC | Description \n");
-		gf_sys_format_help(helpout, help_flags, " --- | --- | --- | --- \n");
-		while ( (pfmt = gf_pixel_fmt_enum(&idx, &name, &fileext, &desc) )) {
-			const char *qtname = "";
-			u32 qt_code = gf_pixel_fmt_to_qt_type(pfmt);
-			if (qt_code) qtname = gf_4cc_to_str(qt_code);
-
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s | %s | %s \n", name, fileext, qtname, desc);
-		}
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# Audio formats\n");
-		gf_sys_format_help(helpout, help_flags, " Name | File extensions | Description \n");
-		gf_sys_format_help(helpout, help_flags, " --- | --- | --- \n");
-		while ( gf_audio_fmt_enum(&idx, &name, &fileext, &desc)) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s | %s \n", name, fileext, desc);
-		}
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# Stream types\n");
-		gf_sys_format_help(helpout, help_flags, " Name | Description \n");
-		gf_sys_format_help(helpout, help_flags, " --- | --- \n");
-		while ( gf_stream_types_enum(&idx, &name, &desc)) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s \n", name, desc);
-		}
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# Codecs\n");
-		gf_sys_format_help(helpout, help_flags, "The codec name identifies a codec within GPAC. There can be several names for a given codec. The first name is used as a default file extension when dumping a raw media stream.\n"
-			" \n");
-
-		gf_sys_format_help(helpout, help_flags, " Name | Description \n");
-		gf_sys_format_help(helpout, help_flags, " --- | --- \n");
-		while ( gf_codecid_enum(idx, &name, &desc)) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR | GF_PRINTARG_ESCAPE_PIPE, "%s | %s \n", name, desc);
-			idx++;
-		}
-
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# CICP code points for audio channel layout\n");
-		gf_sys_format_help(helpout, help_flags, " Name | Integer value | ChannelMask \n");
-		gf_sys_format_help(helpout, help_flags, " --- | --- | --- \n");
-		while ( (cicp = gf_audio_fmt_cicp_enum(idx, &name, &layout)) ) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %d | 0x%016"LLX_SUF" \n", name, cicp, layout);
-			idx++;
-		}
-
-	} else if (gen_doc==2) {
-		u32 idx=0, cicp;
-		u64 layout;
-		const char *name, *fileext, *desc;
-		gf_sys_format_help(helpout, help_flags, "# Pixel formats\n");
-		while ( gf_pixel_fmt_enum(&idx, &name, &fileext, &desc)) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s (ext *.%s)\n%s\n", name, fileext, desc);
-		}
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# Audio formats\n");
-		while ( gf_audio_fmt_enum(&idx, &name, &fileext, &desc)) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s (ext *.%s)\n%s\n", name, fileext, desc);
-		}
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# Stream types\n");
-		while ( gf_stream_types_enum(&idx, &name, &desc)) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s\n%s\n", name, desc);
-		}
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# Codecs\n");
-		while ( gf_codecid_enum(idx, &name, &desc)) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s\n%s\n", name, desc);
-			idx++;
-		}
-
-		idx=0;
-		gf_sys_format_help(helpout, help_flags, "# Stream types\n");
-		while ( (cicp = gf_audio_fmt_cicp_enum(idx, &name, &layout)) ) {
-			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s (int %d)\nLayout 0x%016"LLX_SUF"\n", name, cicp, layout);
-			idx++;
-		}
-	}
-}
-#include <gpac/color.h>
-static void dump_all_colors(void)
-{
-	u32 i=0;
-	GF_Color color;
-	const char *name;
-	while (gf_color_enum(&i, &color, &name)) {
-		gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%s: 0x%08X\n", name, color);
-	}
-}
-
-static void dump_all_audio_cicp(void)
-{
-	u32 i=0, cicp;
-	const char *name;
-	u64 layout;
-
-	while ((cicp = gf_audio_fmt_cicp_enum(i, &name, &layout)) ) {
-		gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%s (%d): 0x%016"LLX_SUF"\n", name, cicp, layout);
-		i++;
-	}
-}
-
-static void dump_all_codec(GF_FilterSession *session)
-{
-	GF_PropertyValue rawp, filep, stp;
-	GF_PropertyValue cp, acp;
-	char szFlags10, szCap2;
-	u32 cidx=0;
-	u32 count = gf_fs_filters_registers_count(session);
-
-	gf_sys_format_help(helpout, help_flags, "Codec support in filters, listed as `built_in_name|variant FLAGS: full_name (mime)` with possible FLAGS values:\n");
-	gf_sys_format_help(helpout, help_flags, " - I: Raw format input (demultiplexer) support\n");
-	gf_sys_format_help(helpout, help_flags, " - O: Raw format output (multiplexer) support\n");
-	gf_sys_format_help(helpout, help_flags, " - D: Decoder support\n");
-	gf_sys_format_help(helpout, help_flags, " - E: Encoder support\n");
-	gf_sys_format_help(helpout, help_flags, "\nNote: Raw output may still be possible even when no output serializer is given\n\n");
-
-	rawp.type = cp.type = GF_PROP_UINT;
-	rawp.value.uint = GF_CODECID_RAW;
-	filep.type = cp.type = GF_PROP_UINT;
-	filep.value.uint = GF_STREAM_FILE;
-	stp.type = GF_PROP_UINT;
-	cp.type = GF_PROP_UINT;
-	acp.type = GF_PROP_UINT;
-	szCap1 = 0;
-
-	while (1) {
-		u32 i;
-		const char *lname;
-		const char *sname;
-		const char *mime;
-		u32 rfc4cc;
-		Bool enc_found = GF_FALSE;
-		Bool dec_found = GF_FALSE;
-		Bool dmx_found = GF_FALSE;
-		Bool mx_found = GF_FALSE;
-		cp.value.uint = gf_codecid_enum(cidx, &sname, &lname);
-		cidx++;
-		if (cp.value.uint == GF_CODECID_NONE) break;
-//		if (cp.value.uint == GF_CODECID_RAW) continue;
-		if (!sname) break;
-
-		stp.value.uint = gf_codecid_type(cp.value.uint);
-		acp.value.uint = gf_codecid_alt(cp.value.uint);
-
-		for (i=0; i<count; i++) {
-			const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
-			if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &stp, GF_PROP_PID_STREAM_TYPE, &stp, GF_TRUE)) {
-				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &rawp, GF_PROP_PID_CODECID, &cp, GF_TRUE)) {
-					enc_found = GF_TRUE;
-				} else if (acp.value.uint && gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &rawp, GF_PROP_PID_CODECID, &acp, GF_TRUE)) {
-						enc_found = GF_TRUE;
-				}
-				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &cp, GF_PROP_PID_CODECID, &rawp, GF_TRUE)) {
-					dec_found = GF_TRUE;
-				} else if (acp.value.uint && gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &acp, GF_PROP_PID_CODECID, &rawp, GF_TRUE)) {
-					dec_found = GF_TRUE;
-				}
-			}
-
-			if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &filep, GF_PROP_PID_STREAM_TYPE, &stp, GF_TRUE)) {
-				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &filep, GF_PROP_PID_CODECID, &cp, GF_TRUE))
-					dmx_found = GF_TRUE;
-			}
-			if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &stp, GF_PROP_PID_STREAM_TYPE, &filep, GF_TRUE)) {
-				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &cp, GF_PROP_PID_STREAM_TYPE, &filep, GF_TRUE))
-					mx_found = GF_TRUE;
-			}
-		}
-
-		szFlags0 = 0;
-		if (enc_found || dec_found || dmx_found || mx_found) {
-			strcpy(szFlags, " ");
-			if (dmx_found) { szCap0 = 'I'; strcat(szFlags, szCap); }
-			if (mx_found) { szCap0 = 'O'; strcat(szFlags, szCap); }
-			if (dec_found) { szCap0 = 'D'; strcat(szFlags, szCap); }
-			if (enc_found) { szCap0 = 'E'; strcat(szFlags, szCap); }
-			strcat(szFlags, "");
-		}
-
-		mime = gf_codecid_mime(cp.value.uint);
-		rfc4cc = gf_codecid_4cc_type(cp.value.uint);
-		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s%s: ", sname, szFlags);
-		gf_sys_format_help(helpout, help_flags, "%s", lname);
-		if (rfc4cc || mime) {
-			gf_sys_format_help(helpout, help_flags, " (");
-			if (rfc4cc) gf_sys_format_help(helpout, help_flags, "%s", gf_4cc_to_str(rfc4cc) );
-			if (rfc4cc&&mime) gf_sys_format_help(helpout, help_flags, ", ");
-			if (mime) gf_sys_format_help(helpout, help_flags, "%s", mime);
-			gf_sys_format_help(helpout, help_flags, ")");
-		}
-		gf_sys_format_help(helpout, help_flags, "\n");
-	}
-	gf_sys_format_help(helpout, help_flags, "\n");
-}
-
-/*********************************************************
-			Config file writing functions
-*********************************************************/
-
-static void write_core_options()
-{
-	//print libgpac core help
-	const GF_GPACArg *args = gf_sys_get_options();
-	u32 i = 0;
-
-	while (argsi.name) {
-		if (! gf_opts_get_key("core", argsi.name) && argsi.val) {
-			gf_opts_set_key("core", argsi.name, argsi.val);
-		}
-		i++;
-	}
-}
-
-static void write_file_extensions()
-{
-	u32 i = 0;
-
-	while (1) {
-		const char *short_name, *long_name, *mime ;
-		u32 cid = gf_codecid_enum(i, &short_name, &long_name);
-		if (cid==GF_CODECID_NONE) break;
-		mime = gf_codecid_mime(cid);
-		if (mime && ! gf_opts_get_key("file_extensions", mime) ) {
-			gf_opts_set_key("file_extensions", mime, short_name);
-		}
-		i++;
-	}
-}
-
-static void write_filters_options(GF_FilterSession *fsess)
-{
-	u32 i, count;
-	count = gf_fs_filters_registers_count(fsess);
-	for (i=0; i<count; i++) {
-		char *meta_sep;
-		u32 j=0;
-		char szSecName200;
-
-		const GF_FilterRegister *freg = gf_fs_get_filter_register(fsess, i);
-		sprintf(szSecName, "filter@%s", freg->name);
-		meta_sep = strchr(szSecName + 7, ':');
-		if (meta_sep) meta_sep0 = 0;
-
-		while (freg->args) {
-			const GF_FilterArgs *arg = &freg->argsj;
-			if (!arg || !arg->arg_name) break;
-			j++;
-
-			if (arg->arg_default_val && !gf_opts_get_key(szSecName, arg->arg_name)) {
-				gf_opts_set_key(szSecName, arg->arg_name, arg->arg_default_val);
-			}
-		}
-	}
-}
-
-/*********************************************************
-		Language file creation / update functions
-*********************************************************/
-
-static Bool lang_updated = GF_FALSE;
-static void gpac_lang_set_key(GF_Config *cfg, const char *sec_name, const char *key_name, const char *key_val)
-{
-	char szKeyCRC1024;
-	const char *opt = gf_cfg_get_key(cfg, sec_name, key_name);
-	u32 crc_key = 0;
-	if (opt) {
-		sprintf(szKeyCRC, "%s_crc", key_name);
-		const char *crc_opt = gf_cfg_get_key(cfg, sec_name, szKeyCRC);
-		if (crc_opt) {
-			u32 old_crc = atoi(crc_opt);
-			crc_key = gf_crc_32((u8*)key_val, (u32) strlen(key_val));
-			if (old_crc != crc_key) {
-				gf_sys_format_help(helpout, help_flags, "Warning: description has changed for %s:%s (crc %d - crc in file %d) - please check translation\n", sec_name, key_name, crc_key, old_crc);
-			}
-			return;
-		}
-	}
-	if (!opt) {
-		char szKeyCRCVal100;
-		if (!crc_key) {
-			sprintf(szKeyCRC, "%s_crc", key_name);
-			crc_key = gf_crc_32((u8*)key_val, (u32) strlen(key_val));
-		}
-		sprintf(szKeyCRCVal, "%u", crc_key);
-		gf_cfg_set_key(cfg, sec_name, key_name, key_val);
-		gf_cfg_set_key(cfg, sec_name, szKeyCRC, szKeyCRCVal);
-		lang_updated = GF_TRUE;
-	}
-}
-static int gpac_make_lang(char *filename)
-{
-	GF_Config *cfg;
-	u32 i;
-	gf_sys_init(GF_MemTrackerNone, NULL);
-
-	session = gf_fs_new_defaults(0);
-	if (!session) {
-		gf_sys_format_help(helpout, help_flags, "failed to load session, cannot create language file\n");
-		return 1;
-	}
-	if (!gf_file_exists(filename)) {
-		FILE *f = gf_fopen(filename, "wt");
-		if (!f) {
-			gf_sys_format_help(helpout, help_flags, "failed to open %s in write mode\n", filename);
-			gf_fs_del(session);
-			return 1;
-		}
-		gf_fclose(f);
-	}
-
-	cfg = gf_cfg_new(NULL, filename);
-
-	//print gpac help
-	i = 0;
-	while (gpac_argsi.name) {
-		gpac_lang_set_key(cfg, "gpac", gpac_argsi.name, gpac_argsi.description);
-		i++;
-	}
-
-	//print gpac doc
-	gpac_lang_set_key(cfg, "gpac", "doc", gpac_doc);
-
-	//print gpac alias doc
-	gpac_lang_set_key(cfg, "gpac", "alias", gpac_alias);
-
-	//print libgpac core help
-	const GF_GPACArg *args = gf_sys_get_options();
-	i = 0;
-
-	while (argsi.name) {
-		gpac_lang_set_key(cfg, "core", argsi.name, argsi.description);
-		i++;
-	}
-
-	//print properties
-	i=0;
-	const GF_BuiltInProperty *prop_info;
-	while ((prop_info = gf_props_get_description(i))) {
-		i++;
-		if (! prop_info->name || !prop_info->description) continue;
-		gpac_lang_set_key(cfg, "properties", prop_info->name, prop_info->description);
-	}
-
-	//print filters
-	u32 count = gf_fs_filters_registers_count(session);
-	for (i=0; i<count; i++) {
-		u32 j=0;
-		const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
-
-		if (reg->description) {
-			gpac_lang_set_key(cfg, reg->name, "desc", reg->description);
-		}
-		if (reg->help) {
-			gpac_lang_set_key(cfg, reg->name, "help", reg->help);
-		}
-		while (reg->args && reg->argsj.arg_name) {
-			gpac_lang_set_key(cfg, reg->name, reg->argsj.arg_name, reg->argsj.arg_desc);
-			j++;
-		}
-	}
-
-	if (!lang_updated) {
-		gf_cfg_discard_changes(cfg);
-		fprintf(stderr, "lang file %s has not been modified\n", filename);
-	} else {
-		fprintf(stderr, "lang file generated in %s\n", filename);
-	}
-	gf_cfg_del(cfg);
-
-	gf_fs_del(session);
-	gf_sys_close();
-	return 0;
-}
-
-
-/*********************************************************
-			Alias functions
-*********************************************************/
-
-static GFINLINE void push_arg(char *_arg, Bool _dup)
-{
-	alias_argv = gf_realloc(alias_argv, sizeof(char**) * (alias_argc+1));\
-	alias_argvalias_argc = _dup ? gf_strdup(_arg) : _arg; \
-	if (_dup) {
-		if (!args_alloc) args_alloc = gf_list_new();
-		gf_list_add(args_alloc, alias_argvalias_argc);
-	}
-	alias_argc++;
-}
-
-static Bool gpac_expand_alias_arg(char *param, char *prefix, char *suffix, int arg_idx, int argc, char **argv);
-
-static Bool check_param_extension(char *szArg, int arg_idx, int argc, char **argv)
-{
-	char *par_start = strstr(szArg, "@{");
-	if (par_start) {
-		char szPar100;
-		Bool ok;
-		char *par_end = strchr(par_start, '}');
-		if (!par_end) {
-			fprintf(stderr, "Bad format %s for alias parameter, expecting @{N}\n", szArg);
-			return GF_FALSE;
-		}
-		par_end0 = 0;
-		strcpy(szPar, par_start+2);
-		par_start0 = 0;
-
-	 	ok = gpac_expand_alias_arg(szPar, szArg, par_end+1, arg_idx, argc, argv);
-	 	if (!ok) return GF_FALSE;
-		par_start0 = '@';
-		par_end0 = '}';
-		return GF_TRUE;
-	}
-	//done, push arg
-	push_arg(szArg, 1);
-	return GF_TRUE;
-}
-
-static Bool gpac_expand_alias_arg(char *param, char *prefix, char *suffix, int arg_idx, int argc, char **argv)
-{
-	char *alias_arg=NULL;
-	char szSepList2;
-	char *oparam = param;
-	szSepList0 = separator_setSEP_LIST;
-	szSepList1 = 0;
-
-	Bool is_list = param0=='-';
-	Bool is_expand = param0=='+';
-
-	if (is_list || is_expand) param++;
-
-	gf_dynstrcat(&alias_arg, prefix, NULL);
-	while (param) {
-		u32 idx=0;
-		u32 last_idx=0;
-		char *sep = strchr(param, ',');
-		if (sep) sep0=0;
-
-		if ((param0=='n') || (param0=='N')) {
-			idx = argc - arg_idx - 1;
-			if (param1=='-') {
-				u32 diff = atoi(param+2);
-				if (diff>=idx) {
-					if (sep) sep0=',';
-					fprintf(stderr, "Bad usage for alias parameter %s: not enough parameters\n", oparam);
-					gf_free(alias_arg);
-					return GF_FALSE;
-				}
-				idx -= diff;
-			}
-		} else {
-			char *lsep = strchr(param, ':');
-			if (lsep) {
-				lsep0 = 0;
-				if (strlen(param))
-					idx = atoi(param);
-				else
-					idx=1;
-
-				lsep0 = ':';
-				if ((lsep1=='n') || (lsep1=='N')) {
-
-					last_idx = argc - arg_idx - 1;
-					if (lsep2=='-') {
-						u32 diff = atoi(lsep+3);
-						if (diff>=last_idx) {
-							fprintf(stderr, "Bad usage for alias parameter %s: not enough parameters\n", oparam);
-							gf_free(alias_arg);
-							return GF_FALSE;
-						}
-						last_idx -= diff;
-					}
-				} else {
-					last_idx = atoi(lsep+1);
-				}
-			} else {
-				idx = atoi(param);
-			}
-		}
-		if (!idx) {
-			if (sep) sep0=',';
-			fprintf(stderr, "Bad format for alias parameter %s: cannot extract argument index\n", oparam);
-			gf_free(alias_arg);
-			return GF_FALSE;
-		}
-		if ((int) idx + arg_idx >= argc) {
-			if (sep) sep0=',';
-			fprintf(stderr, "Bad format for alias parameter %s: argument out of bounds (not enough paramteters?)\n", oparam);
-			gf_free(alias_arg);
-			return GF_FALSE;
-		}
-
-		if (!last_idx) last_idx=idx;
-		for (; idx<=last_idx;idx++) {
-			char *an_arg = argvidx+arg_idx;
-
-			if (!args_used) args_used = gf_list_new();
-			gf_list_add(args_used, an_arg);
-
-			if (is_expand) {
-				gf_free(alias_arg);
-				alias_arg = NULL;
-				gf_dynstrcat(&alias_arg, prefix, NULL);
-				gf_dynstrcat(&alias_arg, an_arg, NULL);
-				gf_dynstrcat(&alias_arg, suffix, NULL);
-
-				Bool ok = check_param_extension(alias_arg, arg_idx, argc, argv);
-				if (!ok) {
-					if (sep) sep0=',';
-					gf_free(alias_arg);
-					return GF_FALSE;
-				}
-			} else {
-				gf_dynstrcat(&alias_arg, an_arg, NULL);
-				if (is_list && (idx<last_idx)) {
-					gf_dynstrcat(&alias_arg, szSepList, NULL);
-				}
-			}
-		}
-
-		if (!sep) break;
-		sep0=',';
-		param = sep+1;
-		if (is_list) {
-			gf_dynstrcat(&alias_arg, szSepList, NULL);
-		}
-	}
-
-	if (is_expand) {
-		gf_free(alias_arg);
-		return GF_TRUE;
-	}
-
-	gf_dynstrcat(&alias_arg, suffix, NULL);
-
-	Bool res = check_param_extension(alias_arg, arg_idx, argc, argv);
-	gf_free(alias_arg);
-	return res;
-}
-
-static Bool gpac_expand_alias(int o_argc, char **o_argv)
-{
-	u32 i, a_idx;
-	int argc = o_argc;
-
-	//move all options at the begining
-	char **argv = gf_malloc(sizeof(char*) * argc);
-	if (!argv) return GF_FALSE;
-
-	a_idx = 1;
-	argv0 = o_argv0;
-	for (i=1; i< (u32) argc; i++) {
-		//alias, do not push
-		if ( gf_opts_get_key("gpac.alias", o_argvi) != NULL)
-			continue;
-		//not an option, do not push
-		if (o_argvi0 != '-') continue;
-		argva_idx = o_argvi;
-		a_idx++;
-	}
-	for (i=1; i< (u32) argc; i++) {
-		//option and not an alias, do not push
-		if (o_argvi0 == '-') {
-			if ((char*) gf_opts_get_key("gpac.alias", o_argvi) == NULL)
-				continue;
-		}
-		argva_idx = o_argvi;
-		a_idx++;
-	}
-	assert(argc==a_idx);
-
-	for (i=0; i< (u32) argc; i++) {
-		char *arg = argvi;
-		char *alias = (char *) gf_opts_get_key("gpac.alias", arg);
-		if (alias == NULL) {
-			if (gf_list_find(args_used, arg)<0) {
-				push_arg(arg, 0);
-			}
-			continue;
-		}
-		char *sep;
-		while (alias) {
-			sep = strchr(alias, ' ');
-			if (sep) sep0 = 0;
-			Bool ok = check_param_extension(alias, i, argc, argv);
-			if (sep) sep0 = ' ';
-			if (!ok) {
-				gf_free(argv);
-				return GF_FALSE;
-			}
-			if (!sep) break;
-			alias = sep+1;
-		}
-	}
-	gf_free(argv);
-	return GF_TRUE;
-}
-
-#ifdef GPAC_ENABLE_COVERAGE
-#include <gpac/utf.h>
-#include <gpac/base_coding.h>
-#include <gpac/network.h>
-#include <gpac/iso639.h>
-#include <gpac/token.h>
-#include <gpac/xml.h>
-#include <gpac/thread.h>
-#include <gpac/avparse.h>
-#include <gpac/mpegts.h>
-#include <gpac/scenegraph_vrml.h>
-#include <gpac/rtp_streamer.h>
-#include <gpac/internal/odf_dev.h>
-#include <gpac/internal/media_dev.h>
-#include <gpac/internal/isomedia_dev.h>
-#endif
-static u32 gpac_unit_tests(GF_MemTrackerType mem_track)
-{
-#ifdef GPAC_ENABLE_COVERAGE
-	u32 ucs4_buf4;
-	u32 i;
-	u8 utf8_buf7;
-
-	void *mem = gf_calloc(4, sizeof(u32));
-	gf_free(mem);
-
-	if (mem_track == GF_MemTrackerNone) return 0;
-
-	gpac_fsess_task_help(); //for coverage
-	gf_dm_sess_last_error(NULL);
-	gf_log_use_color();
-	gf_4cc_parse("abcd");
-	gf_gpac_abi_micro();
-	gf_audio_fmt_get_layout_from_name("3/2.1");
-	gf_audio_fmt_get_dolby_chanmap(4);
-	gf_itags_get_id3tag(1);
-	i=0;
-	gf_itags_enum_tags(&i, NULL, NULL, NULL);
-
-	GF_LOG(GF_LOG_INFO, GF_LOG_CORE, ("CoreUnitTests performing tests\n"));
-
-	utf8_buf0 = 'a';
-	utf8_buf1 = 0;
-	if (! utf8_to_ucs4 (ucs4_buf, 1, (unsigned char *) utf8_buf)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for single char\n"));
-		return 1;
-	}
-	utf8_buf0 = 0xc2;
-	utf8_buf1 = 0xa3;
-	utf8_buf2 = 'a';
-	utf8_buf3 = 0;
-	if (! utf8_to_ucs4 (ucs4_buf, 3, (unsigned char *) utf8_buf)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 2-byte + 1-byte char\n"));
-		return 1;
-	}
-	utf8_buf0 = 0xe0;
-	utf8_buf1 = 0xa4;
-	utf8_buf2 = 0xb9;
-	utf8_buf3 = 0;
-	if (! utf8_to_ucs4 (ucs4_buf, 3, (unsigned char *) utf8_buf)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 3-byte char\n"));
-		return 1;
-	}
-	utf8_buf0 = 0xf0;
-	utf8_buf1 = 0x90;
-	utf8_buf2 = 0x8d;
-	utf8_buf3 = 0x88;
-	utf8_buf4 = 0;
-	if (! utf8_to_ucs4 (ucs4_buf, 4, (unsigned char *) utf8_buf)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 4-byte char\n"));
-		return 1;
-	}
-
-	utf8_buf0 = 0xf8;
-	utf8_buf1 = 0x80;
-	utf8_buf2 = 0x80;
-	utf8_buf3 = 0x80;
-	utf8_buf4 = 0xaf;
-	utf8_buf5 = 0;
-	if (! utf8_to_ucs4 (ucs4_buf, 5, (unsigned char *) utf8_buf)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 5-byte char\n"));
-		return 1;
-	}
-	utf8_buf0 = 0xfc;
-	utf8_buf1 = 0x80;
-	utf8_buf2 = 0x80;
-	utf8_buf3 = 0x80;
-	utf8_buf4 = 0x80;
-	utf8_buf5 = 0xaf;
-	utf8_buf6 = 0;
-	if (! utf8_to_ucs4 (ucs4_buf, 6, (unsigned char *) utf8_buf)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 6-byte char\n"));
-		return 1;
-	}
-	//test error case
-	utf8_buf0 = 0xf8;
-	utf8_to_ucs4 (ucs4_buf, 6, (unsigned char *) utf8_buf);
-
-	char buf5, obuf3;
-	obuf0 = 1;
-	obuf1 = 2;
-	u32 res = gf_base16_encode(obuf, 2, buf, 5);
-	if (res != 4) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests base16 encode fail\n"));
-		return 1;
-	}
-	u32 res2 = gf_base16_decode(buf, res, obuf, 3);
-	if (res2 != 2) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests base16 decode fail\n"));
-		return 1;
-	}
-
-	u8 *zbuf;
-	u32 osize;
-	GF_Err e;
-	u8 *ozbuf;
-
-#ifndef GPAC_DISABLE_ZLIB
-	zbuf = gf_strdup("123451234512345123451234512345");
-	osize=0;
-	e = gf_gz_compress_payload(&zbuf, 1 + (u32) strlen(zbuf), &osize);
-	if (e) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests zlib compress fail\n"));
-		gf_free(zbuf);
-		return 1;
-	}
-	ozbuf=NULL;
-	res=0;
-	e = gf_gz_decompress_payload(zbuf, osize, &ozbuf, &res);
-	gf_free(zbuf);
-	if (ozbuf) gf_free(ozbuf);
-	if (e) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests zlib decompress fail\n"));
-		return 1;
-	}
-#endif
-
-	zbuf = gf_strdup("123451234512345123451234512345");
-	osize=0;
-	e = gf_lz_compress_payload(&zbuf, 1+(u32) strlen(zbuf), &osize);
-	if (e && (e!= GF_NOT_SUPPORTED)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests lzma compress fail\n"));
-		gf_free(zbuf);
-		return 1;
-	}
-	ozbuf=NULL;
-	res=0;
-	e = gf_lz_decompress_payload(zbuf, osize, &ozbuf, &res);
-	gf_free(zbuf);
-	if (ozbuf) gf_free(ozbuf);
-	if (e && (e!= GF_NOT_SUPPORTED)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests lzma decompress fail\n"));
-		return 1;
-	}
-
-	gf_htonl(0xAABBCCDD);
-	gf_ntohl(0xAABBCCDD);
-	gf_htons(0xAABB);
-	gf_ntohs(0xAABB);
-	gf_errno_str(-1);
-
-	/* these two lock the bash shell in test mode
-	gf_prompt_set_echo_off(GF_TRUE);
-	gf_prompt_set_echo_off(GF_FALSE);
-	*/
-
-	gf_net_set_ntp_shift(-1000);
-	gf_net_get_ntp_diff_ms(gf_net_get_ntp_ts() );
-	gf_net_get_timezone();
-	gf_net_get_utc_ts(70, 1, 0, 0, 0, 0);
-	gf_net_ntp_diff_ms(1000000, 1000000);
-	gf_lang_get_count();
-	gf_lang_get_2cc(2);
-	GF_Blob b;
-	memset(&b, 0, sizeof(GF_Blob));
-	b.data = (u8 *) "test";
-	b.size = 5;
-	char url100;
-	u8 *data;
-	u32 size;
-	sprintf(url, "gmem://%p", &b);
-
-	gf_sys_profiler_set_callback(NULL, NULL);
-
-	gf_blob_get(url, &data, &size, NULL);
-	if (!data || strcmp((char *)data, "test")) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests blob url parsing fail\n"));
-		return 1;
-	}
-	gf_sys_get_battery_state(NULL, NULL, NULL, NULL, NULL);
-	gf_sys_get_process_id();
-	data = (u8 *) gf_log_get_tools_levels();
-	if (data) gf_free(data);
-
-	gf_sys_is_quiet();
-	gf_sys_get_argv();
-	gf_mx_get_num_locks(NULL);
-	signal_catched = GF_TRUE;
-
-#ifdef WIN32
-	gpac_sig_handler(CTRL_C_EVENT);
-#else
-	gpac_sig_handler(SIGINT);
-	gpac_sig_handler(SIGTERM);
-#endif
-
-	gf_mkdir("testdir");
-	gf_mkdir("testdir/somedir");
-	strcpy(url, "testdir/somedir/test.bin");
-	FILE *f=gf_fopen(url, "wb");
-	fprintf(f, "some test\n");
-#ifdef GPAC_MEMORY_TRACKING
-	gf_memory_print();
-#endif
-	gf_fclose(f);
-	gf_file_modification_time(url);
-	gf_m2ts_probe_file(url);
-
-	gf_dir_cleanup("testdir");
-	gf_rmdir("testdir");
-
-	//math.c not covered yet by our sample files
-	GF_Matrix2D mx;
-	gf_mx2d_init(mx);
-	gf_mx2d_add_skew(&mx, FIX_ONE, FIX_ONE);
-	gf_mx2d_add_skew_x(&mx, GF_PI/4);
-	gf_mx2d_add_skew_y(&mx, GF_PI/4);
-	GF_Point2D scale, translate;
-	Fixed rotate;
-	gf_mx2d_decompose(&mx, &scale, &rotate, &translate);
-	GF_Rect rc1, rc2;
-	memset(&rc1, 0, sizeof(GF_Rect));
-	memset(&rc2, 0, sizeof(GF_Rect));
-	gf_rect_equal(&rc1, &rc2);
-
-	GF_Matrix mat;
-	gf_mx_init(mat);
-	Fixed yaw, pitch, roll;
-	gf_mx_get_yaw_pitch_roll(&mat, &yaw, &pitch, &roll);
-	gf_mx_ortho_reverse_z(&mat, -20, 20, -20, 20, 0.1, 100.0);
-	gf_mx_perspective_reverse_z(&mat, 0.76, 1.0, 0.1, 100.0);
-
-	GF_Ray ray;
-	GF_Vec center, outPoint;
-	memset(&ray, 0, sizeof(GF_Ray));
-	ray.dir.z = FIX_ONE;
-	memset(&center, 0, sizeof(GF_Vec));
-	gf_ray_hit_sphere(&ray, &center, FIX_ONE, &outPoint);
-
-	gf_closest_point_to_line(center, ray.dir, center);
-
-	GF_Plane plane;
-	plane.d = FIX_ONE;
-	plane.normal = center;
-	gf_plane_intersect_line(&plane, &center, &ray.dir, &outPoint);
-
-	GF_Vec4 rot, quat;
-	rot.x = rot.y = 0;
-	rot.z = FIX_ONE;
-	rot.q = GF_PI/4;
-	quat = gf_quat_from_rotation(rot);
-	gf_quat_get_inv(&quat);
-	gf_quat_rotate(&quat, &ray.dir);
-	gf_quat_slerp(quat, quat, FIX_ONE/2);
-	GF_BBox bbox;
-	memset(&bbox, 0, sizeof(GF_BBox));
-	gf_bbox_equal(&bbox, &bbox);
-
-	GF_Vec v;
-	v.x = v.y = v.z = 0;
-	gf_vec_scale_p(&v, 2*FIX_ONE);
-
-	//token.c
-	char container1024;
-	gf_token_get_strip("12 34{ 56 : }", 0, "{:", " ", container, 1024);
-
-	//netwok.c
-	char nameGF_MAX_IP_NAME_LEN;
-	gf_sk_get_host_name(name);
-	gf_sk_set_usec_wait(NULL, 1000);
-	u32 fam;
-	u16 port;
-	//to remove once we have rtsp server back
-	gf_sk_get_local_info(NULL, &port, &fam);
-	gf_sk_receive_wait(NULL, NULL, 0, &fam, 1);
-	gf_sk_send_wait(NULL, NULL, 0, 1);
-
-	//path2D
-	GF_Path *path = gf_path_new();
-	gf_path_add_move_to(path, 0, 0);
-	gf_path_add_quadratic_to(path, 5, 5, 10, 0);
-	gf_path_point_over(path, 4, 0);
-	gf_path_del(path);
-
-	//xml dom - to update once we find a way to integrate atsc demux in tests
-	GF_DOMParser *dom = gf_xml_dom_new();
-	gf_xml_dom_parse_string(dom, "<Dummy>test</Dummy>");
-	gf_xml_dom_get_error(dom);
-	gf_xml_dom_get_line(dom);
-	gf_xml_dom_get_root_nodes_count(dom);
-	gf_xml_dom_del(dom);
-
-	//downloader - to update once we find a way to integrate atsc demux in tests
-	GF_DownloadManager *dm = gf_dm_new(NULL);
-	gf_dm_set_auth_callback(dm, NULL, NULL);
-
-	gf_dm_set_data_rate(dm, 0);
-	gf_dm_get_data_rate(dm);
-	gf_dm_set_localcache_provider(dm, NULL, NULL);
-	gf_dm_sess_abort(NULL);
-	gf_dm_del(dm);
-
-	//constants
-	gf_stream_type_afx_name(GPAC_AFX_3DMC);
-	//thread
-	gf_th_stop(NULL);
-	gf_list_swap(NULL, NULL);
-	//bitstream
-	GF_BitStream *bs = gf_bs_new("test", 4, GF_BITSTREAM_READ);
-	gf_bs_bits_available(bs);
-	gf_bs_get_bit_offset(bs);
-	gf_bs_read_vluimsbf5(bs);
-	gf_bs_del(bs);
-	//module
-	gf_module_load_static(NULL);
-
-	gf_mp3_version_name(0);
-	char tsbuf188;
-	u8 is_pes=GF_TRUE;
-	memset(tsbuf, 0, 188);
-	tsbuf0 = 0x47;
-	tsbuf1 = 0x40;
-	tsbuf4=0x00;
-	tsbuf5=0x00;
-	tsbuf6=0x01;
-	tsbuf10 = 0x80;
-	tsbuf11 = 0xc0;
-	tsbuf13 = 0x2 << 4;
-	gf_m2ts_restamp(tsbuf, 188, 1000, &is_pes);
-
-
-	gf_filter_post_task(NULL,NULL,NULL,NULL);
-	gf_filter_get_arg_str(NULL, NULL, NULL);
-	gf_filter_all_sinks_done(NULL);
-
-	gf_opts_discard_changes();
-
-	gf_rtp_reset_ssrc(NULL);
-	gf_rtp_enable_nat_keepalive(NULL, 0);
-	gf_rtp_stop(NULL);
-	gf_rtp_streamer_get_payload_type(NULL);
-	gf_rtsp_unregister_interleave(NULL, 0);
-	gf_rtsp_reset_aggregation(NULL);
-
-	get_cmd('h');
-	gpac_suggest_arg("blcksize");
-	gpac_suggest_filter("outf", GF_FALSE, GF_FALSE);
-	//todo: build tests for these two
-	gf_filter_pid_negociate_property_str(NULL, NULL, NULL);
-	gf_filter_pid_negociate_property_dyn(NULL, NULL, NULL);
-
-	gf_props_parse_type("uint");
-	//this one is just a wrapper around an internal function
-	gf_filter_pck_new_copy(NULL, NULL, NULL);
-	gf_filter_get_max_extra_input_pids(NULL);
-	gf_filter_remove(NULL);
-	gf_filter_reconnect_output(NULL);
-	gf_filter_pid_get_udta_flags(NULL);
-
-	gf_audio_fmt_get_cicp_layout(2, 1, 1);
-	gf_audio_fmt_get_layout_from_cicp(3);
-	gf_audio_fmt_get_layout_name_from_cicp(3);
-	gf_audio_fmt_get_cicp_from_layout(GF_AUDIO_CH_FRONT_LEFT|GF_AUDIO_CH_FRONT_RIGHT);
-
-	//old bifs parsing stuff
-	gf_odf_desc_del(gf_odf_desc_new(GF_ODF_ELEM_MASK_TAG));
-	GF_TextConfig *txtc = (GF_TextConfig *)gf_odf_desc_new(GF_ODF_TEXT_CFG_TAG);
-	gf_odf_get_text_config(NULL, 0, 0, txtc);
-	gf_odf_dump_txtcfg(txtc, NULL, 0, GF_FALSE);
-	gf_odf_desc_del((GF_Descriptor *) txtc);
-
-	//stuff only used by vtbdec
-	gf_hevc_read_pps_bs(NULL, NULL);
-	gf_hevc_read_sps_bs(NULL, NULL);
-	gf_hevc_read_vps_bs(NULL, NULL);
-	gf_mpegv12_get_config(NULL, 0, NULL);
-
-	//hinting stuff
-	GF_HintPacket *hpck = gf_isom_hint_pck_new(GF_ISOM_BOX_TYPE_RTCP_STSD);
-	gf_isom_hint_pck_length(hpck);
-	gf_isom_hint_pck_size(hpck);
-	GF_BitStream *hbs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-	gf_isom_hint_pck_write(hpck, hbs);
-	u8 *hbuf;
-	u32 hsize;
-	gf_bs_get_content(hbs, &hbuf, &hsize);
-	gf_bs_del(hbs);
-	hbs = gf_bs_new(hbuf, hsize, GF_BITSTREAM_READ);
-	gf_isom_hint_pck_read(hpck, hbs);
-	gf_bs_del(hbs);
-	gf_free(hbuf);
-	gf_isom_hint_pck_del(hpck);
-
-	gf_isom_last_error(NULL);
-	gf_isom_get_media_time(NULL, 0, 0, NULL);
-	gf_isom_get_sample_description_index(NULL, 0, 0);
-
-	gf_sg_has_scripting();
-	gf_node_get_proto_root(NULL);
-	gf_node_proto_is_grouping(NULL);
-	gf_sg_proto_get_id(NULL);
-	gf_sg_proto_instance_set_ised(NULL, 0, NULL, 0);
-
-	gf_audio_fmt_to_isobmf(0);
-	gf_pixel_fmt_probe(0, NULL);
-	gf_net_ntp_to_utc(0);
-	gf_sys_profiler_sampling_enabled();
-
-
-#endif
-	return 0;
-}
-
-static Bool revert_cache_file(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
-{
-	const char *url;
-	GF_Config *cached;
-	if (strncmp(item_name, "gpac_cache_", 11)) return GF_FALSE;
-	cached = gf_cfg_new(NULL, item_path);
-	url = gf_cfg_get_key(cached, "cache", "url");
-	if (url) url = strstr(url, "://");
-	if (url) {
-		u32 i, len, dir_len=0, k=0;
-		char *dst_name;
-		char *sep;
-
-		sep = strstr(item_path, "gpac_cache_");
-		if (sep) {
-			sep0 = 0;
-			dir_len = (u32) strlen(item_path);
-			sep0 = 'g';
-		}
-		url+=3;
-		len = (u32) strlen(url);
-		dst_name = gf_malloc(len+dir_len+1);
-		memset(dst_name, 0, len+dir_len+1);
-
-		strncpy(dst_name, item_path, dir_len);
-		k=dir_len;
-		for (i=0; i<len; i++) {
-			dst_namek = urli;
-			if (dst_namek==':') dst_namek='_';
-			else if (dst_namek=='/') {
-				if (!gf_dir_exists(dst_name))
-					gf_mkdir(dst_name);
-			}
-			k++;
-		}
-		sep = strrchr(item_path, '.');
-		if (sep) {
-			sep0=0;
-			if (gf_file_exists(item_path)) {
-				gf_file_move(item_path, dst_name);
-			}
-			sep0='.';
-		}
-		gf_free(dst_name);
-	}
-	gf_cfg_del(cached);
-	gf_file_delete(item_path);
-	return GF_FALSE;
-}
-
-
-typedef struct
-{
-	FILE *filep;
-	char *path;
-	Bool write;
-	u32 nb_refs;
-} FileIOCtx;
-
-static GF_List *all_gfio_defined = NULL;
-
-static GF_FileIO *fio_open(GF_FileIO *fileio_ref, const char *url, const char *mode, GF_Err *out_err);
-
-static GF_Err fio_seek(GF_FileIO *fileio, u64 offset, s32 whence)
-{
-	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
-	if (!ioctx || !ioctx->filep) return GF_BAD_PARAM;
-	gf_fseek(ioctx->filep, offset, whence);
-	return GF_OK;
-}
-static u32 fio_read(GF_FileIO *fileio, u8 *buffer, u32 bytes)
-{
-	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
-	if (!ioctx || !ioctx->filep) return 0;
-	return (u32) gf_fread(buffer, bytes, ioctx->filep);
-}
-static u32 fio_write(GF_FileIO *fileio, u8 *buffer, u32 bytes)
-{
-	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
-	if (!ioctx || !ioctx->filep) return 0;
-	if (!bytes) {
-		fflush(ioctx->filep);
-		return 0;
-	}
-	return (u32) gf_fwrite(buffer, bytes, ioctx->filep);
-}
-static s64 fio_tell(GF_FileIO *fileio)
-{
-	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
-	if (!ioctx || !ioctx->filep) return -1;
-	return gf_ftell(ioctx->filep);
-}
-static Bool fio_eof(GF_FileIO *fileio)
-{
-	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
-	if (!ioctx || !ioctx->filep) return GF_TRUE;
-	return feof(ioctx->filep);
-}
-static int fio_printf(GF_FileIO *fileio, const char *format, va_list args)
-{
-	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
-	if (!ioctx || !ioctx->filep) return -1;
-	return vfprintf(ioctx->filep, format, args);
-}
-
-static GF_FileIO *fio_open(GF_FileIO *fileio_ref, const char *url, const char *mode, GF_Err *out_err)
-{
-	GF_FileIO *gfio;
-	FileIOCtx *ioctx;
-	u32 i, count;
-	u64 file_size;
-	Bool no_concatenate = GF_FALSE;
-	FileIOCtx *ioctx_ref = gf_fileio_get_udta(fileio_ref);
-
-	*out_err = GF_OK;
-
-	if (!strcmp(mode, "ref")) {
-		ioctx_ref->nb_refs++;
-		return fileio_ref;
-	}
-	if (!strcmp(mode, "unref")) {
-		if (!ioctx_ref->nb_refs) return NULL;
-		ioctx_ref->nb_refs--;
-		if (ioctx_ref->nb_refs)
-			return fileio_ref;
-
-		url = NULL;
-	}
-
-	if (!strcmp(mode, "url")) {
-		if (!url) return NULL;
-		GF_SAFEALLOC(ioctx, FileIOCtx);
-		if (!ioctx) return NULL;
-		ioctx->path = gf_url_concatenate(ioctx_ref->path, url);
-		gfio = gf_fileio_new(ioctx->path, ioctx, fio_open, fio_seek, fio_read, fio_write, fio_tell, fio_eof, fio_printf);
-		if (!gfio) {
-			if (ioctx->path) gf_free(ioctx->path);
-			gf_free(ioctx);
-			return NULL;
-		}
-		//remember it but no need to keep a ref on it
-		gf_list_add(all_gfio_defined, gfio);
-		return gfio;
-	}
-	if (!strcmp(mode, "probe")) {
-		if (!gf_file_exists(url)) *out_err = GF_URL_ERROR;
-		return NULL;
-	}
-
-	if (!url) {
-		if (ioctx_ref->filep) gf_fclose(ioctx_ref->filep);
-		ioctx_ref->filep = NULL;
-
-		if (!ioctx_ref->nb_refs) {
-			gf_list_del_item(all_gfio_defined, fileio_ref);
-			gf_fileio_del(fileio_ref);
-			if (ioctx_ref->path) gf_free(ioctx_ref->path);
-			gf_free(ioctx_ref);
-		}
-		return NULL;
-	}
-
-	//file handle not opened, we can use the current gfio
-	if (!ioctx_ref->filep && (!strnicmp(url, "gfio://", 7) || !strcmp(url, ioctx_ref->path)) ) {
-		ioctx_ref->filep = gf_fopen(ioctx_ref->path, mode);
-		if (!ioctx_ref->filep) {
-			*out_err = GF_IO_ERR;
-			return NULL;
-		}
-		file_size = gf_fsize(ioctx_ref->filep);
-		//in test mode we want to use our ftell and fseek wrappers
-		if (strchr(mode, 'r')) {
-			gf_fileio_set_stats(fileio_ref, file_size, file_size, GF_TRUE, 0);
-		}
-		return fileio_ref;
-	}
-
-	//file handle already open (file is being opened twice), create a new gfio or check if we have already created one
-	gfio = NULL;
-	ioctx = NULL;
-	count = gf_list_count(all_gfio_defined);
-	for (i=0; i<count; i++) {
-		GF_FileIO *a_gfio = gf_list_get(all_gfio_defined, i);
-		ioctx = gf_fileio_get_udta(a_gfio);
-		if (ioctx && !strcmp(ioctx->path, url)) {
-			if (ioctx->filep) {
-				no_concatenate = GF_TRUE;
-				ioctx = NULL;
-			}
-			gfio = a_gfio;
-			break;
-		}
-		ioctx = NULL;
-	}
-	if (!ioctx) {
-		GF_SAFEALLOC(ioctx, FileIOCtx);
-		if (!ioctx) {
-			*out_err = GF_OUT_OF_MEM;
-			return NULL;
-		}
-		if (strnicmp(url, "gfio://", 7)) {
-			if (no_concatenate)
-				ioctx->path = gf_strdup(url);
-			else
-				ioctx->path = gf_url_concatenate(ioctx_ref->path, url);
-		} else {
-			ioctx->path = gf_strdup(ioctx_ref->path);
-		}
-		gfio = gf_fileio_new(ioctx->path, ioctx, fio_open, fio_seek, fio_read, fio_write, fio_tell, fio_eof, fio_printf);
-		if (!gfio) {
-			if (ioctx->path) gf_free(ioctx->path);
-			gf_free(ioctx);
-			*out_err = GF_OUT_OF_MEM;
-		}
-	}
-
-	if (strnicmp(url, "gfio://", 7)) {
-		ioctx->filep = gf_fopen(ioctx->path, mode);
-	} else {
-		ioctx->filep = gf_fopen(ioctx_ref->path, mode);
-	}
-
-	if (!ioctx->filep) {
-		*out_err = GF_IO_ERR;
-		gf_list_del_item(all_gfio_defined, gfio);
-		gf_fileio_del(gfio);
-		if (ioctx->path) gf_free(ioctx->path);
-		gf_free(ioctx);
-		return NULL;
-	}
-
-	file_size = gf_fsize(ioctx->filep);
-	if (strchr(mode, 'r'))
-		gf_fileio_set_stats(gfio, file_size,file_size, GF_TRUE, 0);
-	return gfio;
-}
-
-
-static const char *make_fileio(const char *inargs, const char **out_arg, Bool is_input, GF_Err *e)
-{
-	FileIOCtx *ioctx;
-	GF_FileIO *fio;
-	char *sep = (char *) gf_url_colon_suffix(inargs, separator_set1);
-	*out_arg = NULL;
-	if (sep) sep0 = 0;
-
-	GF_SAFEALLOC(ioctx, FileIOCtx);
-	if (!ioctx) return NULL;
-	ioctx->path = gf_strdup(inargs);
-	if (!ioctx->path) {
-		gf_free(ioctx);
-		return NULL;
-	}
-	if (sep) {
-		sep0 = ':';
-		*out_arg = sep+1;
-	}
-	fio = gf_fileio_new(ioctx->path, ioctx, fio_open, fio_seek, fio_read, fio_write, fio_tell, fio_eof, fio_printf);
-	if (!fio) {
-		gf_free(ioctx->path);
-		gf_free(ioctx);
-		*e = GF_OUT_OF_MEM;
-		return NULL;
-	}
-	if (!all_gfio_defined) {
-		all_gfio_defined = gf_list_new();
-		if (!all_gfio_defined) return NULL;
-	}
-	gf_list_add(all_gfio_defined, fio);
-	//keep alive until end
-	ioctx->nb_refs = 1;
-	return gf_fileio_url(fio);
-}
-
-static void cleanup_file_io()
-{
-	if (!all_gfio_defined) return;
-	while (gf_list_count(all_gfio_defined)) {
-		GF_FileIO *gfio = gf_list_pop_back(all_gfio_defined);
-		FileIOCtx *ioctx = gf_fileio_get_udta(gfio);
-		gf_fileio_del(gfio);
-
-		if (ioctx->filep) {
-			fprintf(stderr, "Warning: file IO for %s still opened!\n", ioctx->path);
-			gf_fclose(ioctx->filep);
-		}
-		if (ioctx->path) gf_free(ioctx->path);
-		gf_free(ioctx);
-	}
-	gf_list_del(all_gfio_defined);
-	all_gfio_defined = NULL;
-}
-
-static GF_Err cust_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
-{
-	GF_FilterEvent evt;
-	if (is_remove) return GF_OK;
-
-	GF_FEVT_INIT(evt, GF_FEVT_PLAY, pid);
-	gf_filter_pid_send_event(pid, &evt);
-	gf_filter_pid_set_framing_mode(pid, GF_TRUE);
-	return GF_OK;
-}
-static GF_Err cust_process(GF_Filter *filter)
-{
-	u32 i;
-	for (i=0; i<gf_filter_get_ipid_count(filter); i++) {
-		GF_FilterPid *pid = gf_filter_get_ipid(filter, i);
-		const char *name = gf_filter_pid_get_name(pid);
-		while (1) {
-			GF_FilterPacket *pck = gf_filter_pid_get_packet(pid);
-			if (!pck) break;
-			fprintf(stderr, "PID %s Got packet CTS "LLU"\n", name, gf_filter_pck_get_cts(pck));
-			gf_filter_pid_drop_packet(pid);
-		}
-	}
-	return GF_OK;
-}
-
-static GF_Filter *load_custom_filter(GF_FilterSession *sess, char *opts, GF_Err *e)
-{
-	GF_Filter *f = gf_fs_new_filter(sess, "custom", 0, e);
-	if (!f) return NULL;
-
-	*e = gf_filter_push_caps(f, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_VISUAL), NULL, GF_CAPS_INPUT, 0);
-	if (*e) return NULL;
-	*e = gf_filter_set_configure_ckb(f, cust_configure_pid);
-	if (*e) return NULL;
-	*e = gf_filter_set_process_ckb(f, cust_process);
-	if (*e) return NULL;
-	*e = gf_filter_set_process_event_ckb(f, NULL);
-	if (*e) return NULL;
-	*e = gf_filter_set_reconfigure_output_ckb(f, NULL);
-	if (*e) return NULL;
-	*e = gf_filter_set_probe_data_cbk(f, NULL);
-	if (*e) return NULL;
-
-	return f;
-}

gpac-2.0.0.tar.gz/applications/mp4box/main.c Deleted

@@ -1,6588 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2022
- *					All rights reserved
- *
- * This file is part of GPAC / mp4box application
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-#include "mp4box.h"
-
-#ifdef GPAC_DISABLE_ISOM
-
-#error "Cannot compile MP4Box if GPAC is not built with ISO File Format support"
-
-#else
-
-#if defined(WIN32) && !defined(_WIN32_WCE)
-#include <io.h>
-#include <fcntl.h>
-#endif
-
-#include <gpac/media_tools.h>
-#include <gpac/main.h>
-
-/*RTP packetizer flags*/
-#ifndef GPAC_DISABLE_STREAMING
-#include <gpac/ietf.h>
-#endif
-
-#ifndef GPAC_DISABLE_CRYPTO
-#include <gpac/crypt_tools.h>
-#endif
-
-#include <gpac/constants.h>
-#include <gpac/filters.h>
-
-#include <gpac/mpd.h>
-
-#define BUFFSIZE	8192
-#define DEFAULT_INTERLEAVING_IN_SEC 0.5
-
-//undefine to check validity of defined args' syntax
-//#define TEST_ARGS
-
-
-int mp4boxTerminal(int argc, char **argv);
-
-static u32 mp4box_cleanup(u32 ret_code);
-
-/*
- * 		START OF ARGUMENT VALUES DECLARATION
- */
-
-
-
-typedef struct
-{
-	GF_ISOTrackID trackID;
-	char *line;
-} SDPLine;
-
-typedef enum {
-	META_ACTION_SET_TYPE			= 0,
-	META_ACTION_ADD_ITEM			= 1,
-	META_ACTION_REM_ITEM			= 2,
-	META_ACTION_SET_PRIMARY_ITEM	= 3,
-	META_ACTION_SET_XML				= 4,
-	META_ACTION_SET_BINARY_XML		= 5,
-	META_ACTION_REM_XML				= 6,
-	META_ACTION_DUMP_ITEM			= 7,
-	META_ACTION_DUMP_XML			= 8,
-	META_ACTION_ADD_IMAGE_ITEM		= 9,
-	META_ACTION_ADD_IMAGE_DERIVED	= 10,
-} MetaActionType;
-
-typedef struct {
-	u32 ref_item_id;
-	u32 ref_type;
-} MetaRef;
-
-typedef struct
-{
-	MetaActionType act_type;
-	Bool root_meta, use_dref;
-	GF_ISOTrackID trackID;
-	u32 meta_4cc;
-	char *szPath, *szName, *mime_type, *enc_type, *keep_props;
-	u32 item_id;
-	Bool primary;
-	Bool replace;
-	u32 item_type;
-	u32 ref_item_id;
-	GF_List *item_refs;
-	u32 group_id;
-	u32 group_type;
-	GF_ImageItemProperties *image_props;
-} MetaAction;
-
-
-typedef enum {
-	TRACK_ACTION_REM_TRACK= 0,
-	TRACK_ACTION_SET_LANGUAGE,
-	TRACK_ACTION_SET_DELAY,
-	TRACK_ACTION_SET_KMS_URI,
-	TRACK_ACTION_SET_PAR,
-	TRACK_ACTION_SET_HANDLER_NAME,
-	TRACK_ACTION_ENABLE,
-	TRACK_ACTION_DISABLE,
-	TRACK_ACTION_REFERENCE,
-	TRACK_ACTION_RAW_EXTRACT,
-	TRACK_ACTION_REM_NON_RAP,
-	TRACK_ACTION_SET_KIND,
-	TRACK_ACTION_REM_KIND,
-	TRACK_ACTION_SET_ID,
-	TRACK_ACTION_SET_UDTA,
-	TRACK_ACTION_SWAP_ID,
-	TRACK_ACTION_REM_NON_REFS,
-	TRACK_ACTION_SET_CLAP,
-	TRACK_ACTION_SET_MX,
-	TRACK_ACTION_SET_EDITS,
-	TRACK_ACTION_SET_TIME,
-	TRACK_ACTION_SET_MEDIA_TIME,
-} TrackActionType;
-
-typedef struct
-{
-	TrackActionType act_type;
-	GF_ISOTrackID trackID;
-	char lang10;
-	GF_Fraction delay;
-	const char *kms;
-	const char *hdl_name;
-	s32 par_num, par_den;
-	u8 force_par, rewrite_bs;
-	u32 dump_type, sample_num;
-	char *out_name;
-	char *src_name;
-	char *string;
-	u32 udta_type;
-	char *kind_scheme, *kind_value;
-	u32 newTrackID;
-	s32 clap_wnum, clap_wden, clap_hnum, clap_hden, clap_honum, clap_hoden, clap_vonum, clap_voden;
-	s32 mx9;
-	u64 time;
-	u8 dump_track_type;
-} TrackAction;
-
-enum
-{
-	GF_ISOM_CONV_TYPE_ISMA = 1,
-	GF_ISOM_CONV_TYPE_ISMA_EX,
-	GF_ISOM_CONV_TYPE_3GPP,
-	GF_ISOM_CONV_TYPE_IPOD,
-	GF_ISOM_CONV_TYPE_PSP,
-	GF_ISOM_CONV_TYPE_MOV
-};
-
-typedef enum {
-	TSEL_ACTION_SET_PARAM = 0,
-	TSEL_ACTION_REMOVE_TSEL = 1,
-	TSEL_ACTION_REMOVE_ALL_TSEL_IN_GROUP = 2,
-} TSELActionType;
-
-typedef struct
-{
-	TSELActionType act_type;
-	GF_ISOTrackID trackID;
-
-	GF_ISOTrackID refTrackID;
-	u32 criteria30;
-	u32 nb_criteria;
-	Bool is_switchGroup;
-	u32 switchGroupID;
-} TSELAction;
-
-GF_FileType get_file_type_by_ext(char *inName);
-
-
-char outfileGF_MAX_PATH;
-#ifndef GPAC_DISABLE_SCENE_ENCODER
-GF_SMEncodeOptions smenc_opts;
-u32 swf_flags = GF_SM_SWF_SPLIT_TIMELINE;
-#endif
-GF_Fraction import_fps;
-
-//things to free upon cleanup
-MetaAction *metas = NULL;
-TrackAction *tracks = NULL;
-TSELAction *tsel_acts = NULL;
-SDPLine *sdp_lines = NULL;
-u32 *brand_add = NULL;
-u32 *brand_rem = NULL;
-char **mpd_base_urls = NULL;
-u32 nb_mpd_base_urls = 0;
-GF_DashSegmenterInput *dash_inputs = NULL;
-u32 nb_dash_inputs = 0;
-
-
-
-//all other options values - keep options with assignment other than 0 on a single line
-
-FILE *helpout = NULL;
-u32 help_flags = 0;
-
-Double interleaving_time=0.0, split_duration=0.0, split_start=-1.0, dash_duration=0.0, dash_subduration=0.0, swf_flatten_angle=0.0;
-Bool dash_duration_strict=0, dvbhdemux=0, keep_sys_tracks=0;
-
-u64 initial_tfdt=0;
-s32 subsegs_per_sidx=0, laser_resolution=0, ast_offset_ms=0;
-const char *split_range_str = NULL;
-GF_DashSwitchingMode bitstream_switching_mode = GF_DASH_BSMODE_DEFAULT;
-u32 stat_level=0, hint_flags=0, info_track_id=0, import_flags=0, nb_add=0, nb_cat=0, crypt=0, agg_samples=0, nb_sdp_ex=0, max_ptime=0, split_size=0, nb_meta_act=0, nb_track_act=0, rtp_rate=0, major_brand=0, nb_alt_brand_add=0, nb_alt_brand_rem=0, old_interleave=0, minor_version=0, conv_type=0, nb_tsel_acts=0, program_number=0, dump_nal=0, time_shift_depth=0, initial_moof_sn=0, dump_std=0, import_subtitle=0, dump_saps=0, dump_saps_mode=0, force_new=0;
-GF_DashDynamicMode dash_mode=GF_DASH_STATIC;
-#ifndef GPAC_DISABLE_SCENE_DUMP
-GF_SceneDumpFormat dump_mode=GF_SM_DUMP_NONE;
-#endif
-
-/*align cat is the new default behavior for -cat*/
-Bool align_cat=GF_TRUE;
-
-Double mpd_live_duration=0;
-Bool do_hint=0, do_save=0, full_interleave=0, do_frag=0, hint_interleave=0, dump_rtp=0, regular_iod=0, remove_sys_tracks=0, remove_hint=0, remove_root_od=0;
-Bool print_sdp=0, open_edit=0, dump_cr=0, force_ocr=0, encode=0, do_scene_log=0, dump_srt=0, dump_ttxt=0, do_saf=0, dump_m2ts=0, dump_cart=0, dump_chunk=0, dump_check_xml=0;
-Bool do_hash=0, verbose=0, force_cat=0, pack_wgt=0, single_group=0, clean_groups=0, dash_live=0, no_fragments_defaults=0;
-Bool single_traf_per_moof=0, tfdt_per_traf=0, hls_clock=0, do_mpd_rip=0, merge_vtt_cues=0, get_nb_tracks=0;
-u32 compress_moov=0;
-char *inName=NULL, *outName=NULL, *mediaSource=NULL, *input_ctx=NULL, *output_ctx=NULL, *drm_file=NULL, *avi2raw=NULL, *cprt=NULL;
-char *chap_file=NULL, *chap_file_qt=NULL, *itunes_tags=NULL, *pack_file=NULL, *raw_cat=NULL, *seg_name=NULL, *dash_ctx_file=NULL;
-char *compress_top_boxes=NULL, *high_dynamc_range_filename=NULL, *use_init_seg=NULL, *box_patch_filename=NULL, *udp_dest = NULL;
-
-GF_ISOTrackID trackID=0;
-u32 track_dump_type=0, dump_isom=0, dump_timestamps=0, dump_nal_type=0, do_flat=0, box_patch_trackID=0, print_info=0;
-Bool no_inplace=0, merge_last_seg=0, freeze_box_order=0, no_odf_conf=0;
-Double min_buffer = 1.5;
-u32 size_top_box=0, fs_dump_flags=0, dump_chap=0, dump_udta_type=0, dump_udta_track=0, moov_pading=0, sdtp_in_traf=0, segment_marker=0, timescale=0;
-
-u32 dash_scale = 1000;
-GF_ISOFile *file = NULL;
-
-Bool insert_utc=0, chunk_mode=0, HintCopy=0, hint_no_offset=0, do_bin_xml=0, frag_real_time=0, force_co64=0, live_scene=0, use_mfra=0;
-Bool dump_iod=0, samplegroups_in_traf=0, mvex_after_traks=0, daisy_chain_sidx=0, use_ssix=0, single_segment=0, single_file=0, segment_timeline=0;
-Bool has_add_image=0;
-
-char *do_mpd_conv=NULL;
-u32 MTUSize = 1450;
-char *dash_start_date=NULL;
-GF_DASH_ContentLocationMode cp_location_mode = GF_DASH_CPMODE_ADAPTATION_SET;
-Double mpd_update_time = 0.0;
-GF_MemTrackerType mem_track = GF_MemTrackerNone;
-GF_DASHPSSHMode pssh_mode=0;
-
-GF_DashProfile dash_profile=GF_DASH_PROFILE_AUTO;
-char *dash_profile_extension = NULL;
-char *dash_cues = NULL;
-Bool strict_cues=0, use_url_template=0, seg_at_rap=0, frag_at_rap=0, memory_frags=0, keep_utc=0, has_next_arg=0, no_cache=0, no_loop=0;
-u32 adjust_split_end=0;
-char *do_wget = NULL;
-char *mux_name = NULL;
-char *seg_ext = NULL;
-char *init_seg_ext = NULL;
-char *dash_title = NULL;
-char *dash_source = NULL;
-char *dash_more_info = NULL;
-
-FILE *logfile = NULL;
-u32 run_for=0, dash_cumulated_time=0, dash_prev_time=0, dash_now_time=0;
-GF_DASH_SplitMode dash_split_mode = GF_DASH_SPLIT_OUT;
-
-
-typedef u32 (*parse_arg_fun)(char *arg_val, u32 param);
-typedef u32 (*parse_arg_fun2)(char *arg_name, char *arg_val, u32 param);
-
-//other custom option parsing functions definitions are in mp4box.h
-static u32 parse_meta_args(char *opts, MetaActionType act_type);
-static Bool parse_tsel_args(char *opts, TSELActionType act);
-
-
-
-/*
- * 		START OF ARGS PARSING AND HELP
- */
-
-
-Bool print_version(char *arg_val, u32 param)
-{
-	fprintf(stderr, "MP4Box - GPAC version %s\n"
-	 "%s\n"
-	 "GPAC Configuration: " GPAC_CONFIGURATION "\n"
-	 "Features: %s %s\n", gf_gpac_version(), gf_gpac_copyright_cite(), gf_sys_features(GF_FALSE), gf_sys_features(GF_TRUE));
-	return GF_TRUE;
-}
-
-//arg will toggle open_edit
-#define ARG_OPEN_EDIT		1
-//arg will toggle do_save
-#define ARG_NEED_SAVE		1<<1
-#define ARG_NO_INPLACE		1<<2
-#define ARG_BIT_MASK		1<<3
-#define ARG_BIT_MASK_REM	1<<4
-#define ARG_HAS_VALUE		1<<5
-#define ARG_DIV_1000		1<<6
-#define ARG_NON_ZERO		1<<7
-#define ARG_64BITS			1<<8
-#define ARG_IS_4CC			1<<9
-#define ARG_BOOL_REV		1<<10
-#define ARG_INT_INC			1<<11
-#define ARG_IS_FUN			1<<12
-#define ARG_EMPTY			1<<13
-#define ARG_PUSH_SYSARGS	1<<14
-#define ARG_IS_FUN2			1<<15
-
-
-
-typedef struct
-{
-	GF_GPAC_ARG_BASE
-
-	void *arg_ptr;
-	u32 argv_val;
-	u16 parse_flags;
-} MP4BoxArg;
-
-#define MP4BOX_ARG(_a, _c, _f, _g, _h, _i, _j) {_a, NULL, _c, NULL, NULL, _f, _g, _h, _i, _j}
-#define MP4BOX_ARG_ALT(_a, _b, _c, _f, _g, _h, _i, _j) {_a, _b, _c, NULL, NULL, _f, _g, _h, _i, _j}
-#define MP4BOX_ARG_S(_a, _s, _c, _g, _h, _i, _j) {_a, NULL, _c, _s, NULL, GF_ARG_CUSTOM, _g, _h, _i, _j}
-#define MP4BOX_ARG_S_ALT(_a, _b, _s, _c, _g, _h, _i, _j) {_a, _b, _c, _s, NULL, GF_ARG_CUSTOM, _g, _h, _i, _j}
-
-
-MP4BoxArg m4b_gen_args =
-{
-#ifdef GPAC_MEMORY_TRACKING
- 	MP4BOX_ARG("mem-track", "enable memory tracker", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, NULL, 0, 0),
- 	MP4BOX_ARG("mem-track-stack", "enable memory tracker with stack dumping", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, NULL, 0, 0),
-#endif
- 	MP4BOX_ARG("p", "use indicated profile for the global GPAC config. If not found, config file is created. If a file path is indicated, this will load profile from that file. Otherwise, this will create a directory of the specified name and store new config there. Reserved name `0` means a new profile, not stored to disk. Works using -p=NAME or -p NAME", GF_ARG_STRING, GF_ARG_HINT_EXPERT, NULL, 0, 0),
- 	{"inter", NULL, "interleave file, producing track chunks with given duration in ms. A value of 0 disables interleaving ", "0.5", NULL, GF_ARG_DOUBLE, 0, parse_store_mode, 0, ARG_IS_FUN},
- 	MP4BOX_ARG("old-inter", "same as -inter() but without drift correction", GF_ARG_DOUBLE, GF_ARG_HINT_EXPERT, parse_store_mode, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("tight", "tight interleaving (sample based) of the file. This reduces disk seek operations but increases file size", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &full_interleave, 0, ARG_OPEN_EDIT|ARG_NEED_SAVE),
- 	MP4BOX_ARG("flat", "store file with all media data first, non-interleaved. This speeds up writing time when creating new files", GF_ARG_BOOL, 0, &do_flat, 0, ARG_NO_INPLACE),
- 	MP4BOX_ARG("frag", "fragment file, producing track fragments of given duration in ms. This disables interleaving", GF_ARG_DOUBLE, 0, parse_store_mode, 2, ARG_IS_FUN),
- 	MP4BOX_ARG("out", "specify ISOBMFF output file name. By default input file is overwritten", GF_ARG_STRING, 0, &outName, 0, 0),
- 	MP4BOX_ARG("co64","force usage of 64-bit chunk offsets for ISOBMF files", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &force_co64, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("new", "force creation of a new destination file", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &force_new, 0, 0),
- 	MP4BOX_ARG("newfs", "force creation of a new destination file without temp file but interleaving support", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, parse_store_mode, 3, ARG_IS_FUN),
- 	MP4BOX_ARG_ALT("no-sys", "nosys", "remove all MPEG-4 Systems info except IOD, kept for profiles. This is the default when creating regular AV content", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &remove_sys_tracks, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("no-iod", "remove MPEG-4 InitialObjectDescriptor from file", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &remove_root_od, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("mfra", "insert movie fragment random offset when fragmenting file (ignored in dash mode)", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &use_mfra, 0, 0),
- 	MP4BOX_ARG("isma", "rewrite the file as an ISMA 1.0 file", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_ISMA, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("ismax", "same as -isma() and remove all clock references", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_ISMA_EX, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("3gp", "rewrite as 3GPP(2) file (no more MPEG-4 Systems Info), always enabled if destination file extension is `.3gp`, `.3g2` or `.3gpp`. Some tracks may be removed in the process", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_3GPP, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("ipod", "rewrite the file for iPod/old iTunes", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_IPOD, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("psp", "rewrite the file for PSP devices", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_PSP, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("brand", "set major brand of file (`ABCD`) or brand with optional version (`ABCD:v`)", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_brand, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("ab", "add given brand to file's alternate brand list", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_brand, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("rb", "remove given brand to file's alternate brand list", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_brand, 2, ARG_IS_FUN),
- 	MP4BOX_ARG("cprt", "add copyright string to file", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &cprt, 0, 0),
- 	MP4BOX_ARG("chap", "set chapter information from given file. The following formats are supported (but cannot be mixed) in the chapter text file:\n"
-		" - ZoomPlayer: `AddChapter(nb_frames,chapter name)`, `AddChapterBySeconds(nb_sec,chapter name)` and `AddChapterByTime(h,m,s,chapter name)` with 1 chapter per line\n"
-		" - Time codes: `h:m:s chapter_name`, `h:m:s:ms chapter_name` and `h:m:s.ms chapter_name` with 1 chapter per line\n"
-		" - SMPTE codes: `h:m:s;nb_f/fps chapter_name` and `h:m:s;nb_f chapter_name` with `nb_f` the number of frames and `fps` the framerate with 1 chapter per line\n"
-		" - Common syntax: `CHAPTERX=h:m:s:ms or .ms` on first line and `CHAPTERXNAME=name` on next line (reverse order accepted)", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &chap_file, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("chapqt", "set chapter information from given file, using QT signaling for text tracks", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &chap_file_qt, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG_S("set-track-id", "id1:id2", "change id of track with id1 to id2", 0, parse_track_action, TRACK_ACTION_SET_ID, ARG_IS_FUN),
- 	MP4BOX_ARG_S("swap-track-id", "id1:id2", "swap the id between tracks with id1 to id2", 0, parse_track_action, TRACK_ACTION_SWAP_ID, ARG_IS_FUN),
- 	MP4BOX_ARG("rem", "remove given track from file", GF_ARG_INT, 0, parse_track_action, TRACK_ACTION_REM_TRACK, ARG_IS_FUN),
- 	MP4BOX_ARG("rap", "remove all non-RAP samples from given track", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_rap_ref, 0, ARG_IS_FUN | ARG_EMPTY),
- 	MP4BOX_ARG("refonly", "remove all non-reference pictures from given track", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_rap_ref, 1, ARG_IS_FUN | ARG_EMPTY),
- 	MP4BOX_ARG("enable", "enable given track", GF_ARG_INT, 0, parse_track_action, TRACK_ACTION_ENABLE, ARG_IS_FUN),
- 	MP4BOX_ARG("disable", "disable given track", GF_ARG_INT, 0, parse_track_action, TRACK_ACTION_DISABLE, ARG_IS_FUN),
- 	{"timescale", NULL, "set movie timescale to given value (ticks per second)", "600", NULL, GF_ARG_INT, 0, &timescale, 0, ARG_OPEN_EDIT},
- 	MP4BOX_ARG_S("lang", "tkID=LAN", "set language. LAN is the BCP-47 code (eng, en-UK, ...). If no track ID is given, sets language to all tracks", 0, parse_track_action, TRACK_ACTION_SET_LANGUAGE, ARG_IS_FUN),
- 	MP4BOX_ARG_S("delay", "tkID=TIME", "set track start delay (>0) or initial skip (<0) in ms or in fractional seconds (`N/D`)", 0, parse_track_action, TRACK_ACTION_SET_DELAY, ARG_IS_FUN),
- 	MP4BOX_ARG_S("par", "tkID=PAR", "set visual track pixel aspect ratio. PAR is:\n"
-					" - N:D: set PAR to N:D in track, do not modify the bitstream\n"
-					" - wN:D: set PAR to N:D in track and try to modify the bitstream\n"
-					" - none: remove PAR info from track, do not modify the bitstream\n"
-					" - auto: retrieve PAR info from bitstream and set it in track\n"
-					" - force: force 1:1 PAR in track, do not modify the bitstream", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_PAR, ARG_IS_FUN
-					),
- 	MP4BOX_ARG_S("clap", "tkID=CLAP", "set visual track clean aperture. CLAP is `Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd` or `none`\n"
- 			"- n, d: numerator, denominator\n"
-	 "- W, H, HO, VO: clap width, clap height, clap horizontal offset, clap vertical offset\n"
- 			, GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_CLAP, ARG_IS_FUN),
- 	MP4BOX_ARG_S("mx", "tkID=MX", "set track matrix, with MX is M1:M2:M3:M4:M5:M6:M7:M8:M9 in 16.16 fixed point integers or hexa"
- 			, GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_MX, ARG_IS_FUN),
-	MP4BOX_ARG_S("kind", "tkID=schemeURI=value", "set kind for the track or for all tracks using `all=schemeURI=value`", 0, parse_track_action, TRACK_ACTION_SET_KIND, ARG_IS_FUN),
-	MP4BOX_ARG_S("kind-rem", "tkID=schemeURI=value", "remove kind if given schemeID for the track or for all tracks with `all=schemeURI=value`", 0, parse_track_action, TRACK_ACTION_REM_KIND, ARG_IS_FUN),
- 	MP4BOX_ARG_S("name", "tkID=NAME", "set track handler name to NAME (UTF-8 string)", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_HANDLER_NAME, ARG_IS_FUN),
- 	MP4BOX_ARG("itags", "set iTunes tags to file, see `-h tags`", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &itunes_tags, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("group-add", "create a new grouping information in the file. Format is a colon-separated list of following options:\n"
-	 "- refTrack=ID: ID of the track used as a group reference. If not set, the track will belong to the same group as the "
-	 "previous trackID specified. If 0 or no previous track specified, a new alternate group will be created\n"
-	 "- switchID=ID: ID of the switch group to create. If 0, a new ID will be computed for you. If <0, disables SwitchGroup\n"
-	 "- criteria=string: list of space-separated 4CCs\n"
-	 "- trackID=ID: ID of the track to add to this group\n"
-	 " \n"
-	 "Warning: Options modify state as they are parsed, `trackID=1:criteria=lang:trackID=2` is different from `criteria=lang:trackID=1:trackID=2`"
-	 "\n", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_tsel_args, TSEL_ACTION_SET_PARAM, ARG_IS_FUN),
-
-	MP4BOX_ARG("group-rem-track", "remove given track from its group", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_tsel_args, TSEL_ACTION_REMOVE_TSEL, ARG_IS_FUN),
-	MP4BOX_ARG("group-rem", "remove the track's group", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_tsel_args, TSEL_ACTION_REMOVE_ALL_TSEL_IN_GROUP, ARG_IS_FUN),
-	MP4BOX_ARG("group-clean", "remove all group information from all tracks", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &clean_groups, 0, ARG_OPEN_EDIT),
-	MP4BOX_ARG_S("ref", "id:XXXX:refID", "add a reference of type 4CC from track ID to track refID", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_REFERENCE, ARG_IS_FUN),
-	MP4BOX_ARG("keep-utc", "keep UTC timing in the file after edit", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &keep_utc, 0, 0),
-	MP4BOX_ARG_S("udta", "tkID:OPTS", "set udta for given track or movie if tkID is 0. OPTS is a colon separated list of:\n"
-	 "- type=CODE: 4CC code of the UDTA (not needed for `box=` option)\n"
-	 "- box=FILE: location of the udta data, formatted as serialized boxes\n"
-	 "- box=base64,DATA: base64 encoded udta data, formatted as serialized boxes\n"
-	 "- src=FILE: location of the udta data (will be stored in a single box of type CODE)\n"
-	 "- src=base64,DATA: base64 encoded udta data (will be stored in a single box of type CODE)\n"
-	 "- str=STRING: use the given string as payload for the udta box\n"
-	 "Note: If no source is set, UDTA of type CODE will be removed\n", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_UDTA, ARG_IS_FUN|ARG_OPEN_EDIT),
-	MP4BOX_ARG_S("patch", "tkID=FILE", "apply box patch described in FILE, for given trackID if set", GF_ARG_HINT_ADVANCED, parse_boxpatch, 0, ARG_IS_FUN),
-	MP4BOX_ARG("bo", "freeze the order of boxes in input file", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &freeze_box_order, 0, 0),
-	MP4BOX_ARG("init-seg", "use the given file as an init segment for dumping or for encryption", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &use_init_seg, 0, 0),
-	MP4BOX_ARG("zmov", "compress movie box according to ISOBMFF box compression", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, parse_compress, 0, ARG_IS_FUN),
-	MP4BOX_ARG("xmov", "same as zmov and wraps ftyp in otyp", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, parse_compress, 1, ARG_IS_FUN),
- 	MP4BOX_ARG_S("edits", "tkID=EDITS", "set edit list. The following syntax is used (no separators between entries):\n"
-			" - `r`: removes all edits\n"
-			" - `eSTART`: add empty edit with given start time. START can be\n"
-			" - `VAL`: start time in seconds (int, double, fraction), media duration used as edit duration\n"
-			" - `VAL-DUR`: start time and duration in seconds (int, double, fraction)\n"
-			" - `eSTART,MEDIA,RATE`: add regular edit with given start, media start time in seconds (int, double, fraction) and rate (fraction or INT)\n"
-			" - Examples: \n"
-			" - `re0-5e5-3,4`: remove edits, add empty edit at 0s for 5s, then add regular edit at 5s for 3s starting at 4s in media track\n"
-			" - `re0-4,0,0.5`: remove edits, add single edit at 0s for 4s starting at 0s in media track and playing at speed 0.5\n"
-				, 0, parse_track_action, TRACK_ACTION_SET_EDITS, ARG_IS_FUN),
- 	MP4BOX_ARG("moovpad", "specify amount of padding to keep after moov box for later inplace editing - if 0, moov padding is disabled", GF_ARG_INT, GF_ARG_HINT_EXPERT, &moov_pading, 0, ARG_NEED_SAVE),
- 	MP4BOX_ARG("no-inplace", "disable inplace rewrite", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &no_inplace, 0, 0),
- 	MP4BOX_ARG("hdr", "update HDR information based on given XML, 'none' removes HDR info", GF_ARG_STRING, GF_ARG_HINT_EXPERT, &high_dynamc_range_filename, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG_S("time", "tkID=DAY/MONTH/YEAR-H:M:S", "set movie or track creation time", GF_ARG_HINT_EXPERT, parse_track_action, TRACK_ACTION_SET_TIME, ARG_IS_FUN),
- 	MP4BOX_ARG_S("mtime", "tkID=DAY/MONTH/YEAR-H:M:S", "set media creation time", GF_ARG_HINT_EXPERT, parse_track_action, TRACK_ACTION_SET_MEDIA_TIME, ARG_IS_FUN),
-	{0}
-};
-
-void PrintGeneralUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# General Options\n"
-		"MP4Box is a multimedia packager, with a vast number of functionalities: conversion, splitting, hinting, dumping, DASH-ing, encryption, transcoding and others.\n"
-		"MP4Box provides a large set of options, classified by categories (see -h()). These options do not follow any particular ordering.\n"
-		" \n"
-		"By default, MP4Box rewrites the input file. You can change this behavior by using the -out() option.\n"
-		"MP4Box stores by default the file with 0.5 second interleaving and meta-data (`moov` ...) at the beginning, making it suitable for HTTP download-and-play. This may however takes longer to store the file, use -flat() to change this behavior.\n"
-		" \n"
-		"MP4Box usually generates a temporary file when creating a new IsoMedia file. The location of this temporary file is OS-dependent, and it may happen that the drive/partition the temporary file is created on has not enough space or no write access. In such a case, you can specify a temporary file location with -tmp().\n"
-		" \n"
-		"Option values:\n"
-		"Unless specified otherwise, an option of type `integer` expects a trackID value following it."
-		"An option of type `boolean` expects no following value."
-		"Note: Track operations identify tracks through their ID (usually referred to as tkID in the help), not their order.\n"
-		" \n"
-	);
-
-
-	while (m4b_gen_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_gen_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-gen");
-	}
-}
-
-
-MP4BoxArg m4b_split_args =
-{
- 	MP4BOX_ARG("split", "split in files of given max duration (float number) in seconds. A trailing unit can be specified:\n"
-	"- `M`, `m`: duration is in minutes\n"
-	"- `H`, `h`: size is in hours", GF_ARG_STRING, 0, parse_split, 0, ARG_IS_FUN),
-	MP4BOX_ARG_ALT("split-rap", "splitr", "split in files at each new RAP", GF_ARG_STRING, 0, parse_split, 1, ARG_IS_FUN),
-	MP4BOX_ARG_ALT("split-size", "splits", "split in files of given max size (integer number) in kilobytes. A trailing unit can be specified:\n"
-	"- `M`, `m`: size is in megabytes\n"
-	"- `G`, `g`: size is in gigabytes", GF_ARG_STRING, 0, parse_split, 2, ARG_IS_FUN),
-	MP4BOX_ARG_ALT("split-chunk", "splitx", "extract the specified time range as follows:\n"
-	"- the start time is moved to the RAP sample closest to the specified start time\n"
-	"- the end time is kept as requested"
-		, GF_ARG_STRING, 0, parse_split, 3, ARG_IS_FUN),
-	MP4BOX_ARG("splitz", "extract the specified time range so that ranges `A:B` and `B:C` share exactly the same boundary `B`:\n"
-	"- the start time is moved to the RAP sample at or after the specified start time\n"
-	"- the end time is moved to the frame preceding the RAP sample at or following the specified end time"
-		, GF_ARG_STRING, 0, parse_split, 4, ARG_IS_FUN),
-	MP4BOX_ARG("splitg", "extract the specified time range as follows:\n"
-	"- the start time is moved to the RAP sample at or before the specified start time\n"
-	"- the end time is moved to the frame preceding the RAP sample at or following the specified end time"
-		, GF_ARG_STRING, 0, parse_split, 5, ARG_IS_FUN),
-	MP4BOX_ARG("splitf", "extract the specified time range and insert edits such that the extracted output is exactly the specified range\n", GF_ARG_STRING, 0, parse_split, 6, ARG_IS_FUN),
-	{0}
-};
-
-
-static void PrintSplitUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, " \n"
-		"# File splitting\n"
-		"MP4Box can split input files by size, duration or extract a given part of the file to new IsoMedia file(s).\n"
-		"This requires that at most one track in the input file has non random-access points (typically one video track at most).\n"
-		"Splitting will ignore all MPEG-4 Systems tracks and hint tracks, but will try to split private media tracks.\n"
-		"The input file must have enough random access points in order to be split. If this is not the case, you will have to re-encode the content.\n"
-		"You can add media to a file and split it in the same pass. In this case, the destination file (the one which would be obtained without splitting) will not be stored.\n"
-		" \n"
-		"Time ranges are specified as follows:\n"
-		"- `S-E`: `S` start and `E` end times, formatted as `HH:MM:SS.ms`, `MM:SS.ms` or time in seconds (int, double, fraction)\n"
-		"- `S:E`: `S` start time and `E` end times in seconds (int, double, fraction)\n"
-		"- `S:end` or `S:end-N`: `S` start time in seconds (int, double), `N` number of seconds (int, double) before the end\n"
-		" \n"
-		"MP4Box splitting runs a filter session using the `reframer` filter as follows:\n"
-		"- `splitrange` option of the reframer is always set\n"
-		"- source is demultiplexed with `alltk` option set\n"
-		"- start and end ranges are passed to `xs` and `xe` options of the reframer\n"
-		"- for `-splitz`, options `xadjust` and `xround=after` are enforced\n"
-		"- for `-splitg`, options `xadjust` and `xround=before` are enforced\n"
-		"- for `-splitf`, option `xround=seek` is enforced and `propbe_ref`set if not specified at prompt\n"
-		"- for `-splitx`, option `xround=closest` and `propbe_ref` are enforced if not specified at prompt\n"
-		" \n"
-		"The default output storage mode is to full interleave and will require a temp file for each output. This behavior can be modified using `-flat`, `-newfs`, `-inter` and `-frag`.\n"
-		"The output file name(s) can be specified using `-out` and templates (e.g. `-out split$num%%04d$.mp4` produces split0001.mp4, split0002.mp4, ...).\n"
-		" \n"
-	);
-
-	i=0;
-	while (m4b_split_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_split_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-split");
-	}
-
-}
-
-
-MP4BoxArg m4b_dash_args =
-{
- 	MP4BOX_ARG ("dash", "create DASH from input files with given segment (subsegment for onDemand profile) duration in ms", GF_ARG_DOUBLE, 0, &dash_duration, 0, ARG_NON_ZERO),
- 	MP4BOX_ARG("dash-live", "generate a live DASH session using the given segment duration in ms; using `-dash-live=F` will also write the live context to `F`. MP4Box will run the live session until `q` is pressed or a fatal error occurs", GF_ARG_DOUBLE, 0, parse_dashlive, 0, ARG_IS_FUN2),
- 	MP4BOX_ARG("ddbg-live", "same as -dash-live() without time regulation for debug purposes", GF_ARG_DOUBLE, 0, parse_dashlive, 1, ARG_IS_FUN2),
-	MP4BOX_ARG("frag", "specify the fragment duration in ms. If not set, this is the DASH duration (one fragment per segment)", GF_ARG_DOUBLE, 0, parse_store_mode, 2, ARG_IS_FUN),
-	MP4BOX_ARG("out", "specify the output MPD file name", GF_ARG_STRING, 0, &outName, 0, 0),
-	MP4BOX_ARG_ALT("profile", "dash-profile", "specify the target DASH profile, and set default options to ensure conformance to the desired profile. Default profile is `full` in static mode, `live` in dynamic mode (old syntax using `:live` instead of `.live` as separator still possible). Defined values are onDemand, live, main, simple, full, hbbtv1.5.live, dashavc264.live, dashavc264.onDemand, dashif.ll", GF_ARG_STRING, 0, parse_dash_profile, 0, ARG_IS_FUN),
-	MP4BOX_ARG("profile-ext", "specify a list of profile extensions, as used by DASH-IF and DVB. The string will be colon-concatenated with the profile used", GF_ARG_STRING, 0, &dash_profile_extension, 0, 0),
-	MP4BOX_ARG("rap", "ensure that segments begin with random access points, segment durations might vary depending on the source encoding", GF_ARG_BOOL, 0, parse_rap_ref, 0, ARG_IS_FUN | ARG_EMPTY),
-	MP4BOX_ARG("frag-rap", "ensure that all fragments begin with random access points (duration might vary depending on the source encoding)", GF_ARG_BOOL, 0, &frag_at_rap, 0, 0),
-	MP4BOX_ARG("segment-name", "set the segment name for generated segments. If not set (default), segments are concatenated in output file except in `live` profile where `dash_%%s`. Supported replacement strings are:\n"
-	 "- $Number%%0Nd$ is replaced by the segment number, possibly prefixed with 0\n"
-	 "- $RepresentationID$ is replaced by representation name\n"
-	 "- $Time$ is replaced by segment start time\n"
-	 "- $Bandwidth$ is replaced by representation bandwidth\n"
-	 "- $Init=NAME$ is replaced by NAME for init segment, ignored otherwise\n"
-	 "- $Index=NAME$ is replaced by NAME for index segments, ignored otherwise\n"
-	 "- $Path=PATH$ is replaced by PATH when creating segments, ignored otherwise\n"
-	 "- $Segment=NAME$ is replaced by NAME for media segments, ignored for init segments", GF_ARG_STRING, 0, &seg_name, 0, 0),
-	{"segment-ext", NULL, "set the segment extension, `null` means no extension", "m4s", NULL, GF_ARG_STRING, 0, &seg_ext, 0, 0},
-	{"init-segment-ext", NULL, "set the segment extension for init, index and bitstream switching segments, `null` means no extension\n", "mp4", NULL, GF_ARG_STRING, 0, &init_seg_ext, 0, 0},
-	MP4BOX_ARG("segment-timeline", "use `SegmentTimeline` when generating segments", GF_ARG_BOOL, 0, &segment_timeline, 0, 0),
-	MP4BOX_ARG("segment-marker", "add a box of given type (4CC) at the end of each DASH segment", GF_ARG_STRING, 0, &segment_marker, 0, ARG_IS_4CC),
-	MP4BOX_ARG("insert-utc", "insert UTC clock at the beginning of each ISOBMF segment", GF_ARG_BOOL, 0, &insert_utc, 0, 0),
-	MP4BOX_ARG("base-url", "set Base url at MPD level. Can be used several times. \nWarning: this does not modify generated files location", GF_ARG_STRING, 0, parse_base_url, 0, ARG_IS_FUN),
-	MP4BOX_ARG("mpd-title", "set MPD title", GF_ARG_STRING, 0, &dash_title, 0, 0),
-	MP4BOX_ARG("mpd-source", "set MPD source", GF_ARG_STRING, 0, &dash_source, 0, 0),
-	MP4BOX_ARG("mpd-info-url", "set MPD info url", GF_ARG_STRING, 0, &dash_more_info, 0, 0),
- 	MP4BOX_ARG("cprt", "add copyright string to MPD", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &cprt, 0, 0),
-	MP4BOX_ARG("dash-ctx", "store/restore DASH timing from indicated file", GF_ARG_STRING, 0, &dash_ctx_file, 0, 0),
-	MP4BOX_ARG("dynamic", "use dynamic MPD type instead of static", GF_ARG_BOOL, 0, &dash_mode, GF_DASH_DYNAMIC, 0),
-	MP4BOX_ARG("last-dynamic", "same as -dynamic() but close the period (insert lmsg brand if needed and update duration)", GF_ARG_BOOL, 0, &dash_mode, GF_DASH_DYNAMIC_LAST, 0),
-	MP4BOX_ARG("mpd-duration", "set the duration in second of a live session (if `0`, you must use -mpd-refresh())", GF_ARG_DOUBLE, 0, &mpd_live_duration, 0, 0),
-	MP4BOX_ARG("mpd-refresh", "specify MPD update time in seconds", GF_ARG_DOUBLE, 0, &mpd_update_time, 0, 0),
-	MP4BOX_ARG("time-shift", "specify MPD time shift buffer depth in seconds, `-1` to keep all files)", GF_ARG_INT, 0, &time_shift_depth, 0, 0),
-	MP4BOX_ARG("subdur", "specify maximum duration in ms of the input file to be dashed in LIVE or context mode. This does not change the segment duration, but stops dashing once segments produced exceeded the duration. If there is not enough samples to finish a segment, data is looped unless -no-loop() is used which triggers a period end", GF_ARG_DOUBLE, 0, &dash_subduration, 0, 0),
-	MP4BOX_ARG("run-for", "run for given ms the dash-live session then exits", GF_ARG_INT, 0, &run_for, 0, 0),
-	MP4BOX_ARG("min-buffer", "specify MPD min buffer time in ms", GF_ARG_INT, 0, &min_buffer, 0, ARG_DIV_1000),
-	MP4BOX_ARG("ast-offset", "specify MPD AvailabilityStartTime offset in ms if positive, or availabilityTimeOffset of each representation if negative", GF_ARG_INT, 0, &ast_offset_ms, 0, 0),
-	MP4BOX_ARG("dash-scale", "specify that timing for -dash(), -dash-live(), -subdur() and -do_frag() are expressed in given timescale (units per seconds) rather than ms", GF_ARG_INT, 0, &dash_scale, 0, ARG_NON_ZERO),
-	MP4BOX_ARG("mem-frags", "fragmentation happens in memory rather than on disk before flushing to disk", GF_ARG_BOOL, 0, &memory_frags, 0, 0),
-	MP4BOX_ARG("pssh", "set pssh store mode\n"
-	"- v: initial movie\n"
-	"- f: movie fragments\n"
-	"- m: MPD\n"
-	"- mv, vm: in initial movie and MPD\n"
-	"- mf, fm: in movie fragments and MPD", GF_ARG_INT, 0, parse_pssh, 0, ARG_IS_FUN),
-	MP4BOX_ARG("sample-groups-traf", "store sample group descriptions in traf (duplicated for each traf). If not set, sample group descriptions are stored in the initial movie", GF_ARG_BOOL, 0, &samplegroups_in_traf, 0, 0),
-	MP4BOX_ARG("mvex-after-traks", "store `mvex` box after `trak` boxes within the moov box. If not set, `mvex` is before", GF_ARG_BOOL, 0, &mvex_after_traks, 0, 0),
-	MP4BOX_ARG("sdtp-traf", "use `sdtp` box in `traf` (Smooth-like)\n"
-	"- no: do not use sdtp\n"
-	"- sdtp: use sdtp box to indicate sample dependencies and do not write info in trun sample flags\n"
-	"- both: use sdtp box to indicate sample dependencies and also write info in trun sample flags\n", GF_ARG_INT, 0, parse_sdtp, 0, ARG_IS_FUN),
-	MP4BOX_ARG("no-cache", "disable file cache for dash inputs", GF_ARG_BOOL, 0, &no_cache, 0, 0),
-	MP4BOX_ARG("no-loop", "disable looping content in live mode and uses period switch instead", GF_ARG_BOOL, 0, &no_loop, 0, 0),
-	MP4BOX_ARG("hlsc", "insert UTC in variant playlists for live HLS", GF_ARG_BOOL, 0, &hls_clock, 0, 0),
-	MP4BOX_ARG("bound", "segmentation will always try to split before or at, but never after, the segment boundary", GF_ARG_BOOL, 0, &dash_split_mode, GF_DASH_SPLIT_IN, 0),
-	MP4BOX_ARG("closest", "segmentation will use the closest frame to the segment boundary (before or after)", GF_ARG_BOOL, 0, &dash_split_mode, GF_DASH_SPLIT_CLOSEST, 0),
-	MP4BOX_ARG_ALT("subsegs-per-sidx", "frags-per-sidx", "set the number of subsegments to be written in each SIDX box\n"
-	"- 0: a single SIDX box is used per segment\n"
-	"- -1: no SIDX box is used", GF_ARG_INT, GF_ARG_HINT_EXPERT, &subsegs_per_sidx, 0, 0),
-	MP4BOX_ARG("ssix", "enable SubsegmentIndexBox describing 2 ranges, first one from moof to end of first I-frame, second one unmapped. This does not work with daisy chaining mode enabled", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &use_ssix, 0, 0),
-	MP4BOX_ARG("url-template", "use SegmentTemplate instead of explicit sources in segments. Ignored if segments are stored in the output file", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &use_url_template, 1, 0),
-	MP4BOX_ARG("url-template-sim", "use SegmentTemplate simulation while converting HLS to MPD", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &use_url_template, 2, 0),
-	MP4BOX_ARG("daisy-chain", "use daisy-chain SIDX instead of hierarchical. Ignored if frags/sidx is 0", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &daisy_chain_sidx, 0, 0),
-	MP4BOX_ARG("single-segment", "use a single segment for the whole file (OnDemand profile)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &single_segment, 0, 0),
-	{"single-file", NULL, "use a single file for the whole file (default)", "yes", NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &single_file, 0, 0},
-	{"bs-switching", NULL, "set bitstream switching mode\n"
-	"- inband: use inband param set and a single init segment\n"
-	"- merge: try to merge param sets in a single sample description, fallback to `no`\n"
-	"- multi: use several sample description, one per quality\n"
-	"- no: use one init segment per quality\n"
-	"- pps: use out of band VPS,SPS,DCI, inband for PPS,APS and a single init segment\n"
-	"- single: to test with single input", "inband", "inband|merge|multi|no|single", GF_ARG_STRING, GF_ARG_HINT_EXPERT, parse_bs_switch, 0, ARG_IS_FUN},
-	MP4BOX_ARG("moof-sn", "set sequence number of first moof to given value", GF_ARG_INT, GF_ARG_HINT_EXPERT, &initial_moof_sn, 0, 0),
-	MP4BOX_ARG("tfdt", "set TFDT of first traf to given value in SCALE units (cf -dash-scale)", GF_ARG_INT, GF_ARG_HINT_EXPERT, &initial_tfdt, 0, ARG_64BITS),
-	MP4BOX_ARG("no-frags-default", "disable default fragments flags in trex (required by some dash-if profiles and CMAF/smooth streaming compatibility)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &no_fragments_defaults, 0, 0),
-	MP4BOX_ARG("single-traf", "use a single track fragment per moof (smooth streaming and derived specs may require this)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &single_traf_per_moof, 0, 0),
-	MP4BOX_ARG("tfdt-traf", "use a tfdt per track fragment (when -single-traf is used)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &tfdt_per_traf, 0, 0),
-	MP4BOX_ARG("dash-ts-prog", "program_number to be considered in case of an MPTS input file", GF_ARG_INT, GF_ARG_HINT_EXPERT, &program_number, 0, 0),
-	MP4BOX_ARG("frag-rt", "when using fragments in live mode, flush fragments according to their timing", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &frag_real_time, 0, 0),
-	MP4BOX_ARG("cp-location", "set ContentProtection element location\n"
-	 "- as: sets ContentProtection in AdaptationSet element\n"
-	 "- rep: sets ContentProtection in Representation element\n"
-	 "- both: sets ContentProtection in both elements", GF_ARG_STRING, GF_ARG_HINT_EXPERT, parse_cp_loc, 0, ARG_IS_FUN),
-	MP4BOX_ARG("start-date", "for live mode, set start date (as xs:date, e.g. YYYY-MM-DDTHH:MM:SSZ). Default is current UTC\n"
-	"Warning: Do not use with multiple periods, nor when DASH duration is not a multiple of GOP size", GF_ARG_STRING, GF_ARG_HINT_EXPERT, &dash_start_date, 0, 0),
-	MP4BOX_ARG("cues", "ignore dash duration and segment according to cue times in given XML file (tests/media/dash_cues for examples)", GF_ARG_STRING, GF_ARG_HINT_EXPERT, &dash_cues, 0, 0),
-	MP4BOX_ARG("strict-cues", "throw error if something is wrong while parsing cues or applying cue-based segmentation", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &strict_cues, 0, 0),
-	MP4BOX_ARG("merge-last-seg", "merge last segment if shorter than half the target duration", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &merge_last_seg, 0, 0),
-	{0}
-};
-
-void PrintDASHUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# DASH Options\n"
-		"Also see:\n"
-		"- the dasher `gpac -h dash`(dasher) filter documentation\n"
-		"- DASH wiki|DASH-intro.\n"
-		"\n"
-		"# Specifying input files\n"
-		"Input media files to dash can use the following modifiers\n"
-		"- #trackID=N: only use the track ID N from the source file\n"
-		"- #N: only use the track ID N from the source file (mapped to -tkid(mp4dmx))\n"
-		"- #video: only use the first video track from the source file\n"
-		"- #audio: only use the first audio track from the source file\n"
-		"- :id=NAME: set the representation ID to NAME. Reserved value `NULL` disables representation ID for multiplexed inputs. If not set, a default value is computed and all selected tracks from the source will be in the same output multiplex.\n"
-		"- :dur=VALUE: process VALUE seconds (fraction) from the media. If VALUE is longer than media duration, last sample duration is extended.\n"
-		"- :period=NAME: set the representation's period to NAME. Multiple periods may be used. Periods appear in the MPD in the same order as specified with this option\n"
-		"- :BaseURL=NAME: set the BaseURL. Set multiple times for multiple BaseURLs\nWarning: This does not modify generated files location (see segment template).\n"
-		"- :bandwidth=VALUE: set the representation's bandwidth to a given value\n"
-		"- :pdur=VALUE: sets the duration of the associated period to VALUE seconds (fraction) (alias for period_duration:VALUE). This is only used when no input media is specified (remote period insertion), e.g. `:period=X:xlink=Z:pdur=Y`\n"
-		"- :ddur=VALUE: override target DASH segment duration to VALUE seconds (fraction) for this input (alias for duration:VALUE)\n"
-		"- :xlink=VALUE: set the xlink value for the period containing this element. Only the xlink declared on the first rep of a period will be used\n"
-		"- :asID=VALUE: set the AdaptationSet ID to NAME\n"
-		"- :role=VALUE: set the role of this representation (cf DASH spec). Media with different roles belong to different adaptation sets.\n"
-		"- :desc_p=VALUE: add a descriptor at the Period level. Value must be a properly formatted XML element.\n"
-		"- :desc_as=VALUE: add a descriptor at the AdaptationSet level. Value must be a properly formatted XML element. Two input files with different values will be in different AdaptationSet elements.\n"
-		"- :desc_as_c=VALUE: add a descriptor at the AdaptationSet level. Value must be a properly formatted XML element. Value is ignored while creating AdaptationSet elements.\n"
-		"- :desc_rep=VALUE: add a descriptor at the Representation level. Value must be a properly formatted XML element. Value is ignored while creating AdaptationSet elements.\n"
-		"- :sscale: force movie timescale to match media timescale of the first track in the segment.\n"
-		"- :trackID=N: only use the track ID N from the source file\n"
-		"- @f1:args@fN:args@@fK:args: set a filter chain to insert between the source and the dasher. Each filter in the chain is formatted as a regular filter, see filter doc `gpac -h doc`(filters_general). If several filters are set:\n"
-		" - they will be chained in the given order if separated by a single `@`\n"
-		" - a new filter chain will be created if separated by a double `@@`. In this case, no representation ID is assigned to the source.\n"
-		"EX source.mp4:@c=avc:b=1M@@c=avc:b=500k\n"
-		"This will load a filter chain with two encoders connected to the source and to the dasher.\n"
-		"EX source.mp4:@c=avc:b=1M@c=avc:b=500k\n"
-		"This will load a filter chain with the second encoder connected to the output of the first (!!).\n"
-		"\n"
-		"Note: `@f` must be placed after all other options.\n"
-		"\n"
-		"# Options\n"
-		);
-
-
-	while (m4b_dash_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_dash_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-dash");
-	}
-}
-
-
-MP4BoxArg m4b_imp_args =
-{
-	MP4BOX_ARG("add", "add given file tracks to file. Multiple inputs can be specified using `+`, e.g. `-add url1+url2`", GF_ARG_STRING, 0, &nb_add, 0, ARG_INT_INC),
-	MP4BOX_ARG("cat", "concatenate given file samples to file, creating tracks if needed. Multiple inputs can be specified using `+`, e.g/ `-cat url1+url2`. \nNote: This aligns initial timestamp of the file to be concatenated", GF_ARG_STRING, 0, &nb_cat, 0, ARG_INT_INC),
- 	MP4BOX_ARG("catx", "same as -cat() but new tracks can be imported before concatenation by specifying `+ADD_COMMAND` where `ADD_COMMAND` is a regular -add() syntax", GF_ARG_STRING, 0, &nb_cat, 0, ARG_INT_INC),
- 	MP4BOX_ARG("catpl", "concatenate files listed in the given playlist file (one file per line, lines starting with # are comments). \nNote: Each listed file is concatenated as if called with -cat", GF_ARG_STRING, 0, &nb_cat, 0, ARG_INT_INC),
- 	MP4BOX_ARG("unalign-cat", "do not attempt to align timestamps of samples in-between tracks", GF_ARG_BOOL, 0, &align_cat, 0, ARG_BOOL_REV),
- 	MP4BOX_ARG("force-cat", "skip media configuration check when concatenating file. \nWarning: THIS MAY BREAK THE CONCATENATED TRACK(S)", GF_ARG_BOOL, 0, &force_cat, 0, 0),
- 	MP4BOX_ARG("keep-sys", "keep all MPEG-4 Systems info when using -add() and -cat() (only used when adding IsoMedia files)", GF_ARG_BOOL, 0, &keep_sys_tracks, 0, 0),
-	MP4BOX_ARG("dref", "keep media data in original file using `data referencing`. The resulting file only contains the meta-data of the presentation (frame sizes, timing, etc...) and references media data in the original file. This is extremely useful when developing content, since importing and storage of the MP4 file is much faster and the resulting file much smaller. \nNote: Data referencing may fail on some files because it requires the framed data (e.g. an IsoMedia sample) to be continuous in the original file, which is not always the case depending on the original interleaving or bitstream format (__AVC__ or __HEVC__ cannot use this option)", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_USE_DATAREF, ARG_BIT_MASK),
- 	MP4BOX_ARG_ALT("no-drop", "nodrop", "force constant FPS when importing AVI video", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_NO_FRAME_DROP, ARG_BIT_MASK),
- 	MP4BOX_ARG("packed", "force packed bitstream when importing raw MPEG-4 part 2 Advanced Simple Profile", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_FORCE_PACKED, ARG_BIT_MASK),
- 	MP4BOX_ARG("sbr", "backward compatible signaling of AAC-SBR", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_SBR_IMPLICIT, ARG_BIT_MASK),
- 	MP4BOX_ARG("sbrx", "non-backward compatible signaling of AAC-SBR", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_SBR_EXPLICIT, ARG_BIT_MASK),
- 	MP4BOX_ARG("ps", "backward compatible signaling of AAC-PS", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_PS_IMPLICIT, ARG_BIT_MASK),
- 	MP4BOX_ARG("psx", "non-backward compatible signaling of AAC-PS", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_PS_EXPLICIT, ARG_BIT_MASK),
- 	MP4BOX_ARG("ovsbr", "oversample SBR import (SBR AAC, PS AAC and oversampled SBR cannot be detected at import time)", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_OVSBR, ARG_BIT_MASK),
- 	MP4BOX_ARG("fps", "force frame rate for video and SUB subtitles import to the given value, expressed as a number, as `TS-inc` or `TS/inc`. \nNote: For raw H263 import, default FPS is `15`, otherwise `25`. This is ignored for ISOBMFF import, use `:rescale` option for that", GF_ARG_STRING, 0, parse_fps, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("mpeg4", "force MPEG-4 sample descriptions when possible. For AAC, forces MPEG-4 AAC signaling even if MPEG-2", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_FORCE_MPEG4, ARG_BIT_MASK),
- 	MP4BOX_ARG("agg", "aggregate N audio frames in 1 sample (3GP media only, maximum value is 15)", GF_ARG_INT, 0, &agg_samples, 0, 0),
-	{0}
-};
-
-
-static MP4BoxArg m4b_imp_fileopt_args = {
-	GF_DEF_ARG("dur", NULL, "`XC` import only the specified duration from the media. Value can be:\n"
-		" - positive float: specifies duration in seconds\n"
-		" - fraction: specifies duration as NUM/DEN fraction\n"
-		" - negative integer: specifies duration in number of coded frames", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("start", NULL, "`C` target start time in source media, may not be supported depending on the source", NULL, NULL, GF_ARG_DOUBLE, 0),
-	GF_DEF_ARG("lang", NULL, "`S` set imported media language code", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("delay", NULL, "`S` set imported media initial delay (>0) or initial skip (<0) in ms or as fractional seconds (`N/D`)", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("par", NULL, "`S` set visual pixel aspect ratio (see -par(MP4B_GEN) )", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("clap", NULL, "`S` set visual clean aperture (see -clap(MP4B_GEN) )", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("mx", NULL, "`S` set track matrix (see -mx(MP4B_GEN) )", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("name", NULL, "`S` set track handler name", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("ext", NULL, "override file extension when importing", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("hdlr", NULL, "`S` set track handler type to the given code point (4CC)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("stype", NULL, "`S` force sample description type to given code point (4CC), may likely break the file", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("tkhd", NULL, "`S` set track header flags has hex integer or as comma-separated list of `enable`, `movie`, `preview`, `size_ar` keywords (use `tkhd+=FLAGS` to add and `tkhd-=FLAGS` to remove)", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("disable", NULL, "`S` disable imported track(s), use `disable=no` to force enabling a disabled track", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("group", NULL, "`S` add the track as part of the G alternate group. If G is 0, the first available GroupID will be picked", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("fps", NULL, "same as -fps()", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("rap", NULL, "`DS` import only RAP samples", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("refs", NULL, "`DS` import only reference pictures", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("trailing", NULL, "keep trailing 0-bytes in AVC/HEVC samples", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("agg", NULL, "`X` same as -agg()", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("dref", NULL, "`XC` same as -dref()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("keep_refs", NULL, "`C` keep track reference when importing a single track", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("nodrop", NULL, "same as -nodrop()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("packed", NULL, "`X` same as -packed()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("sbr", NULL, "same as -sbr()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("sbrx", NULL, "same as -sbrx()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("ovsbr", NULL, "same as -ovsbr()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("ps", NULL, "same as -ps()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("psx", NULL, "same as -psx()", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("asemode", NULL, "`XS` set the mode to create the AudioSampleEntry. Value can be:\n"
-		" - v0-bs: use MPEG AudioSampleEntry v0 and the channel count from the bitstream (even if greater than 2) - default\n"
-		" - v0-2: use MPEG AudioSampleEntry v0 and the channel count is forced to 2\n"
-		" - v1: use MPEG AudioSampleEntry v1 and the channel count from the bitstream\n"
-		" - v1-qt: use QuickTime Sound Sample Description Version 1 and the channel count from the bitstream (even if greater than 2). This will also trigger using alis data references instead of url, even for non-audio tracks", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("audio_roll", NULL, "`S` add a roll sample group with roll_distance `N` for audio tracks", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("roll", NULL, "`S` add a roll sample group with roll_distance `N`", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("proll", NULL, "`S` add a preroll sample group with roll_distance `N`", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("mpeg4", NULL, "`X` same as -mpeg4() option", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("nosei", NULL, "discard all SEI messages during import", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("svc", NULL, "import SVC/LHVC with explicit signaling (no AVC base compatibility)", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("nosvc", NULL, "discard SVC/LHVC data when importing", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("svcmode", NULL, "`DS` set SVC/LHVC import mode. Value can be:\n"
-		" - split: each layer is in its own track\n"
-		" - merge: all layers are merged in a single track\n"
-		" - splitbase: all layers are merged in a track, and the AVC base in another\n"
-		" - splitnox: each layer is in its own track, and no extractors are written\n"
-		" - splitnoxib: each layer is in its own track, no extractors are written, using inband param set signaling", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("temporal", NULL, "`DS` set HEVC/LHVC temporal sublayer import mode. Value can be:\n"
-		" - split: each sublayer is in its own track\n"
-		" - splitbase: all sublayers are merged in a track, and the HEVC base in another\n"
-		" - splitnox: each layer is in its own track, and no extractors are written", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("subsamples", NULL, "add SubSample information for AVC+SVC", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("deps", NULL, "import sample dependency information for AVC and HEVC", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("ccst", NULL, "`S` add default HEIF ccst box to visual sample entry", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("forcesync", NULL, "force non IDR samples with I slices (OpenGOP or GDR) to be marked as sync points\n"
-		"Warning: RESULTING FILE IS NOT COMPLIANT WITH THE SPEC but will fix seeking in most players", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("xps_inband", NULL, "`XC` set xPS inband for AVC/H264 and HEVC (for reverse operation, re-import from raw media)", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("xps_inbandx", NULL, "`XC` same as xps_inband and also keep first xPS in sample description", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("au_delim", NULL, "keep AU delimiter NAL units in the imported file", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("max_lid", NULL, "set HEVC max layer ID to be imported to `N` (by default imports all layers)", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("max_tid", NULL, "set HEVC max temporal ID to be imported to `N` (by default imports all temporal sublayers)", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("tiles", NULL, "`S` add HEVC tiles signaling and NALU maps without splitting the tiles into different tile tracks", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("split_tiles", NULL, "`DS` split HEVC tiles into different tile tracks, one tile (or all tiles of one slice) per track", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("negctts", NULL, "`S` use negative CTS-DTS offsets (ISO4 brand). Use `negctts=no` to force using positive offset on existing track", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("chap", NULL, "`S` specify the track is a chapter track", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("chapter", NULL, "`S` add a single chapter (old nero format) with given name lasting the entire file", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("chapfile", NULL, "`S` add a chapter file (old nero format)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("layout", NULL, "`S` specify the track layout as `WxHxXxYxLAYER`. If `W` (resp `H`) is 0, the max width (resp height) of the tracks in the file are used", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("rescale", NULL, "`S` force media timescale to TS (int or fraction) and change the media duration", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("sampdur", NULL, "`S` force all samples duration (`D`) or sample durations and media timescale (`D/TS`), used to patch CFR files with broken timings", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("timescale", NULL, "`S` set imported media timescale to TS", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("moovts", NULL, "`S` set movie timescale to TS. A negative value picks the media timescale of the first track imported", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("noedit", NULL, "`XS` do not set edit list when importing B-frames video tracks", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("rvc", NULL, "`S` set RVC configuration for the media", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("fmt", NULL, "override format detection with given format - disable data probing and force `ext` option on source", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("profile", NULL, "`S` override AVC profile. Integer value, or `high444`, `high`, `extended`, `main`, `baseline`", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("level", NULL, "`S` override AVC level, if value < 6, interpreted as decimal expression", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("compat", NULL, "`S` force the profile compatibility flags for the H.264 content", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("novpsext", NULL, "remove VPS extensions from HEVC VPS", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("keepav1t", NULL, "keep AV1 temporal delimiter OBU in samples, might help if source file had losses", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("font", NULL, "specify font name for text import (default `Serif`)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("size", NULL, "specify font size for text import (default `18`)", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("text_layout", NULL, "specify the track text layout as WxHxXxY\n"
-		" - if W (resp H) = 0: the max width (resp height) of the tracks in the file are used\n"
-		" - if Y=-1: the layout is moved to the bottom of the track area\n"
-		" - X and Y can be omitted: `:layout=WxH`", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("swf-global", NULL, "all SWF defines are placed in first scene replace rather than when needed", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-no-ctrl", NULL, "use a single stream for movie control and dictionary (this will disable ActionScript)", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-no-text", NULL, "remove all SWF text", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-no-font", NULL, "remove all embedded SWF Fonts (local playback host fonts used)", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-no-line", NULL, "remove all lines from SWF shapes", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-no-grad", NULL, "remove all gradients from SWF shapes", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-quad", NULL, "use quadratic bezier curves instead of cubic ones", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-xlp", NULL, "support for lines transparency and scalability", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-ic2d", NULL, "use indexed curve 2D hardcoded proto", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-same-app", NULL, "appearance nodes are reused", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("swf-flatten", NULL, "complementary angle below which 2 lines are merged, `0` means no flattening", NULL, NULL, GF_ARG_DOUBLE, 0),
-	GF_DEF_ARG("kind", NULL, "`S` set kind for the track as `schemeURI=value`", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("txtflags", NULL, "set display flags (hexa number) of text track. Use `txtflags+=FLAGS` to add flags and `txtflags-=FLAGS` to remove flags", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("rate", NULL, "force average rate and max rate to VAL (in bps) in btrt box. If 0, removes btrt box", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("stz2", NULL, "`S` use compact size table (for low-bitrates)", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("bitdepth", NULL, "set bit depth to VAL for imported video content (default is 24)", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("colr", NULL, "`S` set color profile for imported video content (see ISO/IEC 23001-8). Value is formatted as:\n"
-		" - nclc,p,t,m: with p colour primary (int or string), t transfer characteristics (int or string) and m matrix coef (int or string)\n"
-		" - nclx,p,t,m,r: same as `nclx` with r full range flag (`yes`, `on` or `no`, `off`)\n"
-		" - prof,path: with path indicating the file containing the ICC color profile\n"
-		" - rICC,path: with path indicating the file containing the restricted ICC color profile\n"
-		" - 'none': removes color info", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("hdr", NULL, "`S` set HDR info on track (see -hdr(MP4B_GEN) ), 'none' removes HDR info", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("dv-profile", NULL, "`S` set the Dolby Vision profile on imported track\n"
-	"- Profile is an integer, or `none` to remove DV signaling\n"
-	"- Profile can be suffixed with compatibility ID, e.g. `5.hdr10`\n"
-	"- Allowed compatibility ID are `none`, `hdr10`, `bt709`, `hlg709`, `hlg2100`, `bt2020`, `brd`, or integer value as per DV spec\n"
-	"- Profile can be prefixed with 'f' to force DV codec type signaling, e.g. `f8.2`", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("fullrange", NULL, "`S` force the video fullrange type in VUI for the AVC|H264 content (value `yes`, `on` or `no`, `off`)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("videofmt", NULL, "`S` force the video format in VUI for AVC|H264 and HEVC content, value can be `component`, `pal`, `ntsc`, `secam`, `mac`, `undef`", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("colorprim", NULL, "`S` force the colour primaries in VUI for AVC|H264 and HEVC (int or string, cf `-h cicp`)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("colortfc", NULL, "`S` force transfer characteristics in VUI for AVC|H264 and HEVC (int or string, cf `-h cicp`)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("colormx", NULL, "`S` force the matrix coefficients in VUI for the AVC|H264 and HEVC content (int or string, cf `-h cicp`)", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("tc", NULL, "`S` inject a single QT timecode. Value is formatted as:\n"
-		" - dFPS/FPS_den,h,m,s,f,framespertick: optional drop flag, framerate (integer or fractional), hours, minutes, seconds and frame number\n"
-		" - : `d` is an optional flag used to indicate that the counter is in drop-frame format\n"
-		" - : the `framespertick` is optional and defaults to round(framerate); it indicates the number of frames per counter tick", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("edits", NULL, "`S` override edit list, same syntax as -edits()", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("lastsampdur", NULL, "`S` set duration of the last sample. Value is formatted as:\n"
-		" - no value: use the previous sample duration\n"
-		" - integer: indicate the duration in milliseconds\n"
-		" - N/D: indicate the duration as fractional second", NULL, NULL, GF_ARG_STRING, 0),
-	GF_DEF_ARG("ID", NULL, "`S` set target ID\n"
-		" - a value of 0 (default) will try to keep source track ID\n"
-		" - a value of -1 will ignore source track ID\n"
-		" - other value will try to set track ID to this value if no other track with same ID is present"
-		"", NULL, NULL, GF_ARG_INT, 0),
-	GF_DEF_ARG("stats", "fstat", "`C` print filter session stats after import", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("graph", "fgraph", "`C` print filter session graph after import", NULL, NULL, GF_ARG_BOOL, 0),
-	{"sopt:OPTS", NULL, "set `OPTS` as additional arguments to source filter. `OPTS` can be any usual filter argument, see filter doc `gpac -h doc`(Filters)"},
-	{"dopt:OPTS", NULL, "`X` set `OPTS` as additional arguments to destination filter(mp4mx). OPTS can be any usual filter argument, see filter doc `gpac -h doc`(Filters)"},
-	{"@f1:args@fN:args", NULL, "set a filter chain to insert before the multiplexer. Each filter in the chain is formatted as a regular filter, see filter doc `gpac -h doc`(Filters). A `@@` separator starts a new chain (see DASH help). The last filter in each chain shall not have any ID specified"},
-	{0}
-};
-
-void PrintImportUsage()
-{
-	u32 i;
-
-	gf_sys_format_help(helpout, help_flags, "# Importing Options\n"
-		"# File importing\n"
-		"Syntax is -add() / -cat() `URL#FRAGMENT:opt1...:optN=val`\n"
-		"This process will create the destination file if not existing, and add the track(s) to it. If you wish to always create a new destination file, add -new(MP4B_GEN).\n"
-		"The supported input media types depend on your installation, check filters documentation(Filters) for more info.\n"
-		" \n"
-		"To select a desired media track from a source, a fragment identifier '#' can be specified, before any other options. The following syntax is used:\n"
-		"- `#video`: adds the first video track found in source\n"
-		"- `#audio`: adds the first audio track found in source\n"
-		"- `#auxv`: adds the first auxiliary video track found in source\n"
-		"- `#pict`: adds the first picture track found in source\n"
-		"- `#trackID=ID` or `#ID`: adds the specified track. For IsoMedia files, ID is the track ID. For other media files, ID is the value indicated by `MP4Box -info inputFile`\n"
-		"- `#pid=ID`: number of desired PID for MPEG-2 TS sources\n"
-		"- `#prog_id=ID`: number of desired program for MPEG-2 TS sources\n"
-		"- `#program=NAME`: name of desired program for MPEG-2 TS sources\n"
-		" \n"
-		"By default all imports are performed sequentially, and final interleaving is done at the end; this however requires a temporary file holding original ISOBMF file (if any) and added files before creating the final output. Since this can become quite large, it is possible to add media to a new file without temporary storage, using -flat(MP4B_GEN) option, but this disables media interleaving.\n"
-		" \n"
-		"If you wish to create an interleaved new file with no temporary storage, use the -newfs(MP4B_GEN) option. The interleaving might not be as precise as when using -new() since it is dependent on multiplexer input scheduling (each execution might lead to a slightly different result). Additionally in this mode: \n"
-		" - Some multiplexing options (marked with `X` below) will be activated for all inputs (e.g. it is not possible to import one AVC track with `xps_inband` and another without).\n"
-		" - Some multiplexing options (marked as `D` below) cannot be used as they require temporary storage for file edition.\n"
-		" - Usage of -cat() is possible, but concatenated sources will not be interleaved in the output. If you wish to perform more complex cat/add operations without temp file, use a playlist(flist).\n"
-		" \n"
-		"Source URL can be any URL supported by GPAC, not limited to local files.\n"
-		" \n"
-		"Note: When importing SRT or SUB files, MP4Box will choose default layout options to make the subtitle appear at the bottom of the video. You SHOULD NOT import such files before any video track is added to the destination file, otherwise the results will likely not be useful (default SRT/SUB importing uses default serif font, fontSize 18 and display size 400x60). For more details, check TTXT doc(Subtitling-with-GPAC).\n"
-		" \n"
-		"When importing several tracks/sources in one pass, all options will be applied if relevant to each source. These options are set for all imported streams. If you need to specify these options per stream, set per-file options using the syntax `-add stream:opt1:...:optN`.\n"
-		" \n"
-		"The import file name may be set to empty or `self`, indicating that the import options should be applied to the destination file track(s).\n"
-		"EX -add self:moovts=-1:noedit src.mp4\n"
-		"This will apply `moovts` and `noedit` option to all tracks in src.mp4\n"
-		"EX -add self#2:moovts=-1:noedit src.mp4\n"
-		"This will apply `moovts` and `noedit` option to track with `ID=2` in src.mp4\n"
-		"Only per-file options marked with a `S` are possible in this mode.\n"
-		" \n"
-		"When importing an ISOBMFF/QT file, only options marked as `C` or `S` can be used.\n"
-		" \n"
-		"Allowed per-file options:\n\n"
-	);
-
-	i=0;
-	while (m4b_imp_fileopt_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_imp_fileopt_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags | GF_PRINTARG_NO_DASH, arg, "mp4box-import");
-	}
-
-	gf_sys_format_help(helpout, help_flags, "\n"
-		"Note: `sopt`, `dopt` and `@f` must be placed after all other options.\n"
-		"# Global import options\n"
-	);
-
-	i=0;
-	while (m4b_imp_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_imp_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-import");
-	}
-}
-
-Bool mp4box_check_isom_fileopt(char *opt)
-{
-	GF_GPACArg *arg = NULL;
-	u32 i=0;
-
-	while (m4b_imp_fileopt_argsi.name) {
-		arg = (GF_GPACArg *) &m4b_imp_fileopt_argsi;
-		i++;
-		if (!stricmp(arg->name, opt)) break;
-		arg = NULL;
-	}
-	if (!arg) {
-		fprintf(stderr, "Option %s not described in doc, please report to GPAC devs!\n", opt);
-		return GF_FALSE;
-	}
-	if (arg->description0 != '`')
-		return GF_FALSE;
-	const char *d = arg->description+1;
-	while (d0 != '`') {
-		if (d0=='S') return GF_TRUE;
-		if (d0=='C') return GF_TRUE;
-		d++;
-	}
-	return GF_FALSE;
-}
-
-
-MP4BoxArg m4b_senc_args =
-{
-#ifndef GPAC_DISABLE_SCENE_ENCODER
- 	MP4BOX_ARG("mp4", "specify input file is for BIFS/LASeR encoding", GF_ARG_BOOL, 0, &encode, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("def", "encode DEF names in BIFS", GF_ARG_BOOL, 0, &smenc_opts.flags, GF_SM_ENCODE_USE_NAMES, ARG_BIT_MASK),
- 	MP4BOX_ARG("sync", "force BIFS sync sample generation every given time in ms (cannot be used with -shadow() or -carousel() )", GF_ARG_INT, 0, parse_senc_param, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("shadow", "force BIFS sync shadow sample generation every given time in ms (cannot be used with -sync() or -carousel() )", GF_ARG_INT, 0, parse_senc_param, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("carousel", "use BIFS carousel (cannot be used with -sync() or -shadow() )", GF_ARG_INT, 0, parse_senc_param, 2, ARG_IS_FUN),
-
- 	MP4BOX_ARG("sclog", "generate scene codec log file if available", GF_ARG_BOOL, 0, &do_scene_log, 0, 0),
- 	MP4BOX_ARG("ms", "import tracks from the given file", GF_ARG_STRING, 0, &mediaSource, 0, 0),
- 	MP4BOX_ARG("ctx-in", "specify initial context (MP4/BT/XMT) file for chunk processing. Input file must be a commands-only file", GF_ARG_STRING, 0, parse_senc_param, 5, ARG_IS_FUN),
- 	MP4BOX_ARG("ctx-out", "specify storage of updated context (MP4/BT/XMT) file for chunk processing, optional", GF_ARG_STRING, 0, &output_ctx, 0, 0),
- 	MP4BOX_ARG("resolution", "resolution factor (-8 to 7, default 0) for LASeR encoding, and all coordinates are multiplied by `2^res` before truncation (LASeR encoding)", GF_ARG_INT, 0, &smenc_opts.resolution, 0, 0),
- 	MP4BOX_ARG("coord-bits", "number of bits used for encoding truncated coordinates (0 to 31, default 12) (LASeR encoding)", GF_ARG_INT, 0, &smenc_opts.coord_bits, 0, 0),
- 	MP4BOX_ARG("scale-bits", "extra bits used for encoding truncated scales (0 to 4, default 0) (LASeR encoding)", GF_ARG_INT, 0, &smenc_opts.scale_bits, 0, 0),
- 	MP4BOX_ARG("auto-quant", "resolution is given as if using -resolution() but coord-bits and scale-bits are inferred (LASeR encoding)", GF_ARG_INT, 0, parse_senc_param, 3, ARG_IS_FUN),
- 	MP4BOX_ARG("global-quant", "resolution is given as if using -resolution() but the res is inferred (BIFS encoding)", GF_ARG_INT, 0, parse_senc_param, 4, ARG_IS_FUN),
-#endif
- 	{0}
-};
-
-
-void PrintEncodeUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# MPEG-4 Scene Encoding Options\n"
-		"## General considerations\n"
-		"MP4Box supports encoding and decoding of of BT, XMT, VRML and (partially) X3D formats int MPEG-4 BIFS, and encoding and decoding of XSR and SVG into MPEG-4 LASeR\n"
-		"Any media track specified through a `MuxInfo` element will be imported in the resulting MP4 file.\n"
-		"See https://wiki.gpac.io/MPEG-4-BIFS-Textual-Format and related pages.\n"
-		"## Scene Random Access\n"
-		"MP4Box can encode BIFS or LASeR streams and insert random access points at a given frequency. This is useful when packaging content for broadcast, where users will not turn in the scene at the same time. In MPEG-4 terminology, this is called the __scene carousel__."
-		"## BIFS Chunk Processing\n"
-		"The BIFS chunk encoding mode allows encoding single BIFS access units from an initial context and a set of commands.\n"
-		"The generated AUs are raw BIFS (not SL-packetized), in files called FILE-ESID-AUIDX.bifs, with FILE the basename of the input file.\n"
-		"Commands with a timing of 0 in the input will modify the carousel version only (i.e. output context).\n"
-		"Commands with a timing different from 0 in the input will generate new AUs.\n"
-		" \n"
-		"Options:\n"
-	);
-
-	while (m4b_senc_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_senc_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-senc");
-	}
-}
-
-MP4BoxArg m4b_crypt_args =
-{
- 	MP4BOX_ARG("crypt", "encrypt the input file using the given `CryptFile`", GF_ARG_STRING, 0, parse_cryp, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("decrypt", "decrypt the input file, potentially using the given `CryptFile`. If `CryptFile` is not given, will fail if the key management system is not supported", GF_ARG_STRING, 0, parse_cryp, 1, ARG_IS_FUN | ARG_EMPTY),
- 	MP4BOX_ARG_S("set-kms", "tkID=kms_uri", "change ISMA/OMA KMS location for a given track or for all tracks if `all=` is used", 0, parse_track_action, TRACK_ACTION_SET_KMS_URI, ARG_IS_FUN),
- 	{0}
-};
-
-void PrintEncryptUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# Encryption/Decryption Options\n"
-	"MP4Box supports encryption and decryption of ISMA, OMA and CENC content, see encryption filter `gpac -h cecrypt`(cecrypt).\n"
-	"It requires a specific XML file called `CryptFile`, whose syntax is available at https://wiki.gpac.io/Common-Encryption\n"
-	"Image files (HEIF) can also be crypted / decrypted, using CENC only.\n"
-	" \n"
-	"Options:\n"
-	);
-	while (m4b_crypt_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_crypt_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-crypt");
-	}
-}
-
-MP4BoxArg m4b_hint_args =
-{
-#ifndef GPAC_DISABLE_STREAMING
- 	MP4BOX_ARG("hint", "hint the file for RTP/RTSP", GF_ARG_BOOL, 0, &do_hint, 0, ARG_OPEN_EDIT),
- 	{"mtu", NULL, "specify RTP MTU (max size) in bytes (this includes 12 bytes RTP header)", "1450", NULL, GF_ARG_INT, 0, &MTUSize, 0, 0},
- 	MP4BOX_ARG("copy", "copy media data to hint track rather than reference (speeds up server but takes much more space)", GF_ARG_BOOL, 0, &HintCopy, 0, 0),
- 	MP4BOX_ARG_S("multi", "maxptime", "enable frame concatenation in RTP packets if possible (with max duration 100 ms or `maxptime` ms if given)", 0, parse_multi_rtp, 0, ARG_IS_FUN),
- 	{"rate", NULL, "specify rtp rate in Hz when no default for payload", "90000", NULL, GF_ARG_INT, 0, &rtp_rate, 0, 0},
- 	MP4BOX_ARG("mpeg4", "force MPEG-4 generic payload whenever possible", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_FORCE_MPEG4, ARG_BIT_MASK),
- 	MP4BOX_ARG("latm", "force MPG4-LATM transport for AAC streams", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_USE_LATM_AAC, ARG_BIT_MASK),
- 	MP4BOX_ARG("static", "enable static RTP payload IDs whenever possible (by default, dynamic payloads are always used)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_USE_STATIC_ID, ARG_BIT_MASK),
- 	MP4BOX_ARG("add-sdp", "add given SDP string to movie (`string`) or track (`tkID:string`), `tkID` being the track ID or the hint track ID", GF_ARG_STRING, 0, parse_sdp_ext, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("no-offset", "signal no random offset for sequence number and timestamp (support will depend on server)", GF_ARG_BOOL, 0, &hint_no_offset, 0, 0),
- 	MP4BOX_ARG("unhint", "remove all hinting information from file", GF_ARG_BOOL, 0, &remove_hint, 0, ARG_OPEN_EDIT),
- 	MP4BOX_ARG("group-single", "put all tracks in a single hint group", GF_ARG_BOOL, 0, &single_group, 0, 0),
- 	MP4BOX_ARG("ocr", "force all MPEG-4 streams to be synchronized (MPEG-4 Systems only)", GF_ARG_BOOL, 0, &force_ocr, 0, 0),
- 	MP4BOX_ARG("rap", "signal random access points in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, parse_rap_ref, 0, ARG_IS_FUN | ARG_EMPTY),
- 	MP4BOX_ARG("ts", "signal AU Time Stamps in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_SIGNAL_TS, ARG_BIT_MASK),
-	MP4BOX_ARG("size", "signal AU size in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_SIGNAL_SIZE, ARG_BIT_MASK),
- 	MP4BOX_ARG("idx", "signal AU sequence numbers in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_SIGNAL_AU_IDX, ARG_BIT_MASK),
- 	MP4BOX_ARG("iod", "prevent systems tracks embedding in IOD (MPEG-4 Systems), not compatible with -isma()", GF_ARG_BOOL, 0, &regular_iod, 0, 0),
-#endif
- 	{0}
-};
-
-void PrintHintUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# Hinting Options\n"
-		"IsoMedia hinting consists in creating special tracks in the file that contain transport protocol specific information and optionally multiplexing information. These tracks are then used by the server to create the actual packets being sent over the network, in other words they provide the server with hints on how to build packets, hence their names `hint tracks`.\n"
-		"MP4Box supports creation of hint tracks for RTSP servers supporting these such as QuickTime Streaming Server, DarwinStreaming Server or 3GPP-compliant RTSP servers.\n"
-		"Note: GPAC streaming tools rtp output(rtpout) and rtsp server(rtspout) do not use hint tracks, they use on-the-fly packetization "
-		"from any media sources, not just MP4\n"
-		" \n"
-		"Options:\n"
-	);
-	while (m4b_hint_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_hint_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-hint");
-	}
-}
-
-
-MP4BoxArg m4b_extr_args =
-{
- 	MP4BOX_ARG("raw", "extract given track in raw format when supported. Use `tkID:output=FileName` to set output file name", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_NATIVE, ARG_IS_FUN),
- 	MP4BOX_ARG("raws", "extract each sample of the given track to a file. Use `tkID:N` to extract the Nth sample", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_RAW_SAMPLES, ARG_IS_FUN),
- 	MP4BOX_ARG("nhnt", "extract given track to NHNT(nhntr) format", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_NHNT, ARG_IS_FUN),
- 	MP4BOX_ARG("nhml", "extract given track to NHML(nhmlr) format. Use `tkID:full` for full NHML dump with all packet properties", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_NHML, ARG_IS_FUN),
- 	MP4BOX_ARG("webvtt-raw", "extract given track as raw media in WebVTT as metadata. Use `tkID:embedded` to include media data in the WebVTT file", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_WEBVTT_META, ARG_IS_FUN),
- 	MP4BOX_ARG("single", "extract given track to a new mp4 file", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_MP4, ARG_IS_FUN),
- 	MP4BOX_ARG("six", "extract given track as raw media in **experimental** XML streaming instructions", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_SIX, ARG_IS_FUN),
- 	MP4BOX_ARG("mux", "multiplex input file to given destination", GF_ARG_STRING, 0, &mux_name, 0, 0),
- 	MP4BOX_ARG("qcp", "same as -raw() but defaults to QCP file for EVRC/SMV", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_NATIVE | GF_EXPORT_USE_QCP, ARG_IS_FUN),
- 	MP4BOX_ARG("saf", "multiplex input file to SAF multiplex", GF_ARG_BOOL, 0, &do_saf, 0, 0),
- 	MP4BOX_ARG("dvbhdemux", "demultiplex DVB-H file into IP Datagrams sent on the network", GF_ARG_BOOL, 0, &dvbhdemux, 0, 0),
- 	MP4BOX_ARG("raw-layer", "same as -raw() but skips SVC/MVC/LHVC extractors when extracting", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_NATIVE | GF_EXPORT_SVC_LAYER, ARG_IS_FUN),
- 	MP4BOX_ARG("diod", "extract file IOD in raw format", GF_ARG_BOOL, 0, &dump_iod, 0, 0),
- 	MP4BOX_ARG("mpd", "convert given HLS or smooth manifest (local or remote http) to MPD. \nWarning: This is not compatible with other DASH options and does not convert associated segments", GF_ARG_STRING, 0, &do_mpd_conv, 0, 0),
- 	{0}
-};
-
-void PrintExtractUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# Extracting Options\n"
-	"MP4Box can be used to extract media tracks from MP4 files. If you need to convert these tracks however, please check the filters doc(Filters).\n"
-	" \n"
-	"Options:\n"
-	);
-	while (m4b_extr_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_extr_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
-	}
-}
-
-MP4BoxArg m4b_dump_args =
-{
- 	MP4BOX_ARG("std", "dump/write to stdout and assume stdout is opened in binary mode", GF_ARG_BOOL, 0, &dump_std, 2, 0),
- 	MP4BOX_ARG("stdb", "dump/write to stdout and try to reopen stdout in binary mode", GF_ARG_BOOL, 0, &dump_std, 1, 0),
- 	MP4BOX_ARG("tracks", "print the number of tracks on stdout", GF_ARG_BOOL, 0, &get_nb_tracks, 0, 0),
- 	MP4BOX_ARG("info", "print movie info (no parameter) or track extended info with specified ID", GF_ARG_STRING, 0, parse_file_info, 0, ARG_IS_FUN|ARG_EMPTY),
- 	MP4BOX_ARG("infon", "print track info for given track number, 1 being the first track in the file", GF_ARG_STRING, 0, parse_file_info, 1, ARG_IS_FUN|ARG_EMPTY),
- 	MP4BOX_ARG("infox", "print movie and track extended info (same as -info N` for each track)", GF_ARG_BOOL, 0, parse_file_info, 2, ARG_IS_FUN|ARG_EMPTY),
- 	MP4BOX_ARG_ALT("diso", "dmp4", "dump IsoMedia file boxes in XML output", GF_ARG_BOOL, 0, &dump_isom, 1, 0),
- 	MP4BOX_ARG("dxml", "dump IsoMedia file boxes and known track samples in XML output", GF_ARG_BOOL, 0, &dump_isom, 2, 0),
- 	MP4BOX_ARG("disox", "dump IsoMedia file boxes except sample tables in XML output", GF_ARG_BOOL, 0, &dump_isom, 3, 0),
- 	MP4BOX_ARG("keep-ods", "do not translate ISOM ODs and ESDs tags (debug purpose only)", GF_ARG_BOOL, 0, &no_odf_conf, 0, 0),
-#ifndef GPAC_DISABLE_SCENE_DUMP
- 	MP4BOX_ARG("bt", "dump scene to BT format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_BT, ARG_HAS_VALUE),
- 	MP4BOX_ARG("xmt", "dump scene to XMT format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_XMTA, 0),
- 	MP4BOX_ARG("wrl", "dump scene to VRML format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_VRML, 0),
- 	MP4BOX_ARG("x3d", "dump scene to X3D XML format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_X3D_XML, 0),
- 	MP4BOX_ARG("x3dv", "dump scene to X3D VRML format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_X3D_VRML, 0),
- 	MP4BOX_ARG("lsr", "dump scene to LASeR XML (XSR) format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_LASER, 0),
- 	MP4BOX_ARG("svg", "dump scene to SVG", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_SVG, 0),
-#endif
- 	MP4BOX_ARG("drtp", "dump rtp hint samples structure to XML output", GF_ARG_BOOL, 0, &dump_rtp, 0, 0),
- 	MP4BOX_ARG("dts", "print sample timing, size and position in file to text output", GF_ARG_BOOL, 0, parse_dump_ts, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("dtsx", "same as -dts() but does not print offset", GF_ARG_BOOL, 0, &dump_timestamps, 2, 0),
- 	MP4BOX_ARG("dtsc", "same as -dts() but analyses each sample for duplicated dts/cts (__slow !__)", GF_ARG_BOOL, 0, &dump_timestamps, 3, 0),
- 	MP4BOX_ARG("dtsxc", "same as -dtsc() but does not print offset (__slow !__)", GF_ARG_BOOL, 0, &dump_timestamps, 4, 0),
- 	MP4BOX_ARG("dnal", "print NAL sample info of given track", GF_ARG_INT, 0, parse_dnal, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("dnalc", "print NAL sample info of given track, adding CRC for each nal", GF_ARG_INT, 0, parse_dnal, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("dnald", "print NAL sample info of given track without DTS and CTS info", GF_ARG_INT, 0, parse_dnal, 2, ARG_IS_FUN),
- 	MP4BOX_ARG("dnalx", "print NAL sample info of given track without DTS and CTS info and adding CRC for each nal", GF_ARG_INT, 0, parse_dnal, 2|1, ARG_IS_FUN),
- 	MP4BOX_ARG("sdp", "dump SDP description of hinted file", GF_ARG_BOOL, 0, &print_sdp, 0, 0),
- 	MP4BOX_ARG("dsap", "dump DASH SAP cues (see -cues) for a given track", GF_ARG_INT, 0, parse_dsap, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("dsaps", "same as -dsap() but only print sample number", GF_ARG_INT, 0, parse_dsap, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("dsapc", "same as -dsap() but only print CTS", GF_ARG_INT, 0, parse_dsap, 2, ARG_IS_FUN),
- 	MP4BOX_ARG("dsapd", "same as -dsap() but only print DTS", GF_ARG_INT, 0, parse_dsap, 3, ARG_IS_FUN),
- 	MP4BOX_ARG("dsapp", "same as -dsap() but only print presentation time", GF_ARG_INT, 4, parse_dsap, 4, ARG_IS_FUN),
- 	MP4BOX_ARG("dcr", "dump ISMACryp samples structure to XML output", GF_ARG_BOOL, 0, &dump_cr, 0, 0),
- 	MP4BOX_ARG("dchunk", "dump chunk info", GF_ARG_BOOL, 0, &dump_chunk, 0, 0),
- 	MP4BOX_ARG("dump-cover", "extract cover art", GF_ARG_BOOL, 0, &dump_cart, 0, 0),
- 	MP4BOX_ARG("dump-chap", "extract chapter file as TTXT format", GF_ARG_BOOL, 0, &dump_chap, 1, 0),
- 	MP4BOX_ARG("dump-chap-ogg", "extract chapter file as OGG format", GF_ARG_BOOL, 0, &dump_chap, 2, 0),
- 	MP4BOX_ARG("dump-chap-zoom", "extract chapter file as zoom format", GF_ARG_BOOL, 0, &dump_chap, 3, 0),
- 	MP4BOX_ARG_S("dump-udta", "tkID:4cc", "extract user data for the given 4CC. If `tkID` is given, dumps from UDTA of the given track ID, otherwise moov is used", 0, parse_dump_udta, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("mergevtt", "merge vtt cues while dumping", GF_ARG_BOOL, 0, &merge_vtt_cues, 0, 0),
- 	MP4BOX_ARG("ttxt", "convert input subtitle to GPAC TTXT format if no parameter. Otherwise, dump given text track to GPAC TTXT format", GF_ARG_INT, 0, parse_ttxt, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("srt", "convert input subtitle to SRT format if no parameter. Otherwise, dump given text track to SRT format", GF_ARG_INT, 0, parse_ttxt, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("nstat", "generate node/field statistics for scene", GF_ARG_BOOL, 0, &stat_level, 1, 0),
- 	MP4BOX_ARG("nstats", "generate node/field statistics per Access Unit", GF_ARG_BOOL, 0, &stat_level, 2, 0),
- 	MP4BOX_ARG("nstatx", "generate node/field statistics for scene after each AU", GF_ARG_BOOL, 0, &stat_level, 3, 0),
- 	MP4BOX_ARG("hash", "generate SHA-1 Hash of the input file", GF_ARG_BOOL, 0, &do_hash, 0, 0),
- 	MP4BOX_ARG("comp", "replace with compressed version all top level box types given as parameter, formatted as `orig_4cc_1=comp_4cc_1,orig_4cc_2=comp_4cc_2`", GF_ARG_STRING, 0, parse_comp_box, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("topcount", "print to stdout the number of top-level boxes matching box types given as parameter, formatted as `4cc_1,4cc_2N`", GF_ARG_STRING, 0, parse_comp_box, 2, ARG_IS_FUN),
- 	MP4BOX_ARG("topsize", "print to stdout the number of bytes of top-level boxes matching types given as parameter, formatted as `4cc_1,4cc_2N` or `all` for all boxes", GF_ARG_STRING, 0, parse_comp_box, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("bin", "convert input XML file using NHML bitstream syntax to binary", GF_ARG_BOOL, 0, &do_bin_xml, 0, 0),
- 	MP4BOX_ARG("mpd-rip", "fetch MPD and segment to disk", GF_ARG_BOOL, 0, &do_mpd_rip, 0, 0),
- 	//MP4BOX_ARG_S("udp-write", "IP:port", "write input name to UDP (default port 2345)", GF_FS_ARG_HINT_EXPERT, &udp_dest, 0, GF_ARG_STRING),
-	{"udp-write", NULL, "write input name to UDP (default port 2345)", "IP:port", NULL, GF_ARG_STRING, GF_FS_ARG_HINT_EXPERT, &udp_dest, 0, 0},
- 	MP4BOX_ARG("raw-cat", "raw concatenation of given file with input file", GF_ARG_STRING, GF_FS_ARG_HINT_EXPERT, &raw_cat, 0, 0),
- 	MP4BOX_ARG("wget", "fetch resource from http(s) URL", GF_ARG_STRING, GF_FS_ARG_HINT_EXPERT, &do_wget, 0, 0),
- 	MP4BOX_ARG("dm2ts", "dump timing of an input MPEG-2 TS stream sample timing", GF_ARG_BOOL, 0, &dump_m2ts, 0, 0),
- 	MP4BOX_ARG("check-xml", "check XML output format for -dnal*, -diso* and -dxml options", GF_ARG_BOOL, 0, &dump_check_xml, 0, 0),
- 	{0}
-};
-
-void PrintDumpUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# File Dumping\n"
-	" \n"
-	"MP4Box has many dump functionalities, from simple track listing to more complete reporting of special tracks.\n"
-	" \n"
-	"Options:\n"
-	);
-	while (m4b_dump_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_dump_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
-	}
-}
-
-MP4BoxArg m4b_meta_args =
-{
- 	MP4BOX_ARG_S("set-meta", "ABCD:tk=tkID", "set meta box type, with `ABCD` the four char meta type (NULL or 0 to remove meta)\n"
-		"- tk not set: use root (file) meta\n"
-		"- tkID == 0: use moov meta\n"
-		"- tkID != 0: use meta of given track", 0, parse_meta_args, META_ACTION_SET_TYPE, ARG_IS_FUN),
- 	MP4BOX_ARG("add-item", "add resource to meta, with parameter syntax `file_path:opt1:optN`\n"
-		"- file_path `this` or `self`: item is the file itself\n"
-		"- tk=tkID: meta location (file, moov, track)\n"
-		"- name=str: item name, none if not set\n"
-		"- type=itype: item 4cc type (not needed if mime is provided)\n"
-		"- mime=mtype: item mime type, none if not set\n"
-		"- encoding=enctype: item content-encoding type, none if not set\n"
-		"- id=ID: item ID\n"
-		"- ref=4cc,id: reference of type 4cc to an other item (can be set multiple times)\n"
-		"- group=id,type: indicate the id and type of an alternate group for this item\n"
-		"- replace: replace existing item by new item"
-		, GF_ARG_STRING, 0, parse_meta_args, META_ACTION_ADD_ITEM, ARG_IS_FUN),
-	MP4BOX_ARG("add-image", "add the given file as HEIF image item, with parameter syntax `file_path:opt1:optN`. If `filepath` is omitted, source is the input MP4 file\n"
-		"- name, id, ref: see -add-item()\n"
-		"- primary: indicate that this item should be the primary item\n"
-		"- time=t-e/i: use the next sync sample after time t (float, in sec, default 0). A negative time imports ALL intra frames as items\n"
-		" - If `e` is set (float, in sec), import all sync samples between `t` and `e`\n"
-		" - If `i` is set (float, in sec), sets time increment between samples to import\n"
-		"- split_tiles: for an HEVC tiled image, each tile is stored as a separate item\n"
-		"- image-size=wxh: force setting the image size and ignoring the bitstream info, used for grid, overlay and identity derived images also\n"
-		"- rotation=a: set the rotation angle for this image to 90*a degrees anti-clockwise\n"
-		"- mirror-axis=axis: set the mirror axis: vertical, horizontal\n"
-		"- clap=Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd: see track clap\n"
- 		"- image-pasp=axb: force the aspect ratio of the image\n"
- 		"- image-pixi=(a|a,b,c): force the bit depth (1 or 3 channels)\n"
-		"- hidden: indicate that this image item should be hidden\n"
-		"- icc_path: path to icc data to add as color info\n"
-		"- alpha: indicate that the image is an alpha image (should use ref=auxl also)\n"
-		"- depth: indicate that the image is a depth image (should use ref=auxl also)\n"
-		"- it=ID: indicate the item ID of the source item to import\n"
-		"- itp=ID: same as `it=` but copy over all properties of the source item\n"
-		"- tk=tkID: indicate the track ID of the source sample. If 0, uses the first video track in the file\n"
-		"- samp=N: indicate the sample number of the source sample\n"
-		"- ref: do not copy the data but refer to the final sample/item location, ignored if `filepath` is set\n"
-		"- agrid=AR: creates an automatic grid from the image items present in the file, in their declaration order. The grid will **try to** have `AR` aspect ratio if specified (float), or the aspect ratio of the source otherwise. The grid will be the primary item and all other images will be hidden\n"
-		"- av1_op_index: select the AV1 operating point to use via a1op box\n"
-		"- replace: replace existing image by new image, keeping props listed in `keep_props`\n"
-		"- keep_props=4CCs: coma-separated list of properties types to keep when replacing the image, e.g. `keep_props=auxC`\n"
-		"- auxt=URN: mark image as auxiliary using given `URN`\n"
-		"- auxd=FILE: use data from `FILE` as auxiliary extensions (cf `auxC` box)\n"
-		"- any other options will be passed as options to the media importer, see -add()"
-		, GF_ARG_STRING, 0, parse_meta_args, META_ACTION_ADD_IMAGE_ITEM, ARG_IS_FUN),
-	MP4BOX_ARG("add-derived-image", "create an image grid, overlay or identity item, with parameter syntax `:type=(grid|iovl|iden):opt1:optN`\n"
-		"- image-grid-size=rxc: set the number of rows and columns of the grid\n"
- 		"- image-overlay-offsets=h,v,h,v*: set the horizontal and vertical offsets of the images in the overlay\n"
- 		"- image-overlay-color=r,g,b,a: set the canvas color of the overlay 0-65535\n"
-	 "- any other options from -add-image() can be used\n", GF_ARG_STRING, 0, parse_meta_args, META_ACTION_ADD_IMAGE_DERIVED, ARG_IS_FUN),
-	MP4BOX_ARG_S_ALT("rem-item", "rem-image", "item_ID:tk=tkID", "remove resource from meta", 0, parse_meta_args, META_ACTION_REM_ITEM, ARG_IS_FUN),
-	MP4BOX_ARG_S("set-primary", "item_ID:tk=tkID", "set item as primary for meta", 0, parse_meta_args, META_ACTION_SET_PRIMARY_ITEM, ARG_IS_FUN),
-	MP4BOX_ARG_S("set-xml", "xml_file_path:tk=tkID:binary", "set meta XML data", 0, parse_meta_args, META_ACTION_SET_XML, ARG_IS_FUN),
-	MP4BOX_ARG_S("rem-xml", "tk=tkID", "remove meta XML data", 0, parse_meta_args, META_ACTION_REM_XML, ARG_IS_FUN),
-	MP4BOX_ARG_S("dump-xml", "file_path:tk=tkID", "dump meta XML to file", 0, parse_meta_args, META_ACTION_DUMP_XML, ARG_IS_FUN),
-	MP4BOX_ARG_S("dump-item", "item_ID:tk=tkID:path=fileName", "dump item to file", 0, parse_meta_args, META_ACTION_DUMP_ITEM, ARG_IS_FUN),
-	MP4BOX_ARG("package", "package input XML file into an ISO container, all media referenced except hyperlinks are added to file", GF_ARG_STRING, 0, &pack_file, 0, 0),
-	MP4BOX_ARG("mgt", "package input XML file into an MPEG-U widget with ISO container, all files contained in the current folder are added to the widget package", GF_ARG_STRING, 0, parse_mpegu, 0, ARG_IS_FUN),
-	{0}
-};
-
-void PrintMetaUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# Meta and HEIF Options\n"
-	"IsoMedia files can be used as generic meta-data containers, for examples storing XML information and sample images for a movie. The resulting file may not always contain a movie as is the case with some HEIF files or MPEG-21 files.\n"
-	" \n"
-	"These information can be stored at the file root level, as is the case for HEIF/IFF and MPEG-21 file formats, or at the movie or track level for a regular movie."
-	" \n \n");
-	while (m4b_meta_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_meta_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
-	}
-}
-
-MP4BoxArg m4b_swf_args =
-{
-#ifndef GPAC_DISABLE_SCENE_ENCODER
- 	MP4BOX_ARG("global", "all SWF defines are placed in first scene replace rather than when needed", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_STATIC_DICT, ARG_BIT_MASK),
- 	MP4BOX_ARG("no-ctrl", "use a single stream for movie control and dictionary (this will disable ActionScript)", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_SPLIT_TIMELINE, ARG_BIT_MASK_REM),
- 	MP4BOX_ARG("no-text", "remove all SWF text", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_TEXT, ARG_BIT_MASK),
- 	MP4BOX_ARG("no-font", "remove all embedded SWF Fonts (local playback host fonts used)", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_FONT, ARG_BIT_MASK),
- 	MP4BOX_ARG("no-line", "remove all lines from SWF shapes", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_LINE, ARG_BIT_MASK),
- 	MP4BOX_ARG("no-grad", "remove all gradients from swf shapes", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_GRADIENT, ARG_BIT_MASK),
- 	MP4BOX_ARG("quad", "use quadratic bezier curves instead of cubic ones", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_QUAD_CURVE, ARG_BIT_MASK),
- 	MP4BOX_ARG("xlp", "support for lines transparency and scalability", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_SCALABLE_LINE, ARG_BIT_MASK),
-	MP4BOX_ARG("ic2d", "use indexed curve 2D hardcoded proto", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_USE_IC2D, ARG_BIT_MASK),
-	MP4BOX_ARG("same-app", "appearance nodes are reused", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_REUSE_APPEARANCE, ARG_BIT_MASK),
- 	MP4BOX_ARG("flatten", "complementary angle below which 2 lines are merged, value `0` means no flattening", GF_ARG_DOUBLE, 0, &swf_flatten_angle, 0, 0),
-#endif
-	{0}
-};
-
-void PrintSWFUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# SWF Importer Options\n"
-	 "\n"
-	 "MP4Box can import simple Macromedia Flash files (\".SWF\")\n"
-	 "You can specify a SWF input file with \'-bt\', \'-xmt\' and \'-mp4\' options\n"
-	 " \n"
-	 "Options:\n"
-	);
-	while (m4b_swf_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_swf_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
-	}
-}
-
-MP4BoxArg m4b_liveenc_args =
-{
- 	MP4BOX_ARG("live", "enable live BIFS/LASeR encoder", GF_ARG_BOOL, 0, &live_scene, 0, 0),
- 	GF_DEF_ARG("dst", NULL, "destination IP", NULL, NULL, GF_ARG_STRING, 0),
- 	GF_DEF_ARG("port", NULL, "destination port", "7000", NULL, GF_ARG_INT, 0),
- 	GF_DEF_ARG("mtu", NULL, "path MTU for RTP packets", "1450", NULL, GF_ARG_INT, 0),
- 	GF_DEF_ARG("ifce", NULL, "IP address of the physical interface to use", NULL, NULL, GF_ARG_STRING, 0),
- 	GF_DEF_ARG("ttl", NULL, "time to live for multicast packets", "1", NULL, GF_ARG_INT, 0),
- 	GF_DEF_ARG("sdp", NULL, "output SDP file", "session.sdp", NULL, GF_ARG_STRING, 0),
- 	GF_DEF_ARG("dims", NULL, "turn on DIMS mode for SVG input", NULL, NULL, GF_ARG_BOOL, 0),
- 	GF_DEF_ARG("no-rap", NULL, "disable RAP sending and carousel generation", NULL, NULL, GF_ARG_BOOL, 0),
- 	GF_DEF_ARG("src", NULL, "source of scene updates", NULL, NULL, GF_ARG_STRING, 0),
- 	GF_DEF_ARG("rap", NULL, "duration in ms of base carousel; you can specify the RAP period of a single ESID (not in DIMS) using `ESID=X:time`", NULL, NULL, GF_ARG_INT, 0),
- 	{0}
-};
-
-void PrintLiveUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "# Live Scene Encoder Options\n"
-	 "The options shall be specified as `opt_name=opt_val.\n"
-	 "Options:\n"
-	 "\n"
-	);
-	while (m4b_liveenc_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_liveenc_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
-	}
-
-	gf_sys_format_help(helpout, help_flags, " \n"
-		"Runtime options:\n"
-		"- q: quits\n"
-		"- u: inputs some commands to be sent\n"
-		"- U: same as u but signals the updates as critical\n"
-		"- e: inputs some commands to be sent without being aggregated\n"
-		"- E: same as e but signals the updates as critical\n"
-		"- f: forces RAP sending\n"
-		"- F: forces RAP regeneration and sending\n"
-		"- p: dumps current scene\n"
-	);
-}
-
-void PrintCoreUsage()
-{
-	gf_sys_format_help(helpout, help_flags, "# libgpac core options\n");
-	gf_sys_print_core_help(helpout, 0, GF_ARGMODE_ALL, 0);
-}
-
-void PrintTags()
-{
-	u32 i = 0;
-
-	gf_sys_format_help(helpout, help_flags, "# Tagging support\n"
-	"Tags are specified as a colon-separated list `tag_name=tag_value:tag2=val2`\n"
-	"Setting a tag with no value or value `NULL` removes the tag.\n"
-	"Special tag value `clear` (or `reset`) removes all tags.\n"
-	"Unsupported tags can be added using their four character code as a tag name, and string value will be assumed.\n"
-	"If the tag name length is 3, the prefix 0xA9 is used to create the four character code.\n"
-	" \n"
-	"Tags can also be loaded from a text file using `-itags filename`. The file must be in UTF8 with:\n"
-	"- lines starting with `tag_name=value` specify the start of a tag\n"
-	"- other lines specify the remainder of the last declared tag\n"
-	" \n"
-	"If tag name starts with `WM/`, the tag is added to `Xtra` box (WMA tag, string only).\n"
-	" \n"
-	"Supported tag names, values, types, aliases:\n"
-	);
-
-	while (1) {
-		s32 type = gf_itags_get_type(i);
-		if (type<0) break;
-		const char *name = gf_itags_get_name(i);
-		u32 itag = gf_itags_get_itag(i);
-		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST , "%s", name);
-		gf_sys_format_help(helpout, help_flags, " (%s) ", gf_4cc_to_str(itag) );
-		switch (type) {
-		case GF_ITAG_STR:
-			gf_sys_format_help(helpout, help_flags, "string"); break;
-		case GF_ITAG_INT8:
-		case GF_ITAG_INT16:
-		case GF_ITAG_INT32:
-		case GF_ITAG_INT64:
-			gf_sys_format_help(helpout, help_flags, "integer"); break;
-		case GF_ITAG_FRAC6:
-		case GF_ITAG_FRAC8:
-			gf_sys_format_help(helpout, help_flags, "fraction (syntax: `A/B` or `A`, B will be 0)"); break;
-		case GF_ITAG_BOOL:
-			gf_sys_format_help(helpout, help_flags, "bool (`yes` or `no`)"); break;
-		case GF_ITAG_ID3_GENRE:
-			gf_sys_format_help(helpout, help_flags, "string (ID3 genre tag)"); break;
-		case GF_ITAG_FILE:
-			gf_sys_format_help(helpout, help_flags, "file path"); break;
-		}
-		name = gf_itags_get_alt_name(i);
-		if (name) {
-			gf_sys_format_help(helpout, help_flags, " (`alias` %s)", name);
-		}
-
-		gf_sys_format_help(helpout, help_flags, "\n");
-		i++;
-	}
-}
-
-void PrintCICP()
-{
-	u32 i;
-	gf_sys_format_help(helpout, help_flags, "# Video CICP (ISO/IEC 23091-2) Constants\n");
-	gf_sys_format_help(helpout, help_flags, "CICP Color Primaries:\n");
-	for (i=0; i<GF_CICP_PRIM_LAST; i++) {
-		const char *name = gf_cicp_color_primaries_name(i);
-		if (!name || !strcmp(name, "unknwon")) continue;
-		gf_sys_format_help(helpout, help_flags, " - `%s` (value %d)\n", name, i);
-	}
-	gf_sys_format_help(helpout, help_flags, " \nCICP Color Transfer Characteristics:\n");
-	for (i=0; i<GF_CICP_TRANSFER_LAST; i++) {
-		const char *name = gf_cicp_color_transfer_name(i);
-		if (!name) continue;
-		gf_sys_format_help(helpout, help_flags, " - `%s` (value %d)\n", name, i);
-	}
-	gf_sys_format_help(helpout, help_flags, " \nCICP Color Matrix Coefficients:\n");
-	for (i=0; i<GF_CICP_MX_LAST; i++) {
-		const char *name = gf_cicp_color_matrix_name(i);
-		if (!name) continue;
-		gf_sys_format_help(helpout, help_flags, " - `%s` (value %d)\n", name, i);
-	}
-}
-
-MP4BoxArg m4b_usage_args =
-{
- 	MP4BOX_ARG("h", "print help\n"
- 		"- general: general options help\n"
-		"- hint: hinting options help\n"
-		"- dash: DASH segmenter help\n"
-		"- split: split options help\n"
-		"- import: import options help\n"
-		"- encode: scene description encoding options help\n"
-		"- meta: meta (HEIF, MPEG-21) handling options help\n"
-		"- extract: extraction options help\n"
-		"- dump: dump options help\n"
-		"- swf: Flash (SWF) options help\n"
-		"- crypt: ISMA E&A options help\n"
-		"- format: supported formats help\n"
-		"- live: BIFS streamer help\n"
-		"- core: libgpac core options\n"
-		"- all: print all the above help screens\n"
-		"- opts: print all options\n"
-		"- tags: print supported iTunes tags\n"
-		"- cicp: print various CICP code points\n"
-		"- VAL: search for option named `VAL` (without `-` or `--`) in MP4Box, libgpac core and all filters\n"
-		, GF_ARG_STRING, 0, parse_help, 0, ARG_IS_FUN | ARG_EMPTY | ARG_PUSH_SYSARGS),
- 	MP4BOX_ARG("hx", "look for given string in name and descriptions of all MP4Box and filters options"
-		, GF_ARG_STRING, 0, parse_help, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("nodes", "list supported MPEG4 nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("nodex", "list supported MPEG4 nodes and print nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("node", "get given MPEG4 node syntax and QP infolist", GF_ARG_STRING, 0, PrintNode, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("xnodes", "list supported X3D nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 2, ARG_IS_FUN),
- 	MP4BOX_ARG("xnodex", "list supported X3D nodes and print nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 3, ARG_IS_FUN),
- 	MP4BOX_ARG("xnode", "get given X3D node syntax", GF_ARG_STRING, 0, PrintNode, 1, ARG_IS_FUN),
- 	MP4BOX_ARG("snodes", "list supported SVG nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 4, ARG_IS_FUN),
- 	MP4BOX_ARG("languages", "list supported ISO 639 languages", GF_ARG_BOOL, 0, PrintLanguages, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("boxes", "list all supported ISOBMF boxes and their syntax", GF_ARG_BOOL, 0, PrintBuiltInBoxes, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("boxcov", "perform coverage of box IO coode", GF_ARG_BOOL, GF_ARG_HINT_HIDE, PrintBuiltInBoxes, 1, ARG_IS_FUN|ARG_PUSH_SYSARGS),
- 	MP4BOX_ARG_ALT("stats", "fstat", "print filter session statistics (import/export/encrypt/decrypt/dashing)", GF_ARG_BOOL, 0, &fs_dump_flags, 1, ARG_BIT_MASK),
- 	MP4BOX_ARG_ALT("graph", "fgraph", "print filter session graph (import/export/encrypt/decrypt/dashing)", GF_ARG_BOOL, 0, &fs_dump_flags, 2, ARG_BIT_MASK),
- 	MP4BOX_ARG("v", "verbose mode", GF_ARG_BOOL, 0, &verbose, 0, ARG_INT_INC),
- 	MP4BOX_ARG("version", "get build version", GF_ARG_BOOL, 0, print_version, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("genmd", "generate MD doc", GF_ARG_BOOL, GF_ARG_HINT_HIDE, parse_gendoc, 0, ARG_IS_FUN),
- 	MP4BOX_ARG("genman", "generate man doc", GF_ARG_BOOL, GF_ARG_HINT_HIDE, parse_gendoc, 1, ARG_IS_FUN),
- 	MP4BOX_ARG_S("-", "INPUT", "escape option if INPUT starts with `-` character", 0, NULL, 0, 0),
- 	{0}
-};
-
-void PrintUsage()
-{
-	u32 i=0;
-	gf_sys_format_help(helpout, help_flags, "MP4Box option input option\n"
-		" \n"
-		"# General Options:\n"
-	);
-	while (m4b_usage_argsi.name) {
-		GF_GPACArg *arg = (GF_GPACArg *) &m4b_usage_argsi;
-		i++;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-general");
-	}
-}
-
-/*
- * 		END OF ARGS PARSING AND HELP
- */
-
-
-enum
-{
-	SEARCH_ARG_EXACT,
-	SEARCH_ARG_CLOSE,
-	SEARCH_DESC,
-};
-
-static u32 PrintHelpForArgs(char *arg_name, MP4BoxArg *args, GF_GPACArg *_args, u32 search_type, char *class_name)
-{
-	char szDesc100;
-	u32 res=0;
-	u32 i=0;
-	u32 alen = (u32) strlen(arg_name);
-
-	sprintf(szDesc, "see MP4Box -h %s", class_name);
-
-	while (1) {
-		u32 flags=0;
-		GF_GPACArg *arg;
-		GF_GPACArg an_arg;
-		Bool do_match = GF_FALSE;
-		if (args) {
-			if (!argsi.name)
-				break;
-			arg = (GF_GPACArg *) &argsi;
-		} else {
-			if (!_argsi.name)
-				break;
-			arg = &_argsi;
-		}
-
-		if (args == m4b_imp_fileopt_args) {
-			flags = GF_PRINTARG_COLON;
-			if (!strncmp(arg_name, arg->name, alen) && ((arg->namealen==0) || (arg->namealen=='=')))
-				do_match = GF_TRUE;
-		}
-		else if (!strcmp(arg_name, arg->name))
-			do_match = GF_TRUE;
-		else if ((alen < (u32) strlen(arg->name)) && (arg->namealen==' ') && !strncmp(arg_name, arg->name, alen))
-			do_match = GF_TRUE;
-
-		if (arg_name0 == '@')
-			do_match = GF_TRUE;
-
-		if ((search_type==SEARCH_ARG_EXACT) && !do_match) {
-			i++;
-			continue;
-		}
-		if ((search_type==SEARCH_ARG_CLOSE) && !gf_sys_word_match(arg_name, arg->name)) {
-			i++;
-			continue;
-		}
-		if ((search_type==SEARCH_DESC) && strcmp(arg->name, arg_name) && !gf_strnistr(arg->description, arg_name, alen)) {
-			i++;
-			continue;
-		}
-
-		an_arg = *arg;
-		if (search_type!=SEARCH_ARG_EXACT) {
-			if (search_type == SEARCH_DESC)
-				an_arg.description = szDesc;
-			else
-				an_arg.description = NULL;
-			an_arg.type = GF_ARG_BOOL;
-			gf_sys_print_arg(helpout, flags, (GF_GPACArg *) &an_arg, "");
-
-		} else {
-			gf_sys_print_arg(helpout, flags, (GF_GPACArg *) &an_arg, "");
-		}
-		res++;
-		i++;
-	}
-	return res;
-}
-static Bool PrintHelpArg(char *arg_name, u32 search_type, GF_FilterSession *fs)
-{
-	char szDesc100;
-	Bool first=GF_TRUE;
-	GF_GPACArg an_arg;
-	u32 i, count;
-	u32 res = 0;
-	u32 alen = (u32) strlen(arg_name);
-	res += PrintHelpForArgs(arg_name, m4b_gen_args, NULL, search_type, "general");
-	res += PrintHelpForArgs(arg_name, m4b_split_args, NULL, search_type, "split");
-	res += PrintHelpForArgs(arg_name, m4b_dash_args, NULL, search_type, "dash");
-	res += PrintHelpForArgs(arg_name, m4b_imp_args, NULL, search_type, "import");
-	res += PrintHelpForArgs(arg_name, m4b_imp_fileopt_args, NULL, search_type, "import (per-file option)");
-	res += PrintHelpForArgs(arg_name, m4b_senc_args, NULL, search_type, "encode");
-	res += PrintHelpForArgs(arg_name, m4b_crypt_args, NULL, search_type, "crypt");
-	res += PrintHelpForArgs(arg_name, m4b_hint_args, NULL, search_type, "hint");
-	res += PrintHelpForArgs(arg_name, m4b_extr_args, NULL, search_type, "extract");
-	res += PrintHelpForArgs(arg_name, m4b_dump_args, NULL, search_type, "dump");
-	res += PrintHelpForArgs(arg_name, m4b_meta_args, NULL, search_type, "meta");
-	res += PrintHelpForArgs(arg_name, m4b_swf_args, NULL, search_type, "swf");
-	res += PrintHelpForArgs(arg_name, m4b_liveenc_args, NULL, search_type, "live");
-	res += PrintHelpForArgs(arg_name, m4b_usage_args, NULL, search_type, "");
-	res += PrintHelpForArgs(arg_name, NULL, (GF_GPACArg *) gf_sys_get_options(), search_type, "core");
-
-	if (!fs) return res;
-
-	memset(&an_arg, 0, sizeof(GF_GPACArg));
-	count = gf_fs_filters_registers_count(fs);
-	for (i=0; i<count; i++) {
-		u32 j=0;
-		const GF_FilterRegister *reg = gf_fs_get_filter_register(fs, i);
-
-		while (reg->args) {
-			u32 len;
-			const GF_FilterArgs *arg = &reg->argsj;
-			if (!arg || !arg->arg_name) break;
-			j++;
-			if ((search_type==SEARCH_ARG_EXACT) && strcmp(arg->arg_name, arg_name)) continue;
-
-			if ((search_type==SEARCH_ARG_CLOSE) && !gf_sys_word_match(arg->arg_name, arg_name)) continue;
-
-			if (search_type==SEARCH_DESC) {
-				if (stricmp(arg->arg_name, arg_name) && !gf_strnistr(arg->arg_desc, arg_name, alen)) continue;
-			}
-
-			an_arg.name = arg->arg_name;
-			if (search_type==SEARCH_ARG_EXACT) {
-				an_arg.description = arg->arg_desc;
-				switch (arg->arg_type) {
-				case GF_PROP_BOOL:
-					an_arg.type = GF_ARG_BOOL;
-					break;
-				case GF_PROP_UINT:
-				case GF_PROP_SINT:
-					an_arg.type = GF_ARG_INT;
-					break;
-				case GF_PROP_DOUBLE:
-					an_arg.type = GF_ARG_DOUBLE;
-					break;
-				case GF_PROP_STRING_LIST:
-				case GF_PROP_UINT_LIST:
-				case GF_PROP_SINT_LIST:
-				case GF_PROP_VEC2I_LIST:
-					an_arg.type = GF_ARG_STRINGS;
-					break;
-				case GF_PROP_4CC:
-					an_arg.type = GF_ARG_4CC;
-					break;
-				case GF_PROP_4CC_LIST:
-					an_arg.type = GF_ARG_4CCS;
-					break;
-				default:
-					an_arg.type = GF_ARG_STRING;
-					break;
-				}
-				if (first) {
-					first = GF_FALSE;
-					gf_sys_format_help(helpout, 0, "\nGlobal filter session arguments matching %s:\n", arg_name);
-					//. Syntax is `--arg` or `--arg=VAL`. `F` indicates filter name. See `gpac -h` and `gpac -h F` for more info.\n");
-				}
-				fprintf(helpout, "%s", reg->name);
-				len = (u32)strlen(reg->name);
-				while (len<10) {
-					len++;
-					fprintf(helpout, " ");
-				}
-				fprintf(helpout, " ");
-			} else if (search_type==SEARCH_DESC) {
-				sprintf(szDesc, "see filter %s", reg->name);
-				an_arg.description = szDesc;
-			}
-
-			gf_sys_print_arg(helpout, GF_PRINTARG_ADD_DASH, &an_arg, "TEST");
-			res++;
-		}
-	}
-	if (res) return GF_TRUE;
-	return GF_FALSE;
-}
-
-static void PrintHelp(char *arg_name, Bool search_desc, Bool no_match)
-{
-	GF_FilterSession *fs;
-	Bool res;
-
-	fs = gf_fs_new_defaults(0);
-
-	if (arg_name0=='-')
-		arg_name++;
-
-	if (search_desc) {
-		char *_arg_name = gf_strdup(arg_name);
-		strlwr(_arg_name);
-		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Possible options mentioning `%s`:\n", arg_name));
-		PrintHelpArg(_arg_name, SEARCH_DESC, fs);
-		gf_free(_arg_name);
-	} else {
-		res = no_match ? GF_FALSE : PrintHelpArg(arg_name, SEARCH_ARG_EXACT, fs);
-		if (!res) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Option -%s unknown, please check usage.\n", arg_name));
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Possible options are:\n"));
-
-			PrintHelpArg(arg_name, SEARCH_ARG_CLOSE, fs);
-		}
-	}
-	if (fs)
-		gf_fs_del(fs);
-}
-
-
-u32 parse_sdp_ext(char *arg_val, u32 param)
-{
-	char *id;
-	sdp_lines = gf_realloc(sdp_lines, sizeof(SDPLine) * (nb_sdp_ex + 1));
-	if (!sdp_lines) return 2;
-	id = strchr(arg_val, ':');
-	if (id) {
-		id0 = 0;
-		if (sscanf(arg_val, "%u", &sdp_linesnb_sdp_ex.trackID) == 1) {
-			id0 = ':';
-			sdp_linesnb_sdp_ex.line = id + 1;
-		}
-		else {
-			id0 = ':';
-			sdp_linesnb_sdp_ex.line = arg_val;
-			sdp_linesnb_sdp_ex.trackID = 0;
-		}
-	}
-	else {
-		sdp_linesnb_sdp_ex.line = arg_val;
-		sdp_linesnb_sdp_ex.trackID = 0;
-	}
-	open_edit = GF_TRUE;
-	nb_sdp_ex++;
-	return GF_FALSE;
-}
-
-
-#ifndef GPAC_DISABLE_ISOM_WRITE
-static u32 parse_meta_args(char *opts, MetaActionType act_type)
-{
-	MetaAction *meta;
-
-	metas = gf_realloc(metas, sizeof(MetaAction) * (nb_meta_act + 1));
-	if (!metas) return 2;
-	meta = &metasnb_meta_act;
-	nb_meta_act ++;
-
-	memset(meta, 0, sizeof(MetaAction));
-	meta->act_type = act_type;
-	meta->trackID = 0;
-	meta->root_meta = 1;
-	open_edit = GF_TRUE;
-
-	if (!opts) return 2;
-
-	if (act_type == META_ACTION_ADD_IMAGE_ITEM)
-		has_add_image = GF_TRUE;
-
-#define CHECK_IMGPROP\
-			if (!meta->image_props) {\
-				GF_SAFEALLOC(meta->image_props, GF_ImageItemProperties);\
-				if (!meta->image_props) return 2;\
-			}\
-
-	while (1) {
-		char *next;
-		char *szSlot;
-		if (!opts || !opts0) return 0;
-		if (opts0==':') opts += 1;
-
-		szSlot = opts;
-		next = gf_url_colon_suffix(opts, '=');
-		if (next) next0 = 0;
-		if (next && !strncmp(szSlot, "auxt", 4)) {
-			next0 = ':';
-			char *sep = strchr(next, '=');
-			if (sep) {
-				next = sep;
-				while (next0 != ':')
-					next--;
-
-				next0 = 0;
-			}
-		}
-
-		if (!strnicmp(szSlot, "tk=", 3)) {
-			sscanf(szSlot, "tk=%u", &meta->trackID);
-			if (act_type == META_ACTION_ADD_ITEM)
-				meta->root_meta = 0;
-		}
-		else if (!strnicmp(szSlot, "id=", 3)) {
-			meta->item_id = atoi(szSlot+3);
-		}
-		else if (!strnicmp(szSlot, "type=", 5)) {
-			meta->item_type = GF_4CC(szSlot5, szSlot6, szSlot7, szSlot8);
-		}
-		//"ref" (without '=') is for data reference, "ref=" is for item references
-		else if (!strnicmp(szSlot, "ref=", 4)) {
-			char type5;
-			MetaRef	*ref;
-			if (!meta->item_refs) {
-				meta->item_refs = gf_list_new();
-				if (!meta->item_refs) return 2;
-			}
-			GF_SAFEALLOC(ref, MetaRef);
-			if (!ref) return 2;
-			sscanf(szSlot, "ref=%4s,%u", type, &(ref->ref_item_id));
-			ref->ref_type = GF_4CC(type0, type1, type2, type3);
-			gf_list_add(meta->item_refs, ref);
-		}
-		else if (!strnicmp(szSlot, "name=", 5)) {
-			meta->szName = gf_strdup(szSlot+5);
-		}
-		else if (!strnicmp(szSlot, "path=", 5)) {
-			meta->szPath = gf_strdup(szSlot+5);
-		}
-		else if (!strnicmp(szSlot, "mime=", 5)) {
-			meta->item_type = GF_META_ITEM_TYPE_MIME;
-			meta->mime_type = gf_strdup(szSlot+5);
-		}
-		else if (!strnicmp(szSlot, "encoding=", 9)) {
-			meta->enc_type = gf_strdup(szSlot+9);
-		}
-		else if (!strnicmp(szSlot, "image-size=", 11)) {
-			CHECK_IMGPROP
-			sscanf(szSlot+11, "%dx%d", &meta->image_props->width, &meta->image_props->height);
-		}
-		else if (!strnicmp(szSlot, "image-grid-size=", 16)) {
-			CHECK_IMGPROP
-			sscanf(szSlot+16, "%dx%d", &meta->image_props->num_grid_rows, &meta->image_props->num_grid_columns);
-		}
-		else if (!strnicmp(szSlot, "image-overlay-color=", 20)) {
-			CHECK_IMGPROP
-			sscanf(szSlot+20, "%d,%d,%d,%d", &meta->image_props->overlay_canvas_fill_value_r,&meta->image_props->overlay_canvas_fill_value_g,&meta->image_props->overlay_canvas_fill_value_b,&meta->image_props->overlay_canvas_fill_value_a);
-		}
-		else if (!strnicmp(szSlot, "image-overlay-offsets=", 22)) {
-			CHECK_IMGPROP
-			u32 position = 22;
-			u32 comma_count = 0;
-			u32 offset_index = 0;
-			char *prev = szSlot+position;
-			char *sub_next = strchr(szSlot+position, ',');
-			while (sub_next != NULL) {
-				comma_count++;
-				sub_next++;
-				sub_next = strchr(sub_next, ',');
-			}
-			meta->image_props->overlay_count = comma_count/2+1;
-			meta->image_props->overlay_offsets = (GF_ImageItemOverlayOffset *)gf_malloc(meta->image_props->overlay_count*sizeof(GF_ImageItemOverlayOffset));
-			if (!meta->image_props->overlay_offsets) {
-				return 0;
-			}
-			sub_next = strchr(szSlot+position, ',');
-			while (sub_next != NULL) {
-				*sub_next = 0;
-				meta->image_props->overlay_offsetsoffset_index.horizontal = atoi(prev);
-				*sub_next = ',';
-				sub_next++;
-				prev = sub_next;
-				if (sub_next) {
-					sub_next = strchr(sub_next, ',');
-					if (sub_next) *sub_next = 0;
-					meta->image_props->overlay_offsetsoffset_index.vertical = atoi(prev);
-					if (sub_next) {
-						*sub_next = ',';
-						sub_next++;
-						prev = sub_next;
-						sub_next = strchr(sub_next, ',');
-					}
-				} else {
-					meta->image_props->overlay_offsetsoffset_index.vertical = 0;
-				}
-				offset_index++;
-			}
-		}
-		else if (!strnicmp(szSlot, "image-pasp=", 11)) {
-			CHECK_IMGPROP
-			sscanf(szSlot+11, "%dx%d", &meta->image_props->hSpacing, &meta->image_props->vSpacing);
-		}
-		else if (!strnicmp(szSlot, "image-pixi=", 11)) {
-			CHECK_IMGPROP
-			if (strchr(szSlot+11, ',') == NULL) {
-				meta->image_props->num_channels = 1;
-				meta->image_props->bits_per_channel0 = atoi(szSlot+11);
-			} else {
-				meta->image_props->num_channels = 3;
-				sscanf(szSlot+11, "%u,%u,%u", &(meta->image_props->bits_per_channel0), &(meta->image_props->bits_per_channel1), &(meta->image_props->bits_per_channel2));
-			}
-		}
-		else if (!strnicmp(szSlot, "image-rloc=", 11)) {
-			CHECK_IMGPROP
-			sscanf(szSlot+11, "%dx%d", &meta->image_props->hOffset, &meta->image_props->vOffset);
-		}
-		else if (!strnicmp(szSlot, "rotation=", 9)) {
-			CHECK_IMGPROP
-			meta->image_props->angle = atoi(szSlot+9);
-		}
-		else if (!strnicmp(szSlot, "mirror-axis=", 12)) {
-			CHECK_IMGPROP
-			meta->image_props->mirror = (!strnicmp(szSlot+12, "vertical", 8) ? 1 : 2);
-		}
-		else if (!strnicmp(szSlot, "clap=", 5)) {
-			CHECK_IMGPROP
-			sscanf(szSlot + 5, "%d,%d,%d,%d,%d,%d,%d,%d", &meta->image_props->clap_wnum, &meta->image_props->clap_wden,
-					 &meta->image_props->clap_hnum, &meta->image_props->clap_hden,
-					 &meta->image_props->clap_honum, &meta->image_props->clap_hoden,
-					 &meta->image_props->clap_vonum, &meta->image_props->clap_voden);
-		}
-		else if (!stricmp(szSlot, "hidden")) {
-			CHECK_IMGPROP
-			meta->image_props->hidden = GF_TRUE;
-		}
-		else if (!stricmp(szSlot, "alpha")) {
-			CHECK_IMGPROP
-			meta->image_props->alpha = GF_TRUE;
-		}
-		else if (!stricmp(szSlot, "depth")) {
-			CHECK_IMGPROP
-			meta->image_props->depth = GF_TRUE;
- 		}
-		//"ref" (without '=') is for data reference, "ref=" is for item references
-		else if (!stricmp(szSlot, "ref")) {
-			CHECK_IMGPROP
-			meta->image_props->use_reference = GF_TRUE;
-		}
-		else if (!strnicmp(szSlot, "it=", 3)) {
-			CHECK_IMGPROP
-			meta->image_props->item_ref_id = atoi(szSlot+3);
-		}
-		else if (!strnicmp(szSlot, "itp=", 4)) {
-			CHECK_IMGPROP
-			meta->image_props->item_ref_id = atoi(szSlot+4);
-			meta->image_props->copy_props = 1;
-		}
-		else if (!strnicmp(szSlot, "time=", 5)) {
-			Float s=0, e=0, step=0;
-			CHECK_IMGPROP
-			if (sscanf(szSlot+5, "%f-%f/%f", &s, &e, &step)==3) {
-				meta->image_props->time = s;
-				meta->image_props->end_time = e;
-				meta->image_props->step_time = step;
-			} else if (sscanf(szSlot+5, "%f-%f", &s, &e)==2) {
-				meta->image_props->time = s;
-				meta->image_props->end_time = e;
-			} else if (sscanf(szSlot+5, "%f/%f", &s, &step)==2) {
-				meta->image_props->time = s;
-				meta->image_props->step_time = step;
-			} else if (sscanf(szSlot+5, "%f", &s)==1) {
-				meta->image_props->time = s;
-			}
-		}
-		else if (!strnicmp(szSlot, "samp=", 5)) {
-			CHECK_IMGPROP
-			meta->image_props->sample_num = atoi(szSlot+5);
-			meta->root_meta = 1;
-		}
-		else if (!strnicmp(szSlot, "group=", 6)) {
-			char type5;
-			sscanf(szSlot, "group=%4s,%u", type, &meta->group_id);
-			meta->group_type = GF_4CC(type0, type1, type2, type3);
-		}
-		else if (!stricmp(szSlot, "split_tiles")) {
-			CHECK_IMGPROP
-			meta->image_props->tile_mode = TILE_ITEM_ALL_BASE;
-		}
-		else if (!stricmp(szSlot, "dref")) {
-			meta->use_dref = 1;
-		}
-		else if (!stricmp(szSlot, "primary")) {
-			meta->primary = 1;
-		}
-		else if (!stricmp(szSlot, "binary")) {
-			if (meta->act_type==META_ACTION_SET_XML) meta->act_type=META_ACTION_SET_BINARY_XML;
-		}
-		else if (!strnicmp(szSlot, "icc_path=", 9)) {
-			CHECK_IMGPROP
-			strcpy(meta->image_props->iccPath, szSlot+9);
-		}
-		else if (!stricmp(szSlot, "agrid") || !strnicmp(szSlot, "agrid=", 6)) {
-			CHECK_IMGPROP
-			meta->image_props->auto_grid = GF_TRUE;
-			if (!strnicmp(szSlot, "agrid=", 6))
-				meta->image_props->auto_grid_ratio = atof(szSlot+6);
-		}
-		else if (!strnicmp(szSlot, "av1_op_index=", 13)) {
-			CHECK_IMGPROP
-			meta->image_props->av1_op_index = atoi(szSlot+13);
-		}
-		else if (!stricmp(szSlot, "replace")) {
-			meta->replace = GF_TRUE;
-		}
-		else if (!strnicmp(szSlot, "keep_props=", 11)) {
-			CHECK_IMGPROP
-			meta->keep_props = gf_strdup(szSlot+11);
-		}
-		else if (!strnicmp(szSlot, "auxt=", 5)) {
-			CHECK_IMGPROP
-			meta->image_props->aux_urn = gf_strdup(szSlot+5);
-		}
-		else if (!strnicmp(szSlot, "auxd=", 5)) {
-			CHECK_IMGPROP
-			GF_Err e = gf_file_load_data(szSlot+5, (u8 **) &meta->image_props->aux_data, &meta->image_props->aux_data_len);
-			if (e) {
-				M4_LOG(GF_LOG_ERROR, ("Failed to load auxiliary data file %s: %s\n", szSlot+5, gf_error_to_string(e) ));
-				return 1;
-			}
-		}
-		else if (!strchr(szSlot, '=')) {
-			switch (meta->act_type) {
-			case META_ACTION_SET_TYPE:
-				if (!stricmp(szSlot, "null") || !stricmp(szSlot, "0")) meta->meta_4cc = 0;
-				else meta->meta_4cc = GF_4CC(szSlot0, szSlot1, szSlot2, szSlot3);
-				break;
-			case META_ACTION_ADD_ITEM:
-			case META_ACTION_ADD_IMAGE_ITEM:
-			case META_ACTION_SET_XML:
-			case META_ACTION_DUMP_XML:
-				if (!strncmp(szSlot, "dopt", 4) || !strncmp(szSlot, "sopt", 4) || !strncmp(szSlot, "@", 1)) {
-					if (next) next0=':';
-					next=NULL;
-				}
-				//cat as -add arg
-				gf_dynstrcat(&meta->szPath, szSlot, ":");
-				if (!meta->szPath) return 2;
-				break;
-			case META_ACTION_REM_ITEM:
-			case META_ACTION_SET_PRIMARY_ITEM:
-			case META_ACTION_DUMP_ITEM:
-				meta->item_id = atoi(szSlot);
-				break;
-			default:
-				break;
-			}
-		}
-		if (!next) break;
-		opts += strlen(szSlot);
-		next0 = ':';
-	}
-	return 0;
-}
-#endif //GPAC_DISABLE_ISOM_WRITE
-
-
-#ifndef GPAC_DISABLE_ISOM_WRITE
-static Bool parse_tsel_args(char *opts, TSELActionType act)
-{
-	GF_ISOTrackID refTrackID = 0;
-	Bool has_switch_id;
-	u32 switch_id = 0;
-	u32 criteria30;
-	u32 nb_criteria = 0;
-	TSELAction *tsel_act;
-	char szSlot1024;
-
-	has_switch_id = 0;
-
-	if (!opts) return 0;
-	while (1) {
-		char *next;
-		if (!opts || !opts0) return 0;
-		if (opts0==':') opts += 1;
-		strcpy(szSlot, opts);
-		next = gf_url_colon_suffix(szSlot, '=');
-		if (next) next0 = 0;
-
-
-		if (!strnicmp(szSlot, "refTrack=", 9)) refTrackID = atoi(szSlot+9);
-		else if (!strnicmp(szSlot, "switchID=", 9)) {
-			if (atoi(szSlot+9)<0) {
-				switch_id = 0;
-				has_switch_id = 0;
-			} else {
-				switch_id = atoi(szSlot+9);
-				has_switch_id = 1;
-			}
-		}
-		else if (!strnicmp(szSlot, "switchID", 8)) {
-			switch_id = 0;
-			has_switch_id = 1;
-		}
-		else if (!strnicmp(szSlot, "criteria=", 9)) {
-			u32 j=9;
-			nb_criteria = 0;
-			while (j+3<strlen(szSlot)) {
-				criterianb_criteria = GF_4CC(szSlotj, szSlotj+1, szSlotj+2, szSlotj+3);
-				j+=5;
-				nb_criteria++;
-			}
-		}
-		else if (!strnicmp(szSlot, "trackID=", 8) || !strchr(szSlot, '=') ) {
-			tsel_acts = gf_realloc(tsel_acts, sizeof(TSELAction) * (nb_tsel_acts + 1));
-			if (!tsel_acts) return 2;
-
-			tsel_act = &tsel_actsnb_tsel_acts;
-			nb_tsel_acts++;
-
-			memset(tsel_act, 0, sizeof(TSELAction));
-			tsel_act->act_type = act;
-			tsel_act->trackID = strchr(szSlot, '=') ? atoi(szSlot+8) : atoi(szSlot);
-			tsel_act->refTrackID = refTrackID;
-			tsel_act->switchGroupID = switch_id;
-			tsel_act->is_switchGroup = has_switch_id;
-			tsel_act->nb_criteria = nb_criteria;
-			memcpy(tsel_act->criteria, criteria, sizeof(u32)*nb_criteria);
-
-			if (!refTrackID)
-				refTrackID = tsel_act->trackID;
-
-			open_edit = GF_TRUE;
-		}
-		opts += strlen(szSlot);
-	}
-	return 0;
-}
-#endif // GPAC_DISABLE_ISOM_WRITE
-
-
-GF_DashSegmenterInput *set_dash_input(GF_DashSegmenterInput *dash_inputs, char *name, u32 *nb_dash_inputs)
-{
-	GF_DashSegmenterInput *di;
-	Bool skip_rep_id = GF_FALSE;
-	char *other_opts = NULL;
-	char *sep = gf_url_colon_suffix(name, '=');
-
-	dash_inputs = gf_realloc(dash_inputs, sizeof(GF_DashSegmenterInput) * (*nb_dash_inputs + 1) );
-	memset(&dash_inputs*nb_dash_inputs, 0, sizeof(GF_DashSegmenterInput) );
-	di = &dash_inputs*nb_dash_inputs;
-	(*nb_dash_inputs)++;
-
-	if (sep) {
-		char *opts, *first_opt;
-		first_opt = sep;
-		opts = sep+1;
-		while (opts) {
-			//none of our options use filenames, so don't check for '='
-			sep = gf_url_colon_suffix(opts, 0);
-			if (sep && !strncmp(sep, "://", 3) && strncmp(sep, ":@", 2)) sep = gf_url_colon_suffix(sep+3, 0);
-			if (sep) sep0 = 0;
-
-			if (!strnicmp(opts, "id=", 3)) {
-				if (!stricmp(opts+3, "NULL"))
-					skip_rep_id = GF_TRUE;
-				else
-					di->representationID = gf_strdup(opts+3);
-				/*we allow the same repID to be set to force muxed representations*/
-			}
-			else if (!strnicmp(opts, "dur=", 4)) gf_parse_lfrac(opts+4, &di->media_duration);
-			else if (!strnicmp(opts, "period=", 7)) di->periodID = gf_strdup(opts+7);
-			else if (!strnicmp(opts, "BaseURL=", 8)) {
-				di->baseURL = (char **)gf_realloc(di->baseURL, (di->nb_baseURL+1)*sizeof(char *));
-				di->baseURLdi->nb_baseURL = gf_strdup(opts+8);
-				di->nb_baseURL++;
-			} else if (!strnicmp(opts, "bandwidth=", 10)) di->bandwidth = atoi(opts+10);
-			else if (!strnicmp(opts, "role=", 5)) {
-				di->roles = gf_realloc(di->roles, sizeof (char *) * (di->nb_roles+1));
-				di->rolesdi->nb_roles = gf_strdup(opts+5);
-				di->nb_roles++;
-			} else if (!strnicmp(opts, "desc", 4)) {
-				u32 *nb_descs=NULL;
-				char ***descs=NULL;
-				u32 opt_offset=0;
-				u32 len;
-				if (!strnicmp(opts, "desc_p=", 7)) {
-					nb_descs = &di->nb_p_descs;
-					descs = &di->p_descs;
-					opt_offset = 7;
-				} else if (!strnicmp(opts, "desc_as=", 8)) {
-					nb_descs = &di->nb_as_descs;
-					descs = &di->as_descs;
-					opt_offset = 8;
-				} else if (!strnicmp(opts, "desc_as_c=", 8)) {
-					nb_descs = &di->nb_as_c_descs;
-					descs = &di->as_c_descs;
-					opt_offset = 10;
-				} else if (!strnicmp(opts, "desc_rep=", 8)) {
-					nb_descs = &di->nb_rep_descs;
-					descs = &di->rep_descs;
-					opt_offset = 9;
-				}
-				if (opt_offset) {
-					(*nb_descs)++;
-					opts += opt_offset;
-					len = (u32) strlen(opts);
-					(*descs) = (char **)gf_realloc((*descs), (*nb_descs)*sizeof(char *));
-					(*descs)(*nb_descs)-1 = (char *)gf_malloc((len+1)*sizeof(char));
-					memcpy((*descs)(*nb_descs)-1, opts, len);
-					(*descs)(*nb_descs)-1len = 0;
-				}
-
-			}
-			else if (!strnicmp(opts, "xlink=", 6)) di->xlink = gf_strdup(opts+6);
-			else if (!strnicmp(opts, "sscale", 6)) di->sscale = GF_TRUE;
-			else if (!strnicmp(opts, "pdur=", 5)) gf_parse_frac(opts+5, &di->period_duration);
-			else if (!strnicmp(opts, "period_duration=", 16)) gf_parse_frac(opts+16, &di->period_duration);
-			else if (!strnicmp(opts, "ddur=", 5)) gf_parse_frac(opts+5, &di->dash_duration);
-			else if (!strnicmp(opts, "duration=", 9)) gf_parse_frac(opts+9, &di->dash_duration);
-			else if (!strnicmp(opts, "asID=", 5)) di->asID = atoi(opts+5);
-			else if (!strnicmp(opts, "sn=", 3)) di->startNumber = atoi(opts+3);
-			else if (!strnicmp(opts, "tpl=", 4)) di->seg_template = gf_strdup(opts+4);
-			else if (!strnicmp(opts, "hls=", 4)) di->hls_pl = gf_strdup(opts+4);
-			else if (!strnicmp(opts, "trackID=", 8)) di->track_id = atoi(opts+8);
-			else if (!strnicmp(opts, "@", 1)) {
-				Bool old_syntax = (opts1=='@') ? GF_TRUE : GF_FALSE;
-				if (sep) sep0 = ':';
-				di->filter_chain = gf_strdup(opts + (old_syntax ? 2 : 1) );
-				sep = NULL;
-				if (!old_syntax && (strstr(di->filter_chain, "@@")!=NULL)) {
-					skip_rep_id = GF_TRUE;
-				}
-			} else {
-				gf_dynstrcat(&other_opts, opts, ":");
-			}
-
-			if (!sep) break;
-			sep0 = ':';
-			opts = sep+1;
-		}
-		first_opt0 = '\0';
-	}
-	di->file_name = name;
-	di->source_opts = other_opts;
-
-	if (!skip_rep_id && !di->representationID) {
-		char szRep100;
-		sprintf(szRep, "%d", *nb_dash_inputs);
-		di->representationID = gf_strdup(szRep);
-	}
-
-	return dash_inputs;
-}
-
-static Bool create_new_track_action(char *arg_val, u32 act_type, u32 dump_type)
-{
-	TrackAction *tka;
-	char *param = arg_val;
-	tracks = (TrackAction *)gf_realloc(tracks, sizeof(TrackAction) * (nb_track_act+1));
-	if (!tracks) return GF_FALSE;
-
-	tka = & tracksnb_track_act;
-	nb_track_act++;
-
-	memset(tka, 0, sizeof(TrackAction) );
-	tka->act_type = act_type;
-	tka->dump_type = dump_type;
-	if (act_type != TRACK_ACTION_RAW_EXTRACT) {
-		open_edit = GF_TRUE;
-		do_save = GF_TRUE;
-	}
-
-	if ((act_type==TRACK_ACTION_SET_ID) || (act_type==TRACK_ACTION_SWAP_ID)) {
-		if (sscanf(param, "%d:%u", &tka->trackID, &tka->newTrackID) != 2) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for -set-track-id - expecting \"id1:id2\" got \"%s\"\n", param));
-			return GF_FALSE;
-		}
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_SET_PAR) {
-		char *ext;
-		ext = strchr(param, '=');
-		if (!ext) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track par - expecting tkID=none or tkID=PAR_NUM:PAR_DEN got %s\n", param));
-			return GF_FALSE;
-		}
-		ext0 = 0;
-		tka->trackID = atoi(param);
-		ext0 = '=';
-
-		if (!stricmp(ext+1, "none"))
-			tka->par_num = tka->par_den = 0;
-		else if (!stricmp(ext+1, "auto")) {
-			tka->par_num = tka->par_den = -1;
-			tka->force_par = 1;
-		}
-		else if (!stricmp(ext+1, "force")) {
-			tka->par_num = tka->par_den = 1;
-			tka->force_par = 1;
-		}
-		else {
-			if (ext1=='w') {
-				tka->rewrite_bs = 1;
-				ext++;
-			}
-			if (sscanf(ext+1, "%d:%d", &tka->par_num, &tka->par_den) != 2) {
-				M4_LOG(GF_LOG_ERROR, ("Bad format for track par - expecting tkID=PAR_NUM:PAR_DEN got %s\n", param));
-				return GF_FALSE;
-			}
-		}
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_SET_CLAP) {
-		char *ext = strchr(param, '=');
-		if (!ext) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track clap - expecting tkID=none or tkID=Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd got %s\n", param));
-			return GF_FALSE;
-		}
-		ext0 = 0;
-		tka->trackID = atoi(param);
-		ext0 = '=';
-		if (stricmp(ext + 1, "none")) {
-			if (sscanf(ext + 1, "%d,%d,%d,%d,%d,%d,%d,%d", &tka->clap_wnum, &tka->clap_wden, &tka->clap_hnum, &tka->clap_hden, &tka->clap_honum, &tka->clap_hoden, &tka->clap_vonum, &tka->clap_voden) != 8) {
-
-				M4_LOG(GF_LOG_ERROR, ("Bad format for track clap - expecting tkID=none or tkID=Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd got %s\n", param));
-				return GF_FALSE;
-			}
-		}
-		return GF_TRUE;
-	}
-
-	if (act_type==TRACK_ACTION_SET_MX) {
-		char *ext = strchr(param, '=');
-		if (!ext) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track matrix - expecting ID=none or ID=M1:M2:M3:M4:M5:M6:M7:M8:M9 got %s\n", param));
-			return GF_FALSE;
-		}
-		ext0 = 0;
-		tka->trackID = atoi(param);
-		ext0 = '=';
-		if (!stricmp(ext + 1, "none")) {
-			memset(tka->mx, 0, sizeof(s32)*9);
-			tka->mx0 = tka->mx4 = tka->mx8 = 1;
-		} else {
-			s32 res;
-			if (strstr(ext+1, "0x")) {
-				res = sscanf(ext + 1, "0x%d:0x%d:0x%d:0x%d:0x%d:0x%d:0x%d:0x%d:0x%d", &tka->mx0, &tka->mx1, &tka->mx2, &tka->mx3, &tka->mx4, &tka->mx5, &tka->mx6, &tka->mx7, &tka->mx8);
-			} else {
-				res = sscanf(ext + 1, "%d:%d:%d:%d:%d:%d:%d:%d:%d", &tka->mx0, &tka->mx1, &tka->mx2, &tka->mx3, &tka->mx4, &tka->mx5, &tka->mx6, &tka->mx7, &tka->mx8);
-			}
-			if (res != 9) {
-				M4_LOG(GF_LOG_ERROR, ("Bad format for track matrix - expecting ID=none or ID=M1:M2:M3:M4:M5:M6:M7:M8:M9 got %s\n", param));
-				return GF_FALSE;
-			}
-		}
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_SET_EDITS) {
-		char *ext = strchr(param, '=');
-		if (!ext) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track edits - expecting ID=EDITS got %s\n", param));
-			return GF_FALSE;
-		}
-		ext0 = 0;
-		tka->trackID = atoi(param);
-		ext0 = '=';
-		tka->string = gf_strdup(ext+1);
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_SET_LANGUAGE) {
-		char *ext = strchr(param, '=');
-		if (!strnicmp(param, "all=", 4)) {
-			strncpy(tka->lang, param + 4, 10-1);
-		}
-		else if (!ext) {
-			strncpy(tka->lang, param, 10-1);
-		} else {
-			strncpy(tka->lang, ext + 1, 10-1);
-			ext0 = 0;
-			tka->trackID = atoi(param);
-			ext0 = '=';
-		}
-		return GF_TRUE;
-	}
-	if ((act_type==TRACK_ACTION_SET_KIND) || (act_type==TRACK_ACTION_REM_KIND)) {
-		char *ext;
-		char *scheme_start = NULL;
-
-		//extract trackID
-		if (!strnicmp(param, "all=", 4)) {
-			scheme_start = param + 4;
-		} else {
-			ext = strchr(param, '=');
-			if (ext) {
-				ext0 = 0;
-				if (sscanf(param, "%d", &tka->trackID) == 1) {
-					scheme_start = ext + 1;
-				} else {
-					scheme_start = param;
-				}
-				ext0 = '=';
-			} else {
-				scheme_start = param;
-			}
-		}
-
-		//extract scheme and value - if not, remove kind
-		if (!scheme_start || !scheme_start0) {
-			M4_LOG(GF_LOG_ERROR, ("Missing kind scheme - expecting ID=schemeURI=value got %s\n", param));
-			return GF_FALSE;
-		} else {
-			ext = strchr(scheme_start, '=');
-			if (!ext) {
-				tka->kind_scheme = gf_strdup(scheme_start);
-			} else {
-				ext0 = 0;
-				tka->kind_scheme = gf_strdup(scheme_start);
-				ext0 = '=';
-				tka->kind_value = gf_strdup(ext + 1);
-			}
-		}
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_SET_DELAY) {
-		char *ext = strchr(param, '=');
-		if (!ext) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track delay - expecting tkID=DLAY got %s\n", param));
-			return GF_FALSE;
-		}
-		ext0 = 0;
-		tka->trackID = atoi(param);
-		ext0 = '=';
-		if (sscanf(ext+1, "%d/%u", &tka->delay.num, &tka->delay.den) != 2) {
-			tka->delay.num = atoi(ext + 1);
-			tka->delay.den = 1000;
-		}
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_REFERENCE) {
-		char *ext = strchr(param, '=');
-		if (!ext) ext = strchr(param, ':');
-		if (!ext) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track reference - expecting tkID:XXXX:refID got %s\n", param));
-			return GF_FALSE;
-		}
-		ext0 = 0;
-		tka->trackID = atoi(param);
-		ext0 = '=';
-
-		char *ext2 = strchr(ext, ':');
-		if (!ext2) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track reference - expecting tkID:XXXX:refID got %s\n", param));
-			return GF_FALSE;
-		}
-		ext20 = 0;
-		strncpy(tka->lang, ext+1, 9);
-		ext20 = ':';
-		tka->newTrackID = (s32) atoi(ext2 + 1);
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_SET_HANDLER_NAME) {
-		char *ext = strchr(param, '=');
-		if (!ext) {
-			M4_LOG(GF_LOG_ERROR, ("Bad format for track name - expecting tkID=name got %s\n", param));
-			return GF_FALSE;
-		}
-		ext0 = 0;
-		tka->trackID = atoi(param);
-		ext0 = '=';
-		tka->hdl_name = ext + 1;
-		return GF_TRUE;
-	}
-	if (act_type==TRACK_ACTION_SET_KMS_URI) {
-		char *ext = strchr(param, '=');
-
-		if (!strnicmp(param, "all=", 4)) {
-			tka->kms = param + 4;
-		} else if (!ext) {
-			tka->kms = param;
-		} else {
-			tka->kms = ext + 1;
-			ext0 = 0;
-			tka->trackID = atoi(param);
-			ext0 = '=';
-		}
-		return GF_TRUE;
-	}
-	if ((act_type==TRACK_ACTION_SET_TIME) || (act_type==TRACK_ACTION_SET_MEDIA_TIME)) {
-		struct tm time;
-		char *ext = strchr(arg_val, '=');
-		if (ext) {
-			ext0 = 0;
-			tka->trackID = atoi(arg_val);
-			ext0 = '=';
-			arg_val = ext+1;
-		}
-		memset(&time, 0, sizeof(struct tm));
-		sscanf(arg_val, "%d/%d/%d-%d:%d:%d", &time.tm_mday, &time.tm_mon, &time.tm_year, &time.tm_hour, &time.tm_min, &time.tm_sec);
-		time.tm_isdst = 0;
-		time.tm_year -= 1900;
-		time.tm_mon -= 1;
-		tka->time = 2082758400;
-		tka->time += mktime(&time);
-		return GF_TRUE;
-	}
-
-	while (param) {
-		param = gf_url_colon_suffix(param, '=');
-		if (param) {
-			*param = 0;
-			param++;
-#ifndef GPAC_DISABLE_MEDIA_EXPORT
-			if (!strncmp("vttnomerge", param, 10)) {
-				tka->dump_type |= GF_EXPORT_WEBVTT_NOMERGE;
-			} else if (!strncmp("layer", param, 5)) {
-				tka->dump_type |= GF_EXPORT_SVC_LAYER;
-			} else if (!strncmp("full", param, 4)) {
-				tka->dump_type |= GF_EXPORT_NHML_FULL;
-			} else if (!strncmp("embedded", param, 8)) {
-				tka->dump_type |= GF_EXPORT_WEBVTT_META_EMBEDDED;
-			} else if (!strncmp("output=", param, 7)) {
-				tka->out_name = gf_strdup(param+7);
-			} else if (!strncmp("src=", param, 4)) {
-				tka->src_name = gf_strdup(param+4);
-			} else if (!strncmp("str=", param, 4)) {
-				tka->string = gf_strdup(param+4);
-			} else if (!strncmp("box=", param, 4)) {
-				tka->src_name = gf_strdup(param+4);
-				tka->sample_num = 1;
-			} else if (!strncmp("type=", param, 4)) {
-				tka->udta_type = GF_4CC(param5, param6, param7, param8);
-			} else if (tka->dump_type == GF_EXPORT_RAW_SAMPLES) {
-				tka->sample_num = atoi(param);
-			}
-#endif
-		}
-	}
-	if (arg_val) {
-		if (!strcmp(arg_val, "*")) {
-			tka->trackID = (u32) -1;
-		} else {
-			if (act_type==TRACK_ACTION_RAW_EXTRACT) {
-				if (!strncmp(arg_val, "video", 5)) {
-					arg_val += 5;
-					tka->dump_track_type = 1;
-				}
-				else if (!strncmp(arg_val, "audio", 5)) {
-					arg_val += 5;
-					tka->dump_track_type = 2;
-				}
-			}
-			if (arg_val0)
-				tka->trackID = atoi(arg_val);
-		}
-	}
-	return GF_TRUE;
-}
-
-u32 parse_track_dump(char *arg, u32 dump_type)
-{
-	if (!create_new_track_action(arg, TRACK_ACTION_RAW_EXTRACT, dump_type))
-		return 2;
-	track_dump_type = dump_type;
-	return 0;
-}
-u32 parse_track_action(char *arg, u32 act_type)
-{
-	if (!create_new_track_action(arg, act_type, 0)) {
-		return 2;
-	}
-	return 0;
-}
-
-u32 parse_comp_box(char *arg_val, u32 opt)
-{
-	compress_top_boxes = arg_val;
-	size_top_box = opt;
-	return 0;
-}
-u32 parse_dnal(char *arg_val, u32 opt)
-{
-	dump_nal = atoi(arg_val);
-	dump_nal_type = opt;
-	return 0;
-}
-u32 parse_dsap(char *arg_val, u32 opt)
-{
-	dump_saps = atoi(arg_val);
-	dump_saps_mode = opt;
-	return 0;
-}
-
-u32 parse_bs_switch(char *arg_val, u32 opt)
-{
-	if (!stricmp(arg_val, "no") || !stricmp(arg_val, "off")) bitstream_switching_mode = GF_DASH_BSMODE_NONE;
-	else if (!stricmp(arg_val, "merge")) bitstream_switching_mode = GF_DASH_BSMODE_MERGED;
-	else if (!stricmp(arg_val, "multi")) bitstream_switching_mode = GF_DASH_BSMODE_MULTIPLE_ENTRIES;
-	else if (!stricmp(arg_val, "single")) bitstream_switching_mode = GF_DASH_BSMODE_SINGLE;
-	else if (!stricmp(arg_val, "inband")) bitstream_switching_mode = GF_DASH_BSMODE_INBAND;
-	else if (!stricmp(arg_val, "pps")) bitstream_switching_mode = GF_DASH_BSMODE_INBAND_PPS;
-	else {
-		M4_LOG(GF_LOG_ERROR, ("Unrecognized bitstream switching mode \"%s\" - please check usage\n", arg_val));
-		return 2;
-	}
-	return 0;
-}
-
-u32 parse_cp_loc(char *arg_val, u32 opt)
-{
-	if (!strcmp(arg_val, "both")) cp_location_mode = GF_DASH_CPMODE_BOTH;
-	else if (!strcmp(arg_val, "as")) cp_location_mode = GF_DASH_CPMODE_ADAPTATION_SET;
-	else if (!strcmp(arg_val, "rep")) cp_location_mode = GF_DASH_CPMODE_REPRESENTATION;
-	else {
-		M4_LOG(GF_LOG_ERROR, ("Unrecognized ContentProtection loction mode \"%s\" - please check usage\n", arg_val));
-		return 2;
-	}
-	return 0;
-}
-
-u32 parse_pssh(char *arg_val, u32 opt)
-{
-	if (!strcmp(arg_val, "f")) pssh_mode = GF_DASH_PSSH_MOOF;
-	else if (!strcmp(arg_val, "v")) pssh_mode = GF_DASH_PSSH_MOOV;
-	else if (!strcmp(arg_val, "m")) pssh_mode = GF_DASH_PSSH_MPD;
-	else if (!strcmp(arg_val, "mf") || !strcmp(arg_val, "fm")) pssh_mode = GF_DASH_PSSH_MOOF_MPD;
-	else if (!strcmp(arg_val, "mv") || !strcmp(arg_val, "vm")) pssh_mode = GF_DASH_PSSH_MOOV_MPD;
-	else pssh_mode = GF_DASH_PSSH_MOOV;
-	return 0;
-}
-u32 parse_sdtp(char *arg_val, u32 opt)
-{
-	if (!stricmp(arg_val, "both")) sdtp_in_traf = 2;
-	else if (!stricmp(arg_val, "sdtp")) sdtp_in_traf = 1;
-	else sdtp_in_traf = 0;
-	return 0;
-}
-
-u32 parse_rap_ref(char *arg_val, u32 opt)
-{
-	if (arg_val) {
-		if (sscanf(arg_val, "%d", &trackID) == 1) {
-			parse_track_action(arg_val, opt ? TRACK_ACTION_REM_NON_REFS : TRACK_ACTION_REM_NON_RAP);
-		}
-	}
-#ifndef GPAC_DISABLE_STREAMING
-	hint_flags |= GP_RTP_PCK_SIGNAL_RAP;
-#endif
-	seg_at_rap = 1;
-	return 0;
-}
-u32 parse_store_mode(char *arg_val, u32 opt)
-{
-	do_save = GF_TRUE;
-	if ((opt == 0) || (opt == 1)) {
-		interleaving_time = atof(arg_val) / 1000;
-		if (!interleaving_time) do_flat = 2;
-		open_edit = GF_TRUE;
-		no_inplace = GF_TRUE;
-		if (opt==1) old_interleave = 1;
-	} else if (opt==2) {
-		interleaving_time = atof(arg_val);
-		do_frag = GF_TRUE;
-	} else {
-		force_new = 2;
-		interleaving_time = 0.5;
-		do_flat = 1;
-	}
-	return 0;
-}
-u32 parse_base_url(char *arg_val, u32 opt)
-{
-	mpd_base_urls = gf_realloc(mpd_base_urls, (nb_mpd_base_urls + 1)*sizeof(char**));
-	if (!mpd_base_urls) return 2;
-	mpd_base_urlsnb_mpd_base_urls = arg_val;
-	nb_mpd_base_urls++;
-	return 0;
-}
-u32 parse_multi_rtp(char *arg_val, u32 opt)
-{
-#ifndef GPAC_DISABLE_STREAMING
-	hint_flags |= GP_RTP_PCK_USE_MULTI;
-#endif
-	if (arg_val)
-		max_ptime = atoi(arg_val);
-	return 0;
-}
-
-
-u32 parse_senc_param(char *arg_val, u32 opt)
-{
-#ifndef GPAC_DISABLE_SCENE_ENCODER
-	switch (opt) {
-	case 0: //-sync
-		smenc_opts.flags |= GF_SM_ENCODE_RAP_INBAND;
-		smenc_opts.rap_freq = atoi(arg_val);
-		break;
-	case 1: //-shadow
-		smenc_opts.flags &= ~GF_SM_ENCODE_RAP_INBAND;
-		smenc_opts.flags |= GF_SM_ENCODE_RAP_SHADOW;
-		smenc_opts.rap_freq = atoi(arg_val);
-		break;
-	case 2: //-carousel
-		smenc_opts.flags &= ~(GF_SM_ENCODE_RAP_INBAND | GF_SM_ENCODE_RAP_SHADOW);
-		smenc_opts.rap_freq = atoi(arg_val);
-		break;
-	case 3: //-auto-quant
-		smenc_opts.resolution = atoi(arg_val);
-		smenc_opts.auto_quant = 1;
-		break;
-	case 4: //-global-quant
-		smenc_opts.resolution = atoi(arg_val);
-		smenc_opts.auto_quant = 2;
-		break;
-	case 5: //-ctx-in or -inctx
-		chunk_mode = GF_TRUE;
-		input_ctx = arg_val;
-	}
-#endif
-	return 0;
-}
-u32 parse_cryp(char *arg_val, u32 opt)
-{
-	open_edit = GF_TRUE;
-	if (!opt) {
-		crypt = 1;
-		drm_file = arg_val;
-		open_edit = GF_TRUE;
-		return 0;
-	}
-	crypt = 2;
-	if (arg_val && get_file_type_by_ext(arg_val) != 1) {
-		drm_file = arg_val;
-		return 0;
-	}
-	return 3;
-}
-
-u32 parse_dash_profile(char *arg_val, u32 opt)
-{
-	if (!stricmp(arg_val, "live") || !stricmp(arg_val, "simple")) dash_profile = GF_DASH_PROFILE_LIVE;
-	else if (!stricmp(arg_val, "onDemand")) dash_profile = GF_DASH_PROFILE_ONDEMAND;
-	else if (!stricmp(arg_val, "hbbtv1.5:live") || !stricmp(arg_val, "hbbtv1.5.live"))
-		dash_profile = GF_DASH_PROFILE_HBBTV_1_5_ISOBMF_LIVE;
-	else if (!stricmp(arg_val, "dashavc264:live") || !stricmp(arg_val, "dashavc264.live"))
-		dash_profile = GF_DASH_PROFILE_AVC264_LIVE;
-	else if (!stricmp(arg_val, "dashavc264:onDemand") || !stricmp(arg_val, "dashavc264.onDemand"))
-		dash_profile = GF_DASH_PROFILE_AVC264_ONDEMAND;
-	else if (!stricmp(arg_val, "dashif.ll")) dash_profile = GF_DASH_PROFILE_DASHIF_LL;
-	else if (!stricmp(arg_val, "main")) dash_profile = GF_DASH_PROFILE_MAIN;
-	else if (!stricmp(arg_val, "full")) dash_profile = GF_DASH_PROFILE_FULL;
-	else {
-		M4_LOG(GF_LOG_ERROR, ("Unrecognized DASH profile \"%s\" - please check usage\n", arg_val));
-		return 2;
-	}
-	return 0;
-}
-
-u32 parse_fps(char *arg_val, u32 opt)
-{
-	u32 ticks, dts_inc;
-	if (!strcmp(arg_val, "auto")) {
-		M4_LOG(GF_LOG_WARNING, ("Warning, fps=auto option is deprecated\n"));
-	}
-	else if ((sscanf(arg_val, "%u-%u", &ticks, &dts_inc)==2) || (sscanf(arg_val, "%u/%u", &ticks, &dts_inc)==2) ) {
-		if (!dts_inc) dts_inc = 1;
-		import_fps.num = ticks;
-		import_fps.den = dts_inc;
-	} else {
-		gf_parse_frac(arg_val, &import_fps);
-	}
-	return 0;
-}
-
-u32 parse_split(char *arg_val, u32 opt)
-{
-	u32 scale=1;
-	char *unit;
-	switch (opt) {
-	case 0://-split
-		unit = arg_val + (u32) (strlen(arg_val) - 1);
-		if (strchr("Mm", unit0)) scale = 60;
-		else if (strchr("Hh", unit0)) scale = 3600;
-		if (scale > 1) {
-			char c = unit0;
-			unit0 = 0;
-			split_duration = scale * atof(arg_val);
-			unit0 = c;
-		} else {
-			split_duration = atof(arg_val);
-		}
-		if (split_duration < 0) split_duration = 0;
-		split_size = 0;
-		break;
-	case 1: //-split-rap, -splitr
-		split_duration = -1;
-		split_size = -1;
-		break;
-	case 2: //-split-size, -splits
-		unit = arg_val + (u32) (strlen(arg_val) - 1);
-		if (strchr("Mm", unit0)) scale = 1000;
-		else if (strchr("Gg", unit0)) scale = 1000000;
-		if (scale > 1) {
-			char c = unit0;
-			unit0 = 0;
-			split_size = scale * (u32)atoi(arg_val);
-			unit0 = c;
-		} else {
-			split_size = (u32)atoi(arg_val);
-		}
-		split_duration = 0;
-		break;
-	case 3: //-split-chunk, -splitx
-	case 4: //-splitz
-	case 5: //-splitg
-	case 6: //-splitf
-		adjust_split_end = opt-3;
-		if (!strstr(arg_val, ":") && !strstr(arg_val, "-")) {
-			M4_LOG(GF_LOG_ERROR, ("Chunk extraction usage: \"-split* start:end\" expressed in seconds\n"));
-			return 2;
-		}
-		if (strstr(arg_val, "end")) {
-			if (strstr(arg_val, "end-")) {
-				Double dur_end=0;
-				sscanf(arg_val, "%lf:end-%lf", &split_start, &dur_end);
-				split_duration = -2 - dur_end;
-			} else {
-				sscanf(arg_val, "%lf:end", &split_start);
-				split_duration = -2;
-			}
-		} else {
-			split_range_str = arg_val;
-		}
-		split_size = 0;
-		break;
-	}
-	return 0;
-}
-
-u32 parse_brand(char *b, u32 opt)
-{
-	open_edit = GF_TRUE;
-	switch (opt) {
-	case 0: //-brand
-		major_brand = GF_4CC(b0, b1, b2, b3);
-		if (b4 == ':') {
-			if (!strncmp(b+5, "0x", 2))
-				sscanf(b+5, "0x%x", &minor_version);
-			else
-				minor_version = atoi(b + 5);
-		}
-		break;
-	case 1: //-ab
-		brand_add = (u32*)gf_realloc(brand_add, sizeof(u32) * (nb_alt_brand_add + 1));
-		if (!brand_add) return 2;
-		brand_addnb_alt_brand_add = GF_4CC(b0, b1, b2, b3);
-		nb_alt_brand_add++;
-		break;
-	case 2: //-rb
-		brand_rem = (u32*)gf_realloc(brand_rem, sizeof(u32) * (nb_alt_brand_rem + 1));
-		if (!brand_rem) return 2;
-		brand_remnb_alt_brand_rem = GF_4CC(b0, b1, b2, b3);
-		nb_alt_brand_rem++;
-		break;
-	}
-	return 0;
-}
-
-u32 parse_mpegu(char *arg_val, u32 opt)
-{
-	pack_file = arg_val;
-	pack_wgt = GF_TRUE;
-	return 0;
-}
-
-u32 parse_file_info(char *arg_val, u32 opt)
-{
-	print_info = opt ? 2 : 1;
-	if (opt==2) {
-		print_info = 2;
-		if (arg_val) return 3;
-		return 0;
-	}
-	if (arg_val) {
-		if (sscanf(arg_val, "%u", &info_track_id) == 1) {
-			char szTk20;
-			sprintf(szTk, "%u", info_track_id);
-			if (strcmp(szTk, arg_val)) info_track_id = 0;
-		}
-		if (!info_track_id) return 3;
-	}
-	return 0;
-}
-u32 parse_boxpatch(char *arg_val, u32 opt)
-{
-	box_patch_filename = arg_val;
-	char *sep = strchr(box_patch_filename, '=');
-	if (sep) {
-		sep0 = 0;
-		box_patch_trackID = atoi(box_patch_filename);
-		sep0 = '=';
-		box_patch_filename = sep+1;
-	}
-	open_edit = GF_TRUE;
-	return 0;
-}
-u32 parse_compress(char *arg_val, u32 opt)
-{
-	compress_moov = opt ? 2 : 1;
-	open_edit = GF_TRUE;
-	return 0;
-}
-
-
-u32 parse_dump_udta(char *code, u32 opt)
-{
-	char *sep;
-	sep = strchr(code, ':');
-	if (sep) {
-		sep0 = 0;
-		dump_udta_track = atoi(code);
-		sep0 = ':';
-		code = sep + 1;
-	}
-
-	if (strlen(code) == 4) {
-		dump_udta_type = GF_4CC(code0, code1, code2, code3);
-	} else if (strlen(code) == 8) {
-		// hex representation on 8 chars
-		u32 hex1, hex2, hex3, hex4;
-		if (sscanf(code, "%02x%02x%02x%02x", &hex1, &hex2, &hex3, &hex4) != 4) {
-			M4_LOG(GF_LOG_ERROR, ("udta code is either a 4CC or 8 hex chars for non-printable 4CC\n"));
-			return 2;
-		}
-		dump_udta_type = GF_4CC(hex1, hex2, hex3, hex4);
-	} else {
-		M4_LOG(GF_LOG_ERROR, ("udta code is either a 4CC or 8 hex chars for non-printable 4CC\n"));
-		return 2;
-	}
-	return 0;
-}
-
-u32 parse_dump_ts(char *arg_val, u32 opt)
-{
-	dump_timestamps = 1;
-	if (arg_val) {
-		if (isdigit(arg_val0)) {
-			program_number = atoi(arg_val);
-		} else {
-			return 3;
-		}
-	}
-	return 0;
-}
-
-u32 parse_ttxt(char *arg_val, u32 opt)
-{
-	if (opt) //-srt
-		dump_srt = GF_TRUE;
-	else
-		dump_ttxt = GF_TRUE;
-
-	import_subtitle = 1;
-	trackID = 0;
-
-	if (arg_val && (!strcmp(arg_val, "*") || !strcmp(arg_val, "@") || !strcmp(arg_val, "all")) ) {
-		trackID = (u32)-1;
-	} else if (arg_val) {
-		if (sscanf(arg_val, "%u", &trackID) == 1) {
-			char szTk20;
-			sprintf(szTk, "%d", trackID);
-			if (strcmp(szTk, arg_val))
-				trackID = 0;
-		}
-		if (!trackID) return 3;
-	}
-	return 0;
-}
-
-u32 parse_dashlive(char *arg, char *arg_val, u32 opt)
-{
-	dash_mode = opt ? GF_DASH_DYNAMIC_DEBUG : GF_DASH_DYNAMIC;
-	dash_live = 1;
-	if (arg10 == '=') {
-		dash_ctx_file = arg + 11;
-	}
-	dash_duration = atof(arg_val);
-	return 0;
-}
-
-u32 parse_help(char *arg_val, u32 opt)
-{
-	if (!arg_val) PrintUsage();
-	else if (opt) PrintHelp(arg_val, GF_TRUE, GF_FALSE);
-	else if (!strcmp(arg_val, "general")) PrintGeneralUsage();
-	else if (!strcmp(arg_val, "extract")) PrintExtractUsage();
-	else if (!strcmp(arg_val, "split")) PrintSplitUsage();
-	else if (!strcmp(arg_val, "dash")) PrintDASHUsage();
-	else if (!strcmp(arg_val, "dump")) PrintDumpUsage();
-	else if (!strcmp(arg_val, "import")) PrintImportUsage();
-	else if (!strcmp(arg_val, "format")) {
-		M4_LOG(GF_LOG_WARNING, ("deprecated, see filters documentation(Filters)\n"));
-	}
-	else if (!strcmp(arg_val, "hint")) PrintHintUsage();
-	else if (!strcmp(arg_val, "encode")) PrintEncodeUsage();
-	else if (!strcmp(arg_val, "crypt")) PrintEncryptUsage();
-	else if (!strcmp(arg_val, "meta")) PrintMetaUsage();
-	else if (!strcmp(arg_val, "swf")) PrintSWFUsage();
-#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
-	else if (!strcmp(arg_val, "rtp")) {
-		M4_LOG(GF_LOG_WARNING, ("RTP streaming deprecated in MP4Box, use gpac application\n"));
-	}
-	else if (!strcmp(arg_val, "live")) PrintLiveUsage();
-#endif
-	else if (!strcmp(arg_val, "core")) PrintCoreUsage();
-	else if (!strcmp(arg_val, "tags")) PrintTags();
-	else if (!strcmp(arg_val, "cicp")) PrintCICP();
-	else if (!strcmp(arg_val, "all")) {
-		PrintGeneralUsage();
-		PrintExtractUsage();
-		PrintDASHUsage();
-		PrintSplitUsage();
-		PrintDumpUsage();
-		PrintImportUsage();
-		PrintHintUsage();
-		PrintEncodeUsage();
-		PrintEncryptUsage();
-		PrintMetaUsage();
-		PrintSWFUsage();
-#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
-		PrintLiveUsage();
-#endif
-		PrintCoreUsage();
-		PrintTags();
-		PrintCICP();
-	} else if (!strcmp(arg_val, "opts")) {
-		PrintHelp("@", GF_FALSE, GF_FALSE);
-	} else {
-		PrintHelp(arg_val, GF_FALSE, GF_FALSE);
-	}
-	return 1;
-}
-
-u32 parse_gendoc(char *name, u32 opt)
-{
-	u32 i=0;
-	//gen MD
-	if (!opt) {
-		help_flags = GF_PRINTARG_MD | GF_PRINTARG_IS_APP;
-		helpout = gf_fopen("mp4box-gen-opts.md", "w");
-
-		fprintf(helpout, "**HOME**(Home) » **MP4Box**(MP4Box) » General");
-		fprintf(helpout, "\n");
-		fprintf(helpout, "# Syntax\n");
-		gf_sys_format_help(helpout, help_flags, "MP4Box option input option other_dash_inputs\n"
-			" \n"
-		);
-		PrintGeneralUsage();
-		PrintEncryptUsage();
-		fprintf(helpout, "# Help Options\n");
-		while (m4b_usage_argsi.name) {
-			GF_GPACArg *g_arg = (GF_GPACArg *) &m4b_usage_argsi;
-			i++;
-			gf_sys_print_arg(helpout, help_flags, g_arg, "mp4box-general");
-		}
-
-		gf_fclose(helpout);
-
-		helpout = gf_fopen("mp4box-import-opts.md", "w");
-		fprintf(helpout, "**HOME**(Home) » **MP4Box**(MP4Box) » Media Import");
-		fprintf(helpout, "\n");
-		PrintImportUsage();
-		gf_fclose(helpout);
-
-		helpout = gf_fopen("mp4box-dash-opts.md", "w");
-		fprintf(helpout, "**HOME**(Home) » **MP4Box**(MP4Box) » Media DASH");
-		fprintf(helpout, "\n");
-		PrintDASHUsage();
-		gf_fclose(helpout);
-
-		helpout = gf_fopen("mp4box-dump-opts.md", "w");
-		fprintf(helpout, "**HOME**(Home) » **MP4Box**(MP4Box) » Media Dump and Export");
-		fprintf(helpout, "\n");
-		PrintExtractUsage();
-		PrintDumpUsage();
-		PrintSplitUsage();
-		gf_fclose(helpout);
-
-		helpout = gf_fopen("mp4box-meta-opts.md", "w");
-		fprintf(helpout, "**HOME**(Home) » **MP4Box**(MP4Box) » Meta and HEIF/IFF");
-		fprintf(helpout, "\n");
-		PrintMetaUsage();
-		gf_fclose(helpout);
-
-
-		helpout = gf_fopen("mp4box-scene-opts.md", "w");
-		fprintf(helpout, "**HOME**(Home) » **MP4Box**(MP4Box) » Scene Description");
-		fprintf(helpout, "\n");
-		PrintEncodeUsage();
-#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
-		PrintLiveUsage();
-#endif
-		PrintSWFUsage();
-		gf_fclose(helpout);
-
-		helpout = gf_fopen("mp4box-other-opts.md", "w");
-		fprintf(helpout, "**HOME**(Home) » **MP4Box**(MP4Box) » Other Features");
-		fprintf(helpout, "\n");
-		PrintHintUsage();
-		PrintTags();
-		gf_fclose(helpout);
-	}
-	//gen man
-	else {
-		help_flags = GF_PRINTARG_MAN;
-		helpout = gf_fopen("mp4box.1", "w");
-
-
-		fprintf(helpout, ".TH MP4Box 1 2019 MP4Box GPAC\n");
-		fprintf(helpout, ".\n.SH NAME\n.LP\nMP4Box \\- GPAC command-line media packager\n.SH SYNOPSIS\n.LP\n.B MP4Box\n.RI options \\ file \\ options\n.br\n.\n");
-
-		PrintGeneralUsage();
-		PrintExtractUsage();
-		PrintDASHUsage();
-		PrintSplitUsage();
-		PrintDumpUsage();
-		PrintImportUsage();
-		PrintHintUsage();
-		PrintEncodeUsage();
-		PrintEncryptUsage();
-		PrintMetaUsage();
-		PrintSWFUsage();
-		PrintTags();
-#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
-		PrintLiveUsage();
-#endif
-
-		fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/MP4Box\n");
-		fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
-		".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
-		".br\nbuild: %s\n"
-		".br\nCopyright: %s\n.br\n"
-		".SH SEE ALSO\n"
-		".LP\ngpac(1), MP4Client(1)\n", gf_gpac_version(), gf_gpac_copyright());
-
-		gf_fclose(helpout);
-	}
-	return 1;
-}
-
-static Bool arg_parse_res = 0;
-u32 mp4box_parse_single_arg_class(int argc, char **argv, char *arg, u32 *arg_index, MP4BoxArg *arg_class)
-{
-	MP4BoxArg *arg_desc = NULL;
-	char *arg_val = NULL;
-	u32 i=0;
-	while (arg_classi.name) {
-		arg_desc = (MP4BoxArg *) &arg_classi;
-		i++;
-
-#ifdef TEST_ARGS
-		char *sep = strchr(arg_desc->name, ' ');
-		if (sep) {
-			M4_LOG(GF_LOG_ERROR, ("Invalid arg %s, space not allowed\n", arg_desc->name));
-			exit(1);
-		}
-#endif
-		if (!strcmp(arg_desc->name, arg+1))
-			break;
-		if (arg_desc->altname && !strcmp(arg_desc->altname, arg+1))
-			break;
-
-		if (arg_desc->parse_flags & ARG_IS_FUN2) {
-			if (!strncmp(arg_desc->name, arg+1, strlen(arg_desc->name) ))
-				break;
-		}
-		arg_desc = NULL;
-	}
-	if (!arg_desc)
-		return GF_FALSE;
-
-	if (arg_desc->parse_flags & ARG_OPEN_EDIT) open_edit = GF_TRUE;
-	if (arg_desc->parse_flags & ARG_NEED_SAVE) do_save = GF_TRUE;
-	if (arg_desc->parse_flags & ARG_NO_INPLACE) no_inplace = GF_TRUE;
-
-	if (arg_desc->type != GF_ARG_BOOL) {
-		Bool has_next = GF_TRUE;
-		if (*arg_index + 1 == (u32) argc)
-			has_next = GF_FALSE;
-		else if (argv*arg_index + 10 == '-') {
-			s32 v;
-			if (sscanf(argv*arg_index + 1, "%d", &v)!=1)
-				has_next = GF_FALSE;
-		}
-		if (!has_next && ! (arg_desc->parse_flags & ARG_EMPTY) ) {
-			M4_LOG(GF_LOG_ERROR, ("Missing argument value for %s - please check usage\n", arg));
-			arg_parse_res = 2;
-			return GF_TRUE;
-		}
-
-		if (has_next && (arg_desc->parse_flags & ARG_EMPTY) && (arg_desc->type==GF_ARG_INT)) {
-			s32 ival;
-			if (sscanf(argv*arg_index + 1, "%d", &ival) != 1) {
-				has_next = GF_FALSE;
-				arg_val = NULL;
-			}
-		}
-		if (has_next) {
-			has_next_arg = GF_TRUE;
-			*arg_index += 1;
-			arg_val = argv*arg_index;
-		}
-	}
-	if (!arg_desc->arg_ptr) return GF_TRUE;
-
-	if (arg_desc->parse_flags & (ARG_IS_FUN|ARG_IS_FUN2) ) {
-		u32 res;
-		if (arg_desc->parse_flags & ARG_PUSH_SYSARGS)
-			gf_sys_set_args(argc, (const char**) argv);
-
-		if (arg_desc->parse_flags & ARG_IS_FUN) {
-			parse_arg_fun fun = (parse_arg_fun) arg_desc->arg_ptr;
-			res = fun(arg_val, arg_desc->argv_val);
-		} else {
-			parse_arg_fun2 fun2 = (parse_arg_fun2) arg_desc->arg_ptr;
-			res = fun2(arg, arg_val, arg_desc->argv_val);
-		}
-		//rewind, not our arg
-		if ((res==3) && argv) {
-			*arg_index -= 1;
-			res = 0;
-		}
-		arg_parse_res = res;
-		return GF_TRUE;
-	}
-
-	if (arg_desc->parse_flags & ARG_INT_INC) {
-		* (u32 *) arg_desc->arg_ptr += 1;
-		return GF_TRUE;
-	}
-
-	if (arg_desc->type == GF_ARG_BOOL) {
-		if (!arg_desc->parse_flags) {
-			if (arg_desc->argv_val) {
-				* (u32 *) arg_desc->arg_ptr = arg_desc->argv_val;
-			} else {
-				* (Bool *) arg_desc->arg_ptr = GF_TRUE;
-			}
-		} else if (arg_desc->parse_flags & ARG_BOOL_REV) {
-			* (Bool *) arg_desc->arg_ptr = GF_FALSE;
-		} else if (arg_desc->parse_flags & ARG_HAS_VALUE) {
-			* (u32 *) arg_desc->arg_ptr = 0;
-		} else if (arg_desc->parse_flags & ARG_BIT_MASK) {
-			* (u32 *) arg_desc->arg_ptr |= arg_desc->argv_val;
-		} else if (arg_desc->parse_flags & ARG_BIT_MASK_REM) {
-			* (u32 *) arg_desc->arg_ptr &= ~arg_desc->argv_val;
-		} else if (arg_desc->argv_val) {
-			* (u32 *) arg_desc->arg_ptr = arg_desc->argv_val;
-		} else {
-			* (u32 *) arg_desc->arg_ptr = GF_TRUE;
-		}
-		return GF_TRUE;
-	}
-
-	if (arg_desc->type == GF_ARG_STRING) {
-		if (arg_desc->parse_flags & ARG_IS_4CC) {
-			u32 alen = arg_val ? (u32) strlen(arg_val) : 0;
-			if ((alen<3) || (alen>4)) {
-				M4_LOG(GF_LOG_ERROR, ("Value for %s must be a 4CC, %s is not - please check usage\n", arg, arg_val));
-				arg_parse_res = 2;
-				return GF_TRUE;
-			}
-			* (u32 *) arg_desc->arg_ptr = GF_4CC(arg_val0, arg_val1, arg_val2, arg_val3);
-			return GF_TRUE;
-		}
-
-		* (char **) arg_desc->arg_ptr = arg_val;
-		return GF_TRUE;
-	}
-	if (!arg_val) {
-		M4_LOG(GF_LOG_ERROR, ("Missing value for %s - please check usage\n", arg));
-		arg_parse_res = 2;
-		return GF_TRUE;
-	}
-
-	if (arg_desc->type == GF_ARG_DOUBLE) {
-		Double v = atof(arg_val);
-		if (arg_desc->parse_flags & ARG_DIV_1000) {
-			v /= 1000;
-		}
-		if ((arg_desc->parse_flags & ARG_NON_ZERO) && !v) {
-			M4_LOG(GF_LOG_ERROR, ("Value for %s shall not be 0 - please check usage\n", arg));
-			arg_parse_res = 2;
-			return GF_TRUE;
-		}
-		* (Double *) arg_desc->arg_ptr = v;
-		return GF_TRUE;
-	}
-
-	if (arg_desc->type != GF_ARG_INT) {
-		M4_LOG(GF_LOG_ERROR, ("Unsupported argument type for %s - please report to gpac devs\n", arg));
-		arg_parse_res = 2;
-		return GF_TRUE;
-	}
-	if (arg_desc->parse_flags & ARG_64BITS) {
-		u64 v;
-		sscanf(arg_val, LLU, &v);
-		if (arg_desc->parse_flags & ARG_DIV_1000) {
-			v /= 1000;
-		}
-		if ((arg_desc->parse_flags & ARG_NON_ZERO) && !v) {
-			M4_LOG(GF_LOG_ERROR, ("Value for %s shall not be 0 - please check usage\n", arg));
-			arg_parse_res = 2;
-			return GF_TRUE;
-		}
-		* (u64 *) arg_desc->arg_ptr = v;
-	} else {
-		u32 v = atoi(arg_val);
-		if (arg_desc->parse_flags & ARG_DIV_1000) {
-			v /= 1000;
-		}
-		if ((arg_desc->parse_flags & ARG_NON_ZERO) && !v) {
-			M4_LOG(GF_LOG_ERROR, ("Value for %s shall not be 0 - please check usage\n", arg));
-			arg_parse_res = 2;
-			return GF_TRUE;
-		}
-		* (s32 *) arg_desc->arg_ptr = v;
-	}
-	return GF_TRUE;
-}
-
-Bool mp4box_parse_single_arg(int argc, char **argv, char *arg, u32 *arg_index)
-{
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_gen_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_split_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_dash_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_imp_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_senc_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_crypt_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_hint_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_extr_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_dump_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_meta_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_swf_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_liveenc_args)) return GF_TRUE;
-	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_usage_args)) return GF_TRUE;
-
-	return GF_FALSE;
-}
-
-
-u32 mp4box_parse_args(int argc, char **argv)
-{
-	u32 i;
-	/*parse our args*/
-	for (i = 1; i < (u32)argc; i++) {
-		char *arg = argvi;
-		/*input file(s)*/
-		if ((arg0 != '-') || !stricmp(arg, "--")) {
-			char *arg_val = arg;
-			if (!stricmp(arg, "--")) {
-				if (i+1==(u32)argc) {
-					M4_LOG(GF_LOG_ERROR, ("Missing arg for `--` - please check usage\n"));
-					return 2;
-				}
-				has_next_arg = GF_TRUE;
-				arg_val = argvi + 1;
-				i++;
-			}
-			if (argc < 3) {
-				M4_LOG(GF_LOG_ERROR, ("Error - only one input file found as argument, please check usage\n"));
-				return 2;
-			}
-			else if (inName) {
-				if (dash_duration) {
-					if (!nb_dash_inputs) {
-						dash_inputs = set_dash_input(dash_inputs, inName, &nb_dash_inputs);
-					}
-					dash_inputs = set_dash_input(dash_inputs, arg_val, &nb_dash_inputs);
-				}
-				else {
-					M4_LOG(GF_LOG_ERROR, ("Error - 2 input names specified, please check usage\n"));
-					return 2;
-				}
-			}
-			else {
-				inName = arg_val;
-			}
-		}
-		//all deprecated options
-		else if (!stricmp(arg, "-grab-ts") || !stricmp(arg, "-atsc") || !stricmp(arg, "-rtp")) {
-			M4_LOG(GF_LOG_ERROR, ("Deprecated fuctionnality `%s` - use gpac application\n", arg));
-			return 2;
-		}
-		else if (!stricmp(arg, "-write-buffer")) {
-			M4_LOG(GF_LOG_WARNING, ("`%s` option deprecated, use `-bs-cache-size`", arg));
-			gf_opts_set_key("temp", "bs-cache-size", argvi + 1);
-			i++;
-		}
-		else if (!stricmp(arg, "-pssh-moof")) {
-			M4_LOG(GF_LOG_ERROR, ("`-pssh-moof` option deprecated , use `-pssh` option\n"));
-			return 2;
-		}
-		else if (!stricmp(arg, "-tag-list")) {
-			M4_LOG(GF_LOG_ERROR, ("`-tag-list` option deprecated, use `-h tags`\n"));
-			return 2;
-		}
-		else if (!stricmp(arg, "-aviraw")) {
-			M4_LOG(GF_LOG_ERROR, ("`-aviraw` option deprecated, use `-raw`\n"));
-			return 2;
-		}
-		else if (!stricmp(arg, "-avi")) {
-			M4_LOG(GF_LOG_ERROR, ("`-avi` option deprecated, use `-mux`\n"));
-			return 2;
-		}
-		else if (!strncmp(arg, "-p=", 3)) {
-			continue;
-		}
-
-		//parse argument
-		else if (mp4box_parse_single_arg(argc, argv, arg, &i)) {
-			if (arg_parse_res)
-				return mp4box_cleanup(arg_parse_res);
-		}
-		//not a MP4Box arg
-		else {
-			u32 res = gf_sys_is_gpac_arg(arg);
-			if (res==0) {
-				PrintHelp(arg, GF_FALSE, GF_TRUE);
-				return 2;
-			} else if (res==2) {
-				i++;
-			}
-		}
-		//live scene encoder does not use the unified parsing and should be moved as a scene encoder filter
-		if (live_scene) return 0;
-	}
-	return 0;
-}
-
-/*
-	END OF OPTION PARSING CODE
-*/
-
-
-
-void scene_coding_log(void *cbk, GF_LOG_Level log_level, GF_LOG_Tool log_tool, const char *fmt, va_list vlist)
-{
-	FILE *logs = cbk;
-	if (log_tool != GF_LOG_CODING) return;
-	vfprintf(logs, fmt, vlist);
-	fflush(logs);
-}
-
-
-#ifndef GPAC_DISABLE_ISOM_HINTING
-
-/*
-		MP4 File Hinting
-*/
-
-void SetupClockReferences(GF_ISOFile *file)
-{
-	u32 i, count, ocr_id;
-	count = gf_isom_get_track_count(file);
-	if (count==1) return;
-	ocr_id = 0;
-	for (i=0; i<count; i++) {
-		if (!gf_isom_is_track_in_root_od(file, i+1)) continue;
-		ocr_id = gf_isom_get_track_id(file, i+1);
-		break;
-	}
-	/*doesn't look like MP4*/
-	if (!ocr_id) return;
-	for (i=0; i<count; i++) {
-		GF_ESD *esd = gf_isom_get_esd(file, i+1, 1);
-		if (esd) {
-			esd->OCRESID = ocr_id;
-			gf_isom_change_mpeg4_description(file, i+1, 1, esd);
-			gf_odf_desc_del((GF_Descriptor *) esd);
-		}
-	}
-}
-
-/*base RTP payload type used (you can specify your own types if needed)*/
-#define BASE_PAYT		96
-
-GF_Err HintFile(GF_ISOFile *file, u32 MTUSize, u32 max_ptime, u32 rtp_rate, u32 base_flags, Bool copy_data, Bool interleave, Bool regular_iod, Bool single_group, Bool hint_no_offset)
-{
-	GF_ESD *esd;
-	GF_InitialObjectDescriptor *iod;
-	u32 i, val, res, streamType;
-	u32 sl_mode, prev_ocr, single_ocr, nb_done, tot_bw, bw, flags, spec_type;
-	GF_Err e;
-	char szPayload30;
-	GF_RTPHinter *hinter;
-	Bool copy, has_iod, single_av;
-	u8 init_payt = BASE_PAYT;
-	u32 mtype;
-	GF_SDP_IODProfile iod_mode = GF_SDP_IOD_NONE;
-	u32 media_group = 0;
-	u8 media_prio = 0;
-
-	tot_bw = 0;
-	prev_ocr = 0;
-	single_ocr = 1;
-
-	has_iod = 1;
-	iod = (GF_InitialObjectDescriptor *) gf_isom_get_root_od(file);
-	if (!iod) has_iod = 0;
-	else {
-		if (!gf_list_count(iod->ESDescriptors)) has_iod = 0;
-		gf_odf_desc_del((GF_Descriptor *) iod);
-	}
-
-	spec_type = gf_isom_guess_specification(file);
-	single_av = single_group ? 1 : gf_isom_is_single_av(file);
-
-	/*first make sure we use a systems track as base OCR*/
-	for (i=0; i<gf_isom_get_track_count(file); i++) {
-		res = gf_isom_get_media_type(file, i+1);
-		if ((res==GF_ISOM_MEDIA_SCENE) || (res==GF_ISOM_MEDIA_OD)) {
-			if (gf_isom_is_track_in_root_od(file, i+1)) {
-				gf_isom_set_default_sync_track(file, i+1);
-				break;
-			}
-		}
-	}
-
-	nb_done = 0;
-	for (i=0; i<gf_isom_get_track_count(file); i++) {
-		sl_mode = base_flags;
-		copy = copy_data;
-		/*skip emty tracks (mainly MPEG-4 interaction streams...*/
-		if (!gf_isom_get_sample_count(file, i+1)) continue;
-		if (!gf_isom_is_track_enabled(file, i+1)) {
-			M4_LOG(GF_LOG_INFO, ("Track ID %d disabled - skipping hint\n", gf_isom_get_track_id(file, i+1) ));
-			continue;
-		}
-
-		mtype = gf_isom_get_media_type(file, i+1);
-		switch (mtype) {
-		case GF_ISOM_MEDIA_VISUAL:
-			if (single_av) {
-				media_group = 2;
-				media_prio = 2;
-			}
-			break;
- case GF_ISOM_MEDIA_AUXV:
- if (single_av) {
- media_group = 2;
- media_prio = 3;
- }
- break;
- case GF_ISOM_MEDIA_PICT:
- if (single_av) {
- media_group = 2;
- media_prio = 4;
- }
- break;
-		case GF_ISOM_MEDIA_AUDIO:
-			if (single_av) {
-				media_group = 2;
-				media_prio = 1;
-			}
-			break;
-		case GF_ISOM_MEDIA_HINT:
-			continue;
-		default:
-			/*no hinting of systems track on isma*/
-			if (spec_type==GF_ISOM_BRAND_ISMA) continue;
-		}
-		mtype = gf_isom_get_media_subtype(file, i+1, 1);
-		if ((mtype==GF_ISOM_SUBTYPE_MPEG4) || (mtype==GF_ISOM_SUBTYPE_MPEG4_CRYP) ) mtype = gf_isom_get_mpeg4_subtype(file, i+1, 1);
-
-		if (!single_av) {
-			/*one media per group only (we should prompt user for group selection)*/
-			media_group ++;
-			media_prio = 1;
-		}
-
-		streamType = 0;
-		esd = gf_isom_get_esd(file, i+1, 1);
-		if (esd && esd->decoderConfig) {
-			streamType = esd->decoderConfig->streamType;
-			if (!prev_ocr) {
-				prev_ocr = esd->OCRESID;
-				if (!esd->OCRESID) prev_ocr = esd->ESID;
-			} else if (esd->OCRESID && prev_ocr != esd->OCRESID) {
-				single_ocr = 0;
-			}
-			/*OD MUST BE WITHOUT REFERENCES*/
-			if (streamType==1) copy = 1;
-		}
-		gf_odf_desc_del((GF_Descriptor *) esd);
-
-		if (!regular_iod && gf_isom_is_track_in_root_od(file, i+1)) {
-			/*single AU - check if base64 would fit in ESD (consider 33% overhead of base64), otherwise stream*/
-			if (gf_isom_get_sample_count(file, i+1)==1) {
-				GF_ISOSample *samp = gf_isom_get_sample(file, i+1, 1, &val);
-				if (streamType && samp) {
-					res = gf_hinter_can_embbed_data(samp->data, samp->dataLength, streamType);
-				} else {
-					/*not a system track, we shall hint it*/
-					res = 0;
-				}
-				if (samp) gf_isom_sample_del(&samp);
-				if (res) continue;
-			}
-		}
-		if (interleave) sl_mode |= GP_RTP_PCK_USE_INTERLEAVING;
-
-		hinter = gf_hinter_track_new(file, i+1, MTUSize, max_ptime, rtp_rate, sl_mode, init_payt, copy, media_group, media_prio, &e);
-
-		if (!hinter) {
-			if (e) {
-				M4_LOG(nb_done ? GF_LOG_WARNING : GF_LOG_ERROR, ("Cannot create hinter (%s)\n", gf_error_to_string(e) ));
-				if (!nb_done) return e;
-			}
-			continue;
-		}
-
-		if (hint_no_offset)
-			gf_hinter_track_force_no_offsets(hinter);
-
-		bw = gf_hinter_track_get_bandwidth(hinter);
-		tot_bw += bw;
-		flags = gf_hinter_track_get_flags(hinter);
-
-		//set extraction mode for AVC/SVC
-		gf_isom_set_nalu_extract_mode(file, i+1, GF_ISOM_NALU_EXTRACT_LAYER_ONLY);
-
-		gf_hinter_track_get_payload_name(hinter, szPayload);
-		M4_LOG(GF_LOG_INFO, ("Hinting track ID %d - Type \"%s:%s\" (%s) - BW %d kbps\n", gf_isom_get_track_id(file, i+1), gf_4cc_to_str(mtype), gf_4cc_to_str(mtype), szPayload, bw));
-		if (flags & GP_RTP_PCK_SYSTEMS_CAROUSEL) M4_LOG(GF_LOG_INFO, ("\tMPEG-4 Systems stream carousel enabled\n"));
-		e = gf_hinter_track_process(hinter);
-
-		if (!e) e = gf_hinter_track_finalize(hinter, has_iod);
-		gf_hinter_track_del(hinter);
-
-		if (e) {
-			M4_LOG(GF_LOG_ERROR, ("Error while hinting (%s)\n", gf_error_to_string(e)));
-			if (!nb_done) return e;
-		}
-		init_payt++;
-		nb_done ++;
-	}
-
-	if (has_iod) {
-		iod_mode = GF_SDP_IOD_ISMA;
-		if (regular_iod) iod_mode = GF_SDP_IOD_REGULAR;
-	} else {
-		iod_mode = GF_SDP_IOD_NONE;
-	}
-	gf_hinter_finalize(file, iod_mode, tot_bw);
-
-	if (!single_ocr)
-		M4_LOG(GF_LOG_WARNING, ("Warning: at least 2 timelines found in the file\nThis may not be supported by servers/players\n\n"));
-
-	return GF_OK;
-}
-
-#endif /*GPAC_DISABLE_ISOM_HINTING*/
-
-#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_AV_PARSERS)
-
-static void check_media_profile(GF_ISOFile *file, u32 track)
-{
-	u8 PL;
-	GF_ESD *esd = gf_isom_get_esd(file, track, 1);
-	if (!esd) return;
-
-	switch (esd->decoderConfig->streamType) {
-	case 0x04:
-		PL = gf_isom_get_pl_indication(file, GF_ISOM_PL_VISUAL);
-		if (esd->decoderConfig->objectTypeIndication==GF_CODECID_MPEG4_PART2) {
-			GF_M4VDecSpecInfo vdsi;
-			gf_m4v_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &vdsi);
-			if (vdsi.VideoPL > PL) gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, vdsi.VideoPL);
-		} else if ((esd->decoderConfig->objectTypeIndication==GF_CODECID_AVC) || (esd->decoderConfig->objectTypeIndication==GF_CODECID_SVC)) {
-			gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0x15);
-		} else if (!PL) {
-			gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0xFE);
-		}
-		break;
-	case 0x05:
-		PL = gf_isom_get_pl_indication(file, GF_ISOM_PL_AUDIO);
-		switch (esd->decoderConfig->objectTypeIndication) {
-		case GF_CODECID_AAC_MPEG2_MP:
-		case GF_CODECID_AAC_MPEG2_LCP:
-		case GF_CODECID_AAC_MPEG2_SSRP:
-		case GF_CODECID_AAC_MPEG4:
-		{
-			GF_M4ADecSpecInfo adsi;
-			gf_m4a_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &adsi);
-			if (adsi.audioPL > PL) gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, adsi.audioPL);
-		}
-			break;
-		default:
-			if (!PL) gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, 0xFE);
-		}
-		break;
-	}
-	gf_odf_desc_del((GF_Descriptor *) esd);
-}
-void remove_systems_tracks(GF_ISOFile *file)
-{
-	u32 i, count;
-
-	count = gf_isom_get_track_count(file);
-	if (count==1) return;
-
-	/*force PL rewrite*/
-	gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0);
-	gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, 0);
-	gf_isom_set_pl_indication(file, GF_ISOM_PL_OD, 1);	/*the lib always remove IOD when no profiles are specified..*/
-
-	for (i=0; i<gf_isom_get_track_count(file); i++) {
-		switch (gf_isom_get_media_type(file, i+1)) {
-		case GF_ISOM_MEDIA_VISUAL:
- case GF_ISOM_MEDIA_AUXV:
- case GF_ISOM_MEDIA_PICT:
-		case GF_ISOM_MEDIA_AUDIO:
-		case GF_ISOM_MEDIA_TEXT:
-		case GF_ISOM_MEDIA_SUBT:
-			gf_isom_remove_track_from_root_od(file, i+1);
-			check_media_profile(file, i+1);
-			break;
-		/*only remove real systems tracks (eg, delaing with scene description & presentation)
-		but keep meta & all unknown tracks*/
-		case GF_ISOM_MEDIA_SCENE:
-			switch (gf_isom_get_media_subtype(file, i+1, 1)) {
-			case GF_ISOM_MEDIA_DIMS:
-				gf_isom_remove_track_from_root_od(file, i+1);
-				continue;
-			default:
-				break;
-			}
-		case GF_ISOM_MEDIA_OD:
-		case GF_ISOM_MEDIA_OCR:
-		case GF_ISOM_MEDIA_MPEGJ:
-			gf_isom_remove_track(file, i+1);
-			i--;
-			break;
-		default:
-			break;
-		}
-	}
-	/*none required*/
-	if (!gf_isom_get_pl_indication(file, GF_ISOM_PL_AUDIO)) gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, 0xFF);
-	if (!gf_isom_get_pl_indication(file, GF_ISOM_PL_VISUAL)) gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0xFF);
-
-	gf_isom_set_pl_indication(file, GF_ISOM_PL_OD, 0xFF);
-	gf_isom_set_pl_indication(file, GF_ISOM_PL_SCENE, 0xFF);
-	gf_isom_set_pl_indication(file, GF_ISOM_PL_GRAPHICS, 0xFF);
-	gf_isom_set_pl_indication(file, GF_ISOM_PL_INLINE, 0);
-}
-
-#endif /*!defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_AV_PARSERS)*/
-
-GF_FileType get_file_type_by_ext(char *inName)
-{
-	GF_FileType type = GF_FILE_TYPE_NOT_SUPPORTED;
-	char *ext = strrchr(inName, '.');
-	if (ext) {
-		char *sep;
-		if (!strcmp(ext, ".gz")) ext = strrchr(ext-1, '.');
-		ext+=1;
-		sep = strchr(ext, '.');
-		if (sep) sep0 = 0;
-
-		if (!stricmp(ext, "mp4") || !stricmp(ext, "3gp") || !stricmp(ext, "mov") || !stricmp(ext, "3g2") || !stricmp(ext, "3gs")) {
-			type = GF_FILE_TYPE_ISO_MEDIA;
-		} else if (!stricmp(ext, "bt") || !stricmp(ext, "wrl") || !stricmp(ext, "x3dv")) {
-			type = GF_FILE_TYPE_BT_WRL_X3DV;
-		} else if (!stricmp(ext, "xmt") || !stricmp(ext, "x3d")) {
-			type = GF_FILE_TYPE_XMT_X3D;
-		} else if (!stricmp(ext, "lsr") || !stricmp(ext, "saf")) {
-			type = GF_FILE_TYPE_LSR_SAF;
-		} else if (!stricmp(ext, "svg") || !stricmp(ext, "xsr") || !stricmp(ext, "xml")) {
-			type = GF_FILE_TYPE_SVG;
-		} else if (!stricmp(ext, "swf")) {
-			type = GF_FILE_TYPE_SWF;
-		} else if (!stricmp(ext, "jp2")) {
-			if (sep) sep0 = '.';
-			return GF_FILE_TYPE_NOT_SUPPORTED;
-		}
-		else type = GF_FILE_TYPE_NOT_SUPPORTED;
-
-		if (sep) sep0 = '.';
-	}
-
-
-	/*try open file in read mode*/
-	if (!type && gf_isom_probe_file(inName)) type = GF_FILE_TYPE_ISO_MEDIA;
-	return type;
-}
-
-
-#ifndef GPAC_DISABLE_CORE_TOOLS
-static GF_Err xml_bs_to_bin(char *inName, char *outName, u32 dump_std)
-{
-	GF_Err e;
-	GF_XMLNode *root;
-	u8 *data = NULL;
-	u32 data_size;
-
-	GF_DOMParser *dom = gf_xml_dom_new();
-	e = gf_xml_dom_parse(dom, inName, NULL, NULL);
-	if (e) {
-		gf_xml_dom_del(dom);
-		M4_LOG(GF_LOG_ERROR, ("Failed to parse XML file: %s\n", gf_error_to_string(e)));
-		return e;
-	}
-	root = gf_xml_dom_get_root_idx(dom, 0);
-	if (!root) {
-		gf_xml_dom_del(dom);
-		return GF_OK;
-	}
-
-	e = gf_xml_parse_bit_sequence(root, inName, &data, &data_size);
-	gf_xml_dom_del(dom);
-
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("Failed to parse binary sequence: %s\n", gf_error_to_string(e)));
-		return e;
-	}
-
-	if (dump_std) {
-		gf_fwrite(data, data_size, stdout);
-	} else {
-		FILE *t;
-		char szFileGF_MAX_PATH;
-		if (outName) {
-			strcpy(szFile, outName);
-		} else {
-			strcpy(szFile, inName);
-			strcat(szFile, ".bin");
-		}
-		t = gf_fopen(szFile, "wb");
-		if (!t) {
-			M4_LOG(GF_LOG_ERROR, ("Failed to open file %s\n", szFile));
-			e = GF_IO_ERR;
-		} else {
-			if (gf_fwrite(data, data_size, t) != data_size) {
-				M4_LOG(GF_LOG_ERROR, ("Failed to write output to file %s\n", szFile));
-				e = GF_IO_ERR;
-			}
-			gf_fclose(t);
-		}
-	}
-	gf_free(data);
-	return e;
-}
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
-
-static u64 do_size_top_boxes(char *inName, char *compress_top_boxes, u32 mode)
-{
-	FILE *in;
-	u64 top_size = 0;
-	Bool do_all = GF_FALSE;
-	GF_BitStream *bs_in;
-	if (!compress_top_boxes) return GF_BAD_PARAM;
-	if (!strcmp(compress_top_boxes, "all") || !strcmp(compress_top_boxes, "*") || !strcmp(compress_top_boxes, "@"))
-		do_all = GF_TRUE;
-
-	in = gf_fopen(inName, "rb");
-	if (!in) return GF_URL_ERROR;
-	bs_in = gf_bs_from_file(in, GF_BITSTREAM_READ);
-	while (gf_bs_available(bs_in)) {
-		const char *stype;
-		u32 hdr_size = 8;
-		u64 lsize = gf_bs_read_u32(bs_in);
-		u32 type = gf_bs_read_u32(bs_in);
-
-		if (lsize==1) {
-			lsize = gf_bs_read_u64(bs_in);
-			hdr_size = 16;
-		} else if (lsize==0) {
-			lsize = gf_bs_available(bs_in) + 8;
-		}
-		stype = gf_4cc_to_str(type);
-		if (do_all || strstr(compress_top_boxes, stype)) {
-			//only count boxes
-			if (mode==2) {
-				top_size += 1;
-			} else {
-				top_size += lsize;
-			}
-		}
-		gf_bs_skip_bytes(bs_in, lsize - hdr_size);
-	}
-	gf_bs_del(bs_in);
-	gf_fclose(in);
-	return top_size;
-
-}
-
-static GF_Err do_compress_top_boxes(char *inName, char *outName)
-{
-	FILE *in, *out;
-	u8 *buf;
-	u32 buf_alloc, comp_size;
-	s32 bytes_comp=0;
-	s32 bytes_uncomp=0;
-	GF_Err e = GF_OK;
-	u64 source_size, dst_size;
-	u32 orig_box_overhead;
-	u32 final_box_overhead;
-	u32 nb_added_box_bytes=0;
-	Bool has_mov = GF_FALSE;
-	Bool replace_all = !strcmp(compress_top_boxes, "*");
-	GF_BitStream *bs_in, *bs_out;
-
-	if (!outName) {
-		M4_LOG(GF_LOG_ERROR, ("Missing output file name\n"));
-		return GF_BAD_PARAM;
-	}
-
-	in = gf_fopen(inName, "rb");
-	if (!in) return GF_URL_ERROR;
-	out = gf_fopen(outName, "wb");
-	if (!out) return GF_IO_ERR;
-
-	buf_alloc = 4096;
-	buf = gf_malloc(buf_alloc);
-
-	bs_in = gf_bs_from_file(in, GF_BITSTREAM_READ);
-	source_size = gf_bs_get_size(bs_in);
-
-	bs_out = gf_bs_from_file(out, GF_BITSTREAM_WRITE);
-
-	orig_box_overhead = 0;
-	final_box_overhead = 0;
-	while (gf_bs_available(bs_in)) {
-		u32 size = gf_bs_read_u32(bs_in);
-		u32 type = gf_bs_read_u32(bs_in);
-		const char *b4cc = gf_4cc_to_str(type);
-		const u8 *replace = (const u8 *) strstr(compress_top_boxes, b4cc);
-		if (!strcmp(b4cc, "moov")) has_mov = GF_TRUE;
-
-		if (!replace && !replace_all) {
-			gf_bs_write_u32(bs_out, size);
-			gf_bs_write_u32(bs_out, type);
-
-			size-=8;
-			while (size) {
-				u32 nbytes = size;
-				if (nbytes>buf_alloc) nbytes=buf_alloc;
-				gf_bs_read_data(bs_in, buf, nbytes);
-				gf_bs_write_data(bs_out, buf, nbytes);
-				size-=nbytes;
-			}
-			continue;
-		}
-		orig_box_overhead += size;
-
-		size-=8;
-
-		if (size>buf_alloc) {
-			buf_alloc = size;
-			buf = gf_realloc(buf, buf_alloc);
-		}
-		gf_bs_read_data(bs_in, buf, size);
-
-		replace+=5;
-
-		comp_size = buf_alloc;
-
-		e = gf_gz_compress_payload(&buf, size, &comp_size);
-		if (e) break;
-
-		if (comp_size>buf_alloc) {
-			buf_alloc = comp_size;
-		}
-		bytes_uncomp += size;
-		bytes_comp += comp_size;
-
-		//write size
-		gf_bs_write_u32(bs_out, comp_size+8);
-		//write type
-		gf_bs_write_data(bs_out, replace, 4);
-		//write data
-		gf_bs_write_data(bs_out, buf, comp_size);
-
-		final_box_overhead += 8+comp_size;
-	}
-	dst_size = gf_bs_get_position(bs_out);
-
-	if (buf) gf_free(buf);
-	gf_bs_del(bs_in);
-	gf_bs_del(bs_out);
-	gf_fclose(in);
-	gf_fclose(out);
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("Error compressing: %s\n", gf_error_to_string(e)));
-		return e;
-	}
-
-	if (has_mov) {
-		u32 i, nb_tracks, nb_samples;
-		GF_ISOFile *mov;
-		Double rate, new_rate, duration;
-
-		mov = gf_isom_open(inName, GF_ISOM_OPEN_READ, NULL);
-		duration = (Double) gf_isom_get_duration(mov);
-		duration /= gf_isom_get_timescale(mov);
-
-		nb_samples = 0;
-		nb_tracks = gf_isom_get_track_count(mov);
-		for (i=0; i<nb_tracks; i++) {
-			nb_samples += gf_isom_get_sample_count(mov, i+1);
-		}
-		gf_isom_close(mov);
-
-		rate = (Double) source_size;
-		rate /= duration;
-		rate /= 1000;
-
-		new_rate = (Double) dst_size;
-		new_rate /= duration;
-		new_rate /= 1000;
-
-
-		fprintf(stderr, "Log format:\nname\torig\tcomp\tgain\tadded_bytes\torate\tcrate\tsamples\tduration\tobbps\tcbbps\n");
-		fprintf(stdout, "%s\t%d\t%d\t%g\t%d\t%g\t%g\t%d\t%g\t%g\t%g\n", inName, bytes_uncomp, bytes_comp, ((Double)(bytes_uncomp-bytes_comp)*100)/bytes_uncomp, nb_added_box_bytes, rate, new_rate, nb_samples, duration, ((Double)orig_box_overhead)/nb_samples, ((Double)final_box_overhead)/nb_samples );
-
-		fprintf(stderr, "%s Compressing top-level boxes saved %d bytes out of %d (reduced by %g %%) additional bytes %d original rate %g kbps new rate %g kbps, orig %g box bytes/sample final %g bytes/sample\n", inName, bytes_uncomp-bytes_comp, bytes_uncomp, ((Double)(bytes_uncomp-bytes_comp)*100)/bytes_uncomp, nb_added_box_bytes, rate, new_rate, ((Double)orig_box_overhead)/nb_samples, ((Double)final_box_overhead)/nb_samples );
-
-	} else {
-		fprintf(stderr, "Log format:\nname\torig\tcomp\tgain\tadded_bytes\n");
-		fprintf(stdout, "%s\t%d\t%d\t%g\t%d\n", inName, bytes_uncomp, bytes_comp, ((Double) (bytes_uncomp - bytes_comp)*100)/(bytes_uncomp), nb_added_box_bytes);
-
-		fprintf(stderr, "%s Compressing top-level boxes saved %d bytes out of %d (reduced by %g %%) additional bytes %d\n", inName, bytes_uncomp-bytes_comp, bytes_uncomp, ((Double)(bytes_uncomp-bytes_comp)*100)/bytes_uncomp, nb_added_box_bytes);
-
-	}
-	return GF_OK;
-}
-
-static GF_Err hash_file(char *name, u32 dump_std)
-{
-	u32 i;
-	u8 hash20;
-	GF_Err e = gf_media_get_file_hash(name, hash);
-	if (e) return e;
-	if (dump_std==2) {
-		gf_fwrite(hash, 20, stdout);
-	} else if (dump_std==1) {
-		for (i=0; i<20; i++) fprintf(stdout, "%02X", hashi);
-	}
-	fprintf(stderr, "File hash (SHA-1): ");
-	for (i=0; i<20; i++) fprintf(stderr, "%02X", hashi);
-	fprintf(stderr, "\n");
-
-	return GF_OK;
-}
-
-static u32 do_raw_cat()
-{
-	char chunk4096;
-	FILE *fin, *fout;
-	s64 to_copy, done;
-	fin = gf_fopen(raw_cat, "rb");
-	if (!fin) return mp4box_cleanup(1);
-
-	fout = gf_fopen(inName, "a+b");
-	if (!fout) {
-		gf_fclose(fin);
-		return mp4box_cleanup(1);
-	}
-	gf_fseek(fin, 0, SEEK_END);
-	to_copy = gf_ftell(fin);
-	gf_fseek(fin, 0, SEEK_SET);
-	done = 0;
-	while (1) {
-		u32 nb_bytes = (u32) gf_fread(chunk, 4096, fin);
-		gf_fwrite(chunk, nb_bytes, fout);
-		done += nb_bytes;
-		fprintf(stderr, "Appending file %s - %02.2f done\r", raw_cat, 100.0*done/to_copy);
-		if (done >= to_copy) break;
-	}
-	gf_fclose(fin);
-	gf_fclose(fout);
-	return mp4box_cleanup(0);
-}
-
-static u32 do_write_udp()
-{
-	GF_Err e;
-	u32 res = 0;
-	GF_Socket *sock = gf_sk_new(GF_SOCK_TYPE_UDP);
-	u16 port = 2345;
-	char *sep = strrchr(udp_dest, ':');
-	if (sep) {
-		sep0 = 0;
-		port = atoi(sep+1);
-	}
-	e = gf_sk_bind( sock, NULL, port, udp_dest, port, 0);
-	if (sep) sep0 = ':';
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("Failed to bind socket to %s: %s\n", udp_dest, gf_error_to_string(e) ));
-		res = 1;
-	} else {
-		e = gf_sk_send(sock, (u8 *) inName, (u32)strlen(inName));
-		if (e) {
-			M4_LOG(GF_LOG_ERROR, ("Failed to send datagram: %s\n", gf_error_to_string(e) ));
-			res = 1;
-		}
-	}
-	gf_sk_del(sock);
-	return res;
-}
-
-#ifndef GPAC_DISABLE_MPD
-static u32 convert_mpd()
-{
-	GF_Err e;
-	Bool remote = GF_FALSE;
-	GF_MPD *mpd;
-	char *mpd_base_url = NULL;
-	if (!strnicmp(inName, "http://", 7) || !strnicmp(inName, "https://", 8)) {
-#if !defined(GPAC_DISABLE_CORE_TOOLS)
-		e = gf_dm_wget(inName, "tmp_main.m3u8", 0, 0, &mpd_base_url);
-		if (e != GF_OK) {
-			M4_LOG(GF_LOG_ERROR, ("Cannot retrieve M3U8 (%s): %s\n", inName, gf_error_to_string(e)));
-			if (mpd_base_url) gf_free(mpd_base_url);
-			return mp4box_cleanup(1);
-		}
-		remote = GF_TRUE;
-#else
-		gf_free(mpd_base_url);
-		M4_LOG(GF_LOG_ERROR, ("HTTP Downloader disabled in this build\n"));
-		return mp4box_cleanup(1);
-#endif
-
-		if (outName)
-			strcpy(outfile, outName);
-		else {
-			const char *sep = gf_file_basename(inName);
-			char *ext = gf_file_ext_start(sep);
-			if (ext) ext0 = 0;
-			sprintf(outfile, "%s.mpd", sep);
-			if (ext) ext0 = '.';
-		}
-	} else {
-		if (outName)
-			strcpy(outfile, outName);
-		else {
-			char *dst = strdup(inName);
-			char *ext = strstr(dst, ".m3u8");
-			if (ext) ext0 = 0;
-			sprintf(outfile, "%s.mpd", dst);
-			gf_free(dst);
-		}
-	}
-
-	mpd = gf_mpd_new();
-	if (!mpd) {
-		e = GF_OUT_OF_MEM;
-		M4_LOG(GF_LOG_ERROR, ("DASH Error: MPD creation problem %s\n", gf_error_to_string(e)));
-		mp4box_cleanup(1);
-	}
-	FILE *f = gf_fopen(remote ? "tmp_main.m3u8" : inName, "r");
-	u32 manif_type = 0;
-	if (f) {
-		char szDATA1000;
-		s32 read;
-		szDATA999=0;
-		read = (s32) gf_fread(szDATA, 999, f);
-		if (read<0) read = 0;
-		szDATAread=0;
-		gf_fclose(f);
-		if (strstr(szDATA, "SmoothStreamingMedia"))
-			manif_type = 2;
-		else if (strstr(szDATA, "#EXTM3U"))
-			manif_type = 1;
-	}
-
-	if (manif_type==1) {
-		e = gf_m3u8_to_mpd(remote ? "tmp_main.m3u8" : inName, mpd_base_url ? mpd_base_url : inName, outfile, 0, "video/mp2t", GF_TRUE, use_url_template, segment_timeline, NULL, mpd, GF_TRUE, GF_TRUE);
-	} else if (manif_type==2) {
-		e = gf_mpd_smooth_to_mpd(remote ? "tmp_main.m3u8" : inName, mpd, mpd_base_url ? mpd_base_url : inName);
-	} else {
-		e = GF_NOT_SUPPORTED;
-	}
-	if (!e)
-		gf_mpd_write_file(mpd, outfile);
-
-	if (mpd)
-		gf_mpd_del(mpd);
-	if (mpd_base_url)
-		gf_free(mpd_base_url);
-
-	if (remote) {
-		gf_file_delete("tmp_main.m3u8");
-	}
-	if (e != GF_OK) {
-		M4_LOG(GF_LOG_ERROR, ("Error converting %s (%s) to MPD (%s): %s\n", (manif_type==1) ? "HLS" : "Smooth", inName, outfile, gf_error_to_string(e)));
-		return mp4box_cleanup(1);
-	} else {
-		M4_LOG(GF_LOG_INFO, ("Done converting %s (%s) to MPD (%s)\n", (manif_type==1) ? "HLS" : "Smooth", inName, outfile));
-		return mp4box_cleanup(0);
-	}
-}
-#endif
-
-static u32 do_import_sub()
-{
-	/* We import the subtitle file,
-	 i.e. we parse it and store the content as samples of a 3GPP Timed Text track in an ISO file,
-	 possibly for later export (e.g. when converting SRT to TTXT, ...) */
-#ifndef GPAC_DISABLE_MEDIA_IMPORT
-	GF_Err e;
-	GF_MediaImporter import;
-	/* Prepare the importer */
-	file = gf_isom_open("ttxt_convert", GF_ISOM_OPEN_WRITE, NULL);
-	if (timescale && file) gf_isom_set_timescale(file, timescale);
-
-	memset(&import, 0, sizeof(GF_MediaImporter));
-	import.dest = file;
-	import.in_name = inName;
-	/* Start the import */
-	e = gf_media_import(&import);
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("Error importing %s: %s\n", inName, gf_error_to_string(e)));
-		gf_isom_delete(file);
-		gf_file_delete("ttxt_convert");
-		return mp4box_cleanup(1);
-	}
-	/* Prepare the export */
-	strcpy(outfile, inName);
-	if (strchr(outfile, '.')) {
-		while (outfilestrlen(outfile)-1 != '.') outfilestrlen(outfile)-1 = 0;
-		outfilestrlen(outfile)-1 = 0;
-	}
-#ifndef GPAC_DISABLE_ISOM_DUMP
-	/* Start the export of the track #1, in the appropriate dump type, indicating it's a conversion */
-	dump_isom_timed_text(file, gf_isom_get_track_id(file, 1),
-						 dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE,
-						 GF_TRUE,
-						 (import_subtitle==2) ? GF_TEXTDUMPTYPE_SVG : (dump_srt ? GF_TEXTDUMPTYPE_SRT : GF_TEXTDUMPTYPE_TTXT));
-#endif
-	/* Clean the importer */
-	gf_isom_delete(file);
-	gf_file_delete("ttxt_convert");
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("Error converting %s: %s\n", inName, gf_error_to_string(e)));
-		return mp4box_cleanup(1);
-	}
-	return mp4box_cleanup(0);
-#else
-	M4_LOG(GF_LOG_ERROR, ("Feature not supported\n"));
-	return mp4box_cleanup(1);
-#endif
-}
-
-#if !defined(GPAC_DISABLE_MEDIA_IMPORT) && !defined(GPAC_DISABLE_ISOM_WRITE)
-static u32 do_add_cat(int argc, char **argv)
-{
-	GF_Err e;
-	u32 i, ipass, nb_pass = 1;
-	char *mux_args=NULL;
-	char *mux_sid=NULL;
-	GF_FilterSession *fs = NULL;
-	if (nb_add) {
-
-		GF_ISOOpenMode open_mode = GF_ISOM_OPEN_EDIT;
-		if (force_new) {
-			open_mode = (do_flat || (force_new==2)) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
-		} else {
-			FILE *test = gf_fopen(inName, "rb");
-			if (!test) {
-				open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
-				if (!outName) outName = inName;
-			} else {
-				gf_fclose(test);
-				if (! gf_isom_probe_file(inName) ) {
-					open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
-					if (!outName) outName = inName;
-				}
-			}
-		}
-		open_edit = do_flat ? GF_FALSE : GF_TRUE;
-		file = gf_isom_open(inName, open_mode, NULL);
-		if (!file) {
-			M4_LOG(GF_LOG_ERROR, ("Cannot open destination file %s: %s\n", inName, gf_error_to_string(gf_isom_last_error(NULL)) ));
-			return mp4box_cleanup(1);
-		}
-
-		if (freeze_box_order)
-			gf_isom_freeze_order(file);
-
-		if (do_flat) {
-			if (major_brand)
-				gf_isom_set_brand_info(file, major_brand, minor_version);
-			for (i=0; i<nb_alt_brand_add; i++) {
-				gf_isom_modify_alternate_brand(file, brand_addi, GF_TRUE);
-				do_save = GF_TRUE;
-			}
-
-			if (!major_brand && !nb_alt_brand_add && has_add_image) {
-				gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_MIF1, GF_TRUE);
-			}
-		}
-	}
-
-	if (file && keep_utc && open_edit) {
-		gf_isom_keep_utc_times(file, 1);
-	}
-
-	if (do_flat && interleaving_time) {
-		char szSubArg100;
-		gf_isom_set_storage_mode(file, GF_ISOM_STORE_FASTSTART);
-		do_flat = 2;
-		nb_pass = 2;
-		fs = gf_fs_new_defaults(0);
-		if (!fs) {
-			M4_LOG(GF_LOG_ERROR, ("Error creating filter session\n"));
-			gf_isom_delete(file);
-			return mp4box_cleanup(1);
-		}
-
-		//mux args
-		gf_dynstrcat(&mux_args, "mp4mx:importer:store=fstart", ":");
-
-		sprintf(szSubArg, "file=%p", file);
-		gf_dynstrcat(&mux_args, szSubArg, ":");
-		sprintf(szSubArg, "cdur=%g", interleaving_time);
-		gf_dynstrcat(&mux_args, szSubArg, ":");
-	}
-
-	for (ipass=0; ipass<nb_pass; ipass++) {
-		u32 tk_idx = 1;
-		for (i=0; i<(u32) argc; i++) {
-			char *margs=NULL;
-			char *msid = NULL;
-			if (!strcmp(argvi, "-add")) {
-				char *src = argvi+1;
-
-				while (src) {
-					char *loc_src = src;
-					char *sep = NULL;
-					while (1) {
-						char *opt_sep;
-						sep = strchr(loc_src, '+');
-						if (!sep) break;
-
-						sep0 = 0;
-						if (strstr(src, "://"))
-							break;
-
-						opt_sep = gf_url_colon_suffix(src, '=');
-						if (opt_sep)
-							opt_sep0 = 0;
-						if (gf_file_exists(src)) {
-							if (opt_sep)
-								opt_sep0 = ':';
-							break;
-						}
-						if (opt_sep)
-							opt_sep0 = ':';
-
-						sep0 = '+';
-						loc_src = sep+1;
-					}
-					if (fs && (ipass==0)) {
-						e = import_file(file, src, import_flags, import_fps, agg_samples, fs, &margs, &msid, tk_idx);
-					} else {
-						e = import_file(file, src, import_flags, import_fps, agg_samples, fs, NULL, NULL, tk_idx);
-					}
-					tk_idx++;
-
-					if (margs) {
-						gf_dynstrcat(&mux_args, margs, ":");
-						gf_free(margs);
-					}
-					if (msid) {
-						gf_dynstrcat(&mux_sid, msid, ",");
-						gf_free(msid);
-					}
-
-					if (e) {
-						M4_LOG(GF_LOG_ERROR, ("Error importing %s: %s\n", argvi+1, gf_error_to_string(e)));
-						gf_isom_delete(file);
-						if (fs)
-							gf_fs_del(fs);
-						return mp4box_cleanup(1);
-					}
-					if (sep) {
-						sep0 = '+';
-						src = sep+1;
-					} else {
-						break;
-					}
-				}
-				i++;
-			} else if (!strcmp(argvi, "-cat") || !strcmp(argvi, "-catx") || !strcmp(argvi, "-catpl")) {
-				if (nb_pass == 2) {
-					M4_LOG(GF_LOG_ERROR, ("Cannot cat files when using -newfs mode\n"));
-					return mp4box_cleanup(1);
-				}
-				if (!file) {
-					u8 open_mode = GF_ISOM_OPEN_EDIT;
-					if (force_new) {
-						open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
-					} else {
-						FILE *test = gf_fopen(inName, "rb");
-						if (!test) {
-							open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
-							if (!outName) outName = inName;
-						}
-						else gf_fclose(test);
-					}
-
-					open_edit = GF_TRUE;
-					file = gf_isom_open(inName, open_mode, NULL);
-					if (!file) {
-						M4_LOG(GF_LOG_ERROR, ("Cannot open destination file %s: %s\n", inName, gf_error_to_string(gf_isom_last_error(NULL)) ));
-						return mp4box_cleanup(1);
-					}
-				}
-
-				e = cat_isomedia_file(file, argvi+1, import_flags, import_fps, agg_samples, force_cat, align_cat, !strcmp(argvi, "-catx") ? GF_TRUE : GF_FALSE, !strcmp(argvi, "-catpl") ? GF_TRUE : GF_FALSE);
-				if (e) {
-					M4_LOG(GF_LOG_ERROR, ("Error appending %s: %s\n", argvi+1, gf_error_to_string(e)));
-					gf_isom_delete(file);
-					return mp4box_cleanup(1);
-				}
-				i++;
-			}
-		}
-		if ((nb_pass == 2) && !ipass) {
-			if (mux_sid) {
-				gf_dynstrcat(&mux_args, "SID=", ":");
-				gf_dynstrcat(&mux_args, mux_sid, NULL);
-			}
-			GF_Filter *mux_filter = gf_fs_load_filter(fs, mux_args, NULL);
-			gf_free(mux_args);
-			if (!mux_filter) {
-				M4_LOG(GF_LOG_ERROR, ("Error loadin isobmff mux filter\n"));
-				gf_isom_delete(file);
-				gf_fs_del(fs);
-				return mp4box_cleanup(1);
-			}
-
-			e = gf_fs_run(fs);
-			if (e==GF_EOS) e = GF_OK;
-
-			if (!e) e = gf_fs_get_last_connect_error(fs);
-			if (!e) e = gf_fs_get_last_process_error(fs);
-
-			if (e) {
-				M4_LOG(GF_LOG_ERROR, ("Error importing sources: %s\n", gf_error_to_string(e)));
-				gf_isom_delete(file);
-				gf_fs_del(fs);
-				return mp4box_cleanup(1);
-			}
-		}
-	}
-	if (fs) {
-		gf_fs_print_non_connected(fs);
-		if (fs_dump_flags & 1) gf_fs_print_stats(fs);
-		if (fs_dump_flags & 2) gf_fs_print_connections(fs);
-		gf_fs_del(fs);
-	}
-
-	/*unless explicitly asked, remove all systems tracks*/
-#ifndef GPAC_DISABLE_AV_PARSERS
-	if (!keep_sys_tracks) remove_systems_tracks(file);
-#endif
-	do_save = GF_TRUE;
-
-	return 0;
-}
-#endif /*!GPAC_DISABLE_MEDIA_IMPORT && !GPAC_DISABLE_ISOM_WRITE*/
-
-
-#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-static GF_Err do_scene_encode()
-{
-	GF_Err e;
-	FILE *logs = NULL;
-	if (do_scene_log) {
-		char alogfileGF_MAX_PATH;
-		strcpy(alogfile, inName);
-		if (strchr(alogfile, '.')) {
-			while (alogfilestrlen(alogfile)-1 != '.') alogfilestrlen(alogfile)-1 = 0;
-			alogfilestrlen(alogfile)-1 = 0;
-		}
-		strcat(alogfile, "_enc.logs");
-		logs = gf_fopen(alogfile, "wt");
-	}
-	strcpy(outfile, outName ? outName : inName);
-	if (strchr(outfile, '.')) {
-		while (outfilestrlen(outfile)-1 != '.') outfilestrlen(outfile)-1 = 0;
-		outfilestrlen(outfile)-1 = 0;
-	}
-	strcat(outfile, ".mp4");
-	file = gf_isom_open(outfile, GF_ISOM_WRITE_EDIT, NULL);
-	smenc_opts.mediaSource = mediaSource ? mediaSource : outfile;
-	e = EncodeFile(inName, file, &smenc_opts, logs);
-	if (logs) gf_fclose(logs);
-	if (e) return e;
-	do_save = GF_TRUE;
-	if (do_saf) {
-		do_save = GF_FALSE;
-		open_edit = GF_FALSE;
-	}
-	return GF_OK;
-}
-#endif //!defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-
-
-static GF_Err do_dash()
-{
-	GF_Err e;
-	u32 i;
-	Bool del_file = GF_FALSE;
-	char szMPDGF_MAX_PATH, *sep;
-	char szStateFileGF_MAX_PATH;
-	Bool dyn_state_file = GF_FALSE;
-	u32 do_abort = 0;
-	GF_DASHSegmenter *dasher=NULL;
-
-	if (crypt) {
-		M4_LOG(GF_LOG_ERROR, ("MP4Box cannot use -crypt and -dash in the same pass. Please encrypt your content first, or specify encryption filters on dash sources.\n"));
-		return GF_BAD_PARAM;
-	}
-
-	strcpy(outfile, outName ? outName : gf_url_get_resource_name(inName) );
-	sep = strrchr(outfile, '.');
-	if (sep) sep0 = 0;
-	if (!outName) strcat(outfile, "_dash");
-	strcpy(szMPD, outfile);
-	if (outName && sep) {
-		sep0 = '.';
-		strcat(szMPD, sep);
-	} else {
-		strcat(szMPD, ".mpd");
-	}
-
-	if ((dash_subduration>0) && (dash_duration > dash_subduration)) {
-		M4_LOG(GF_LOG_WARNING, ("Warning: -subdur parameter (%g s) should be greater than segment duration (%g s), using segment duration instead\n", dash_subduration, dash_duration));
-		dash_subduration = dash_duration;
-	}
-
-	if (dash_mode && dash_live)
-		M4_LOG(GF_LOG_INFO, ("Live DASH-ing - press 'q' to quit, 's' to save context and quit\n"));
-
-	if (!dash_ctx_file && dash_live) {
-		u32 r1;
-		u64 add = (u64) (intptr_t) &dasher;
-		add ^= gf_net_get_utc();
-		r1 = (u32) add ^ (u32) (add/0xFFFFFFFF);
-		r1 ^= gf_rand();
-		sprintf(szStateFile, "%s/dasher_%X.xml", gf_get_default_cache_directory(), r1 );
-		dash_ctx_file = szStateFile;
-		dyn_state_file = GF_TRUE;
-	} else if (dash_ctx_file) {
-		if (force_new)
-			gf_file_delete(dash_ctx_file);
-	}
-
-	if (dash_profile==GF_DASH_PROFILE_AUTO)
-		dash_profile = dash_mode ? GF_DASH_PROFILE_LIVE : GF_DASH_PROFILE_FULL;
-
-	if (!dash_mode) {
-		time_shift_depth = 0;
-		mpd_update_time = 0;
-	} else if ((dash_profile>=GF_DASH_PROFILE_MAIN) && !use_url_template && !mpd_update_time) {
-		/*use a default MPD update of dash_duration sec*/
-		mpd_update_time = (Double) (dash_subduration ? dash_subduration : dash_duration);
-		M4_LOG(GF_LOG_INFO, ("Using default MPD refresh of %g seconds\n", mpd_update_time));
-	}
-
-	if (file && do_save) {
-		gf_isom_close(file);
-		file = NULL;
-		del_file = GF_TRUE;
-	}
-
-	/*setup dash*/
-	dasher = gf_dasher_new(szMPD, dash_profile, NULL, dash_scale, dash_ctx_file);
-	if (!dasher) {
-		return mp4box_cleanup(1);
-	}
-	e = gf_dasher_set_info(dasher, dash_title, cprt, dash_more_info, dash_source, NULL);
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("DASH Error: %s\n", gf_error_to_string(e)));
-		gf_dasher_del(dasher);
-		return e;
-	}
-
-	gf_dasher_set_start_date(dasher, dash_start_date);
-	gf_dasher_set_location(dasher, dash_source);
-	for (i=0; i < nb_mpd_base_urls; i++) {
-		e = gf_dasher_add_base_url(dasher, mpd_base_urlsi);
-		if (e) {
-			M4_LOG(GF_LOG_ERROR, ("DASH Error: %s\n", gf_error_to_string(e)));
-			gf_dasher_del(dasher);
-			return e;
-		}
-	}
-
-	if (segment_timeline && !use_url_template) {
-		M4_LOG(GF_LOG_WARNING, ("DASH Warning: using -segment-timeline with no -url-template. Forcing URL template.\n"));
-		use_url_template = GF_TRUE;
-	}
-
-	e = gf_dasher_enable_url_template(dasher, (Bool) use_url_template, seg_name, seg_ext, init_seg_ext);
-	if (!e) e = gf_dasher_enable_segment_timeline(dasher, segment_timeline);
-	if (!e) e = gf_dasher_enable_single_segment(dasher, single_segment);
-	if (!e) e = gf_dasher_enable_single_file(dasher, single_file);
-	if (!e) e = gf_dasher_set_switch_mode(dasher, bitstream_switching_mode);
-	if (!e) e = gf_dasher_set_durations(dasher, dash_duration, interleaving_time, dash_subduration);
-	if (!e) e = gf_dasher_enable_rap_splitting(dasher, seg_at_rap, frag_at_rap);
-	if (!e) e = gf_dasher_set_segment_marker(dasher, segment_marker);
-	if (!e) e = gf_dasher_enable_sidx(dasher, (subsegs_per_sidx>=0) ? 1 : 0, (u32) subsegs_per_sidx, daisy_chain_sidx, use_ssix);
-	if (!e) e = gf_dasher_set_dynamic_mode(dasher, dash_mode, mpd_update_time, time_shift_depth, mpd_live_duration);
-	if (!e) e = gf_dasher_set_min_buffer(dasher, min_buffer);
-	if (!e) e = gf_dasher_set_ast_offset(dasher, ast_offset_ms);
-	if (!e) e = gf_dasher_enable_memory_fragmenting(dasher, memory_frags);
-	if (!e) e = gf_dasher_set_initial_isobmf(dasher, initial_moof_sn, initial_tfdt);
-	if (!e) e = gf_dasher_configure_isobmf_default(dasher, no_fragments_defaults, pssh_mode, samplegroups_in_traf, single_traf_per_moof, tfdt_per_traf, mvex_after_traks, sdtp_in_traf);
-	if (!e) e = gf_dasher_enable_utc_ref(dasher, insert_utc);
-	if (!e) e = gf_dasher_enable_real_time(dasher, frag_real_time);
-	if (!e) e = gf_dasher_set_content_protection_location_mode(dasher, cp_location_mode);
-	if (!e) e = gf_dasher_set_profile_extension(dasher, dash_profile_extension);
-	if (!e) e = gf_dasher_enable_cached_inputs(dasher, no_cache);
-	if (!e) e = gf_dasher_enable_loop_inputs(dasher, ! no_loop);
-	if (!e) e = gf_dasher_set_split_mode(dasher, dash_split_mode);
-	if (!e) e = gf_dasher_set_last_segment_merge(dasher, merge_last_seg);
-	if (!e) e = gf_dasher_set_hls_clock(dasher, hls_clock);
-	if (!e && dash_cues) e = gf_dasher_set_cues(dasher, dash_cues, strict_cues);
-	if (!e) e = gf_dasher_print_session_info(dasher, fs_dump_flags);
-	if (!e) e = gf_dasher_keep_source_utc(dasher, keep_utc);
-
-	for (i=0; i < nb_dash_inputs; i++) {
-		if (!e) e = gf_dasher_add_input(dasher, &dash_inputsi);
-	}
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("DASH Setup Error: %s\n", gf_error_to_string(e)));
-		gf_dasher_del(dasher);
-		return e;
-	}
-
-	dash_cumulated_time=0;
-
-	while (1) {
-		if (run_for && (dash_cumulated_time >= run_for)) {
-			M4_LOG(GF_LOG_INFO, ("Done running, computing static MPD\n"));
-			do_abort = 3;
-		}
-
-		dash_prev_time=gf_sys_clock();
-		if (do_abort>=2) {
-			e = gf_dasher_set_dynamic_mode(dasher, GF_DASH_DYNAMIC_LAST, 0, time_shift_depth, mpd_live_duration);
-		}
-
-		if (!e) e = gf_dasher_process(dasher);
-		if (!dash_live && (e==GF_EOS) ) {
-			M4_LOG(GF_LOG_INFO, ("Nothing to dash, too early ...\n"));
-			e = GF_OK;
-		}
-
-		if (do_abort)
-			break;
-
-		//this happens when reading file while writing them (local playback of the live session ...)
-		if (dash_live && (e==GF_IO_ERR) ) {
-			M4_LOG(GF_LOG_WARNING, ("Error dashing file (%s) but continuing ...\n", gf_error_to_string(e) ));
-			e = GF_OK;
-		}
-
-		if (e) break;
-
-		if (dash_live) {
-			u64 ms_in_session=0;
-			u32 slept = gf_sys_clock();
-			u32 sleep_for = gf_dasher_next_update_time(dasher, &ms_in_session);
-			M4_LOG(GF_LOG_INFO, ("Next generation scheduled in %u ms (DASH time "LLU" ms)\r", sleep_for, ms_in_session));
-			if (run_for && (ms_in_session>=run_for)) {
-				dash_cumulated_time = 1+run_for;
-				continue;
-			}
-
-			while (1) {
-				if (gf_prompt_has_input()) {
-					char c = (char) gf_prompt_get_char();
-					if (c=='X') {
-						do_abort = 1;
-						break;
-					}
-					if (c=='q') {
-						do_abort = 2;
-						break;
-					}
-					if (c=='s') {
-						do_abort = 3;
-						break;
-					}
-				}
-
-				if (dash_mode == GF_DASH_DYNAMIC_DEBUG) {
-					break;
-				}
-				if (!sleep_for) break;
-
-				gf_sleep(sleep_for/10);
-				sleep_for = gf_dasher_next_update_time(dasher, NULL);
-				if (sleep_for<=1) {
-					dash_now_time=gf_sys_clock();
-					dash_cumulated_time+=(dash_now_time-dash_prev_time);
-					M4_LOG(GF_LOG_INFO, ("Slept for %d ms before generation, dash cumulated time %d\n", dash_now_time - slept, dash_cumulated_time));
-					break;
-				}
-			}
-		} else {
-			break;
-		}
-	}
-
-	gf_dasher_del(dasher);
-
-	if (!run_for && dash_ctx_file && (do_abort==3) && (dyn_state_file) && !gf_sys_is_test_mode() ) {
-		char szName1024;
-		M4_LOG(GF_LOG_INFO, ("Enter file name to save dash context:\n"));
-		if (scanf("%1023s", szName) == 1) {
-			gf_file_move(dash_ctx_file, szName);
-		}
-	}
-	if (e) M4_LOG(GF_LOG_ERROR, ("Error DASHing file: %s\n", gf_error_to_string(e)));
-	if (file) gf_isom_delete(file);
-	if (del_file)
-		gf_file_delete(inName);
-
-	return e;
-}
-
-
-static GF_Err do_export_tracks_non_isobmf()
-{
-	u32 i;
-
-	GF_MediaExporter mdump;
-	char szFileGF_MAX_PATH+24;
-	for (i=0; i<nb_track_act; i++) {
-		GF_Err e;
-		TrackAction *tka = &tracksi;
-		if (tka->act_type != TRACK_ACTION_RAW_EXTRACT) continue;
-		memset(&mdump, 0, sizeof(mdump));
-		mdump.in_name = inName;
-		mdump.flags = tka->dump_type;
-		mdump.trackID = tka->trackID;
-		mdump.track_type = tka->dump_track_type;
-		mdump.sample_num = tka->sample_num;
-
-		if (dump_std) {
-			mdump.out_name = "std";
-		}
-		else if (outName) {
-			mdump.out_name = outName;
-			mdump.flags |= GF_EXPORT_MERGE;
-		} else if (nb_track_act>1) {
-			sprintf(szFile, "%s_track%d", outfile, mdump.trackID);
-			mdump.out_name = szFile;
-		} else {
-			mdump.out_name = outfile;
-		}
-		mdump.print_stats_graph = fs_dump_flags;
-		e = gf_media_export(&mdump);
-		if (e) return e;
-	}
-	return GF_OK;
-}
-
-
-static GF_Err do_dump_iod()
-{
-	GF_Err e = GF_OK;
-	GF_InitialObjectDescriptor *iod = (GF_InitialObjectDescriptor *)gf_isom_get_root_od(file);
-	if (!iod) {
-		M4_LOG(GF_LOG_WARNING, ("File %s has no IOD\n", inName));
-	} else {
-		char szNameGF_MAX_PATH+10;
-		FILE *iodf;
-		sprintf(szName, "%s.iod", outfile);
-		iodf = gf_fopen(szName, "wb");
-		if (!iodf) {
-			M4_LOG(GF_LOG_ERROR, ("Cannot open destination %s\n", szName));
-			e = GF_IO_ERR;
-		} else {
-			u8 *desc;
-			u32 size;
-			GF_BitStream *bs = gf_bs_from_file(iodf, GF_BITSTREAM_WRITE);
-			if (gf_odf_desc_write((GF_Descriptor *)iod, &desc, &size)==GF_OK) {
-				gf_fwrite(desc, size, iodf);
-				gf_free(desc);
-			} else {
-				M4_LOG(GF_LOG_ERROR, ("Error writing IOD %s\n", szName));
-				e = GF_IO_ERR;
-			}
-			gf_bs_del(bs);
-			gf_fclose(iodf);
-		}
-		gf_odf_desc_del((GF_Descriptor*)iod);
-	}
-	return e;
-}
-
-static GF_Err do_export_tracks()
-{
-	GF_Err e;
-	u32 i;
-	char szFileGF_MAX_PATH+24;
-	GF_MediaExporter mdump;
-	for (i=0; i<nb_track_act; i++) {
-		u32 j;
-		TrackAction *tka = &tracksi;
-		if (tka->act_type != TRACK_ACTION_RAW_EXTRACT) continue;
-		memset(&mdump, 0, sizeof(mdump));
-		mdump.file = file;
-		mdump.flags = tka->dump_type;
-		mdump.trackID = tka->trackID;
-		mdump.sample_num = tka->sample_num;
-		if (tka->out_name) {
-			mdump.out_name = tka->out_name;
-		} else if (outName) {
-			mdump.out_name = outName;
-			mdump.flags |= GF_EXPORT_MERGE;
-			/*don't infer extension on user-given filename*/
-			mdump.flags |= GF_EXPORT_NO_FILE_EXT;
-		} else if (mdump.trackID) {
-			sprintf(szFile, "%s_track%d", outfile, mdump.trackID);
-			mdump.out_name = szFile;
-		} else {
-			sprintf(szFile, "%s_export", outfile);
-			mdump.out_name = szFile;
-		}
-		if (tka->trackID==(u32) -1) {
-			for (j=0; j<gf_isom_get_track_count(file); j++) {
-				mdump.trackID = gf_isom_get_track_id(file, j+1);
-				sprintf(szFile, "%s_track%d", outfile, mdump.trackID);
-				mdump.out_name = szFile;
-				mdump.print_stats_graph = fs_dump_flags;
-				e = gf_media_export(&mdump);
-				if (e) return e;
-			}
-		} else {
-			mdump.print_stats_graph = fs_dump_flags;
-			e = gf_media_export(&mdump);
-			if (e) return e;
-		}
-	}
-	return GF_OK;
-}
-
-static GF_Err do_meta_act()
-{
-	u32 i;
-	for (i=0; i<nb_meta_act; i++) {
-		GF_Err e = GF_OK;
-		u32 tk = 0;
-#ifndef GPAC_DISABLE_ISOM_WRITE
-		Bool self_ref;
-#endif
-		MetaAction *meta = &metasi;
-
-		if (meta->trackID) tk = gf_isom_get_track_by_id(file, meta->trackID);
-
-		switch (meta->act_type) {
-#ifndef GPAC_DISABLE_ISOM_WRITE
-		case META_ACTION_SET_TYPE:
-			/*note: we don't handle file brand modification, this is an author stuff and cannot be guessed from meta type*/
-			e = gf_isom_set_meta_type(file, meta->root_meta, tk, meta->meta_4cc);
-			gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_ISO2, GF_TRUE);
-			do_save = GF_TRUE;
-			break;
-		case META_ACTION_ADD_ITEM:
-
-			if (meta->replace) {
-				if (!gf_isom_get_meta_item_by_id(file, meta->root_meta, tk, meta->item_id)) {
-					M4_LOG(GF_LOG_WARNING, ("No item with ID %d, ignoring replace\n", meta->item_id));
-					meta->item_id = 0;
-				} else {
-					e = gf_isom_remove_meta_item(file, meta->root_meta, tk, meta->item_id, GF_TRUE, meta->keep_props);
-					if (e) break;
-				}
-			}
-
-			self_ref = !stricmp(meta->szPath, "NULL") || !stricmp(meta->szPath, "this") || !stricmp(meta->szPath, "self");
-			e = gf_isom_add_meta_item(file, meta->root_meta, tk, self_ref, self_ref ? NULL : meta->szPath,
-			 meta->szName,
-			 meta->item_id,
-									 meta->item_type,
-			 meta->mime_type,
-			 meta->enc_type,
-			 meta->use_dref ? meta->szPath : NULL, NULL,
-			 meta->image_props);
-			if (meta->item_refs && gf_list_count(meta->item_refs)) {
-				u32 ref_i;
-				for (ref_i = 0; ref_i < gf_list_count(meta->item_refs); ref_i++) {
-					MetaRef	*ref_entry = gf_list_get(meta->item_refs, ref_i);
-					e = gf_isom_meta_add_item_ref(file, meta->root_meta, tk, meta->item_id, ref_entry->ref_item_id, ref_entry->ref_type, NULL);
-				}
-			}
-			do_save = GF_TRUE;
-			break;
-		case META_ACTION_ADD_IMAGE_ITEM:
-		{
-			u32 old_tk_count = gf_isom_get_track_count(file);
-			u32 src_tk_id = 1;
-			GF_Fraction _frac = {0,0};
-			GF_ISOFile *fsrc = file;
-			self_ref = GF_FALSE;
-
-			tk = 0;
-			if (meta->image_props && meta->image_props->auto_grid) {
-				e = GF_OK;
-				self_ref = GF_TRUE;
-			} else if (!meta->szPath || (meta->image_props && meta->image_props->sample_num && meta->image_props->use_reference)) {
-				e = GF_OK;
-				self_ref = GF_TRUE;
-				src_tk_id = meta->trackID;
-			} else if (meta->szPath) {
-				if (meta->image_props && gf_isom_probe_file(meta->szPath) && !meta->image_props->tile_mode) {
-					meta->image_props->src_file = gf_isom_open(meta->szPath, GF_ISOM_OPEN_READ, NULL);
-					e = gf_isom_last_error(meta->image_props->src_file);
-					fsrc = meta->image_props->src_file;
-					if (meta->image_props->item_ref_id)
-						src_tk_id = 0;
-				} else {
-					gf_isom_disable_brand_rewrite(file, GF_TRUE);
-					e = import_file(file, meta->szPath, 0, _frac, 0, NULL, NULL, NULL, 0);
-					gf_isom_disable_brand_rewrite(file, GF_FALSE);
-				}
-			} else {
-				M4_LOG(GF_LOG_ERROR, ("Missing file name to import\n"));
-				e = GF_BAD_PARAM;
-			}
-			if (e == GF_OK) {
-				u32 meta_type = gf_isom_get_meta_type(file, meta->root_meta, tk);
-				if (!meta_type) {
-					e = gf_isom_set_meta_type(file, meta->root_meta, tk, GF_META_ITEM_TYPE_PICT);
-				} else {
-					if (meta_type != GF_META_ITEM_TYPE_PICT) {
-						GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("Warning: file already has a root 'meta' box of type %s\n", gf_4cc_to_str(meta_type)));
-						e = GF_BAD_PARAM;
-					}
-				}
-				if (e == GF_OK) {
-					if (!meta->item_id) {
-						e = gf_isom_meta_get_next_item_id(file, meta->root_meta, tk, &meta->item_id);
-					}
-					if (e == GF_OK) {
-						if (!src_tk_id && (!meta->image_props || !meta->image_props->item_ref_id) ) {
-							u32 j;
-							for (j=0; j<gf_isom_get_track_count(fsrc); j++) {
-								if (gf_isom_is_video_handler_type (gf_isom_get_media_type(fsrc, j+1))) {
-									src_tk_id = gf_isom_get_track_id(fsrc, j+1);
-									break;
-								}
-							}
-
-							if (!src_tk_id) {
-								M4_LOG(GF_LOG_ERROR, ("No video track in file, cannot add image from track\n"));
-								e = GF_BAD_PARAM;
-							}
-						}
-
-						if (e == GF_OK && meta->replace) {
-							if (!gf_isom_get_meta_item_by_id(file, meta->root_meta, tk, meta->item_id)) {
-								M4_LOG(GF_LOG_WARNING, ("No item with ID %d, ignoring replace\n", meta->item_id));
-								meta->item_id = 0;
-							} else {
-								e = gf_isom_remove_meta_item(file, meta->root_meta, tk, meta->item_id, GF_TRUE, meta->keep_props);
-							}
-						}
-						if (e==GF_OK)
-							e = gf_isom_iff_create_image_item_from_track(file, meta->root_meta, tk, src_tk_id, meta->szName, meta->item_id, meta->image_props, NULL);
-
-						if (e == GF_OK && meta->primary) {
-							e = gf_isom_set_meta_primary_item(file, meta->root_meta, tk, meta->item_id);
-						}
-						if (e == GF_OK && meta->item_refs && gf_list_count(meta->item_refs)) {
-							u32 ref_i;
-							for (ref_i = 0; ref_i < gf_list_count(meta->item_refs); ref_i++) {
-								MetaRef	*ref_entry = gf_list_get(meta->item_refs, ref_i);
-								e = gf_isom_meta_add_item_ref(file, meta->root_meta, tk, meta->item_id, ref_entry->ref_item_id, ref_entry->ref_type, NULL);
-							}
-						}
-						if (e == GF_OK && meta->group_type) {
-							e = gf_isom_meta_add_item_group(file, meta->root_meta, tk, meta->item_id, meta->group_id, meta->group_type);
-						}
-					}
-				}
-			}
-			if (meta->image_props && meta->image_props->src_file) {
-				gf_isom_delete(meta->image_props->src_file);
-				meta->image_props->src_file = NULL;
-			} else if (!self_ref) {
-				gf_isom_remove_track(file, old_tk_count+1);
-				if (do_flat) {
-					M4_LOG(GF_LOG_ERROR, ("Warning: -flat storage cannot be used when using -add-image on external file\n"));
-					e = GF_NOT_SUPPORTED;
-				}
-			}
-			do_save = GF_TRUE;
-		}
-			break;
-		case META_ACTION_ADD_IMAGE_DERIVED:
-		{
-			u32 meta_type = gf_isom_get_meta_type(file, meta->root_meta, tk);
-			e = GF_OK;
-			if (!meta_type) {
-				e = gf_isom_set_meta_type(file, meta->root_meta, tk, GF_META_ITEM_TYPE_PICT);
-			} else {
-				if (meta_type != GF_META_ITEM_TYPE_PICT) {
-					GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("Warning: file already has a root 'meta' box of type %s\n", gf_4cc_to_str(meta_type)));
-					e = GF_BAD_PARAM;
-				}
-			}
-			if (e) break;
-			if (!meta->item_id) {
-				e = gf_isom_meta_get_next_item_id(file, meta->root_meta, tk, &meta->item_id);
-			}
-			if (e == GF_OK && meta->item_type) {
-				if (meta->item_type == GF_4CC('g','r','i','d')) {
-					e = gf_isom_iff_create_image_grid_item(file, meta->root_meta, tk,
-							meta->szName && strlen(meta->szName) ? meta->szName : NULL,
-							meta->item_id,
-							meta->image_props);
-				} else if (meta->item_type == GF_4CC('i','o','v','l')) {
-					e = gf_isom_iff_create_image_overlay_item(file, meta->root_meta, tk,
-							meta->szName && strlen(meta->szName) ? meta->szName : NULL,
-							meta->item_id,
-							meta->image_props);
-				} else if (meta->item_type == GF_4CC('i','d','e','n')) {
-					e = gf_isom_iff_create_image_identity_item(file, meta->root_meta, tk,
-							meta->szName && strlen(meta->szName) ? meta->szName : NULL,
-							meta->item_id,
-							meta->image_props);
-				} else {
-					e = GF_NOT_SUPPORTED;
-				}
-				if (e) break;
-				if (meta->primary) {
-					e = gf_isom_set_meta_primary_item(file, meta->root_meta, tk, meta->item_id);
-					if (e) break;
-				}
-				if (meta->item_refs && gf_list_count(meta->item_refs)) {
-					u32 ref_i;
-					for (ref_i = 0; ref_i < gf_list_count(meta->item_refs); ref_i++) {
-						MetaRef	*ref_entry = gf_list_get(meta->item_refs, ref_i);
-						e = gf_isom_meta_add_item_ref(file, meta->root_meta, tk, meta->item_id, ref_entry->ref_item_id, ref_entry->ref_type, NULL);
-						if (e) break;
-					}
-				}
-			}
-			do_save = GF_TRUE;
-		}
-			break;
-		case META_ACTION_REM_ITEM:
-			e = gf_isom_remove_meta_item(file, meta->root_meta, tk, meta->item_id, GF_FALSE, NULL);
-			do_save = GF_TRUE;
-			break;
-		case META_ACTION_SET_PRIMARY_ITEM:
-			e = gf_isom_set_meta_primary_item(file, meta->root_meta, tk, meta->item_id);
-			do_save = GF_TRUE;
-			break;
-		case META_ACTION_SET_XML:
-		case META_ACTION_SET_BINARY_XML:
-			e = gf_isom_set_meta_xml(file, meta->root_meta, tk, meta->szPath, NULL, 0, (meta->act_type==META_ACTION_SET_BINARY_XML) ? 1 : 0);
-			do_save = GF_TRUE;
-			break;
-		case META_ACTION_REM_XML:
-			if (gf_isom_get_meta_item_count(file, meta->root_meta, tk)) {
-				e = gf_isom_remove_meta_xml(file, meta->root_meta, tk);
-				do_save = GF_TRUE;
-			} else {
-				M4_LOG(GF_LOG_WARNING, ("No meta box in input file\n"));
-				e = GF_OK;
-			}
-			break;
-		case META_ACTION_DUMP_ITEM:
-			if (gf_isom_get_meta_item_count(file, meta->root_meta, tk)) {
-				e = gf_isom_extract_meta_item(file, meta->root_meta, tk, meta->item_id, meta->szPath && strlen(meta->szPath) ? meta->szPath : NULL);
-			} else {
-				M4_LOG(GF_LOG_WARNING, ("No meta box in input file\n"));
-				e = GF_OK;
-			}
-			break;
-#endif // GPAC_DISABLE_ISOM_WRITE
-
-		case META_ACTION_DUMP_XML:
-			if (gf_isom_has_meta_xml(file, meta->root_meta, tk)) {
-				e = gf_isom_extract_meta_xml(file, meta->root_meta, tk, meta->szPath, NULL);
-			} else {
-				M4_LOG(GF_LOG_WARNING, ("No meta box in input file\n"));
-				e = GF_OK;
-			}
-			break;
-		default:
-			break;
-		}
-		if (meta->item_refs) {
-			while (gf_list_count(meta->item_refs)) {
-				gf_free(gf_list_pop_back(meta->item_refs));
-			}
-			gf_list_del(meta->item_refs);
-			meta->item_refs = NULL;
-		}
-		// meta->image_props is freed in mp4box_cleanup
-		if (e) return e;
-	}
-	return GF_OK;
-}
-
-static GF_Err do_tsel_act()
-{
-	u32 i;
-	GF_Err e;
-	for (i=0; i<nb_tsel_acts; i++) {
-		switch (tsel_actsi.act_type) {
-		case TSEL_ACTION_SET_PARAM:
-			e = gf_isom_set_track_switch_parameter(file,
-			 gf_isom_get_track_by_id(file, tsel_actsi.trackID),
-			 tsel_actsi.refTrackID ? gf_isom_get_track_by_id(file, tsel_actsi.refTrackID) : 0,
-			 tsel_actsi.is_switchGroup ? 1 : 0,
-			 &tsel_actsi.switchGroupID,
-			 tsel_actsi.criteria, tsel_actsi.nb_criteria);
-			if (e == GF_BAD_PARAM) {
-				u32 alternateGroupID, nb_groups;
-				gf_isom_get_track_switch_group_count(file, gf_isom_get_track_by_id(file, tsel_actsi.trackID), &alternateGroupID, &nb_groups);
-				if (alternateGroupID) {
-					M4_LOG(GF_LOG_ERROR, ("Error - for adding more tracks to group, using: -group-add -refTrack=ID1:criteria:trackID=ID2\n"));
-				} else {
-					M4_LOG(GF_LOG_ERROR, ("Error - for creating a new grouping information, using -group-add -trackID=ID1:criteria:trackID=ID2\n"));
-				}
-			}
-			if (e) return e;
-			do_save = GF_TRUE;
-			break;
-		case TSEL_ACTION_REMOVE_TSEL:
-			e = gf_isom_reset_track_switch_parameter(file, gf_isom_get_track_by_id(file, tsel_actsi.trackID), 0);
-			if (e) return e;
-			do_save = GF_TRUE;
-			break;
-		case TSEL_ACTION_REMOVE_ALL_TSEL_IN_GROUP:
-			e = gf_isom_reset_track_switch_parameter(file, gf_isom_get_track_by_id(file, tsel_actsi.trackID), 1);
-			if (e) return e;
-			do_save = GF_TRUE;
-			break;
-		default:
-			break;
-		}
-	}
-	return GF_OK;
-}
-
-static void do_ipod_conv()
-{
-	u32 i, ipod_major_brand = 0;
-	M4_LOG(GF_LOG_INFO, ("Setting up iTunes/iPod file\n"));
-
-	for (i=0; i<gf_isom_get_track_count(file); i++) {
-		u32 mType = gf_isom_get_media_type(file, i+1);
-		switch (mType) {
-		case GF_ISOM_MEDIA_VISUAL:
-		case GF_ISOM_MEDIA_AUXV:
-		case GF_ISOM_MEDIA_PICT:
-			ipod_major_brand = GF_ISOM_BRAND_M4V;
-			gf_isom_set_ipod_compatible(file, i+1);
-			break;
-		case GF_ISOM_MEDIA_AUDIO:
-			if (!ipod_major_brand) ipod_major_brand = GF_ISOM_BRAND_M4A;
-			else gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_M4A, GF_TRUE);
-			break;
-		case GF_ISOM_MEDIA_TEXT:
-			/*this is a text track track*/
-			if (gf_isom_get_media_subtype(file, i+1, 1) == GF_ISOM_SUBTYPE_TX3G) {
-				Bool is_chap = 0;
-				u32 j;
-				for (j=0; j<gf_isom_get_track_count(file); j++) {
-					s32 count = gf_isom_get_reference_count(file, j+1, GF_ISOM_REF_CHAP);
-					if (count>0) {
-						u32 tk, k;
-						for (k=0; k<(u32) count; k++) {
-							gf_isom_get_reference(file, j+1, GF_ISOM_REF_CHAP, k+1, &tk);
-							if (tk==i+1) {
-								is_chap = 1;
-								break;
-							}
-						}
-						if (is_chap) break;
-					}
-					if (is_chap) break;
-				}
-				/*this is a subtitle track*/
-				if (!is_chap)
-					gf_isom_set_media_type(file, i+1, GF_ISOM_MEDIA_SUBT);
-			}
-			break;
-		}
-	}
-	gf_isom_set_brand_info(file, ipod_major_brand, 1);
-	gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_MP42, GF_TRUE);
-	do_save = GF_TRUE;
-}
-
-static GF_Err do_track_act()
-{
-	u32 j;
-	for (j=0; j<nb_track_act; j++) {
-		u32 i;
-		GF_Err e = GF_OK;
-		TrackAction *tka = &tracksj;
-		u32 track = tka->trackID ? gf_isom_get_track_by_id(file, tka->trackID) : 0;
-
-		timescale = gf_isom_get_timescale(file);
-		switch (tka->act_type) {
-		case TRACK_ACTION_REM_TRACK:
-			e = gf_isom_remove_track(file, track);
-			if (e) {
-				M4_LOG(GF_LOG_ERROR, ("Error Removing track ID %d: %s\n", tka->trackID, gf_error_to_string(e)));
-			} else {
-				M4_LOG(GF_LOG_INFO, ("Removing track ID %d\n", tka->trackID));
-			}
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_LANGUAGE:
-			for (i=0; i<gf_isom_get_track_count(file); i++) {
-				if (track && (track != i+1)) continue;
-				e = gf_isom_set_media_language(file, i+1, tka->lang);
-				if (e) return e;
-				do_save = GF_TRUE;
-			}
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_KIND:
-			for (i=0; i<gf_isom_get_track_count(file); i++) {
-				if (track && (track != i+1)) continue;
-				e = gf_isom_add_track_kind(file, i+1, tka->kind_scheme, tka->kind_value);
-				if (e) return e;
-				do_save = GF_TRUE;
-			}
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_REM_KIND:
-			for (i=0; i<gf_isom_get_track_count(file); i++) {
-				if (track && (track != i+1)) continue;
-				e = gf_isom_remove_track_kind(file, i+1, tka->kind_scheme, tka->kind_value);
-				if (e) return e;
-				do_save = GF_TRUE;
-			}
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_DELAY:
-			if (tka->delay.num && tka->delay.den) {
-				u64 tk_dur;
-
-				e = gf_isom_remove_edits(file, track);
-				if (e) return e;
-				tk_dur = gf_isom_get_track_duration(file, track);
-				if (gf_isom_get_edits_count(file, track))
-					do_save = GF_TRUE;
-				if (tka->delay.num>0) {
-					//cast to u64, delay_ms * timescale can be quite big before / 1000
-					e = gf_isom_append_edit(file, track, ((u64) tka->delay.num) * timescale / tka->delay.den, 0, GF_ISOM_EDIT_EMPTY);
-					if (e) return e;
-					e = gf_isom_append_edit(file, track, tk_dur, 0, GF_ISOM_EDIT_NORMAL);
-					if (e) return e;
-					do_save = GF_TRUE;
-				} else {
-					//cast to u64, delay_ms * timescale can be quite big before / 1000
-					u64 to_skip = ((u64) -tka->delay.num) * timescale / tka->delay.den;
-					if (to_skip<tk_dur) {
-						//cast to u64, delay_ms * timescale can be quite big before / 1000
-						u64 media_time = ((u64) -tka->delay.num) * gf_isom_get_media_timescale(file, track) / tka->delay.den;
-						e = gf_isom_append_edit(file, track, tk_dur-to_skip, media_time, GF_ISOM_EDIT_NORMAL);
-						if (e) return e;
-						do_save = GF_TRUE;
-					} else {
-						M4_LOG(GF_LOG_WARNING, ("Warning: request negative delay longer than track duration - ignoring\n"));
-					}
-				}
-			} else if (gf_isom_get_edits_count(file, track)) {
-				e = gf_isom_remove_edits(file, track);
-				if (e) return e;
-				do_save = GF_TRUE;
-			}
-			break;
-		case TRACK_ACTION_SET_KMS_URI:
-			for (i=0; i<gf_isom_get_track_count(file); i++) {
-				if (track && (track != i+1)) continue;
-				if (!gf_isom_is_media_encrypted(file, i+1, 1)) continue;
-				if (!gf_isom_is_ismacryp_media(file, i+1, 1)) continue;
-				e = gf_isom_change_ismacryp_protection(file, i+1, 1, NULL, (char *) tka->kms);
-				if (e) return e;
-				do_save = GF_TRUE;
-			}
-			break;
-		case TRACK_ACTION_SET_ID:
-			if (!tka->trackID && (gf_isom_get_track_count(file) == 1)) {
-				M4_LOG(GF_LOG_WARNING, ("Warning: track id is not specified, but file has only one track - assume that you want to change id for this track\n"));
-				track = 1;
-			}
-			if (track) {
-				u32 newTrack;
-				newTrack = gf_isom_get_track_by_id(file, tka->newTrackID);
-				if (newTrack != 0) {
-					M4_LOG(GF_LOG_WARNING, ("Cannot set track id with value %d because a track already exists - ignoring", tka->newTrackID));
-				} else {
-					e = gf_isom_set_track_id(file, track, tka->newTrackID);
-					if (e) return e;
-					do_save = GF_TRUE;
-				}
-			} else {
-				M4_LOG(GF_LOG_WARNING, ("Error: Cannot change id for track %d because it does not exist - ignoring", tka->trackID));
-			}
-			break;
-		case TRACK_ACTION_SWAP_ID:
-			if (track) {
-				u32 tk1, tk2;
-				tk1 = gf_isom_get_track_by_id(file, tka->trackID);
-				tk2 = gf_isom_get_track_by_id(file, tka->newTrackID);
-				if (!tk1 || !tk2) {
-					M4_LOG(GF_LOG_WARNING, ("Error: Cannot swap track IDs because not existing - ignoring"));
-				} else {
-					e = gf_isom_set_track_id(file, tk2, 0);
-					if (e) return e;
-					e = gf_isom_set_track_id(file, tk1, tka->newTrackID);
-					if (e) return e;
-					e = gf_isom_set_track_id(file, tk2, tka->trackID);
-					if (e) return e;
-					do_save = GF_TRUE;
-				}
-			} else {
-				M4_LOG(GF_LOG_WARNING, ("Error: Cannot change id for track %d because it does not exist - ignoring", tka->trackID));
-			}
-			break;
-		case TRACK_ACTION_SET_PAR:
-			e = gf_media_change_par(file, track, tka->par_num, tka->par_den, tka->force_par, tka->rewrite_bs);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_CLAP:
-			e = gf_isom_set_clean_aperture(file, track, 1, tka->clap_wnum, tka->clap_wden, tka->clap_hnum, tka->clap_hden, tka->clap_honum, tka->clap_hoden, tka->clap_vonum, tka->clap_voden);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_MX:
-			e = gf_isom_set_track_matrix(file, track, tka->mx);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_HANDLER_NAME:
-			e = gf_isom_set_handler_name(file, track, tka->hdl_name);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_ENABLE:
-			if (!gf_isom_is_track_enabled(file, track)) {
-				e = gf_isom_set_track_enabled(file, track, GF_TRUE);
-				do_save = GF_TRUE;
-			}
-			break;
-		case TRACK_ACTION_DISABLE:
-			if (gf_isom_is_track_enabled(file, track)) {
-				e = gf_isom_set_track_enabled(file, track, GF_FALSE);
-				do_save = GF_TRUE;
-			}
-			break;
-		case TRACK_ACTION_REFERENCE:
-			e = gf_isom_set_track_reference(file, track, GF_4CC(tka->lang0, tka->lang1, tka->lang2, tka->lang3), tka->newTrackID);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_REM_NON_RAP:
-			e = gf_media_remove_non_rap(file, track, GF_FALSE);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_REM_NON_REFS:
-			e = gf_media_remove_non_rap(file, track, GF_TRUE);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_UDTA:
-			e = set_file_udta(file, track, tka->udta_type, tka->string ? tka->string : tka->src_name , tka->sample_num ? GF_TRUE : GF_FALSE, tka->string ? GF_TRUE : GF_FALSE);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_EDITS:
-			e = apply_edits(file, track, tka->string);
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_TIME:
-			if (!tka->trackID) {
-				e = gf_isom_set_creation_time(file, tka->time, tka->time);
-				if (e) return e;
-				for (i=0; i<gf_isom_get_track_count(file); i++) {
-					e = gf_isom_set_track_creation_time(file, i+1, tka->time, tka->time);
-					if (e) return e;
-				}
-			} else {
-				e = gf_isom_set_track_creation_time(file, track, tka->time, tka->time);
-			}
-			do_save = GF_TRUE;
-			break;
-		case TRACK_ACTION_SET_MEDIA_TIME:
-			for (i=0; i<gf_isom_get_track_count(file); i++) {
-				if (track && (track != i+1)) continue;
-				e = gf_isom_set_media_creation_time(file, i+1, tka->time, tka->time);
-				if (e) return e;
-			}
-			do_save = GF_TRUE;
-			break;
-		default:
-			break;
-		}
-		if (e) return e;
-	}
-	return GF_OK;
-}
-
-static GF_Err do_itunes_tag()
-{
-	GF_Err e;
-	char *itunes_data = NULL;
-	char *tags = itunes_tags;
-
-	if (gf_file_exists(itunes_tags)) {
-		u32 len;
-		e = gf_file_load_data(itunes_tags, (u8 **) &itunes_data, &len);
-		if (e) return e;
-		tags = itunes_data;
-	}
-
-	while (tags) {
-		char *val;
-		Bool clear = GF_FALSE;
-		Bool is_wma = GF_FALSE;
-		u32 tlen, tagtype=0, itag = 0;
-		s32 tag_idx=-1;
-		char *sep = itunes_data ? strchr(tags, '\n') : gf_url_colon_suffix(tags, '=');
-		while (sep) {
-			char *eq = strchr(sep+1, '=');
-			if (eq) eq0 = 0;
-			s32 next_tag_idx = gf_itags_find_by_name(sep+1);
-			if (next_tag_idx<0) {
-				//4CC tag
-				if ( strlen(sep+1)==4) {
-					next_tag_idx = 0;
-				}
-				//3CC tag, changed to @tag
-				if ( strlen(sep+1)==3) {
-					next_tag_idx = 0;
-				}
-				//unrecognized tag tag
-				else {
-					M4_LOG(GF_LOG_WARNING, ("Unrecognize tag \"%s\", assuming part of previous tag\n", sep+1));
-				}
-			}
-
-			if (eq) eq0 = '=';
-			if (next_tag_idx>=0) {
-				sep0 = 0;
-				break;
-			}
-			sep = itunes_data ? strchr(sep+1, '\n') : gf_url_colon_suffix(sep+1, '=');
-		}
-		val = strchr(tags, '=');
-		if (val) val0 = 0;
-		if (!strcmp(tags, "clear") || !strcmp(tags, "reset")) {
-			clear = GF_TRUE;
-		} else if (!strncmp(tags, "WM/", 3) ) {
-			is_wma = GF_TRUE;
-		} else {
-			tag_idx = gf_itags_find_by_name(tags);
-			if (tag_idx<0) {
-				if (strlen(tags)==4) {
-					itag = GF_4CC(tags0, tags1, tags2, tags3);
-					tagtype = GF_ITAG_STR;
-				} else if (strlen(tags)==3) {
-					itag = GF_4CC(0xA9, tags0, tags1, tags2);
-					tagtype = GF_ITAG_STR;
-				}
-			}
-		}
-		if (val) {
-			val0 = '=';
-			val++;
-		}
-		if (!itag && !clear && !is_wma) {
-			if (tag_idx<0) {
-				M4_LOG(GF_LOG_WARNING, ("Invalid iTune tag name \"%s\" - ignoring\n", tags));
-				break;
-			}
-			itag = gf_itags_get_itag(tag_idx);
-			tagtype = gf_itags_get_type(tag_idx);
-		}
-		if (!val || (val0==':') || !val0 || !stricmp(val, "NULL") ) val = NULL;
-
-		//if val is NULL, use tlen=1 to force removal of tag
-		tlen = val ? (u32) strlen(val) : 1;
-		if (clear) {
-			e = gf_isom_apple_set_tag(file, GF_ISOM_ITUNE_RESET, NULL, 0, 0, 0);
-		}
-		else if (is_wma) {
-			if (val) val-1 = 0;
-			e = gf_isom_wma_set_tag(file, tags, val);
-			if (val) val-1 = '=';
-		}
-		else if (val && (tagtype==GF_ITAG_FILE)) {
-			u32 flen = (u32) strlen(val);
-			u8 *d=NULL;
-			while (flen && valflen-1=='\n') flen--;
-			valflen = 0;
-			e = gf_file_load_data(val, (u8 **) &d, &tlen);
-			valflen = '\n';
-
-			if (!e)
-				e = gf_isom_apple_set_tag(file, itag, d, tlen, 0, 0);
-
-			if (d) gf_free(d);
-		} else {
-			e = gf_isom_apple_set_tag(file, itag, (u8 *) val, tlen, 0, 0);
-		}
-		if (e) {
-			M4_LOG(GF_LOG_ERROR, ("Error assigning tag %s: %s\n", tags, gf_error_to_string(e) ));
-		}
-
-		do_save = GF_TRUE;
-
-		if (sep) {
-			sep0 = itunes_data ? '\n' : ':';
-			tags = sep+1;
-		} else {
-			tags = NULL;
-		}
-	}
-	if (itunes_data) gf_free(itunes_data);
-	return GF_OK;
-}
-
-#if !defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)
-static void set_sdp_ext()
-{
-	u32 i, j;
-	for (i=0; i<nb_sdp_ex; i++) {
-		if (sdp_linesi.trackID) {
-			u32 track = gf_isom_get_track_by_id(file, sdp_linesi.trackID);
-			if (gf_isom_get_media_type(file, track)!=GF_ISOM_MEDIA_HINT) {
-				s32 ref_count;
-				u32 k, count = gf_isom_get_track_count(file);
-				for (j=0; j<count; j++) {
-					if (gf_isom_get_media_type(file, j+1)!=GF_ISOM_MEDIA_HINT) continue;
-					ref_count = gf_isom_get_reference_count(file, j+1, GF_ISOM_REF_HINT);
-					if (ref_count<0) continue;
-					for (k=0; k<(u32) ref_count; k++) {
-						u32 refTk;
-						if (gf_isom_get_reference(file, j+1, GF_ISOM_REF_HINT, k+1, &refTk)) continue;
-						if (refTk==track) {
-							track = j+1;
-							j=count;
-							break;
-						}
-					}
-				}
-			}
-			gf_isom_sdp_add_track_line(file, track, sdp_linesi.line);
-			do_save = GF_TRUE;
-		} else {
-			gf_isom_sdp_add_line(file, sdp_linesi.line);
-			do_save = GF_TRUE;
-		}
-	}
-}
-#endif /*!defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)*/
-
-static GF_Err do_remux_file()
-{
-	GF_MediaExporter mdump;
-	memset(&mdump, 0, sizeof(GF_MediaExporter));
-	mdump.in_name = inName;
-	mdump.out_name = mux_name;
-	mdump.flags = GF_EXPORT_REMUX;
-	mdump.print_stats_graph = fs_dump_flags;
-	return gf_media_export(&mdump);
-}
-
-static u32 mp4box_cleanup(u32 ret_code) {
-	if (mpd_base_urls) {
-		gf_free(mpd_base_urls);
-		mpd_base_urls = NULL;
-	}
-	if (sdp_lines) {
-		gf_free(sdp_lines);
-		sdp_lines = NULL;
-	}
-	if (metas) {
-		u32 i;
-		for (i=0; i<nb_meta_act; i++) {
-			if (metasi.enc_type) gf_free(metasi.enc_type);
-			if (metasi.mime_type) gf_free(metasi.mime_type);
-			if (metasi.szName) gf_free(metasi.szName);
-			if (metasi.szPath) gf_free(metasi.szPath);
-			if (metasi.keep_props) gf_free(metasi.keep_props);
-			if (metasi.image_props) {
-				GF_ImageItemProperties *iprops = metasi.image_props;
-				if (iprops->overlay_offsets) gf_free(iprops->overlay_offsets);
-				if (iprops->aux_urn) gf_free((char *) iprops->aux_urn);
-				if (iprops->aux_data) gf_free((char *) iprops->aux_data);
-				gf_free(iprops);
-			}
-		}
-		gf_free(metas);
-		metas = NULL;
-	}
-	if (tracks) {
-		u32 i;
-		for (i = 0; i<nb_track_act; i++) {
-			if (tracksi.out_name)
-				gf_free(tracksi.out_name);
-			if (tracksi.src_name)
-				gf_free(tracksi.src_name);
-			if (tracksi.string)
-				gf_free(tracksi.string);
-			if (tracksi.kind_scheme)
-				gf_free(tracksi.kind_scheme);
-			if (tracksi.kind_value)
-				gf_free(tracksi.kind_value);
-		}
-		gf_free(tracks);
-		tracks = NULL;
-	}
-	if (tsel_acts) {
-		gf_free(tsel_acts);
-		tsel_acts = NULL;
-	}
-	if (brand_add) {
-		gf_free(brand_add);
-		brand_add = NULL;
-	}
-	if (brand_rem) {
-		gf_free(brand_rem);
-		brand_rem = NULL;
-	}
-	if (dash_inputs) {
-		u32 i, j;
-		for (i = 0; i<nb_dash_inputs; i++) {
-			GF_DashSegmenterInput *di = &dash_inputsi;
-			if (di->nb_baseURL) {
-				for (j = 0; j<di->nb_baseURL; j++) {
-					gf_free(di->baseURLj);
-				}
-				gf_free(di->baseURL);
-			}
-			if (di->rep_descs) {
-				for (j = 0; j<di->nb_rep_descs; j++) {
-					gf_free(di->rep_descsj);
-				}
-				gf_free(di->rep_descs);
-			}
-			if (di->as_descs) {
-				for (j = 0; j<di->nb_as_descs; j++) {
-					gf_free(di->as_descsj);
-				}
-				gf_free(di->as_descs);
-			}
-			if (di->as_c_descs) {
-				for (j = 0; j<di->nb_as_c_descs; j++) {
-					gf_free(di->as_c_descsj);
-				}
-				gf_free(di->as_c_descs);
-			}
-			if (di->p_descs) {
-				for (j = 0; j<di->nb_p_descs; j++) {
-					gf_free(di->p_descsj);
-				}
-				gf_free(di->p_descs);
-			}
-			if (di->representationID) gf_free(di->representationID);
-			if (di->periodID) gf_free(di->periodID);
-			if (di->xlink) gf_free(di->xlink);
-			if (di->seg_template) gf_free(di->seg_template);
-			if (di->hls_pl) gf_free(di->hls_pl);
-			if (di->source_opts) gf_free(di->source_opts);
-			if (di->filter_chain) gf_free(di->filter_chain);
-
-			if (di->roles) {
-				for (j = 0; j<di->nb_roles; j++) {
-					gf_free(di->rolesj);
-				}
-				gf_free(di->roles);
-			}
-		}
-		gf_free(dash_inputs);
-		dash_inputs = NULL;
-	}
-	if (logfile) gf_fclose(logfile);
-	gf_sys_close();
-
-#ifdef GPAC_MEMORY_TRACKING
-	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
-		gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
-		gf_memory_print();
-	}
-#endif
-
-	return ret_code;
-}
-
-
-
-int mp4boxMain(int argc, char **argv)
-{
-	u32 i, j;
-	const char *gpac_profile = "0";
-	GF_Err e = GF_OK;
-
-#ifdef TEST_ARGS
-	i=0;
-	mp4box_parse_single_arg(argc, argv, "", &i);
-#endif
-
-	for (i = 1; i < (u32) argc ; i++) {
-		if (!strcmp(argvi, "-mem-track") || !strcmp(argvi, "-mem-track-stack")) {
-#ifdef GPAC_MEMORY_TRACKING
- mem_track = !strcmp(argvi, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
-#else
-			M4_LOG(GF_LOG_WARNING, ("WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", argvi));
-#endif
-			break;
-		}
-		else if (!strcmp(argvi, "-p")) {
-			if (i+1<(u32) argc)
-				gpac_profile = argvi+1;
-			else {
-				M4_LOG(GF_LOG_ERROR, ("Bad argument for -p, expecting profile name but no more args\n"));
-				return 1;
-			}
-		}
-		else if (!strncmp(argvi, "-p=", 3))
-			gpac_profile = argvi+3;
-	}
-
-#ifdef _TWO_DIGIT_EXPONENT
-	_set_output_format(_TWO_DIGIT_EXPONENT);
-#endif
-
-	/*init libgpac*/
-	gf_sys_init(mem_track, gpac_profile);
-	if (argc < 2) {
-		M4_LOG(GF_LOG_ERROR, ("Not enough arguments - check usage with -h\n"));
-		M4_LOG(GF_LOG_INFO, ("MP4Box - GPAC version %s\n"
-	 "%s\n", gf_gpac_version(), gf_gpac_copyright_cite() ));
-		gf_sys_close();
-		return 0;
-	}
-
-	helpout = stdout;
-
-	i = mp4box_parse_args(argc, argv);
-	if (i) {
-		return mp4box_cleanup(i - 1);
-	}
-#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
-	if (live_scene) {
-		int ret = live_session(argc, argv);
-		return mp4box_cleanup(ret);
-	}
-#endif
-
-	if (!dash_duration && interleaving_time && do_frag)
-		interleaving_time /= 1000;
-
-	if (do_mpd_conv) inName = do_mpd_conv;
-
-#ifndef GPAC_DISABLE_STREAMING
-	if (import_flags & GF_IMPORT_FORCE_MPEG4)
-		hint_flags |= GP_RTP_PCK_FORCE_MPEG4;
-#endif
-
-	if (!inName && dump_std)
-		inName = "std";
-
-	if (!dash_duration && cprt)
-		open_edit = GF_TRUE;
-
-	if (!inName) {
-		if (has_next_arg) {
-			M4_LOG(GF_LOG_ERROR, ("Broken argument specifier or file name missing - check usage with -h\n"));
-		} else {
-			PrintUsage();
-		}
-		return mp4box_cleanup(1);
-	}
-	if (!strcmp(inName, "std")) dump_std = 2;
-	if (!strcmp(inName, "stdb")) {
-		inName = "std";
-		dump_std = 1;
-	}
-
-	if (!interleaving_time) {
-		/*by default use single fragment per dash segment*/
-		if (dash_duration)
-			interleaving_time = dash_duration;
-		else if (!do_flat && !(split_duration || split_size || split_range_str)) {
-			interleaving_time = DEFAULT_INTERLEAVING_IN_SEC;
-		}
-	}
-
-	if (dump_std)
-		outName = "std";
-
-	if (dump_std==2) {
-#ifdef WIN32
-		if ( _setmode(_fileno(stdout), _O_BINARY) == -1 )
-#else
-		if ( freopen(NULL, "wb", stdout) == NULL)
-#endif
-		{
-			M4_LOG(GF_LOG_ERROR, ("Fatal error: cannot reopen stdout in binary mode.\n"));
-			return mp4box_cleanup(1);
-		}
-	}
-
-	GF_LOG_Level level = verbose ? GF_LOG_DEBUG : GF_LOG_INFO;
-	gf_log_set_tool_level(GF_LOG_CONTAINER, level);
-	gf_log_set_tool_level(GF_LOG_SCENE, level);
-	gf_log_set_tool_level(GF_LOG_PARSER, level);
-	gf_log_set_tool_level(GF_LOG_MEDIA, level);
-	gf_log_set_tool_level(GF_LOG_CODING, level);
-	gf_log_set_tool_level(GF_LOG_DASH, level);
-#ifdef GPAC_MEMORY_TRACKING
-	if (mem_track)
-		gf_log_set_tool_level(GF_LOG_MEMORY, level);
-#endif
-
-	e = gf_sys_set_args(argc, (const char **) argv);
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("Error assigning libgpac arguments: %s\n", gf_error_to_string(e) ));
-		return mp4box_cleanup(1);
-	}
-
-	if (raw_cat)
-		return do_raw_cat();
-
-	if (compress_top_boxes) {
-		if (size_top_box) {
-			u64 top_size = do_size_top_boxes(inName, compress_top_boxes, size_top_box);
-			fprintf(stdout, LLU"\n", top_size);
-			return mp4box_cleanup(e ? 1 : 0);
-		} else {
-			e = do_compress_top_boxes(inName, outName);
-			return mp4box_cleanup(e ? 1 : 0);
-		}
-	}
-
-	if (do_mpd_rip) {
-		e = rip_mpd(inName, outName);
-		return mp4box_cleanup(e ? 1 : 0);
-	}
-
-#ifndef GPAC_DISABLE_CORE_TOOLS
-	if (do_wget != NULL) {
-		e = gf_dm_wget(do_wget, inName, 0, 0, NULL);
-		if (e != GF_OK) {
-			M4_LOG(GF_LOG_ERROR, ("Cannot retrieve %s: %s\n", do_wget, gf_error_to_string(e) ));
-			return mp4box_cleanup(1);
-		}
-		return mp4box_cleanup(0);
-	}
-#endif
-
-	if (udp_dest)
-		return do_write_udp();
-
-#ifndef GPAC_DISABLE_MPD
-	if (do_mpd_conv)
-		return convert_mpd();
-#endif
-
-	if (dash_duration && !nb_dash_inputs) {
-		dash_inputs = set_dash_input(dash_inputs, inName, &nb_dash_inputs);
-	}
-
-	if (do_saf && !encode) {
-		switch (get_file_type_by_ext(inName)) {
-		case GF_FILE_TYPE_BT_WRL_X3DV:
-		case GF_FILE_TYPE_XMT_X3D:
-		case GF_FILE_TYPE_SVG:
-			encode = GF_TRUE;
-			break;
-		case GF_FILE_TYPE_NOT_SUPPORTED:
-		case GF_FILE_TYPE_ISO_MEDIA:
-		case GF_FILE_TYPE_SWF:
-		case GF_FILE_TYPE_LSR_SAF:
-			break;
-		}
-	}
-
-#ifndef GPAC_DISABLE_SCENE_DUMP
-	if (dump_mode == GF_SM_DUMP_SVG) {
-		if (strstr(inName, ".srt") || strstr(inName, ".ttxt")) import_subtitle = 2;
-	}
-#endif
-
-	if (import_subtitle && !trackID)
-		return do_import_sub();
-
-
-#if !defined(GPAC_DISABLE_MEDIA_IMPORT) && !defined(GPAC_DISABLE_ISOM_WRITE)
-	if (nb_add || nb_cat) {
-		u32 res = do_add_cat(argc, argv);
-		if (res) return res;
-	}
-#endif /*!GPAC_DISABLE_MEDIA_IMPORT && !GPAC_DISABLE_ISOM_WRITE*/
-
-#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-	else if (chunk_mode) {
-		if (!inName) {
-			M4_LOG(GF_LOG_ERROR, ("chunk encoding syntax: -outctx outDump -inctx inScene auFile\n"));
-			return mp4box_cleanup(1);
-		}
-		e = EncodeFileChunk(inName, outName ? outName : inName, input_ctx, output_ctx);
-		if (e) {
-			M4_LOG(GF_LOG_ERROR, ("Error encoding chunk file %s\n", gf_error_to_string(e)));
-			return mp4box_cleanup(1);
-		}
-		goto exit;
-	}
-#endif // !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-
-	else if (encode) {
-#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-		e = do_scene_encode();
-		if (e) goto err_exit;
-#endif //!defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-	}
-
-#ifndef GPAC_DISABLE_ISOM_WRITE
-	else if (pack_file) {
-		//don't use any check for ':', the first word must be the four CC
-		char *fileName = gf_url_colon_suffix(pack_file, 0);
-		if (fileName && ((fileName - pack_file)==4)) {
-			fileName0 = 0;
-			file = package_file(fileName + 1, pack_file, pack_wgt);
-			fileName0 = ':';
-		} else {
-			file = package_file(pack_file, NULL, pack_wgt);
-			if (!file) {
-				M4_LOG(GF_LOG_ERROR, ("Failed to package file\n"));
-				return mp4box_cleanup(1);
-			}
-		}
-		if (!outName) outName = inName;
-		do_save = GF_TRUE;
-		open_edit = GF_TRUE;
-	}
-#endif //GPAC_DISABLE_ISOM_WRITE
-
-	if (dash_duration) {
-		e = do_dash();
-		if (e) return mp4box_cleanup(1);
-		goto exit;
-	}
-
-	if (split_duration || split_size || split_range_str) {
-		if (force_new==2) {
-			do_flat = 3;
-			force_new = 0;
-		}
-	} else {
-		if (do_flat)
-			open_edit = GF_TRUE;
-	}
-
-	//need to open input
-	if (!file && !do_hash) {
-		FILE *st = gf_fopen(inName, "rb");
-		Bool file_exists = 0;
-		GF_ISOOpenMode omode;
-		if (st) {
-			file_exists = 1;
-			gf_fclose(st);
-		}
-		switch (get_file_type_by_ext(inName)) {
-		case 1:
-			omode = (u8) (force_new ? GF_ISOM_WRITE_EDIT : (open_edit ? GF_ISOM_OPEN_EDIT : ( ((dump_isom>0) || print_info) ? GF_ISOM_OPEN_READ_DUMP : GF_ISOM_OPEN_READ) ) );
-
-			if (crypt) {
-				//keep fragment signaling in moov
-				omode = GF_ISOM_OPEN_READ;
-				if (use_init_seg)
-					file = gf_isom_open(use_init_seg, GF_ISOM_OPEN_READ, NULL);
-			}
-			if (!crypt && use_init_seg) {
-				file = gf_isom_open(use_init_seg, GF_ISOM_OPEN_READ_DUMP, NULL);
-				if (file) {
-					e = gf_isom_open_segment(file, inName, 0, 0, 0);
-					if (e==GF_ISOM_INCOMPLETE_FILE) {
-						M4_LOG(GF_LOG_WARNING, ("Segment %s: %s\n", inName, gf_error_to_string(e) ));
-					} else if (e) {
-						M4_LOG(GF_LOG_ERROR, ("Error opening segment %s: %s\n", inName, gf_error_to_string(e) ));
-						gf_isom_delete(file);
-						file = NULL;
-					}
-				}
-			}
-			if (!file)
-				file = gf_isom_open(inName, omode, NULL);
-
-			if (!file && (gf_isom_last_error(NULL) == GF_ISOM_INCOMPLETE_FILE) && !open_edit) {
-				u64 missing_bytes;
-				gf_isom_open_progressive(inName, 0, 0, GF_FALSE, &file, &missing_bytes);
-				if (missing_bytes)
-					M4_LOG(GF_LOG_ERROR, ("Truncated file - missing "LLD" bytes\n", missing_bytes));
-			}
-
-			if (!file) {
-				if (open_edit && nb_meta_act) {
-					file = gf_isom_open(inName, GF_ISOM_WRITE_EDIT, NULL);
-					if (!outName && file) outName = inName;
-				}
-
-				if (!file) {
-					M4_LOG(GF_LOG_ERROR, ("Error opening file %s: %s\n", inName, gf_error_to_string(gf_isom_last_error(NULL))));
-					return mp4box_cleanup(1);
-				}
-			}
-			if (freeze_box_order)
-				gf_isom_freeze_order(file);
-			break;
-		/*allowed for bt<->xmt*/
-		case 2:
-		case 3:
-		/*allowed for svg->lsr**/
-		case 4:
-		/*allowed for swf->bt, swf->xmt, swf->svg*/
-		case 5:
-			break;
-		/*used for .saf / .lsr dump*/
-		case 6:
-#ifndef GPAC_DISABLE_SCENE_DUMP
-			if ((dump_mode==GF_SM_DUMP_LASER) || (dump_mode==GF_SM_DUMP_SVG)) {
-				break;
-			}
-#endif
-
-		default:
-			if (!open_edit && file_exists && !gf_isom_probe_file(inName) && track_dump_type) {
-			}
-#ifndef GPAC_DISABLE_ISOM_WRITE
-			else if (!open_edit && file_exists /* && !gf_isom_probe_file(inName) */
-#ifndef GPAC_DISABLE_SCENE_DUMP
-			 && dump_mode == GF_SM_DUMP_NONE
-#endif //GPAC_DISABLE_SCENE_DUMP
-			 ) {
-				/*************************************************************************************************/
-#ifndef GPAC_DISABLE_MEDIA_IMPORT
-				if(dvbhdemux)
-				{
-					GF_MediaImporter import;
-					file = gf_isom_open("ttxt_convert", GF_ISOM_OPEN_WRITE, NULL);
-					memset(&import, 0, sizeof(GF_MediaImporter));
-					import.dest = file;
-					import.in_name = inName;
-					import.flags = GF_IMPORT_MPE_DEMUX;
-					e = gf_media_import(&import);
-					if (e) {
-						M4_LOG(GF_LOG_ERROR, ("Error importing %s: %s\n", inName, gf_error_to_string(e)));
-						gf_isom_delete(file);
-						gf_file_delete("ttxt_convert");
-						return mp4box_cleanup(1);
-					}
-				}
-#endif /*GPAC_DISABLE_MEDIA_IMPORT*/
-
-				if (dump_m2ts) {
-#ifndef GPAC_DISABLE_MPEG2TS
-					dump_mpeg2_ts(inName, outName, program_number);
-#endif
-				} else if (dump_timestamps) {
-#ifndef GPAC_DISABLE_MPEG2TS
-					dump_mpeg2_ts(inName, outName, program_number);
-#endif
-#ifndef GPAC_DISABLE_CORE_TOOLS
-				} else if (do_bin_xml) {
-					xml_bs_to_bin(inName, outName, dump_std);
-#endif
-				} else if (do_hash) {
-					hash_file(inName, dump_std);
-				} else if (print_info) {
-#ifndef GPAC_DISABLE_MEDIA_IMPORT
-					convert_file_info(inName, info_track_id);
-#endif
-				} else {
-					if (mux_name) {
-						e = do_remux_file();
-						if (e) goto err_exit;
-						if (file) gf_isom_delete(file);
-						goto exit;
-					} else {
-						M4_LOG(GF_LOG_ERROR, ("Input %s is not an MP4 file, operation not allowed\n", inName));
-						return mp4box_cleanup(1);
-					}
-				}
-				goto exit;
-			}
-#endif /*GPAC_DISABLE_ISOM_WRITE*/
-			else if (open_edit) {
-				file = gf_isom_open(inName, GF_ISOM_WRITE_EDIT, NULL);
-				if (!outName && file) outName = inName;
-			} else if (!file_exists) {
-				M4_LOG(GF_LOG_ERROR, ("Error %s file %s: %s\n", force_new ? "creating" : "opening", inName, gf_error_to_string(GF_URL_ERROR)));
-				return mp4box_cleanup(1);
-			} else {
-				M4_LOG(GF_LOG_ERROR, ("Cannot open %s - extension not supported\n", inName));
-				return mp4box_cleanup(1);
-			}
-		}
-	}
-
-	if (high_dynamc_range_filename) {
-		e = parse_high_dynamc_range_xml_desc(file, 0, high_dynamc_range_filename);
-		if (e) goto err_exit;
-	}
-
-	if (file && keep_utc) {
-		gf_isom_keep_utc_times(file, 1);
-	}
-
-	if ( gf_strlcpy(outfile, outName ? outName : inName, sizeof(outfile)) >= sizeof(outfile) ) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Filename too long (limit is %d)\n", GF_MAX_PATH));
-		return mp4box_cleanup(1);
-	}
-
-	char *szExt = gf_file_ext_start(outfile);
-	if (szExt) {
-		/*turn on 3GP saving*/
-		if (!stricmp(szExt, ".3gp") || !stricmp(szExt, ".3gpp") || !stricmp(szExt, ".3g2"))
-			conv_type = GF_ISOM_CONV_TYPE_3GPP;
-		else if (!stricmp(szExt, ".m4a") || !stricmp(szExt, ".m4v"))
-			conv_type = GF_ISOM_CONV_TYPE_IPOD;
-		else if (!stricmp(szExt, ".psp"))
-			conv_type = GF_ISOM_CONV_TYPE_PSP;
-		else if (!stricmp(szExt, ".mov") || !stricmp(szExt, ".qt"))
-			conv_type = GF_ISOM_CONV_TYPE_MOV;
-
-		//remove extension from outfile
-		*szExt = 0;
-	}
-
-#ifndef GPAC_DISABLE_MEDIA_EXPORT
-	if (!open_edit && track_dump_type && !gf_isom_probe_file(inName)) {
-		e = do_export_tracks_non_isobmf();
-		if (e) goto err_exit;
-		goto exit;
-	}
-	if (mux_name) {
-		e = do_remux_file();
-		if (e) goto err_exit;
-		if (file) gf_isom_delete(file);
-		goto exit;
-	}
-
-
-
-#endif /*GPAC_DISABLE_MEDIA_EXPORT*/
-
-#ifndef GPAC_DISABLE_SCENE_DUMP
-	if (dump_mode != GF_SM_DUMP_NONE) {
-		e = dump_isom_scene(inName, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_mode, do_scene_log, no_odf_conf);
-		if (e) goto err_exit;
-	}
-#endif
-
-#ifndef GPAC_DISABLE_SCENE_STATS
-	if (stat_level) dump_isom_scene_stats(inName, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, stat_level);
-#endif
-
-#ifndef GPAC_DISABLE_ISOM_HINTING
-	if (!do_hint && print_sdp) dump_isom_sdp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
-#endif
-	if (get_nb_tracks) {
-		fprintf(stdout, "%d\n", gf_isom_get_track_count(file));
-	}
-	if (print_info) {
-		if (!file) {
-			M4_LOG(GF_LOG_ERROR, ("Cannot print info on a non ISOM file (%s)\n", inName));
-		} else {
-			if (info_track_id) DumpTrackInfo(file, info_track_id, 1, (print_info==2) ? GF_TRUE : GF_FALSE, GF_FALSE);
-			else DumpMovieInfo(file, (print_info==2) ? GF_TRUE : GF_FALSE);
-		}
-	}
-#ifndef GPAC_DISABLE_ISOM_DUMP
-	if (dump_isom) {
-		e = dump_isom_xml(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, (dump_isom==2) ? GF_TRUE : GF_FALSE, merge_vtt_cues, use_init_seg ? GF_TRUE : GF_FALSE, (dump_isom==3) ? GF_TRUE : GF_FALSE);
-		if (e) goto err_exit;
-	}
-	if (dump_cr) dump_isom_ismacryp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
-	if ((dump_ttxt || dump_srt) && trackID) {
-
-		if (trackID == (u32)-1) {
-			for (j=0; j<gf_isom_get_track_count(file); j++) {
-				trackID = gf_isom_get_track_id(file, j+1);
-				dump_isom_timed_text(file, trackID, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE,
-									GF_FALSE, dump_srt ? GF_TEXTDUMPTYPE_SRT : GF_TEXTDUMPTYPE_TTXT);
-			}
-
-		}
-		else {
-			dump_isom_timed_text(file, trackID, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE,
-								GF_FALSE, dump_srt ? GF_TEXTDUMPTYPE_SRT : GF_TEXTDUMPTYPE_TTXT);
-		}
-	}
-
-#ifndef GPAC_DISABLE_ISOM_HINTING
-	if (dump_rtp) dump_isom_rtp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
-#endif
-
-#endif
-
-	if (dump_timestamps) dump_isom_timestamps(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_timestamps);
-	if (dump_nal) {
-		e = dump_isom_nal(file, dump_nal, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_nal_type);
-		if (e) goto err_exit;
-	}
-	if (dump_saps) dump_isom_saps(file, dump_saps, dump_saps_mode, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
-
-	if (do_hash) {
-		e = hash_file(inName, dump_std);
-		if (e) goto err_exit;
-	}
-#ifndef GPAC_DISABLE_CORE_TOOLS
-	if (do_bin_xml) {
-		e = xml_bs_to_bin(inName, outName, dump_std);
-		if (e) goto err_exit;
-	}
-#endif
-
-	if (dump_chunk) dump_isom_chunks(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
-	if (dump_cart) dump_isom_cover_art(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
-	if (dump_chap) dump_isom_chapters(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_chap);
-	if (dump_udta_type) dump_isom_udta(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_udta_type, dump_udta_track);
-
-	if (dump_iod) {
-		e = do_dump_iod();
-		if (e) goto err_exit;
-	}
-
-#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-	if (split_duration || split_size || split_range_str) {
-		split_isomedia_file(file, split_duration, split_size, inName, interleaving_time, split_start, adjust_split_end, outName, seg_at_rap, split_range_str, fs_dump_flags);
-
-		/*never save file when splitting is desired*/
-		open_edit = GF_FALSE;
-		do_save = GF_FALSE;
-	}
-#endif // !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
-
-#ifndef GPAC_DISABLE_MEDIA_EXPORT
-	if (track_dump_type) {
-		e = do_export_tracks();
-		if (e) goto err_exit;
-	} else if (do_saf) {
-		GF_MediaExporter mdump;
-		memset(&mdump, 0, sizeof(mdump));
-		mdump.file = file;
-		mdump.flags = GF_EXPORT_SAF;
-		mdump.out_name = outfile;
-		mdump.print_stats_graph = fs_dump_flags;
-		e = gf_media_export(&mdump);
-		if (e) goto err_exit;
-	}
-#endif
-
-	e = do_meta_act();
-	if (e) goto err_exit;
-
-	if (!open_edit && !do_save) {
-		if (file) gf_isom_delete(file);
-		goto exit;
-	}
-
-
-#ifndef GPAC_DISABLE_ISOM_WRITE
-	if (clean_groups) {
-		e = gf_isom_reset_switch_parameters(file);
-		if (e) goto err_exit;
-		do_save = GF_TRUE;
-	}
-
-
-	e = do_tsel_act();
-	if (e) goto err_exit;
-
-	if (remove_sys_tracks) {
-#ifndef GPAC_DISABLE_AV_PARSERS
-		remove_systems_tracks(file);
-#endif
-		do_save = GF_TRUE;
-		if (conv_type < GF_ISOM_CONV_TYPE_ISMA_EX) conv_type = 0;
-	}
-	if (remove_root_od) {
-		gf_isom_remove_root_od(file);
-		do_save = GF_TRUE;
-	}
-#ifndef GPAC_DISABLE_ISOM_HINTING
-	if (remove_hint) {
-		for (i=0; i<gf_isom_get_track_count(file); i++) {
-			if (gf_isom_get_media_type(file, i+1) == GF_ISOM_MEDIA_HINT) {
-				M4_LOG(GF_LOG_INFO, ("Removing hint track ID %d\n", gf_isom_get_track_id(file, i+1)));
-				gf_isom_remove_track(file, i+1);
-				i--;
-			}
-		}
-		gf_isom_sdp_clean(file);
-		do_save = GF_TRUE;
-	}
-#endif // GPAC_DISABLE_ISOM_HINTING
-
-	if (timescale && (timescale != gf_isom_get_timescale(file))) {
-		gf_isom_set_timescale(file, timescale);
-		do_save = GF_TRUE;
-	}
-
-	if (!encode) {
-		if (!file) {
-			M4_LOG(GF_LOG_INFO, ("Nothing to do - exiting\n"));
-			goto exit;
-		}
-		if (outName) {
-			strcpy(outfile, outName);
-		} else {
-			const char *tmp_dir = gf_opts_get_key("core", "tmp");
-			char *rel_name = strrchr(inName, GF_PATH_SEPARATOR);
-			if (!rel_name) rel_name = strrchr(inName, '/');
-
-			strcpy(outfile, "");
-			if (tmp_dir) {
-				strcpy(outfile, tmp_dir);
-				if (!strchr("\\/", tmp_dirstrlen(tmp_dir)-1)) strcat(outfile, "/");
-			}
-			if (!pack_file) strcat(outfile, "out_");
-			strcat(outfile, rel_name ? rel_name + 1 : inName);
-
-			if (pack_file) {
-				strcpy(outfile, rel_name ? rel_name + 1 : inName);
-				rel_name = strrchr(outfile, '.');
-				if (rel_name) rel_name0 = 0;
-				strcat(outfile, ".m21");
-			}
-		}
-#ifndef GPAC_DISABLE_MEDIA_IMPORT
-		if ((conv_type == GF_ISOM_CONV_TYPE_ISMA) || (conv_type == GF_ISOM_CONV_TYPE_ISMA_EX)) {
-			M4_LOG(GF_LOG_INFO, ("Converting to ISMA Audio-Video MP4 file\n"));
-			/*keep ESIDs when doing ISMACryp*/
-			e = gf_media_make_isma(file, crypt ? 1 : 0, GF_FALSE, (conv_type==GF_ISOM_CONV_TYPE_ISMA_EX) ? 1 : 0);
-			if (e) goto err_exit;
-			do_save = GF_TRUE;
-		}
-		if (conv_type == GF_ISOM_CONV_TYPE_3GPP) {
-			M4_LOG(GF_LOG_INFO, ("Converting to 3GP file\n"));
-			e = gf_media_make_3gpp(file);
-			if (e) goto err_exit;
-			do_save = GF_TRUE;
-		}
-		if (conv_type == GF_ISOM_CONV_TYPE_PSP) {
-			M4_LOG(GF_LOG_INFO, ("Converting to PSP file\n"));
-			e = gf_media_make_psp(file);
-			if (e) goto err_exit;
-			do_save = GF_TRUE;
-		}
-		if (conv_type == GF_ISOM_CONV_TYPE_MOV) {
-			e = gf_media_check_qt_prores(file);
-			if (e) goto err_exit;
-			do_save = GF_TRUE;
-			if (interleaving_time) interleaving_time = 0.5;
-		}
-#endif /*GPAC_DISABLE_MEDIA_IMPORT*/
-		if (conv_type == GF_ISOM_CONV_TYPE_IPOD) {
-			do_ipod_conv();
-		}
-
-	} else if (outName) {
-		strcpy(outfile, outName);
-	}
-
-	e = do_track_act();
-	if (e) goto err_exit;
-
-	if (itunes_tags) {
-		e = do_itunes_tag();
-		if (e) goto err_exit;
-	}
-
-	if (cprt) {
-		e = gf_isom_set_copyright(file, "und", cprt);
-		do_save = GF_TRUE;
-		if (e) goto err_exit;
-	}
-	if (chap_file || chap_file_qt) {
-#ifndef GPAC_DISABLE_MEDIA_IMPORT
-		Bool chap_qt = GF_FALSE;
-		if (chap_file_qt) {
-			chap_file = chap_file_qt;
-			chap_qt = GF_TRUE;
-		}
-		e = gf_media_import_chapters(file, chap_file, import_fps, chap_qt);
-		do_save = GF_TRUE;
-#else
-		M4_LOG(GF_LOG_WARNING, ("Warning: GPAC compiled without Media Import, chapters can't be imported\n"));
-		e = GF_NOT_SUPPORTED;
-#endif
-		if (e) goto err_exit;
-	}
-
-	if (major_brand) {
-		gf_isom_set_brand_info(file, major_brand, minor_version);
-		do_save = GF_TRUE;
-	}
-	for (i=0; i<nb_alt_brand_add; i++) {
-		gf_isom_modify_alternate_brand(file, brand_addi, GF_TRUE);
-		do_save = GF_TRUE;
-	}
-	for (i=0; i<nb_alt_brand_rem; i++) {
-		gf_isom_modify_alternate_brand(file, brand_remi, GF_FALSE);
-		do_save = GF_TRUE;
-	}
-	if (box_patch_filename) {
-		e = gf_isom_apply_box_patch(file, box_patch_trackID, box_patch_filename, GF_FALSE);
-		if (e) {
-			M4_LOG(GF_LOG_ERROR, ("Failed to apply box patch %s: %s\n", box_patch_filename, gf_error_to_string(e) ));
-			goto err_exit;
-		}
-		do_save = GF_TRUE;
-	}
-
-#ifndef GPAC_DISABLE_CRYPTO
-	if (crypt) {
-		if (!drm_file && (crypt==1) ) {
-			M4_LOG(GF_LOG_ERROR, ("Missing DRM file location - usage '-%s drm_file input_file\n", (crypt==1) ? "crypt" : "decrypt"));
-			e = GF_BAD_PARAM;
-			goto err_exit;
-		}
-		if (crypt == 1) {
-			if (use_init_seg) {
-				e = gf_crypt_fragment(file, drm_file, outfile, inName, fs_dump_flags);
-			} else {
-				e = gf_crypt_file(file, drm_file, outfile, interleaving_time, fs_dump_flags);
-			}
-		} else if (crypt ==2) {
-			if (use_init_seg) {
-				e = gf_decrypt_fragment(file, drm_file, outfile, inName, fs_dump_flags);
-			} else {
-				e = gf_decrypt_file(file, drm_file, outfile, interleaving_time, fs_dump_flags);
-			}
-		}
-		if (e) goto err_exit;
-		do_save = outName ? GF_FALSE : GF_TRUE;
-
-		if (!do_frag && !do_hint && !full_interleave && !force_co64) {
-			char szNameGF_MAX_PATH;
-			strcpy(szName, gf_isom_get_filename(file) );
-			gf_isom_delete(file);
-			file = NULL;
-			if (!outName) {
-				e = gf_file_move(outfile, szName);
-				if (e) goto err_exit;
-			}
-			goto exit;
-		}
-	}
-#endif /*GPAC_DISABLE_CRYPTO*/
-
-#ifndef GPAC_DISABLE_ISOM_FRAGMENTS
-	if (do_frag) {
-		if (!interleaving_time) interleaving_time = DEFAULT_INTERLEAVING_IN_SEC;
-		if (do_hint) M4_LOG(GF_LOG_WARNING, ("Warning: cannot hint and fragment - ignoring hint\n"));
-		M4_LOG(GF_LOG_INFO, ("Fragmenting file (%.3f seconds fragments)\n", interleaving_time));
-		e = gf_media_fragment_file(file, outfile, interleaving_time, use_mfra);
-		if (e) M4_LOG(GF_LOG_ERROR, ("Error while fragmenting file: %s\n", gf_error_to_string(e)));
-		if (!e && !outName) {
-			if (gf_file_exists(inName) && gf_file_delete(inName)) {
-				M4_LOG(GF_LOG_INFO, ("Error removing file %s\n", inName));
-			}
-			else if (gf_file_move(outfile, inName)) {
-				M4_LOG(GF_LOG_INFO, ("Error renaming file %s to %s\n", outfile, inName));
-			}
-		}
-		if (e) goto err_exit;
-		gf_isom_delete(file);
-		goto exit;
-	}
-#endif
-
-#ifndef GPAC_DISABLE_ISOM_HINTING
-	if (do_hint) {
-		if (force_ocr) SetupClockReferences(file);
-		MTUSize -= 12;
-		e = HintFile(file, MTUSize, max_ptime, rtp_rate, hint_flags, HintCopy, hint_interleave, regular_iod, single_group, hint_no_offset);
-		if (e) goto err_exit;
-		do_save = GF_TRUE;
-		if (print_sdp) dump_isom_sdp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
-	}
-#endif
-
-#if !defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)
-	set_sdp_ext();
-#endif /*!defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)*/
-
-	if (force_co64)
-		gf_isom_force_64bit_chunk_offset(file, GF_TRUE);
-
-	if (compress_moov)
-		gf_isom_enable_compression(file, GF_ISOM_COMP_ALL, (compress_moov==2) ? GF_ISOM_COMP_WRAP_FTYPE : 0);
-
-	if (no_inplace)
-		gf_isom_disable_inplace_rewrite(file);
-
-	if (moov_pading)
-		gf_isom_set_inplace_padding(file, moov_pading);
-
-	if (outName) {
-		gf_isom_set_final_name(file, outfile);
-	} else if (!encode && !force_new && !gf_isom_is_inplace_rewrite(file)) {
-		gf_isom_set_final_name(file, outfile);
-	}
-
-	Bool is_inplace = gf_isom_is_inplace_rewrite(file);
-
-
-	/*full interleave (sample-based) if just hinted*/
-	if (full_interleave) {
-		e = gf_isom_set_storage_mode(file, GF_ISOM_STORE_TIGHT);
-	} else if (do_flat) {
-		e = gf_isom_set_storage_mode(file, (do_flat==1) ? GF_ISOM_STORE_FLAT : GF_ISOM_STORE_STREAMABLE);
-		do_save = GF_TRUE;
-	}
-	//do not set storage mode unless inplace rewrite is disabled , either by user or due to operations on file
-	else if (!is_inplace) {
-		e = gf_isom_make_interleave(file, interleaving_time);
-		if (!e && old_interleave) e = gf_isom_set_storage_mode(file, GF_ISOM_STORE_INTERLEAVED);
-	}
-
-	if (e) goto err_exit;
-
-
-	if (do_save) {
-
-		if (!gf_sys_is_quiet()) {
-			if (outName) {
-			} else if (encode || pack_file) {
-				M4_LOG(GF_LOG_INFO, ("Saving to %s: ", gf_isom_get_filename(file) ));
-			} else {
-				M4_LOG(GF_LOG_INFO, ("Saving %s: ", inName));
-			}
-			if (is_inplace) {
-				M4_LOG(GF_LOG_INFO, ("In-place rewrite\n"));
-			} else if (do_hint && full_interleave) {
-				M4_LOG(GF_LOG_INFO, ("Hinted file - Full Interleaving\n"));
-			} else if (full_interleave) {
-				M4_LOG(GF_LOG_INFO, ("Full Interleaving\n"));
-			} else if ((force_new==2) && interleaving_time) {
-				M4_LOG(GF_LOG_INFO, ("Fast-start interleaved storage\n"));
-			} else if (do_flat || !interleaving_time) {
-				M4_LOG(GF_LOG_INFO, ("Flat storage\n"));
-			} else {
-				M4_LOG(GF_LOG_INFO, ("%.3f secs Interleaving%s\n", interleaving_time, old_interleave ? " - no drift control" : ""));
-			}
-		}
-
-		e = gf_isom_close(file);
-		file = NULL;
-
-		if (!e && !outName && !encode && !force_new && !pack_file && !is_inplace) {
-			if (gf_file_exists(inName)) {
-				e = gf_file_delete(inName);
-				if (e) {
-					M4_LOG(GF_LOG_ERROR, ("Error removing file %s\n", inName));
-				}
-			}
-
-			e = gf_file_move(outfile, inName);
-			if (e) {
-				M4_LOG(GF_LOG_ERROR, ("Error renaming file %s to %s\n", outfile, inName));
-			}
-		}
-	} else {
-		gf_isom_delete(file);
-	}
-
-	if (e) {
-		M4_LOG(GF_LOG_ERROR, ("Error: %s\n", gf_error_to_string(e)));
-		goto err_exit;
-	}
-	goto exit;
-
-#else
-	/*close libgpac*/
-	gf_isom_delete(file);
-	M4_LOG(GF_LOG_ERROR, ("Error: Read-only version of MP4Box.\n"));
-	return mp4box_cleanup(1);
-#endif //GPAC_DISABLE_ISOM_WRITE
-
-
-err_exit:
-	/*close libgpac*/
-	if (file) gf_isom_delete(file);
-	M4_LOG(GF_LOG_ERROR, ("\n\tError: %s\n", gf_error_to_string(e)));
-	return mp4box_cleanup(1);
-
-exit:
-	mp4box_cleanup(0);
-
-#ifdef GPAC_MEMORY_TRACKING
-	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
-		gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
-		gf_memory_print();
-		return 2;
-	}
-#endif
-	return 0;
-}
-
-
-GF_MAIN_FUNC(mp4boxMain)
-
-
-#endif /*GPAC_DISABLE_ISOM*/

gpac-2.0.0.tar.gz/applications/mp4box_android Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/.gitignore Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/build.gradle Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/java Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/java/com Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/java/com/gpac Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/java/com/gpac/mp4box Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/java/com/gpac/mp4box/mp4box.java Deleted

@@ -1,90 +0,0 @@
-package com.gpac.mp4box;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-import com.gpac.mp4box.R;
-
-import android.app.Activity;
-import android.os.Bundle;
-import android.widget.Button;
-import android.widget.EditText;
-import android.util.Log;
-import android.view.View;
-
-
-
-public class mp4box extends Activity {
-	private mp4terminal myTerminal;
-
- /** Called when the activity is first created. */
- @Override
-
-
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.main);
- myTerminal = new mp4terminal();
- errors = loadAllLibraries();
- System.out.println( "hello world java" );
- final Button button = (Button) findViewById(R.id.OkButton);
-
- button.setOnClickListener(new View.OnClickListener() {
- public void onClick(View v) {
- 	EditText oCommandLine = (EditText) findViewById(R.id.CommandLineEdit );
- 	CharSequence sCommandLine = oCommandLine.getText();
- 	myTerminal.run( sCommandLine.toString() );
- 	//showKeyboard( true );
- }
- });
-
- }
-
-
- private final static String LOG_LIB = "com.gpac.mp4box.libloader";
-
- private static Map<String, Throwable> errors = null;
-
- synchronized static Map<String, Throwable> loadAllLibraries()
- {
- 	if( errors != null)
- 		return errors;
- StringBuilder sb = new StringBuilder();
- // final String toLoad = { "GLESv1_CM", "dl", "log",//$NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-1$
- // "jpeg", "javaenv", //$NON-NLS-1$ //$NON-NLS-2$
- // "mad", "editline", "ft2", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
- // "js_osmo", "openjpeg", "png", "z", //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ //$NON-NLS-4$
- // "ffmpeg", "faad", "gpac", //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
- // "stdc++", "mp4box" }; // //$NON-NLS-1$ //$NON-NLS-2$
- final String toLoad = {"avutil", "swresample", "swscale", "avcodec", "avformat", "avfilter", "avdevice",
- "editline", "faad", "ft2",
- "jpegdroid", "js_osmo", "mad", "openjpeg",
- "png", "stlport_shared",
- "z", "gpac", "mp4box"};
- HashMap<String, Throwable> exceptions = new HashMap<String, Throwable>();
- for (String s : toLoad) {
- try {
- String msg = "Loading library " + s + "...";
- sb.append(msg);
- Log.i(LOG_LIB, msg);
- System.loadLibrary(s);
- } catch (UnsatisfiedLinkError e) {
- sb.append("Failed to load " + s + ", error=" + e.getLocalizedMessage() + " :: "
- + e.getClass().getSimpleName() + "\n"); //$NON-NLS-1$
- exceptions.put(s, e);
- Log.e(LOG_LIB, "Failed to load library : " + s + " due to link error " + e.getLocalizedMessage(), e);
- } catch (SecurityException e) {
- exceptions.put(s, e);
- Log.e(LOG_LIB, "Failed to load library : " + s + " due to security error " + e.getLocalizedMessage(), e);
- } catch (Throwable e) {
- exceptions.put(s, e);
- Log.e(LOG_LIB, "Failed to load library : " + s + " due to Runtime error " + e.getLocalizedMessage(), e);
- }
- }
-
- errors = Collections.unmodifiableMap(exceptions);
- return errors;
-}
-
-}
\ No newline at end of file

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/jni Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/jni/wrapper.c Deleted

@@ -1,102 +0,0 @@
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <android/log.h>
-#include <jni.h>
-#include "stdlib.h"
-#include "stdio.h"
-#include "string.h"
-
-
-#define jniTAG "WRAPPER_JNI"
-
-#define jniLOGV(X) __android_log_print(ANDROID_LOG_VERBOSE, jniTAG, X)
-#define jniLOGI(X) __android_log_print(ANDROID_LOG_INFO, jniTAG, X)
-#define jniLOGE(X) __android_log_print(ANDROID_LOG_ERROR, jniTAG, X)
-
-/*#define CAST_HANDLE(wr) jclass c = env->GetObjectClass(obj);\
- if (!c) return;\
- jfieldID fid = env->GetFieldID(c, "handle", "J");\
- if (!fid){\
- __android_log_print(ANDROID_LOG_ERROR, jniTAG, "No Field ID, ERROR");\
- return;\
- }\
- jlong h = env->GetLongField(obj, fid);
- //CNativeWrapper* wr = (CNativeWrapper*) h;*/
-
-char ** ConvertCommandLine( const char* sCommand, int* iNbArg );
-int mp4boxMain(int argc, char **argv);
-
-JNIEXPORT void JNICALL Java_com_gpac_mp4box_mp4terminal_run(JNIEnv * env, jobject obj, jstring sCommand)
-{
-	//CAST_HANDLE(wr);
-	jniLOGV("mp4terminal::start");
-	/*if (!wr)
-	{
-		jniLOGV("mp4terminal::end : aborted");
-	 return;
-	}*/
-	jboolean isCopy;
-	const char * sOriginalCommand = (*env)->GetStringUTFChars(env, sCommand, &isCopy);
-
-	jniLOGV("mp4terminal::command get back ok");
-	//jniLOGV(sOriginalCommand);
-
-	int i = 0;
-	char** sConvertedCommandLine;
-	sConvertedCommandLine = ConvertCommandLine( sOriginalCommand, &i );
-
-	jniLOGV("Convert command line done");
-	FILE* ferr = freopen( "/mnt/sdcard/stderrout.txt", "w", stderr );
-
-	FILE* fout = freopen( "/mnt/sdcard/stdout.txt", "w", stdout );
-
-	mp4boxMain(i, sConvertedCommandLine);
-
-	(*env)->ReleaseStringUTFChars(env, sCommand, sOriginalCommand);
-	jniLOGV("mp4terminal::end");
-	fclose(ferr);
-	fclose(fout);
-}
-
-char ** ConvertCommandLine( const char* sCommand, int* iNbArg )
-{
-	int iLength = strlen( sCommand );
-	int iArgNumber = 1;
-	int i = 0;
-	char** pReturn;
-	int iPreviousPos = 0;
-	int k = 1;//begin at character position 1 as the 0 position will be held by the process name , i.e. mp4box
-	int l = 0;
-
-	for ( i = 0; i < iLength ; i++ )
-	{
-		if( sCommandi == ' ' )
-		{
-			iArgNumber++;
-		}
-	}
-	iArgNumber++; // last argument will not be detected as it is not followed by a space character
-	pReturn = (char**)malloc(sizeof(char*)*iArgNumber);
-	pReturn0 = (char*)malloc(sizeof( char) * ( 7 ));
-	strcpy( pReturn0, "MP4Box" );//just a place holder , will never be read.
-	pReturn06 = '\0';
-
-	for ( l = 0; l <= iLength ; l++ )
-	{
-		if( sCommandl == ' ' || l == ( iLength ) )
-		{
-			pReturnk = (char*)malloc(sizeof( char) * ( l - iPreviousPos + 1));
-			strncpy( pReturnk, sCommand + iPreviousPos, l - iPreviousPos );
-			pReturnkl-iPreviousPos = '\0';
-			iPreviousPos = l + 1;
-			k++;
-		}
-	}
-	*iNbArg = iArgNumber;
-	return pReturn;
-}
-#ifdef __cplusplus
-}
-#endif

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/res Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/res/drawable-hdpi Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/res/drawable-ldpi Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/res/drawable-mdpi Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/res/layout Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/res/layout/main.xml Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/app/src/main/res/values Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/build.gradle Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/gradle Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/gradle/wrapper Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/gradle/wrapper/gradle-wrapper.jar Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/gradle/wrapper/gradle-wrapper.properties Deleted

gpac-2.0.0.tar.gz/applications/mp4box_android/gradlew Deleted

@@ -1,160 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while  -h "$PRG"  ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> $.*$$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if  -n "$JAVA_HOME"  ; then
-    if  -x "$JAVA_HOME/jre/sh/java"  ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if  ! -x "$JAVACMD"  ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if  "$cygwin" = "false" -a "$darwin" = "false"  ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if  $? -eq 0  ; then
-        if  "$MAX_FD" = "maximum" -o "$MAX_FD" = "max"  ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if  $? -ne 0  ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if  "$GRADLE_CYGPATTERN" != ""  ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if  $CHECK -ne 0  &&  $CHECK2 -eq 0  ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS${#JVM_OPTS*}="-Dorg.gradle.appname=$APP_BASE_NAME"
-
-exec "$JAVACMD" "${JVM_OPTS@}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gpac-2.0.0.tar.gz/applications/mp4box_android/gradlew.bat Deleted

@@ -1,90 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windowz variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval2+2" == "4" goto 4NT_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

gpac-2.0.0.tar.gz/applications/mp4box_android/settings.gradle Deleted

gpac-2.0.0.tar.gz/applications/mp4client Deleted

gpac-2.0.0.tar.gz/applications/mp4client/carbon_events.c Deleted

@@ -1,109 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2005-2012
- *					All rights reserved
- *
- * This file is part of GPAC / command-line client
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#if defined(__DARWIN__) || defined(__APPLE__)
-#include <Carbon/Carbon.h>
-#endif
-
-
-int gf_sys_set_args(int argc, const char **argv);
-void send_open_url(const char *url);
-
-void RunApplicationEventLoop(void);
-void QuitApplicationEventLoop(void);
-
-char *my_argv2;
-
-static int main_evt_loop_run = 1;
-
-static AEEventHandlerUPP	open_app_UPP, open_doc_UPP;
-
-static pascal OSErr ae_open_app (const AppleEvent *ae_event, AppleEvent *ae_reply, long ae_ref_count)
-{
-	if (main_evt_loop_run) {
-		QuitApplicationEventLoop();
-		main_evt_loop_run = 0;
-	}
-	return (noErr);
-}
-
-static pascal OSErr ae_open_doc (const AppleEvent *ae_event, AppleEvent *ae_reply, long ae_ref_count)
-{
-	OSErr err;
-	FSRef	ref;
-	AEDescList	docList;
-	long	count;
-
-	err = AEGetParamDesc(ae_event, keyDirectObject, typeAEList, &docList);
-	if (err)
-		return (noErr);
-
-	err = AECountItems(&docList, &count);
-	if (err == noErr) {
-		err = AEGetNthPtr(&docList, 1, typeFSRef, NULL, NULL, &ref, sizeof(FSRef), NULL);
-		if (err == noErr) {
-			char path4096;
-			FSRefMakePath(&ref, (UInt8 *) path, 4096);
-			if (main_evt_loop_run) {
-				my_argv1 = strdup(path);
-				gf_sys_set_args(2, (const char **) my_argv);
-			} else {
-				send_open_url(path);
-			}
-		}
-	}
-	AEDisposeDesc(&docList);
-
-	if (main_evt_loop_run) {
-		QuitApplicationEventLoop();
-		main_evt_loop_run = 0;
-	}
-	return (noErr);
-}
-
-void carbon_init ()
-{
-	my_argv0 = "GPAC";
-	my_argv1 = NULL;
-
-	open_app_UPP = NewAEEventHandlerUPP(ae_open_app);
-	AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, open_app_UPP, 0L, false);
-	open_doc_UPP = NewAEEventHandlerUPP(ae_open_doc);
-	AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, open_doc_UPP, 0L, false);
-
-	main_evt_loop_run = 1;
-	RunApplicationEventLoop();
-}
-
-void carbon_uninit()
-{
-
-	DisposeAEEventHandlerUPP(open_app_UPP);
-	DisposeAEEventHandlerUPP(open_doc_UPP);
-
-	if (my_argv1) free(my_argv1);
-}
-
-

gpac-2.0.0.tar.gz/applications/mp4client/main.c Deleted

@@ -1,2811 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2005-2022
- *					All rights reserved
- *
- * This file is part of GPAC / command-line client
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-/*includes both terminal and od browser*/
-#include <gpac/terminal.h>
-#include <gpac/term_info.h>
-#include <gpac/constants.h>
-#include <gpac/events.h>
-#include <gpac/media_tools.h>
-#include <gpac/options.h>
-#include <gpac/main.h>
-
-#include <gpac/avparse.h>
-#include <gpac/network.h>
-#include <gpac/utf.h>
-
-/*ISO 639 languages*/
-#include <gpac/iso639.h>
-
-
-#ifndef WIN32
-#include <dlfcn.h>
-#include <pwd.h>
-#include <unistd.h>
-#if defined(__DARWIN__) || defined(__APPLE__)
-#include <sys/types.h>
-#include <sys/stat.h>
-
-void carbon_init();
-void carbon_uninit();
-
-#endif
-
-#else
-#include <windows.h> /*for GetModuleFileName*/
-#endif	//WIN32
-
-/*local prototypes*/
-static void PrintWorldInfo(GF_Terminal *term);
-static void ViewOD(GF_Terminal *term, u32 OD_ID, u32 number, const char *URL);
-static void PrintODList(GF_Terminal *term, GF_ObjectManager *root_odm, u32 num, u32 indent, char *root_name);
-
-static void ViewODs(GF_Terminal *term, Bool show_timing);
-static void MakeScreenshot(Bool for_coverage);
-static void PrintAVInfo(Bool final);
-
-static u32 gui_mode = 0;
-static int ret_val = 0;
-
-static Bool restart = GF_FALSE;
-static Bool reload = GF_FALSE;
-Bool do_coverage = GF_FALSE;
-
-Bool no_prog = 0;
-
-static FILE *helpout = NULL;
-u32 help_flags = 0;
-
-#if defined(__DARWIN__) || defined(__APPLE__)
-#define VK_MOD GF_KEY_MOD_ALT
-#else
-#define VK_MOD GF_KEY_MOD_CTRL
-#endif
-
-static Bool no_audio = GF_FALSE;
-static u32 bench_mode = 0;
-static u32 bench_mode_start = 0;
-static u32 bench_buffer = 0;
-static Bool eos_seen = GF_FALSE;
-static Bool addon_visible = GF_TRUE;
-Bool is_connected = GF_FALSE;
-Bool startup_file = GF_FALSE;
-GF_User user;
-GF_Terminal *term;
-u64 Duration;
-GF_Err last_error = GF_OK;
-static Bool enable_add_ons = GF_TRUE;
-static Fixed playback_speed = FIX_ONE;
-
-static s32 request_next_playlist_item = GF_FALSE;
-FILE *playlist = NULL;
-static Bool readonly_playlist = GF_FALSE;
-
-static u32 display_rti = 0;
-static Bool Run;
-static Bool CanSeek = GF_FALSE;
-static char the_urlGF_MAX_PATH;
-static char pl_pathGF_MAX_PATH;
-static Bool no_mime_check = GF_TRUE;
-static u64 log_rti_time_start = 0;
-static Bool loop_at_end = GF_FALSE;
-static u32 forced_width=0;
-static u32 forced_height=0;
-
-/*windowless options*/
-u32 align_mode = 0;
-u32 init_w = 0;
-u32 init_h = 0;
-u32 last_x, last_y;
-Bool right_down = GF_FALSE;
-
-Float scale = 1;
-
-static Bool shell_visible = GF_TRUE;
-#if defined(WIN32) && !defined(_WIN32_WCE)
-
-static HWND console_hwnd = NULL;
-static Bool owns_wnd = GF_FALSE;
-#include <tlhelp32.h>
-#include <Psapi.h>
-static DWORD getParentPID(DWORD pid)
-{
-	DWORD ppid = 0;
-	HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-	if (h) {
-		PROCESSENTRY32 pe = { 0 };
-		pe.dwSize = sizeof(PROCESSENTRY32);
-		if (Process32First(h, &pe)) {
-			do {
-				if (pe.th32ProcessID == pid) {
-					ppid = pe.th32ParentProcessID;
-					break;
-				}
-			} while (Process32Next(h, &pe));
-		}
-		CloseHandle(h);
-	}
-	return (ppid);
-}
-
-static void getProcessName(DWORD pid, PUCHAR fname, DWORD sz)
-{
-	HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
-	if (h) {
-		GetModuleFileNameEx(h, NULL, fname, sz);
-		CloseHandle(h);
-	}
-}
-static void w32_hide_shell(u32 cmd_type)
-{
-	typedef HWND (WINAPI *GetConsoleWindowT)(void);
-	HMODULE hk32 = GetModuleHandle("kernel32.dll");
-	if (!console_hwnd) {
-		char parentNameGF_MAX_PATH;
-		DWORD dwProcessId = 0;
-		DWORD dwParentProcessId = 0;
-		DWORD dwParentParentProcessId = 0;
-		GetConsoleWindowT GetConsoleWindow = (GetConsoleWindowT)GetProcAddress(hk32, "GetConsoleWindow");
-		console_hwnd = GetConsoleWindow();
-		dwProcessId = GetCurrentProcessId();
-		dwParentProcessId = getParentPID(dwProcessId);
-		if (dwParentProcessId)
-				dwParentParentProcessId = getParentPID(dwParentProcessId);
-		//get parent process name, check for explorer
-		parentName0 = 0;
-		getProcessName(dwParentProcessId, parentName, GF_MAX_PATH);
-		if (strstr(parentName, "explorer")) {
-			owns_wnd = GF_TRUE;
-		}
-		//get parent parent process name, check for devenv (or any other ide name ...)
-		else if (dwParentParentProcessId) {
-			owns_wnd = GF_FALSE;
-			parentName0 = 0;
-			getProcessName(dwParentParentProcessId, parentName, GF_MAX_PATH);
-			if (strstr(parentName, "devenv")) {
-				owns_wnd = GF_TRUE;
-			}
-		} else {
-			owns_wnd = GF_FALSE;
-		}
-	}
-	if (!owns_wnd || !console_hwnd) return;
-
-	if (cmd_type==0) {
-		ShowWindow(console_hwnd, SW_SHOW);
-		shell_visible = GF_TRUE;
-	}
-	else if (cmd_type==1) {
-		ShowWindow(console_hwnd, SW_HIDE);
-		shell_visible = GF_FALSE;
-	}
-	else if (cmd_type == 2) {
-		PostMessage(GetConsoleWindow(), WM_CLOSE, 0, 0);
-	}
-}
-
-#define hide_shell w32_hide_shell
-#else
-
-#define hide_shell(_var)
-
-#endif
-
-
-void send_open_url(const char *url)
-{
-	GF_Event evt;
-	memset(&evt, 0, sizeof(GF_Event));
-	evt.type = GF_EVENT_NAVIGATE;
-	evt.navigate.to_url = url;
-	gf_term_send_event(term, &evt);
-}
-
-GF_GPACArg mp4client_args =
-{
-#ifdef GPAC_MEMORY_TRACKING
- 	GF_DEF_ARG("mem-track", NULL, "enable memory tracker", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
- 	GF_DEF_ARG("mem-track-stack", NULL, "enable memory tracker with stack dumping", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-#endif
-	 GF_DEF_ARG("rti", NULL, "log run-time info (FPS, CPU, Mem usage) to given file", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
-	 GF_DEF_ARG("rtix", NULL, "same as -rti but driven by GPAC logs", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
-	 GF_DEF_ARG("size", NULL, "specify visual size WxH. If not set, scene size or video size is used", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
-	 GF_DEF_ARG("rti-refresh", NULL, "set refresh time in ms between two runt-time counters queries (default is 200)", NULL, NULL, GF_ARG_INT, 0),
-
- 	GF_DEF_ARG("no-thread", NULL, "disable thread usage (except for depending on driver audio)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
- 	GF_DEF_ARG("no-audio", NULL, "disable audio", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
-
-#ifdef GPAC_CONFIG_WIN32
- 	GF_DEF_ARG("no-wnd", NULL, "use windowless mode (Win32 only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERIMENTAL),
- 	GF_DEF_ARG("no-back", NULL, "use transparent background for output window when no background is specified (Win32 only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERIMENTAL),
- 	GF_DEF_ARG("align", NULL, "specify v and h alignment for windowless mode\n"
- 	"- tl: top/left\n"
- 	"- tm: top/horizontal middle\n"
- 	"- tr: top/right\n"
- 	"- ml: vertical middle/left\n"
- 	"- mm: vertical middle/horizontal middle\n"
- 	"- mr: vertical middle/right\n"
- 	"- bl: bottom/left\n"
- 	"- bm: bottom/horizontal middle\n"
- 	"- br: bottom/right", "tl", "tl|tm|tr|ml|mm|mr|bl|bm|br", GF_ARG_INT, GF_ARG_HINT_EXPERIMENTAL),
-#endif // GPAC_CONFIG_WIN32
-
- 	GF_DEF_ARG("pause", NULL, "pause at first frame", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
-	GF_DEF_ARG("play-from", NULL, "start playback from given time in seconds in media", NULL, NULL, GF_ARG_DOUBLE, 0),
-	GF_DEF_ARG("speed", NULL, "start playback wit given speed", NULL, NULL, GF_ARG_DOUBLE, 0),
-	GF_DEF_ARG("loop", NULL, "loop playback", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("fs", NULL, "start in fullscreen mode", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("exit", NULL, "exit when presentation is over", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
-	GF_DEF_ARG("run-for", NULL, "run for indicated time in seconds and exits", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
-	GF_DEF_ARG("service", NULL, "auto-tune to given service ID in a multiplex", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_ADVANCED),
-	GF_DEF_ARG("no-save", NULL, "do not save configuration file on exit", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("no-addon", NULL, "disable automatic loading of media addons declared in source URL", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("gui", NULL, "start in GUI mode. The GUI is indicated in the configuration(core_config) file __GeneralStartupFile__", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("p", NULL, "use indicated profile for the global GPAC config. If not found, config file is created. If a file path is indicated, this will load profile from that file. Otherwise, this will create a directory of the specified name and store new config there. Reserved name `0` means a new profile, not stored to disk. Works using -p=NAME or -p NAME", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
-	GF_DEF_ARG("stats", NULL, "dump filter session stats after playback", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("graph", NULL, "dump filter session graph after playback", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
-	GF_DEF_ARG("nk", NULL, "disable keyboard interaction", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
-	GF_DEF_ARG("h", "help", "show this help. Use `-hx` to show expert help", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("hc", NULL, "show libgpac core options", NULL, NULL, GF_ARG_BOOL, 0),
-	GF_DEF_ARG("hr", NULL, "show runtime options when keybard interaction is enabled", NULL, NULL, GF_ARG_BOOL, 0),
-	{0}
-};
-
-
-void PrintUsage(Bool show_all)
-{
-	u32 i=0;
-
-	if (help_flags & GF_PRINTARG_MAN) {
-		fprintf(helpout, ".SH \"DESCRIPTION\"\n.LP\nMP4Client is GPAC command-line media player. It supports all GPAC playback features (2D and 3D support, local playback, RTP streaming, HTTP faststart, many audio and video codecs ...).\n.br\nSpecific URLs shortcuts are available, see gpac -h compositor\n.\n.\n.SH OPTIONS\n");
-	} else {
-		gf_sys_format_help(helpout, help_flags, "Usage: MP4Client options filename\n"
-			"# General\n"
-			"The player accepts any URL supported by GPAC.\n"
-			"Specific URLs shortcuts are available, see GPAC Compositor (gpac -h compositor)(compositor)\n"
-			"\n"
-			"Warning: MP4Client is being deprecated, use `gpac -play URL`, `gpac -gui URL` or `gpac -mp4c URL`.\n"
-			"\n"
-			"Version: %s\n"
-			"%s\n"
-			"For more info on GPAC configuration, use `gpac ` -h(GPAC) `bin` \n \n"
-			"# Options \n \n",
-			(help_flags == GF_PRINTARG_MD) ? GPAC_VERSION : gf_gpac_version(),
-			gf_gpac_copyright_cite()
-		);
-	}
-
-	while (mp4client_argsi.name) {
-		GF_GPACArg *arg = &mp4client_argsi;
-		i++;
-		if (!show_all && (arg->flags & (GF_ARG_HINT_EXPERIMENTAL|GF_ARG_HINT_EXPERT) ))
-			continue;
-		gf_sys_print_arg(helpout, help_flags, arg, "mp4client");
-	}
-}
-
-typedef enum
-{
-	MP4C_QUIT = 0,
-	MP4C_KILL,
-	MP4C_RELOAD,
-	MP4C_OPEN,
-	MP4C_OPEN_PL,
-	MP4C_PL_NEXT,
-	MP4C_PL_JUMP,
-	MP4C_DISCONNECT,
-	MP4C_SELECT,
-	MP4C_PAUSE_RESUME,
-	MP4C_STEP,
-	MP4C_SEEK,
-	MP4C_SEEK_TIME,
-	MP4C_TIME,
-	MP4C_UPDATE,
-	MP4C_EVALJS,
-	MP4C_SCREENSHOT,
-	MP4C_WORLDINFO,
-	MP4C_ODLIST,
-	MP4C_ODINFO_ID,
-	MP4C_ODINFO_NUM,
-	MP4C_ODTIME,
-	MP4C_ODBUF,
-	MP4C_DUMPSCENE,
-	MP4C_STRESSMODE,
-	MP4C_NAVMODE,
-	MP4C_LASTVP,
-	MP4C_OGL2D,
-	MP4C_AR_4_3,
-	MP4C_AR_16_9,
-	MP4C_AR_NONE,
-	MP4C_AR_ORIG,
-	MP4C_LOGS,
-	MP4C_RELOAD_OPTS,
-	MP4C_DISP_RTI,
-	MP4C_DISP_FPS,
-	MP4C_DISP_STATS,
-	MP4C_DISP_GRAPH,
-	MP4C_HELP,
-	MP4C_DOWNRATE,
-	MP4C_VMEM_CACHE,
-
-} MP4C_Command;
-
-struct _mp4c_key
-{
- u8 char_code;
- MP4C_Command cmd_type;
- const char *cmd_help;
- u32 flags;
-} MP4C_Keys = {
-	{'q', MP4C_QUIT, "quit", 0},
-	{'X', MP4C_KILL, "kill", 0},
-	{'r', MP4C_KILL, "reload current presentation", 0},
-	{'o', MP4C_OPEN, "connect to the specified URL", 0},
-	{'O', MP4C_OPEN_PL, "connect to the specified playlist", 0},
-	{'N', MP4C_PL_NEXT, "switch to the next URL in the playlist. Also works with `\\n`", 0},
-	{'P', MP4C_PL_JUMP, "jump to a given number ahead in the playlist", 0},
-	{'D', MP4C_DISCONNECT, "disconnect the current presentation", 0},
-	{'G', MP4C_SELECT, "select object or service ID", 0},
-	{'p', MP4C_PAUSE_RESUME, "play/pause the presentation", 0},
-	{'s', MP4C_STEP, "step one frame ahead", 0},
-	{'z', MP4C_SEEK, "seek into presentation by percentage", 0},
-	{'T', MP4C_SEEK_TIME, "seek into presentation by time", 0},
-	{'t', MP4C_TIME, "print current timing", 0},
-	{'u', MP4C_UPDATE, "send a command (BIFS or LASeR) to the main scene", 0},
-	{'e', MP4C_EVALJS, "evaluate JavaScript code in the main scene", 0},
-	{'Z', MP4C_SCREENSHOT, "dump current output frame to PNG", 0},
-	{'w', MP4C_WORLDINFO, "view world info", 0},
-	{ 'v', MP4C_ODLIST, "view list of active media objects in scene", 0},
-	{ 'i', MP4C_ODINFO_ID, "view Object Descriptor info (by ID)", 0},
-	{ 'j', MP4C_ODINFO_NUM, "view Object Descriptor info (by number)", 0},
-	{ 'b', MP4C_ODTIME, "view media objects timing and buffering info", 0},
-	{ 'm', MP4C_ODBUF, "view media objects buffering and memory info", 0},
-	{ 'd', MP4C_DUMPSCENE, "dump scene graph", 0},
-	{ 'k', MP4C_STRESSMODE, "turn stress mode on/off", 0},
-	{ 'n', MP4C_NAVMODE, "change navigation mode", 0},
-	{ 'x', MP4C_LASTVP, "reset to last active viewpoint", 0},
-	{ '3', MP4C_OGL2D, "switch OpenGL on or off for 2D scenes", 0},
-	{ '4', MP4C_AR_4_3, "force 4/3 Aspect Ratio", 0},
-	{ '5', MP4C_AR_16_9, "force 16/9 Aspect Ratio", 0},
-	{ '6', MP4C_AR_NONE, "force no Aspect Ratio (always fill screen)", 0},
-	{ '7', MP4C_AR_ORIG, "force original Aspect Ratio (default)", 0},
-	{ 'H', MP4C_DOWNRATE, "set HTTP max download rate", 0},
-	{ 'E', MP4C_RELOAD_OPTS, "force reload of compositor options", 0},
-
-	{ 'L', MP4C_LOGS, "change to new log tool/level. CF MP4Client usage for possible values", 0},
-	{ 'R', MP4C_DISP_RTI, "toggle run-time info display in window title bar on/off", 0},
-	{ 'F', MP4C_DISP_FPS, "toggle displaying of FPS in stderr on/off", 0},
-	{ 'f', MP4C_DISP_STATS, "print filter session stats", 0},
-	{ 'g', MP4C_DISP_GRAPH, "print filter session graph", 0},
-
-	{ 'h', MP4C_HELP, "print this message", 0},
-	//below this, only experimental features
-	{ 'M', MP4C_VMEM_CACHE, "specify video cache memory for 2D objects", 1},
-	{0}
-};
-
-MP4C_Command get_cmd(u8 char_code)
-{
-	u32 i=0;
-	while (MP4C_Keysi.char_code) {
-		if (MP4C_Keysi.char_code == char_code)
-			return MP4C_Keysi.cmd_type;
-		i++;
-	}
-	return 0;
-}
-
-void PrintHelp()
-{
-	u32 i=0;
-
-	gf_sys_format_help(helpout, help_flags, "# MP4Client runtime commands\n"
-		"## Prompt Interaction\n"
-		"The following keys are used for prompt interaction:\n");
-
-	while (MP4C_Keysi.char_code) {
-		struct _mp4c_key *k = &MP4C_Keysi;
-		i++;
-		gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%c: %s%s\n", k->char_code, k->cmd_help, k->flags ? " **! experimental !**" : "");
-	}
-
-	gf_sys_format_help(helpout, help_flags, "\n"
-		"## Content interaction\n"
-		"It is possible to interact with content (interactive or not) using mouse and keyboard.\n"
-		"The following commands are available:\n"
-		"TODO\n"
-		"\n"
-	);
-}
-
-
-static void PrintTime(u64 time)
-{
-	u32 ms, h, m, s;
-	h = (u32) (time / 1000 / 3600);
-	m = (u32) (time / 1000 / 60 - h*60);
-	s = (u32) (time / 1000 - h*3600 - m*60);
-	ms = (u32) (time - (h*3600 + m*60 + s) * 1000);
-	fprintf(stderr, "%02d:%02d:%02d.%03d", h, m, s, ms);
-}
-
-
-static u32 rti_update_time_ms = 200;
-static FILE *rti_logs = NULL;
-
-static void UpdateRTInfo(const char *legend)
-{
-	GF_SystemRTInfo rti;
-
-	/*refresh every second*/
-	if (!Run) return;
-	if (!display_rti && !rti_logs) return;
-	if (!gf_sys_get_rti(rti_update_time_ms, &rti, 0) && !legend)
-		return;
-
-	if (display_rti) {
-		char szMsg1024;
-
-		if (rti.total_cpu_usage && (bench_mode<2) ) {
-			sprintf(szMsg, "FPS %02.02f CPU %2d (%02d) Mem %d kB",
-			 gf_term_get_framerate(term, 0), rti.total_cpu_usage, rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024));
-		} else {
-			sprintf(szMsg, "FPS %02.02f CPU %02d Mem %d kB",
-			 gf_term_get_framerate(term, 0), rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024) );
-		}
-
-		if (display_rti==2) {
-			if (bench_mode>=2) {
-				PrintAVInfo(GF_FALSE);
-			}
-			fprintf(stderr, "%s\r", szMsg);
-		} else {
-			GF_Event evt;
-			evt.type = GF_EVENT_SET_CAPTION;
-			evt.caption.caption = szMsg;
-			gf_term_user_event(term, &evt);
-		}
-	}
-	if (rti_logs) {
-		fprintf(rti_logs, "% 8d\t% 8d\t% 8d\t% 4d\t% 8d\t%s",
-		 gf_sys_clock(),
-		 gf_term_get_time_in_ms(term),
-		 rti.total_cpu_usage,
-		 (u32) gf_term_get_framerate(term, 0),
-		 (u32) (rti.gpac_memory / 1024),
-		 legend ? legend : ""
-		 );
-		if (!legend) fprintf(rti_logs, "\n");
-	}
-}
-
-#include <gpac/revision.h>
-#define MP4CLIENT_CAPTION	"GPAC MP4Client "GPAC_VERSION "-rev" GPAC_GIT_REVISION
-
-static void ResetCaption()
-{
-	GF_Event event;
-	if (display_rti) return;
-	event.type = GF_EVENT_SET_CAPTION;
-	event.caption.caption = NULL;
-
-	if (is_connected) {
-		char szName1024;
-		GF_TermURLInfo urli;
-
-		/*get any service info*/
-		if (!startup_file && gf_term_get_service_info(term, gf_term_get_root_object(term), &urli) == GF_OK) {
-			strcpy(szName, "");
-			if (urli.track_num) {
-				char szBuf10;
-				sprintf(szBuf, "%02d ", (u32) urli.track_num );
-				strcat(szName, szBuf);
-			}
-			if (urli.artist) {
-				strcat(szName, urli.artist);
-				strcat(szName, " ");
-			}
-			if (urli.name) {
-				strcat(szName, urli.name);
-				strcat(szName, " ");
-			}
-			if (urli.album) {
-				strcat(szName, "(");
-				strcat(szName, urli.album);
-				strcat(szName, ")");
-			}
-			if (urli.provider) {
-				strcat(szName, "(");
-				strcat(szName, urli.provider);
-				strcat(szName, ")");
-			}
-			if (strlen(szName)) event.caption.caption = szName;
-		}
-		if (!event.caption.caption) {
-			char *str = strrchr(the_url, '\\');
-			if (!str) str = strrchr(the_url, '/');
-			event.caption.caption = str ? str+1 : the_url;
-		}
-	} else {
-		event.caption.caption = MP4CLIENT_CAPTION;
-	}
-	gf_term_user_event(term, &event);
-}
-
-#ifdef WIN32
-u32 get_sys_col(int idx)
-{
-	u32 res;
-	DWORD val = GetSysColor(idx);
-	res = (val)&0xFF;
-	res<<=8;
-	res |= (val>>8)&0xFF;
-	res<<=8;
-	res |= (val>>16)&0xFF;
-	return res;
-}
-#endif
-
-void switch_bench(u32 is_on)
-{
-	bench_mode = is_on;
-	display_rti = is_on ? 2 : 0;
-	ResetCaption();
-	gf_term_set_option(term, GF_OPT_VIDEO_BENCH, is_on);
-}
-
-#ifdef GPAC_ENABLE_COVERAGE
-#define getch() 0
-#define read_line_input(_line, _maxSize, _showContent) GF_FALSE
-
-#else
-
-#ifndef WIN32
-#include <termios.h>
-int getch() {
-	struct termios old;
-	struct termios new;
-	int rc;
-	if (tcgetattr(0, &old) == -1) {
-		return -1;
-	}
-	new = old;
-	new.c_lflag &= ~(ICANON | ECHO);
-	new.c_ccVMIN = 1;
-	new.c_ccVTIME = 0;
-	if (tcsetattr(0, TCSANOW, &new) == -1) {
-		return -1;
-	}
-	rc = getchar();
-	(void) tcsetattr(0, TCSANOW, &old);
-	return rc;
-}
-#else
-int getch() {
-	return getchar();
-}
-#endif
-
-/**
- * Reads a line of input from stdin
- * @param line the buffer to fill
- * @param maxSize the maximum size of the line to read
- * @param showContent boolean indicating if the line read should be printed on stderr or not
- */
-static Bool read_line_input(char * line, int maxSize, Bool showContent) {
-	char read;
-	int i = 0;
-	if (fflush( stderr ))
-		perror("Failed to flush buffer %s");
-	do {
-		linei = '\0';
-		if (i >= maxSize - 1)
-			return GF_FALSE;
-		read = getch();
-		if (read == 8 || read == 127) {
-			if (i > 0) {
-				fprintf(stderr, "\b \b");
-				i--;
-			}
-		} else if (read > 32) {
-			fputc(showContent ? read : '*', stderr);
-			linei++ = read;
-		}
-		fflush(stderr);
-	} while (read != '\n');
-	if (!read)
-		return GF_FALSE;
-	return GF_TRUE;
-}
-#endif //!GPAC_ENABLE_COVERAGE
-
-static void do_set_speed(Fixed desired_speed)
-{
-	if (gf_term_set_speed(term, desired_speed) == GF_OK) {
-		playback_speed = desired_speed;
-		fprintf(stderr, "Playing at %g speed\n", FIX2FLT(playback_speed));
-	} else {
-		fprintf(stderr, "Adjusting speed to %g not supported for this content\n", FIX2FLT(desired_speed));
-	}
-}
-
-Bool GPAC_EventProc(void *ptr, GF_Event *evt)
-{
-	if (!term) return 0;
-
-	if (gui_mode==1) {
-		if (evt->type==GF_EVENT_QUIT) {
-			Run = 0;
-			if (evt->message.error>0)
-				ret_val = evt->message.error;
-		} else if (evt->type==GF_EVENT_KEYDOWN) {
-			switch (evt->key.key_code) {
-			case GF_KEY_C:
-				if (evt->key.flags & (GF_KEY_MOD_CTRL|GF_KEY_MOD_ALT)) {
-					hide_shell(shell_visible ? 1 : 0);
-					if (shell_visible) gui_mode=2;
-				}
-				break;
-			default:
-				break;
-			}
-		}
-		return 0;
-	}
-
-	switch (evt->type) {
-	case GF_EVENT_DURATION:
-		Duration = (u64) ( 1000 * (s64) evt->duration.duration);
-		CanSeek = evt->duration.can_seek;
-		break;
-	case GF_EVENT_MESSAGE:
-	{
-		const char *servName;
-		if (!evt->message.service || !strcmp(evt->message.service, the_url)) {
-			servName = "";
-		} else if (!strnicmp(evt->message.service, "data:", 5)) {
-			servName = "(embedded data)";
-		} else {
-			servName = evt->message.service;
-		}
-
-
-		if (!evt->message.message) return 0;
-
-		if (evt->message.error) {
-			if (!is_connected) last_error = evt->message.error;
-			if (evt->message.error==GF_SCRIPT_INFO) {
-				GF_LOG(GF_LOG_INFO, GF_LOG_CONSOLE, ("%s\n", evt->message.message));
-			} else {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CONSOLE, ("%s %s: %s\n", servName, evt->message.message, gf_error_to_string(evt->message.error)));
-			}
-		} else {
-			GF_LOG(GF_LOG_INFO, GF_LOG_CONSOLE, ("%s %s\n", servName, evt->message.message));
-		}
-	}
-	break;
-	case GF_EVENT_PROGRESS:
-	{
-		char *szTitle = "";
-		if (evt->progress.progress_type==0) {
-			szTitle = "Buffer ";
-			if (bench_mode && (bench_mode!=3) ) {
-				if (evt->progress.done >= evt->progress.total) bench_buffer = 0;
-				else bench_buffer = 1 + 100*evt->progress.done / evt->progress.total;
-				break;
-			}
-		}
-		else if (evt->progress.progress_type==1) {
-			if (bench_mode) break;
-			szTitle = "Download ";
-		}
-		else if (evt->progress.progress_type==2) szTitle = "Import ";
-		gf_set_progress(szTitle, evt->progress.done, evt->progress.total);
-	}
-	break;
-
-
-	case GF_EVENT_DBLCLICK:
-		gf_term_set_option(term, GF_OPT_FULLSCREEN, !gf_term_get_option(term, GF_OPT_FULLSCREEN));
-		return 0;
-
-	case GF_EVENT_MOUSEDOWN:
-		if (evt->mouse.button==GF_MOUSE_RIGHT) {
-			right_down = 1;
-			last_x = evt->mouse.x;
-			last_y = evt->mouse.y;
-		}
-		return 0;
-	case GF_EVENT_MOUSEUP:
-		if (evt->mouse.button==GF_MOUSE_RIGHT) {
-			right_down = 0;
-			last_x = evt->mouse.x;
-			last_y = evt->mouse.y;
-		}
-		return 0;
-	case GF_EVENT_MOUSEMOVE:
-		if (right_down && (user.init_flags & GF_TERM_WINDOWLESS) ) {
-			GF_Event move;
-			move.move.x = evt->mouse.x - last_x;
-			move.move.y = last_y-evt->mouse.y;
-			move.type = GF_EVENT_MOVE;
-			move.move.relative = 1;
-			gf_term_user_event(term, &move);
-		}
-		return 0;
-
-	case GF_EVENT_KEYUP:
-		switch (evt->key.key_code) {
-		case GF_KEY_SPACE:
-			if (evt->key.flags & GF_KEY_MOD_CTRL) switch_bench(!bench_mode);
-			break;
-		}
-		break;
-	case GF_EVENT_KEYDOWN:
-		switch (evt->key.key_code) {
-		case GF_KEY_SPACE:
-			if (evt->key.flags & GF_KEY_MOD_CTRL) {
-				/*ignore key repeat*/
-				if (!bench_mode) switch_bench(!bench_mode);
-			}
-			break;
-		case GF_KEY_PAGEDOWN:
-		case GF_KEY_MEDIANEXTTRACK:
-			request_next_playlist_item = 1;
-			break;
-		case GF_KEY_MEDIAPREVIOUSTRACK:
-			break;
-		case GF_KEY_ESCAPE:
-			gf_term_set_option(term, GF_OPT_FULLSCREEN, !gf_term_get_option(term, GF_OPT_FULLSCREEN));
-			break;
-		case GF_KEY_C:
-			if (evt->key.flags & (GF_KEY_MOD_CTRL|GF_KEY_MOD_ALT)) {
-				hide_shell(shell_visible ? 1 : 0);
-				if (!shell_visible) gui_mode=1;
-			}
-			break;
-		case GF_KEY_F:
-			if (evt->key.flags & GF_KEY_MOD_CTRL) fprintf(stderr, "Rendering rate: %f FPS\n", gf_term_get_framerate(term, 0));
-			break;
-		case GF_KEY_T:
-			if (evt->key.flags & GF_KEY_MOD_CTRL) fprintf(stderr, "Scene Time: %f \n", gf_term_get_time_in_ms(term)/1000.0);
-			break;
-		case GF_KEY_D:
-			if (evt->key.flags & GF_KEY_MOD_CTRL) gf_term_set_option(term, GF_OPT_DRAW_MODE, (gf_term_get_option(term, GF_OPT_DRAW_MODE)==GF_DRAW_MODE_DEFER) ? GF_DRAW_MODE_IMMEDIATE : GF_DRAW_MODE_DEFER );
-			break;
-		case GF_KEY_4:
-			if (evt->key.flags & GF_KEY_MOD_CTRL)
-				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
-			break;
-		case GF_KEY_5:
-			if (evt->key.flags & GF_KEY_MOD_CTRL)
-				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
-			break;
-		case GF_KEY_6:
-			if (evt->key.flags & GF_KEY_MOD_CTRL)
-				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
-			break;
-		case GF_KEY_7:
-			if (evt->key.flags & GF_KEY_MOD_CTRL)
-				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
-			break;
-		case GF_KEY_O:
-			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
-				if (gf_term_get_option(term, GF_OPT_MAIN_ADDON)) {
-					fprintf(stderr, "Resuming to main content\n");
-					gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PLAY_LIVE);
-				} else {
-					fprintf(stderr, "Main addon not enabled\n");
-				}
-			}
-			break;
-		case GF_KEY_P:
-			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
-				u32 pause_state = gf_term_get_option(term, GF_OPT_PLAY_STATE) ;
-				fprintf(stderr, "Status: %s\n", pause_state ? "Playing" : "Paused");
-				if ((pause_state == GF_STATE_PAUSED) && (evt->key.flags & GF_KEY_MOD_SHIFT)) {
-					gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PLAY_LIVE);
-				} else {
-					gf_term_set_option(term, GF_OPT_PLAY_STATE, (pause_state==GF_STATE_PAUSED) ? GF_STATE_PLAYING : GF_STATE_PAUSED);
-				}
-			}
-			break;
-		case GF_KEY_S:
-			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
-				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
-				fprintf(stderr, "Step time: ");
-				PrintTime(gf_term_get_time_in_ms(term));
-				fprintf(stderr, "\n");
-			}
-			break;
-		case GF_KEY_B:
-			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected)
-				ViewODs(term, 1);
-			break;
-		case GF_KEY_M:
-			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected)
-				ViewODs(term, 0);
-			break;
-		case GF_KEY_H:
-			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
-				gf_term_switch_quality(term, 1);
-			//	gf_term_set_option(term, GF_OPT_MULTIVIEW_MODE, 0);
-			}
-			break;
-		case GF_KEY_L:
-			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
-				gf_term_switch_quality(term, 0);
-			//	gf_term_set_option(term, GF_OPT_MULTIVIEW_MODE, 1);
-			}
-			break;
-		case GF_KEY_F5:
-			if (is_connected)
-				reload = 1;
-			break;
-		case GF_KEY_A:
-			addon_visible = !addon_visible;
-			gf_term_toggle_addons(term, addon_visible);
-			break;
-		case GF_KEY_UP:
-			if ((evt->key.flags & VK_MOD) && is_connected) {
-				do_set_speed(playback_speed * 2);
-			}
-			break;
-		case GF_KEY_DOWN:
-			if ((evt->key.flags & VK_MOD) && is_connected) {
-				do_set_speed(playback_speed / 2);
-			}
-			break;
-		case GF_KEY_LEFT:
-			if ((evt->key.flags & VK_MOD) && is_connected) {
-				do_set_speed(-1 * playback_speed );
-			}
-			break;
-
-		}
-		break;
-
-	case GF_EVENT_CONNECT:
-		if (evt->connect.is_connected) {
-			is_connected = 1;
-			fprintf(stderr, "Service Connected\n");
-			eos_seen = GF_FALSE;
-			if (playback_speed != FIX_ONE)
-				gf_term_set_speed(term, playback_speed);
-
-			if (do_coverage) {
-				gf_term_switch_quality(term, 1);
-			}
-
-		} else if (is_connected) {
-			fprintf(stderr, "Service %s\n", is_connected ? "Disconnected" : "Connection Failed");
-			is_connected = 0;
-			Duration = 0;
-		}
-		if (init_w && init_h) {
-			gf_term_set_size(term, init_w, init_h);
-		}
-		ResetCaption();
-		break;
-	case GF_EVENT_EOS:
-		eos_seen = GF_TRUE;
-		if (playlist) {
-			if (Duration>1500)
-				request_next_playlist_item = GF_TRUE;
-		}
-		else if (loop_at_end) {
-			restart = 1;
-		}
-		break;
-	case GF_EVENT_SIZE:
-		if (user.init_flags & GF_TERM_WINDOWLESS) {
-			GF_Event move;
-			move.type = GF_EVENT_MOVE;
-			move.move.align_x = align_mode & 0xFF;
-			move.move.align_y = (align_mode>>8) & 0xFF;
-			move.move.relative = 2;
-			gf_term_user_event(term, &move);
-		}
-		break;
-	case GF_EVENT_SCENE_SIZE:
-
-		if ((forced_width && forced_height) || scale) {
-			GF_Event size;
-			u32 nw = forced_width ? forced_width : evt->size.width;
-			u32 nh = forced_height ? forced_height : evt->size.height;
-
-			if (scale != 1) {
-				nw = (u32)(nw * scale);
-				nh = (u32)(nh * scale);
-			}
-			if ((nw != evt->size.width) || (nh != evt->size.height)) {
-				size.type = GF_EVENT_SIZE;
-				size.size.width = nw;
-				size.size.height = nh;
-				gf_term_user_event(term, &size);
-			}
-		}
-		break;
-
-	case GF_EVENT_METADATA:
-		ResetCaption();
-		break;
-	case GF_EVENT_DROPFILE:
-	{
-		u32 i, pos;
-		/*todo - force playlist mode*/
-		if (readonly_playlist) {
-			gf_fclose(playlist);
-			playlist = NULL;
-		}
-		readonly_playlist = 0;
-		if (!playlist) {
-			readonly_playlist = 0;
-			playlist = gf_file_temp(NULL);
-		}
-		pos = (u32) gf_ftell(playlist);
-		i=0;
-		while (i<evt->open_file.nb_files) {
-			if (evt->open_file.filesi != NULL) {
-				fprintf(playlist, "%s\n", evt->open_file.filesi);
-			}
-			i++;
-		}
-		gf_fseek(playlist, pos, SEEK_SET);
-		request_next_playlist_item = 1;
-	}
-	return 1;
-
-	case GF_EVENT_QUIT:
-		if (evt->message.error<0) {
-			fprintf(stderr, "A fatal error was encoutered: %s (%s) - exiting ...\n", evt->message.message ? evt->message.message : "no details", gf_error_to_string(evt->message.error) );
-		} else {
-			ret_val = evt->message.error;
-		}
-		Run = 0;
-		break;
-	case GF_EVENT_DISCONNECT:
-		gf_term_disconnect(term);
-		break;
-	case GF_EVENT_MIGRATE:
-	{
-	}
-	break;
-	case GF_EVENT_NAVIGATE_INFO:
-		if (evt->navigate.to_url)
-			fprintf(stderr, "Go to URL: \"%s\"\r", evt->navigate.to_url);
-		break;
-	case GF_EVENT_NAVIGATE:
-		if (gf_term_is_supported_url(term, evt->navigate.to_url, 1, no_mime_check)) {
-			strncpy(the_url, evt->navigate.to_url, sizeof(the_url)-1);
-			the_urlsizeof(the_url) - 1 = 0;
-			fprintf(stderr, "Navigating to URL %s\n", the_url);
-			gf_term_navigate_to(term, evt->navigate.to_url);
-			return 1;
-		} else {
-			fprintf(stderr, "Navigation destination not supported\nGo to URL: %s\n", evt->navigate.to_url);
-		}
-		break;
-	case GF_EVENT_SET_CAPTION:
-		gf_term_user_event(term, evt);
-		break;
-	case GF_EVENT_AUTHORIZATION:
-	{
-		u32 nb_retry = 4;
-		assert( evt->type == GF_EVENT_AUTHORIZATION);
-		assert( evt->auth.user);
-		assert( evt->auth.password);
-		assert( evt->auth.site_url);
-		while ((!strlen(evt->auth.user) || !strlen(evt->auth.password)) && (nb_retry > 0) ) {
-			nb_retry--;
-			fprintf(stderr, "**** Authorization required for site %s ****\n", evt->auth.site_url);
-			fprintf(stderr, "login : ");
-			if (!read_line_input(evt->auth.user, 50, 1))
-				continue;
-			fprintf(stderr, "\npassword: ");
-			if (!read_line_input(evt->auth.password, 50, 0))
-				continue;
-			fprintf(stderr, "*********\n");
-		}
-		if (nb_retry == 0) {
-			fprintf(stderr, "**** No User or password has been filled, aborting ***\n");
-			return 0;
-		}
-		return 1;
-	}
-	case GF_EVENT_ADDON_DETECTED:
-		if (enable_add_ons) {
-			fprintf(stderr, "Media Addon %s detected - enabling it\n", evt->addon_connect.addon_url);
-			addon_visible = 1;
-		}
-		return enable_add_ons;
-	}
-	return 0;
-}
-
-
-void list_modules()
-{
-	u32 i;
-	fprintf(stderr, "\rAvailable modules:\n");
-	for (i=0; i<gf_modules_count(); i++) {
-		char *str = (char *) gf_modules_get_file_name(i);
-		if (str) fprintf(stderr, "\t%s\n", str);
-	}
-	fprintf(stderr, "\n");
-}
-
-void set_navigation()
-{
-	GF_Err e;
-	char nav;
-	u32 type = gf_term_get_option(term, GF_OPT_NAVIGATION_TYPE);
-	e = GF_OK;
-//	fflush(stdin);
-
-	if (!type) {
-		fprintf(stderr, "Content/compositor doesn't allow user-selectable navigation\n");
-	} else if (type==1) {
-		fprintf(stderr, "Select Navigation (\'N\'one, \'E\'xamine, \'S\'lide): ");
-		nav = do_coverage ? 'N' : getch();
-		if (nav=='N') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
-		else if (nav=='E') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
-		else if (nav=='S') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
-		else fprintf(stderr, "Unknown selector \'%c\' - only \'N\',\'E\',\'S\' allowed\n", nav);
-	} else if (type==2) {
-		fprintf(stderr, "Select Navigation (\'N\'one, \'W\'alk, \'F\'ly, \'E\'xamine, \'P\'an, \'S\'lide, \'G\'ame, \'V\'R, \'O\'rbit): ");
-		nav = do_coverage ? 'N' : getch();
-		if (nav=='N') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
-		else if (nav=='W') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_WALK);
-		else if (nav=='F') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_FLY);
-		else if (nav=='E') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
-		else if (nav=='P') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_PAN);
-		else if (nav=='S') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
-		else if (nav=='G') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_GAME);
-		else if (nav=='O') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_ORBIT);
-		else if (nav=='V') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_VR);
-		else fprintf(stderr, "Unknown selector %c - only \'N\',\'W\',\'F\',\'E\',\'P\',\'S\',\'G\', \'V\', \'O\' allowed\n", nav);
-	}
-	if (e) fprintf(stderr, "Error setting mode: %s\n", gf_error_to_string(e));
-}
-
-
-static void on_rti_log(void *cbk, GF_LOG_Level ll, GF_LOG_Tool lm, const char *fmt, va_list list)
-{
-	if (rti_logs && (lm & GF_LOG_RTI)) {
-		char szMsg2048;
-		vsnprintf(szMsg, 2048, fmt, list);
-		UpdateRTInfo(szMsg + 6 /*"RTI "*/);
-	}
-}
-
-static void init_rti_logs(char *rti_file, char *url, Bool use_rtix)
-{
-	if (rti_logs) gf_fclose(rti_logs);
-	rti_logs = gf_fopen(rti_file, "wt");
-	if (rti_logs) {
-		fprintf(rti_logs, "!! GPAC RunTime Info ");
-		if (url) fprintf(rti_logs, "for file %s", url);
-		fprintf(rti_logs, " !!\n");
-		fprintf(rti_logs, "SysTime(ms)\tSceneTime(ms)\tCPU\tFPS\tMemory(kB)\tObservation\n");
-
-		/*turn on RTI loging*/
-		if (use_rtix) {
-			gf_log_set_callback(NULL, on_rti_log);
-			gf_log_set_tool_level(GF_LOG_RTI, GF_LOG_DEBUG);
-
-			GF_LOG(GF_LOG_DEBUG, GF_LOG_RTI, ("RTI System state when enabling log\n"));
-		} else if (log_rti_time_start) {
-			log_rti_time_start = gf_sys_clock_high_res();
-		}
-	}
-}
-
-
-#ifdef WIN32
-#include <wincon.h>
-#endif
-
-int mp4client_main(int argc, char **argv)
-{
-	char c;
-	MP4C_Command cmdtype;
-	const char *str;
-	GF_Err e;
-	u32 i, ll;
-	u32 simulation_time_in_ms = 0;
-	u32 initial_service_id = 0;
-	Bool auto_exit = GF_FALSE;
-	Bool start_fs = GF_FALSE;
-	Bool use_rtix = GF_FALSE;
-	Bool pause_at_first = GF_FALSE;
-	Bool no_cfg_save = GF_FALSE;
-	Bool print_stats = GF_FALSE;
-	Bool print_graph = GF_FALSE;
-	Bool no_keyboard = GF_FALSE;
-	Double play_from = 0;
-#ifdef GPAC_MEMORY_TRACKING
- GF_MemTrackerType mem_track = GF_MemTrackerNone;
-#endif
-	Bool has_command;
-	char *url_arg, *gpac_profile, *rti_file;
-	FILE *logfile = NULL;
-#ifndef WIN32
-	dlopen(NULL, RTLD_NOW|RTLD_GLOBAL);
-#endif
-
-	helpout = stdout;
-
-	/*by default use current dir*/
-	strcpy(the_url, ".");
-
-	memset(&user, 0, sizeof(GF_User));
-
-	has_command = GF_FALSE;
-	url_arg = gpac_profile = rti_file = NULL;
-
-	/*first identify profile and mem tracking */
-	for (i=1; i<(u32) argc; i++) {
-		char *arg = argvi;
-		if (!strcmp(arg, "-p")) {
-			gpac_profile = argvi+1;
-			i++;
-		} else if (!strncmp(arg, "-p=", 3)) {
-			gpac_profile = argvi+3;
-		} else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
-#ifdef GPAC_MEMORY_TRACKING
- mem_track = !strcmp(arg, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
-#else
-			fprintf(stderr, "WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", arg);
-#endif
-		} else if (!strcmp(arg, "-gui")) {
-			gui_mode = 1;
-		} else if (!strcmp(arg, "-guid")) {
-			gui_mode = 2;
-		} else if (!strcmp(arg, "-h") || !strcmp(arg, "-help")) {
-			PrintUsage(GF_FALSE);
-			return 0;
-		} else if (!strcmp(arg, "-hx")) {
-			PrintUsage(GF_TRUE);
-			return 0;
-		} else if (!strcmp(arg, "-hr")) {
-			PrintHelp();
-			return 0;
-		} else if (!strcmp(arg, "-hc")) {
-			fprintf(helpout, "libgpac options:\n");
-			gf_sys_print_core_help(helpout, help_flags, GF_ARGMODE_ALL, 0);
-			return 0;
-		}
-	}
-
-#ifdef GPAC_MEMORY_TRACKING
-	gf_sys_init(mem_track, gpac_profile);
-#else
-	gf_sys_init(GF_MemTrackerNone, gpac_profile);
-#endif
-
-	gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_WARNING);
-	//we by default want 2 additional threads:
-	//main thread might get locked on vsync
-	//second thread might be busy decoding audio/video
-	//third thread will then be able to refill all buffers/perform networks tasks
-	gf_opts_set_key("temp", "threads", "2");
-
-	e = gf_sys_set_args(argc, (const char **) argv);
-	if (e) {
-		fprintf(stderr, "Error assigning libgpac arguments: %s\n", gf_error_to_string(e) );
-		gf_sys_close();
-		return 1;
-	}
-
-	if (!gui_mode) {
-		str = gf_opts_get_key("General", "ForceGUI");
-		if (str && !strcmp(str, "yes")) gui_mode = 1;
-	}
-
-	for (i=1; i<(u32) argc; i++) {
-		char *arg = argvi;
-
-		if (!strcmp(arg, "-genmd")) {
-			help_flags = GF_PRINTARG_MD;
-			helpout = gf_fopen("mp4client.md", "w");
-
-	 		fprintf(helpout, "**HOME**(Home) » MP4Client \n");
-	 		fprintf(helpout, "\n");
-			PrintUsage(GF_TRUE);
-			PrintHelp();
-			gf_fclose(helpout);
-			gf_sys_close();
-			return 0;
-		} else if (!strcmp(arg, "-genman")) {
-			help_flags = GF_PRINTARG_MAN;
-			helpout = gf_fopen("mp4client.1", "w");
-
-
-	 		fprintf(helpout, ".TH MP4Client 1 2019 MP4Client GPAC\n");
-			fprintf(helpout, ".\n.SH NAME\n.LP\nMP4Client \\- GPAC command-line media player\n.SH SYNOPSIS\n.LP\n.B MP4Client\n.RI options \\ file\n.br\n.\n");
-
-	 		PrintUsage(GF_TRUE);
-			PrintHelp();
-
-			fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/mp4client\n");
-			fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
-			".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
-			".br\nbuild: %s\n"
-			".br\nCopyright: %s\n.br\n"
-			".SH SEE ALSO\n"
-			".LP\ngpac(1), MP4Box(1)\n", gf_gpac_version(), gf_gpac_copyright());
-
-			gf_fclose(helpout);
-			gf_sys_close();
-			return 0;
-		} else if (!strcmp(arg, "-rti")) {
-			rti_file = argvi+1;
-			i++;
-		} else if (!strcmp(arg, "-rtix")) {
-			rti_file = argvi+1;
-			i++;
-			use_rtix = GF_TRUE;
-		} else if (!strcmp(arg, "-rti-refresh")) {
-			rti_update_time_ms = atoi(argvi+1);
-			i++;
-		} else if (!stricmp(arg, "-size")) {
-			/*usage of %ud breaks sscanf on MSVC*/
-			if (sscanf(argvi+1, "%dx%d", &forced_width, &forced_height) != 2) {
-				forced_width = forced_height = 0;
-			}
-			i++;
-		}
-		//libgpac opts using an argument
-		else if (!strcmp(arg, "-log-file") || !strcmp(arg, "-lf") || !strcmp(arg, "-logs") || !strcmp(arg, "-cfg") || !strcmp(arg, "-ifce") ) {
-			i++;
-		}
-
-		else if (!strcmp(arg, "-no-thread")) {
-			gf_opts_set_key("temp", "threads", "0");
-		}
-		else if (!strcmp(arg, "-no-audio")) {
-			no_audio = GF_TRUE;
-		}
-		else if (!strcmp(arg, "-fs")) start_fs = 1;
-		else if (!stricmp(arg, "-no-save") || !stricmp(arg, "--no-save") /*old versions used --n-save ...*/) {
-			no_cfg_save=1;
-		}
-		else if (!stricmp(arg, "-run-for")) {
-			simulation_time_in_ms = (u32) (atof(argvi+1) * 1000);
-			if (!simulation_time_in_ms)
-				simulation_time_in_ms = 1; /*1ms*/
-			i++;
-		} else if (!stricmp(arg, "-scale")) {
-			sscanf(argvi+1, "%f", &scale);
-			i++;
-		}
-		/* already parsed */
-		else if (!strcmp(arg, "-nk")) {
-			no_keyboard = GF_TRUE;
-		}
-		/* already parsed */
-		else if (!strcmp(arg, "-p")) {
-			i++;
-		}
-		/* already parsed */
-		else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack") || !strcmp(arg, "-gui") || !strcmp(arg, "-guid")
-			 || !strncmp(arg, "-p=", 3)
-		) {
-		}
-
-		/*arguments only used in non-gui mode*/
-		else if (!gui_mode) {
-			if (arg0 != '-') {
-				if (url_arg) {
-					fprintf(stderr, "Several input URLs provided (\"%s\", \"%s\"). Check your command-line.\n", url_arg, arg);
-					return 1;
-				}
-				url_arg = arg;
-			}
-			else if (!strcmp(arg, "-loop")) loop_at_end = 1;
-			else if (!strcmp(arg, "-bench")) bench_mode = 1;
-			else if (!strcmp(arg, "-vbench")) bench_mode = 2;
-			else if (!strcmp(arg, "-sbench")) bench_mode = 3;
-			else if (!strcmp(arg, "-no-addon")) enable_add_ons = GF_FALSE;
-
-			else if (!strcmp(arg, "-pause")) pause_at_first = 1;
-			else if (!strcmp(arg, "-play-from")) {
-				play_from = atof((const char *) argvi+1);
-				i++;
-			}
-			else if (!strcmp(arg, "-speed")) {
-				playback_speed = FLT2FIX( atof((const char *) argvi+1) );
-				if (playback_speed <= 0) playback_speed = FIX_ONE;
-				i++;
-			}
-			else if (!strcmp(arg, "-no-wnd")) user.init_flags |= GF_TERM_WINDOWLESS;
-			else if (!strcmp(arg, "-no-back")) user.init_flags |= GF_TERM_WINDOW_TRANSPARENT;
-			else if (!strcmp(arg, "-align")) {
-				if (argvi+10=='m') align_mode = 1;
-				else if (argvi+10=='b') align_mode = 2;
-				align_mode <<= 8;
-				if (argvi+11=='m') align_mode |= 1;
-				else if (argvi+11=='r') align_mode |= 2;
-				i++;
-			}
-			else if (!strcmp(arg, "-exit")) auto_exit = GF_TRUE;
-			else if (!stricmp(arg, "-com")) {
-				has_command = GF_TRUE;
-				i++;
-			}
-			else if (!stricmp(arg, "-service")) {
-				initial_service_id = atoi(argvi+1);
-				i++;
-			} else if (!stricmp(arg, "-stats")) {
-				print_stats=GF_TRUE;
-			} else if (!stricmp(arg, "-graph")) {
-				print_graph=GF_TRUE;
-			} else if (!stricmp(arg, "-cov")) {
-				do_coverage = GF_TRUE;
-				print_stats = GF_TRUE;
-				print_graph = GF_TRUE;
-			} else {
-				u32 res = gf_sys_is_gpac_arg(arg);
-				if (!res) {
-					fprintf(stderr, "Unrecognized option %s\n", arg);
-				} else if (res==2) {
-					i++;
-				}
-			}
-		} else if (gf_sys_is_gpac_arg(arg)==2) {
-			i++;
-		}
- 	}
-
-	//will run switch helpout to stderr
-	helpout = stderr;
-
-	if (!gui_mode && !url_arg && (gf_opts_get_key("General", "StartupFile") != NULL)) {
-		gui_mode=1;
-	}
-
-#ifdef WIN32
-	if (gui_mode==1) {
-		const char *opt;
-		TCHAR buffer1024;
-		DWORD res = GetCurrentDirectory(1024, buffer);
-		bufferres = 0;
-		opt = gf_opts_get_key("core", "module-dir");
-		if (strstr(opt, buffer)) {
-			gui_mode=1;
-		} else {
-			gui_mode=2;
-		}
-	}
-#endif
-
-	if (gui_mode==1) {
-		hide_shell(1);
-	}
-	if (gui_mode) {
-		gf_sys_set_cfg_option("core:noprog=yes");
-	}
-
-#if defined(__DARWIN__) || defined(__APPLE__)
-	carbon_init();
-#endif
-
-
-	if (rti_file) init_rti_logs(rti_file, url_arg, use_rtix);
-
-	{
-		GF_SystemRTInfo rti;
-		if (gf_sys_get_rti(0, &rti, 0))
-			fprintf(stderr, "System info: %d MB RAM - %d cores\n", (u32) (rti.physical_memory/1024/1024), rti.nb_cores);
-	}
-
-
-	init_w = forced_width;
-	init_h = forced_height;
-
-	user.EventProc = GPAC_EventProc;
-	/*dummy in this case (global vars) but MUST be non-NULL*/
-	user.opaque = &user;
-
-	if (no_audio) user.init_flags |= GF_TERM_NO_AUDIO;
-
-	if (bench_mode) {
-		gf_opts_discard_changes();
-		auto_exit = GF_TRUE;
-		if (bench_mode!=2) user.init_flags |= GF_TERM_NO_VIDEO;
-	}
-
-	if (forced_width && forced_height) {
-		char dim50;
-		sprintf(dim, "%d", forced_width);
-		gf_opts_set_key("Temp", "DefaultWidth", dim);
-		sprintf(dim, "%d", forced_height);
-		gf_opts_set_key("Temp", "DefaultHeight", dim);
-	}
-
-	fprintf(stderr, "Loading GPAC Terminal\n");
-	i = gf_sys_clock();
-
-	term = gf_term_new(&user);
-	if (!term) {
-		fprintf(stderr, "\nInit error - check you have at least one video out and one rasterizer...\nFound modules:\n");
-		list_modules();
-		gf_opts_discard_changes();
-		gf_sys_close();
-		if (logfile) gf_fclose(logfile);
-		return 1;
-	}
-	fprintf(stderr, "Terminal Loaded in %d ms\n", gf_sys_clock()-i);
-
-	if (bench_mode) {
-		display_rti = 2;
-		gf_term_set_option(term, GF_OPT_VIDEO_BENCH, (bench_mode==3) ? 2 : 1);
-		if (bench_mode==1) bench_mode=2;
-	}
-
-	str = gf_opts_get_key("General", "NoMIMETypeFetch");
-	no_mime_check = (str && !stricmp(str, "yes")) ? 1 : 0;
-
-	if (gf_opts_get_bool("core", "proxy-on")) {
-		str = gf_opts_get_key("core", "proxy-name");
-		if (str) fprintf(stderr, "HTTP Proxy %s enabled\n", str);
-	}
-
-	if (rti_file) {
-		UpdateRTInfo("At GPAC load time\n");
-	}
-
-	Run = 1;
-
-	if (url_arg && !strcmp(url_arg, "NOGUI")) {
-		url_arg = NULL;
-	}
-	/*connect if requested*/
-	else if (!gui_mode && url_arg) {
-		char *ext;
-
-		if (strlen(url_arg) >= sizeof(the_url)) {
-			fprintf(stderr, "Input url %s is too long, truncating to %d chars.\n", url_arg, (int)(sizeof(the_url) - 1));
-			strncpy(the_url, url_arg, sizeof(the_url)-1);
-			the_urlsizeof(the_url) - 1 = 0;
-		}
-		else {
-			strcpy(the_url, url_arg);
-		}
-		ext = strrchr(the_url, '.');
-		//only local playlist - maybe we could remove and control through flist ?
-		if (ext && !strncmp("http", the_url, 4) && (!stricmp(ext, ".m3u") || !stricmp(ext, ".pls"))) {
-			e = GF_OK;
-			fprintf(stderr, "Opening Playlist %s\n", the_url);
-
-			strcpy(pl_path, the_url);
-			playlist = e ? NULL : gf_fopen(the_url, "rt");
-			readonly_playlist = 1;
-			if (playlist) {
-				request_next_playlist_item = GF_TRUE;
-			} else {
-				if (e)
-					fprintf(stderr, "Failed to open playlist %s: %s\n", the_url, gf_error_to_string(e) );
-				fprintf(stderr, "Hit 'h' for help\n\n");
-			}
-		} else {
-			fprintf(stderr, "Opening URL %s\n", the_url);
-			if (pause_at_first) fprintf(stderr, "Status: Paused\n");
-			gf_term_connect_from_time(term, the_url, (u64) (play_from*1000), pause_at_first);
-		}
-	} else {
-		fprintf(stderr, "Hit 'h' for help\n\n");
-		str = gf_opts_get_key("General", "StartupFile");
-		if (str) {
-			snprintf(the_url, sizeof(the_url)-1, "MP4Client %s", gf_gpac_version() );
-			the_urlsizeof(the_url) - 1 = 0;
-			gf_term_connect(term, str);
-			startup_file = 1;
-			is_connected = 1;
-		}
-	}
-	if (gui_mode==2) gui_mode=0;
-
-	if (start_fs) gf_term_set_option(term, GF_OPT_FULLSCREEN, 1);
-
-	if (bench_mode) {
-		rti_update_time_ms = 500;
-		bench_mode_start = gf_sys_clock();
-	}
-
-	if (simulation_time_in_ms)
-		simulation_time_in_ms += gf_sys_clock();
-
-
-	while (Run) {
-
-		/*we don't want getchar to block*/
-		if ((gui_mode==1) || (no_keyboard || !gf_prompt_has_input()) ) {
-			if (reload) {
-				reload = 0;
-				gf_term_disconnect(term);
-				gf_term_connect(term, startup_file ? gf_opts_get_key("General", "StartupFile") : the_url);
-			}
-			if (restart && gf_term_get_option(term, GF_OPT_IS_OVER)) {
-				restart = 0;
-				gf_term_play_from_time(term, 0, 0);
-			}
-			if (request_next_playlist_item) {
-				c = '\n';
-				request_next_playlist_item = 0;
-				goto force_input;
-			}
-
-			if (has_command && is_connected) {
-				has_command = GF_FALSE;
-				for (i=0; i<(u32)argc; i++) {
-					if (!strcmp(argvi, "-com")) {
-						gf_term_scene_update(term, NULL, argvi+1);
-						i++;
-					}
-				}
-			}
-			if (initial_service_id && is_connected) {
-				GF_ObjectManager *root_od = gf_term_get_root_object(term);
-				if (root_od) {
-					gf_term_select_service(term, root_od, initial_service_id);
-					initial_service_id = 0;
-				}
-			}
-
-			if (!use_rtix || display_rti) UpdateRTInfo(NULL);
-
-
-			gf_term_process_step(term);
-
-			if (auto_exit && eos_seen && gf_term_get_option(term, GF_OPT_IS_OVER)) {
-				Run = GF_FALSE;
-			}
-
-			/*sim time*/
-			if (simulation_time_in_ms
-			 && ( (gf_term_get_elapsed_time_in_ms(term)>simulation_time_in_ms) || (!url_arg && gf_sys_clock()>simulation_time_in_ms))
-			 ) {
-				Run = GF_FALSE;
-			}
-			continue;
-		}
-
-		c = gf_prompt_get_char();
-
-force_input:
-		if (c=='\n') cmdtype=MP4C_PL_NEXT;
-		else cmdtype = get_cmd(c);
-
-		switch (cmdtype) {
-		case MP4C_QUIT:
-		{
-			GF_Event evt;
-			memset(&evt, 0, sizeof(GF_Event));
-			evt.type = GF_EVENT_QUIT;
-			gf_term_send_event(term, &evt);
-		}
-//			Run = 0;
-		break;
-		case MP4C_KILL:
-			exit(0);
-			break;
-
-		case MP4C_OPEN:
-			startup_file = 0;
-			gf_term_disconnect(term);
-			fprintf(stderr, "Enter the absolute URL\n");
-			if (1 > scanf("%1023s", the_url)) {
-				fprintf(stderr, "Cannot read absolute URL, aborting\n");
-				break;
-			}
-			if (rti_file) init_rti_logs(rti_file, the_url, use_rtix);
-			gf_term_connect(term, the_url);
-			break;
-		case MP4C_OPEN_PL:
-			gf_term_disconnect(term);
-			fprintf(stderr, "Enter the absolute URL to the playlist\n");
-			if (1 > scanf("%1023s", the_url)) {
-				fprintf(stderr, "Cannot read the absolute URL, aborting.\n");
-				break;
-			}
-			playlist = gf_fopen(the_url, "rt");
-			if (playlist) {
-				if (1 >	fscanf(playlist, "%1023s", the_url)) {
-					fprintf(stderr, "Cannot read any URL from playlist, aborting.\n");
-					gf_fclose( playlist);
-					break;
-				}
-				fprintf(stderr, "Opening URL %s\n", the_url);
-				gf_term_connect(term, the_url);
-			}
-			break;
-		case MP4C_PL_NEXT:
-			if (playlist) {
-				int res;
-				gf_term_disconnect(term);
-
-				res = fscanf(playlist, "%1023s", the_url);
-				if ((res == EOF) && loop_at_end) {
-					gf_fseek(playlist, 0, SEEK_SET);
-					res = fscanf(playlist, "%1023s", the_url);
-				}
-				if (res == EOF) {
-					fprintf(stderr, "No more items - exiting\n");
-					Run = 0;
-				} else if (the_url0 == '#') {
-					request_next_playlist_item = GF_TRUE;
-				} else {
-					fprintf(stderr, "Opening URL %s\n", the_url);
-					gf_term_connect_with_path(term, the_url, pl_path);
-				}
-			}
-			break;
-		case MP4C_PL_JUMP:
-			if (playlist) {
-				u32 count;
-				gf_term_disconnect(term);
-				if (1 > scanf("%u", &count)) {
-					fprintf(stderr, "Cannot read number, aborting.\n");
-					break;
-				}
-				while (count) {
-					if (fscanf(playlist, "%1023s", the_url)) {
-						fprintf(stderr, "Failed to read line, aborting\n");
-						break;
-					}
-					count--;
-				}
-				fprintf(stderr, "Opening URL %s\n", the_url);
-				gf_term_connect(term, the_url);
-			}
-			break;
-		case MP4C_RELOAD:
-			if (is_connected)
-				reload = 1;
-			break;
-
-		case MP4C_DISCONNECT:
-			if (is_connected) gf_term_disconnect(term);
-			break;
-
-		case MP4C_PAUSE_RESUME:
-			if (is_connected) {
-				Bool is_pause = gf_term_get_option(term, GF_OPT_PLAY_STATE);
-				fprintf(stderr, "Status: %s\n", is_pause ? "Playing" : "Paused");
-				gf_term_set_option(term, GF_OPT_PLAY_STATE, is_pause ? GF_STATE_PLAYING : GF_STATE_PAUSED);
-			}
-			break;
-		case MP4C_STEP:
-			if (is_connected) {
-				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
-				fprintf(stderr, "Step time: ");
-				PrintTime(gf_term_get_time_in_ms(term));
-				fprintf(stderr, "\n");
-			}
-			break;
-
-		case MP4C_SEEK:
-		case MP4C_SEEK_TIME:
-			if (!CanSeek || (Duration<=2000)) {
-				fprintf(stderr, "scene not seekable\n");
-			} else {
-				Double res;
-				s32 seekTo;
-				fprintf(stderr, "Duration: ");
-				PrintTime(Duration);
-				res = gf_term_get_time_in_ms(term);
-				if (cmdtype==MP4C_SEEK) {
-					res *= 100;
-					res /= (s64)Duration;
-					fprintf(stderr, " (current %.2f %%)\nEnter Seek percentage:\n", res);
-					if (scanf("%d", &seekTo) == 1) {
-						if (seekTo > 100) seekTo = 100;
-						res = (Double)(s64)Duration;
-						res /= 100;
-						res *= seekTo;
-						gf_term_play_from_time(term, (u64) (s64) res, 0);
-					}
-				} else {
-					u32 r, h, m, s;
-					fprintf(stderr, " - Current Time: ");
-					PrintTime((u64) res);
-					fprintf(stderr, "\nEnter seek time (Format: s, m:s or h:m:s):\n");
-					h = m = s = 0;
-					r =scanf("%d:%d:%d", &h, &m, &s);
-					if (r==2) {
-						s = m;
-						m = h;
-						h = 0;
-					}
-					else if (r==1) {
-						s = h;
-						m = h = 0;
-					}
-
-					if (r && (r<=3)) {
-						u64 time = h*3600 + m*60 + s;
-						gf_term_play_from_time(term, time*1000, 0);
-					}
-				}
-			}
-			break;
-
-		case MP4C_TIME:
-		{
-			if (is_connected) {
-				fprintf(stderr, "Current Time: ");
-				PrintTime(gf_term_get_time_in_ms(term));
-				fprintf(stderr, " - Duration: ");
-				PrintTime(Duration);
-				fprintf(stderr, "\n");
-			}
-		}
-		break;
-		case MP4C_WORLDINFO:
-			if (is_connected) PrintWorldInfo(term);
-			break;
-		case MP4C_ODLIST:
-			if (is_connected) PrintODList(term, NULL, 0, 0, "Root");
-			break;
-		case MP4C_ODINFO_ID:
-			if (is_connected) {
-				u32 ID;
-				fprintf(stderr, "Enter OD ID (0 for main OD): ");
-				fflush(stderr);
-				if (scanf("%ud", &ID) == 1) {
-					ViewOD(term, ID, (u32)-1, NULL);
-				} else {
-					char str_urlGF_MAX_PATH;
-					if (scanf("%1023s", str_url) == 1)
-						ViewOD(term, 0, (u32)-1, str_url);
-				}
-			}
-			break;
-		case MP4C_ODINFO_NUM:
-			if (is_connected) {
-				u32 num;
-				do {
-					fprintf(stderr, "Enter OD number (0 for main OD): ");
-					fflush(stderr);
-				} while( 1 > scanf("%ud", &num));
-				ViewOD(term, (u32)-1, num, NULL);
-			}
-			break;
-		case MP4C_ODTIME:
-			if (is_connected) ViewODs(term, 1);
-			break;
-
-		case MP4C_ODBUF:
-			if (is_connected) ViewODs(term, 0);
-			break;
-
-		case MP4C_NAVMODE:
-			if (is_connected) set_navigation();
-			break;
-		case MP4C_LASTVP:
-			if (is_connected) gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
-			break;
-
-		case MP4C_DUMPSCENE:
-			if (is_connected) {
-				GF_ObjectManager *odm = NULL;
-				char radnameGF_MAX_PATH, *sExt;
-				u32 count, odid;
-				Bool xml_dump, std_out;
-				radname0 = 0;
-				do {
-					fprintf(stderr, "Enter Inline OD ID if any or 0 : ");
-					fflush(stderr);
-				} while( 1 > scanf("%ud", &odid));
-				if (odid) {
-					GF_ObjectManager *root_odm = gf_term_get_root_object(term);
-					if (!root_odm) break;
-					count = gf_term_get_object_count(term, root_odm);
-					for (i=0; i<count; i++) {
-						GF_MediaInfo info;
-						odm = gf_term_get_object(term, root_odm, i);
-						if (gf_term_get_object_info(term, odm, &info) == GF_OK) {
-							if (info.ODID==odid) break;
-						}
-						odm = NULL;
-					}
-				}
-				do {
-					fprintf(stderr, "Enter file radical name (+\'.x\' for XML dumping) - \"std\" for stderr: ");
-					fflush(stderr);
-				} while( 1 > scanf("%1023s", radname));
-				sExt = strrchr(radname, '.');
-				xml_dump = 0;
-				if (sExt) {
-					if (!stricmp(sExt, ".x")) xml_dump = 1;
-					sExt0 = 0;
-				}
-				std_out = strnicmp(radname, "std", 3) ? 0 : 1;
-				e = gf_term_dump_scene(term, std_out ? NULL : radname, NULL, xml_dump, 0, odm);
-				fprintf(stderr, "Dump done (%s)\n", gf_error_to_string(e));
-			}
-			break;
-
-		case MP4C_OGL2D:
-		{
-			Bool use_3d = !gf_term_get_option(term, GF_OPT_USE_OPENGL);
-			if (gf_term_set_option(term, GF_OPT_USE_OPENGL, use_3d)==GF_OK) {
-				fprintf(stderr, "Using %s for 2D drawing\n", use_3d ? "OpenGL" : "2D rasterizer");
-			}
-		}
-		break;
-		case MP4C_STRESSMODE:
-		{
-			Bool opt = gf_term_get_option(term, GF_OPT_STRESS_MODE);
-			opt = !opt;
-			fprintf(stderr, "Turning stress mode %s\n", opt ? "on" : "off");
-			gf_term_set_option(term, GF_OPT_STRESS_MODE, opt);
-		}
-		break;
-		case MP4C_AR_4_3:
-			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
-			break;
-		case MP4C_AR_16_9:
-			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
-			break;
-		case MP4C_AR_NONE:
-			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
-			break;
-		case MP4C_AR_ORIG:
-			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
-			break;
-
-		case MP4C_DISP_RTI:
-			display_rti = !display_rti;
-			ResetCaption();
-			break;
-		case MP4C_DISP_FPS:
-			if (display_rti) display_rti = 0;
-			else display_rti = 2;
-			ResetCaption();
-			break;
-		case MP4C_DISP_STATS:
-		case MP4C_DISP_GRAPH:
-			ll = gf_log_get_tool_level(GF_LOG_APP);
-			gf_log_set_tool_level(GF_LOG_APP, GF_LOG_INFO);
-			if (cmdtype==MP4C_DISP_STATS)
-				gf_term_print_stats(term);
-			else
-				gf_term_print_graph(term);
-			gf_log_set_tool_level(GF_LOG_APP, ll);
-			break;
-		case MP4C_UPDATE:
-		{
-			char szCom8192;
-			fprintf(stderr, "Enter command to send:\n");
-//			fflush(stdin);
-			szCom0 = 0;
-			if (1 > scanf("%8191^\t\n", szCom)) {
-				fprintf(stderr, "Cannot read command to send, aborting.\n");
-				break;
-			}
-			e = gf_term_scene_update(term, NULL, szCom);
-			if (e) fprintf(stderr, "Processing command failed: %s\n", gf_error_to_string(e));
-		}
-		break;
-		case MP4C_EVALJS:
-		{
-			char jsCode8192;
-			fprintf(stderr, "Enter JavaScript code to evaluate:\n");
-//			fflush(stdin);
-			jsCode0 = 0;
-			if (1 > scanf("%8191^\t\n", jsCode)) {
-				fprintf(stderr, "Cannot read code to evaluate, aborting.\n");
-				break;
-			}
-			e = gf_term_scene_update(term, "application/ecmascript", jsCode);
-			if (e) fprintf(stderr, "Processing JS code failed: %s\n", gf_error_to_string(e));
-		}
-		break;
-
-		case MP4C_LOGS:
-		{
-			char szLog1024, *cur_logs;
-			cur_logs = gf_log_get_tools_levels();
-			fprintf(stderr, "Enter new log level (current tools %s):\n", cur_logs);
-			gf_free(cur_logs);
-			if (scanf("%1023s", szLog) < 1) {
-				fprintf(stderr, "Cannot read new log level, aborting.\n");
-				break;
-			}
-			gf_log_modify_tools_levels(szLog);
-		}
-		break;
-
-		case MP4C_VMEM_CACHE:
-		{
-			u32 size;
-			do {
-				fprintf(stderr, "Enter new video cache memory in kBytes (current %ud):\n", gf_term_get_option(term, GF_OPT_VIDEO_CACHE_SIZE));
-			} while (1 > scanf("%ud", &size));
-			gf_term_set_option(term, GF_OPT_VIDEO_CACHE_SIZE, size);
-		}
-		break;
-
-		case MP4C_DOWNRATE:
-		{
-			u32 http_bitrate = gf_term_get_option(term, GF_OPT_HTTP_MAX_RATE);
-			do {
-				fprintf(stderr, "Enter new http bitrate in bps (0 for none) - current limit: %d\n", http_bitrate);
-			} while (1 > scanf("%ud", &http_bitrate));
-
-			gf_term_set_option(term, GF_OPT_HTTP_MAX_RATE, http_bitrate);
-		}
-		break;
-
-		case MP4C_RELOAD_OPTS:
-			gf_term_set_option(term, GF_OPT_RELOAD_CONFIG, 1);
-			break;
-
-		/*extract to PNG*/
-		case MP4C_SCREENSHOT:
-			MakeScreenshot(GF_FALSE);
-			break;
-
-		case MP4C_SELECT:
-		{
-			GF_ObjectManager *root_od, *odm;
-			u32 index;
-			char szOpt8192;
-			fprintf(stderr, "Enter 0-based index of object to select or service ID:\n");
-//			fflush(stdin);
-			szOpt0 = 0;
-			if (1 > scanf("%8191^\t\n", szOpt)) {
-				fprintf(stderr, "Cannot read OD ID\n");
-				break;
-			}
-			index = atoi(szOpt);
-			odm = NULL;
-			root_od = gf_term_get_root_object(term);
-			if (root_od) {
-				if ( gf_term_find_service(term, root_od, index)) {
-					gf_term_select_service(term, root_od, index);
-				} else {
-					fprintf(stderr, "Cannot find service %d - trying with object index\n", index);
-					odm = gf_term_get_object(term, root_od, index);
-					if (odm) {
-						gf_term_select_object(term, odm);
-					} else {
-						fprintf(stderr, "Cannot find object at index %d\n", index);
-					}
-				}
-			}
-		}
-		break;
-
-		case MP4C_HELP:
-			PrintHelp();
-			break;
-		default:
-			break;
-		}
-	}
-
-	if (bench_mode) {
-		PrintAVInfo(GF_TRUE);
-	}
-
-	/*FIXME: we have an issue in cleaning up after playing in bench mode and run-for 0 (buildbot tests). We for now disable error checks after run-for is done*/
-	if (simulation_time_in_ms) {
-		gf_log_set_strict_error(0);
-	}
-
-	if (print_graph || print_stats) {
-		ll = gf_log_get_tool_level(GF_LOG_APP);
-		gf_log_set_tool_level(GF_LOG_APP, GF_LOG_INFO);
-		if (print_graph)
-			gf_term_print_graph(term);
-		if (print_stats)
-			gf_term_print_stats(term);
-		gf_log_set_tool_level(GF_LOG_APP, ll);
-	}
-
-#ifdef GPAC_ENABLE_COVERAGE
-	if (do_coverage) {
-		u32 w, h, k, nb_drawn;
-		GF_Event evt;
-		Bool is_bound;
-		const char *outName;
-		GF_ObjectManager *root_odm, *odm;
-		PrintAVInfo(GF_TRUE);
-		PrintODList(term, NULL, 0, 0, "Root");
-		ViewODs(term, GF_TRUE);
-		ViewODs(term, GF_FALSE);
-		ViewOD(term, 0, (u32) -1, NULL);
-		ViewOD(term, 0, 1, NULL);
-		PrintUsage(0);
-		PrintHelp();
-		PrintWorldInfo(term);
-		gf_term_dump_scene(term, NULL, NULL, GF_FALSE, 0, NULL);
-		gf_term_get_current_service_id(term);
-		gf_term_toggle_addons(term, GF_FALSE);
-		set_navigation();
-		get_cmd('v');
-
-		gf_term_play_from_time(term, 0, 0);
-
-		memset(&evt, 0, sizeof(GF_Event));
-		evt.type = GF_EVENT_MOUSEUP;
-		evt.mouse.x = 20;
-		evt.mouse.y = 20;
-		gf_term_send_event(term, &evt);
-
-		gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
-		//exercise step clocks
-		gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
-		root_odm = gf_term_get_root_object(term);
-		gf_term_find_service(term, root_odm, 0);
-		gf_term_select_service(term, root_odm, 0);
-		odm = gf_term_get_object(term, root_odm, 0);
-		gf_term_select_object(term, odm );
-		gf_term_object_subscene_type(term, odm);
-		gf_term_get_visual_output_size(term, &w, &h);
-
-		gf_term_is_type_supported(term, "video/mp4");
-		gf_term_get_url(term);
-		gf_term_get_simulation_frame_rate(term, &nb_drawn);
-
-		gf_term_get_text_selection(term, GF_TRUE);
-		gf_term_paste_text(term, "test", GF_TRUE);
-
-		gf_term_set_option(term, GF_OPT_AUDIO_MUTE, 1);
-
-
-		MakeScreenshot(GF_TRUE);
-
-		gf_term_scene_update(term, NULL, "REPLACE DYN_TRANS.translation BY 10 10");
-		gf_term_add_object(term, NULL, GF_TRUE);
-
-		gf_term_get_viewpoint(term, 1, &outName, &is_bound);
-		gf_term_set_viewpoint(term, 1, "testvp");
-
-		for (k=GF_NAVIGATE_WALK; k<=GF_NAVIGATE_VR; k++) {
-			gf_term_set_option(term, GF_OPT_NAVIGATION, k);
-			memset(&evt, 0, sizeof(GF_Event));
-			evt.type = GF_EVENT_MOUSEDOWN;
-			evt.mouse.x = 100;
-			evt.mouse.y = 100;
-			gf_term_user_event(term, &evt);
-			evt.type = GF_EVENT_MOUSEMOVE;
-			evt.mouse.x += 10;
-			gf_term_user_event(term, &evt);
-			evt.mouse.y += 10;
-			gf_term_user_event(term, &evt);
-
-			evt.type = GF_EVENT_KEYDOWN;
-			evt.key.key_code = GF_KEY_CONTROL;
-			gf_term_user_event(term, &evt);
-
-			evt.type = GF_EVENT_MOUSEMOVE;
-			evt.mouse.x = 120;
-			evt.mouse.y = 110;
-			gf_term_user_event(term, &evt);
-
-			evt.type = GF_EVENT_KEYUP;
-			evt.key.key_code = GF_KEY_CONTROL;
-			gf_term_user_event(term, &evt);
-
-			evt.type = GF_EVENT_KEYDOWN;
-			evt.key.key_code = GF_KEY_J;
-			gf_term_user_event(term, &evt);
-
-		}
-		gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
-
-		gf_term_connect_with_path(term, "logo.jpg", "./media/auxiliary_files/");
-		gf_term_navigate_to(term, "./media/auxiliary_files/logo.jpg");
-		send_open_url("./media/auxiliary_files/logo.jpg");
-		switch_bench(1);
-		do_set_speed(1.0);
-		hide_shell(0);
-		list_modules();
-	}
-#endif
-
-	i = gf_sys_clock();
-	gf_term_disconnect(term);
-	if (rti_file) UpdateRTInfo("Disconnected\n");
-
-	if (playlist) gf_fclose(playlist);
-
-#if defined(__DARWIN__) || defined(__APPLE__)
-	carbon_uninit();
-#endif
-
-	//special condition for immediate exit without terminal deletion
-	if (ret_val==3) {
-		fprintf(stderr, "Exit forced, no cleanup\n");
-		exit(0);
-	}
-
-	fprintf(stderr, "Deleting terminal... ");
-	gf_term_del(term);
-	fprintf(stderr, "done (in %d ms) - ran for %d ms\n", gf_sys_clock() - i, gf_sys_clock());
-
-	fprintf(stderr, "GPAC cleanup ...\n");
-
-	if (no_cfg_save)
-		gf_opts_discard_changes();
-
-	gf_sys_close();
-
-	if (rti_logs) gf_fclose(rti_logs);
-	if (logfile) gf_fclose(logfile);
-
-	if (gui_mode) {
-		hide_shell(2);
-	}
-
-#ifdef GPAC_MEMORY_TRACKING
-	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
-	 gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
-		gf_memory_print();
-		return 2;
-	}
-#endif
-
-	return ret_val;
-}
-
-GF_MAIN_FUNC(mp4client_main)
-
-
-static void MakeScreenshot(Bool for_coverage)
-{
-	char szFileName100;
-	u32 nb_pass, nb_views, offscreen_view = 0;
-	GF_VideoSurface fb;
-	GF_Err e;
-	nb_pass = 1;
-	nb_views = gf_term_get_option(term, GF_OPT_NUM_STEREO_VIEWS);
-	if (nb_views>1) {
-		fprintf(stderr, "Auto-stereo mode detected - type number of view to dump (0 is main output, 1 to %d offscreen view, %d for all offscreen, %d for all offscreen and main)\n", nb_views, nb_views+1, nb_views+2);
-		if (!for_coverage) {
-			if (scanf("%d", &offscreen_view) != 1) {
-				offscreen_view = 0;
-			}
-		}
-		if (offscreen_view==nb_views+1) {
-			offscreen_view = 1;
-			nb_pass = nb_views;
-		}
-		else if (offscreen_view==nb_views+2) {
-			offscreen_view = 0;
-			nb_pass = nb_views+1;
-		}
-	}
-	if (for_coverage && !offscreen_view) {
-		if (gf_term_get_offscreen_buffer(term, &fb, 0, 0)==GF_OK)
-			gf_term_release_screen_buffer(term, &fb);
-	}
-	while (nb_pass) {
-		nb_pass--;
-		if (offscreen_view) {
-			sprintf(szFileName, "view%d_dump.png", offscreen_view);
-			e = gf_term_get_offscreen_buffer(term, &fb, offscreen_view-1, 0);
-		} else {
-			sprintf(szFileName, "gpac_video_dump_"LLU".png", gf_net_get_utc() );
-			e = gf_term_get_screen_buffer(term, &fb);
-		}
-		offscreen_view++;
-		if (e) {
-			fprintf(stderr, "Error dumping screen buffer %s\n", gf_error_to_string(e) );
-			nb_pass = 0;
-		} else {
-#ifndef GPAC_DISABLE_AV_PARSERS
-			u32 dst_size = fb.width*fb.height*4;
-			char *dst = (char*)gf_malloc(sizeof(char)*dst_size);
-
-			e = gf_img_png_enc(fb.video_buffer, fb.width, fb.height, fb.pitch_y, fb.pixel_format, dst, &dst_size);
-			if (e) {
-				fprintf(stderr, "Error encoding PNG %s\n", gf_error_to_string(e) );
-				nb_pass = 0;
-			} else {
-				FILE *png = gf_fopen(szFileName, "wb");
-				if (!png) {
-					fprintf(stderr, "Error writing file %s\n", szFileName);
-					nb_pass = 0;
-				} else {
-					gf_fwrite(dst, dst_size, png);
-					gf_fclose(png);
-					fprintf(stderr, "Dump to %s\n", szFileName);
-				}
-			}
-			if (dst) gf_free(dst);
-			gf_term_release_screen_buffer(term, &fb);
-
-			if (for_coverage) gf_file_delete(szFileName);
-#endif //GPAC_DISABLE_AV_PARSERS
-		}
-	}
-	fprintf(stderr, "Done: %s\n", szFileName);
-}
-
-static GF_ObjectManager *video_odm = NULL;
-static GF_ObjectManager *audio_odm = NULL;
-static GF_ObjectManager *scene_odm = NULL;
-static u32 last_odm_count = 0;
-
-static void PrintAVInfo(Bool final)
-{
-	GF_MediaInfo a_odi, v_odi, s_odi;
-	Double avg_dec_time;
-	u32 tot_time;
-
-	if (scene_odm) {
-		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
-		u32 count = gf_term_get_object_count(term, root_odm);
-		if (last_odm_count != count) {
-			last_odm_count = count;
-			scene_odm = NULL;
-		}
-	}
-	if (!video_odm && !audio_odm && !scene_odm) {
-		u32 count, i;
-		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
-		if (!root_odm) return;
-
-		if (gf_term_get_object_info(term, root_odm, &v_odi)==GF_OK) {
-			if (!scene_odm && (v_odi.generated_scene== 0)) {
-				scene_odm = root_odm;
-			}
-		}
-
-		count = gf_term_get_object_count(term, root_odm);
-		for (i=0; i<count; i++) {
-			GF_ObjectManager *odm = gf_term_get_object(term, root_odm, i);
-			if (!odm) break;
-			if (gf_term_get_object_info(term, odm, &v_odi) == GF_OK) {
-				if (!video_odm && (v_odi.od_type == GF_STREAM_VISUAL) && (v_odi.raw_media || (v_odi.cb_max_count>1) || v_odi.direct_video_memory || (bench_mode == 3) )) {
-					video_odm = odm;
-				}
-				else if (!audio_odm && (v_odi.od_type == GF_STREAM_AUDIO)) {
-					audio_odm = odm;
-				}
-				else if (!scene_odm && (v_odi.od_type == GF_STREAM_SCENE)) {
-					scene_odm = odm;
-				}
-			}
-		}
-	}
-
-	if (0 && bench_buffer) {
-		fprintf(stderr, "Buffering %d %% ", bench_buffer-1);
-		return;
-	}
-
-	if (video_odm) {
-		if (gf_term_get_object_info(term, video_odm, &v_odi)!= GF_OK) {
-			video_odm = NULL;
-			return;
-		}
-	} else {
-		memset(&v_odi, 0, sizeof(v_odi));
-	}
-	if (audio_odm) {
-		gf_term_get_object_info(term, audio_odm, &a_odi);
-	} else {
-		memset(&a_odi, 0, sizeof(a_odi));
-	}
-	if (!video_odm && scene_odm) {
-		gf_term_get_object_info(term, scene_odm, &s_odi);
-	} else {
-		memset(&s_odi, 0, sizeof(s_odi));
-	}
-
-	if (final) {
-		tot_time = gf_sys_clock() - bench_mode_start;
-		fprintf(stderr, " \r");
-		fprintf(stderr, "************** Bench Mode Done in %d ms ********************\n", tot_time);
-		if (bench_mode==3) fprintf(stderr, "** Systems layer only (no decoding) **\n");
-
-		if (!video_odm) {
-			u32 nb_frames_drawn;
-			Double FPS = gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
-			fprintf(stderr, "Drawn %d frames FPS %.2f (simulation FPS %.2f) - duration %d ms\n", nb_frames_drawn, ((Float)nb_frames_drawn*1000)/tot_time,(Float) FPS, gf_term_get_time_in_ms(term) );
-		}
-	}
-	if (video_odm) {
-		fprintf(stderr, "%s %dx%d sar=%d:%d duration %.2fs\n", v_odi.codec_name, v_odi.width, v_odi.height, v_odi.par ? (v_odi.par>>16)&0xFF : 1, v_odi.par ? (v_odi.par)&0xFF : 1, v_odi.duration);
-		if (final) {
-			u32 dec_run_time = v_odi.last_frame_time - v_odi.first_frame_time;
-			if (!dec_run_time) dec_run_time = 1;
-			if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
-			fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / dec_run_time, v_odi.max_dec_time, (u32) v_odi.avg_bitrate/1000, (u32) v_odi.max_bitrate/1000);
-			if (v_odi.nb_dropped) {
-				fprintf(stderr, " (Error during bench: %d frames drop)", v_odi.nb_dropped);
-			}
-			fprintf(stderr, "\n");
-		}
-	}
-	if (audio_odm) {
-		fprintf(stderr, "%s SR %d num channels %d %s duration %.2fs\n", a_odi.codec_name, a_odi.sample_rate, a_odi.num_channels, gf_audio_fmt_name(a_odi.afmt), a_odi.duration);
-		if (final) {
-			u32 dec_run_time = a_odi.last_frame_time - a_odi.first_frame_time;
-			if (!dec_run_time) dec_run_time = 1;
-			if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
-			fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max) rate avg %d max %d", a_odi.nb_dec_frames, ((Float)dec_run_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0, (u32) a_odi.avg_bitrate/1000, (u32) a_odi.max_bitrate/1000);
-			if (a_odi.nb_dropped) {
-				fprintf(stderr, " (Error during bench: %d frames drop)", a_odi.nb_dropped);
-			}
-			fprintf(stderr, "\n");
-		}
-	}
-	if (scene_odm) {
-		u32 w, h;
-		gf_term_get_visual_output_size(term, &w, &h);
-		fprintf(stderr, "%s scene size %dx%d rastered to %dx%d duration %.2fs\n", s_odi.codec_name ? s_odi.codec_name : "", s_odi.width, s_odi.height, w, h, s_odi.duration);
-		if (final) {
-			if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
-				u32 dec_run_time = s_odi.last_frame_time - s_odi.first_frame_time;
-				if (!dec_run_time) dec_run_time = 1;
-				fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", s_odi.nb_dec_frames, ((Float)s_odi.nb_dec_frames*1000) / dec_run_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000, (u32) s_odi.max_bitrate/1000);
-				fprintf(stderr, "\n");
-			} else {
-				u32 nb_frames_drawn;
-				Double FPS;
-				gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
-				tot_time = gf_sys_clock() - bench_mode_start;
-				FPS = gf_term_get_framerate(term, 0);
-				fprintf(stderr, "%d frames FPS %.2f (abs %.2f)\n", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
-			}
-
-			fprintf(stderr, "**********************************************************\n\n");
-			return;
-		}
-	}
-
-	if (video_odm) {
-		tot_time = v_odi.last_frame_time - v_odi.first_frame_time;
-		if (!tot_time) tot_time=1;
-		if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
-		fprintf(stderr, "%d f FPS %.2f (%.2f ms max) rate %d ", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / tot_time, v_odi.max_dec_time/1000.0, (u32) v_odi.avg_bitrate/1000);
-	}
-	else if (scene_odm) {
-
-		if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
-			avg_dec_time = (Float) 1000000 * s_odi.nb_dec_frames;
-			avg_dec_time /= s_odi.total_dec_time;
-			if (s_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*s_odi.current_time / s_odi.duration ) );
-			fprintf(stderr, "%d f %.2f (%d us max) - rate %d ", s_odi.nb_dec_frames, avg_dec_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000);
-		} else {
-			u32 nb_frames_drawn;
-			Double FPS;
-			gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
-			tot_time = gf_sys_clock() - bench_mode_start;
-			FPS = gf_term_get_framerate(term, 1);
-			fprintf(stderr, "%d f FPS %.2f (abs %.2f) ", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
-		}
-	}
-	else if (audio_odm) {
-		gf_term_get_object_info(term, audio_odm, &a_odi);
-
-		tot_time = a_odi.last_frame_time - a_odi.first_frame_time;
-		if (!tot_time) tot_time=1;
-		if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
-		fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max)", a_odi.nb_dec_frames, ((Float)tot_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0);
-	}
-}
-
-static void PrintWorldInfo(GF_Terminal *term)
-{
-	u32 i;
-	const char *title;
-	GF_List *descs;
-	descs = gf_list_new();
-	title = gf_term_get_world_info(term, NULL, descs);
-	if (!title && !gf_list_count(descs)) {
-		fprintf(stderr, "No World Info available\n");
-	} else {
-		fprintf(stderr, "\t%s\n", title ? title : "No title available");
-		for (i=0; i<gf_list_count(descs); i++) {
-			char *str = gf_list_get(descs, i);
-			fprintf(stderr, "%s\n", str);
-		}
-	}
-	gf_list_del(descs);
-}
-
-static void PrintODList(GF_Terminal *term, GF_ObjectManager *root_odm, u32 num, u32 indent, char *root_name)
-{
-	GF_MediaInfo odi;
-	u32 i, count;
-	char szIndent50;
-
-	if (!root_odm) {
-		fprintf(stderr, "Currently loaded objects:\n");
-		root_odm = gf_term_get_root_object(term);
-	}
-	if (!root_odm) return;
-
-	count = gf_term_get_current_service_id(term);
-	if (count)
-		fprintf(stderr, "Current service ID %d\n", count);
-
-	if (gf_term_get_object_info(term, root_odm, &odi) != GF_OK) return;
-	if (!odi.ODID) {
-		fprintf(stderr, "Service not attached\n");
-		return;
-	}
-
-	for (i=0; i<indent; i++) szIndenti=' ';
-	szIndentindent=0;
-
-	fprintf(stderr, "%s", szIndent);
-	fprintf(stderr, "#%d %s - ", num, root_name);
-	if (odi.ServiceID) fprintf(stderr, "Service ID %d ", odi.ServiceID);
-	if (odi.media_url) {
-		fprintf(stderr, "%s\n", odi.media_url);
-	} else {
-		fprintf(stderr, "OD ID %d\n", odi.ODID);
-	}
-
-	szIndentindent=' ';
-	szIndentindent+1=0;
-	indent++;
-
-	count = gf_term_get_object_count(term, root_odm);
-	for (i=0; i<count; i++) {
-		GF_ObjectManager *odm = gf_term_get_object(term, root_odm, i);
-		if (!odm) break;
-		num++;
-		if (gf_term_get_object_info(term, odm, &odi) == GF_OK) {
-			switch (gf_term_object_subscene_type(term, odm)) {
-			case 1:
-				PrintODList(term, odm, num, indent, "Root");
-				break;
-			case 2:
-				PrintODList(term, odm, num, indent, "Inline Scene");
-				break;
-			case 3:
-				PrintODList(term, odm, num, indent, "EXTERNPROTO Library");
-				break;
-			default:
-				fprintf(stderr, "%s", szIndent);
-				fprintf(stderr, "#%d - ", num);
-				if (odi.media_url) {
-					fprintf(stderr, "%s", odi.media_url);
-				} else if (odi.service_url) {
-					fprintf(stderr, "%s", odi.service_url);
-				} else if (odi.remote_url) {
-					fprintf(stderr, "%s", odi.remote_url);
-				} else {
-					fprintf(stderr, "ID %d", odi.ODID);
-				}
-				fprintf(stderr, " - %s", (odi.od_type==GF_STREAM_VISUAL) ? "Video" : (odi.od_type==GF_STREAM_AUDIO) ? "Audio" : "Systems");
-				if (odi.ServiceID) fprintf(stderr, " - Service ID %d", odi.ServiceID);
-				fprintf(stderr, "\n");
-				break;
-			}
-		}
-	}
-}
-
-static void ViewOD(GF_Terminal *term, u32 OD_ID, u32 number, const char *szURL)
-{
-	GF_MediaInfo odi;
-	u32 i, count, d_enum, id;
-	GF_TermNetStats stats;
-	GF_Err e;
-	GF_ObjectManager *odm, *root_odm = gf_term_get_root_object(term);
-	if (!root_odm) return;
-
-	odm = NULL;
-	if (!szURL && ((!OD_ID && (number == (u32)-1)) || ((OD_ID == (u32)(-1)) && !number))) {
-		odm = root_odm;
-		if ((gf_term_get_object_info(term, odm, &odi) != GF_OK)) odm=NULL;
-	} else {
-		count = gf_term_get_object_count(term, root_odm);
-		for (i=0; i<count; i++) {
-			odm = gf_term_get_object(term, root_odm, i);
-			if (!odm) break;
-			if (gf_term_get_object_info(term, odm, &odi) == GF_OK) {
-				if (szURL && strstr(odi.service_url, szURL)) break;
-				if ((number == (u32)(-1)) && (odi.ODID == OD_ID)) break;
-				else if (i == (u32)(number-1)) break;
-			}
-			odm = NULL;
-		}
-	}
-	if (!odm) {
-		if (szURL) fprintf(stderr, "cannot find OD for URL %s\n", szURL);
-		if (number == (u32)-1) fprintf(stderr, "cannot find OD with ID %d\n", OD_ID);
-		else fprintf(stderr, "cannot find OD with number %d\n", number);
-		return;
-	}
-	if (!odi.ODID) {
-		if (number == (u32)-1) fprintf(stderr, "Object %d not attached yet\n", OD_ID);
-		else fprintf(stderr, "Object #%d not attached yet\n", number);
-		return;
-	}
-
-	fprintf(stderr, "Object Duration: ");
-	if (odi.duration) {
-		PrintTime((u32) (odi.duration*1000));
-	} else {
-		fprintf(stderr, "unknown");
-	}
-	fprintf(stderr, "\n");
-
-	fprintf(stderr, "Service Handler: %s\n", odi.service_handler);
-	fprintf(stderr, "Service URL: %s\n", odi.service_url);
-
-	if (odi.codec_name) {
-		Float avg_dec_time;
-		switch (odi.od_type) {
-		case GF_STREAM_VISUAL:
-			fprintf(stderr, "Video Object: Width %d - Height %d\r\n", odi.width, odi.height);
-			fprintf(stderr, "Media Codec: %s\n", odi.codec_name);
-			if (odi.par) fprintf(stderr, "Pixel Aspect Ratio: %d:%d\n", (odi.par>>16)&0xFF, (odi.par)&0xFF);
-			break;
-		case GF_STREAM_AUDIO:
-			fprintf(stderr, "Audio Object: Sample Rate %d - %d channels\r\n", odi.sample_rate, odi.num_channels);
-			fprintf(stderr, "Media Codec: %s\n", odi.codec_name);
-			break;
-		case GF_STREAM_SCENE:
-		case GF_STREAM_PRIVATE_SCENE:
-			if (odi.width && odi.height) {
-				fprintf(stderr, "Scene Description - Width %d - Height %d\n", odi.width, odi.height);
-			} else {
-				fprintf(stderr, "Scene Description - no size specified\n");
-			}
-			fprintf(stderr, "Scene Codec: %s\n", odi.codec_name);
-			break;
-		case GF_STREAM_TEXT:
-			if (odi.width && odi.height) {
-				fprintf(stderr, "Text Object: Width %d - Height %d\n", odi.width, odi.height);
-			} else {
-				fprintf(stderr, "Text Object: No size specified\n");
-			}
-			fprintf(stderr, "Text Codec %s\n", odi.codec_name);
-			break;
-		}
-
-		avg_dec_time = 0;
-		if (odi.nb_dec_frames) {
-			avg_dec_time = (Float) odi.total_dec_time;
-			avg_dec_time /= odi.nb_dec_frames;
-		}
-		fprintf(stderr, "\tBitrate over last second: %d kbps\n\tMax bitrate over one second: %d kbps\n\tAverage Decoding Time %.2f us %d max)\n\tTotal decoded frames %d\n",
-		 (u32) odi.avg_bitrate/1024, odi.max_bitrate/1024, avg_dec_time, odi.max_dec_time, odi.nb_dec_frames);
-	}
-	if (odi.protection) fprintf(stderr, "Encrypted Media scheme %s\n", gf_4cc_to_str(odi.protection) );
-
-	fprintf(stderr, "\nStream ID %d - %s - Clock ID %d\n", odi.pid_id, gf_stream_type_name(odi.od_type), odi.ocr_id);
-//	if (esd->dependsOnESID) fprintf(stderr, "\tDepends on Stream ID %d for decoding\n", esd->dependsOnESID);
-
-	if (odi.lang_code)
-		fprintf(stderr, "\tStream Language: %s\n", odi.lang_code);
-
-	fprintf(stderr, "\n");
-
-	switch (odi.status) {
-	case 0:
-		fprintf(stderr, "Stopped - ");
-		break;
-	case 1:
-		fprintf(stderr, "Playing - ");
-		break;
-	case 2:
-		fprintf(stderr, "Paused - ");
-		break;
-	case 3:
-		fprintf(stderr, "Not setup yet\n");
-		return;
-	default:
-		fprintf(stderr, "Setup Failed\n");
-		return;
-	}
-	if (odi.buffer>=0) fprintf(stderr, "Buffer: %d ms - ", odi.buffer);
-	else fprintf(stderr, "Not buffering - ");
-	fprintf(stderr, "Clock drift: %d ms\n", odi.clock_drift);
-	if (odi.db_unit_count) fprintf(stderr, "%d AU in DB\n", odi.db_unit_count);
-	if (odi.cb_max_count) fprintf(stderr, "Composition Buffer: %d CU (%d max)\n", odi.cb_unit_count, odi.cb_max_count);
-	fprintf(stderr, "\n");
-
-	if (odi.owns_service) {
-		const char *url;
-		u32 done, total, bps;
-		d_enum = 0;
-		while (gf_term_get_download_info(term, odm, &d_enum, &url, &done, &total, &bps)) {
-			if (d_enum==1) fprintf(stderr, "Current Downloads in service:\n");
-			if (done && total) {
-				fprintf(stderr, "%s: %d / %d bytes (%.2f %%) - %.2f kBps\n", url, done, total, (100.0f*done)/total, ((Float)bps)/1024.0f);
-			} else {
-				fprintf(stderr, "%s: %.2f kbps\n", url, ((Float)8*bps)/1024.0f);
-			}
-		}
-		if (!d_enum) fprintf(stderr, "No Downloads in service\n");
-		fprintf(stderr, "\n");
-	}
-
-	d_enum = 0;
-	while (gf_term_get_channel_net_info(term, odm, &d_enum, &id, &stats, &e)) {
-		if (e) continue;
-		if (!stats.bw_down && !stats.bw_up) continue;
-
-		fprintf(stderr, "Stream ID %d statistics:\n", id);
-		if (stats.multiplex_port) {
-			fprintf(stderr, "\tMultiplex Port %d - multiplex ID %d\n", stats.multiplex_port, stats.port);
-		} else {
-			fprintf(stderr, "\tPort %d\n", stats.port);
-		}
-		fprintf(stderr, "\tPacket Loss Percentage: %.4f\n", stats.pck_loss_percentage);
-		fprintf(stderr, "\tDown Bandwidth: %d bps\n", stats.bw_down);
-		if (stats.bw_up) fprintf(stderr, "\tUp Bandwidth: %d bps\n", stats.bw_up);
-		if (stats.ctrl_port) {
-			if (stats.multiplex_port) {
-				fprintf(stderr, "\tControl Multiplex Port: %d - Control Multiplex ID %d\n", stats.multiplex_port, stats.ctrl_port);
-			} else {
-				fprintf(stderr, "\tControl Port: %d\n", stats.ctrl_port);
-			}
-			fprintf(stderr, "\tDown Bandwidth: %d bps\n", stats.ctrl_bw_down);
-			fprintf(stderr, "\tUp Bandwidth: %d bps\n", stats.ctrl_bw_up);
-		}
-		fprintf(stderr, "\n");
-	}
-}
-
-static void PrintODTiming(GF_Terminal *term, GF_ObjectManager *odm, u32 indent)
-{
-	GF_MediaInfo odi;
-	u32 ind = indent;
-	u32 i, count;
-	if (!odm) return;
-
-	if (gf_term_get_object_info(term, odm, &odi) != GF_OK) return;
-	if (!odi.ODID) {
-		fprintf(stderr, "Service not attached\n");
-		return;
-	}
-	while (ind) {
-		fprintf(stderr, " ");
-		ind--;
-	}
-
-	if (! odi.generated_scene) {
-
-		fprintf(stderr, "- OD %d: ", odi.ODID);
-		switch (odi.status) {
-		case 1:
-			fprintf(stderr, "Playing - ");
-			break;
-		case 2:
-			fprintf(stderr, "Paused - ");
-			break;
-		default:
-			fprintf(stderr, "Stopped - ");
-			break;
-		}
-		if (odi.buffer>=0) fprintf(stderr, "Buffer: %d ms - ", odi.buffer);
-		else fprintf(stderr, "Not buffering - ");
-		fprintf(stderr, "Clock drift: %d ms", odi.clock_drift);
-		fprintf(stderr, " - time: ");
-		PrintTime((u32) (odi.current_time*1000));
-		fprintf(stderr, "\n");
-
-	} else {
-		fprintf(stderr, "+ Service %s:\n", odi.service_url);
-	}
-
-	count = gf_term_get_object_count(term, odm);
-	for (i=0; i<count; i++) {
-		GF_ObjectManager *an_odm = gf_term_get_object(term, odm, i);
-		PrintODTiming(term, an_odm, indent+1);
-	}
-	return;
-
-}
-
-static void PrintODBuffer(GF_Terminal *term, GF_ObjectManager *odm, u32 indent)
-{
-	Float avg_dec_time;
-	GF_MediaInfo odi;
-	u32 ind, i, count;
-	if (!odm) return;
-
-	if (gf_term_get_object_info(term, odm, &odi) != GF_OK) return;
-	if (!odi.ODID) {
-		fprintf(stderr, "Service not attached\n");
-		return;
-	}
-
-	ind = indent;
-	while (ind) {
-		fprintf(stderr, " ");
-		ind--;
-	}
-
-	if (odi.generated_scene) {
-		fprintf(stderr, "+ Service %s:\n", odi.service_url);
-	} else {
-		fprintf(stderr, "- OD %d: ", odi.ODID);
-		switch (odi.status) {
-		case 1:
-			fprintf(stderr, "Playing");
-			break;
-		case 2:
-			fprintf(stderr, "Paused");
-			break;
-		default:
-			fprintf(stderr, "Stopped");
-			break;
-		}
-		if (odi.buffer>=0) fprintf(stderr, " - Buffer: %d ms", odi.buffer);
-		if (odi.db_unit_count) fprintf(stderr, " - DB: %d AU", odi.db_unit_count);
-		if (odi.cb_max_count) fprintf(stderr, " - CB: %d/%d CUs", odi.cb_unit_count, odi.cb_max_count);
-
-		fprintf(stderr, "\n");
-		ind = indent;
-		while (ind) {
-			fprintf(stderr, " ");
-			ind--;
-		}
-
-		fprintf(stderr, " %d decoded frames - %d dropped frames\n", odi.nb_dec_frames, odi.nb_dropped);
-
-		ind = indent;
-		while (ind) {
-			fprintf(stderr, " ");
-			ind--;
-		}
-
-		avg_dec_time = 0;
-		if (odi.nb_dec_frames) {
-			avg_dec_time = (Float) odi.total_dec_time;
-			avg_dec_time /= odi.nb_dec_frames;
-		}
-		fprintf(stderr, " Avg Bitrate %d kbps (%d max) - Avg Decoding Time %.2f us (%d max)\n",
-		 (u32) odi.avg_bitrate/1024, odi.max_bitrate/1024, avg_dec_time, odi.max_dec_time);
-	}
-
-	count = gf_term_get_object_count(term, odm);
-	for (i=0; i<count; i++) {
-		GF_ObjectManager *an_odm = gf_term_get_object(term, odm, i);
-		PrintODBuffer(term, an_odm, indent+1);
-	}
-
-}
-
-static void ViewODs(GF_Terminal *term, Bool show_timing)
-{
-	GF_ObjectManager *root_odm = gf_term_get_root_object(term);
-	if (!root_odm) return;
-
-	if (show_timing) {
-		PrintODTiming(term, root_odm, 0);
-	} else {
-		PrintODBuffer(term, root_odm, 0);
-	}
-	fprintf(stderr, "\n");
-}

gpac-2.0.0.tar.gz/applications/osmo4_android_studio Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/build.gradle Deleted

@@ -1,36 +0,0 @@
-apply plugin: 'com.android.application'
-import org.apache.tools.ant.taskdefs.condition.Os
-
-android {
-    compileSdkVersion 23
-    buildToolsVersion "23.0.3"
-
-    defaultConfig {
-        applicationId "com.gpac.Osmo4"
-        minSdkVersion 16
-        targetSdkVersion 22
-    }
-
-    sourceSets.main {
-        jni.srcDirs =  // This prevents the auto generation of Android.mk
-        jniLibs.srcDir 'src/main/libs' // This is not necessary unless you have precompiled libraries in your project.
-    }
-
-
-
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
-        }
-    }
-}
-
-dependencies {
-    compile files('libs/real3d.jar')
-    compile 'com.android.support:recyclerview-v7:23.1.1'
-    compile 'com.android.support:cardview-v7:23.1.1'
-    compile 'com.android.support:appcompat-v7:23.1.1'
-    compile 'com.android.support:design:23.1.1'
-
-}

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/libs Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/assets Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/java Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/java/com Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/java/com/gpac Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4 Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/GPACInstance.java Deleted

@@ -1,425 +0,0 @@
-/**
- * $URL$
- *
- * $LastChangedBy$ - $LastChangedDate$
- */
-package com.gpac.Osmo4;
-
-import java.io.File;
-import java.io.PrintStream;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-import android.util.Log;
-import android.view.KeyEvent;
-import android.view.MotionEvent;
-
-/**
- * @version $Revision$
- *
- */
-public class GPACInstance implements GPACInstanceInterface {
-
- private final static String LOG_LIB = "LibrariesLoader"; //$NON-NLS-1$
-
- private final Thread uniqueThread;
-
- /**
- *
- * a recursive method to get the directory hierarchy under root.
- *
- * @param sb StringBuilder object which will return the final hierarchy
- * @param root root of the hierarchy
- * @param inc initial number of spaces.
- */
- private static void listing(StringBuilder sb, File root, int inc) {
- StringBuilder increment = new StringBuilder();
- for (int i = 0; i < inc; i++)
- increment.append(' ');
- String incr = increment.toString();
- for (File f : root.listFiles()) {
- sb.append(incr).append(f.getName());
- if (f.isDirectory()) {
- sb.append(" Directory\n"); //$NON-NLS-1$
- listing(sb, f, inc + 2);
- } else {
- sb.append(" ").append(f.length() + " bytes\n"); //$NON-NLS-1$//$NON-NLS-2$
- }
- }
- }
-
- /**
- * Loads all libraries
- *
- * @param config
- *
- * @return a map of exceptions containing the library as key and the exception as value. If map is empty, no error
- *
- */
-
-
- synchronized static Map<String, Throwable> loadAllLibraries(GpacConfig config) {
- if (errors != null)
- return errors;
- StringBuilder sb = new StringBuilder();
- final String toLoad = { "GLESv2", "log",//$NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-1$
- "jpegdroid", "javaenv", //$NON-NLS-1$ //$NON-NLS-2$
- "mad", "ft2", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
- "openjpeg", "png", "z", //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ //$NON-NLS-4$
- "stlport_shared", "stdc++", "faad", //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
- "avutil", "swscale", "swresample", "avcodec", "avformat", "avfilter", "avdevice",
- "gpacWrapper", "gpac",
- "gm_droid_mpegv" }; // //$NON-NLS-1$ //$NON-NLS-2$
- HashMap<String, Throwable> exceptions = new HashMap<String, Throwable>();
- for (String s : toLoad) {
- try {
- String msg = "Loading library " + s + "...";//$NON-NLS-1$//$NON-NLS-2$
- sb.append(msg);
- Log.i(LOG_LIB, msg);
- System.loadLibrary(s);
- } catch (UnsatisfiedLinkError e) {
- sb.append("Failed to load " + s + ", error=" + e.getLocalizedMessage() + " :: " //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
- + e.getClass().getSimpleName() + "\n"); //$NON-NLS-1$
- exceptions.put(s, e);
- Log.e(LOG_LIB, "Failed to load library : " + s + " due to link error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
- } catch (SecurityException e) {
- exceptions.put(s, e);
- Log.e(LOG_LIB, "Failed to load library : " + s + " due to security error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
- } catch (Throwable e) {
- exceptions.put(s, e);
- Log.e(LOG_LIB, "Failed to load library : " + s + " due to Runtime error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
- }
- }
-
- if (!exceptions.isEmpty()) {
- try {
- PrintStream out = new PrintStream(config.getGpacLogDirectory() + "debug_libs.txt", "UTF-8"); //$NON-NLS-1$//$NON-NLS-2$
- out.println("$Revision$"); //$NON-NLS-1$
- out.println(new Date());
- out.println("\n*** Configuration\n"); //$NON-NLS-1$
- out.println(config.getConfigAsText());
- sb.append("*** Libs listing: "); //$NON-NLS-1$
- sb.append(config.getGpacLibsDirectory());
- sb.append('\n');
- listing(sb, new File(config.getGpacLibsDirectory()), 2);
- sb.append("*** Modules listing: "); //$NON-NLS-1$
- sb.append(config.getGpacModulesDirectory());
- sb.append('\n');
- listing(sb, new File(config.getGpacModulesDirectory()), 2);
- sb.append("*** Fonts listing: \n"); //$NON-NLS-1$
- sb.append(config.getGpacFontDirectory());
- sb.append('\n');
- listing(sb, new File(config.getGpacFontDirectory()), 2);
- sb.append("*** Exceptions:\n"); //$NON-NLS-1$
- for (Map.Entry<String, Throwable> ex : exceptions.entrySet()) {
- sb.append(ex.getKey()).append(": ") //$NON-NLS-1$
- .append(ex.getValue().getLocalizedMessage())
- .append('(')
- .append(ex.getValue().getClass())
- .append(")\n"); //$NON-NLS-1$
- }
- out.println(sb.toString());
- out.flush();
- out.close();
- } catch (Exception e) {
- Log.e(LOG_LIB, "Failed to output debug info to debug file", e); //$NON-NLS-1$
- }
- }
- errors = Collections.unmodifiableMap(exceptions);
- return errors;
- }
-
- private static Map<String, Throwable> errors = null;
-
- private boolean hasToBeFreed = true;
-
- /**
- * Constructor
- *
- * @param callback
- * @param width
- * @param height
- * @param config The configuration to use for GPAC
- * @param urlToOpen
- * @throws GpacInstanceException
- */
- public GPACInstance(GpacCallback callback, int width, int height, GpacConfig config, String urlToOpen)
- throws GpacInstanceException {
- StringBuilder sb = new StringBuilder();
- Map<String, Throwable> errors = loadAllLibraries(config);
- if (!errors.isEmpty()) {
- sb.append("Exceptions while loading libraries:"); //$NON-NLS-1$
- for (Map.Entry<String, Throwable> x : errors.entrySet()) {
- sb.append('\n')
- .append(x.getKey())
- .append('')
- .append(x.getValue().getClass().getSimpleName())
- .append(": ") //$NON-NLS-1$
- .append(x.getValue().getLocalizedMessage());
- }
- Log.e(LOG_LIB, sb.toString());
- }
- try {
- handle = createInstance(callback,
- width,
- height,
- config.getGpacConfigDirectory(),
- config.getGpacModulesDirectory(),
- config.getGpacCacheDirectory(),
- config.getGpacFontDirectory(),
- config.getGpacGuiDirectory(),
- urlToOpen);
- } catch (Throwable e) {
- throw new GpacInstanceException("Error while creating instance\n" + sb.toString()); //$NON-NLS-1$
- }
- if (handle == 0) {
- throw new GpacInstanceException("Error while creating instance, no handle created!\n" + sb.toString()); //$NON-NLS-1$
- }
- synchronized (this) {
- hasToBeFreed = true;
- }
- uniqueThread = Thread.currentThread();
- }
-
- /**
- * This one handles the pointer to the real C object
- */
- private final long handle;
-
- /**
- * @return the handle
- */
- public synchronized long getHandle() {
- return handle;
- }
-
- private void checkCurrentThread() throws RuntimeException {
- if (Thread.currentThread() != uniqueThread)
- throw new RuntimeException("Method called outside allowed Thread scope !"); //$NON-NLS-1$
- }
-
- @Override
- public void disconnect() {
- checkCurrentThread();
- gpacrender();
- gpacdisconnect();
- }
-
- @Override
- public void connect(String url) {
- Log.i(LOG_LIB, "connect(" + url + ")"); //$NON-NLS-1$ //$NON-NLS-2$
- checkCurrentThread();
- gpacrender();
- gpacconnect(url);
- }
-
- /**
- * Call this method when a key has been pressed
- *
- * @param keyCode
- * @param event
- * @param pressed true if key is pressed, false if key is released
- * @param unicode
- */
- public void eventKey(int keyCode, KeyEvent event, boolean pressed, int unicode) {
- checkCurrentThread();
- gpaceventkeypress(keyCode, event.getScanCode(), pressed ? 1 : 0, event.getFlags(), unicode);
- }
-
- /**
- * Renders the current frame
- */
- public void render() {
- checkCurrentThread();
- gpacrender();
- }
-
- /**
- * Resizes the object to new dimensions
- *
- * @param width
- * @param height
- */
- public void resize(int width, int height) {
- Log.i(LOG_LIB, "Resizing to " + width + "x" + height); //$NON-NLS-1$ //$NON-NLS-2$
- gpacresize(width, height);
- }
-
- private boolean touched = false;
-
- /**
- * Call this when a motion event occurs
- *
- * @param event
- */
- public void motionEvent(MotionEvent event) {
- checkCurrentThread();
- final float x = event.getX();
- final float y = event.getY();
- switch (event.getAction()) {
- // not in 1.6 case MotionEvent.ACTION_POINTER_1_DOWN:
- case MotionEvent.ACTION_DOWN:
- gpaceventmousemove(x, y);
- gpaceventmousedown(x, y);
- touched = true;
- break;
- // not in 1.6 case MotionEvent.ACTION_POINTER_1_UP:
- case MotionEvent.ACTION_UP:
- 	if ( !touched )
- 		break;
- 	gpaceventmouseup(x, y);
- touched = false;
- break;
- case MotionEvent.ACTION_MOVE:
- 	gpaceventmousemove(x, y);
- 	if ( !touched ) {
- 		touched = true;
- 		//Log.i("Osmo4", "Mouse down: " + x +"," + y);
- 		gpaceventmousedown(x, y);
- 	}
- 	break;
- case MotionEvent.ACTION_CANCEL:
- 	if ( !touched )
- 		break;
- 	//Log.i("Osmo4", "Mouse up: " + x +"," + y);
- gpaceventmouseup(x, y);
- touched = false;
- break;
- }
- }
-
- @Override
- public void finalize() throws Throwable {
- // Not sure how to do this..., destroy is supposed to be called already
- // destroy();
- super.finalize();
- }
-
- /**
- * All Native functions, those functions are binded using the handle
- */
-
- /**
- * Opens an URL
- *
- * @param url The URL to open
- */
- private native void gpacconnect(String url);
-
- /**
- * Used to create the GPAC instance
- *
- * @param callback
- * @param width
- * @param height
- * @param cfg_dir
- * @param modules_dir
- * @param cache_dir
- * @param font_dir
- * @param gui_dir
- * @return
- */
- private native long createInstance(GpacCallback callback, int width, int height, String cfg_dir,
- String modules_dir, String cache_dir, String font_dir, String gui_dir, String url_to_open);
-
- /**
- * Disconnects the currently loaded URL
- */
- private native void gpacdisconnect();
-
- /**
- * Renders
- *
- * @param handle
- */
- private native void gpacrender();
-
- /**
- * Resizes the current view
- *
- * @param width The new width to set
- * @param height The new height to set
- */
- private native void gpacresize(int width, int height);
-
- /**
- * Free all GPAC resources
- */
- private native void gpacfree();
-
- /**
- * To call when a key has been pressed
- *
- * @param keycode
- * @param rawkeycode
- * @param up
- * @param flag
- */
- private native void gpaceventkeypress(int keycode, int rawkeycode, int up, int flag, int unicode);
-
- /**
- * To call when a mouse is down
- *
- * @param x Position in pixels
- * @param y Position in pixels
- */
- private native void gpaceventmousedown(float x, float y);
-
- /**
- * To call when a mouse is up (released)
- *
- * @param x Position in pixels
- * @param y Position in pixels
- */
- private native void gpaceventmouseup(float x, float y);
-
- /**
- * To call when a mouse is moving
- *
- * @param x Position in pixels
- * @param y Position in pixels
- */
- private native void gpaceventmousemove(float x, float y);
-
- /**
- * To call when a change in orientation is returned from the sensors
- * All angles are in RADIANS and positive in the COUNTER-CLOCKWISE direction
- *
- * @param x yaw (rotation around the -Z axis) range: -PI, PI
- * @param y pitch (rotation around the -X axis) range: -PI/2, PI/2
- * @param z roll (rotation around the Y axis) range: -PI, PI
- */
- private native void gpaceventorientationchange(float x, float y, float z);
-
- public void onOrientationChange(float yaw, float pitch, float roll){
- gpaceventorientationchange(yaw, pitch, roll);
- }
-
- @Override
- public void destroy() {
- boolean freeIt;
- synchronized (this) {
- freeIt = hasToBeFreed;
- hasToBeFreed = false;
- }
- if (freeIt) {
- disconnect();
- gpacfree();
- }
- }
-
- /**
- * @see com.gpac.Osmo4.GPACInstanceInterface#setGpacPreference(String, String, String)
- */
- @Override
- public native void setGpacPreference(String category, String name, String value);
-
-
-
- /**
- * @see com.gpac.Osmo4.GPACInstanceInterface#setGpacLogs(String)
- */
- @Override
- public native void setGpacLogs(String tools_at_levels);
-}

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/logs Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/jni Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/drawable Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/drawable-hdpi Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/drawable-ldpi Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/drawable-mdpi Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/layout Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/layout/auth_requested.xml Deleted

@@ -1,92 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
- android:layout_width="fill_parent"
- android:layout_height="fill_parent">
-
- <LinearLayout
- android:id="@+id/verticalLayout"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:orientation="vertical">
-
- <TableLayout
- android:id="@+id/usernameAndPasswordLayout"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content">
-
- <TableRow
- android:id="@+id/tableRow1"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:layout_gravity="fill_horizontal"
- android:baselineAligned="true">
-
- <TextView
- android:id="@+id/userNameLabel"
- android:layout_width="wrap_content"
- android:layout_height="fill_parent"
- android:layout_gravity="right"
- android:text="@string/usernameLabel" />
-
- <EditText
- android:id="@+id/userNamePrompt"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:layout_weight="2"
- android:gravity="fill_horizontal|right"
- android:hint="@string/usernameHint"
- android:inputType="textUri"
- android:text="" />
- </TableRow>
-
- <TableRow
- android:id="@+id/tableRow2"
- android:layout_height="wrap_content"
- android:layout_gravity="fill_horizontal"
- android:gravity="fill_horizontal">
-
- <TextView
- android:id="@+id/passwordLabel"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:layout_gravity="right"
- android:layout_weight="0"
- android:baselineAligned="true"
- android:text="@string/passwordLabel" />
-
- <EditText
- android:id="@+id/passwordPrompt"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:layout_gravity="fill_horizontal"
- android:layout_weight="2"
- android:gravity="fill_horizontal|right"
- android:hint="@string/passwordHint"
- android:inputType="textPassword"
- android:text="" />
- </TableRow>
- </TableLayout>
-
- <LinearLayout
- android:id="@+id/linearLayout1"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content">
-
- <Button
- android:id="@+id/button1"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="Button" />
-
- <Button
- android:id="@+id/button2"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="Button" />
-
-
- </LinearLayout>
- </LinearLayout>
-
-
-</FrameLayout>

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/menu Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/values Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/app/src/main/res/xml Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/gradle Deleted

gpac-2.0.0.tar.gz/applications/osmo4_android_studio/gradle/wrapper Deleted

gpac-2.0.0.tar.gz/applications/osmo4_ios Deleted

gpac-2.0.0.tar.gz/applications/osmo4_ios/Resources Deleted

gpac-2.0.0.tar.gz/applications/osmo4_ios/main.c Deleted

@@ -1,841 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre, Romain Bouqueau
- *			Copyright (c) Telecom ParisTech 2000-2012
- *					All rights reserved
- *
- * This file is part of GPAC / command-line client
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-/*includes both terminal and od browser*/
-#include <gpac/terminal.h>
-#include <gpac/term_info.h>
-#include <gpac/constants.h>
-#include <gpac/options.h>
-#include <gpac/events.h>
-
-#include <pwd.h>
-#include <unistd.h>
-
-#include "sensors_def.h"
-
-void PrintAVInfo(Bool final);
-
-static Bool restart = 0;
-static Bool not_threaded = 1;
-
-static Bool no_audio = 0;
-Bool is_connected = 0;
-Bool startup_file = 0;
-GF_User user;
-GF_Terminal *term;
-u64 Duration;
-GF_Err last_error = GF_OK;
-
-static u32 display_rti = 0;
-static Bool Run;
-static Bool CanSeek = 0;
-static char the_urlGF_MAX_PATH;
-static Bool no_mime_check = 1;
-static Bool be_quiet = 0;
-static u32 log_time_start = 0;
-
-static u32 forced_width=0;
-static u32 forced_height=0;
-static u32 bench_mode = 0;
-static u32 bench_mode_start = 0;
-static u32 paused_by_bench = 0;
-
-/*windowless options*/
-u32 align_mode = 0;
-u32 init_w = 0;
-u32 init_h = 0;
-u32 last_x, last_y;
-Bool right_down = 0;
-
-static u32 rti_update_time_ms = 200;
-static FILE *rti_logs = NULL;
-static u64 memory_at_gpac_startup = 0;
-
-static void UpdateRTInfo(const char *legend)
-{
-	GF_SystemRTInfo rti;
-	if (paused_by_bench==1) return;
-
-	/*refresh every second*/
-	if (!display_rti && !rti_logs) return;
-	if (!gf_sys_get_rti(rti_update_time_ms, &rti, 0) && !legend)
-		return;
-
-	if (display_rti) {
-		if (display_rti==2) {
-			char szMsg1024;
-
-			if (rti.total_cpu_usage && (bench_mode<2) ) {
-				sprintf(szMsg, "FPS %02.02f CPU %2d (%02d) Mem %d kB",
-			 gf_term_get_framerate(term, 0), rti.total_cpu_usage, rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024));
-			} else {
-				sprintf(szMsg, "FPS %02.02f CPU %02d Mem %d kB",
-			 gf_term_get_framerate(term, 0), rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024) );
-			}
-
-			PrintAVInfo(GF_FALSE);
-
-
-			fprintf(stderr, "%s\r", szMsg);
-		} else {
-			if (!rti.process_memory) rti.process_memory = (u32) (memory_at_gpac_startup-rti.physical_memory_avail);
-
-			if (!rti.gpac_memory) rti.gpac_memory = (u32) (memory_at_gpac_startup-rti.physical_memory_avail);
-		}
-
-	}
-	if (rti_logs) {
-		fprintf(rti_logs, "% 8d\t% 8d\t% 8d\t% 4d\t% 8d\t%s",
-		 gf_sys_clock(),
-		 gf_term_get_time_in_ms(term),
-		 rti.total_cpu_usage,
-		 (u32) gf_term_get_framerate(term, 0),
-		 (u32) (rti.gpac_memory / 1024),
-		 legend ? legend : ""
-		 );
-		if (!legend) fprintf(rti_logs, "\n");
-	}
-}
-
-static void ResetCaption()
-{
-	GF_Event event;
-	if (display_rti) return;
-	memset(&event, 0, sizeof(GF_Event));
-
-	event.type = GF_EVENT_SET_CAPTION;
-	if (is_connected) {
-#ifdef FILTER_FIXME
-		char szName1024;
-		NetInfoCommand com;
-
-		event.caption.caption = NULL;
-		/*get any service info*/
-		if (!startup_file && gf_term_get_service_info(term, gf_term_get_root_object(term), &com) == GF_OK) {
-			strcpy(szName, "");
-			if (com.track_info) {
-				char szBuf10;
-				sprintf(szBuf, "%02d ", (u32) (com.track_info>>16) );
-				strcat(szName, szBuf);
-			}
-			if (com.artist) {
-				strcat(szName, com.artist);
-				strcat(szName, " ");
-			}
-			if (com.name) {
-				strcat(szName, com.name);
-				strcat(szName, " ");
-			}
-			if (com.album) {
-				strcat(szName, "(");
-				strcat(szName, com.album);
-				strcat(szName, ")");
-			}
-
-			if (strlen(szName)) event.caption.caption = szName;
-		}
-		if (!event.caption.caption) {
-			char *str = strrchr(the_url, '\\');
-			if (!str) str = strrchr(the_url, '/');
-			event.caption.caption = str ? str+1 : the_url;
-		}
-#endif
-
-	} else {
-		event.caption.caption = "GPAC MP4Client " GPAC_VERSION;
-	}
-	gf_term_user_event(term, &event);
-}
-
-#ifdef WIN32
-u32 get_sys_col(int idx)
-{
-	u32 res;
-	DWORD val = GetSysColor(idx);
-	res = (val)&0xFF;
-	res<<=8;
-	res |= (val>>8)&0xFF;
-	res<<=8;
-	res |= (val>>16)&0xFF;
-	return res;
-}
-#endif
-
-
-void *gyro_dev = NULL;
-
-void ios_sensor_callback(int sensorType, float x, float y, float z, float w)
-{
-	GF_Event evt;
-	memset(&evt, 0, sizeof(GF_Event));
-
-	switch (sensorType) {
-	case SENSOR_ORIENTATION:
-		evt.type = GF_EVENT_SENSOR_ORIENTATION;
-		evt.sensor.x = x;
-		evt.sensor.y = y;
-		evt.sensor.z = z;
-		evt.sensor.w = w;
-		gf_term_user_event(term, &evt);
-		return;
-	default:
-		return;
-	}
-}
-
-static s32 request_next_playlist_item = GF_FALSE;
-FILE *playlist = NULL;
-
-Bool GPAC_EventProc(void *ptr, GF_Event *evt)
-{
-	if (!term) return 0;
-
-	switch (evt->type) {
-	case GF_EVENT_DURATION:
-		Duration = 1000;
-		Duration = (u64) (((s64) Duration) * evt->duration.duration);
-		CanSeek = evt->duration.can_seek;
-		break;
-	case GF_EVENT_MESSAGE:
-	{
-		const char *servName;
-		if (!evt->message.service || !strcmp(evt->message.service, the_url)) {
-			servName = "main service";
-		} else if (!strnicmp(evt->message.service, "data:", 5)) {
-			servName = "";
-		} else {
-			servName = evt->message.service;
-		}
-		if (!evt->message.message) return 0;
-		if (evt->message.error) {
-			if (!is_connected) last_error = evt->message.error;
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s (%s): %s\n", evt->message.message, servName, gf_error_to_string(evt->message.error) ));
-		} else if (!be_quiet) {
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("(%s) %s\r", servName, evt->message.message ));
-		}
-	}
-	break;
-	case GF_EVENT_PROGRESS:
-		if (bench_mode && (evt->progress.progress_type==1) ) {
-
-			fprintf(stderr, "Bench mode paused - downloading %02d %%\r", (u32) (evt->progress.done*100.0/evt->progress.total) );
-			if (!paused_by_bench) {
-				gf_term_set_option(term, GF_OPT_VIDEO_BENCH, 0);
-				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PAUSED);
-				paused_by_bench=1;
-			} else if (evt->progress.done == evt->progress.total) {
-				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PLAYING);
-				gf_term_set_option(term, GF_OPT_VIDEO_BENCH, (bench_mode==3) ? 2 : 1);
-				bench_mode_start = gf_sys_clock();
-				paused_by_bench=2;
-			}
-		}
-		break;
-
-	case GF_EVENT_CONNECT:
-		if (evt->connect.is_connected) {
-			is_connected = 1;
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Service Connected\n"));
-		} else if (is_connected) {
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Service %s\n", is_connected ? "Disconnected" : "Connection Failed"));
-			is_connected = 0;
-			Duration = 0;
-		}
-		if (init_w && init_h) {
-			gf_term_set_size(term, init_w, init_h);
-		}
-		ResetCaption();
-		break;
-
-	case GF_EVENT_QUIT:
-		Run = 0;
-		break;
-	case GF_EVENT_DISCONNECT:
-		gf_term_disconnect(term);
-		break;
-
-	case GF_EVENT_NAVIGATE:
-		if (gf_term_is_supported_url(term, evt->navigate.to_url, 1, no_mime_check)) {
-			strcpy(the_url, evt->navigate.to_url);
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Navigating to URL %s\n", the_url));
-			gf_term_navigate_to(term, evt->navigate.to_url);
-			return 1;
-		} else {
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Navigation destination not supported\nGo to URL: %s\n", evt->navigate.to_url ));
-		}
-		break;
-	case GF_EVENT_DBLCLICK:
-		if (playlist) {
-			request_next_playlist_item=GF_TRUE;
-		}
-		break;
-	case GF_EVENT_SENSOR_REQUEST:
-		if (evt->activate_sensor.sensor_type==GF_EVENT_SENSOR_ORIENTATION) {
-			if (!gyro_dev) {
-				gyro_dev = sensor_create(SENSOR_ORIENTATION, ios_sensor_callback);
-				if (!gyro_dev)
-					return GF_FALSE;
-			}
-			if (evt->activate_sensor.activate) {
-				/*start sensors*/
-				sensor_start(gyro_dev);
-			} else if (gyro_dev) {
-				sensor_stop(gyro_dev);
-			}
-			return GF_TRUE;
-		}
-		return GF_FALSE;
-	}
-	return 0;
-}
-
-
-static void on_gpac_log(void *cbk, GF_LOG_Level ll, GF_LOG_Tool lm, const char *fmt, va_list list)
-{
-	FILE *logs = cbk;
-
-	if (rti_logs && (lm & GF_LOG_RTI)) {
-		char szMsg2048;
-		vsnprintf(szMsg, 2048, fmt, list);
-		UpdateRTInfo(szMsg + 6 /*"RTI "*/);
-	} else {
-		if (log_time_start) fprintf(logs, "At %d", gf_sys_clock() - log_time_start);
-		vfprintf(logs, fmt, list);
-		fflush(logs);
-	}
-}
-
-void set_cfg_option(char *opt_string)
-{
-	char *sep, *sep2, szSec1024, szKey1024, szVal1024;
-	sep = strchr(opt_string, ':');
-	if (!sep) {
-		fprintf(stderr, "Badly formatted option %s - expected Section:Name=Value\n", opt_string);
-		return;
-	}
-	{
-		const size_t sepIdx = sep - opt_string;
-		strncpy(szSec, opt_string, sepIdx);
-		szSecsepIdx = 0;
-	}
-	sep ++;
-	sep2 = strchr(sep, '=');
-	if (!sep2) {
-		fprintf(stderr, "Badly formatted option %s - expected Section:Name=Value\n", opt_string);
-		return;
-	}
-	{
-		const size_t sepIdx = sep2 - sep;
-		strncpy(szKey, sep, sepIdx);
-		szKeysepIdx = 0;
-		strcpy(szVal, sep2+1);
-	}
-
-	if (!stricmp(szKey, "*")) {
-		if (stricmp(szVal, "null")) {
-			fprintf(stderr, "Badly formatted option %s - expected Section:*=null\n", opt_string);
-			return;
-		}
-		gf_opts_del_section(szSec);
-		return;
-	}
-
-	if (!stricmp(szVal, "null")) {
-		szVal0=0;
-	}
-	gf_opts_set_key(szSec, szKey, szVal0 ? szVal : NULL);
-}
-
-
-static void on_progress_null(const void *_ptr, const char *_title, u64 done, u64 total)
-{
-}
-#ifdef GPAC_CONFIG_IOS
-int SDL_main (int argc, char *argv)
-#else
-int main (int argc, char *argv)
-#endif
-{
-	const char *str;
-	char *ext;
-	u32 i;
-	u32 url_idx_plus_1 = 0;
-	u32 simulation_time = 0;
-	Bool auto_exit = 0;
-	Bool use_gui = 0;
- GF_MemTrackerType mem_track = GF_MemTrackerNone;
-	Bool logs_set = GF_FALSE;
-	char *url_arg, *the_cfg;
-	const char *logs_settings = NULL;
-	GF_SystemRTInfo rti;
-	FILE *logfile = NULL;
-	/*by default use current dir*/
-	strcpy(the_url, ".");
-
-	memset(&user, 0, sizeof(GF_User));
-
-	url_arg = the_cfg = NULL;
-
-#ifdef GPAC_MEMORY_TRACKING
-	for (i=1; i<argc; i++) {
-		char *arg = argvi;
-		if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
- mem_track = !strcmp(arg, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
-		}
-	}
-#endif
-
-	gf_sys_init(mem_track, NULL);
-	gf_set_progress_callback(NULL, on_progress_null);
- 
-	for (i=1; i<argc; i++) {
-		char *arg = argvi;
-		if (arg0 != '-') {
-			url_arg = arg;
-			url_idx_plus_1 = i+1;
-		}
-		else if (!strcmp(arg, "-logs")) {
-			logs_settings = argvi+1;
-			i++;
-		}
-		else if (!strcmp(arg, "-lf")) {
-			logfile = gf_fopen(argvi+1, "wt");
-			gf_log_set_callback(logfile, on_gpac_log);
-			i++;
-		}
-#ifndef GPAC_MEMORY_TRACKING
-		else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
-			fprintf(stderr, "WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", arg);
-		}
-#endif
-		else if (!strcmp(arg, "-no-audio")) no_audio = GF_TRUE;
-		else if (!strcmp(arg, "-bench")) bench_mode = 1;
-		else if (!strcmp(arg, "-vbench")) bench_mode = 2;
-		else if (!strcmp(arg, "-sbench")) bench_mode = 3;
-		else if (!strcmp(arg, "-gui") || !strcmp(arg, "-guid")) use_gui = 1;
-		else if (!strcmp(arg, "-opt")) {
-			set_cfg_option(argvi+1);
-			i++;
-		}
-		else if (!strcmp(arg, "-run-for")) {
-			simulation_time = atoi(argvi+1);
-			i++;
-		}
- 	}
-
-	if (logs_settings) {
-		if (gf_log_set_tools_levels(logs_settings, GF_TRUE) != GF_OK) {
-			return 1;
-		}
-		logs_set = GF_TRUE;
-	}
-
-	if (!logs_set)
-		gf_log_set_tools_levels( gf_opts_get_key("core", "logs"), GF_TRUE);
-
-	gf_opts_set_key("filter@compositor", "ogl", "hybrid");
-
-	if (!logfile) {
-		const char *opt = gf_opts_get_key("core", "log-file");
-		if (opt) {
-			logfile = gf_fopen(opt, "wt");
-			if (logfile)
-				gf_log_set_callback(logfile, on_gpac_log);
-		}
-	}
-
-	gf_sys_get_rti(500, &rti, GF_RTI_SYSTEM_MEMORY_ONLY);
-	memory_at_gpac_startup = rti.physical_memory_avail;
-
-	init_w = forced_width;
-	init_h = forced_height;
-/*
-	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Loading modules\n" ));
-	str = gf_opts_get_key("core", "mod-dirs");
-
-	user.modules = gf_modules_new((const char *) str, cfg_file);
-	if (user.modules) i = gf_modules_get_count(user.modules);
-	if (!i || !user.modules) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Error: no modules found in %s - exiting\n", str));
-		if (user.modules) gf_modules_del(user.modules);
-		gf_cfg_del(cfg_file);
-		gf_sys_close();
-		if (logfile) gf_fclose(logfile);
-		return 1;
-	}
-	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Modules Loaded (%d found in %s)\n", i, str));
-*/
-//	url_arg="$IOS_DOCS/NBA_score_table_2_hd.mp4#LIVE360TV";
-
-	if (url_arg && !strncmp(url_arg, "$IOS_DOCS", 9)) {
-		char *path = (char *) gf_opts_get_key("General", "iOSDocumentsDir");
-		if (path) {
-			strcpy(the_url, path);
-			path = strchr(url_arg, '/');
-			if (path) {
-				strcat(the_url, path+1);
-				url_arg = the_url;
-				argvurl_idx_plus_1 - 1 = url_arg;
-			}
-		}
-	}
-	gf_sys_set_args(argc, (const char **) argv);
-
-	user.EventProc = GPAC_EventProc;
-	/*dummy in this case (global vars) but MUST be non-NULL*/
-	//user.opaque = user.modules;
-	if (no_audio) user.init_flags |= GF_TERM_NO_AUDIO;
-
-	if (bench_mode) {
-		//gf_cfg_discard_changes(user.config);
-		auto_exit = GF_TRUE;
-		if (bench_mode!=2) {
-			gf_opts_set_key("filter@compositor", "ogl", "off");
-		} else {
-			gf_opts_set_key("core", "disable-vsync", "yes");
-		}
-	}
-
-
-	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Loading GPAC Terminal\n"));
-	term = gf_term_new(&user);
-	if (!term) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("\nInit error - check you have at least one video out and one rasterizer...\nFound modules:\n"));
-		//gf_modules_del(user.modules);
-		//gf_cfg_del(cfg_file);
-		gf_sys_close();
-		if (logfile) gf_fclose(logfile);
-		return 1;
-	}
-	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Terminal Loaded\n"));
-
-	if (bench_mode) {
-		display_rti = 2;
-		gf_term_set_option(term, GF_OPT_VIDEO_BENCH, (bench_mode==3) ? 2 : 1);
-		if (bench_mode==1) bench_mode=2;
-	}
-
-	/*check audio output*/
-	str = gf_opts_get_key("core", "audio-output");
-	if (!str || !strcmp(str, "No Audio Output Available")) {
-		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("WARNING: no audio output availble - make sure no other program is locking the sound card\n"));
-	}
-	str = gf_opts_get_key("General", "NoMIMETypeFetch");
-	no_mime_check = (str && !stricmp(str, "yes")) ? 1 : 0;
-
-	str = gf_opts_get_key("core", "proxy-on");
-	if (str && !strcmp(str, "yes")) {
-		str = gf_opts_get_key("core", "proxy-name");
-		if (str) GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("HTTP Proxy %s enabled\n", str));
-	}
-
-	Run = 1;
-
-	ext = url_arg ? strrchr(url_arg, '.') : NULL;
-	if (ext && (!stricmp(ext, ".m3u") || !stricmp(ext, ".pls"))) {
-		char pl_pathGF_MAX_PATH;
-		GF_Err e = GF_OK;
-		fprintf(stderr, "Opening Playlist %s\n", url_arg);
-
-		strcpy(pl_path, url_arg);
-		/*this is not clean, we need to have a plugin handle playlist for ourselves*/
-		if (!strncmp("http:", url_arg, 5)) {
-#ifdef FILTER_FIXME
-			GF_DownloadSession *sess = gf_dm_sess_new(term->downloader, url_arg, GF_NETIO_SESSION_NOT_THREADED, NULL, NULL, &e);
-			if (sess) {
-				e = gf_dm_sess_process(sess);
-				if (!e) strcpy(pl_path, gf_dm_sess_get_cache_name(sess));
-				gf_dm_sess_del(sess);
-			}
-#endif
-
-		}
-
-		playlist = e ? NULL : gf_fopen(pl_path, "rt");
-		if (playlist) {
-			request_next_playlist_item = GF_TRUE;
-		} else {
-			if (e)
-				fprintf(stderr, "Failed to open playlist %s: %s\n", url_arg, gf_error_to_string(e) );
-
-			fprintf(stderr, "Hit 'h' for help\n\n");
-		}
-	} else if (!use_gui && url_arg) {
-		gf_term_connect(term, url_arg);
-	} else {
-		str = gf_opts_get_key("General", "StartupFile");
-		if (str) {
-			if (!url_arg) {
-				sprintf(the_url, "MP4Client %s", gf_gpac_version() );
-			}
-			gf_term_connect(term, str);
-			startup_file = 1;
-		}
-	}
-
-	/*force fullscreen*/
-	gf_term_set_option(term, GF_OPT_FULLSCREEN, 1);
-
-	if (bench_mode) {
-		rti_update_time_ms = 500;
-		bench_mode_start = gf_sys_clock();
-	}
-
-	while (Run) {
-		if (restart) {
-			restart = 0;
-			gf_term_play_from_time(term, 0, 0);
-		}
-
-		if (request_next_playlist_item) {
-			char szPathGF_MAX_PATH;
-
-			request_next_playlist_item=0;
-			gf_term_disconnect(term);
-
-			if (fscanf(playlist, "%1023s", szPath) == EOF) {
-				fprintf(stderr, "No more items - exiting\n");
-				Run = 0;
-			} else if (szPath0 == '#') {
-				request_next_playlist_item = GF_TRUE;
-			} else {
-				fprintf(stderr, "Opening URL %s\n", szPath);
-				gf_term_connect_with_path(term, szPath, url_arg);
-			}
-		}
-
-		if (display_rti) UpdateRTInfo(NULL);
-		if (not_threaded) {
-			//printf("gf_term_process_step from run loop\n");
-			gf_term_process_step(term);
-			if (auto_exit && gf_term_get_option(term, GF_OPT_IS_OVER)) {
-				Run = 0;
-			}
-		} else {
-			gf_sleep(rti_update_time_ms);
-		}
-		/*sim time*/
-		if (simulation_time && (gf_term_get_time_in_ms(term)>simulation_time)) {
-			Run = 0;
-		}
-	}
-
-	if (bench_mode) {
-		PrintAVInfo(GF_TRUE);
-	}
-
-	gf_term_disconnect(term);
-
-	if (gyro_dev) {
-		sensor_stop(gyro_dev);
-	}
-
-	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Deleting terminal... "));
-	gf_term_del(term);
-	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("OK\n"));
-
-	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("GPAC cleanup ...\n"));
-	//gf_modules_del(user.modules);
-	//gf_cfg_del(cfg_file);
-
-	if (gyro_dev) {
-		sensor_destroy(&gyro_dev);
-	}
-
-#ifdef GPAC_MEMORY_TRACKING
-	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
-		gf_memory_print();
-	}
-#endif
-
-	gf_sys_close();
-	if (rti_logs) gf_fclose(rti_logs);
-	if (logfile) gf_fclose(logfile);
-	if (playlist) gf_fclose(playlist);
-
-	exit(0);
-	return 0;
-}
-
-static GF_ObjectManager *video_odm = NULL;
-static GF_ObjectManager *audio_odm = NULL;
-static GF_ObjectManager *scene_odm = NULL;
-static u32 last_odm_count = 0;
-void PrintAVInfo(Bool final)
-{
-	GF_MediaInfo a_odi, v_odi, s_odi;
-	u32 tot_time;
-
-	if (scene_odm) {
-		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
-		u32 count = gf_term_get_object_count(term, root_odm);
-		if (last_odm_count != count) {
-			last_odm_count = count;
-			scene_odm = NULL;
-		}
-	}
-	if (!video_odm && !audio_odm && !scene_odm) {
-		u32 count, i;
-		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
-		if (!root_odm) return;
-
-		if (gf_term_get_object_info(term, root_odm, &v_odi)==GF_OK) {
-			if (!scene_odm && (v_odi.generated_scene== 0)) {
-				scene_odm = root_odm;
-			}
-		}
-
-		count = gf_term_get_object_count(term, root_odm);
-		for (i=0; i<count; i++) {
-			GF_ObjectManager *odm = gf_term_get_object(term, root_odm, i);
-			if (!odm) break;
-			if (gf_term_get_object_info(term, odm, &v_odi) == GF_OK) {
-				if (!video_odm && (v_odi.od_type == GF_STREAM_VISUAL) && (v_odi.raw_media || (v_odi.cb_max_count>1) || v_odi.direct_video_memory) ) {
-					video_odm = odm;
-				}
-				else if (!audio_odm && (v_odi.od_type == GF_STREAM_AUDIO)) {
-					audio_odm = odm;
-				}
-				else if (!scene_odm && (v_odi.od_type == GF_STREAM_SCENE)) {
-					scene_odm = odm;
-				}
-			}
-		}
-	}
-
-	if (video_odm) {
-		if (gf_term_get_object_info(term, video_odm, &v_odi)!= GF_OK) {
-			video_odm = NULL;
-			return;
-		}
-	} else {
-		memset(&v_odi, 0, sizeof(v_odi));
-	}
-	if (audio_odm) {
-		gf_term_get_object_info(term, audio_odm, &a_odi);
-	} else {
-		memset(&a_odi, 0, sizeof(a_odi));
-	}
-	if (!video_odm && scene_odm) {
-		gf_term_get_object_info(term, scene_odm, &s_odi);
-	} else {
-		memset(&s_odi, 0, sizeof(s_odi));
-	}
-
-	if (final) {
-		tot_time = gf_sys_clock() - bench_mode_start;
-		fprintf(stderr, " \r");
-		fprintf(stderr, "************** Bench Mode Done in %d ms ********************\n", tot_time);
-		if (bench_mode==3) fprintf(stderr, "** Systems layer only (no decoding) **\n");
-
-		if (!video_odm) {
-			u32 nb_frames_drawn;
-			Double FPS = gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
-			fprintf(stderr, "Drawn %d frames FPS %.2f (simulation FPS %.2f) - duration %d ms\n", nb_frames_drawn, ((Float)nb_frames_drawn*1000)/tot_time,(Float) FPS, gf_term_get_time_in_ms(term) );
-		}
-	}
-	if (video_odm) {
-		fprintf(stderr, "%s %dx%d sar=%d:%d duration %.2fs\n", v_odi.codec_name, v_odi.width, v_odi.height, v_odi.par ? (v_odi.par>>16)&0xFF : 1, v_odi.par ? (v_odi.par)&0xFF : 1, v_odi.duration);
-		if (final) {
-			u32 dec_run_time = v_odi.last_frame_time - v_odi.first_frame_time;
-			if (!dec_run_time) dec_run_time = 1;
-			if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
-			fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / dec_run_time, v_odi.max_dec_time, (u32) v_odi.avg_bitrate/1000, (u32) v_odi.max_bitrate/1000);
-			if (v_odi.nb_dropped) {
-				fprintf(stderr, " (Error during bench: %d frames drop)", v_odi.nb_dropped);
-			}
-			fprintf(stderr, "\n");
-		}
-	}
-	if (audio_odm) {
-		fprintf(stderr, "%s SR %d num channels %d fmt %s duration %.2fs\n", a_odi.codec_name, a_odi.sample_rate, a_odi.num_channels, gf_audio_fmt_name(a_odi.afmt), a_odi.duration);
-		if (final) {
-			u32 dec_run_time = a_odi.last_frame_time - a_odi.first_frame_time;
-			if (!dec_run_time) dec_run_time = 1;
-			if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
-			fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max) rate avg %d max %d", a_odi.nb_dec_frames, ((Float)dec_run_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0, (u32) a_odi.avg_bitrate/1000, (u32) a_odi.max_bitrate/1000);
-			if (a_odi.nb_dropped) {
-				fprintf(stderr, " (Error during bench: %d frames drop)", a_odi.nb_dropped);
-			}
-			fprintf(stderr, "\n");
-		}
-	}
-	if (scene_odm) {
-		u32 w, h;
-		gf_term_get_visual_output_size(term, &w, &h);
-		fprintf(stderr, "%s scene size %dx%d rastered to %dx%d duration %.2fs\n", s_odi.codec_name ? s_odi.codec_name : "", s_odi.width, s_odi.height, w, h, s_odi.duration);
-		if (final) {
-			if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
-				u32 dec_run_time = s_odi.last_frame_time - s_odi.first_frame_time;
-				if (!dec_run_time) dec_run_time = 1;
-				fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", s_odi.nb_dec_frames, ((Float)s_odi.nb_dec_frames*1000) / dec_run_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000, (u32) s_odi.max_bitrate/1000);
-				fprintf(stderr, "\n");
-			} else {
-				u32 nb_frames_drawn;
-				Double FPS;
-				gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
-				tot_time = gf_sys_clock() - bench_mode_start;
-				FPS = gf_term_get_framerate(term, 0);
-				fprintf(stderr, "%d frames FPS %.2f (abs %.2f)\n", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
-			}
-		}
-	}
-	if (final) {
-		fprintf(stderr, "**********************************************************\n\n");
-		return;
-	}
-
-	if (video_odm) {
-		u32 dec_run_time = v_odi.last_frame_time - v_odi.first_frame_time;
-		if (!dec_run_time) dec_run_time = 1;
-		tot_time = v_odi.last_frame_time - v_odi.first_frame_time;
-		if (!tot_time) tot_time=1;
-		if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
-		fprintf(stderr, "%d f FPS %.2f (max %d us/f) rate avg %d max %d", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / dec_run_time, v_odi.max_dec_time, (u32) v_odi.avg_bitrate/1000, (u32) v_odi.max_bitrate/1000);
-	}
-	else if (scene_odm) {
-		if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
-			u32 dec_run_time = s_odi.last_frame_time - s_odi.first_frame_time;
-			if (!dec_run_time) dec_run_time = 1;
-			fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", s_odi.nb_dec_frames, ((Float)s_odi.nb_dec_frames*1000) / dec_run_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000, (u32) s_odi.max_bitrate/1000);
-			fprintf(stderr, "\n");
-		} else {
-			u32 nb_frames_drawn;
-			Double FPS;
-			gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
-			tot_time = gf_sys_clock() - bench_mode_start;
-			FPS = gf_term_get_framerate(term, 0);
-			fprintf(stderr, "%d frames FPS %.2f (abs %.2f)\n", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
-		}
-	}
-	else if (audio_odm) {
-		gf_term_get_object_info(term, audio_odm, &a_odi);
-		tot_time = a_odi.last_frame_time - a_odi.first_frame_time;
-		if (!tot_time) tot_time=1;
-		if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
-		fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max)", a_odi.nb_dec_frames, ((Float)tot_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0);
-	}
-}
-

gpac-2.0.0.tar.gz/applications/osmo4_ios/osmo4ios-Info.plist Deleted

@@ -1,57 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIconFiles</key>
-	<array>
-		<string>icon.png</string>
-		<string>icon_retina.png</string>
-		<string>icon_ipad.png</string>
-		<string>icon_ipad_retina.png</string>
-	</array>
-	<key>CFBundleIcons</key>
-	<dict>
-		<key>CFBundlePrimaryIcon</key>
-		<dict>
-			<key>CFBundleIconFiles</key>
-			<array>
-				<string>icon.png</string>
-				<string>icon_retina.png</string>
-				<string>icon_ipad.png</string>
-				<string>icon_ipad_retina.png</string>
-			</array>
-		</dict>
-	</dict>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>Osmo4</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>2.0</string>
-	<key>CFBundleSignature</key>
-	<string>gpac</string>
-	<key>CFBundleVersion</key>
-	<string>0000</string>
-	<key>UIFileSharingEnabled</key>
-	<true/>
-	<key>UIRequiresFullScreen</key>
-	<true/>
-	<key>UIStatusBarHidden</key>
-	<true/>
-	<key>UISupportedInterfaceOrientations</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-</dict>
-</plist>

gpac-2.0.0.tar.gz/applications/osmo4_ios/sensors.h Deleted

gpac-2.0.0.tar.gz/applications/osmo4_ios/sensors.m Deleted

@@ -1,201 +0,0 @@
-//
-//  ios_mpegv.m
-//  ios_mpegv
-//
-//  Created by mac on 3/8/13.
-//
-//
-
-#import "sensors.h"
-
-@implementation SensorAccess
-
-- (id)init {
-	if ((self = super init)) {
-        @autoreleasepool {
-            self.motionManager = CMMotionManager alloc init autorelease;
-			self.motionManager.deviceMotionUpdateInterval = 0.1f;
-            self.queue = NSOperationQueue alloc init autorelease;
-            
-            self.locMngr = CLLocationManager alloc init autorelease;
-            self.locMngr.delegate = self;
-            self.locMngr.desiredAccuracy = kCLLocationAccuracyBest;
-            self.locMngr.distanceFilter = 2;
-            
-            sensorCallbak = NULL;
-            sensorType = -1;
-            gpsActive = 0;
-        }
-	}
-	return self;
-}
-
-- (void)dealloc{
-    self.locMngr.delegate = NULL;
-    super dealloc;
-}
-
-- (int) setSensorType :(int) type
-{
-    sensorType = type;
-    return 0;
-}
-
-- (int) getSensorType
-{
-    return sensorType;
-}
-
-- (int) setSensorCallback:(SensorDataCallback*)callback
-{
-    sensorCallbak = callback;
-    return 0;
-}
-
-- (int) startSensor
-{
-	sensorActive=1;
-    switch (sensorType) {
-        case SENSOR_ACCELEROMETER:
-            if ( !self motionManager isAccelerometerAvailable )
-                return 1;
-            self motionManager startAccelerometerUpdatesToQueue:self queue withHandler:^(CMAccelerometerData* data, NSError* error) {
-                    if ( sensorCallbak && sensorActive) {
-                        sensorCallbak(sensorType, data.acceleration.x, data.acceleration.y, data.acceleration.z, 0);
-                    }
-                }
-             ;
-            return 0;
-
-        case SENSOR_GYROSCOPE:
-            if ( !self motionManager isGyroAvailable )
-                return 1;
-            self motionManager startGyroUpdatesToQueue:self queue withHandler:^(CMGyroData* data, NSError* error) {
-                if ( sensorCallbak  && sensorActive) {
-                    sensorCallbak(sensorType, data.rotationRate.x, data.rotationRate.y, data.rotationRate.z, 0);
-                }
-            }
-             ;
-            return 0;
-
-		case SENSOR_ORIENTATION:
-            if ( !self motionManager isGyroAvailable )
-                return 1;
-            self motionManager startDeviceMotionUpdatesToQueue:self queue withHandler:^(CMDeviceMotion* data, NSError* error) {
-                if ( sensorCallbak  && sensorActive) {
-                    sensorCallbak(sensorType, data.attitude.quaternion.x, data.attitude.quaternion.y, data.attitude.quaternion.z, data.attitude.quaternion.w);
-                }
-            }
-             ;
-            return 0;
-
-        case SENSOR_MAGNETOMETER:
-            if ( !self motionManager isMagnetometerAvailable )
-                return 1;
-            self motionManager startMagnetometerUpdatesToQueue:self queue withHandler:^(CMMagnetometerData* data, NSError* error) {
-                if ( sensorCallbak  && sensorActive) {
-                    sensorCallbak(sensorType, data.magneticField.x, data.magneticField.y, data.magneticField.z, 0);
-                }
-            }
-             ;
-            return 0;
-
-        case SENSOR_GPS:
-            self.locMngr startUpdatingLocation;
-            gpsActive = 1;
-            return 0;
-
-    }
-
-    return 1;
-}
-
-- (int) stopSensor
-{
-	sensorActive=0;
-    switch (sensorType) {
-        case SENSOR_ACCELEROMETER:
-            self motionManager stopAccelerometerUpdates;
-            return 0;
-            break;
-        case SENSOR_GYROSCOPE:
-            self motionManager stopGyroUpdates;
-            return 0;
-            break;
-        case SENSOR_MAGNETOMETER:
-            self motionManager stopMagnetometerUpdates;
-            return 0;
-        case SENSOR_GPS:
-            self.locMngr stopUpdatingLocation;
-            gpsActive = 0;
-            return 0;
-            break;
-    }
-    return 1;
-}
-
-- (int) isSensorStarted
-{
-    switch (sensorType) {
-        case SENSOR_ACCELEROMETER:
-            return self motionManager isAccelerometerActive;
-            break;
-        case SENSOR_GYROSCOPE:
-            return self motionManager isGyroActive;
-            break;
-        case SENSOR_MAGNETOMETER:
-            return self motionManager isMagnetometerActive;
-        case SENSOR_GPS:
-            return gpsActive;
-            break;
-    }
-    return 0;
-}
-
-- (void)locationManager:(CLLocationManager *)manager didUpdateToLocation:(CLLocation *)location fromLocation:(CLLocation *)oldLocation {
-    if ( sensorCallbak ) {
-		sensorCallbak(sensorType, (float)location.coordinate.latitude, (float)location.coordinate.longitude, (float)location.altitude, (float)location.horizontalAccuracy);
-	}
-}
-
-@end
-
-
-int sensor_get_type(void* inst);
-int sensor_start(void* inst);
-int sensor_stop(void* inst);
-int sensor_is_running(void* inst);
-
-void *sensor_create(int type, SensorDataCallback *callback) {
-    void* obj = SensorAccess alloc init;
-	if (!obj) return NULL;
-    (id)obj setSensorType:type;
-    (id)obj setSensorCallback:callback ;
-    return obj;
-}
-
-int sensor_destroy(void** inst) {
-    (id)*inst dealloc;
-    *inst = NULL;
-    return 0;
-}
-
-int sensor_get_type(void* inst) {
-    if ( !inst ) return 1;
-    return (id)inst getSensorType;
-}
-
-int sensor_start(void* inst) {
-    if ( !inst ) return 1;
-    return (id)inst startSensor;
-}
-
-int sensor_stop(void* inst) {
-    if ( !inst ) return 1;
-    return (id)inst stopSensor;
-}
-
-int sensor_is_running(void* inst) {
-    if ( !inst ) return 1;
-    return (id)inst isSensorStarted;
-}

gpac-2.0.0.tar.gz/applications/osmo4_ios/sensors_def.h Deleted

gpac-2.0.0.tar.gz/applications/testapps/player_api Deleted

gpac-2.0.0.tar.gz/build/android/AndroidManifest.xml Deleted

gpac-2.0.0.tar.gz/build/android/gen Deleted

gpac-2.0.0.tar.gz/build/android/gen/com Deleted

gpac-2.0.0.tar.gz/build/android/gen/com/enst Deleted

gpac-2.0.0.tar.gz/build/android/gen/com/enst/gpac Deleted

gpac-2.0.0.tar.gz/build/android/gen/com/enst/gpac/R.java Deleted

gpac-2.0.0.tar.gz/build/android/jni/modules/gm_widgetman.mk Deleted

gpac-2.0.0.tar.gz/build/android/jni/mp4box Deleted

gpac-2.0.0.tar.gz/build/android/jni/mp4box/Android.mk Deleted

gpac-2.0.0.tar.gz/build/android/jni/mp4box/Application.mk Deleted

gpac-2.0.0.tar.gz/build/android/res Deleted

gpac-2.0.0.tar.gz/build/android/res/drawable-hdpi Deleted

gpac-2.0.0.tar.gz/build/android/res/drawable-hdpi/icon.png Deleted

gpac-2.0.0.tar.gz/build/android/res/drawable-ldpi Deleted

gpac-2.0.0.tar.gz/build/android/res/drawable-ldpi/icon.png Deleted

gpac-2.0.0.tar.gz/build/android/res/drawable-mdpi Deleted

gpac-2.0.0.tar.gz/build/android/res/drawable-mdpi/icon.png Deleted

gpac-2.0.0.tar.gz/build/android/res/layout Deleted

gpac-2.0.0.tar.gz/build/android/res/layout/main.xml Deleted

gpac-2.0.0.tar.gz/build/android/res/values Deleted

gpac-2.0.0.tar.gz/build/android/res/values/strings.xml Deleted

gpac-2.0.0.tar.gz/build/android/src Deleted

gpac-2.0.0.tar.gz/build/android/src/com Deleted

gpac-2.0.0.tar.gz/build/android/src/com/enst Deleted

gpac-2.0.0.tar.gz/build/android/src/com/enst/gpac Deleted

gpac-2.0.0.tar.gz/build/android/src/com/enst/gpac/gpac.java Deleted

gpac-2.0.0.tar.gz/build/symbian Deleted

gpac-2.0.0.tar.gz/build/symbian/sis Deleted

gpac-2.0.0.tar.gz/build/xcode/gpac4ios.xcodeproj/xcshareddata/xcschemes/osmo4ios.xcscheme Deleted

@@ -1,87 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Scheme
- LastUpgradeVersion = "1020"
- version = "1.3">
- <BuildAction
- parallelizeBuildables = "YES"
- buildImplicitDependencies = "YES">
- <BuildActionEntries>
- <BuildActionEntry
- buildForTesting = "YES"
- buildForRunning = "YES"
- buildForProfiling = "YES"
- buildForArchiving = "YES"
- buildForAnalyzing = "YES">
- <BuildableReference
- BuildableIdentifier = "primary"
- BlueprintIdentifier = "71A19B1912796B5600ACFF58"
- BuildableName = "osmo4ios.app"
- BlueprintName = "osmo4ios"
- ReferencedContainer = "container:gpac4ios.xcodeproj">
- </BuildableReference>
- </BuildActionEntry>
- </BuildActionEntries>
- </BuildAction>
- <TestAction
- buildConfiguration = "Debug"
- selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
- selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
- shouldUseLaunchSchemeArgsEnv = "YES">
- <MacroExpansion>
- <BuildableReference
- BuildableIdentifier = "primary"
- BlueprintIdentifier = "71A19B1912796B5600ACFF58"
- BuildableName = "osmo4ios.app"
- BlueprintName = "osmo4ios"
- ReferencedContainer = "container:gpac4ios.xcodeproj">
- </BuildableReference>
- </MacroExpansion>
- <Testables>
- </Testables>
- </TestAction>
- <LaunchAction
- buildConfiguration = "Debug"
- selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
- selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
- launchStyle = "0"
- useCustomWorkingDirectory = "NO"
- ignoresPersistentStateOnLaunch = "NO"
- debugDocumentVersioning = "YES"
- debugServiceExtension = "internal"
- allowLocationSimulation = "YES">
- <BuildableProductRunnable
- runnableDebuggingMode = "0">
- <BuildableReference
- BuildableIdentifier = "primary"
- BlueprintIdentifier = "71A19B1912796B5600ACFF58"
- BuildableName = "osmo4ios.app"
- BlueprintName = "osmo4ios"
- ReferencedContainer = "container:gpac4ios.xcodeproj">
- </BuildableReference>
- </BuildableProductRunnable>
- </LaunchAction>
- <ProfileAction
- buildConfiguration = "Release"
- shouldUseLaunchSchemeArgsEnv = "YES"
- savedToolIdentifier = ""
- useCustomWorkingDirectory = "NO"
- debugDocumentVersioning = "YES">
- <BuildableProductRunnable
- runnableDebuggingMode = "0">
- <BuildableReference
- BuildableIdentifier = "primary"
- BlueprintIdentifier = "71A19B1912796B5600ACFF58"
- BuildableName = "osmo4ios.app"
- BlueprintName = "osmo4ios"
- ReferencedContainer = "container:gpac4ios.xcodeproj">
- </BuildableReference>
- </BuildableProductRunnable>
- </ProfileAction>
- <AnalyzeAction
- buildConfiguration = "Debug">
- </AnalyzeAction>
- <ArchiveAction
- buildConfiguration = "Release"
- revealArchiveInOrganizer = "YES">
- </ArchiveAction>
-</Scheme>

gpac-2.0.0.tar.gz/build/xcode/osmo4ios.entitlements Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/ac3_parser.h Deleted

@@ -1,36 +0,0 @@
-/*
- * AC-3 parser prototypes
- * Copyright (c) 2003 Fabrice Bellard
- * Copyright (c) 2003 Michael Niedermayer
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_AC3_PARSER_H
-#define AVCODEC_AC3_PARSER_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-/**
- * Extract the bitstream ID and the frame size from AC-3 data.
- */
-int av_ac3_parse_header(const uint8_t *buf, size_t size,
- uint8_t *bitstream_id, uint16_t *frame_size);
-
-
-#endif /* AVCODEC_AC3_PARSER_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/adts_parser.h Deleted

@@ -1,37 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_ADTS_PARSER_H
-#define AVCODEC_ADTS_PARSER_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#define AV_AAC_ADTS_HEADER_SIZE 7
-
-/**
- * Extract the number of samples and frames from AAC data.
- * @paramin buf pointer to AAC data buffer
- * @paramout samples Pointer to where number of samples is written
- * @paramout frames Pointer to where number of frames is written
- * @return Returns 0 on success, error code on failure.
- */
-int av_adts_header_parse(const uint8_t *buf, uint32_t *samples,
- uint8_t *frames);
-
-#endif /* AVCODEC_ADTS_PARSER_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/avcodec.h Deleted

@@ -1,6146 +0,0 @@
-/*
- * copyright (c) 2001 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_AVCODEC_H
-#define AVCODEC_AVCODEC_H
-
-/**
- * @file
- * @ingroup libavc
- * Libavcodec external API header
- */
-
-#include <errno.h>
-#include "libavutil/samplefmt.h"
-#include "libavutil/attributes.h"
-#include "libavutil/avutil.h"
-#include "libavutil/buffer.h"
-#include "libavutil/cpu.h"
-#include "libavutil/channel_layout.h"
-#include "libavutil/dict.h"
-#include "libavutil/frame.h"
-#include "libavutil/hwcontext.h"
-#include "libavutil/log.h"
-#include "libavutil/pixfmt.h"
-#include "libavutil/rational.h"
-
-#include "version.h"
-
-/**
- * @defgroup libavc libavcodec
- * Encoding/Decoding Library
- *
- * @{
- *
- * @defgroup lavc_decoding Decoding
- * @{
- * @}
- *
- * @defgroup lavc_encoding Encoding
- * @{
- * @}
- *
- * @defgroup lavc_codec Codecs
- * @{
- * @defgroup lavc_codec_native Native Codecs
- * @{
- * @}
- * @defgroup lavc_codec_wrappers External library wrappers
- * @{
- * @}
- * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge
- * @{
- * @}
- * @}
- * @defgroup lavc_internal Internal
- * @{
- * @}
- * @}
- */
-
-/**
- * @ingroup libavc
- * @defgroup lavc_encdec send/receive encoding and decoding API overview
- * @{
- *
- * The avcodec_send_packet()/avcodec_receive_frame()/avcodec_send_frame()/
- * avcodec_receive_packet() functions provide an encode/decode API, which
- * decouples input and output.
- *
- * The API is very similar for encoding/decoding and audio/video, and works as
- * follows:
- * - Set up and open the AVCodecContext as usual.
- * - Send valid input:
- * - For decoding, call avcodec_send_packet() to give the decoder raw
- * compressed data in an AVPacket.
- * - For encoding, call avcodec_send_frame() to give the encoder an AVFrame
- * containing uncompressed audio or video.
- * In both cases, it is recommended that AVPackets and AVFrames are
- * refcounted, or libavcodec might have to copy the input data. (libavformat
- * always returns refcounted AVPackets, and av_frame_get_buffer() allocates
- * refcounted AVFrames.)
- * - Receive output in a loop. Periodically call one of the avcodec_receive_*()
- * functions and process their output:
- * - For decoding, call avcodec_receive_frame(). On success, it will return
- * an AVFrame containing uncompressed audio or video data.
- * - For encoding, call avcodec_receive_packet(). On success, it will return
- * an AVPacket with a compressed frame.
- * Repeat this call until it returns AVERROR(EAGAIN) or an error. The
- * AVERROR(EAGAIN) return value means that new input data is required to
- * return new output. In this case, continue with sending input. For each
- * input frame/packet, the codec will typically return 1 output frame/packet,
- * but it can also be 0 or more than 1.
- *
- * At the beginning of decoding or encoding, the codec might accept multiple
- * input frames/packets without returning a frame, until its internal buffers
- * are filled. This situation is handled transparently if you follow the steps
- * outlined above.
- *
- * In theory, sending input can result in EAGAIN - this should happen only if
- * not all output was received. You can use this to structure alternative decode
- * or encode loops other than the one suggested above. For example, you could
- * try sending new input on each iteration, and try to receive output if that
- * returns EAGAIN.
- *
- * End of stream situations. These require "flushing" (aka draining) the codec,
- * as the codec might buffer multiple frames or packets internally for
- * performance or out of necessity (consider B-frames).
- * This is handled as follows:
- * - Instead of valid input, send NULL to the avcodec_send_packet() (decoding)
- * or avcodec_send_frame() (encoding) functions. This will enter draining
- * mode.
- * - Call avcodec_receive_frame() (decoding) or avcodec_receive_packet()
- * (encoding) in a loop until AVERROR_EOF is returned. The functions will
- * not return AVERROR(EAGAIN), unless you forgot to enter draining mode.
- * - Before decoding can be resumed again, the codec has to be reset with
- * avcodec_flush_buffers().
- *
- * Using the API as outlined above is highly recommended. But it is also
- * possible to call functions outside of this rigid schema. For example, you can
- * call avcodec_send_packet() repeatedly without calling
- * avcodec_receive_frame(). In this case, avcodec_send_packet() will succeed
- * until the codec's internal buffer has been filled up (which is typically of
- * size 1 per output frame, after initial input), and then reject input with
- * AVERROR(EAGAIN). Once it starts rejecting input, you have no choice but to
- * read at least some output.
- *
- * Not all codecs will follow a rigid and predictable dataflow; the only
- * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on
- * one end implies that a receive/send call on the other end will succeed, or
- * at least will not fail with AVERROR(EAGAIN). In general, no codec will
- * permit unlimited buffering of input or output.
- *
- * This API replaces the following legacy functions:
- * - avcodec_decode_video2() and avcodec_decode_audio4():
- * Use avcodec_send_packet() to feed input to the decoder, then use
- * avcodec_receive_frame() to receive decoded frames after each packet.
- * Unlike with the old video decoding API, multiple frames might result from
- * a packet. For audio, splitting the input packet into frames by partially
- * decoding packets becomes transparent to the API user. You never need to
- * feed an AVPacket to the API twice (unless it is rejected with AVERROR(EAGAIN) - then
- * no data was read from the packet).
- * Additionally, sending a flush/draining packet is required only once.
- * - avcodec_encode_video2()/avcodec_encode_audio2():
- * Use avcodec_send_frame() to feed input to the encoder, then use
- * avcodec_receive_packet() to receive encoded packets.
- * Providing user-allocated buffers for avcodec_receive_packet() is not
- * possible.
- * - The new API does not handle subtitles yet.
- *
- * Mixing new and old function calls on the same AVCodecContext is not allowed,
- * and will result in undefined behavior.
- *
- * Some codecs might require using the new API; using the old API will return
- * an error when calling it. All codecs support the new API.
- *
- * A codec is not allowed to return AVERROR(EAGAIN) for both sending and receiving. This
- * would be an invalid state, which could put the codec user into an endless
- * loop. The API has no concept of time either: it cannot happen that trying to
- * do avcodec_send_packet() results in AVERROR(EAGAIN), but a repeated call 1 second
- * later accepts the packet (with no other receive/flush API calls involved).
- * The API is a strict state machine, and the passage of time is not supposed
- * to influence it. Some timing-dependent behavior might still be deemed
- * acceptable in certain cases. But it must never result in both send/receive
- * returning EAGAIN at the same time at any point. It must also absolutely be
- * avoided that the current state is "unstable" and can "flip-flop" between
- * the send/receive APIs allowing progress. For example, it's not allowed that
- * the codec randomly decides that it actually wants to consume a packet now
- * instead of returning a frame, after it just returned AVERROR(EAGAIN) on an
- * avcodec_send_packet() call.
- * @}
- */
-
-/**
- * @defgroup lavc_core Core functions/structures.
- * @ingroup libavc
- *
- * Basic definitions, functions for querying libavcodec capabilities,
- * allocating core structures, etc.
- * @{
- */
-
-
-/**
- * Identify the syntax and semantics of the bitstream.
- * The principle is roughly:
- * Two decoders with the same ID can decode the same streams.
- * Two encoders with the same ID can encode compatible streams.
- * There may be slight deviations from the principle due to implementation
- * details.
- *
- * If you add a codec ID to this list, add it so that
- * 1. no value of an existing codec ID changes (that would break ABI),
- * 2. it is as close as possible to similar codecs
- *
- * After adding new codec IDs, do not forget to add an entry to the codec
- * descriptor list and bump libavcodec minor version.
- */
-enum AVCodecID {
- AV_CODEC_ID_NONE,
-
- /* video codecs */
- AV_CODEC_ID_MPEG1VIDEO,
- AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
- AV_CODEC_ID_H261,
- AV_CODEC_ID_H263,
- AV_CODEC_ID_RV10,
- AV_CODEC_ID_RV20,
- AV_CODEC_ID_MJPEG,
- AV_CODEC_ID_MJPEGB,
- AV_CODEC_ID_LJPEG,
- AV_CODEC_ID_SP5X,
- AV_CODEC_ID_JPEGLS,
- AV_CODEC_ID_MPEG4,
- AV_CODEC_ID_RAWVIDEO,
- AV_CODEC_ID_MSMPEG4V1,
- AV_CODEC_ID_MSMPEG4V2,
- AV_CODEC_ID_MSMPEG4V3,
- AV_CODEC_ID_WMV1,
- AV_CODEC_ID_WMV2,
- AV_CODEC_ID_H263P,
- AV_CODEC_ID_H263I,
- AV_CODEC_ID_FLV1,
- AV_CODEC_ID_SVQ1,
- AV_CODEC_ID_SVQ3,
- AV_CODEC_ID_DVVIDEO,
- AV_CODEC_ID_HUFFYUV,
- AV_CODEC_ID_CYUV,
- AV_CODEC_ID_H264,
- AV_CODEC_ID_INDEO3,
- AV_CODEC_ID_VP3,
- AV_CODEC_ID_THEORA,
- AV_CODEC_ID_ASV1,
- AV_CODEC_ID_ASV2,
- AV_CODEC_ID_FFV1,
- AV_CODEC_ID_4XM,
- AV_CODEC_ID_VCR1,
- AV_CODEC_ID_CLJR,
- AV_CODEC_ID_MDEC,
- AV_CODEC_ID_ROQ,
- AV_CODEC_ID_INTERPLAY_VIDEO,
- AV_CODEC_ID_XAN_WC3,
- AV_CODEC_ID_XAN_WC4,
- AV_CODEC_ID_RPZA,
- AV_CODEC_ID_CINEPAK,
- AV_CODEC_ID_WS_VQA,
- AV_CODEC_ID_MSRLE,
- AV_CODEC_ID_MSVIDEO1,
- AV_CODEC_ID_IDCIN,
- AV_CODEC_ID_8BPS,
- AV_CODEC_ID_SMC,
- AV_CODEC_ID_FLIC,
- AV_CODEC_ID_TRUEMOTION1,
- AV_CODEC_ID_VMDVIDEO,
- AV_CODEC_ID_MSZH,
- AV_CODEC_ID_ZLIB,
- AV_CODEC_ID_QTRLE,
- AV_CODEC_ID_TSCC,
- AV_CODEC_ID_ULTI,
- AV_CODEC_ID_QDRAW,
- AV_CODEC_ID_VIXL,
- AV_CODEC_ID_QPEG,
- AV_CODEC_ID_PNG,
- AV_CODEC_ID_PPM,
- AV_CODEC_ID_PBM,
- AV_CODEC_ID_PGM,
- AV_CODEC_ID_PGMYUV,
- AV_CODEC_ID_PAM,
- AV_CODEC_ID_FFVHUFF,
- AV_CODEC_ID_RV30,
- AV_CODEC_ID_RV40,
- AV_CODEC_ID_VC1,
- AV_CODEC_ID_WMV3,
- AV_CODEC_ID_LOCO,
- AV_CODEC_ID_WNV1,
- AV_CODEC_ID_AASC,
- AV_CODEC_ID_INDEO2,
- AV_CODEC_ID_FRAPS,
- AV_CODEC_ID_TRUEMOTION2,
- AV_CODEC_ID_BMP,
- AV_CODEC_ID_CSCD,
- AV_CODEC_ID_MMVIDEO,
- AV_CODEC_ID_ZMBV,
- AV_CODEC_ID_AVS,
- AV_CODEC_ID_SMACKVIDEO,
- AV_CODEC_ID_NUV,
- AV_CODEC_ID_KMVC,
- AV_CODEC_ID_FLASHSV,
- AV_CODEC_ID_CAVS,
- AV_CODEC_ID_JPEG2000,
- AV_CODEC_ID_VMNC,
- AV_CODEC_ID_VP5,
- AV_CODEC_ID_VP6,
- AV_CODEC_ID_VP6F,
- AV_CODEC_ID_TARGA,
- AV_CODEC_ID_DSICINVIDEO,
- AV_CODEC_ID_TIERTEXSEQVIDEO,
- AV_CODEC_ID_TIFF,
- AV_CODEC_ID_GIF,
- AV_CODEC_ID_DXA,
- AV_CODEC_ID_DNXHD,
- AV_CODEC_ID_THP,
- AV_CODEC_ID_SGI,
- AV_CODEC_ID_C93,
- AV_CODEC_ID_BETHSOFTVID,
- AV_CODEC_ID_PTX,
- AV_CODEC_ID_TXD,
- AV_CODEC_ID_VP6A,
- AV_CODEC_ID_AMV,
- AV_CODEC_ID_VB,
- AV_CODEC_ID_PCX,
- AV_CODEC_ID_SUNRAST,
- AV_CODEC_ID_INDEO4,
- AV_CODEC_ID_INDEO5,
- AV_CODEC_ID_MIMIC,
- AV_CODEC_ID_RL2,
- AV_CODEC_ID_ESCAPE124,
- AV_CODEC_ID_DIRAC,
- AV_CODEC_ID_BFI,
- AV_CODEC_ID_CMV,
- AV_CODEC_ID_MOTIONPIXELS,
- AV_CODEC_ID_TGV,
- AV_CODEC_ID_TGQ,
- AV_CODEC_ID_TQI,
- AV_CODEC_ID_AURA,
- AV_CODEC_ID_AURA2,
- AV_CODEC_ID_V210X,
- AV_CODEC_ID_TMV,
- AV_CODEC_ID_V210,
- AV_CODEC_ID_DPX,
- AV_CODEC_ID_MAD,
- AV_CODEC_ID_FRWU,
- AV_CODEC_ID_FLASHSV2,
- AV_CODEC_ID_CDGRAPHICS,
- AV_CODEC_ID_R210,
- AV_CODEC_ID_ANM,
- AV_CODEC_ID_BINKVIDEO,
- AV_CODEC_ID_IFF_ILBM,
-#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
- AV_CODEC_ID_KGV1,
- AV_CODEC_ID_YOP,
- AV_CODEC_ID_VP8,
- AV_CODEC_ID_PICTOR,
- AV_CODEC_ID_ANSI,
- AV_CODEC_ID_A64_MULTI,
- AV_CODEC_ID_A64_MULTI5,
- AV_CODEC_ID_R10K,
- AV_CODEC_ID_MXPEG,
- AV_CODEC_ID_LAGARITH,
- AV_CODEC_ID_PRORES,
- AV_CODEC_ID_JV,
- AV_CODEC_ID_DFA,
- AV_CODEC_ID_WMV3IMAGE,
- AV_CODEC_ID_VC1IMAGE,
- AV_CODEC_ID_UTVIDEO,
- AV_CODEC_ID_BMV_VIDEO,
- AV_CODEC_ID_VBLE,
- AV_CODEC_ID_DXTORY,
- AV_CODEC_ID_V410,
- AV_CODEC_ID_XWD,
- AV_CODEC_ID_CDXL,
- AV_CODEC_ID_XBM,
- AV_CODEC_ID_ZEROCODEC,
- AV_CODEC_ID_MSS1,
- AV_CODEC_ID_MSA1,
- AV_CODEC_ID_TSCC2,
- AV_CODEC_ID_MTS2,
- AV_CODEC_ID_CLLC,
- AV_CODEC_ID_MSS2,
- AV_CODEC_ID_VP9,
- AV_CODEC_ID_AIC,
- AV_CODEC_ID_ESCAPE130,
- AV_CODEC_ID_G2M,
- AV_CODEC_ID_WEBP,
- AV_CODEC_ID_HNM4_VIDEO,
- AV_CODEC_ID_HEVC,
-#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
- AV_CODEC_ID_FIC,
- AV_CODEC_ID_ALIAS_PIX,
- AV_CODEC_ID_BRENDER_PIX,
- AV_CODEC_ID_PAF_VIDEO,
- AV_CODEC_ID_EXR,
- AV_CODEC_ID_VP7,
- AV_CODEC_ID_SANM,
- AV_CODEC_ID_SGIRLE,
- AV_CODEC_ID_MVC1,
- AV_CODEC_ID_MVC2,
- AV_CODEC_ID_HQX,
- AV_CODEC_ID_TDSC,
- AV_CODEC_ID_HQ_HQA,
- AV_CODEC_ID_HAP,
- AV_CODEC_ID_DDS,
- AV_CODEC_ID_DXV,
- AV_CODEC_ID_SCREENPRESSO,
- AV_CODEC_ID_RSCC,
-
- AV_CODEC_ID_Y41P = 0x8000,
- AV_CODEC_ID_AVRP,
- AV_CODEC_ID_012V,
- AV_CODEC_ID_AVUI,
- AV_CODEC_ID_AYUV,
- AV_CODEC_ID_TARGA_Y216,
- AV_CODEC_ID_V308,
- AV_CODEC_ID_V408,
- AV_CODEC_ID_YUV4,
- AV_CODEC_ID_AVRN,
- AV_CODEC_ID_CPIA,
- AV_CODEC_ID_XFACE,
- AV_CODEC_ID_SNOW,
- AV_CODEC_ID_SMVJPEG,
- AV_CODEC_ID_APNG,
- AV_CODEC_ID_DAALA,
- AV_CODEC_ID_CFHD,
- AV_CODEC_ID_TRUEMOTION2RT,
- AV_CODEC_ID_M101,
- AV_CODEC_ID_MAGICYUV,
- AV_CODEC_ID_SHEERVIDEO,
- AV_CODEC_ID_YLC,
- AV_CODEC_ID_PSD,
- AV_CODEC_ID_PIXLET,
- AV_CODEC_ID_SPEEDHQ,
- AV_CODEC_ID_FMVC,
- AV_CODEC_ID_SCPR,
- AV_CODEC_ID_CLEARVIDEO,
- AV_CODEC_ID_XPM,
- AV_CODEC_ID_AV1,
- AV_CODEC_ID_BITPACKED,
- AV_CODEC_ID_MSCC,
- AV_CODEC_ID_SRGC,
- AV_CODEC_ID_SVG,
- AV_CODEC_ID_GDV,
- AV_CODEC_ID_FITS,
-
- /* various PCM "codecs" */
- AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
- AV_CODEC_ID_PCM_S16LE = 0x10000,
- AV_CODEC_ID_PCM_S16BE,
- AV_CODEC_ID_PCM_U16LE,
- AV_CODEC_ID_PCM_U16BE,
- AV_CODEC_ID_PCM_S8,
- AV_CODEC_ID_PCM_U8,
- AV_CODEC_ID_PCM_MULAW,
- AV_CODEC_ID_PCM_ALAW,
- AV_CODEC_ID_PCM_S32LE,
- AV_CODEC_ID_PCM_S32BE,
- AV_CODEC_ID_PCM_U32LE,
- AV_CODEC_ID_PCM_U32BE,
- AV_CODEC_ID_PCM_S24LE,
- AV_CODEC_ID_PCM_S24BE,
- AV_CODEC_ID_PCM_U24LE,
- AV_CODEC_ID_PCM_U24BE,
- AV_CODEC_ID_PCM_S24DAUD,
- AV_CODEC_ID_PCM_ZORK,
- AV_CODEC_ID_PCM_S16LE_PLANAR,
- AV_CODEC_ID_PCM_DVD,
- AV_CODEC_ID_PCM_F32BE,
- AV_CODEC_ID_PCM_F32LE,
- AV_CODEC_ID_PCM_F64BE,
- AV_CODEC_ID_PCM_F64LE,
- AV_CODEC_ID_PCM_BLURAY,
- AV_CODEC_ID_PCM_LXF,
- AV_CODEC_ID_S302M,
- AV_CODEC_ID_PCM_S8_PLANAR,
- AV_CODEC_ID_PCM_S24LE_PLANAR,
- AV_CODEC_ID_PCM_S32LE_PLANAR,
- AV_CODEC_ID_PCM_S16BE_PLANAR,
-
- AV_CODEC_ID_PCM_S64LE = 0x10800,
- AV_CODEC_ID_PCM_S64BE,
- AV_CODEC_ID_PCM_F16LE,
- AV_CODEC_ID_PCM_F24LE,
-
- /* various ADPCM codecs */
- AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
- AV_CODEC_ID_ADPCM_IMA_WAV,
- AV_CODEC_ID_ADPCM_IMA_DK3,
- AV_CODEC_ID_ADPCM_IMA_DK4,
- AV_CODEC_ID_ADPCM_IMA_WS,
- AV_CODEC_ID_ADPCM_IMA_SMJPEG,
- AV_CODEC_ID_ADPCM_MS,
- AV_CODEC_ID_ADPCM_4XM,
- AV_CODEC_ID_ADPCM_XA,
- AV_CODEC_ID_ADPCM_ADX,
- AV_CODEC_ID_ADPCM_EA,
- AV_CODEC_ID_ADPCM_G726,
- AV_CODEC_ID_ADPCM_CT,
- AV_CODEC_ID_ADPCM_SWF,
- AV_CODEC_ID_ADPCM_YAMAHA,
- AV_CODEC_ID_ADPCM_SBPRO_4,
- AV_CODEC_ID_ADPCM_SBPRO_3,
- AV_CODEC_ID_ADPCM_SBPRO_2,
- AV_CODEC_ID_ADPCM_THP,
- AV_CODEC_ID_ADPCM_IMA_AMV,
- AV_CODEC_ID_ADPCM_EA_R1,
- AV_CODEC_ID_ADPCM_EA_R3,
- AV_CODEC_ID_ADPCM_EA_R2,
- AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
- AV_CODEC_ID_ADPCM_IMA_EA_EACS,
- AV_CODEC_ID_ADPCM_EA_XAS,
- AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
- AV_CODEC_ID_ADPCM_IMA_ISS,
- AV_CODEC_ID_ADPCM_G722,
- AV_CODEC_ID_ADPCM_IMA_APC,
- AV_CODEC_ID_ADPCM_VIMA,
-
- AV_CODEC_ID_ADPCM_AFC = 0x11800,
- AV_CODEC_ID_ADPCM_IMA_OKI,
- AV_CODEC_ID_ADPCM_DTK,
- AV_CODEC_ID_ADPCM_IMA_RAD,
- AV_CODEC_ID_ADPCM_G726LE,
- AV_CODEC_ID_ADPCM_THP_LE,
- AV_CODEC_ID_ADPCM_PSX,
- AV_CODEC_ID_ADPCM_AICA,
- AV_CODEC_ID_ADPCM_IMA_DAT4,
- AV_CODEC_ID_ADPCM_MTAF,
-
- /* AMR */
- AV_CODEC_ID_AMR_NB = 0x12000,
- AV_CODEC_ID_AMR_WB,
-
- /* RealAudio codecs*/
- AV_CODEC_ID_RA_144 = 0x13000,
- AV_CODEC_ID_RA_288,
-
- /* various DPCM codecs */
- AV_CODEC_ID_ROQ_DPCM = 0x14000,
- AV_CODEC_ID_INTERPLAY_DPCM,
- AV_CODEC_ID_XAN_DPCM,
- AV_CODEC_ID_SOL_DPCM,
-
- AV_CODEC_ID_SDX2_DPCM = 0x14800,
- AV_CODEC_ID_GREMLIN_DPCM,
-
- /* audio codecs */
- AV_CODEC_ID_MP2 = 0x15000,
- AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
- AV_CODEC_ID_AAC,
- AV_CODEC_ID_AC3,
- AV_CODEC_ID_DTS,
- AV_CODEC_ID_VORBIS,
- AV_CODEC_ID_DVAUDIO,
- AV_CODEC_ID_WMAV1,
- AV_CODEC_ID_WMAV2,
- AV_CODEC_ID_MACE3,
- AV_CODEC_ID_MACE6,
- AV_CODEC_ID_VMDAUDIO,
- AV_CODEC_ID_FLAC,
- AV_CODEC_ID_MP3ADU,
- AV_CODEC_ID_MP3ON4,
- AV_CODEC_ID_SHORTEN,
- AV_CODEC_ID_ALAC,
- AV_CODEC_ID_WESTWOOD_SND1,
- AV_CODEC_ID_GSM, ///< as in Berlin toast format
- AV_CODEC_ID_QDM2,
- AV_CODEC_ID_COOK,
- AV_CODEC_ID_TRUESPEECH,
- AV_CODEC_ID_TTA,
- AV_CODEC_ID_SMACKAUDIO,
- AV_CODEC_ID_QCELP,
- AV_CODEC_ID_WAVPACK,
- AV_CODEC_ID_DSICINAUDIO,
- AV_CODEC_ID_IMC,
- AV_CODEC_ID_MUSEPACK7,
- AV_CODEC_ID_MLP,
- AV_CODEC_ID_GSM_MS, /* as found in WAV */
- AV_CODEC_ID_ATRAC3,
- AV_CODEC_ID_APE,
- AV_CODEC_ID_NELLYMOSER,
- AV_CODEC_ID_MUSEPACK8,
- AV_CODEC_ID_SPEEX,
- AV_CODEC_ID_WMAVOICE,
- AV_CODEC_ID_WMAPRO,
- AV_CODEC_ID_WMALOSSLESS,
- AV_CODEC_ID_ATRAC3P,
- AV_CODEC_ID_EAC3,
- AV_CODEC_ID_SIPR,
- AV_CODEC_ID_MP1,
- AV_CODEC_ID_TWINVQ,
- AV_CODEC_ID_TRUEHD,
- AV_CODEC_ID_MP4ALS,
- AV_CODEC_ID_ATRAC1,
- AV_CODEC_ID_BINKAUDIO_RDFT,
- AV_CODEC_ID_BINKAUDIO_DCT,
- AV_CODEC_ID_AAC_LATM,
- AV_CODEC_ID_QDMC,
- AV_CODEC_ID_CELT,
- AV_CODEC_ID_G723_1,
- AV_CODEC_ID_G729,
- AV_CODEC_ID_8SVX_EXP,
- AV_CODEC_ID_8SVX_FIB,
- AV_CODEC_ID_BMV_AUDIO,
- AV_CODEC_ID_RALF,
- AV_CODEC_ID_IAC,
- AV_CODEC_ID_ILBC,
- AV_CODEC_ID_OPUS,
- AV_CODEC_ID_COMFORT_NOISE,
- AV_CODEC_ID_TAK,
- AV_CODEC_ID_METASOUND,
- AV_CODEC_ID_PAF_AUDIO,
- AV_CODEC_ID_ON2AVC,
- AV_CODEC_ID_DSS_SP,
- AV_CODEC_ID_CODEC2,
-
- AV_CODEC_ID_FFWAVESYNTH = 0x15800,
- AV_CODEC_ID_SONIC,
- AV_CODEC_ID_SONIC_LS,
- AV_CODEC_ID_EVRC,
- AV_CODEC_ID_SMV,
- AV_CODEC_ID_DSD_LSBF,
- AV_CODEC_ID_DSD_MSBF,
- AV_CODEC_ID_DSD_LSBF_PLANAR,
- AV_CODEC_ID_DSD_MSBF_PLANAR,
- AV_CODEC_ID_4GV,
- AV_CODEC_ID_INTERPLAY_ACM,
- AV_CODEC_ID_XMA1,
- AV_CODEC_ID_XMA2,
- AV_CODEC_ID_DST,
- AV_CODEC_ID_ATRAC3AL,
- AV_CODEC_ID_ATRAC3PAL,
- AV_CODEC_ID_DOLBY_E,
- AV_CODEC_ID_APTX,
- AV_CODEC_ID_APTX_HD,
- AV_CODEC_ID_SBC,
-
- /* subtitle codecs */
- AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
- AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
- AV_CODEC_ID_DVB_SUBTITLE,
- AV_CODEC_ID_TEXT, ///< raw UTF-8 text
- AV_CODEC_ID_XSUB,
- AV_CODEC_ID_SSA,
- AV_CODEC_ID_MOV_TEXT,
- AV_CODEC_ID_HDMV_PGS_SUBTITLE,
- AV_CODEC_ID_DVB_TELETEXT,
- AV_CODEC_ID_SRT,
-
- AV_CODEC_ID_MICRODVD = 0x17800,
- AV_CODEC_ID_EIA_608,
- AV_CODEC_ID_JACOSUB,
- AV_CODEC_ID_SAMI,
- AV_CODEC_ID_REALTEXT,
- AV_CODEC_ID_STL,
- AV_CODEC_ID_SUBVIEWER1,
- AV_CODEC_ID_SUBVIEWER,
- AV_CODEC_ID_SUBRIP,
- AV_CODEC_ID_WEBVTT,
- AV_CODEC_ID_MPL2,
- AV_CODEC_ID_VPLAYER,
- AV_CODEC_ID_PJS,
- AV_CODEC_ID_ASS,
- AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
-
- /* other specific kind of codecs (generally used for attachments) */
- AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs.
- AV_CODEC_ID_TTF = 0x18000,
-
- AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
- AV_CODEC_ID_BINTEXT = 0x18800,
- AV_CODEC_ID_XBIN,
- AV_CODEC_ID_IDF,
- AV_CODEC_ID_OTF,
- AV_CODEC_ID_SMPTE_KLV,
- AV_CODEC_ID_DVD_NAV,
- AV_CODEC_ID_TIMED_ID3,
- AV_CODEC_ID_BIN_DATA,
-
-
- AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
-
- AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
- * stream (only used by libavformat) */
- AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
- * stream (only used by libavformat) */
- AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
- AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
-};
-
-/**
- * This struct describes the properties of a single codec described by an
- * AVCodecID.
- * @see avcodec_descriptor_get()
- */
-typedef struct AVCodecDescriptor {
- enum AVCodecID id;
- enum AVMediaType type;
- /**
- * Name of the codec described by this descriptor. It is non-empty and
- * unique for each codec descriptor. It should contain alphanumeric
- * characters and '_' only.
- */
- const char *name;
- /**
- * A more descriptive name for this codec. May be NULL.
- */
- const char *long_name;
- /**
- * Codec properties, a combination of AV_CODEC_PROP_* flags.
- */
- int props;
- /**
- * MIME type(s) associated with the codec.
- * May be NULL; if not, a NULL-terminated array of MIME types.
- * The first item is always non-NULL and is the preferred MIME type.
- */
- const char *const *mime_types;
- /**
- * If non-NULL, an array of profiles recognized for this codec.
- * Terminated with FF_PROFILE_UNKNOWN.
- */
- const struct AVProfile *profiles;
-} AVCodecDescriptor;
-
-/**
- * Codec uses only intra compression.
- * Video and audio codecs only.
- */
-#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
-/**
- * Codec supports lossy compression. Audio and video codecs only.
- * @note a codec may support both lossy and lossless
- * compression modes
- */
-#define AV_CODEC_PROP_LOSSY (1 << 1)
-/**
- * Codec supports lossless compression. Audio and video codecs only.
- */
-#define AV_CODEC_PROP_LOSSLESS (1 << 2)
-/**
- * Codec supports frame reordering. That is, the coded order (the order in which
- * the encoded packets are output by the encoders / stored / input to the
- * decoders) may be different from the presentation order of the corresponding
- * frames.
- *
- * For codecs that do not have this property set, PTS and DTS should always be
- * equal.
- */
-#define AV_CODEC_PROP_REORDER (1 << 3)
-/**
- * Subtitle codec is bitmap based
- * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
- */
-#define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
-/**
- * Subtitle codec is text based.
- * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
- */
-#define AV_CODEC_PROP_TEXT_SUB (1 << 17)
-
-/**
- * @ingroup lavc_decoding
- * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
- * This is mainly needed because some optimized bitstream readers read
- * 32 or 64 bit at once and could read over the end. 
- * Note: If the first 23 bits of the additional bytes are not 0, then damaged
- * MPEG bitstreams could cause overread and segfault.
- */
-#define AV_INPUT_BUFFER_PADDING_SIZE 64
-
-/**
- * @ingroup lavc_encoding
- * minimum encoding buffer size
- * Used to avoid some checks during header writing.
- */
-#define AV_INPUT_BUFFER_MIN_SIZE 16384
-
-/**
- * @ingroup lavc_decoding
- */
-enum AVDiscard{
- /* We leave some space between them for extensions (drop some
- * keyframes for intra-only or drop just some bidir frames). */
- AVDISCARD_NONE =-16, ///< discard nothing
- AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi
- AVDISCARD_NONREF = 8, ///< discard all non reference
- AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames
- AVDISCARD_NONINTRA= 24, ///< discard all non intra frames
- AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
- AVDISCARD_ALL = 48, ///< discard all
-};
-
-enum AVAudioServiceType {
- AV_AUDIO_SERVICE_TYPE_MAIN = 0,
- AV_AUDIO_SERVICE_TYPE_EFFECTS = 1,
- AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
- AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3,
- AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4,
- AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5,
- AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6,
- AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7,
- AV_AUDIO_SERVICE_TYPE_KARAOKE = 8,
- AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI
-};
-
-/**
- * @ingroup lavc_encoding
- */
-typedef struct RcOverride{
- int start_frame;
- int end_frame;
- int qscale; // If this is 0 then quality_factor will be used instead.
- float quality_factor;
-} RcOverride;
-
-/* encoding support
- These flags can be passed in AVCodecContext.flags before initialization.
- Note: Not everything is supported yet.
-*/
-
-/**
- * Allow decoders to produce frames with data planes that are not aligned
- * to CPU requirements (e.g. due to cropping).
- */
-#define AV_CODEC_FLAG_UNALIGNED (1 << 0)
-/**
- * Use fixed qscale.
- */
-#define AV_CODEC_FLAG_QSCALE (1 << 1)
-/**
- * 4 MV per MB allowed / advanced prediction for H.263.
- */
-#define AV_CODEC_FLAG_4MV (1 << 2)
-/**
- * Output even those frames that might be corrupted.
- */
-#define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3)
-/**
- * Use qpel MC.
- */
-#define AV_CODEC_FLAG_QPEL (1 << 4)
-/**
- * Use internal 2pass ratecontrol in first pass mode.
- */
-#define AV_CODEC_FLAG_PASS1 (1 << 9)
-/**
- * Use internal 2pass ratecontrol in second pass mode.
- */
-#define AV_CODEC_FLAG_PASS2 (1 << 10)
-/**
- * loop filter.
- */
-#define AV_CODEC_FLAG_LOOP_FILTER (1 << 11)
-/**
- * Only decode/encode grayscale.
- */
-#define AV_CODEC_FLAG_GRAY (1 << 13)
-/**
- * error? variables will be set during encoding.
- */
-#define AV_CODEC_FLAG_PSNR (1 << 15)
-/**
- * Input bitstream might be truncated at a random location
- * instead of only at frame boundaries.
- */
-#define AV_CODEC_FLAG_TRUNCATED (1 << 16)
-/**
- * Use interlaced DCT.
- */
-#define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18)
-/**
- * Force low delay.
- */
-#define AV_CODEC_FLAG_LOW_DELAY (1 << 19)
-/**
- * Place global headers in extradata instead of every keyframe.
- */
-#define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22)
-/**
- * Use only bitexact stuff (except (I)DCT).
- */
-#define AV_CODEC_FLAG_BITEXACT (1 << 23)
-/* Fx : Flag for H.263+ extra options */
-/**
- * H.263 advanced intra coding / MPEG-4 AC prediction
- */
-#define AV_CODEC_FLAG_AC_PRED (1 << 24)
-/**
- * interlaced motion estimation
- */
-#define AV_CODEC_FLAG_INTERLACED_ME (1 << 29)
-#define AV_CODEC_FLAG_CLOSED_GOP (1U << 31)
-
-/**
- * Allow non spec compliant speedup tricks.
- */
-#define AV_CODEC_FLAG2_FAST (1 << 0)
-/**
- * Skip bitstream encoding.
- */
-#define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2)
-/**
- * Place global headers at every keyframe instead of in extradata.
- */
-#define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3)
-
-/**
- * timecode is in drop frame format. DEPRECATED!!!!
- */
-#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13)
-
-/**
- * Input bitstream might be truncated at a packet boundaries
- * instead of only at frame boundaries.
- */
-#define AV_CODEC_FLAG2_CHUNKS (1 << 15)
-/**
- * Discard cropping information from SPS.
- */
-#define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16)
-
-/**
- * Show all frames before the first keyframe
- */
-#define AV_CODEC_FLAG2_SHOW_ALL (1 << 22)
-/**
- * Export motion vectors through frame side data
- */
-#define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28)
-/**
- * Do not skip samples and export skip information as frame side data
- */
-#define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29)
-/**
- * Do not reset ASS ReadOrder field on flush (subtitles decoding)
- */
-#define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30)
-
-/* Unsupported options :
- * Syntax Arithmetic coding (SAC)
- * Reference Picture Selection
- * Independent Segment Decoding */
-/* /Fx */
-/* codec capabilities */
-
-/**
- * Decoder can use draw_horiz_band callback.
- */
-#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
-/**
- * Codec uses get_buffer() for allocating buffers and supports custom allocators.
- * If not set, it might not use get_buffer() at all or use operations that
- * assume the buffer was allocated by avcodec_default_get_buffer.
- */
-#define AV_CODEC_CAP_DR1 (1 << 1)
-#define AV_CODEC_CAP_TRUNCATED (1 << 3)
-/**
- * Encoder or decoder requires flushing with NULL input at the end in order to
- * give the complete and correct output.
- *
- * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
- * with NULL data. The user can still send NULL data to the public encode
- * or decode function, but libavcodec will not pass it along to the codec
- * unless this flag is set.
- *
- * Decoders:
- * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
- * avpkt->size=0 at the end to get the delayed data until the decoder no longer
- * returns frames.
- *
- * Encoders:
- * The encoder needs to be fed with NULL data at the end of encoding until the
- * encoder no longer returns data.
- *
- * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
- * flag also means that the encoder must set the pts and duration for
- * each output packet. If this flag is not set, the pts and duration will
- * be determined by libavcodec from the input frame.
- */
-#define AV_CODEC_CAP_DELAY (1 << 5)
-/**
- * Codec can be fed a final frame with a smaller size.
- * This can be used to prevent truncation of the last audio samples.
- */
-#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
-
-/**
- * Codec can output multiple frames per AVPacket
- * Normally demuxers return one frame at a time, demuxers which do not do
- * are connected to a parser to split what they return into proper frames.
- * This flag is reserved to the very rare category of codecs which have a
- * bitstream that cannot be split into frames without timeconsuming
- * operations like full decoding. Demuxers carrying such bitstreams thus
- * may return multiple frames in a packet. This has many disadvantages like
- * prohibiting stream copy in many cases thus it should only be considered
- * as a last resort.
- */
-#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
-/**
- * Codec is experimental and is thus avoided in favor of non experimental
- * encoders
- */
-#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
-/**
- * Codec should fill in channel configuration and samplerate instead of container
- */
-#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
-/**
- * Codec supports frame-level multithreading.
- */
-#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
-/**
- * Codec supports slice-based (or partition-based) multithreading.
- */
-#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
-/**
- * Codec supports changed parameters at any point.
- */
-#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
-/**
- * Codec supports avctx->thread_count == 0 (auto).
- */
-#define AV_CODEC_CAP_AUTO_THREADS (1 << 15)
-/**
- * Audio encoder supports receiving a different number of samples in each call.
- */
-#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
-/**
- * Decoder is not a preferred choice for probing.
- * This indicates that the decoder is not a good choice for probing.
- * It could for example be an expensive to spin up hardware decoder,
- * or it could simply not provide a lot of useful information about
- * the stream.
- * A decoder marked with this flag should only be used as last resort
- * choice for probing.
- */
-#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
-/**
- * Codec is intra only.
- */
-#define AV_CODEC_CAP_INTRA_ONLY 0x40000000
-/**
- * Codec is lossless.
- */
-#define AV_CODEC_CAP_LOSSLESS 0x80000000
-
-/**
- * Codec is backed by a hardware implementation. Typically used to
- * identify a non-hwaccel hardware decoder. For information about hwaccels, use
- * avcodec_get_hw_config() instead.
- */
-#define AV_CODEC_CAP_HARDWARE (1 << 18)
-
-/**
- * Codec is potentially backed by a hardware implementation, but not
- * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
- * implementation provides some sort of internal fallback.
- */
-#define AV_CODEC_CAP_HYBRID (1 << 19)
-
-/**
- * Pan Scan area.
- * This specifies the area which should be displayed.
- * Note there may be multiple such areas for one frame.
- */
-typedef struct AVPanScan {
- /**
- * id
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int id;
-
- /**
- * width and height in 1/16 pel
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int width;
- int height;
-
- /**
- * position of the top left corner in 1/16 pel for up to 3 fields/frames
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int16_t position32;
-} AVPanScan;
-
-/**
- * This structure describes the bitrate properties of an encoded bitstream. It
- * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD
- * parameters for H.264/HEVC.
- */
-typedef struct AVCPBProperties {
- /**
- * Maximum bitrate of the stream, in bits per second.
- * Zero if unknown or unspecified.
- */
- int max_bitrate;
- /**
- * Minimum bitrate of the stream, in bits per second.
- * Zero if unknown or unspecified.
- */
- int min_bitrate;
- /**
- * Average bitrate of the stream, in bits per second.
- * Zero if unknown or unspecified.
- */
- int avg_bitrate;
-
- /**
- * The size of the buffer to which the ratecontrol is applied, in bits.
- * Zero if unknown or unspecified.
- */
- int buffer_size;
-
- /**
- * The delay between the time the packet this structure is associated with
- * is received and the time when it should be decoded, in periods of a 27MHz
- * clock.
- *
- * UINT64_MAX when unknown or unspecified.
- */
- uint64_t vbv_delay;
-} AVCPBProperties;
-
-/**
- * The decoder will keep a reference to the frame and may reuse it later.
- */
-#define AV_GET_BUFFER_FLAG_REF (1 << 0)
-
-/**
- * @defgroup lavc_packet AVPacket
- *
- * Types and functions for working with AVPacket.
- * @{
- */
-enum AVPacketSideDataType {
- /**
- * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
- * bytes worth of palette. This side data signals that a new palette is
- * present.
- */
- AV_PKT_DATA_PALETTE,
-
- /**
- * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
- * that the extradata buffer was changed and the receiving side should
- * act upon it appropriately. The new extradata is embedded in the side
- * data buffer and should be immediately used for processing the current
- * frame or packet.
- */
- AV_PKT_DATA_NEW_EXTRADATA,
-
- /**
- * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
- * @code
- * u32le param_flags
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
- * s32le channel_count
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
- * u64le channel_layout
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
- * s32le sample_rate
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
- * s32le width
- * s32le height
- * @endcode
- */
- AV_PKT_DATA_PARAM_CHANGE,
-
- /**
- * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
- * structures with info about macroblocks relevant to splitting the
- * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
- * That is, it does not necessarily contain info about all macroblocks,
- * as long as the distance between macroblocks in the info is smaller
- * than the target payload size.
- * Each MB info structure is 12 bytes, and is laid out as follows:
- * @code
- * u32le bit offset from the start of the packet
- * u8 current quantizer at the start of the macroblock
- * u8 GOB number
- * u16le macroblock address within the GOB
- * u8 horizontal MV predictor
- * u8 vertical MV predictor
- * u8 horizontal MV predictor for block number 3
- * u8 vertical MV predictor for block number 3
- * @endcode
- */
- AV_PKT_DATA_H263_MB_INFO,
-
- /**
- * This side data should be associated with an audio stream and contains
- * ReplayGain information in form of the AVReplayGain struct.
- */
- AV_PKT_DATA_REPLAYGAIN,
-
- /**
- * This side data contains a 3x3 transformation matrix describing an affine
- * transformation that needs to be applied to the decoded video frames for
- * correct presentation.
- *
- * See libavutil/display.h for a detailed description of the data.
- */
- AV_PKT_DATA_DISPLAYMATRIX,
-
- /**
- * This side data should be associated with a video stream and contains
- * Stereoscopic 3D information in form of the AVStereo3D struct.
- */
- AV_PKT_DATA_STEREO3D,
-
- /**
- * This side data should be associated with an audio stream and corresponds
- * to enum AVAudioServiceType.
- */
- AV_PKT_DATA_AUDIO_SERVICE_TYPE,
-
- /**
- * This side data contains quality related information from the encoder.
- * @code
- * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
- * u8 picture type
- * u8 error count
- * u16 reserved
- * u64leerror count sum of squared differences between encoder in and output
- * @endcode
- */
- AV_PKT_DATA_QUALITY_STATS,
-
- /**
- * This side data contains an integer value representing the stream index
- * of a "fallback" track. A fallback track indicates an alternate
- * track to use when the current track can not be decoded for some reason.
- * e.g. no decoder available for codec.
- */
- AV_PKT_DATA_FALLBACK_TRACK,
-
- /**
- * This side data corresponds to the AVCPBProperties struct.
- */
- AV_PKT_DATA_CPB_PROPERTIES,
-
- /**
- * Recommmends skipping the specified number of samples
- * @code
- * u32le number of samples to skip from start of this packet
- * u32le number of samples to skip from end of this packet
- * u8 reason for start skip
- * u8 reason for end skip (0=padding silence, 1=convergence)
- * @endcode
- */
- AV_PKT_DATA_SKIP_SAMPLES,
-
- /**
- * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
- * the packet may contain "dual mono" audio specific to Japanese DTV
- * and if it is true, recommends only the selected channel to be used.
- * @code
- * u8 selected channels (0=mail/left, 1=sub/right, 2=both)
- * @endcode
- */
- AV_PKT_DATA_JP_DUALMONO,
-
- /**
- * A list of zero terminated key/value strings. There is no end marker for
- * the list, so it is required to rely on the side data size to stop.
- */
- AV_PKT_DATA_STRINGS_METADATA,
-
- /**
- * Subtitle event position
- * @code
- * u32le x1
- * u32le y1
- * u32le x2
- * u32le y2
- * @endcode
- */
- AV_PKT_DATA_SUBTITLE_POSITION,
-
- /**
- * Data found in BlockAdditional element of matroska container. There is
- * no end marker for the data, so it is required to rely on the side data
- * size to recognize the end. 8 byte id (as found in BlockAddId) followed
- * by data.
- */
- AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
-
- /**
- * The optional first identifier line of a WebVTT cue.
- */
- AV_PKT_DATA_WEBVTT_IDENTIFIER,
-
- /**
- * The optional settings (rendering instructions) that immediately
- * follow the timestamp specifier of a WebVTT cue.
- */
- AV_PKT_DATA_WEBVTT_SETTINGS,
-
- /**
- * A list of zero terminated key/value strings. There is no end marker for
- * the list, so it is required to rely on the side data size to stop. This
- * side data includes updated metadata which appeared in the stream.
- */
- AV_PKT_DATA_METADATA_UPDATE,
-
- /**
- * MPEGTS stream ID, this is required to pass the stream ID
- * information from the demuxer to the corresponding muxer.
- */
- AV_PKT_DATA_MPEGTS_STREAM_ID,
-
- /**
- * Mastering display metadata (based on SMPTE-2086:2014). This metadata
- * should be associated with a video stream and contains data in the form
- * of the AVMasteringDisplayMetadata struct.
- */
- AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
-
- /**
- * This side data should be associated with a video stream and corresponds
- * to the AVSphericalMapping structure.
- */
- AV_PKT_DATA_SPHERICAL,
-
- /**
- * Content light level (based on CTA-861.3). This metadata should be
- * associated with a video stream and contains data in the form of the
- * AVContentLightMetadata struct.
- */
- AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
-
- /**
- * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
- * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
- * The number of bytes of CC data is AVPacketSideData.size.
- */
- AV_PKT_DATA_A53_CC,
-
- /**
- * This side data is encryption initialization data.
- * The format is not part of ABI, use av_encryption_init_info_* methods to
- * access.
- */
- AV_PKT_DATA_ENCRYPTION_INIT_INFO,
-
- /**
- * This side data contains encryption info for how to decrypt the packet.
- * The format is not part of ABI, use av_encryption_info_* methods to access.
- */
- AV_PKT_DATA_ENCRYPTION_INFO,
-
- /**
- * The number of side data types.
- * This is not part of the public API/ABI in the sense that it may
- * change when new side data types are added.
- * This must stay the last enum value.
- * If its value becomes huge, some code using it
- * needs to be updated as it assumes it to be smaller than other limits.
- */
- AV_PKT_DATA_NB
-};
-
-#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
-
-typedef struct AVPacketSideData {
- uint8_t *data;
- int size;
- enum AVPacketSideDataType type;
-} AVPacketSideData;
-
-/**
- * This structure stores compressed data. It is typically exported by demuxers
- * and then passed as input to decoders, or received as output from encoders and
- * then passed to muxers.
- *
- * For video, it should typically contain one compressed frame. For audio it may
- * contain several compressed frames. Encoders are allowed to output empty
- * packets, with no compressed data, containing only side data
- * (e.g. to update some stream parameters at the end of encoding).
- *
- * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
- * ABI. Thus it may be allocated on stack and no new fields can be added to it
- * without libavcodec and libavformat major bump.
- *
- * The semantics of data ownership depends on the buf field.
- * If it is set, the packet data is dynamically allocated and is
- * valid indefinitely until a call to av_packet_unref() reduces the
- * reference count to 0.
- *
- * If the buf field is not set av_packet_ref() would make a copy instead
- * of increasing the reference count.
- *
- * The side data is always allocated with av_malloc(), copied by
- * av_packet_ref() and freed by av_packet_unref().
- *
- * @see av_packet_ref
- * @see av_packet_unref
- */
-typedef struct AVPacket {
- /**
- * A reference to the reference-counted buffer where the packet data is
- * stored.
- * May be NULL, then the packet data is not reference-counted.
- */
- AVBufferRef *buf;
- /**
- * Presentation timestamp in AVStream->time_base units; the time at which
- * the decompressed packet will be presented to the user.
- * Can be AV_NOPTS_VALUE if it is not stored in the file.
- * pts MUST be larger or equal to dts as presentation cannot happen before
- * decompression, unless one wants to view hex dumps. Some formats misuse
- * the terms dts and pts/cts to mean something different. Such timestamps
- * must be converted to true pts/dts before they are stored in AVPacket.
- */
- int64_t pts;
- /**
- * Decompression timestamp in AVStream->time_base units; the time at which
- * the packet is decompressed.
- * Can be AV_NOPTS_VALUE if it is not stored in the file.
- */
- int64_t dts;
- uint8_t *data;
- int size;
- int stream_index;
- /**
- * A combination of AV_PKT_FLAG values
- */
- int flags;
- /**
- * Additional packet data that can be provided by the container.
- * Packet can contain several types of side information.
- */
- AVPacketSideData *side_data;
- int side_data_elems;
-
- /**
- * Duration of this packet in AVStream->time_base units, 0 if unknown.
- * Equals next_pts - this_pts in presentation order.
- */
- int64_t duration;
-
- int64_t pos; ///< byte position in stream, -1 if unknown
-
-#if FF_API_CONVERGENCE_DURATION
- /**
- * @deprecated Same as the duration field, but as int64_t. This was required
- * for Matroska subtitles, whose duration values could overflow when the
- * duration field was still an int.
- */
- attribute_deprecated
- int64_t convergence_duration;
-#endif
-} AVPacket;
-#define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
-#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
-/**
- * Flag is used to discard packets which are required to maintain valid
- * decoder state but are not required for output and should be dropped
- * after decoding.
- **/
-#define AV_PKT_FLAG_DISCARD 0x0004
-/**
- * The packet comes from a trusted source.
- *
- * Otherwise-unsafe constructs such as arbitrary pointers to data
- * outside the packet may be followed.
- */
-#define AV_PKT_FLAG_TRUSTED 0x0008
-/**
- * Flag is used to indicate packets that contain frames that can
- * be discarded by the decoder. I.e. Non-reference frames.
- */
-#define AV_PKT_FLAG_DISPOSABLE 0x0010
-
-
-enum AVSideDataParamChangeFlags {
- AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
- AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
- AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
- AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
-};
-/**
- * @}
- */
-
-struct AVCodecInternal;
-
-enum AVFieldOrder {
- AV_FIELD_UNKNOWN,
- AV_FIELD_PROGRESSIVE,
- AV_FIELD_TT, //< Top coded_first, top displayed first
- AV_FIELD_BB, //< Bottom coded first, bottom displayed first
- AV_FIELD_TB, //< Top coded first, bottom displayed first
- AV_FIELD_BT, //< Bottom coded first, top displayed first
-};
-
-/**
- * main external API structure.
- * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing fields require a major
- * version bump.
- * You can use AVOptions (av_opt* / av_set/get*()) to access these fields from user
- * applications.
- * The name string for AVOptions options matches the associated command line
- * parameter name and can be found in libavcodec/options_table.h
- * The AVOption/command line parameter names differ in some cases from the C
- * structure field names for historic reasons or brevity.
- * sizeof(AVCodecContext) must not be used outside libav*.
- */
-typedef struct AVCodecContext {
- /**
- * information on struct for av_log
- * - set by avcodec_alloc_context3
- */
- const AVClass *av_class;
- int log_level_offset;
-
- enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
- const struct AVCodec *codec;
- enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */
-
- /**
- * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
- * This is used to work around some encoder bugs.
- * A demuxer should set this to what is stored in the field used to identify the codec.
- * If there are multiple such fields in a container then the demuxer should choose the one
- * which maximizes the information about the used codec.
- * If the codec tag field in a container is larger than 32 bits then the demuxer should
- * remap the longer ID to 32 bits with a table or other structure. Alternatively a new
- * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated
- * first.
- * - encoding: Set by user, if not then the default based on codec_id will be used.
- * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
- */
- unsigned int codec_tag;
-
- void *priv_data;
-
- /**
- * Private context used for internal data.
- *
- * Unlike priv_data, this is not codec-specific. It is used in general
- * libavcodec functions.
- */
- struct AVCodecInternal *internal;
-
- /**
- * Private data of the user, can be used to carry app specific stuff.
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- void *opaque;
-
- /**
- * the average bitrate
- * - encoding: Set by user; unused for constant quantizer encoding.
- * - decoding: Set by user, may be overwritten by libavcodec
- * if this info is available in the stream
- */
- int64_t bit_rate;
-
- /**
- * number of bits the bitstream is allowed to diverge from the reference.
- * the reference can be CBR (for CBR pass1) or VBR (for pass2)
- * - encoding: Set by user; unused for constant quantizer encoding.
- * - decoding: unused
- */
- int bit_rate_tolerance;
-
- /**
- * Global quality for codecs which cannot change it per frame.
- * This should be proportional to MPEG-1/2/4 qscale.
- * - encoding: Set by user.
- * - decoding: unused
- */
- int global_quality;
-
- /**
- * - encoding: Set by user.
- * - decoding: unused
- */
- int compression_level;
-#define FF_COMPRESSION_DEFAULT -1
-
- /**
- * AV_CODEC_FLAG_*.
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int flags;
-
- /**
- * AV_CODEC_FLAG2_*
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int flags2;
-
- /**
- * some codecs need / can use extradata like Huffman tables.
- * MJPEG: Huffman tables
- * rv10: additional flags
- * MPEG-4: global headers (they can be in the bitstream or here)
- * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger
- * than extradata_size to avoid problems if it is read with the bitstream reader.
- * The bytewise contents of extradata must not depend on the architecture or CPU endianness.
- * - encoding: Set/allocated/freed by libavcodec.
- * - decoding: Set/allocated/freed by user.
- */
- uint8_t *extradata;
- int extradata_size;
-
- /**
- * This is the fundamental unit of time (in seconds) in terms
- * of which frame timestamps are represented. For fixed-fps content,
- * timebase should be 1/framerate and timestamp increments should be
- * identically 1.
- * This often, but not always is the inverse of the frame rate or field rate
- * for video. 1/time_base is not the average frame rate if the frame rate is not
- * constant.
- *
- * Like containers, elementary streams also can store timestamps, 1/time_base
- * is the unit in which these timestamps are specified.
- * As example of such codec time base see ISO/IEC 14496-2:2001(E)
- * vop_time_increment_resolution and fixed_vop_rate
- * (fixed_vop_rate == 0 implies that it is different from the framerate)
- *
- * - encoding: MUST be set by user.
- * - decoding: the use of this field for decoding is deprecated.
- * Use framerate instead.
- */
- AVRational time_base;
-
- /**
- * For some codecs, the time base is closer to the field rate than the frame rate.
- * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration
- * if no telecine is used ...
- *
- * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
- */
- int ticks_per_frame;
-
- /**
- * Codec delay.
- *
- * Encoding: Number of frames delay there will be from the encoder input to
- * the decoder output. (we assume the decoder matches the spec)
- * Decoding: Number of frames delay in addition to what a standard decoder
- * as specified in the spec would produce.
- *
- * Video:
- * Number of frames the decoded output will be delayed relative to the
- * encoded input.
- *
- * Audio:
- * For encoding, this field is unused (see initial_padding).
- *
- * For decoding, this is the number of samples the decoder needs to
- * output before the decoder's output is valid. When seeking, you should
- * start decoding this many samples prior to your desired seek point.
- *
- * - encoding: Set by libavcodec.
- * - decoding: Set by libavcodec.
- */
- int delay;
-
-
- /* video only */
- /**
- * picture width / height.
- *
- * @note Those fields may not match the values of the last
- * AVFrame output by avcodec_decode_video2 due frame
- * reordering.
- *
- * - encoding: MUST be set by user.
- * - decoding: May be set by the user before opening the decoder if known e.g.
- * from the container. Some decoders will require the dimensions
- * to be set by the caller. During decoding, the decoder may
- * overwrite those values as required while parsing the data.
- */
- int width, height;
-
- /**
- * Bitstream width / height, may be different from width/height e.g. when
- * the decoded frame is cropped before being output or lowres is enabled.
- *
- * @note Those field may not match the value of the last
- * AVFrame output by avcodec_receive_frame() due frame
- * reordering.
- *
- * - encoding: unused
- * - decoding: May be set by the user before opening the decoder if known
- * e.g. from the container. During decoding, the decoder may
- * overwrite those values as required while parsing the data.
- */
- int coded_width, coded_height;
-
- /**
- * the number of pictures in a group of pictures, or 0 for intra_only
- * - encoding: Set by user.
- * - decoding: unused
- */
- int gop_size;
-
- /**
- * Pixel format, see AV_PIX_FMT_xxx.
- * May be set by the demuxer if known from headers.
- * May be overridden by the decoder if it knows better.
- *
- * @note This field may not match the value of the last
- * AVFrame output by avcodec_receive_frame() due frame
- * reordering.
- *
- * - encoding: Set by user.
- * - decoding: Set by user if known, overridden by libavcodec while
- * parsing the data.
- */
- enum AVPixelFormat pix_fmt;
-
- /**
- * If non NULL, 'draw_horiz_band' is called by the libavcodec
- * decoder to draw a horizontal band. It improves cache usage. Not
- * all codecs can do that. You must check the codec capabilities
- * beforehand.
- * When multithreading is used, it may be called from multiple threads
- * at the same time; threads might draw different parts of the same AVFrame,
- * or multiple AVFrames, and there is no guarantee that slices will be drawn
- * in order.
- * The function is also used by hardware acceleration APIs.
- * It is called at least once during frame decoding to pass
- * the data needed for hardware render.
- * In that mode instead of pixel data, AVFrame points to
- * a structure specific to the acceleration API. The application
- * reads the structure and can change some fields to indicate progress
- * or mark state.
- * - encoding: unused
- * - decoding: Set by user.
- * @param height the height of the slice
- * @param y the y position of the slice
- * @param type 1->top field, 2->bottom field, 3->frame
- * @param offset offset into the AVFrame.data from which the slice should be read
- */
- void (*draw_horiz_band)(struct AVCodecContext *s,
- const AVFrame *src, int offsetAV_NUM_DATA_POINTERS,
- int y, int type, int height);
-
- /**
- * callback to negotiate the pixelFormat
- * @param fmt is the list of formats which are supported by the codec,
- * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality.
- * The first is always the native one.
- * @note The callback may be called again immediately if initialization for
- * the selected (hardware-accelerated) pixel format failed.
- * @warning Behavior is undefined if the callback returns a value not
- * in the fmt list of formats.
- * @return the chosen format
- * - encoding: unused
- * - decoding: Set by user, if not set the native format will be chosen.
- */
- enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
-
- /**
- * maximum number of B-frames between non-B-frames
- * Note: The output will be delayed by max_b_frames+1 relative to the input.
- * - encoding: Set by user.
- * - decoding: unused
- */
- int max_b_frames;
-
- /**
- * qscale factor between IP and B-frames
- * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset).
- * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
- * - encoding: Set by user.
- * - decoding: unused
- */
- float b_quant_factor;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int b_frame_strategy;
-#endif
-
- /**
- * qscale offset between IP and B-frames
- * - encoding: Set by user.
- * - decoding: unused
- */
- float b_quant_offset;
-
- /**
- * Size of the frame reordering buffer in the decoder.
- * For MPEG-2 it is 1 IPB or 0 low delay IP.
- * - encoding: Set by libavcodec.
- * - decoding: Set by libavcodec.
- */
- int has_b_frames;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int mpeg_quant;
-#endif
-
- /**
- * qscale factor between P- and I-frames
- * If > 0 then the last P-frame quantizer will be used (q = lastp_q * factor + offset).
- * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
- * - encoding: Set by user.
- * - decoding: unused
- */
- float i_quant_factor;
-
- /**
- * qscale offset between P and I-frames
- * - encoding: Set by user.
- * - decoding: unused
- */
- float i_quant_offset;
-
- /**
- * luminance masking (0-> disabled)
- * - encoding: Set by user.
- * - decoding: unused
- */
- float lumi_masking;
-
- /**
- * temporary complexity masking (0-> disabled)
- * - encoding: Set by user.
- * - decoding: unused
- */
- float temporal_cplx_masking;
-
- /**
- * spatial complexity masking (0-> disabled)
- * - encoding: Set by user.
- * - decoding: unused
- */
- float spatial_cplx_masking;
-
- /**
- * p block masking (0-> disabled)
- * - encoding: Set by user.
- * - decoding: unused
- */
- float p_masking;
-
- /**
- * darkness masking (0-> disabled)
- * - encoding: Set by user.
- * - decoding: unused
- */
- float dark_masking;
-
- /**
- * slice count
- * - encoding: Set by libavcodec.
- * - decoding: Set by user (or 0).
- */
- int slice_count;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int prediction_method;
-#define FF_PRED_LEFT 0
-#define FF_PRED_PLANE 1
-#define FF_PRED_MEDIAN 2
-#endif
-
- /**
- * slice offsets in the frame in bytes
- * - encoding: Set/allocated by libavcodec.
- * - decoding: Set/allocated by user (or NULL).
- */
- int *slice_offset;
-
- /**
- * sample aspect ratio (0 if unknown)
- * That is the width of a pixel divided by the height of the pixel.
- * Numerator and denominator must be relatively prime and smaller than 256 for some video standards.
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- AVRational sample_aspect_ratio;
-
- /**
- * motion estimation comparison function
- * - encoding: Set by user.
- * - decoding: unused
- */
- int me_cmp;
- /**
- * subpixel motion estimation comparison function
- * - encoding: Set by user.
- * - decoding: unused
- */
- int me_sub_cmp;
- /**
- * macroblock comparison function (not supported yet)
- * - encoding: Set by user.
- * - decoding: unused
- */
- int mb_cmp;
- /**
- * interlaced DCT comparison function
- * - encoding: Set by user.
- * - decoding: unused
- */
- int ildct_cmp;
-#define FF_CMP_SAD 0
-#define FF_CMP_SSE 1
-#define FF_CMP_SATD 2
-#define FF_CMP_DCT 3
-#define FF_CMP_PSNR 4
-#define FF_CMP_BIT 5
-#define FF_CMP_RD 6
-#define FF_CMP_ZERO 7
-#define FF_CMP_VSAD 8
-#define FF_CMP_VSSE 9
-#define FF_CMP_NSSE 10
-#define FF_CMP_W53 11
-#define FF_CMP_W97 12
-#define FF_CMP_DCTMAX 13
-#define FF_CMP_DCT264 14
-#define FF_CMP_MEDIAN_SAD 15
-#define FF_CMP_CHROMA 256
-
- /**
- * ME diamond size & shape
- * - encoding: Set by user.
- * - decoding: unused
- */
- int dia_size;
-
- /**
- * amount of previous MV predictors (2a+1 x 2a+1 square)
- * - encoding: Set by user.
- * - decoding: unused
- */
- int last_predictor_count;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int pre_me;
-#endif
-
- /**
- * motion estimation prepass comparison function
- * - encoding: Set by user.
- * - decoding: unused
- */
- int me_pre_cmp;
-
- /**
- * ME prepass diamond size & shape
- * - encoding: Set by user.
- * - decoding: unused
- */
- int pre_dia_size;
-
- /**
- * subpel ME quality
- * - encoding: Set by user.
- * - decoding: unused
- */
- int me_subpel_quality;
-
- /**
- * maximum motion estimation search range in subpel units
- * If 0 then no limit.
- *
- * - encoding: Set by user.
- * - decoding: unused
- */
- int me_range;
-
- /**
- * slice flags
- * - encoding: unused
- * - decoding: Set by user.
- */
- int slice_flags;
-#define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display
-#define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG-2 field pics)
-#define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
-
- /**
- * macroblock decision mode
- * - encoding: Set by user.
- * - decoding: unused
- */
- int mb_decision;
-#define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp
-#define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits
-#define FF_MB_DECISION_RD 2 ///< rate distortion
-
- /**
- * custom intra quantization matrix
- * - encoding: Set by user, can be NULL.
- * - decoding: Set by libavcodec.
- */
- uint16_t *intra_matrix;
-
- /**
- * custom inter quantization matrix
- * - encoding: Set by user, can be NULL.
- * - decoding: Set by libavcodec.
- */
- uint16_t *inter_matrix;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int scenechange_threshold;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int noise_reduction;
-#endif
-
- /**
- * precision of the intra DC coefficient - 8
- * - encoding: Set by user.
- * - decoding: Set by libavcodec
- */
- int intra_dc_precision;
-
- /**
- * Number of macroblock rows at the top which are skipped.
- * - encoding: unused
- * - decoding: Set by user.
- */
- int skip_top;
-
- /**
- * Number of macroblock rows at the bottom which are skipped.
- * - encoding: unused
- * - decoding: Set by user.
- */
- int skip_bottom;
-
- /**
- * minimum MB Lagrange multiplier
- * - encoding: Set by user.
- * - decoding: unused
- */
- int mb_lmin;
-
- /**
- * maximum MB Lagrange multiplier
- * - encoding: Set by user.
- * - decoding: unused
- */
- int mb_lmax;
-
-#if FF_API_PRIVATE_OPT
- /**
- * @deprecated use encoder private options instead
- */
- attribute_deprecated
- int me_penalty_compensation;
-#endif
-
- /**
- * - encoding: Set by user.
- * - decoding: unused
- */
- int bidir_refine;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int brd_scale;
-#endif
-
- /**
- * minimum GOP size
- * - encoding: Set by user.
- * - decoding: unused
- */
- int keyint_min;
-
- /**
- * number of reference frames
- * - encoding: Set by user.
- * - decoding: Set by lavc.
- */
- int refs;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int chromaoffset;
-#endif
-
- /**
- * Note: Value depends upon the compare function used for fullpel ME.
- * - encoding: Set by user.
- * - decoding: unused
- */
- int mv0_threshold;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int b_sensitivity;
-#endif
-
- /**
- * Chromaticity coordinates of the source primaries.
- * - encoding: Set by user
- * - decoding: Set by libavcodec
- */
- enum AVColorPrimaries color_primaries;
-
- /**
- * Color Transfer Characteristic.
- * - encoding: Set by user
- * - decoding: Set by libavcodec
- */
- enum AVColorTransferCharacteristic color_trc;
-
- /**
- * YUV colorspace type.
- * - encoding: Set by user
- * - decoding: Set by libavcodec
- */
- enum AVColorSpace colorspace;
-
- /**
- * MPEG vs JPEG YUV range.
- * - encoding: Set by user
- * - decoding: Set by libavcodec
- */
- enum AVColorRange color_range;
-
- /**
- * This defines the location of chroma samples.
- * - encoding: Set by user
- * - decoding: Set by libavcodec
- */
- enum AVChromaLocation chroma_sample_location;
-
- /**
- * Number of slices.
- * Indicates number of picture subdivisions. Used for parallelized
- * decoding.
- * - encoding: Set by user
- * - decoding: unused
- */
- int slices;
-
- /** Field order
- * - encoding: set by libavcodec
- * - decoding: Set by user.
- */
- enum AVFieldOrder field_order;
-
- /* audio only */
- int sample_rate; ///< samples per second
- int channels; ///< number of audio channels
-
- /**
- * audio sample format
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- enum AVSampleFormat sample_fmt; ///< sample format
-
- /* The following data should not be initialized. */
- /**
- * Number of samples per channel in an audio frame.
- *
- * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame
- * except the last must contain exactly frame_size samples per channel.
- * May be 0 when the codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE set, then the
- * frame size is not restricted.
- * - decoding: may be set by some decoders to indicate constant frame size
- */
- int frame_size;
-
- /**
- * Frame counter, set by libavcodec.
- *
- * - decoding: total number of frames returned from the decoder so far.
- * - encoding: total number of frames passed to the encoder so far.
- *
- * @note the counter is not incremented if encoding/decoding resulted in
- * an error.
- */
- int frame_number;
-
- /**
- * number of bytes per packet if constant and known or 0
- * Used by some WAV based audio codecs.
- */
- int block_align;
-
- /**
- * Audio cutoff bandwidth (0 means "automatic")
- * - encoding: Set by user.
- * - decoding: unused
- */
- int cutoff;
-
- /**
- * Audio channel layout.
- * - encoding: set by user.
- * - decoding: set by user, may be overwritten by libavcodec.
- */
- uint64_t channel_layout;
-
- /**
- * Request decoder to use this channel layout if it can (0 for default)
- * - encoding: unused
- * - decoding: Set by user.
- */
- uint64_t request_channel_layout;
-
- /**
- * Type of service that the audio stream conveys.
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- enum AVAudioServiceType audio_service_type;
-
- /**
- * desired sample format
- * - encoding: Not used.
- * - decoding: Set by user.
- * Decoder will decode to this format if it can.
- */
- enum AVSampleFormat request_sample_fmt;
-
- /**
- * This callback is called at the beginning of each frame to get data
- * buffer(s) for it. There may be one contiguous buffer for all the data or
- * there may be a buffer per each data plane or anything in between. What
- * this means is, you may set however many entries in buf you feel necessary.
- * Each buffer must be reference-counted using the AVBuffer API (see description
- * of buf below).
- *
- * The following fields will be set in the frame before this callback is
- * called:
- * - format
- * - width, height (video only)
- * - sample_rate, channel_layout, nb_samples (audio only)
- * Their values may differ from the corresponding values in
- * AVCodecContext. This callback must use the frame values, not the codec
- * context values, to calculate the required buffer size.
- *
- * This callback must fill the following fields in the frame:
- * - data
- * - linesize
- * - extended_data:
- * * if the data is planar audio with more than 8 channels, then this
- * callback must allocate and fill extended_data to contain all pointers
- * to all data planes. data must hold as many pointers as it can.
- * extended_data must be allocated with av_malloc() and will be freed in
- * av_frame_unref().
- * * otherwise extended_data must point to data
- * - buf must contain one or more pointers to AVBufferRef structures. Each of
- * the frame's data and extended_data pointers must be contained in these. That
- * is, one AVBufferRef for each allocated chunk of memory, not necessarily one
- * AVBufferRef per data entry. See: av_buffer_create(), av_buffer_alloc(),
- * and av_buffer_ref().
- * - extended_buf and nb_extended_buf must be allocated with av_malloc() by
- * this callback and filled with the extra buffers if there are more
- * buffers than buf can hold. extended_buf will be freed in
- * av_frame_unref().
- *
- * If AV_CODEC_CAP_DR1 is not set then get_buffer2() must call
- * avcodec_default_get_buffer2() instead of providing buffers allocated by
- * some other means.
- *
- * Each data plane must be aligned to the maximum required by the target
- * CPU.
- *
- * @see avcodec_default_get_buffer2()
- *
- * Video:
- *
- * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused
- * (read and/or written to if it is writable) later by libavcodec.
- *
- * avcodec_align_dimensions2() should be used to find the required width and
- * height, as they normally need to be rounded up to the next multiple of 16.
- *
- * Some decoders do not support linesizes changing between frames.
- *
- * If frame multithreading is used and thread_safe_callbacks is set,
- * this callback may be called from a different thread, but not from more
- * than one at once. Does not need to be reentrant.
- *
- * @see avcodec_align_dimensions2()
- *
- * Audio:
- *
- * Decoders request a buffer of a particular size by setting
- * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may,
- * however, utilize only part of the buffer by setting AVFrame.nb_samples
- * to a smaller value in the output frame.
- *
- * As a convenience, av_samples_get_buffer_size() and
- * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2()
- * functions to find the required data size and to fill data pointers and
- * linesize. In AVFrame.linesize, only linesize0 may be set for audio
- * since all planes must be the same size.
- *
- * @see av_samples_get_buffer_size(), av_samples_fill_arrays()
- *
- * - encoding: unused
- * - decoding: Set by libavcodec, user can override.
- */
- int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
-
- /**
- * If non-zero, the decoded audio and video frames returned from
- * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted
- * and are valid indefinitely. The caller must free them with
- * av_frame_unref() when they are not needed anymore.
- * Otherwise, the decoded frames must not be freed by the caller and are
- * only valid until the next decode call.
- *
- * This is always automatically enabled if avcodec_receive_frame() is used.
- *
- * - encoding: unused
- * - decoding: set by the caller before avcodec_open2().
- */
- attribute_deprecated
- int refcounted_frames;
-
- /* - encoding parameters */
- float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0)
- float qblur; ///< amount of qscale smoothing over time (0.0-1.0)
-
- /**
- * minimum quantizer
- * - encoding: Set by user.
- * - decoding: unused
- */
- int qmin;
-
- /**
- * maximum quantizer
- * - encoding: Set by user.
- * - decoding: unused
- */
- int qmax;
-
- /**
- * maximum quantizer difference between frames
- * - encoding: Set by user.
- * - decoding: unused
- */
- int max_qdiff;
-
- /**
- * decoder bitstream buffer size
- * - encoding: Set by user.
- * - decoding: unused
- */
- int rc_buffer_size;
-
- /**
- * ratecontrol override, see RcOverride
- * - encoding: Allocated/set/freed by user.
- * - decoding: unused
- */
- int rc_override_count;
- RcOverride *rc_override;
-
- /**
- * maximum bitrate
- * - encoding: Set by user.
- * - decoding: Set by user, may be overwritten by libavcodec.
- */
- int64_t rc_max_rate;
-
- /**
- * minimum bitrate
- * - encoding: Set by user.
- * - decoding: unused
- */
- int64_t rc_min_rate;
-
- /**
- * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.
- * - encoding: Set by user.
- * - decoding: unused.
- */
- float rc_max_available_vbv_use;
-
- /**
- * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.
- * - encoding: Set by user.
- * - decoding: unused.
- */
- float rc_min_vbv_overflow_use;
-
- /**
- * Number of bits which should be loaded into the rc buffer before decoding starts.
- * - encoding: Set by user.
- * - decoding: unused
- */
- int rc_initial_buffer_occupancy;
-
-#if FF_API_CODER_TYPE
-#define FF_CODER_TYPE_VLC 0
-#define FF_CODER_TYPE_AC 1
-#define FF_CODER_TYPE_RAW 2
-#define FF_CODER_TYPE_RLE 3
- /**
- * @deprecated use encoder private options instead
- */
- attribute_deprecated
- int coder_type;
-#endif /* FF_API_CODER_TYPE */
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int context_model;
-#endif
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_threshold;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_factor;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_exp;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_cmp;
-#endif /* FF_API_PRIVATE_OPT */
-
- /**
- * trellis RD quantization
- * - encoding: Set by user.
- * - decoding: unused
- */
- int trellis;
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int min_prediction_order;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int max_prediction_order;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int64_t timecode_frame_start;
-#endif
-
-#if FF_API_RTP_CALLBACK
- /**
- * @deprecated unused
- */
- /* The RTP callback: This function is called */
- /* every time the encoder has a packet to send. */
- /* It depends on the encoder if the data starts */
- /* with a Start Code (it should). H.263 does. */
- /* mb_nb contains the number of macroblocks */
- /* encoded in the RTP payload. */
- attribute_deprecated
- void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
-#endif
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int rtp_payload_size; /* The size of the RTP payload: the coder will */
- /* do its best to deliver a chunk with size */
- /* below rtp_payload_size, the chunk will start */
- /* with a start code on some codecs like H.263. */
- /* This doesn't take account of any particular */
- /* headers inside the transmitted RTP payload. */
-#endif
-
-#if FF_API_STAT_BITS
- /* statistics, used for 2-pass encoding */
- attribute_deprecated
- int mv_bits;
- attribute_deprecated
- int header_bits;
- attribute_deprecated
- int i_tex_bits;
- attribute_deprecated
- int p_tex_bits;
- attribute_deprecated
- int i_count;
- attribute_deprecated
- int p_count;
- attribute_deprecated
- int skip_count;
- attribute_deprecated
- int misc_bits;
-
- /** @deprecated this field is unused */
- attribute_deprecated
- int frame_bits;
-#endif
-
- /**
- * pass1 encoding statistics output buffer
- * - encoding: Set by libavcodec.
- * - decoding: unused
- */
- char *stats_out;
-
- /**
- * pass2 encoding statistics input buffer
- * Concatenated stuff from stats_out of pass1 should be placed here.
- * - encoding: Allocated/set/freed by user.
- * - decoding: unused
- */
- char *stats_in;
-
- /**
- * Work around bugs in encoders which sometimes cannot be detected automatically.
- * - encoding: Set by user
- * - decoding: Set by user
- */
- int workaround_bugs;
-#define FF_BUG_AUTODETECT 1 ///< autodetection
-#define FF_BUG_XVID_ILACE 4
-#define FF_BUG_UMP4 8
-#define FF_BUG_NO_PADDING 16
-#define FF_BUG_AMV 32
-#define FF_BUG_QPEL_CHROMA 64
-#define FF_BUG_STD_QPEL 128
-#define FF_BUG_QPEL_CHROMA2 256
-#define FF_BUG_DIRECT_BLOCKSIZE 512
-#define FF_BUG_EDGE 1024
-#define FF_BUG_HPEL_CHROMA 2048
-#define FF_BUG_DC_CLIP 4096
-#define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders.
-#define FF_BUG_TRUNCATED 16384
-#define FF_BUG_IEDGE 32768
-
- /**
- * strictly follow the standard (MPEG-4, ...).
- * - encoding: Set by user.
- * - decoding: Set by user.
- * Setting this to STRICT or higher means the encoder and decoder will
- * generally do stupid things, whereas setting it to unofficial or lower
- * will mean the encoder might produce output that is not supported by all
- * spec-compliant decoders. Decoders don't differentiate between normal,
- * unofficial and experimental (that is, they always try to decode things
- * when they can) unless they are explicitly asked to behave stupidly
- * (=strictly conform to the specs)
- */
- int strict_std_compliance;
-#define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software.
-#define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences.
-#define FF_COMPLIANCE_NORMAL 0
-#define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions
-#define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
-
- /**
- * error concealment flags
- * - encoding: unused
- * - decoding: Set by user.
- */
- int error_concealment;
-#define FF_EC_GUESS_MVS 1
-#define FF_EC_DEBLOCK 2
-#define FF_EC_FAVOR_INTER 256
-
- /**
- * debug
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int debug;
-#define FF_DEBUG_PICT_INFO 1
-#define FF_DEBUG_RC 2
-#define FF_DEBUG_BITSTREAM 4
-#define FF_DEBUG_MB_TYPE 8
-#define FF_DEBUG_QP 16
-#if FF_API_DEBUG_MV
-/**
- * @deprecated this option does nothing
- */
-#define FF_DEBUG_MV 32
-#endif
-#define FF_DEBUG_DCT_COEFF 0x00000040
-#define FF_DEBUG_SKIP 0x00000080
-#define FF_DEBUG_STARTCODE 0x00000100
-#define FF_DEBUG_ER 0x00000400
-#define FF_DEBUG_MMCO 0x00000800
-#define FF_DEBUG_BUGS 0x00001000
-#if FF_API_DEBUG_MV
-#define FF_DEBUG_VIS_QP 0x00002000
-#define FF_DEBUG_VIS_MB_TYPE 0x00004000
-#endif
-#define FF_DEBUG_BUFFERS 0x00008000
-#define FF_DEBUG_THREADS 0x00010000
-#define FF_DEBUG_GREEN_MD 0x00800000
-#define FF_DEBUG_NOMC 0x01000000
-
-#if FF_API_DEBUG_MV
- /**
- * debug
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int debug_mv;
-#define FF_DEBUG_VIS_MV_P_FOR 0x00000001 // visualize forward predicted MVs of P-frames
-#define FF_DEBUG_VIS_MV_B_FOR 0x00000002 // visualize forward predicted MVs of B-frames
-#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 // visualize backward predicted MVs of B-frames
-#endif
-
- /**
- * Error recognition; may misdetect some more or less valid parts as errors.
- * - encoding: unused
- * - decoding: Set by user.
- */
- int err_recognition;
-
-/**
- * Verify checksums embedded in the bitstream (could be of either encoded or
- * decoded data, depending on the codec) and print an error message on mismatch.
- * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the
- * decoder returning an error.
- */
-#define AV_EF_CRCCHECK (1<<0)
-#define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations
-#define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length
-#define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection
-
-#define AV_EF_IGNORE_ERR (1<<15) ///< ignore errors and continue
-#define AV_EF_CAREFUL (1<<16) ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
-#define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliances as errors
-#define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder should not do as an error
-
-
- /**
- * opaque 64-bit number (generally a PTS) that will be reordered and
- * output in AVFrame.reordered_opaque
- * - encoding: unused
- * - decoding: Set by user.
- */
- int64_t reordered_opaque;
-
- /**
- * Hardware accelerator in use
- * - encoding: unused.
- * - decoding: Set by libavcodec
- */
- const struct AVHWAccel *hwaccel;
-
- /**
- * Hardware accelerator context.
- * For some hardware accelerators, a global context needs to be
- * provided by the user. In that case, this holds display-dependent
- * data FFmpeg cannot instantiate itself. Please refer to the
- * FFmpeg HW accelerator documentation to know how to fill this
- * is. e.g. for VA API, this is a struct vaapi_context.
- * - encoding: unused
- * - decoding: Set by user
- */
- void *hwaccel_context;
-
- /**
- * error
- * - encoding: Set by libavcodec if flags & AV_CODEC_FLAG_PSNR.
- * - decoding: unused
- */
- uint64_t errorAV_NUM_DATA_POINTERS;
-
- /**
- * DCT algorithm, see FF_DCT_* below
- * - encoding: Set by user.
- * - decoding: unused
- */
- int dct_algo;
-#define FF_DCT_AUTO 0
-#define FF_DCT_FASTINT 1
-#define FF_DCT_INT 2
-#define FF_DCT_MMX 3
-#define FF_DCT_ALTIVEC 5
-#define FF_DCT_FAAN 6
-
- /**
- * IDCT algorithm, see FF_IDCT_* below.
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int idct_algo;
-#define FF_IDCT_AUTO 0
-#define FF_IDCT_INT 1
-#define FF_IDCT_SIMPLE 2
-#define FF_IDCT_SIMPLEMMX 3
-#define FF_IDCT_ARM 7
-#define FF_IDCT_ALTIVEC 8
-#define FF_IDCT_SIMPLEARM 10
-#define FF_IDCT_XVID 14
-#define FF_IDCT_SIMPLEARMV5TE 16
-#define FF_IDCT_SIMPLEARMV6 17
-#define FF_IDCT_FAAN 20
-#define FF_IDCT_SIMPLENEON 22
-#define FF_IDCT_NONE 24 /* Used by XvMC to extract IDCT coefficients with FF_IDCT_PERM_NONE */
-#define FF_IDCT_SIMPLEAUTO 128
-
- /**
- * bits per sample/pixel from the demuxer (needed for huffyuv).
- * - encoding: Set by libavcodec.
- * - decoding: Set by user.
- */
- int bits_per_coded_sample;
-
- /**
- * Bits per sample/pixel of internal libavcodec pixel/sample format.
- * - encoding: set by user.
- * - decoding: set by libavcodec.
- */
- int bits_per_raw_sample;
-
-#if FF_API_LOWRES
- /**
- * low resolution decoding, 1-> 1/2 size, 2->1/4 size
- * - encoding: unused
- * - decoding: Set by user.
- */
- int lowres;
-#endif
-
-#if FF_API_CODED_FRAME
- /**
- * the picture in the bitstream
- * - encoding: Set by libavcodec.
- * - decoding: unused
- *
- * @deprecated use the quality factor packet side data instead
- */
- attribute_deprecated AVFrame *coded_frame;
-#endif
-
- /**
- * thread count
- * is used to decide how many independent tasks should be passed to execute()
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int thread_count;
-
- /**
- * Which multithreading methods to use.
- * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread,
- * so clients which cannot provide future frames should not use it.
- *
- * - encoding: Set by user, otherwise the default is used.
- * - decoding: Set by user, otherwise the default is used.
- */
- int thread_type;
-#define FF_THREAD_FRAME 1 ///< Decode more than one frame at once
-#define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once
-
- /**
- * Which multithreading methods are in use by the codec.
- * - encoding: Set by libavcodec.
- * - decoding: Set by libavcodec.
- */
- int active_thread_type;
-
- /**
- * Set by the client if its custom get_buffer() callback can be called
- * synchronously from another thread, which allows faster multithreaded decoding.
- * draw_horiz_band() will be called from other threads regardless of this setting.
- * Ignored if the default get_buffer() is used.
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int thread_safe_callbacks;
-
- /**
- * The codec may call this to execute several independent things.
- * It will return only after finishing all tasks.
- * The user may replace this with some multithreaded implementation,
- * the default implementation will execute the parts serially.
- * @param count the number of things to execute
- * - encoding: Set by libavcodec, user can override.
- * - decoding: Set by libavcodec, user can override.
- */
- int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
-
- /**
- * The codec may call this to execute several independent things.
- * It will return only after finishing all tasks.
- * The user may replace this with some multithreaded implementation,
- * the default implementation will execute the parts serially.
- * Also see avcodec_thread_init and e.g. the --enable-pthread configure option.
- * @param c context passed also to func
- * @param count the number of things to execute
- * @param arg2 argument passed unchanged to func
- * @param ret return values of executed functions, must have space for "count" values. May be NULL.
- * @param func function that will be called count times, with jobnr from 0 to count-1.
- * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no
- * two instances of func executing at the same time will have the same threadnr.
- * @return always 0 currently, but code should handle a future improvement where when any call to func
- * returns < 0 no further calls to func may be done and < 0 is returned.
- * - encoding: Set by libavcodec, user can override.
- * - decoding: Set by libavcodec, user can override.
- */
- int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
-
- /**
- * noise vs. sse weight for the nsse comparison function
- * - encoding: Set by user.
- * - decoding: unused
- */
- int nsse_weight;
-
- /**
- * profile
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int profile;
-#define FF_PROFILE_UNKNOWN -99
-#define FF_PROFILE_RESERVED -100
-
-#define FF_PROFILE_AAC_MAIN 0
-#define FF_PROFILE_AAC_LOW 1
-#define FF_PROFILE_AAC_SSR 2
-#define FF_PROFILE_AAC_LTP 3
-#define FF_PROFILE_AAC_HE 4
-#define FF_PROFILE_AAC_HE_V2 28
-#define FF_PROFILE_AAC_LD 22
-#define FF_PROFILE_AAC_ELD 38
-#define FF_PROFILE_MPEG2_AAC_LOW 128
-#define FF_PROFILE_MPEG2_AAC_HE 131
-
-#define FF_PROFILE_DNXHD 0
-#define FF_PROFILE_DNXHR_LB 1
-#define FF_PROFILE_DNXHR_SQ 2
-#define FF_PROFILE_DNXHR_HQ 3
-#define FF_PROFILE_DNXHR_HQX 4
-#define FF_PROFILE_DNXHR_444 5
-
-#define FF_PROFILE_DTS 20
-#define FF_PROFILE_DTS_ES 30
-#define FF_PROFILE_DTS_96_24 40
-#define FF_PROFILE_DTS_HD_HRA 50
-#define FF_PROFILE_DTS_HD_MA 60
-#define FF_PROFILE_DTS_EXPRESS 70
-
-#define FF_PROFILE_MPEG2_422 0
-#define FF_PROFILE_MPEG2_HIGH 1
-#define FF_PROFILE_MPEG2_SS 2
-#define FF_PROFILE_MPEG2_SNR_SCALABLE 3
-#define FF_PROFILE_MPEG2_MAIN 4
-#define FF_PROFILE_MPEG2_SIMPLE 5
-
-#define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag
-#define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag
-
-#define FF_PROFILE_H264_BASELINE 66
-#define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
-#define FF_PROFILE_H264_MAIN 77
-#define FF_PROFILE_H264_EXTENDED 88
-#define FF_PROFILE_H264_HIGH 100
-#define FF_PROFILE_H264_HIGH_10 110
-#define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
-#define FF_PROFILE_H264_MULTIVIEW_HIGH 118
-#define FF_PROFILE_H264_HIGH_422 122
-#define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
-#define FF_PROFILE_H264_STEREO_HIGH 128
-#define FF_PROFILE_H264_HIGH_444 144
-#define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
-#define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
-#define FF_PROFILE_H264_CAVLC_444 44
-
-#define FF_PROFILE_VC1_SIMPLE 0
-#define FF_PROFILE_VC1_MAIN 1
-#define FF_PROFILE_VC1_COMPLEX 2
-#define FF_PROFILE_VC1_ADVANCED 3
-
-#define FF_PROFILE_MPEG4_SIMPLE 0
-#define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
-#define FF_PROFILE_MPEG4_CORE 2
-#define FF_PROFILE_MPEG4_MAIN 3
-#define FF_PROFILE_MPEG4_N_BIT 4
-#define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
-#define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
-#define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
-#define FF_PROFILE_MPEG4_HYBRID 8
-#define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
-#define FF_PROFILE_MPEG4_CORE_SCALABLE 10
-#define FF_PROFILE_MPEG4_ADVANCED_CODING 11
-#define FF_PROFILE_MPEG4_ADVANCED_CORE 12
-#define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
-#define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
-#define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
-
-#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 1
-#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 2
-#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 32768
-#define FF_PROFILE_JPEG2000_DCINEMA_2K 3
-#define FF_PROFILE_JPEG2000_DCINEMA_4K 4
-
-#define FF_PROFILE_VP9_0 0
-#define FF_PROFILE_VP9_1 1
-#define FF_PROFILE_VP9_2 2
-#define FF_PROFILE_VP9_3 3
-
-#define FF_PROFILE_HEVC_MAIN 1
-#define FF_PROFILE_HEVC_MAIN_10 2
-#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
-#define FF_PROFILE_HEVC_REXT 4
-
-#define FF_PROFILE_AV1_MAIN 0
-#define FF_PROFILE_AV1_HIGH 1
-#define FF_PROFILE_AV1_PROFESSIONAL 2
-
-#define FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT 0xc0
-#define FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT 0xc1
-#define FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT 0xc2
-#define FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS 0xc3
-#define FF_PROFILE_MJPEG_JPEG_LS 0xf7
-
-#define FF_PROFILE_SBC_MSBC 1
-
- /**
- * level
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int level;
-#define FF_LEVEL_UNKNOWN -99
-
- /**
- * Skip loop filtering for selected frames.
- * - encoding: unused
- * - decoding: Set by user.
- */
- enum AVDiscard skip_loop_filter;
-
- /**
- * Skip IDCT/dequantization for selected frames.
- * - encoding: unused
- * - decoding: Set by user.
- */
- enum AVDiscard skip_idct;
-
- /**
- * Skip decoding for selected frames.
- * - encoding: unused
- * - decoding: Set by user.
- */
- enum AVDiscard skip_frame;
-
- /**
- * Header containing style information for text subtitles.
- * For SUBTITLE_ASS subtitle type, it should contain the whole ASS
- * Script Info and V4+ Styles section, plus the Events line and
- * the Format line following. It shouldn't include any Dialogue line.
- * - encoding: Set/allocated/freed by user (before avcodec_open2())
- * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2())
- */
- uint8_t *subtitle_header;
- int subtitle_header_size;
-
-#if FF_API_VBV_DELAY
- /**
- * VBV delay coded in the last frame (in periods of a 27 MHz clock).
- * Used for compliant TS muxing.
- * - encoding: Set by libavcodec.
- * - decoding: unused.
- * @deprecated this value is now exported as a part of
- * AV_PKT_DATA_CPB_PROPERTIES packet side data
- */
- attribute_deprecated
- uint64_t vbv_delay;
-#endif
-
-#if FF_API_SIDEDATA_ONLY_PKT
- /**
- * Encoding only and set by default. Allow encoders to output packets
- * that do not contain any encoded data, only side data.
- *
- * Some encoders need to output such packets, e.g. to update some stream
- * parameters at the end of encoding.
- *
- * @deprecated this field disables the default behaviour and
- * it is kept only for compatibility.
- */
- attribute_deprecated
- int side_data_only_packets;
-#endif
-
- /**
- * Audio only. The number of "priming" samples (padding) inserted by the
- * encoder at the beginning of the audio. I.e. this number of leading
- * decoded samples must be discarded by the caller to get the original audio
- * without leading padding.
- *
- * - decoding: unused
- * - encoding: Set by libavcodec. The timestamps on the output packets are
- * adjusted by the encoder so that they always refer to the
- * first sample of the data actually contained in the packet,
- * including any added padding. E.g. if the timebase is
- * 1/samplerate and the timestamp of the first input sample is
- * 0, the timestamp of the first output packet will be
- * -initial_padding.
- */
- int initial_padding;
-
- /**
- * - decoding: For codecs that store a framerate value in the compressed
- * bitstream, the decoder may export it here. { 0, 1} when
- * unknown.
- * - encoding: May be used to signal the framerate of CFR content to an
- * encoder.
- */
- AVRational framerate;
-
- /**
- * Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
- * - encoding: unused.
- * - decoding: Set by libavcodec before calling get_format()
- */
- enum AVPixelFormat sw_pix_fmt;
-
- /**
- * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
- * - encoding unused.
- * - decoding set by user.
- */
- AVRational pkt_timebase;
-
- /**
- * AVCodecDescriptor
- * - encoding: unused.
- * - decoding: set by libavcodec.
- */
- const AVCodecDescriptor *codec_descriptor;
-
-#if !FF_API_LOWRES
- /**
- * low resolution decoding, 1-> 1/2 size, 2->1/4 size
- * - encoding: unused
- * - decoding: Set by user.
- */
- int lowres;
-#endif
-
- /**
- * Current statistics for PTS correction.
- * - decoding: maintained and used by libavcodec, not intended to be used by user apps
- * - encoding: unused
- */
- int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
- int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
- int64_t pts_correction_last_pts; /// PTS of the last frame
- int64_t pts_correction_last_dts; /// DTS of the last frame
-
- /**
- * Character encoding of the input subtitles file.
- * - decoding: set by user
- * - encoding: unused
- */
- char *sub_charenc;
-
- /**
- * Subtitles character encoding mode. Formats or codecs might be adjusting
- * this setting (if they are doing the conversion themselves for instance).
- * - decoding: set by libavcodec
- * - encoding: unused
- */
- int sub_charenc_mode;
-#define FF_SUB_CHARENC_MODE_DO_NOTHING -1 ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
-#define FF_SUB_CHARENC_MODE_AUTOMATIC 0 ///< libavcodec will select the mode itself
-#define FF_SUB_CHARENC_MODE_PRE_DECODER 1 ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
-#define FF_SUB_CHARENC_MODE_IGNORE 2 ///< neither convert the subtitles, nor check them for valid UTF-8
-
- /**
- * Skip processing alpha if supported by codec.
- * Note that if the format uses pre-multiplied alpha (common with VP6,
- * and recommended due to better video quality/compression)
- * the image will look as if alpha-blended onto a black background.
- * However for formats that do not use pre-multiplied alpha
- * there might be serious artefacts (though e.g. libswscale currently
- * assumes pre-multiplied alpha anyway).
- *
- * - decoding: set by user
- * - encoding: unused
- */
- int skip_alpha;
-
- /**
- * Number of samples to skip after a discontinuity
- * - decoding: unused
- * - encoding: set by libavcodec
- */
- int seek_preroll;
-
-#if !FF_API_DEBUG_MV
- /**
- * debug motion vectors
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int debug_mv;
-#define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames
-#define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames
-#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
-#endif
-
- /**
- * custom intra quantization matrix
- * - encoding: Set by user, can be NULL.
- * - decoding: unused.
- */
- uint16_t *chroma_intra_matrix;
-
- /**
- * dump format separator.
- * can be ", " or "\n " or anything else
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- uint8_t *dump_separator;
-
- /**
- * ',' separated list of allowed decoders.
- * If NULL then all are allowed
- * - encoding: unused
- * - decoding: set by user
- */
- char *codec_whitelist;
-
- /**
- * Properties of the stream that gets decoded
- * - encoding: unused
- * - decoding: set by libavcodec
- */
- unsigned properties;
-#define FF_CODEC_PROPERTY_LOSSLESS 0x00000001
-#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002
-
- /**
- * Additional data associated with the entire coded stream.
- *
- * - decoding: unused
- * - encoding: may be set by libavcodec after avcodec_open2().
- */
- AVPacketSideData *coded_side_data;
- int nb_coded_side_data;
-
- /**
- * A reference to the AVHWFramesContext describing the input (for encoding)
- * or output (decoding) frames. The reference is set by the caller and
- * afterwards owned (and freed) by libavcodec - it should never be read by
- * the caller after being set.
- *
- * - decoding: This field should be set by the caller from the get_format()
- * callback. The previous reference (if any) will always be
- * unreffed by libavcodec before the get_format() call.
- *
- * If the default get_buffer2() is used with a hwaccel pixel
- * format, then this AVHWFramesContext will be used for
- * allocating the frame buffers.
- *
- * - encoding: For hardware encoders configured to use a hwaccel pixel
- * format, this field should be set by the caller to a reference
- * to the AVHWFramesContext describing input frames.
- * AVHWFramesContext.format must be equal to
- * AVCodecContext.pix_fmt.
- *
- * This field should be set before avcodec_open2() is called.
- */
- AVBufferRef *hw_frames_ctx;
-
- /**
- * Control the form of AVSubtitle.rectsN->ass
- * - decoding: set by user
- * - encoding: unused
- */
- int sub_text_format;
-#define FF_SUB_TEXT_FMT_ASS 0
-#if FF_API_ASS_TIMING
-#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS 1
-#endif
-
- /**
- * Audio only. The amount of padding (in samples) appended by the encoder to
- * the end of the audio. I.e. this number of decoded samples must be
- * discarded by the caller from the end of the stream to get the original
- * audio without any trailing padding.
- *
- * - decoding: unused
- * - encoding: unused
- */
- int trailing_padding;
-
- /**
- * The number of pixels per image to maximally accept.
- *
- * - decoding: set by user
- * - encoding: set by user
- */
- int64_t max_pixels;
-
- /**
- * A reference to the AVHWDeviceContext describing the device which will
- * be used by a hardware encoder/decoder. The reference is set by the
- * caller and afterwards owned (and freed) by libavcodec.
- *
- * This should be used if either the codec device does not require
- * hardware frames or any that are used are to be allocated internally by
- * libavcodec. If the user wishes to supply any of the frames used as
- * encoder input or decoder output then hw_frames_ctx should be used
- * instead. When hw_frames_ctx is set in get_format() for a decoder, this
- * field will be ignored while decoding the associated stream segment, but
- * may again be used on a following one after another get_format() call.
- *
- * For both encoders and decoders this field should be set before
- * avcodec_open2() is called and must not be written to thereafter.
- *
- * Note that some decoders may require this field to be set initially in
- * order to support hw_frames_ctx at all - in that case, all frames
- * contexts used must be created on the same device.
- */
- AVBufferRef *hw_device_ctx;
-
- /**
- * Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated
- * decoding (if active).
- * - encoding: unused
- * - decoding: Set by user (either before avcodec_open2(), or in the
- * AVCodecContext.get_format callback)
- */
- int hwaccel_flags;
-
- /**
- * Video decoding only. Certain video codecs support cropping, meaning that
- * only a sub-rectangle of the decoded frame is intended for display. This
- * option controls how cropping is handled by libavcodec.
- *
- * When set to 1 (the default), libavcodec will apply cropping internally.
- * I.e. it will modify the output frame width/height fields and offset the
- * data pointers (only by as much as possible while preserving alignment, or
- * by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that
- * the frames output by the decoder refer only to the cropped area. The
- * crop_* fields of the output frames will be zero.
- *
- * When set to 0, the width/height fields of the output frames will be set
- * to the coded dimensions and the crop_* fields will describe the cropping
- * rectangle. Applying the cropping is left to the caller.
- *
- * @warning When hardware acceleration with opaque output frames is used,
- * libavcodec is unable to apply cropping from the top/left border.
- *
- * @note when this option is set to zero, the width/height fields of the
- * AVCodecContext and output AVFrames have different meanings. The codec
- * context fields store display dimensions (with the coded dimensions in
- * coded_width/height), while the frame fields store the coded dimensions
- * (with the display dimensions being determined by the crop_* fields).
- */
- int apply_cropping;
-
- /*
- * Video decoding only. Sets the number of extra hardware frames which
- * the decoder will allocate for use by the caller. This must be set
- * before avcodec_open2() is called.
- *
- * Some hardware decoders require all frames that they will use for
- * output to be defined in advance before decoding starts. For such
- * decoders, the hardware frame pool must therefore be of a fixed size.
- * The extra frames set here are on top of any number that the decoder
- * needs internally in order to operate normally (for example, frames
- * used as reference pictures).
- */
- int extra_hw_frames;
-} AVCodecContext;
-
-#if FF_API_CODEC_GET_SET
-/**
- * Accessors for some AVCodecContext fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-AVRational av_codec_get_pkt_timebase (const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_pkt_timebase (AVCodecContext *avctx, AVRational val);
-
-attribute_deprecated
-const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
-
-attribute_deprecated
-unsigned av_codec_get_codec_properties(const AVCodecContext *avctx);
-
-#if FF_API_LOWRES
-attribute_deprecated
-int av_codec_get_lowres(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_lowres(AVCodecContext *avctx, int val);
-#endif
-
-attribute_deprecated
-int av_codec_get_seek_preroll(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);
-
-attribute_deprecated
-uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);
-#endif
-
-/**
- * AVProfile.
- */
-typedef struct AVProfile {
- int profile;
- const char *name; ///< short name for the profile
-} AVProfile;
-
-enum {
- /**
- * The codec supports this format via the hw_device_ctx interface.
- *
- * When selecting this format, AVCodecContext.hw_device_ctx should
- * have been set to a device of the specified type before calling
- * avcodec_open2().
- */
- AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
- /**
- * The codec supports this format via the hw_frames_ctx interface.
- *
- * When selecting this format for a decoder,
- * AVCodecContext.hw_frames_ctx should be set to a suitable frames
- * context inside the get_format() callback. The frames context
- * must have been created on a device of the specified type.
- */
- AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
- /**
- * The codec supports this format by some internal method.
- *
- * This format can be selected without any additional configuration -
- * no device or frames context is required.
- */
- AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
- /**
- * The codec supports this format by some ad-hoc method.
- *
- * Additional settings and/or function calls are required. See the
- * codec-specific documentation for details. (Methods requiring
- * this sort of configuration are deprecated and others should be
- * used in preference.)
- */
- AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
-};
-
-typedef struct AVCodecHWConfig {
- /**
- * A hardware pixel format which the codec can use.
- */
- enum AVPixelFormat pix_fmt;
- /**
- * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
- * setup methods which can be used with this configuration.
- */
- int methods;
- /**
- * The device type associated with the configuration.
- *
- * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
- * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
- */
- enum AVHWDeviceType device_type;
-} AVCodecHWConfig;
-
-typedef struct AVCodecDefault AVCodecDefault;
-
-struct AVSubtitle;
-
-/**
- * AVCodec.
- */
-typedef struct AVCodec {
- /**
- * Name of the codec implementation.
- * The name is globally unique among encoders and among decoders (but an
- * encoder and a decoder can share the same name).
- * This is the primary way to find a codec from the user perspective.
- */
- const char *name;
- /**
- * Descriptive name for the codec, meant to be more human readable than name.
- * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
- */
- const char *long_name;
- enum AVMediaType type;
- enum AVCodecID id;
- /**
- * Codec capabilities.
- * see AV_CODEC_CAP_*
- */
- int capabilities;
- const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
- const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
- const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
- const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
- const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
- uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
- const AVClass *priv_class; ///< AVClass for the private context
- const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
-
- /**
- * Group name of the codec implementation.
- * This is a short symbolic name of the wrapper backing this codec. A
- * wrapper uses some kind of external implementation for the codec, such
- * as an external library, or a codec implementation provided by the OS or
- * the hardware.
- * If this field is NULL, this is a builtin, libavcodec native codec.
- * If non-NULL, this will be the suffix in AVCodec.name in most cases
- * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
- */
- const char *wrapper_name;
-
- /*****************************************************************
- * No fields below this line are part of the public API. They
- * may not be used outside of libavcodec and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
- int priv_data_size;
- struct AVCodec *next;
- /**
- * @name Frame-level threading support functions
- * @{
- */
- /**
- * If defined, called on thread contexts when they are created.
- * If the codec allocates writable tables in init(), re-allocate them here.
- * priv_data will be set to a copy of the original.
- */
- int (*init_thread_copy)(AVCodecContext *);
- /**
- * Copy necessary context variables from a previous thread context to the current one.
- * If not defined, the next thread will start automatically; otherwise, the codec
- * must call ff_thread_finish_setup().
- *
- * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
- */
- int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);
- /** @} */
-
- /**
- * Private codec-specific defaults.
- */
- const AVCodecDefault *defaults;
-
- /**
- * Initialize codec static data, called from avcodec_register().
- *
- * This is not intended for time consuming operations as it is
- * run for every codec regardless of that codec being used.
- */
- void (*init_static_data)(struct AVCodec *codec);
-
- int (*init)(AVCodecContext *);
- int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
- const struct AVSubtitle *sub);
- /**
- * Encode data to an AVPacket.
- *
- * @param avctx codec context
- * @param avpkt output AVPacket (may contain a user-provided buffer)
- * @paramin frame AVFrame containing the raw data to be encoded
- * @paramout got_packet_ptr encoder sets to 0 or 1 to indicate that a
- * non-empty packet was returned in avpkt.
- * @return 0 on success, negative error code on failure
- */
- int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
- int *got_packet_ptr);
- int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
- int (*close)(AVCodecContext *);
- /**
- * Encode API with decoupled packet/frame dataflow. The API is the
- * same as the avcodec_ prefixed APIs (avcodec_send_frame() etc.), except
- * that:
- * - never called if the codec is closed or the wrong type,
- * - if AV_CODEC_CAP_DELAY is not set, drain frames are never sent,
- * - only one drain frame is ever passed down,
- */
- int (*send_frame)(AVCodecContext *avctx, const AVFrame *frame);
- int (*receive_packet)(AVCodecContext *avctx, AVPacket *avpkt);
-
- /**
- * Decode API with decoupled packet/frame dataflow. This function is called
- * to get one output frame. It should call ff_decode_get_packet() to obtain
- * input data.
- */
- int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame);
- /**
- * Flush buffers.
- * Will be called when seeking
- */
- void (*flush)(AVCodecContext *);
- /**
- * Internal codec capabilities.
- * See FF_CODEC_CAP_* in internal.h
- */
- int caps_internal;
-
- /**
- * Decoding only, a comma-separated list of bitstream filters to apply to
- * packets before decoding.
- */
- const char *bsfs;
-
- /**
- * Array of pointers to hardware configurations supported by the codec,
- * or NULL if no hardware supported. The array is terminated by a NULL
- * pointer.
- *
- * The user can only access this field via avcodec_get_hw_config().
- */
- const struct AVCodecHWConfigInternal **hw_configs;
-} AVCodec;
-
-#if FF_API_CODEC_GET_SET
-attribute_deprecated
-int av_codec_get_max_lowres(const AVCodec *codec);
-#endif
-
-struct MpegEncContext;
-
-/**
- * Retrieve supported hardware configurations for a codec.
- *
- * Values of index from zero to some maximum return the indexed configuration
- * descriptor; all other values return NULL. If the codec does not support
- * any hardware configurations then it will always return NULL.
- */
-const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
-
-/**
- * @defgroup lavc_hwaccel AVHWAccel
- *
- * @note Nothing in this structure should be accessed by the user. At some
- * point in future it will not be externally visible at all.
- *
- * @{
- */
-typedef struct AVHWAccel {
- /**
- * Name of the hardware accelerated codec.
- * The name is globally unique among encoders and among decoders (but an
- * encoder and a decoder can share the same name).
- */
- const char *name;
-
- /**
- * Type of codec implemented by the hardware accelerator.
- *
- * See AVMEDIA_TYPE_xxx
- */
- enum AVMediaType type;
-
- /**
- * Codec implemented by the hardware accelerator.
- *
- * See AV_CODEC_ID_xxx
- */
- enum AVCodecID id;
-
- /**
- * Supported pixel format.
- *
- * Only hardware accelerated formats are supported here.
- */
- enum AVPixelFormat pix_fmt;
-
- /**
- * Hardware accelerated codec capabilities.
- * see AV_HWACCEL_CODEC_CAP_*
- */
- int capabilities;
-
- /*****************************************************************
- * No fields below this line are part of the public API. They
- * may not be used outside of libavcodec and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
-
- /**
- * Allocate a custom buffer
- */
- int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);
-
- /**
- * Called at the beginning of each frame or field picture.
- *
- * Meaningful frame information (codec specific) is guaranteed to
- * be parsed at this point. This function is mandatory.
- *
- * Note that buf can be NULL along with buf_size set to 0.
- * Otherwise, this means the whole frame is available at this point.
- *
- * @param avctx the codec context
- * @param buf the frame data buffer base
- * @param buf_size the size of the frame in bytes
- * @return zero if successful, a negative value otherwise
- */
- int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
-
- /**
- * Callback for parameter data (SPS/PPS/VPS etc).
- *
- * Useful for hardware decoders which keep persistent state about the
- * video parameters, and need to receive any changes to update that state.
- *
- * @param avctx the codec context
- * @param type the nal unit type
- * @param buf the nal unit data buffer
- * @param buf_size the size of the nal unit in bytes
- * @return zero if successful, a negative value otherwise
- */
- int (*decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size);
-
- /**
- * Callback for each slice.
- *
- * Meaningful slice information (codec specific) is guaranteed to
- * be parsed at this point. This function is mandatory.
- * The only exception is XvMC, that works on MB level.
- *
- * @param avctx the codec context
- * @param buf the slice data buffer base
- * @param buf_size the size of the slice in bytes
- * @return zero if successful, a negative value otherwise
- */
- int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
-
- /**
- * Called at the end of each frame or field picture.
- *
- * The whole picture is parsed at this point and can now be sent
- * to the hardware accelerator. This function is mandatory.
- *
- * @param avctx the codec context
- * @return zero if successful, a negative value otherwise
- */
- int (*end_frame)(AVCodecContext *avctx);
-
- /**
- * Size of per-frame hardware accelerator private data.
- *
- * Private data is allocated with av_mallocz() before
- * AVCodecContext.get_buffer() and deallocated after
- * AVCodecContext.release_buffer().
- */
- int frame_priv_data_size;
-
- /**
- * Called for every Macroblock in a slice.
- *
- * XvMC uses it to replace the ff_mpv_reconstruct_mb().
- * Instead of decoding to raw picture, MB parameters are
- * stored in an array provided by the video driver.
- *
- * @param s the mpeg context
- */
- void (*decode_mb)(struct MpegEncContext *s);
-
- /**
- * Initialize the hwaccel private data.
- *
- * This will be called from ff_get_format(), after hwaccel and
- * hwaccel_context are set and the hwaccel private data in AVCodecInternal
- * is allocated.
- */
- int (*init)(AVCodecContext *avctx);
-
- /**
- * Uninitialize the hwaccel private data.
- *
- * This will be called from get_format() or avcodec_close(), after hwaccel
- * and hwaccel_context are already uninitialized.
- */
- int (*uninit)(AVCodecContext *avctx);
-
- /**
- * Size of the private data to allocate in
- * AVCodecInternal.hwaccel_priv_data.
- */
- int priv_data_size;
-
- /**
- * Internal hwaccel capabilities.
- */
- int caps_internal;
-
- /**
- * Fill the given hw_frames context with current codec parameters. Called
- * from get_format. Refer to avcodec_get_hw_frames_parameters() for
- * details.
- *
- * This CAN be called before AVHWAccel.init is called, and you must assume
- * that avctx->hwaccel_priv_data is invalid.
- */
- int (*frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx);
-} AVHWAccel;
-
-/**
- * HWAccel is experimental and is thus avoided in favor of non experimental
- * codecs
- */
-#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200
-
-/**
- * Hardware acceleration should be used for decoding even if the codec level
- * used is unknown or higher than the maximum supported level reported by the
- * hardware driver.
- *
- * It's generally a good idea to pass this flag unless you have a specific
- * reason not to, as hardware tends to under-report supported levels.
- */
-#define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0)
-
-/**
- * Hardware acceleration can output YUV pixel formats with a different chroma
- * sampling than 4:2:0 and/or other than 8 bits per component.
- */
-#define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)
-
-/**
- * Hardware acceleration should still be attempted for decoding when the
- * codec profile does not match the reported capabilities of the hardware.
- *
- * For example, this can be used to try to decode baseline profile H.264
- * streams in hardware - it will often succeed, because many streams marked
- * as baseline profile actually conform to constrained baseline profile.
- *
- * @warning If the stream is actually not supported then the behaviour is
- * undefined, and may include returning entirely incorrect output
- * while indicating success.
- */
-#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2)
-
-/**
- * @}
- */
-
-#if FF_API_AVPICTURE
-/**
- * @defgroup lavc_picture AVPicture
- *
- * Functions for working with AVPicture
- * @{
- */
-
-/**
- * Picture data structure.
- *
- * Up to four components can be stored into it, the last component is
- * alpha.
- * @deprecated use AVFrame or imgutils functions instead
- */
-typedef struct AVPicture {
- attribute_deprecated
- uint8_t *dataAV_NUM_DATA_POINTERS; ///< pointers to the image data planes
- attribute_deprecated
- int linesizeAV_NUM_DATA_POINTERS; ///< number of bytes per line
-} AVPicture;
-
-/**
- * @}
- */
-#endif
-
-enum AVSubtitleType {
- SUBTITLE_NONE,
-
- SUBTITLE_BITMAP, ///< A bitmap, pict will be set
-
- /**
- * Plain text, the text field must be set by the decoder and is
- * authoritative. ass and pict fields may contain approximations.
- */
- SUBTITLE_TEXT,
-
- /**
- * Formatted text, the ass field must be set by the decoder and is
- * authoritative. pict and text fields may contain approximations.
- */
- SUBTITLE_ASS,
-};
-
-#define AV_SUBTITLE_FLAG_FORCED 0x00000001
-
-typedef struct AVSubtitleRect {
- int x; ///< top left corner of pict, undefined when pict is not set
- int y; ///< top left corner of pict, undefined when pict is not set
- int w; ///< width of pict, undefined when pict is not set
- int h; ///< height of pict, undefined when pict is not set
- int nb_colors; ///< number of colors in pict, undefined when pict is not set
-
-#if FF_API_AVPICTURE
- /**
- * @deprecated unused
- */
- attribute_deprecated
- AVPicture pict;
-#endif
- /**
- * data+linesize for the bitmap of this subtitle.
- * Can be set for text/ass as well once they are rendered.
- */
- uint8_t *data4;
- int linesize4;
-
- enum AVSubtitleType type;
-
- char *text; ///< 0 terminated plain UTF-8 text
-
- /**
- * 0 terminated ASS/SSA compatible event line.
- * The presentation of this is unaffected by the other values in this
- * struct.
- */
- char *ass;
-
- int flags;
-} AVSubtitleRect;
-
-typedef struct AVSubtitle {
- uint16_t format; /* 0 = graphics */
- uint32_t start_display_time; /* relative to packet pts, in ms */
- uint32_t end_display_time; /* relative to packet pts, in ms */
- unsigned num_rects;
- AVSubtitleRect **rects;
- int64_t pts; ///< Same as packet pts, in AV_TIME_BASE
-} AVSubtitle;
-
-/**
- * This struct describes the properties of an encoded stream.
- *
- * sizeof(AVCodecParameters) is not a part of the public ABI, this struct must
- * be allocated with avcodec_parameters_alloc() and freed with
- * avcodec_parameters_free().
- */
-typedef struct AVCodecParameters {
- /**
- * General type of the encoded data.
- */
- enum AVMediaType codec_type;
- /**
- * Specific type of the encoded data (the codec used).
- */
- enum AVCodecID codec_id;
- /**
- * Additional information about the codec (corresponds to the AVI FOURCC).
- */
- uint32_t codec_tag;
-
- /**
- * Extra binary data needed for initializing the decoder, codec-dependent.
- *
- * Must be allocated with av_malloc() and will be freed by
- * avcodec_parameters_free(). The allocated size of extradata must be at
- * least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
- * bytes zeroed.
- */
- uint8_t *extradata;
- /**
- * Size of the extradata content in bytes.
- */
- int extradata_size;
-
- /**
- * - video: the pixel format, the value corresponds to enum AVPixelFormat.
- * - audio: the sample format, the value corresponds to enum AVSampleFormat.
- */
- int format;
-
- /**
- * The average bitrate of the encoded data (in bits per second).
- */
- int64_t bit_rate;
-
- /**
- * The number of bits per sample in the codedwords.
- *
- * This is basically the bitrate per sample. It is mandatory for a bunch of
- * formats to actually decode them. It's the number of bits for one sample in
- * the actual coded bitstream.
- *
- * This could be for example 4 for ADPCM
- * For PCM formats this matches bits_per_raw_sample
- * Can be 0
- */
- int bits_per_coded_sample;
-
- /**
- * This is the number of valid bits in each output sample. If the
- * sample format has more bits, the least significant bits are additional
- * padding bits, which are always 0. Use right shifts to reduce the sample
- * to its actual size. For example, audio formats with 24 bit samples will
- * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
- * To get the original sample use "(int32_t)sample >> 8"."
- *
- * For ADPCM this might be 12 or 16 or similar
- * Can be 0
- */
- int bits_per_raw_sample;
-
- /**
- * Codec-specific bitstream restrictions that the stream conforms to.
- */
- int profile;
- int level;
-
- /**
- * Video only. The dimensions of the video frame in pixels.
- */
- int width;
- int height;
-
- /**
- * Video only. The aspect ratio (width / height) which a single pixel
- * should have when displayed.
- *
- * When the aspect ratio is unknown / undefined, the numerator should be
- * set to 0 (the denominator may have any value).
- */
- AVRational sample_aspect_ratio;
-
- /**
- * Video only. The order of the fields in interlaced video.
- */
- enum AVFieldOrder field_order;
-
- /**
- * Video only. Additional colorspace characteristics.
- */
- enum AVColorRange color_range;
- enum AVColorPrimaries color_primaries;
- enum AVColorTransferCharacteristic color_trc;
- enum AVColorSpace color_space;
- enum AVChromaLocation chroma_location;
-
- /**
- * Video only. Number of delayed frames.
- */
- int video_delay;
-
- /**
- * Audio only. The channel layout bitmask. May be 0 if the channel layout is
- * unknown or unspecified, otherwise the number of bits set must be equal to
- * the channels field.
- */
- uint64_t channel_layout;
- /**
- * Audio only. The number of audio channels.
- */
- int channels;
- /**
- * Audio only. The number of audio samples per second.
- */
- int sample_rate;
- /**
- * Audio only. The number of bytes per coded audio frame, required by some
- * formats.
- *
- * Corresponds to nBlockAlign in WAVEFORMATEX.
- */
- int block_align;
- /**
- * Audio only. Audio frame size, if known. Required by some formats to be static.
- */
- int frame_size;
-
- /**
- * Audio only. The amount of padding (in samples) inserted by the encoder at
- * the beginning of the audio. I.e. this number of leading decoded samples
- * must be discarded by the caller to get the original audio without leading
- * padding.
- */
- int initial_padding;
- /**
- * Audio only. The amount of padding (in samples) appended by the encoder to
- * the end of the audio. I.e. this number of decoded samples must be
- * discarded by the caller from the end of the stream to get the original
- * audio without any trailing padding.
- */
- int trailing_padding;
- /**
- * Audio only. Number of samples to skip after a discontinuity.
- */
- int seek_preroll;
-} AVCodecParameters;
-
-/**
- * Iterate over all registered codecs.
- *
- * @param opaque a pointer where libavcodec will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered codec or NULL when the iteration is
- * finished
- */
-const AVCodec *av_codec_iterate(void **opaque);
-
-#if FF_API_NEXT
-/**
- * If c is NULL, returns the first registered codec,
- * if c is non-NULL, returns the next registered codec after c,
- * or NULL if c is the last one.
- */
-attribute_deprecated
-AVCodec *av_codec_next(const AVCodec *c);
-#endif
-
-/**
- * Return the LIBAVCODEC_VERSION_INT constant.
- */
-unsigned avcodec_version(void);
-
-/**
- * Return the libavcodec build-time configuration.
- */
-const char *avcodec_configuration(void);
-
-/**
- * Return the libavcodec license.
- */
-const char *avcodec_license(void);
-
-#if FF_API_NEXT
-/**
- * Register the codec codec and initialize libavcodec.
- *
- * @warning either this function or avcodec_register_all() must be called
- * before any other libavcodec functions.
- *
- * @see avcodec_register_all()
- */
-attribute_deprecated
-void avcodec_register(AVCodec *codec);
-
-/**
- * Register all the codecs, parsers and bitstream filters which were enabled at
- * configuration time. If you do not call this function you can select exactly
- * which formats you want to support, by using the individual registration
- * functions.
- *
- * @see avcodec_register
- * @see av_register_codec_parser
- * @see av_register_bitstream_filter
- */
-attribute_deprecated
-void avcodec_register_all(void);
-#endif
-
-/**
- * Allocate an AVCodecContext and set its fields to default values. The
- * resulting struct should be freed with avcodec_free_context().
- *
- * @param codec if non-NULL, allocate private data and initialize defaults
- * for the given codec. It is illegal to then call avcodec_open2()
- * with a different codec.
- * If NULL, then the codec-specific defaults won't be initialized,
- * which may result in suboptimal default settings (this is
- * important mainly for encoders, e.g. libx264).
- *
- * @return An AVCodecContext filled with default values or NULL on failure.
- */
-AVCodecContext *avcodec_alloc_context3(const AVCodec *codec);
-
-/**
- * Free the codec context and everything associated with it and write NULL to
- * the provided pointer.
- */
-void avcodec_free_context(AVCodecContext **avctx);
-
-#if FF_API_GET_CONTEXT_DEFAULTS
-/**
- * @deprecated This function should not be used, as closing and opening a codec
- * context multiple time is not supported. A new codec context should be
- * allocated for each new use.
- */
-int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec);
-#endif
-
-/**
- * Get the AVClass for AVCodecContext. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- */
-const AVClass *avcodec_get_class(void);
-
-#if FF_API_COPY_CONTEXT
-/**
- * Get the AVClass for AVFrame. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- */
-const AVClass *avcodec_get_frame_class(void);
-
-/**
- * Get the AVClass for AVSubtitleRect. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- */
-const AVClass *avcodec_get_subtitle_rect_class(void);
-
-/**
- * Copy the settings of the source AVCodecContext into the destination
- * AVCodecContext. The resulting destination codec context will be
- * unopened, i.e. you are required to call avcodec_open2() before you
- * can use this AVCodecContext to decode/encode video/audio data.
- *
- * @param dest target codec context, should be initialized with
- * avcodec_alloc_context3(NULL), but otherwise uninitialized
- * @param src source codec context
- * @return AVERROR() on error (e.g. memory allocation error), 0 on success
- *
- * @deprecated The semantics of this function are ill-defined and it should not
- * be used. If you need to transfer the stream parameters from one codec context
- * to another, use an intermediate AVCodecParameters instance and the
- * avcodec_parameters_from_context() / avcodec_parameters_to_context()
- * functions.
- */
-attribute_deprecated
-int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src);
-#endif
-
-/**
- * Allocate a new AVCodecParameters and set its fields to default values
- * (unknown/invalid/0). The returned struct must be freed with
- * avcodec_parameters_free().
- */
-AVCodecParameters *avcodec_parameters_alloc(void);
-
-/**
- * Free an AVCodecParameters instance and everything associated with it and
- * write NULL to the supplied pointer.
- */
-void avcodec_parameters_free(AVCodecParameters **par);
-
-/**
- * Copy the contents of src to dst. Any allocated fields in dst are freed and
- * replaced with newly allocated duplicates of the corresponding fields in src.
- *
- * @return >= 0 on success, a negative AVERROR code on failure.
- */
-int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
-
-/**
- * Fill the parameters struct based on the values from the supplied codec
- * context. Any allocated fields in par are freed and replaced with duplicates
- * of the corresponding fields in codec.
- *
- * @return >= 0 on success, a negative AVERROR code on failure
- */
-int avcodec_parameters_from_context(AVCodecParameters *par,
- const AVCodecContext *codec);
-
-/**
- * Fill the codec context based on the values from the supplied codec
- * parameters. Any allocated fields in codec that have a corresponding field in
- * par are freed and replaced with duplicates of the corresponding field in par.
- * Fields in codec that do not have a counterpart in par are not touched.
- *
- * @return >= 0 on success, a negative AVERROR code on failure.
- */
-int avcodec_parameters_to_context(AVCodecContext *codec,
- const AVCodecParameters *par);
-
-/**
- * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
- * function the context has to be allocated with avcodec_alloc_context3().
- *
- * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),
- * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
- * retrieving a codec.
- *
- * @warning This function is not thread safe!
- *
- * @note Always call this function before using decoding routines (such as
- * @ref avcodec_receive_frame()).
- *
- * @code
- * avcodec_register_all();
- * av_dict_set(&opts, "b", "2.5M", 0);
- * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
- * if (!codec)
- * exit(1);
- *
- * context = avcodec_alloc_context3(codec);
- *
- * if (avcodec_open2(context, codec, opts) < 0)
- * exit(1);
- * @endcode
- *
- * @param avctx The context to initialize.
- * @param codec The codec to open this context for. If a non-NULL codec has been
- * previously passed to avcodec_alloc_context3() or
- * for this context, then this parameter MUST be either NULL or
- * equal to the previously passed codec.
- * @param options A dictionary filled with AVCodecContext and codec-private options.
- * On return this object will be filled with options that were not found.
- *
- * @return zero on success, a negative value on error
- * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(),
- * av_dict_set(), av_opt_find().
- */
-int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
-
-/**
- * Close a given AVCodecContext and free all the data associated with it
- * (but not the AVCodecContext itself).
- *
- * Calling this function on an AVCodecContext that hasn't been opened will free
- * the codec-specific data allocated in avcodec_alloc_context3() with a non-NULL
- * codec. Subsequent calls will do nothing.
- *
- * @note Do not use this function. Use avcodec_free_context() to destroy a
- * codec context (either open or closed). Opening and closing a codec context
- * multiple times is not supported anymore -- use multiple codec contexts
- * instead.
- */
-int avcodec_close(AVCodecContext *avctx);
-
-/**
- * Free all allocated data in the given subtitle struct.
- *
- * @param sub AVSubtitle to free.
- */
-void avsubtitle_free(AVSubtitle *sub);
-
-/**
- * @}
- */
-
-/**
- * @addtogroup lavc_packet
- * @{
- */
-
-/**
- * Allocate an AVPacket and set its fields to default values. The resulting
- * struct must be freed using av_packet_free().
- *
- * @return An AVPacket filled with default values or NULL on failure.
- *
- * @note this only allocates the AVPacket itself, not the data buffers. Those
- * must be allocated through other means such as av_new_packet.
- *
- * @see av_new_packet
- */
-AVPacket *av_packet_alloc(void);
-
-/**
- * Create a new packet that references the same data as src.
- *
- * This is a shortcut for av_packet_alloc()+av_packet_ref().
- *
- * @return newly created AVPacket on success, NULL on error.
- *
- * @see av_packet_alloc
- * @see av_packet_ref
- */
-AVPacket *av_packet_clone(const AVPacket *src);
-
-/**
- * Free the packet, if the packet is reference counted, it will be
- * unreferenced first.
- *
- * @param pkt packet to be freed. The pointer will be set to NULL.
- * @note passing NULL is a no-op.
- */
-void av_packet_free(AVPacket **pkt);
-
-/**
- * Initialize optional fields of a packet with default values.
- *
- * Note, this does not touch the data and size members, which have to be
- * initialized separately.
- *
- * @param pkt packet
- */
-void av_init_packet(AVPacket *pkt);
-
-/**
- * Allocate the payload of a packet and initialize its fields with
- * default values.
- *
- * @param pkt packet
- * @param size wanted payload size
- * @return 0 if OK, AVERROR_xxx otherwise
- */
-int av_new_packet(AVPacket *pkt, int size);
-
-/**
- * Reduce packet size, correctly zeroing padding
- *
- * @param pkt packet
- * @param size new size
- */
-void av_shrink_packet(AVPacket *pkt, int size);
-
-/**
- * Increase packet size, correctly zeroing padding
- *
- * @param pkt packet
- * @param grow_by number of bytes by which to increase the size of the packet
- */
-int av_grow_packet(AVPacket *pkt, int grow_by);
-
-/**
- * Initialize a reference-counted packet from av_malloc()ed data.
- *
- * @param pkt packet to be initialized. This function will set the data, size,
- * buf and destruct fields, all others are left untouched.
- * @param data Data allocated by av_malloc() to be used as packet data. If this
- * function returns successfully, the data is owned by the underlying AVBuffer.
- * The caller may not access the data through other means.
- * @param size size of data in bytes, without the padding. I.e. the full buffer
- * size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
- *
- * @return 0 on success, a negative AVERROR on error
- */
-int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
-
-#if FF_API_AVPACKET_OLD_API
-/**
- * @warning This is a hack - the packet memory allocation stuff is broken. The
- * packet is allocated if it was not really allocated.
- *
- * @deprecated Use av_packet_ref or av_packet_make_refcounted
- */
-attribute_deprecated
-int av_dup_packet(AVPacket *pkt);
-/**
- * Copy packet, including contents
- *
- * @return 0 on success, negative AVERROR on fail
- *
- * @deprecated Use av_packet_ref
- */
-attribute_deprecated
-int av_copy_packet(AVPacket *dst, const AVPacket *src);
-
-/**
- * Copy packet side data
- *
- * @return 0 on success, negative AVERROR on fail
- *
- * @deprecated Use av_packet_copy_props
- */
-attribute_deprecated
-int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
-
-/**
- * Free a packet.
- *
- * @deprecated Use av_packet_unref
- *
- * @param pkt packet to free
- */
-attribute_deprecated
-void av_free_packet(AVPacket *pkt);
-#endif
-/**
- * Allocate new information of a packet.
- *
- * @param pkt packet
- * @param type side information type
- * @param size side information size
- * @return pointer to fresh allocated data or NULL otherwise
- */
-uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
- int size);
-
-/**
- * Wrap an existing array as a packet side data.
- *
- * @param pkt packet
- * @param type side information type
- * @param data the side data array. It must be allocated with the av_malloc()
- * family of functions. The ownership of the data is transferred to
- * pkt.
- * @param size side information size
- * @return a non-negative number on success, a negative AVERROR code on
- * failure. On failure, the packet is unchanged and the data remains
- * owned by the caller.
- */
-int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
- uint8_t *data, size_t size);
-
-/**
- * Shrink the already allocated side data buffer
- *
- * @param pkt packet
- * @param type side information type
- * @param size new side information size
- * @return 0 on success, < 0 on failure
- */
-int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
- int size);
-
-/**
- * Get side information from packet.
- *
- * @param pkt packet
- * @param type desired side information type
- * @param size pointer for side information size to store (optional)
- * @return pointer to data if present or NULL otherwise
- */
-uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
- int *size);
-
-#if FF_API_MERGE_SD_API
-attribute_deprecated
-int av_packet_merge_side_data(AVPacket *pkt);
-
-attribute_deprecated
-int av_packet_split_side_data(AVPacket *pkt);
-#endif
-
-const char *av_packet_side_data_name(enum AVPacketSideDataType type);
-
-/**
- * Pack a dictionary for use in side_data.
- *
- * @param dict The dictionary to pack.
- * @param size pointer to store the size of the returned data
- * @return pointer to data if successful, NULL otherwise
- */
-uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
-/**
- * Unpack a dictionary from side_data.
- *
- * @param data data from side_data
- * @param size size of the data
- * @param dict the metadata storage dictionary
- * @return 0 on success, < 0 on failure
- */
-int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
-
-
-/**
- * Convenience function to free all the side data stored.
- * All the other fields stay untouched.
- *
- * @param pkt packet
- */
-void av_packet_free_side_data(AVPacket *pkt);
-
-/**
- * Setup a new reference to the data described by a given packet
- *
- * If src is reference-counted, setup dst as a new reference to the
- * buffer in src. Otherwise allocate a new buffer in dst and copy the
- * data from src into it.
- *
- * All the other fields are copied from src.
- *
- * @see av_packet_unref
- *
- * @param dst Destination packet
- * @param src Source packet
- *
- * @return 0 on success, a negative AVERROR on error.
- */
-int av_packet_ref(AVPacket *dst, const AVPacket *src);
-
-/**
- * Wipe the packet.
- *
- * Unreference the buffer referenced by the packet and reset the
- * remaining packet fields to their default values.
- *
- * @param pkt The packet to be unreferenced.
- */
-void av_packet_unref(AVPacket *pkt);
-
-/**
- * Move every field in src to dst and reset src.
- *
- * @see av_packet_unref
- *
- * @param src Source packet, will be reset
- * @param dst Destination packet
- */
-void av_packet_move_ref(AVPacket *dst, AVPacket *src);
-
-/**
- * Copy only "properties" fields from src to dst.
- *
- * Properties for the purpose of this function are all the fields
- * beside those related to the packet data (buf, data, size)
- *
- * @param dst Destination packet
- * @param src Source packet
- *
- * @return 0 on success AVERROR on failure.
- */
-int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
-
-/**
- * Ensure the data described by a given packet is reference counted.
- *
- * @note This function does not ensure that the reference will be writable.
- * Use av_packet_make_writable instead for that purpose.
- *
- * @see av_packet_ref
- * @see av_packet_make_writable
- *
- * @param pkt packet whose data should be made reference counted.
- *
- * @return 0 on success, a negative AVERROR on error. On failure, the
- * packet is unchanged.
- */
-int av_packet_make_refcounted(AVPacket *pkt);
-
-/**
- * Create a writable reference for the data described by a given packet,
- * avoiding data copy if possible.
- *
- * @param pkt Packet whose data should be made writable.
- *
- * @return 0 on success, a negative AVERROR on failure. On failure, the
- * packet is unchanged.
- */
-int av_packet_make_writable(AVPacket *pkt);
-
-/**
- * Convert valid timing fields (timestamps / durations) in a packet from one
- * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
- * ignored.
- *
- * @param pkt packet on which the conversion will be performed
- * @param tb_src source timebase, in which the timing fields in pkt are
- * expressed
- * @param tb_dst destination timebase, to which the timing fields will be
- * converted
- */
-void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
-
-/**
- * @}
- */
-
-/**
- * @addtogroup lavc_decoding
- * @{
- */
-
-/**
- * Find a registered decoder with a matching codec ID.
- *
- * @param id AVCodecID of the requested decoder
- * @return A decoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_decoder(enum AVCodecID id);
-
-/**
- * Find a registered decoder with the specified name.
- *
- * @param name name of the requested decoder
- * @return A decoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_decoder_by_name(const char *name);
-
-/**
- * The default callback for AVCodecContext.get_buffer2(). It is made public so
- * it can be called by custom get_buffer2() implementations for decoders without
- * AV_CODEC_CAP_DR1 set.
- */
-int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags);
-
-/**
- * Modify width and height values so that they will result in a memory
- * buffer that is acceptable for the codec if you do not use any horizontal
- * padding.
- *
- * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened.
- */
-void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
-
-/**
- * Modify width and height values so that they will result in a memory
- * buffer that is acceptable for the codec if you also ensure that all
- * line sizes are a multiple of the respective linesize_aligni.
- *
- * May only be used if a codec with AV_CODEC_CAP_DR1 has been opened.
- */
-void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
- int linesize_alignAV_NUM_DATA_POINTERS);
-
-/**
- * Converts AVChromaLocation to swscale x/y chroma position.
- *
- * The positions represent the chroma (0,0) position in a coordinates system
- * with luma (0,0) representing the origin and luma(1,1) representing 256,256
- *
- * @param xpos horizontal chroma sample position
- * @param ypos vertical chroma sample position
- */
-int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
-
-/**
- * Converts swscale x/y chroma position to AVChromaLocation.
- *
- * The positions represent the chroma (0,0) position in a coordinates system
- * with luma (0,0) representing the origin and luma(1,1) representing 256,256
- *
- * @param xpos horizontal chroma sample position
- * @param ypos vertical chroma sample position
- */
-enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
-
-/**
- * Decode the audio frame of size avpkt->size from avpkt->data into frame.
- *
- * Some decoders may support multiple frames in a single AVPacket. Such
- * decoders would then just decode the first frame and the return value would be
- * less than the packet size. In this case, avcodec_decode_audio4 has to be
- * called again with an AVPacket containing the remaining data in order to
- * decode the second frame, etc... Even if no frames are returned, the packet
- * needs to be fed to the decoder with remaining data until it is completely
- * consumed or an error occurs.
- *
- * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input
- * and output. This means that for some packets they will not immediately
- * produce decoded output and need to be flushed at the end of decoding to get
- * all the decoded data. Flushing is done by calling this function with packets
- * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
- * returning samples. It is safe to flush even those decoders that are not
- * marked with AV_CODEC_CAP_DELAY, then no samples will be returned.
- *
- * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE
- * larger than the actual read bytes because some optimized bitstream
- * readers read 32 or 64 bits at once and could read over the end.
- *
- * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
- * before packets may be fed to the decoder.
- *
- * @param avctx the codec context
- * @paramout frame The AVFrame in which to store decoded audio samples.
- * The decoder will allocate a buffer for the decoded frame by
- * calling the AVCodecContext.get_buffer2() callback.
- * When AVCodecContext.refcounted_frames is set to 1, the frame is
- * reference counted and the returned reference belongs to the
- * caller. The caller must release the frame using av_frame_unref()
- * when the frame is no longer needed. The caller may safely write
- * to the frame if av_frame_is_writable() returns 1.
- * When AVCodecContext.refcounted_frames is set to 0, the returned
- * reference belongs to the decoder and is valid only until the
- * next call to this function or until closing or flushing the
- * decoder. The caller may not write to it.
- * @paramout got_frame_ptr Zero if no frame could be decoded, otherwise it is
- * non-zero. Note that this field being set to zero
- * does not mean that an error has occurred. For
- * decoders with AV_CODEC_CAP_DELAY set, no given decode
- * call is guaranteed to produce a frame.
- * @paramin avpkt The input AVPacket containing the input buffer.
- * At least avpkt->data and avpkt->size should be set. Some
- * decoders might also require additional fields to be set.
- * @return A negative error code is returned if an error occurred during
- * decoding, otherwise the number of bytes consumed from the input
- * AVPacket is returned.
- *
-* @deprecated Use avcodec_send_packet() and avcodec_receive_frame().
- */
-attribute_deprecated
-int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
- int *got_frame_ptr, const AVPacket *avpkt);
-
-/**
- * Decode the video frame of size avpkt->size from avpkt->data into picture.
- * Some decoders may support multiple frames in a single AVPacket, such
- * decoders would then just decode the first frame.
- *
- * @warning The input buffer must be AV_INPUT_BUFFER_PADDING_SIZE larger than
- * the actual read bytes because some optimized bitstream readers read 32 or 64
- * bits at once and could read over the end.
- *
- * @warning The end of the input buffer buf should be set to 0 to ensure that
- * no overreading happens for damaged MPEG streams.
- *
- * @note Codecs which have the AV_CODEC_CAP_DELAY capability set have a delay
- * between input and output, these need to be fed with avpkt->data=NULL,
- * avpkt->size=0 at the end to return the remaining frames.
- *
- * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
- * before packets may be fed to the decoder.
- *
- * @param avctx the codec context
- * @paramout picture The AVFrame in which the decoded video frame will be stored.
- * Use av_frame_alloc() to get an AVFrame. The codec will
- * allocate memory for the actual bitmap by calling the
- * AVCodecContext.get_buffer2() callback.
- * When AVCodecContext.refcounted_frames is set to 1, the frame is
- * reference counted and the returned reference belongs to the
- * caller. The caller must release the frame using av_frame_unref()
- * when the frame is no longer needed. The caller may safely write
- * to the frame if av_frame_is_writable() returns 1.
- * When AVCodecContext.refcounted_frames is set to 0, the returned
- * reference belongs to the decoder and is valid only until the
- * next call to this function or until closing or flushing the
- * decoder. The caller may not write to it.
- *
- * @paramin avpkt The input AVPacket containing the input buffer.
- * You can create such packet with av_init_packet() and by then setting
- * data and size, some decoders might in addition need other fields like
- * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least
- * fields possible.
- * @paramin,out got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
- * @return On error a negative value is returned, otherwise the number of bytes
- * used or zero if no frame could be decompressed.
- *
- * @deprecated Use avcodec_send_packet() and avcodec_receive_frame().
- */
-attribute_deprecated
-int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
- int *got_picture_ptr,
- const AVPacket *avpkt);
-
-/**
- * Decode a subtitle message.
- * Return a negative value on error, otherwise return the number of bytes used.
- * If no subtitle could be decompressed, got_sub_ptr is zero.
- * Otherwise, the subtitle is stored in *sub.
- * Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for
- * simplicity, because the performance difference is expect to be negligible
- * and reusing a get_buffer written for video codecs would probably perform badly
- * due to a potentially very different allocation pattern.
- *
- * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input
- * and output. This means that for some packets they will not immediately
- * produce decoded output and need to be flushed at the end of decoding to get
- * all the decoded data. Flushing is done by calling this function with packets
- * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
- * returning subtitles. It is safe to flush even those decoders that are not
- * marked with AV_CODEC_CAP_DELAY, then no subtitles will be returned.
- *
- * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
- * before packets may be fed to the decoder.
- *
- * @param avctx the codec context
- * @paramout sub The Preallocated AVSubtitle in which the decoded subtitle will be stored,
- * must be freed with avsubtitle_free if *got_sub_ptr is set.
- * @paramin,out got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
- * @paramin avpkt The input AVPacket containing the input buffer.
- */
-int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
- int *got_sub_ptr,
- AVPacket *avpkt);
-
-/**
- * Supply raw packet data as input to a decoder.
- *
- * Internally, this call will copy relevant AVCodecContext fields, which can
- * influence decoding per-packet, and apply them when the packet is actually
- * decoded. (For example AVCodecContext.skip_frame, which might direct the
- * decoder to drop the frame contained by the packet sent with this function.)
- *
- * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE
- * larger than the actual read bytes because some optimized bitstream
- * readers read 32 or 64 bits at once and could read over the end.
- *
- * @warning Do not mix this API with the legacy API (like avcodec_decode_video2())
- * on the same AVCodecContext. It will return unexpected results now
- * or in future libavcodec versions.
- *
- * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
- * before packets may be fed to the decoder.
- *
- * @param avctx codec context
- * @paramin avpkt The input AVPacket. Usually, this will be a single video
- * frame, or several complete audio frames.
- * Ownership of the packet remains with the caller, and the
- * decoder will not write to the packet. The decoder may create
- * a reference to the packet data (or copy it if the packet is
- * not reference-counted).
- * Unlike with older APIs, the packet is always fully consumed,
- * and if it contains multiple frames (e.g. some audio codecs),
- * will require you to call avcodec_receive_frame() multiple
- * times afterwards before you can send a new packet.
- * It can be NULL (or an AVPacket with data set to NULL and
- * size set to 0); in this case, it is considered a flush
- * packet, which signals the end of the stream. Sending the
- * first flush packet will return success. Subsequent ones are
- * unnecessary and will return AVERROR_EOF. If the decoder
- * still has frames buffered, it will return them after sending
- * a flush packet.
- *
- * @return 0 on success, otherwise negative error code:
- * AVERROR(EAGAIN): input is not accepted in the current state - user
- * must read output with avcodec_receive_frame() (once
- * all output is read, the packet should be resent, and
- * the call will not fail with EAGAIN).
- * AVERROR_EOF: the decoder has been flushed, and no new packets can
- * be sent to it (also returned if more than 1 flush
- * packet is sent)
- * AVERROR(EINVAL): codec not opened, it is an encoder, or requires flush
- * AVERROR(ENOMEM): failed to add packet to internal queue, or similar
- * other errors: legitimate decoding errors
- */
-int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);
-
-/**
- * Return decoded output data from a decoder.
- *
- * @param avctx codec context
- * @param frame This will be set to a reference-counted video or audio
- * frame (depending on the decoder type) allocated by the
- * decoder. Note that the function will always call
- * av_frame_unref(frame) before doing anything else.
- *
- * @return
- * 0: success, a frame was returned
- * AVERROR(EAGAIN): output is not available in this state - user must try
- * to send new input
- * AVERROR_EOF: the decoder has been fully flushed, and there will be
- * no more output frames
- * AVERROR(EINVAL): codec not opened, or it is an encoder
- * other negative values: legitimate decoding errors
- */
-int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);
-
-/**
- * Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet()
- * to retrieve buffered output packets.
- *
- * @param avctx codec context
- * @paramin frame AVFrame containing the raw audio or video frame to be encoded.
- * Ownership of the frame remains with the caller, and the
- * encoder will not write to the frame. The encoder may create
- * a reference to the frame data (or copy it if the frame is
- * not reference-counted).
- * It can be NULL, in which case it is considered a flush
- * packet. This signals the end of the stream. If the encoder
- * still has packets buffered, it will return them after this
- * call. Once flushing mode has been entered, additional flush
- * packets are ignored, and sending frames will return
- * AVERROR_EOF.
- *
- * For audio:
- * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
- * can have any number of samples.
- * If it is not set, frame->nb_samples must be equal to
- * avctx->frame_size for all frames except the last.
- * The final frame may be smaller than avctx->frame_size.
- * @return 0 on success, otherwise negative error code:
- * AVERROR(EAGAIN): input is not accepted in the current state - user
- * must read output with avcodec_receive_packet() (once
- * all output is read, the packet should be resent, and
- * the call will not fail with EAGAIN).
- * AVERROR_EOF: the encoder has been flushed, and no new frames can
- * be sent to it
- * AVERROR(EINVAL): codec not opened, refcounted_frames not set, it is a
- * decoder, or requires flush
- * AVERROR(ENOMEM): failed to add packet to internal queue, or similar
- * other errors: legitimate decoding errors
- */
-int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);
-
-/**
- * Read encoded data from the encoder.
- *
- * @param avctx codec context
- * @param avpkt This will be set to a reference-counted packet allocated by the
- * encoder. Note that the function will always call
- * av_frame_unref(frame) before doing anything else.
- * @return 0 on success, otherwise negative error code:
- * AVERROR(EAGAIN): output is not available in the current state - user
- * must try to send input
- * AVERROR_EOF: the encoder has been fully flushed, and there will be
- * no more output packets
- * AVERROR(EINVAL): codec not opened, or it is an encoder
- * other errors: legitimate decoding errors
- */
-int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt);
-
-/**
- * Create and return a AVHWFramesContext with values adequate for hardware
- * decoding. This is meant to get called from the get_format callback, and is
- * a helper for preparing a AVHWFramesContext for AVCodecContext.hw_frames_ctx.
- * This API is for decoding with certain hardware acceleration modes/APIs only.
- *
- * The returned AVHWFramesContext is not initialized. The caller must do this
- * with av_hwframe_ctx_init().
- *
- * Calling this function is not a requirement, but makes it simpler to avoid
- * codec or hardware API specific details when manually allocating frames.
- *
- * Alternatively to this, an API user can set AVCodecContext.hw_device_ctx,
- * which sets up AVCodecContext.hw_frames_ctx fully automatically, and makes
- * it unnecessary to call this function or having to care about
- * AVHWFramesContext initialization at all.
- *
- * There are a number of requirements for calling this function:
- *
- * - It must be called from get_format with the same avctx parameter that was
- * passed to get_format. Calling it outside of get_format is not allowed, and
- * can trigger undefined behavior.
- * - The function is not always supported (see description of return values).
- * Even if this function returns successfully, hwaccel initialization could
- * fail later. (The degree to which implementations check whether the stream
- * is actually supported varies. Some do this check only after the user's
- * get_format callback returns.)
- * - The hw_pix_fmt must be one of the choices suggested by get_format. If the
- * user decides to use a AVHWFramesContext prepared with this API function,
- * the user must return the same hw_pix_fmt from get_format.
- * - The device_ref passed to this function must support the given hw_pix_fmt.
- * - After calling this API function, it is the user's responsibility to
- * initialize the AVHWFramesContext (returned by the out_frames_ref parameter),
- * and to set AVCodecContext.hw_frames_ctx to it. If done, this must be done
- * before returning from get_format (this is implied by the normal
- * AVCodecContext.hw_frames_ctx API rules).
- * - The AVHWFramesContext parameters may change every time time get_format is
- * called. Also, AVCodecContext.hw_frames_ctx is reset before get_format. So
- * you are inherently required to go through this process again on every
- * get_format call.
- * - It is perfectly possible to call this function without actually using
- * the resulting AVHWFramesContext. One use-case might be trying to reuse a
- * previously initialized AVHWFramesContext, and calling this API function
- * only to test whether the required frame parameters have changed.
- * - Fields that use dynamically allocated values of any kind must not be set
- * by the user unless setting them is explicitly allowed by the documentation.
- * If the user sets AVHWFramesContext.free and AVHWFramesContext.user_opaque,
- * the new free callback must call the potentially set previous free callback.
- * This API call may set any dynamically allocated fields, including the free
- * callback.
- *
- * The function will set at least the following fields on AVHWFramesContext
- * (potentially more, depending on hwaccel API):
- *
- * - All fields set by av_hwframe_ctx_alloc().
- * - Set the format field to hw_pix_fmt.
- * - Set the sw_format field to the most suited and most versatile format. (An
- * implication is that this will prefer generic formats over opaque formats
- * with arbitrary restrictions, if possible.)
- * - Set the width/height fields to the coded frame size, rounded up to the
- * API-specific minimum alignment.
- * - Only _if_ the hwaccel requires a pre-allocated pool: set the initial_pool_size
- * field to the number of maximum reference surfaces possible with the codec,
- * plus 1 surface for the user to work (meaning the user can safely reference
- * at most 1 decoded surface at a time), plus additional buffering introduced
- * by frame threading. If the hwaccel does not require pre-allocation, the
- * field is left to 0, and the decoder will allocate new surfaces on demand
- * during decoding.
- * - Possibly AVHWFramesContext.hwctx fields, depending on the underlying
- * hardware API.
- *
- * Essentially, out_frames_ref returns the same as av_hwframe_ctx_alloc(), but
- * with basic frame parameters set.
- *
- * The function is stateless, and does not change the AVCodecContext or the
- * device_ref AVHWDeviceContext.
- *
- * @param avctx The context which is currently calling get_format, and which
- * implicitly contains all state needed for filling the returned
- * AVHWFramesContext properly.
- * @param device_ref A reference to the AVHWDeviceContext describing the device
- * which will be used by the hardware decoder.
- * @param hw_pix_fmt The hwaccel format you are going to return from get_format.
- * @param out_frames_ref On success, set to a reference to an _uninitialized_
- * AVHWFramesContext, created from the given device_ref.
- * Fields will be set to values required for decoding.
- * Not changed if an error is returned.
- * @return zero on success, a negative value on error. The following error codes
- * have special semantics:
- * AVERROR(ENOENT): the decoder does not support this functionality. Setup
- * is always manual, or it is a decoder which does not
- * support setting AVCodecContext.hw_frames_ctx at all,
- * or it is a software format.
- * AVERROR(EINVAL): it is known that hardware decoding is not supported for
- * this configuration, or the device_ref is not supported
- * for the hwaccel referenced by hw_pix_fmt.
- */
-int avcodec_get_hw_frames_parameters(AVCodecContext *avctx,
- AVBufferRef *device_ref,
- enum AVPixelFormat hw_pix_fmt,
- AVBufferRef **out_frames_ref);
-
-
-
-/**
- * @defgroup lavc_parsing Frame parsing
- * @{
- */
-
-enum AVPictureStructure {
- AV_PICTURE_STRUCTURE_UNKNOWN, //< unknown
- AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field
- AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field
- AV_PICTURE_STRUCTURE_FRAME, //< coded as frame
-};
-
-typedef struct AVCodecParserContext {
- void *priv_data;
- struct AVCodecParser *parser;
- int64_t frame_offset; /* offset of the current frame */
- int64_t cur_offset; /* current offset
- (incremented by each av_parser_parse()) */
- int64_t next_frame_offset; /* offset of the next frame */
- /* video info */
- int pict_type; /* XXX: Put it back in AVCodecContext. */
- /**
- * This field is used for proper frame duration computation in lavf.
- * It signals, how much longer the frame duration of the current frame
- * is compared to normal frame duration.
- *
- * frame_duration = (1 + repeat_pict) * time_base
- *
- * It is used by codecs like H.264 to display telecined material.
- */
- int repeat_pict; /* XXX: Put it back in AVCodecContext. */
- int64_t pts; /* pts of the current frame */
- int64_t dts; /* dts of the current frame */
-
- /* private data */
- int64_t last_pts;
- int64_t last_dts;
- int fetch_timestamp;
-
-#define AV_PARSER_PTS_NB 4
- int cur_frame_start_index;
- int64_t cur_frame_offsetAV_PARSER_PTS_NB;
- int64_t cur_frame_ptsAV_PARSER_PTS_NB;
- int64_t cur_frame_dtsAV_PARSER_PTS_NB;
-
- int flags;
-#define PARSER_FLAG_COMPLETE_FRAMES 0x0001
-#define PARSER_FLAG_ONCE 0x0002
-/// Set if the parser has a valid file offset
-#define PARSER_FLAG_FETCHED_OFFSET 0x0004
-#define PARSER_FLAG_USE_CODEC_TS 0x1000
-
- int64_t offset; ///< byte offset from starting packet start
- int64_t cur_frame_endAV_PARSER_PTS_NB;
-
- /**
- * Set by parser to 1 for key frames and 0 for non-key frames.
- * It is initialized to -1, so if the parser doesn't set this flag,
- * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames
- * will be used.
- */
- int key_frame;
-
-#if FF_API_CONVERGENCE_DURATION
- /**
- * @deprecated unused
- */
- attribute_deprecated
- int64_t convergence_duration;
-#endif
-
- // Timestamp generation support:
- /**
- * Synchronization point for start of timestamp generation.
- *
- * Set to >0 for sync point, 0 for no sync point and <0 for undefined
- * (default).
- *
- * For example, this corresponds to presence of H.264 buffering period
- * SEI message.
- */
- int dts_sync_point;
-
- /**
- * Offset of the current timestamp against last timestamp sync point in
- * units of AVCodecContext.time_base.
- *
- * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
- * contain a valid timestamp offset.
- *
- * Note that the timestamp of sync point has usually a nonzero
- * dts_ref_dts_delta, which refers to the previous sync point. Offset of
- * the next frame after timestamp sync point will be usually 1.
- *
- * For example, this corresponds to H.264 cpb_removal_delay.
- */
- int dts_ref_dts_delta;
-
- /**
- * Presentation delay of current frame in units of AVCodecContext.time_base.
- *
- * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
- * contain valid non-negative timestamp delta (presentation time of a frame
- * must not lie in the past).
- *
- * This delay represents the difference between decoding and presentation
- * time of the frame.
- *
- * For example, this corresponds to H.264 dpb_output_delay.
- */
- int pts_dts_delta;
-
- /**
- * Position of the packet in file.
- *
- * Analogous to cur_frame_pts/dts
- */
- int64_t cur_frame_posAV_PARSER_PTS_NB;
-
- /**
- * Byte position of currently parsed frame in stream.
- */
- int64_t pos;
-
- /**
- * Previous frame byte position.
- */
- int64_t last_pos;
-
- /**
- * Duration of the current frame.
- * For audio, this is in units of 1 / AVCodecContext.sample_rate.
- * For all other types, this is in units of AVCodecContext.time_base.
- */
- int duration;
-
- enum AVFieldOrder field_order;
-
- /**
- * Indicate whether a picture is coded as a frame, top field or bottom field.
- *
- * For example, H.264 field_pic_flag equal to 0 corresponds to
- * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag
- * equal to 1 and bottom_field_flag equal to 0 corresponds to
- * AV_PICTURE_STRUCTURE_TOP_FIELD.
- */
- enum AVPictureStructure picture_structure;
-
- /**
- * Picture number incremented in presentation or output order.
- * This field may be reinitialized at the first picture of a new sequence.
- *
- * For example, this corresponds to H.264 PicOrderCnt.
- */
- int output_picture_number;
-
- /**
- * Dimensions of the decoded video intended for presentation.
- */
- int width;
- int height;
-
- /**
- * Dimensions of the coded video.
- */
- int coded_width;
- int coded_height;
-
- /**
- * The format of the coded data, corresponds to enum AVPixelFormat for video
- * and for enum AVSampleFormat for audio.
- *
- * Note that a decoder can have considerable freedom in how exactly it
- * decodes the data, so the format reported here might be different from the
- * one returned by a decoder.
- */
- int format;
-} AVCodecParserContext;
-
-typedef struct AVCodecParser {
- int codec_ids5; /* several codec IDs are permitted */
- int priv_data_size;
- int (*parser_init)(AVCodecParserContext *s);
- /* This callback never returns an error, a negative value means that
- * the frame start was in a previous packet. */
- int (*parser_parse)(AVCodecParserContext *s,
- AVCodecContext *avctx,
- const uint8_t **poutbuf, int *poutbuf_size,
- const uint8_t *buf, int buf_size);
- void (*parser_close)(AVCodecParserContext *s);
- int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
- struct AVCodecParser *next;
-} AVCodecParser;
-
-/**
- * Iterate over all registered codec parsers.
- *
- * @param opaque a pointer where libavcodec will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered codec parser or NULL when the iteration is
- * finished
- */
-const AVCodecParser *av_parser_iterate(void **opaque);
-
-attribute_deprecated
-AVCodecParser *av_parser_next(const AVCodecParser *c);
-
-attribute_deprecated
-void av_register_codec_parser(AVCodecParser *parser);
-AVCodecParserContext *av_parser_init(int codec_id);
-
-/**
- * Parse a packet.
- *
- * @param s parser context.
- * @param avctx codec context.
- * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished.
- * @param poutbuf_size set to size of parsed buffer or zero if not yet finished.
- * @param buf input buffer.
- * @param buf_size buffer size in bytes without the padding. I.e. the full buffer
- size is assumed to be buf_size + AV_INPUT_BUFFER_PADDING_SIZE.
- To signal EOF, this should be 0 (so that the last frame
- can be output).
- * @param pts input presentation timestamp.
- * @param dts input decoding timestamp.
- * @param pos input byte position in stream.
- * @return the number of bytes of the input bitstream used.
- *
- * Example:
- * @code
- * while(in_len){
- * len = av_parser_parse2(myparser, AVCodecContext, &data, &size,
- * in_data, in_len,
- * pts, dts, pos);
- * in_data += len;
- * in_len -= len;
- *
- * if(size)
- * decode_frame(data, size);
- * }
- * @endcode
- */
-int av_parser_parse2(AVCodecParserContext *s,
- AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
- const uint8_t *buf, int buf_size,
- int64_t pts, int64_t dts,
- int64_t pos);
-
-/**
- * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
- * @deprecated use AVBitStreamFilter
- */
-int av_parser_change(AVCodecParserContext *s,
- AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
- const uint8_t *buf, int buf_size, int keyframe);
-void av_parser_close(AVCodecParserContext *s);
-
-/**
- * @}
- * @}
- */
-
-/**
- * @addtogroup lavc_encoding
- * @{
- */
-
-/**
- * Find a registered encoder with a matching codec ID.
- *
- * @param id AVCodecID of the requested encoder
- * @return An encoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_encoder(enum AVCodecID id);
-
-/**
- * Find a registered encoder with the specified name.
- *
- * @param name name of the requested encoder
- * @return An encoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_encoder_by_name(const char *name);
-
-/**
- * Encode a frame of audio.
- *
- * Takes input samples from frame and writes the next output packet, if
- * available, to avpkt. The output packet does not necessarily contain data for
- * the most recent frame, as encoders can delay, split, and combine input frames
- * internally as needed.
- *
- * @param avctx codec context
- * @param avpkt output AVPacket.
- * The user can supply an output buffer by setting
- * avpkt->data and avpkt->size prior to calling the
- * function, but if the size of the user-provided data is not
- * large enough, encoding will fail. If avpkt->data and
- * avpkt->size are set, avpkt->destruct must also be set. All
- * other AVPacket fields will be reset by the encoder using
- * av_init_packet(). If avpkt->data is NULL, the encoder will
- * allocate it. The encoder will set avpkt->size to the size
- * of the output packet.
- *
- * If this function fails or produces no output, avpkt will be
- * freed using av_packet_unref().
- * @paramin frame AVFrame containing the raw audio data to be encoded.
- * May be NULL when flushing an encoder that has the
- * AV_CODEC_CAP_DELAY capability set.
- * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
- * can have any number of samples.
- * If it is not set, frame->nb_samples must be equal to
- * avctx->frame_size for all frames except the last.
- * The final frame may be smaller than avctx->frame_size.
- * @paramout got_packet_ptr This field is set to 1 by libavcodec if the
- * output packet is non-empty, and to 0 if it is
- * empty. If the function returns an error, the
- * packet can be assumed to be invalid, and the
- * value of got_packet_ptr is undefined and should
- * not be used.
- * @return 0 on success, negative error code on failure
- *
- * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead
- */
-attribute_deprecated
-int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
- const AVFrame *frame, int *got_packet_ptr);
-
-/**
- * Encode a frame of video.
- *
- * Takes input raw video data from frame and writes the next output packet, if
- * available, to avpkt. The output packet does not necessarily contain data for
- * the most recent frame, as encoders can delay and reorder input frames
- * internally as needed.
- *
- * @param avctx codec context
- * @param avpkt output AVPacket.
- * The user can supply an output buffer by setting
- * avpkt->data and avpkt->size prior to calling the
- * function, but if the size of the user-provided data is not
- * large enough, encoding will fail. All other AVPacket fields
- * will be reset by the encoder using av_init_packet(). If
- * avpkt->data is NULL, the encoder will allocate it.
- * The encoder will set avpkt->size to the size of the
- * output packet. The returned data (if any) belongs to the
- * caller, he is responsible for freeing it.
- *
- * If this function fails or produces no output, avpkt will be
- * freed using av_packet_unref().
- * @paramin frame AVFrame containing the raw video data to be encoded.
- * May be NULL when flushing an encoder that has the
- * AV_CODEC_CAP_DELAY capability set.
- * @paramout got_packet_ptr This field is set to 1 by libavcodec if the
- * output packet is non-empty, and to 0 if it is
- * empty. If the function returns an error, the
- * packet can be assumed to be invalid, and the
- * value of got_packet_ptr is undefined and should
- * not be used.
- * @return 0 on success, negative error code on failure
- *
- * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead
- */
-attribute_deprecated
-int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,
- const AVFrame *frame, int *got_packet_ptr);
-
-int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
- const AVSubtitle *sub);
-
-
-/**
- * @}
- */
-
-#if FF_API_AVPICTURE
-/**
- * @addtogroup lavc_picture
- * @{
- */
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-void avpicture_free(AVPicture *picture);
-
-/**
- * @deprecated use av_image_fill_arrays() instead.
- */
-attribute_deprecated
-int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
- enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated use av_image_copy_to_buffer() instead.
- */
-attribute_deprecated
-int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt,
- int width, int height,
- unsigned char *dest, int dest_size);
-
-/**
- * @deprecated use av_image_get_buffer_size() instead.
- */
-attribute_deprecated
-int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated av_image_copy() instead.
- */
-attribute_deprecated
-void av_picture_copy(AVPicture *dst, const AVPicture *src,
- enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-int av_picture_crop(AVPicture *dst, const AVPicture *src,
- enum AVPixelFormat pix_fmt, int top_band, int left_band);
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt,
- int padtop, int padbottom, int padleft, int padright, int *color);
-
-/**
- * @}
- */
-#endif
-
-/**
- * @defgroup lavc_misc Utility functions
- * @ingroup libavc
- *
- * Miscellaneous utility functions related to both encoding and decoding
- * (or neither).
- * @{
- */
-
-/**
- * @defgroup lavc_misc_pixfmt Pixel formats
- *
- * Functions for working with pixel formats.
- * @{
- */
-
-#if FF_API_GETCHROMA
-/**
- * @deprecated Use av_pix_fmt_get_chroma_sub_sample
- */
-
-attribute_deprecated
-void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
-#endif
-
-/**
- * Return a value representing the fourCC code associated to the
- * pixel format pix_fmt, or 0 if no associated fourCC code can be
- * found.
- */
-unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt);
-
-/**
- * @deprecated see av_get_pix_fmt_loss()
- */
-int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
- int has_alpha);
-
-/**
- * Find the best pixel format to convert to given a certain source pixel
- * format. When converting from one pixel format to another, information loss
- * may occur. For example, when converting from RGB24 to GRAY, the color
- * information will be lost. Similarly, other losses occur when converting from
- * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of
- * the given pixel formats should be used to suffer the least amount of loss.
- * The pixel formats from which it chooses one, are determined by the
- * pix_fmt_list parameter.
- *
- *
- * @paramin pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from
- * @paramin src_pix_fmt source pixel format
- * @paramin has_alpha Whether the source pixel format alpha channel is used.
- * @paramout loss_ptr Combination of flags informing you what kind of losses will occur.
- * @return The best pixel format to convert to or -1 if none was found.
- */
-enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
- enum AVPixelFormat src_pix_fmt,
- int has_alpha, int *loss_ptr);
-
-/**
- * @deprecated see av_find_best_pix_fmt_of_2()
- */
-enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
- enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
-
-attribute_deprecated
-enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
- enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
-
-enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
-
-/**
- * @}
- */
-
-#if FF_API_TAG_STRING
-/**
- * Put a string representing the codec tag codec_tag in buf.
- *
- * @param buf buffer to place codec tag in
- * @param buf_size size in bytes of buf
- * @param codec_tag codec tag to assign
- * @return the length of the string that would have been generated if
- * enough space had been available, excluding the trailing null
- *
- * @deprecated see av_fourcc_make_string() and av_fourcc2str().
- */
-attribute_deprecated
-size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
-#endif
-
-void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
-
-/**
- * Return a name for the specified profile, if available.
- *
- * @param codec the codec that is searched for the given profile
- * @param profile the profile value for which a name is requested
- * @return A name for the profile if found, NULL otherwise.
- */
-const char *av_get_profile_name(const AVCodec *codec, int profile);
-
-/**
- * Return a name for the specified profile, if available.
- *
- * @param codec_id the ID of the codec to which the requested profile belongs
- * @param profile the profile value for which a name is requested
- * @return A name for the profile if found, NULL otherwise.
- *
- * @note unlike av_get_profile_name(), which searches a list of profiles
- * supported by a specific decoder or encoder implementation, this
- * function searches the list of profiles from the AVCodecDescriptor
- */
-const char *avcodec_profile_name(enum AVCodecID codec_id, int profile);
-
-int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
-int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
-//FIXME func typedef
-
-/**
- * Fill AVFrame audio data and linesize pointers.
- *
- * The buffer buf must be a preallocated buffer with a size big enough
- * to contain the specified samples amount. The filled AVFrame data
- * pointers will point to this buffer.
- *
- * AVFrame extended_data channel pointers are allocated if necessary for
- * planar audio.
- *
- * @param frame the AVFrame
- * frame->nb_samples must be set prior to calling the
- * function. This function fills in frame->data,
- * frame->extended_data, frame->linesize0.
- * @param nb_channels channel count
- * @param sample_fmt sample format
- * @param buf buffer to use for frame data
- * @param buf_size size of buffer
- * @param align plane size sample alignment (0 = default)
- * @return >=0 on success, negative error code on failure
- * @todo return the size in bytes required to store the samples in
- * case of success, at the next libavutil bump
- */
-int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
- enum AVSampleFormat sample_fmt, const uint8_t *buf,
- int buf_size, int align);
-
-/**
- * Reset the internal decoder state / flush internal buffers. Should be called
- * e.g. when seeking or when switching to a different stream.
- *
- * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0),
- * this invalidates the frames previously returned from the decoder. When
- * refcounted frames are used, the decoder just releases any references it might
- * keep internally, but the caller's reference remains valid.
- */
-void avcodec_flush_buffers(AVCodecContext *avctx);
-
-/**
- * Return codec bits per sample.
- *
- * @paramin codec_id the codec
- * @return Number of bits per sample or zero if unknown for the given codec.
- */
-int av_get_bits_per_sample(enum AVCodecID codec_id);
-
-/**
- * Return the PCM codec associated with a sample format.
- * @param be endianness, 0 for little, 1 for big,
- * -1 (or anything else) for native
- * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
- */
-enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
-
-/**
- * Return codec bits per sample.
- * Only return non-zero if the bits per sample is exactly correct, not an
- * approximation.
- *
- * @paramin codec_id the codec
- * @return Number of bits per sample or zero if unknown for the given codec.
- */
-int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
-
-/**
- * Return audio frame duration.
- *
- * @param avctx codec context
- * @param frame_bytes size of the frame, or 0 if unknown
- * @return frame duration, in samples, if known. 0 if not able to
- * determine.
- */
-int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes);
-
-/**
- * This function is the same as av_get_audio_frame_duration(), except it works
- * with AVCodecParameters instead of an AVCodecContext.
- */
-int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);
-
-#if FF_API_OLD_BSF
-typedef struct AVBitStreamFilterContext {
- void *priv_data;
- const struct AVBitStreamFilter *filter;
- AVCodecParserContext *parser;
- struct AVBitStreamFilterContext *next;
- /**
- * Internal default arguments, used if NULL is passed to av_bitstream_filter_filter().
- * Not for access by library users.
- */
- char *args;
-} AVBitStreamFilterContext;
-#endif
-
-typedef struct AVBSFInternal AVBSFInternal;
-
-/**
- * The bitstream filter state.
- *
- * This struct must be allocated with av_bsf_alloc() and freed with
- * av_bsf_free().
- *
- * The fields in the struct will only be changed (by the caller or by the
- * filter) as described in their documentation, and are to be considered
- * immutable otherwise.
- */
-typedef struct AVBSFContext {
- /**
- * A class for logging and AVOptions
- */
- const AVClass *av_class;
-
- /**
- * The bitstream filter this context is an instance of.
- */
- const struct AVBitStreamFilter *filter;
-
- /**
- * Opaque libavcodec internal data. Must not be touched by the caller in any
- * way.
- */
- AVBSFInternal *internal;
-
- /**
- * Opaque filter-specific private data. If filter->priv_class is non-NULL,
- * this is an AVOptions-enabled struct.
- */
- void *priv_data;
-
- /**
- * Parameters of the input stream. This field is allocated in
- * av_bsf_alloc(), it needs to be filled by the caller before
- * av_bsf_init().
- */
- AVCodecParameters *par_in;
-
- /**
- * Parameters of the output stream. This field is allocated in
- * av_bsf_alloc(), it is set by the filter in av_bsf_init().
- */
- AVCodecParameters *par_out;
-
- /**
- * The timebase used for the timestamps of the input packets. Set by the
- * caller before av_bsf_init().
- */
- AVRational time_base_in;
-
- /**
- * The timebase used for the timestamps of the output packets. Set by the
- * filter in av_bsf_init().
- */
- AVRational time_base_out;
-} AVBSFContext;
-
-typedef struct AVBitStreamFilter {
- const char *name;
-
- /**
- * A list of codec ids supported by the filter, terminated by
- * AV_CODEC_ID_NONE.
- * May be NULL, in that case the bitstream filter works with any codec id.
- */
- const enum AVCodecID *codec_ids;
-
- /**
- * A class for the private data, used to declare bitstream filter private
- * AVOptions. This field is NULL for bitstream filters that do not declare
- * any options.
- *
- * If this field is non-NULL, the first member of the filter private data
- * must be a pointer to AVClass, which will be set by libavcodec generic
- * code to this class.
- */
- const AVClass *priv_class;
-
- /*****************************************************************
- * No fields below this line are part of the public API. They
- * may not be used outside of libavcodec and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
-
- int priv_data_size;
- int (*init)(AVBSFContext *ctx);
- int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
- void (*close)(AVBSFContext *ctx);
-} AVBitStreamFilter;
-
-#if FF_API_OLD_BSF
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use the new bitstream filtering API (using AVBSFContext).
- */
-attribute_deprecated
-void av_register_bitstream_filter(AVBitStreamFilter *bsf);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_get_by_name(), av_bsf_alloc(), and av_bsf_init()
- * from the new bitstream filtering API (using AVBSFContext).
- */
-attribute_deprecated
-AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_send_packet() and av_bsf_receive_packet() from the
- * new bitstream filtering API (using AVBSFContext).
- */
-attribute_deprecated
-int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
- AVCodecContext *avctx, const char *args,
- uint8_t **poutbuf, int *poutbuf_size,
- const uint8_t *buf, int buf_size, int keyframe);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_free() from the new bitstream filtering API (using
- * AVBSFContext).
- */
-attribute_deprecated
-void av_bitstream_filter_close(AVBitStreamFilterContext *bsf);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_iterate() from the new bitstream filtering API (using
- * AVBSFContext).
- */
-attribute_deprecated
-const AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f);
-#endif
-
-/**
- * @return a bitstream filter with the specified name or NULL if no such
- * bitstream filter exists.
- */
-const AVBitStreamFilter *av_bsf_get_by_name(const char *name);
-
-/**
- * Iterate over all registered bitstream filters.
- *
- * @param opaque a pointer where libavcodec will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered bitstream filter or NULL when the iteration is
- * finished
- */
-const AVBitStreamFilter *av_bsf_iterate(void **opaque);
-#if FF_API_NEXT
-attribute_deprecated
-const AVBitStreamFilter *av_bsf_next(void **opaque);
-#endif
-
-/**
- * Allocate a context for a given bitstream filter. The caller must fill in the
- * context parameters as described in the documentation and then call
- * av_bsf_init() before sending any data to the filter.
- *
- * @param filter the filter for which to allocate an instance.
- * @param ctx a pointer into which the pointer to the newly-allocated context
- * will be written. It must be freed with av_bsf_free() after the
- * filtering is done.
- *
- * @return 0 on success, a negative AVERROR code on failure
- */
-int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
-
-/**
- * Prepare the filter for use, after all the parameters and options have been
- * set.
- */
-int av_bsf_init(AVBSFContext *ctx);
-
-/**
- * Submit a packet for filtering.
- *
- * After sending each packet, the filter must be completely drained by calling
- * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
- * AVERROR_EOF.
- *
- * @param pkt the packet to filter. The bitstream filter will take ownership of
- * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
- * This parameter may be NULL, which signals the end of the stream (i.e. no more
- * packets will be sent). That will cause the filter to output any packets it
- * may have buffered internally.
- *
- * @return 0 on success, a negative AVERROR on error.
- */
-int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
-
-/**
- * Retrieve a filtered packet.
- *
- * @paramout pkt this struct will be filled with the contents of the filtered
- * packet. It is owned by the caller and must be freed using
- * av_packet_unref() when it is no longer needed.
- * This parameter should be "clean" (i.e. freshly allocated
- * with av_packet_alloc() or unreffed with av_packet_unref())
- * when this function is called. If this function returns
- * successfully, the contents of pkt will be completely
- * overwritten by the returned data. On failure, pkt is not
- * touched.
- *
- * @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the
- * filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there
- * will be no further output from the filter. Another negative AVERROR value if
- * an error occurs.
- *
- * @note one input packet may result in several output packets, so after sending
- * a packet with av_bsf_send_packet(), this function needs to be called
- * repeatedly until it stops returning 0. It is also possible for a filter to
- * output fewer packets than were sent to it, so this function may return
- * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
- */
-int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);
-
-/**
- * Free a bitstream filter context and everything associated with it; write NULL
- * into the supplied pointer.
- */
-void av_bsf_free(AVBSFContext **ctx);
-
-/**
- * Get the AVClass for AVBSFContext. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- */
-const AVClass *av_bsf_get_class(void);
-
-/**
- * Structure for chain/list of bitstream filters.
- * Empty list can be allocated by av_bsf_list_alloc().
- */
-typedef struct AVBSFList AVBSFList;
-
-/**
- * Allocate empty list of bitstream filters.
- * The list must be later freed by av_bsf_list_free()
- * or finalized by av_bsf_list_finalize().
- *
- * @return Pointer to @ref AVBSFList on success, NULL in case of failure
- */
-AVBSFList *av_bsf_list_alloc(void);
-
-/**
- * Free list of bitstream filters.
- *
- * @param lst Pointer to pointer returned by av_bsf_list_alloc()
- */
-void av_bsf_list_free(AVBSFList **lst);
-
-/**
- * Append bitstream filter to the list of bitstream filters.
- *
- * @param lst List to append to
- * @param bsf Filter context to be appended
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);
-
-/**
- * Construct new bitstream filter context given it's name and options
- * and append it to the list of bitstream filters.
- *
- * @param lst List to append to
- * @param bsf_name Name of the bitstream filter
- * @param options Options for the bitstream filter, can be set to NULL
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
-/**
- * Finalize list of bitstream filters.
- *
- * This function will transform @ref AVBSFList to single @ref AVBSFContext,
- * so the whole chain of bitstream filters can be treated as single filter
- * freshly allocated by av_bsf_alloc().
- * If the call is successful, @ref AVBSFList structure is freed and lst
- * will be set to NULL. In case of failure, caller is responsible for
- * freeing the structure by av_bsf_list_free()
- *
- * @param lst Filter list structure to be transformed
- * @paramout bsf Pointer to be set to newly created @ref AVBSFContext structure
- * representing the chain of bitstream filters
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);
-
-/**
- * Parse string describing list of bitstream filters and create single
- * @ref AVBSFContext describing the whole chain of bitstream filters.
- * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
- * allocated by av_bsf_alloc().
- *
- * @param str String describing chain of bitstream filters in format
- * `bsf1=opt1=val1:opt2=val2,bsf2`
- * @paramout bsf Pointer to be set to newly created @ref AVBSFContext structure
- * representing the chain of bitstream filters
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);
-
-/**
- * Get null/pass-through bitstream filter.
- *
- * @paramout bsf Pointer to be set to new instance of pass-through bitstream filter
- *
- * @return
- */
-int av_bsf_get_null_filter(AVBSFContext **bsf);
-
-/* memory */
-
-/**
- * Same behaviour av_fast_malloc but the buffer has additional
- * AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0.
- *
- * In addition the whole buffer will initially and after resizes
- * be 0-initialized so that no uninitialized data will ever appear.
- */
-void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);
-
-/**
- * Same behaviour av_fast_padded_malloc except that buffer will always
- * be 0-initialized after call.
- */
-void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size);
-
-/**
- * Encode extradata length to a buffer. Used by xiph codecs.
- *
- * @param s buffer to write to; must be at least (v/255+1) bytes long
- * @param v size of extradata in bytes
- * @return number of bytes written to the buffer.
- */
-unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
-
-#if FF_API_USER_VISIBLE_AVHWACCEL
-/**
- * Register the hardware accelerator hwaccel.
- *
- * @deprecated This function doesn't do anything.
- */
-attribute_deprecated
-void av_register_hwaccel(AVHWAccel *hwaccel);
-
-/**
- * If hwaccel is NULL, returns the first registered hardware accelerator,
- * if hwaccel is non-NULL, returns the next registered hardware accelerator
- * after hwaccel, or NULL if hwaccel is the last one.
- *
- * @deprecated AVHWaccel structures contain no user-serviceable parts, so
- * this function should not be used.
- */
-attribute_deprecated
-AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel);
-#endif
-
-#if FF_API_LOCKMGR
-/**
- * Lock operation used by lockmgr
- *
- * @deprecated Deprecated together with av_lockmgr_register().
- */
-enum AVLockOp {
- AV_LOCK_CREATE, ///< Create a mutex
- AV_LOCK_OBTAIN, ///< Lock the mutex
- AV_LOCK_RELEASE, ///< Unlock the mutex
- AV_LOCK_DESTROY, ///< Free mutex resources
-};
-
-/**
- * Register a user provided lock manager supporting the operations
- * specified by AVLockOp. The "mutex" argument to the function points
- * to a (void *) where the lockmgr should store/get a pointer to a user
- * allocated mutex. It is NULL upon AV_LOCK_CREATE and equal to the
- * value left by the last call for all other ops. If the lock manager is
- * unable to perform the op then it should leave the mutex in the same
- * state as when it was called and return a non-zero value. However,
- * when called with AV_LOCK_DESTROY the mutex will always be assumed to
- * have been successfully destroyed. If av_lockmgr_register succeeds
- * it will return a non-negative value, if it fails it will return a
- * negative value and destroy all mutex and unregister all callbacks.
- * av_lockmgr_register is not thread-safe, it must be called from a
- * single thread before any calls which make use of locking are used.
- *
- * @param cb User defined callback. av_lockmgr_register invokes calls
- * to this callback and the previously registered callback.
- * The callback will be used to create more than one mutex
- * each of which must be backed by its own underlying locking
- * mechanism (i.e. do not use a single static object to
- * implement your lock manager). If cb is set to NULL the
- * lockmgr will be unregistered.
- *
- * @deprecated This function does nothing, and always returns 0. Be sure to
- * build with thread support to get basic thread safety.
- */
-attribute_deprecated
-int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op));
-#endif
-
-/**
- * Get the type of the given codec.
- */
-enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
-
-/**
- * Get the name of a codec.
- * @return a static string identifying the codec; never NULL
- */
-const char *avcodec_get_name(enum AVCodecID id);
-
-/**
- * @return a positive value if s is open (i.e. avcodec_open2() was called on it
- * with no corresponding avcodec_close()), 0 otherwise.
- */
-int avcodec_is_open(AVCodecContext *s);
-
-/**
- * @return a non-zero number if codec is an encoder, zero otherwise
- */
-int av_codec_is_encoder(const AVCodec *codec);
-
-/**
- * @return a non-zero number if codec is a decoder, zero otherwise
- */
-int av_codec_is_decoder(const AVCodec *codec);
-
-/**
- * @return descriptor for given codec ID or NULL if no descriptor exists.
- */
-const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
-
-/**
- * Iterate over all codec descriptors known to libavcodec.
- *
- * @param prev previous descriptor. NULL to get the first descriptor.
- *
- * @return next descriptor or NULL after the last descriptor
- */
-const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
-
-/**
- * @return codec descriptor with the given name or NULL if no such descriptor
- * exists.
- */
-const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
-
-/**
- * Allocate a CPB properties structure and initialize its fields to default
- * values.
- *
- * @param size if non-NULL, the size of the allocated struct will be written
- * here. This is useful for embedding it in side data.
- *
- * @return the newly allocated struct or NULL on failure
- */
-AVCPBProperties *av_cpb_properties_alloc(size_t *size);
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_AVCODEC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/avdct.h Deleted

@@ -1,84 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_AVDCT_H
-#define AVCODEC_AVDCT_H
-
-#include "libavutil/opt.h"
-
-/**
- * AVDCT context.
- * @note function pointers can be NULL if the specific features have been
- * disabled at build time.
- */
-typedef struct AVDCT {
- const AVClass *av_class;
-
- void (*idct)(int16_t *block /* align 16 */);
-
- /**
- * IDCT input permutation.
- * Several optimized IDCTs need a permutated input (relative to the
- * normal order of the reference IDCT).
- * This permutation must be performed before the idct_put/add.
- * Note, normally this can be merged with the zigzag/alternate scan 
- * An example to avoid confusion:
- * - (->decode coeffs -> zigzag reorder -> dequant -> reference IDCT -> ...)
- * - (x -> reference DCT -> reference IDCT -> x)
- * - (x -> reference DCT -> simple_mmx_perm = idct_permutation
- * -> simple_idct_mmx -> x)
- * - (-> decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant
- * -> simple_idct_mmx -> ...)
- */
- uint8_t idct_permutation64;
-
- void (*fdct)(int16_t *block /* align 16 */);
-
-
- /**
- * DCT algorithm.
- * must use AVOptions to set this field.
- */
- int dct_algo;
-
- /**
- * IDCT algorithm.
- * must use AVOptions to set this field.
- */
- int idct_algo;
-
- void (*get_pixels)(int16_t *block /* align 16 */,
- const uint8_t *pixels /* align 8 */,
- ptrdiff_t line_size);
-
- int bits_per_sample;
-} AVDCT;
-
-/**
- * Allocates a AVDCT context.
- * This needs to be initialized with avcodec_dct_init() after optionally
- * configuring it with AVOptions.
- *
- * To free it use av_free()
- */
-AVDCT *avcodec_dct_alloc(void);
-int avcodec_dct_init(AVDCT *);
-
-const AVClass *avcodec_dct_get_class(void);
-
-#endif /* AVCODEC_AVDCT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/avfft.h Deleted

@@ -1,118 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_AVFFT_H
-#define AVCODEC_AVFFT_H
-
-/**
- * @file
- * @ingroup lavc_fft
- * FFT functions
- */
-
-/**
- * @defgroup lavc_fft FFT functions
- * @ingroup lavc_misc
- *
- * @{
- */
-
-typedef float FFTSample;
-
-typedef struct FFTComplex {
- FFTSample re, im;
-} FFTComplex;
-
-typedef struct FFTContext FFTContext;
-
-/**
- * Set up a complex FFT.
- * @param nbits log2 of the length of the input array
- * @param inverse if 0 perform the forward transform, if 1 perform the inverse
- */
-FFTContext *av_fft_init(int nbits, int inverse);
-
-/**
- * Do the permutation needed BEFORE calling ff_fft_calc().
- */
-void av_fft_permute(FFTContext *s, FFTComplex *z);
-
-/**
- * Do a complex FFT with the parameters defined in av_fft_init(). The
- * input data must be permuted before. No 1.0/sqrt(n) normalization is done.
- */
-void av_fft_calc(FFTContext *s, FFTComplex *z);
-
-void av_fft_end(FFTContext *s);
-
-FFTContext *av_mdct_init(int nbits, int inverse, double scale);
-void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input);
-void av_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input);
-void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input);
-void av_mdct_end(FFTContext *s);
-
-/* Real Discrete Fourier Transform */
-
-enum RDFTransformType {
- DFT_R2C,
- IDFT_C2R,
- IDFT_R2C,
- DFT_C2R,
-};
-
-typedef struct RDFTContext RDFTContext;
-
-/**
- * Set up a real FFT.
- * @param nbits log2 of the length of the input array
- * @param trans the type of transform
- */
-RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans);
-void av_rdft_calc(RDFTContext *s, FFTSample *data);
-void av_rdft_end(RDFTContext *s);
-
-/* Discrete Cosine Transform */
-
-typedef struct DCTContext DCTContext;
-
-enum DCTTransformType {
- DCT_II = 0,
- DCT_III,
- DCT_I,
- DST_I,
-};
-
-/**
- * Set up DCT.
- *
- * @param nbits size of the input array:
- * (1 << nbits) for DCT-II, DCT-III and DST-I
- * (1 << nbits) + 1 for DCT-I
- * @param type the type of transform
- *
- * @note the first element of the input of DST-I is ignored
- */
-DCTContext *av_dct_init(int nbits, enum DCTTransformType type);
-void av_dct_calc(DCTContext *s, FFTSample *data);
-void av_dct_end (DCTContext *s);
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_AVFFT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/d3d11va.h Deleted

@@ -1,112 +0,0 @@
-/*
- * Direct3D11 HW acceleration
- *
- * copyright (c) 2009 Laurent Aimar
- * copyright (c) 2015 Steve Lhomme
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_D3D11VA_H
-#define AVCODEC_D3D11VA_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_d3d11va
- * Public libavcodec D3D11VA header.
- */
-
-#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0602
-#endif
-
-#include <stdint.h>
-#include <d3d11.h>
-
-/**
- * @defgroup lavc_codec_hwaccel_d3d11va Direct3D11
- * @ingroup lavc_codec_hwaccel
- *
- * @{
- */
-
-#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for Direct3D11 and old UVD/UVD+ ATI video cards
-#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO 2 ///< Work around for Direct3D11 and old Intel GPUs with ClearVideo interface
-
-/**
- * This structure is used to provides the necessary configurations and data
- * to the Direct3D11 FFmpeg HWAccel implementation.
- *
- * The application must make it available as AVCodecContext.hwaccel_context.
- *
- * Use av_d3d11va_alloc_context() exclusively to allocate an AVD3D11VAContext.
- */
-typedef struct AVD3D11VAContext {
- /**
- * D3D11 decoder object
- */
- ID3D11VideoDecoder *decoder;
-
- /**
- * D3D11 VideoContext
- */
- ID3D11VideoContext *video_context;
-
- /**
- * D3D11 configuration used to create the decoder
- */
- D3D11_VIDEO_DECODER_CONFIG *cfg;
-
- /**
- * The number of surface in the surface array
- */
- unsigned surface_count;
-
- /**
- * The array of Direct3D surfaces used to create the decoder
- */
- ID3D11VideoDecoderOutputView **surface;
-
- /**
- * A bit field configuring the workarounds needed for using the decoder
- */
- uint64_t workaround;
-
- /**
- * Private to the FFmpeg AVHWAccel implementation
- */
- unsigned report_id;
-
- /**
- * Mutex to access video_context
- */
- HANDLE context_mutex;
-} AVD3D11VAContext;
-
-/**
- * Allocate an AVD3D11VAContext.
- *
- * @return Newly-allocated AVD3D11VAContext or NULL on failure.
- */
-AVD3D11VAContext *av_d3d11va_alloc_context(void);
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_D3D11VA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/dirac.h Deleted

@@ -1,131 +0,0 @@
-/*
- * Copyright (C) 2007 Marco Gerards <marco@gnu.org>
- * Copyright (C) 2009 David Conrad
- * Copyright (C) 2011 Jordi Ortiz
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_DIRAC_H
-#define AVCODEC_DIRAC_H
-
-/**
- * @file
- * Interface to Dirac Decoder/Encoder
- * @author Marco Gerards <marco@gnu.org>
- * @author David Conrad
- * @author Jordi Ortiz
- */
-
-#include "avcodec.h"
-
-/**
- * The spec limits the number of wavelet decompositions to 4 for both
- * level 1 (VC-2) and 128 (long-gop default).
- * 5 decompositions is the maximum before >16-bit buffers are needed.
- * Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting
- * the others to 4 decompositions (or 3 for the fidelity filter).
- *
- * We use this instead of MAX_DECOMPOSITIONS to save some memory.
- */
-#define MAX_DWT_LEVELS 5
-
-/**
- * Parse code values:
- *
- * Dirac Specification ->
- * 9.6.1 Table 9.1
- *
- * VC-2 Specification ->
- * 10.4.1 Table 10.1
- */
-
-enum DiracParseCodes {
- DIRAC_PCODE_SEQ_HEADER = 0x00,
- DIRAC_PCODE_END_SEQ = 0x10,
- DIRAC_PCODE_AUX = 0x20,
- DIRAC_PCODE_PAD = 0x30,
- DIRAC_PCODE_PICTURE_CODED = 0x08,
- DIRAC_PCODE_PICTURE_RAW = 0x48,
- DIRAC_PCODE_PICTURE_LOW_DEL = 0xC8,
- DIRAC_PCODE_PICTURE_HQ = 0xE8,
- DIRAC_PCODE_INTER_NOREF_CO1 = 0x0A,
- DIRAC_PCODE_INTER_NOREF_CO2 = 0x09,
- DIRAC_PCODE_INTER_REF_CO1 = 0x0D,
- DIRAC_PCODE_INTER_REF_CO2 = 0x0E,
- DIRAC_PCODE_INTRA_REF_CO = 0x0C,
- DIRAC_PCODE_INTRA_REF_RAW = 0x4C,
- DIRAC_PCODE_INTRA_REF_PICT = 0xCC,
- DIRAC_PCODE_MAGIC = 0x42424344,
-};
-
-typedef struct DiracVersionInfo {
- int major;
- int minor;
-} DiracVersionInfo;
-
-typedef struct AVDiracSeqHeader {
- unsigned width;
- unsigned height;
- uint8_t chroma_format; ///< 0: 444 1: 422 2: 420
-
- uint8_t interlaced;
- uint8_t top_field_first;
-
- uint8_t frame_rate_index; ///< index into dirac_frame_rate
- uint8_t aspect_ratio_index; ///< index into dirac_aspect_ratio
-
- uint16_t clean_width;
- uint16_t clean_height;
- uint16_t clean_left_offset;
- uint16_t clean_right_offset;
-
- uint8_t pixel_range_index; ///< index into dirac_pixel_range_presets
- uint8_t color_spec_index; ///< index into dirac_color_spec_presets
-
- int profile;
- int level;
-
- AVRational framerate;
- AVRational sample_aspect_ratio;
-
- enum AVPixelFormat pix_fmt;
- enum AVColorRange color_range;
- enum AVColorPrimaries color_primaries;
- enum AVColorTransferCharacteristic color_trc;
- enum AVColorSpace colorspace;
-
- DiracVersionInfo version;
- int bit_depth;
-} AVDiracSeqHeader;
-
-/**
- * Parse a Dirac sequence header.
- *
- * @param dsh this function will allocate and fill an AVDiracSeqHeader struct
- * and write it into this pointer. The caller must free it with
- * av_free().
- * @param buf the data buffer
- * @param buf_size the size of the data buffer in bytes
- * @param log_ctx if non-NULL, this function will log errors here
- * @return 0 on success, a negative AVERROR code on failure
- */
-int av_dirac_parse_sequence_header(AVDiracSeqHeader **dsh,
- const uint8_t *buf, size_t buf_size,
- void *log_ctx);
-
-#endif /* AVCODEC_DIRAC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/dv_profile.h Deleted

@@ -1,83 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_DV_PROFILE_H
-#define AVCODEC_DV_PROFILE_H
-
-#include <stdint.h>
-
-#include "libavutil/pixfmt.h"
-#include "libavutil/rational.h"
-#include "avcodec.h"
-
-/* minimum number of bytes to read from a DV stream in order to
- * determine the profile */
-#define DV_PROFILE_BYTES (6 * 80) /* 6 DIF blocks */
-
-
-/*
- * AVDVProfile is used to express the differences between various
- * DV flavors. For now it's primarily used for differentiating
- * 525/60 and 625/50, but the plans are to use it for various
- * DV specs as well (e.g. SMPTE314M vs. IEC 61834).
- */
-typedef struct AVDVProfile {
- int dsf; /* value of the dsf in the DV header */
- int video_stype; /* stype for VAUX source pack */
- int frame_size; /* total size of one frame in bytes */
- int difseg_size; /* number of DIF segments per DIF channel */
- int n_difchan; /* number of DIF channels per frame */
- AVRational time_base; /* 1/framerate */
- int ltc_divisor; /* FPS from the LTS standpoint */
- int height; /* picture height in pixels */
- int width; /* picture width in pixels */
- AVRational sar2; /* sample aspect ratios for 4:3 and 16:9 */
- enum AVPixelFormat pix_fmt; /* picture pixel format */
- int bpm; /* blocks per macroblock */
- const uint8_t *block_sizes; /* AC block sizes, in bits */
- int audio_stride; /* size of audio_shuffle table */
- int audio_min_samples3; /* min amount of audio samples */
- /* for 48kHz, 44.1kHz and 32kHz */
- int audio_samples_dist5; /* how many samples are supposed to be */
- /* in each frame in a 5 frames window */
- const uint8_t (*audio_shuffle)9; /* PCM shuffling table */
-} AVDVProfile;
-
-/**
- * Get a DV profile for the provided compressed frame.
- *
- * @param sys the profile used for the previous frame, may be NULL
- * @param frame the compressed data buffer
- * @param buf_size size of the buffer in bytes
- * @return the DV profile for the supplied data or NULL on failure
- */
-const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys,
- const uint8_t *frame, unsigned buf_size);
-
-/**
- * Get a DV profile for the provided stream parameters.
- */
-const AVDVProfile *av_dv_codec_profile(int width, int height, enum AVPixelFormat pix_fmt);
-
-/**
- * Get a DV profile for the provided stream parameters.
- * The frame rate is used as a best-effort parameter.
- */
-const AVDVProfile *av_dv_codec_profile2(int width, int height, enum AVPixelFormat pix_fmt, AVRational frame_rate);
-
-#endif /* AVCODEC_DV_PROFILE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/dxva2.h Deleted

@@ -1,93 +0,0 @@
-/*
- * DXVA2 HW acceleration
- *
- * copyright (c) 2009 Laurent Aimar
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_DXVA2_H
-#define AVCODEC_DXVA2_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_dxva2
- * Public libavcodec DXVA2 header.
- */
-
-#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0602
-#endif
-
-#include <stdint.h>
-#include <d3d9.h>
-#include <dxva2api.h>
-
-/**
- * @defgroup lavc_codec_hwaccel_dxva2 DXVA2
- * @ingroup lavc_codec_hwaccel
- *
- * @{
- */
-
-#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards
-#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO 2 ///< Work around for DXVA2 and old Intel GPUs with ClearVideo interface
-
-/**
- * This structure is used to provides the necessary configurations and data
- * to the DXVA2 FFmpeg HWAccel implementation.
- *
- * The application must make it available as AVCodecContext.hwaccel_context.
- */
-struct dxva_context {
- /**
- * DXVA2 decoder object
- */
- IDirectXVideoDecoder *decoder;
-
- /**
- * DXVA2 configuration used to create the decoder
- */
- const DXVA2_ConfigPictureDecode *cfg;
-
- /**
- * The number of surface in the surface array
- */
- unsigned surface_count;
-
- /**
- * The array of Direct3D surfaces used to create the decoder
- */
- LPDIRECT3DSURFACE9 *surface;
-
- /**
- * A bit field configuring the workarounds needed for using the decoder
- */
- uint64_t workaround;
-
- /**
- * Private to the FFmpeg AVHWAccel implementation
- */
- unsigned report_id;
-};
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_DXVA2_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/jni.h Deleted

@@ -1,46 +0,0 @@
-/*
- * JNI public API functions
- *
- * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_JNI_H
-#define AVCODEC_JNI_H
-
-/*
- * Manually set a Java virtual machine which will be used to retrieve the JNI
- * environment. Once a Java VM is set it cannot be changed afterwards, meaning
- * you can call multiple times av_jni_set_java_vm with the same Java VM pointer
- * however it will error out if you try to set a different Java VM.
- *
- * @param vm Java virtual machine
- * @param log_ctx context used for logging, can be NULL
- * @return 0 on success, < 0 otherwise
- */
-int av_jni_set_java_vm(void *vm, void *log_ctx);
-
-/*
- * Get the Java virtual machine which has been set with av_jni_set_java_vm.
- *
- * @param vm Java virtual machine
- * @return a pointer to the Java virtual machine
- */
-void *av_jni_get_java_vm(void *log_ctx);
-
-#endif /* AVCODEC_JNI_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/mediacodec.h Deleted

@@ -1,88 +0,0 @@
-/*
- * Android MediaCodec public API
- *
- * Copyright (c) 2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_MEDIACODEC_H
-#define AVCODEC_MEDIACODEC_H
-
-#include "libavcodec/avcodec.h"
-
-/**
- * This structure holds a reference to a android/view/Surface object that will
- * be used as output by the decoder.
- *
- */
-typedef struct AVMediaCodecContext {
-
- /**
- * android/view/Surface object reference.
- */
- void *surface;
-
-} AVMediaCodecContext;
-
-/**
- * Allocate and initialize a MediaCodec context.
- *
- * When decoding with MediaCodec is finished, the caller must free the
- * MediaCodec context with av_mediacodec_default_free.
- *
- * @return a pointer to a newly allocated AVMediaCodecContext on success, NULL otherwise
- */
-AVMediaCodecContext *av_mediacodec_alloc_context(void);
-
-/**
- * Convenience function that sets up the MediaCodec context.
- *
- * @param avctx codec context
- * @param ctx MediaCodec context to initialize
- * @param surface reference to an android/view/Surface
- * @return 0 on success, < 0 otherwise
- */
-int av_mediacodec_default_init(AVCodecContext *avctx, AVMediaCodecContext *ctx, void *surface);
-
-/**
- * This function must be called to free the MediaCodec context initialized with
- * av_mediacodec_default_init().
- *
- * @param avctx codec context
- */
-void av_mediacodec_default_free(AVCodecContext *avctx);
-
-/**
- * Opaque structure representing a MediaCodec buffer to render.
- */
-typedef struct MediaCodecBuffer AVMediaCodecBuffer;
-
-/**
- * Release a MediaCodec buffer and render it to the surface that is associated
- * with the decoder. This function should only be called once on a given
- * buffer, once released the underlying buffer returns to the codec, thus
- * subsequent calls to this function will have no effect.
- *
- * @param buffer the buffer to render
- * @param render 1 to release and render the buffer to the surface or 0 to
- * discard the buffer
- * @return 0 on success, < 0 otherwise
- */
-int av_mediacodec_release_buffer(AVMediaCodecBuffer *buffer, int render);
-
-#endif /* AVCODEC_MEDIACODEC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/qsv.h Deleted

@@ -1,107 +0,0 @@
-/*
- * Intel MediaSDK QSV public API
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_QSV_H
-#define AVCODEC_QSV_H
-
-#include <mfx/mfxvideo.h>
-
-#include "libavutil/buffer.h"
-
-/**
- * This struct is used for communicating QSV parameters between libavcodec and
- * the caller. It is managed by the caller and must be assigned to
- * AVCodecContext.hwaccel_context.
- * - decoding: hwaccel_context must be set on return from the get_format()
- * callback
- * - encoding: hwaccel_context must be set before avcodec_open2()
- */
-typedef struct AVQSVContext {
- /**
- * If non-NULL, the session to use for encoding or decoding.
- * Otherwise, libavcodec will try to create an internal session.
- */
- mfxSession session;
-
- /**
- * The IO pattern to use.
- */
- int iopattern;
-
- /**
- * Extra buffers to pass to encoder or decoder initialization.
- */
- mfxExtBuffer **ext_buffers;
- int nb_ext_buffers;
-
- /**
- * Encoding only. If this field is set to non-zero by the caller, libavcodec
- * will create an mfxExtOpaqueSurfaceAlloc extended buffer and pass it to
- * the encoder initialization. This only makes sense if iopattern is also
- * set to MFX_IOPATTERN_IN_OPAQUE_MEMORY.
- *
- * The number of allocated opaque surfaces will be the sum of the number
- * required by the encoder and the user-provided value nb_opaque_surfaces.
- * The array of the opaque surfaces will be exported to the caller through
- * the opaque_surfaces field.
- */
- int opaque_alloc;
-
- /**
- * Encoding only, and only if opaque_alloc is set to non-zero. Before
- * calling avcodec_open2(), the caller should set this field to the number
- * of extra opaque surfaces to allocate beyond what is required by the
- * encoder.
- *
- * On return from avcodec_open2(), this field will be set by libavcodec to
- * the total number of allocated opaque surfaces.
- */
- int nb_opaque_surfaces;
-
- /**
- * Encoding only, and only if opaque_alloc is set to non-zero. On return
- * from avcodec_open2(), this field will be used by libavcodec to export the
- * array of the allocated opaque surfaces to the caller, so they can be
- * passed to other parts of the pipeline.
- *
- * The buffer reference exported here is owned and managed by libavcodec,
- * the callers should make their own reference with av_buffer_ref() and free
- * it with av_buffer_unref() when it is no longer needed.
- *
- * The buffer data is an nb_opaque_surfaces-sized array of mfxFrameSurface1.
- */
- AVBufferRef *opaque_surfaces;
-
- /**
- * Encoding only, and only if opaque_alloc is set to non-zero. On return
- * from avcodec_open2(), this field will be set to the surface type used in
- * the opaque allocation request.
- */
- int opaque_alloc_type;
-} AVQSVContext;
-
-/**
- * Allocate a new context.
- *
- * It must be freed by the caller with av_free().
- */
-AVQSVContext *av_qsv_alloc_context(void);
-
-#endif /* AVCODEC_QSV_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/vaapi.h Deleted

@@ -1,86 +0,0 @@
-/*
- * Video Acceleration API (shared data between FFmpeg and the video player)
- * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
- *
- * Copyright (C) 2008-2009 Splitted-Desktop Systems
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VAAPI_H
-#define AVCODEC_VAAPI_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_vaapi
- * Public libavcodec VA API header.
- */
-
-#include <stdint.h>
-#include "libavutil/attributes.h"
-#include "version.h"
-
-#if FF_API_STRUCT_VAAPI_CONTEXT
-
-/**
- * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding
- * @ingroup lavc_codec_hwaccel
- * @{
- */
-
-/**
- * This structure is used to share data between the FFmpeg library and
- * the client video application.
- * This shall be zero-allocated and available as
- * AVCodecContext.hwaccel_context. All user members can be set once
- * during initialization or through each AVCodecContext.get_buffer()
- * function call. In any case, they must be valid prior to calling
- * decoding functions.
- *
- * Deprecated: use AVCodecContext.hw_frames_ctx instead.
- */
-struct attribute_deprecated vaapi_context {
- /**
- * Window system dependent data
- *
- * - encoding: unused
- * - decoding: Set by user
- */
- void *display;
-
- /**
- * Configuration ID
- *
- * - encoding: unused
- * - decoding: Set by user
- */
- uint32_t config_id;
-
- /**
- * Context ID (video decode pipeline)
- *
- * - encoding: unused
- * - decoding: Set by user
- */
- uint32_t context_id;
-};
-
-/* @} */
-
-#endif /* FF_API_STRUCT_VAAPI_CONTEXT */
-
-#endif /* AVCODEC_VAAPI_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/vdpau.h Deleted

@@ -1,176 +0,0 @@
-/*
- * The Video Decode and Presentation API for UNIX (VDPAU) is used for
- * hardware-accelerated decoding of MPEG-1/2, H.264 and VC-1.
- *
- * Copyright (C) 2008 NVIDIA
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VDPAU_H
-#define AVCODEC_VDPAU_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_vdpau
- * Public libavcodec VDPAU header.
- */
-
-
-/**
- * @defgroup lavc_codec_hwaccel_vdpau VDPAU Decoder and Renderer
- * @ingroup lavc_codec_hwaccel
- *
- * VDPAU hardware acceleration has two modules
- * - VDPAU decoding
- * - VDPAU presentation
- *
- * The VDPAU decoding module parses all headers using FFmpeg
- * parsing mechanisms and uses VDPAU for the actual decoding.
- *
- * As per the current implementation, the actual decoding
- * and rendering (API calls) are done as part of the VDPAU
- * presentation (vo_vdpau.c) module.
- *
- * @{
- */
-
-#include <vdpau/vdpau.h>
-
-#include "libavutil/avconfig.h"
-#include "libavutil/attributes.h"
-
-#include "avcodec.h"
-#include "version.h"
-
-struct AVCodecContext;
-struct AVFrame;
-
-typedef int (*AVVDPAU_Render2)(struct AVCodecContext *, struct AVFrame *,
- const VdpPictureInfo *, uint32_t,
- const VdpBitstreamBuffer *);
-
-/**
- * This structure is used to share data between the libavcodec library and
- * the client video application.
- * The user shall allocate the structure via the av_alloc_vdpau_hwaccel
- * function and make it available as
- * AVCodecContext.hwaccel_context. Members can be set by the user once
- * during initialization or through each AVCodecContext.get_buffer()
- * function call. In any case, they must be valid prior to calling
- * decoding functions.
- *
- * The size of this structure is not a part of the public ABI and must not
- * be used outside of libavcodec. Use av_vdpau_alloc_context() to allocate an
- * AVVDPAUContext.
- */
-typedef struct AVVDPAUContext {
- /**
- * VDPAU decoder handle
- *
- * Set by user.
- */
- VdpDecoder decoder;
-
- /**
- * VDPAU decoder render callback
- *
- * Set by the user.
- */
- VdpDecoderRender *render;
-
- AVVDPAU_Render2 render2;
-} AVVDPAUContext;
-
-/**
- * @brief allocation function for AVVDPAUContext
- *
- * Allows extending the struct without breaking API/ABI
- */
-AVVDPAUContext *av_alloc_vdpaucontext(void);
-
-AVVDPAU_Render2 av_vdpau_hwaccel_get_render2(const AVVDPAUContext *);
-void av_vdpau_hwaccel_set_render2(AVVDPAUContext *, AVVDPAU_Render2);
-
-/**
- * Associate a VDPAU device with a codec context for hardware acceleration.
- * This function is meant to be called from the get_format() codec callback,
- * or earlier. It can also be called after avcodec_flush_buffers() to change
- * the underlying VDPAU device mid-stream (e.g. to recover from non-transparent
- * display preemption).
- *
- * @note get_format() must return AV_PIX_FMT_VDPAU if this function completes
- * successfully.
- *
- * @param avctx decoding context whose get_format() callback is invoked
- * @param device VDPAU device handle to use for hardware acceleration
- * @param get_proc_address VDPAU device driver
- * @param flags zero of more OR'd AV_HWACCEL_FLAG_* flags
- *
- * @return 0 on success, an AVERROR code on failure.
- */
-int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device,
- VdpGetProcAddress *get_proc_address, unsigned flags);
-
-/**
- * Gets the parameters to create an adequate VDPAU video surface for the codec
- * context using VDPAU hardware decoding acceleration.
- *
- * @note Behavior is undefined if the context was not successfully bound to a
- * VDPAU device using av_vdpau_bind_context().
- *
- * @param avctx the codec context being used for decoding the stream
- * @param type storage space for the VDPAU video surface chroma type
- * (or NULL to ignore)
- * @param width storage space for the VDPAU video surface pixel width
- * (or NULL to ignore)
- * @param height storage space for the VDPAU video surface pixel height
- * (or NULL to ignore)
- *
- * @return 0 on success, a negative AVERROR code on failure.
- */
-int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type,
- uint32_t *width, uint32_t *height);
-
-/**
- * Allocate an AVVDPAUContext.
- *
- * @return Newly-allocated AVVDPAUContext or NULL on failure.
- */
-AVVDPAUContext *av_vdpau_alloc_context(void);
-
-#if FF_API_VDPAU_PROFILE
-/**
- * Get a decoder profile that should be used for initializing a VDPAU decoder.
- * Should be called from the AVCodecContext.get_format() callback.
- *
- * @deprecated Use av_vdpau_bind_context() instead.
- *
- * @param avctx the codec context being used for decoding the stream
- * @param profile a pointer into which the result will be written on success.
- * The contents of profile are undefined if this function returns
- * an error.
- *
- * @return 0 on success (non-negative), a negative AVERROR on failure.
- */
-attribute_deprecated
-int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile);
-#endif
-
-/* @}*/
-
-#endif /* AVCODEC_VDPAU_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/version.h Deleted

@@ -1,137 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VERSION_H
-#define AVCODEC_VERSION_H
-
-/**
- * @file
- * @ingroup libavc
- * Libavcodec version macros.
- */
-
-#include "libavutil/version.h"
-
-#define LIBAVCODEC_VERSION_MAJOR 58
-#define LIBAVCODEC_VERSION_MINOR 18
-#define LIBAVCODEC_VERSION_MICRO 100
-
-#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
- LIBAVCODEC_VERSION_MINOR, \
- LIBAVCODEC_VERSION_MICRO)
-#define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \
- LIBAVCODEC_VERSION_MINOR, \
- LIBAVCODEC_VERSION_MICRO)
-#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT
-
-#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- *
- * @note, when bumping the major version it is recommended to manually
- * disable each FF_API_* in its own commit instead of disabling them all
- * at once through the bump. This improves the git bisect-ability of the change.
- */
-
-#ifndef FF_API_LOWRES
-#define FF_API_LOWRES (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_DEBUG_MV
-#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 58)
-#endif
-#ifndef FF_API_AVCTX_TIMEBASE
-#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CODED_FRAME
-#define FF_API_CODED_FRAME (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_SIDEDATA_ONLY_PKT
-#define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_VDPAU_PROFILE
-#define FF_API_VDPAU_PROFILE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CONVERGENCE_DURATION
-#define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_AVPICTURE
-#define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_AVPACKET_OLD_API
-#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_RTP_CALLBACK
-#define FF_API_RTP_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_VBV_DELAY
-#define FF_API_VBV_DELAY (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CODER_TYPE
-#define FF_API_CODER_TYPE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_STAT_BITS
-#define FF_API_STAT_BITS (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_PRIVATE_OPT
-#define FF_API_PRIVATE_OPT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_ASS_TIMING
-#define FF_API_ASS_TIMING (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_BSF
-#define FF_API_OLD_BSF (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_COPY_CONTEXT
-#define FF_API_COPY_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_GET_CONTEXT_DEFAULTS
-#define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_NVENC_OLD_NAME
-#define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_STRUCT_VAAPI_CONTEXT
-#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_MERGE_SD_API
-#define FF_API_MERGE_SD_API (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_TAG_STRING
-#define FF_API_TAG_STRING (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_GETCHROMA
-#define FF_API_GETCHROMA (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CODEC_GET_SET
-#define FF_API_CODEC_GET_SET (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_USER_VISIBLE_AVHWACCEL
-#define FF_API_USER_VISIBLE_AVHWACCEL (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LOCKMGR
-#define FF_API_LOCKMGR (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_NEXT
-#define FF_API_NEXT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-
-
-#endif /* AVCODEC_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/videotoolbox.h Deleted

@@ -1,127 +0,0 @@
-/*
- * Videotoolbox hardware acceleration
- *
- * copyright (c) 2012 Sebastien Zwickert
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VIDEOTOOLBOX_H
-#define AVCODEC_VIDEOTOOLBOX_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_videotoolbox
- * Public libavcodec Videotoolbox header.
- */
-
-#include <stdint.h>
-
-#define Picture QuickdrawPicture
-#include <VideoToolbox/VideoToolbox.h>
-#undef Picture
-
-#include "libavcodec/avcodec.h"
-
-/**
- * This struct holds all the information that needs to be passed
- * between the caller and libavcodec for initializing Videotoolbox decoding.
- * Its size is not a part of the public ABI, it must be allocated with
- * av_videotoolbox_alloc_context() and freed with av_free().
- */
-typedef struct AVVideotoolboxContext {
- /**
- * Videotoolbox decompression session object.
- * Created and freed the caller.
- */
- VTDecompressionSessionRef session;
-
- /**
- * The output callback that must be passed to the session.
- * Set by av_videottoolbox_default_init()
- */
- VTDecompressionOutputCallback output_callback;
-
- /**
- * CVPixelBuffer Format Type that Videotoolbox will use for decoded frames.
- * set by the caller. If this is set to 0, then no specific format is
- * requested from the decoder, and its native format is output.
- */
- OSType cv_pix_fmt_type;
-
- /**
- * CoreMedia Format Description that Videotoolbox will use to create the decompression session.
- * Set by the caller.
- */
- CMVideoFormatDescriptionRef cm_fmt_desc;
-
- /**
- * CoreMedia codec type that Videotoolbox will use to create the decompression session.
- * Set by the caller.
- */
- int cm_codec_type;
-} AVVideotoolboxContext;
-
-/**
- * Allocate and initialize a Videotoolbox context.
- *
- * This function should be called from the get_format() callback when the caller
- * selects the AV_PIX_FMT_VIDETOOLBOX format. The caller must then create
- * the decoder object (using the output callback provided by libavcodec) that
- * will be used for Videotoolbox-accelerated decoding.
- *
- * When decoding with Videotoolbox is finished, the caller must destroy the decoder
- * object and free the Videotoolbox context using av_free().
- *
- * @return the newly allocated context or NULL on failure
- */
-AVVideotoolboxContext *av_videotoolbox_alloc_context(void);
-
-/**
- * This is a convenience function that creates and sets up the Videotoolbox context using
- * an internal implementation.
- *
- * @param avctx the corresponding codec context
- *
- * @return >= 0 on success, a negative AVERROR code on failure
- */
-int av_videotoolbox_default_init(AVCodecContext *avctx);
-
-/**
- * This is a convenience function that creates and sets up the Videotoolbox context using
- * an internal implementation.
- *
- * @param avctx the corresponding codec context
- * @param vtctx the Videotoolbox context to use
- *
- * @return >= 0 on success, a negative AVERROR code on failure
- */
-int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *vtctx);
-
-/**
- * This function must be called to free the Videotoolbox context initialized with
- * av_videotoolbox_default_init().
- *
- * @param avctx the corresponding codec context
- */
-void av_videotoolbox_default_free(AVCodecContext *avctx);
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_VIDEOTOOLBOX_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/vorbis_parser.h Deleted

@@ -1,74 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * A public API for Vorbis parsing
- *
- * Determines the duration for each packet.
- */
-
-#ifndef AVCODEC_VORBIS_PARSER_H
-#define AVCODEC_VORBIS_PARSER_H
-
-#include <stdint.h>
-
-typedef struct AVVorbisParseContext AVVorbisParseContext;
-
-/**
- * Allocate and initialize the Vorbis parser using headers in the extradata.
- */
-AVVorbisParseContext *av_vorbis_parse_init(const uint8_t *extradata,
- int extradata_size);
-
-/**
- * Free the parser and everything associated with it.
- */
-void av_vorbis_parse_free(AVVorbisParseContext **s);
-
-#define VORBIS_FLAG_HEADER 0x00000001
-#define VORBIS_FLAG_COMMENT 0x00000002
-#define VORBIS_FLAG_SETUP 0x00000004
-
-/**
- * Get the duration for a Vorbis packet.
- *
- * If @p flags is @c NULL,
- * special frames are considered invalid.
- *
- * @param s Vorbis parser context
- * @param buf buffer containing a Vorbis frame
- * @param buf_size size of the buffer
- * @param flags flags for special frames
- */
-int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf,
- int buf_size, int *flags);
-
-/**
- * Get the duration for a Vorbis packet.
- *
- * @param s Vorbis parser context
- * @param buf buffer containing a Vorbis frame
- * @param buf_size size of the buffer
- */
-int av_vorbis_parse_frame(AVVorbisParseContext *s, const uint8_t *buf,
- int buf_size);
-
-void av_vorbis_parse_reset(AVVorbisParseContext *s);
-
-#endif /* AVCODEC_VORBIS_PARSER_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavcodec/xvmc.h Deleted

@@ -1,170 +0,0 @@
-/*
- * Copyright (C) 2003 Ivan Kalvachev
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_XVMC_H
-#define AVCODEC_XVMC_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_xvmc
- * Public libavcodec XvMC header.
- */
-
-#include <X11/extensions/XvMC.h>
-
-#include "libavutil/attributes.h"
-#include "version.h"
-#include "avcodec.h"
-
-/**
- * @defgroup lavc_codec_hwaccel_xvmc XvMC
- * @ingroup lavc_codec_hwaccel
- *
- * @{
- */
-
-#define AV_XVMC_ID 0x1DC711C0 /**< special value to ensure that regular pixel routines haven't corrupted the struct
- the number is 1337 speak for the letters IDCT MCo (motion compensation) */
-
-struct attribute_deprecated xvmc_pix_fmt {
- /** The field contains the special constant value AV_XVMC_ID.
- It is used as a test that the application correctly uses the API,
- and that there is no corruption caused by pixel routines.
- - application - set during initialization
- - libavcodec - unchanged
- */
- int xvmc_id;
-
- /** Pointer to the block array allocated by XvMCCreateBlocks().
- The array has to be freed by XvMCDestroyBlocks().
- Each group of 64 values represents one data block of differential
- pixel information (in MoCo mode) or coefficients for IDCT.
- - application - set the pointer during initialization
- - libavcodec - fills coefficients/pixel data into the array
- */
- short* data_blocks;
-
- /** Pointer to the macroblock description array allocated by
- XvMCCreateMacroBlocks() and freed by XvMCDestroyMacroBlocks().
- - application - set the pointer during initialization
- - libavcodec - fills description data into the array
- */
- XvMCMacroBlock* mv_blocks;
-
- /** Number of macroblock descriptions that can be stored in the mv_blocks
- array.
- - application - set during initialization
- - libavcodec - unchanged
- */
- int allocated_mv_blocks;
-
- /** Number of blocks that can be stored at once in the data_blocks array.
- - application - set during initialization
- - libavcodec - unchanged
- */
- int allocated_data_blocks;
-
- /** Indicate that the hardware would interpret data_blocks as IDCT
- coefficients and perform IDCT on them.
- - application - set during initialization
- - libavcodec - unchanged
- */
- int idct;
-
- /** In MoCo mode it indicates that intra macroblocks are assumed to be in
- unsigned format; same as the XVMC_INTRA_UNSIGNED flag.
- - application - set during initialization
- - libavcodec - unchanged
- */
- int unsigned_intra;
-
- /** Pointer to the surface allocated by XvMCCreateSurface().
- It has to be freed by XvMCDestroySurface() on application exit.
- It identifies the frame and its state on the video hardware.
- - application - set during initialization
- - libavcodec - unchanged
- */
- XvMCSurface* p_surface;
-
-/** Set by the decoder before calling ff_draw_horiz_band(),
- needed by the XvMCRenderSurface function. */
-//@{
- /** Pointer to the surface used as past reference
- - application - unchanged
- - libavcodec - set
- */
- XvMCSurface* p_past_surface;
-
- /** Pointer to the surface used as future reference
- - application - unchanged
- - libavcodec - set
- */
- XvMCSurface* p_future_surface;
-
- /** top/bottom field or frame
- - application - unchanged
- - libavcodec - set
- */
- unsigned int picture_structure;
-
- /** XVMC_SECOND_FIELD - 1st or 2nd field in the sequence
- - application - unchanged
- - libavcodec - set
- */
- unsigned int flags;
-//}@
-
- /** Number of macroblock descriptions in the mv_blocks array
- that have already been passed to the hardware.
- - application - zeroes it on get_buffer().
- A successful ff_draw_horiz_band() may increment it
- with filled_mb_block_num or zero both.
- - libavcodec - unchanged
- */
- int start_mv_blocks_num;
-
- /** Number of new macroblock descriptions in the mv_blocks array (after
- start_mv_blocks_num) that are filled by libavcodec and have to be
- passed to the hardware.
- - application - zeroes it on get_buffer() or after successful
- ff_draw_horiz_band().
- - libavcodec - increment with one of each stored MB
- */
- int filled_mv_blocks_num;
-
- /** Number of the next free data block; one data block consists of
- 64 short values in the data_blocks array.
- All blocks before this one have already been claimed by placing their
- position into the corresponding block description structure field,
- that are part of the mv_blocks array.
- - application - zeroes it on get_buffer().
- A successful ff_draw_horiz_band() may zero it together
- with start_mb_blocks_num.
- - libavcodec - each decoded macroblock increases it by the number
- of coded blocks it contains.
- */
- int next_free_data_block_num;
-};
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_XVMC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavdevice Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavdevice/avdevice.h Deleted

@@ -1,514 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVDEVICE_AVDEVICE_H
-#define AVDEVICE_AVDEVICE_H
-
-#include "version.h"
-
-/**
- * @file
- * @ingroup lavd
- * Main libavdevice API header
- */
-
-/**
- * @defgroup lavd libavdevice
- * Special devices muxing/demuxing library.
- *
- * Libavdevice is a complementary library to @ref libavf "libavformat". It
- * provides various "special" platform-specific muxers and demuxers, e.g. for
- * grabbing devices, audio capture and playback etc. As a consequence, the
- * (de)muxers in libavdevice are of the AVFMT_NOFILE type (they use their own
- * I/O functions). The filename passed to avformat_open_input() often does not
- * refer to an actually existing file, but has some special device-specific
- * meaning - e.g. for xcbgrab it is the display name.
- *
- * To use libavdevice, simply call avdevice_register_all() to register all
- * compiled muxers and demuxers. They all use standard libavformat API.
- *
- * @{
- */
-
-#include "libavutil/log.h"
-#include "libavutil/opt.h"
-#include "libavutil/dict.h"
-#include "libavformat/avformat.h"
-
-/**
- * Return the LIBAVDEVICE_VERSION_INT constant.
- */
-unsigned avdevice_version(void);
-
-/**
- * Return the libavdevice build-time configuration.
- */
-const char *avdevice_configuration(void);
-
-/**
- * Return the libavdevice license.
- */
-const char *avdevice_license(void);
-
-/**
- * Initialize libavdevice and register all the input and output devices.
- */
-void avdevice_register_all(void);
-
-/**
- * Audio input devices iterator.
- *
- * If d is NULL, returns the first registered input audio/video device,
- * if d is non-NULL, returns the next registered input audio/video device after d
- * or NULL if d is the last one.
- */
-AVInputFormat *av_input_audio_device_next(AVInputFormat *d);
-
-/**
- * Video input devices iterator.
- *
- * If d is NULL, returns the first registered input audio/video device,
- * if d is non-NULL, returns the next registered input audio/video device after d
- * or NULL if d is the last one.
- */
-AVInputFormat *av_input_video_device_next(AVInputFormat *d);
-
-/**
- * Audio output devices iterator.
- *
- * If d is NULL, returns the first registered output audio/video device,
- * if d is non-NULL, returns the next registered output audio/video device after d
- * or NULL if d is the last one.
- */
-AVOutputFormat *av_output_audio_device_next(AVOutputFormat *d);
-
-/**
- * Video output devices iterator.
- *
- * If d is NULL, returns the first registered output audio/video device,
- * if d is non-NULL, returns the next registered output audio/video device after d
- * or NULL if d is the last one.
- */
-AVOutputFormat *av_output_video_device_next(AVOutputFormat *d);
-
-typedef struct AVDeviceRect {
- int x; /**< x coordinate of top left corner */
- int y; /**< y coordinate of top left corner */
- int width; /**< width */
- int height; /**< height */
-} AVDeviceRect;
-
-/**
- * Message types used by avdevice_app_to_dev_control_message().
- */
-enum AVAppToDevMessageType {
- /**
- * Dummy message.
- */
- AV_APP_TO_DEV_NONE = MKBETAG('N','O','N','E'),
-
- /**
- * Window size change message.
- *
- * Message is sent to the device every time the application changes the size
- * of the window device renders to.
- * Message should also be sent right after window is created.
- *
- * data: AVDeviceRect: new window size.
- */
- AV_APP_TO_DEV_WINDOW_SIZE = MKBETAG('G','E','O','M'),
-
- /**
- * Repaint request message.
- *
- * Message is sent to the device when window has to be repainted.
- *
- * data: AVDeviceRect: area required to be repainted.
- * NULL: whole area is required to be repainted.
- */
- AV_APP_TO_DEV_WINDOW_REPAINT = MKBETAG('R','E','P','A'),
-
- /**
- * Request pause/play.
- *
- * Application requests pause/unpause playback.
- * Mostly usable with devices that have internal buffer.
- * By default devices are not paused.
- *
- * data: NULL
- */
- AV_APP_TO_DEV_PAUSE = MKBETAG('P', 'A', 'U', ' '),
- AV_APP_TO_DEV_PLAY = MKBETAG('P', 'L', 'A', 'Y'),
- AV_APP_TO_DEV_TOGGLE_PAUSE = MKBETAG('P', 'A', 'U', 'T'),
-
- /**
- * Volume control message.
- *
- * Set volume level. It may be device-dependent if volume
- * is changed per stream or system wide. Per stream volume
- * change is expected when possible.
- *
- * data: double: new volume with range of 0.0 - 1.0.
- */
- AV_APP_TO_DEV_SET_VOLUME = MKBETAG('S', 'V', 'O', 'L'),
-
- /**
- * Mute control messages.
- *
- * Change mute state. It may be device-dependent if mute status
- * is changed per stream or system wide. Per stream mute status
- * change is expected when possible.
- *
- * data: NULL.
- */
- AV_APP_TO_DEV_MUTE = MKBETAG(' ', 'M', 'U', 'T'),
- AV_APP_TO_DEV_UNMUTE = MKBETAG('U', 'M', 'U', 'T'),
- AV_APP_TO_DEV_TOGGLE_MUTE = MKBETAG('T', 'M', 'U', 'T'),
-
- /**
- * Get volume/mute messages.
- *
- * Force the device to send AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED or
- * AV_DEV_TO_APP_MUTE_STATE_CHANGED command respectively.
- *
- * data: NULL.
- */
- AV_APP_TO_DEV_GET_VOLUME = MKBETAG('G', 'V', 'O', 'L'),
- AV_APP_TO_DEV_GET_MUTE = MKBETAG('G', 'M', 'U', 'T'),
-};
-
-/**
- * Message types used by avdevice_dev_to_app_control_message().
- */
-enum AVDevToAppMessageType {
- /**
- * Dummy message.
- */
- AV_DEV_TO_APP_NONE = MKBETAG('N','O','N','E'),
-
- /**
- * Create window buffer message.
- *
- * Device requests to create a window buffer. Exact meaning is device-
- * and application-dependent. Message is sent before rendering first
- * frame and all one-shot initializations should be done here.
- * Application is allowed to ignore preferred window buffer size.
- *
- * @note: Application is obligated to inform about window buffer size
- * with AV_APP_TO_DEV_WINDOW_SIZE message.
- *
- * data: AVDeviceRect: preferred size of the window buffer.
- * NULL: no preferred size of the window buffer.
- */
- AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = MKBETAG('B','C','R','E'),
-
- /**
- * Prepare window buffer message.
- *
- * Device requests to prepare a window buffer for rendering.
- * Exact meaning is device- and application-dependent.
- * Message is sent before rendering of each frame.
- *
- * data: NULL.
- */
- AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = MKBETAG('B','P','R','E'),
-
- /**
- * Display window buffer message.
- *
- * Device requests to display a window buffer.
- * Message is sent when new frame is ready to be displayed.
- * Usually buffers need to be swapped in handler of this message.
- *
- * data: NULL.
- */
- AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = MKBETAG('B','D','I','S'),
-
- /**
- * Destroy window buffer message.
- *
- * Device requests to destroy a window buffer.
- * Message is sent when device is about to be destroyed and window
- * buffer is not required anymore.
- *
- * data: NULL.
- */
- AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = MKBETAG('B','D','E','S'),
-
- /**
- * Buffer fullness status messages.
- *
- * Device signals buffer overflow/underflow.
- *
- * data: NULL.
- */
- AV_DEV_TO_APP_BUFFER_OVERFLOW = MKBETAG('B','O','F','L'),
- AV_DEV_TO_APP_BUFFER_UNDERFLOW = MKBETAG('B','U','F','L'),
-
- /**
- * Buffer readable/writable.
- *
- * Device informs that buffer is readable/writable.
- * When possible, device informs how many bytes can be read/write.
- *
- * @warning Device may not inform when number of bytes than can be read/write changes.
- *
- * data: int64_t: amount of bytes available to read/write.
- * NULL: amount of bytes available to read/write is not known.
- */
- AV_DEV_TO_APP_BUFFER_READABLE = MKBETAG('B','R','D',' '),
- AV_DEV_TO_APP_BUFFER_WRITABLE = MKBETAG('B','W','R',' '),
-
- /**
- * Mute state change message.
- *
- * Device informs that mute state has changed.
- *
- * data: int: 0 for not muted state, non-zero for muted state.
- */
- AV_DEV_TO_APP_MUTE_STATE_CHANGED = MKBETAG('C','M','U','T'),
-
- /**
- * Volume level change message.
- *
- * Device informs that volume level has changed.
- *
- * data: double: new volume with range of 0.0 - 1.0.
- */
- AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = MKBETAG('C','V','O','L'),
-};
-
-/**
- * Send control message from application to device.
- *
- * @param s device context.
- * @param type message type.
- * @param data message data. Exact type depends on message type.
- * @param data_size size of message data.
- * @return >= 0 on success, negative on error.
- * AVERROR(ENOSYS) when device doesn't implement handler of the message.
- */
-int avdevice_app_to_dev_control_message(struct AVFormatContext *s,
- enum AVAppToDevMessageType type,
- void *data, size_t data_size);
-
-/**
- * Send control message from device to application.
- *
- * @param s device context.
- * @param type message type.
- * @param data message data. Can be NULL.
- * @param data_size size of message data.
- * @return >= 0 on success, negative on error.
- * AVERROR(ENOSYS) when application doesn't implement handler of the message.
- */
-int avdevice_dev_to_app_control_message(struct AVFormatContext *s,
- enum AVDevToAppMessageType type,
- void *data, size_t data_size);
-
-/**
- * Following API allows user to probe device capabilities (supported codecs,
- * pixel formats, sample formats, resolutions, channel counts, etc).
- * It is build on top op AVOption API.
- * Queried capabilities make it possible to set up converters of video or audio
- * parameters that fit to the device.
- *
- * List of capabilities that can be queried:
- * - Capabilities valid for both audio and video devices:
- * - codec: supported audio/video codecs.
- * type: AV_OPT_TYPE_INT (AVCodecID value)
- * - Capabilities valid for audio devices:
- * - sample_format: supported sample formats.
- * type: AV_OPT_TYPE_INT (AVSampleFormat value)
- * - sample_rate: supported sample rates.
- * type: AV_OPT_TYPE_INT
- * - channels: supported number of channels.
- * type: AV_OPT_TYPE_INT
- * - channel_layout: supported channel layouts.
- * type: AV_OPT_TYPE_INT64
- * - Capabilities valid for video devices:
- * - pixel_format: supported pixel formats.
- * type: AV_OPT_TYPE_INT (AVPixelFormat value)
- * - window_size: supported window sizes (describes size of the window size presented to the user).
- * type: AV_OPT_TYPE_IMAGE_SIZE
- * - frame_size: supported frame sizes (describes size of provided video frames).
- * type: AV_OPT_TYPE_IMAGE_SIZE
- * - fps: supported fps values
- * type: AV_OPT_TYPE_RATIONAL
- *
- * Value of the capability may be set by user using av_opt_set() function
- * and AVDeviceCapabilitiesQuery object. Following queries will
- * limit results to the values matching already set capabilities.
- * For example, setting a codec may impact number of formats or fps values
- * returned during next query. Setting invalid value may limit results to zero.
- *
- * Example of the usage basing on opengl output device:
- *
- * @code
- * AVFormatContext *oc = NULL;
- * AVDeviceCapabilitiesQuery *caps = NULL;
- * AVOptionRanges *ranges;
- * int ret;
- *
- * if ((ret = avformat_alloc_output_context2(&oc, NULL, "opengl", NULL)) < 0)
- * goto fail;
- * if (avdevice_capabilities_create(&caps, oc, NULL) < 0)
- * goto fail;
- *
- * //query codecs
- * if (av_opt_query_ranges(&ranges, caps, "codec", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
- * goto fail;
- * //pick codec here and set it
- * av_opt_set(caps, "codec", AV_CODEC_ID_RAWVIDEO, 0);
- *
- * //query format
- * if (av_opt_query_ranges(&ranges, caps, "pixel_format", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
- * goto fail;
- * //pick format here and set it
- * av_opt_set(caps, "pixel_format", AV_PIX_FMT_YUV420P, 0);
- *
- * //query and set more capabilities
- *
- * fail:
- * //clean up code
- * avdevice_capabilities_free(&query, oc);
- * avformat_free_context(oc);
- * @endcode
- */
-
-/**
- * Structure describes device capabilities.
- *
- * It is used by devices in conjunction with av_device_capabilities AVOption table
- * to implement capabilities probing API based on AVOption API. Should not be used directly.
- */
-typedef struct AVDeviceCapabilitiesQuery {
- const AVClass *av_class;
- AVFormatContext *device_context;
- enum AVCodecID codec;
- enum AVSampleFormat sample_format;
- enum AVPixelFormat pixel_format;
- int sample_rate;
- int channels;
- int64_t channel_layout;
- int window_width;
- int window_height;
- int frame_width;
- int frame_height;
- AVRational fps;
-} AVDeviceCapabilitiesQuery;
-
-/**
- * AVOption table used by devices to implement device capabilities API. Should not be used by a user.
- */
-extern const AVOption av_device_capabilities;
-
-/**
- * Initialize capabilities probing API based on AVOption API.
- *
- * avdevice_capabilities_free() must be called when query capabilities API is
- * not used anymore.
- *
- * @paramout caps Device capabilities data. Pointer to a NULL pointer must be passed.
- * @param s Context of the device.
- * @param device_options An AVDictionary filled with device-private options.
- * On return this parameter will be destroyed and replaced with a dict
- * containing options that were not found. May be NULL.
- * The same options must be passed later to avformat_write_header() for output
- * devices or avformat_open_input() for input devices, or at any other place
- * that affects device-private options.
- *
- * @return >= 0 on success, negative otherwise.
- */
-int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
- AVDictionary **device_options);
-
-/**
- * Free resources created by avdevice_capabilities_create()
- *
- * @param caps Device capabilities data to be freed.
- * @param s Context of the device.
- */
-void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s);
-
-/**
- * Structure describes basic parameters of the device.
- */
-typedef struct AVDeviceInfo {
- char *device_name; /**< device name, format depends on device */
- char *device_description; /**< human friendly name */
-} AVDeviceInfo;
-
-/**
- * List of devices.
- */
-typedef struct AVDeviceInfoList {
- AVDeviceInfo **devices; /**< list of autodetected devices */
- int nb_devices; /**< number of autodetected devices */
- int default_device; /**< index of default device or -1 if no default */
-} AVDeviceInfoList;
-
-/**
- * List devices.
- *
- * Returns available device names and their parameters.
- *
- * @note: Some devices may accept system-dependent device names that cannot be
- * autodetected. The list returned by this function cannot be assumed to
- * be always completed.
- *
- * @param s device context.
- * @paramout device_list list of autodetected devices.
- * @return count of autodetected devices, negative on error.
- */
-int avdevice_list_devices(struct AVFormatContext *s, AVDeviceInfoList **device_list);
-
-/**
- * Convenient function to free result of avdevice_list_devices().
- *
- * @param devices device list to be freed.
- */
-void avdevice_free_list_devices(AVDeviceInfoList **device_list);
-
-/**
- * List devices.
- *
- * Returns available device names and their parameters.
- * These are convinient wrappers for avdevice_list_devices().
- * Device context is allocated and deallocated internally.
- *
- * @param device device format. May be NULL if device name is set.
- * @param device_name device name. May be NULL if device format is set.
- * @param device_options An AVDictionary filled with device-private options. May be NULL.
- * The same options must be passed later to avformat_write_header() for output
- * devices or avformat_open_input() for input devices, or at any other place
- * that affects device-private options.
- * @paramout device_list list of autodetected devices
- * @return count of autodetected devices, negative on error.
- * @note device argument takes precedence over device_name when both are set.
- */
-int avdevice_list_input_sources(struct AVInputFormat *device, const char *device_name,
- AVDictionary *device_options, AVDeviceInfoList **device_list);
-int avdevice_list_output_sinks(struct AVOutputFormat *device, const char *device_name,
- AVDictionary *device_options, AVDeviceInfoList **device_list);
-
-/**
- * @}
- */
-
-#endif /* AVDEVICE_AVDEVICE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavdevice/version.h Deleted

@@ -1,50 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVDEVICE_VERSION_H
-#define AVDEVICE_VERSION_H
-
-/**
- * @file
- * @ingroup lavd
- * Libavdevice version macros
- */
-
-#include "libavutil/version.h"
-
-#define LIBAVDEVICE_VERSION_MAJOR  58
-#define LIBAVDEVICE_VERSION_MINOR   3
-#define LIBAVDEVICE_VERSION_MICRO 100
-
-#define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \
-                                               LIBAVDEVICE_VERSION_MINOR, \
-                                               LIBAVDEVICE_VERSION_MICRO)
-#define LIBAVDEVICE_VERSION     AV_VERSION(LIBAVDEVICE_VERSION_MAJOR, \
-                                           LIBAVDEVICE_VERSION_MINOR, \
-                                           LIBAVDEVICE_VERSION_MICRO)
-#define LIBAVDEVICE_BUILD       LIBAVDEVICE_VERSION_INT
-
-#define LIBAVDEVICE_IDENT       "Lavd" AV_STRINGIFY(LIBAVDEVICE_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- */
-
-#endif /* AVDEVICE_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavfilter Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavfilter/avfilter.h Deleted

@@ -1,1168 +0,0 @@
-/*
- * filter layer
- * Copyright (c) 2007 Bobby Bingham
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVFILTER_AVFILTER_H
-#define AVFILTER_AVFILTER_H
-
-/**
- * @file
- * @ingroup lavfi
- * Main libavfilter public API header
- */
-
-/**
- * @defgroup lavfi libavfilter
- * Graph-based frame editing library.
- *
- * @{
- */
-
-#include <stddef.h>
-
-#include "libavutil/attributes.h"
-#include "libavutil/avutil.h"
-#include "libavutil/buffer.h"
-#include "libavutil/dict.h"
-#include "libavutil/frame.h"
-#include "libavutil/log.h"
-#include "libavutil/samplefmt.h"
-#include "libavutil/pixfmt.h"
-#include "libavutil/rational.h"
-
-#include "libavfilter/version.h"
-
-/**
- * Return the LIBAVFILTER_VERSION_INT constant.
- */
-unsigned avfilter_version(void);
-
-/**
- * Return the libavfilter build-time configuration.
- */
-const char *avfilter_configuration(void);
-
-/**
- * Return the libavfilter license.
- */
-const char *avfilter_license(void);
-
-typedef struct AVFilterContext AVFilterContext;
-typedef struct AVFilterLink AVFilterLink;
-typedef struct AVFilterPad AVFilterPad;
-typedef struct AVFilterFormats AVFilterFormats;
-
-/**
- * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
- * AVFilter.inputs/outputs).
- */
-int avfilter_pad_count(const AVFilterPad *pads);
-
-/**
- * Get the name of an AVFilterPad.
- *
- * @param pads an array of AVFilterPads
- * @param pad_idx index of the pad in the array it; is the caller's
- * responsibility to ensure the index is valid
- *
- * @return name of the pad_idx'th pad in pads
- */
-const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx);
-
-/**
- * Get the type of an AVFilterPad.
- *
- * @param pads an array of AVFilterPads
- * @param pad_idx index of the pad in the array; it is the caller's
- * responsibility to ensure the index is valid
- *
- * @return type of the pad_idx'th pad in pads
- */
-enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx);
-
-/**
- * The number of the filter inputs is not determined just by AVFilter.inputs.
- * The filter might add additional inputs during initialization depending on the
- * options supplied to it.
- */
-#define AVFILTER_FLAG_DYNAMIC_INPUTS (1 << 0)
-/**
- * The number of the filter outputs is not determined just by AVFilter.outputs.
- * The filter might add additional outputs during initialization depending on
- * the options supplied to it.
- */
-#define AVFILTER_FLAG_DYNAMIC_OUTPUTS (1 << 1)
-/**
- * The filter supports multithreading by splitting frames into multiple parts
- * and processing them concurrently.
- */
-#define AVFILTER_FLAG_SLICE_THREADS (1 << 2)
-/**
- * Some filters support a generic "enable" expression option that can be used
- * to enable or disable a filter in the timeline. Filters supporting this
- * option have this flag set. When the enable expression is false, the default
- * no-op filter_frame() function is called in place of the filter_frame()
- * callback defined on each input pad, thus the frame is passed unchanged to
- * the next filters.
- */
-#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC (1 << 16)
-/**
- * Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will
- * have its filter_frame() callback(s) called as usual even when the enable
- * expression is false. The filter will disable filtering within the
- * filter_frame() callback(s) itself, for example executing code depending on
- * the AVFilterContext->is_disabled value.
- */
-#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL (1 << 17)
-/**
- * Handy mask to test whether the filter supports or no the timeline feature
- * (internally or generically).
- */
-#define AVFILTER_FLAG_SUPPORT_TIMELINE (AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL)
-
-/**
- * Filter definition. This defines the pads a filter contains, and all the
- * callback functions used to interact with the filter.
- */
-typedef struct AVFilter {
- /**
- * Filter name. Must be non-NULL and unique among filters.
- */
- const char *name;
-
- /**
- * A description of the filter. May be NULL.
- *
- * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
- */
- const char *description;
-
- /**
- * List of inputs, terminated by a zeroed element.
- *
- * NULL if there are no (static) inputs. Instances of filters with
- * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
- * this list.
- */
- const AVFilterPad *inputs;
- /**
- * List of outputs, terminated by a zeroed element.
- *
- * NULL if there are no (static) outputs. Instances of filters with
- * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
- * this list.
- */
- const AVFilterPad *outputs;
-
- /**
- * A class for the private data, used to declare filter private AVOptions.
- * This field is NULL for filters that do not declare any options.
- *
- * If this field is non-NULL, the first member of the filter private data
- * must be a pointer to AVClass, which will be set by libavfilter generic
- * code to this class.
- */
- const AVClass *priv_class;
-
- /**
- * A combination of AVFILTER_FLAG_*
- */
- int flags;
-
- /*****************************************************************
- * All fields below this line are not part of the public API. They
- * may not be used outside of libavfilter and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
-
- /**
- * Filter pre-initialization function
- *
- * This callback will be called immediately after the filter context is
- * allocated, to allow allocating and initing sub-objects.
- *
- * If this callback is not NULL, the uninit callback will be called on
- * allocation failure.
- *
- * @return 0 on success,
- * AVERROR code on failure (but the code will be
- * dropped and treated as ENOMEM by the calling code)
- */
- int (*preinit)(AVFilterContext *ctx);
-
- /**
- * Filter initialization function.
- *
- * This callback will be called only once during the filter lifetime, after
- * all the options have been set, but before links between filters are
- * established and format negotiation is done.
- *
- * Basic filter initialization should be done here. Filters with dynamic
- * inputs and/or outputs should create those inputs/outputs here based on
- * provided options. No more changes to this filter's inputs/outputs can be
- * done after this callback.
- *
- * This callback must not assume that the filter links exist or frame
- * parameters are known.
- *
- * @ref AVFilter.uninit "uninit" is guaranteed to be called even if
- * initialization fails, so this callback does not have to clean up on
- * failure.
- *
- * @return 0 on success, a negative AVERROR on failure
- */
- int (*init)(AVFilterContext *ctx);
-
- /**
- * Should be set instead of @ref AVFilter.init "init" by the filters that
- * want to pass a dictionary of AVOptions to nested contexts that are
- * allocated during init.
- *
- * On return, the options dict should be freed and replaced with one that
- * contains all the options which could not be processed by this filter (or
- * with NULL if all the options were processed).
- *
- * Otherwise the semantics is the same as for @ref AVFilter.init "init".
- */
- int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);
-
- /**
- * Filter uninitialization function.
- *
- * Called only once right before the filter is freed. Should deallocate any
- * memory held by the filter, release any buffer references, etc. It does
- * not need to deallocate the AVFilterContext.priv memory itself.
- *
- * This callback may be called even if @ref AVFilter.init "init" was not
- * called or failed, so it must be prepared to handle such a situation.
- */
- void (*uninit)(AVFilterContext *ctx);
-
- /**
- * Query formats supported by the filter on its inputs and outputs.
- *
- * This callback is called after the filter is initialized (so the inputs
- * and outputs are fixed), shortly before the format negotiation. This
- * callback may be called more than once.
- *
- * This callback must set AVFilterLink.out_formats on every input link and
- * AVFilterLink.in_formats on every output link to a list of pixel/sample
- * formats that the filter supports on that link. For audio links, this
- * filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" /
- * @ref AVFilterLink.out_samplerates "out_samplerates" and
- * @ref AVFilterLink.in_channel_layouts "in_channel_layouts" /
- * @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously.
- *
- * This callback may be NULL for filters with one input, in which case
- * libavfilter assumes that it supports all input formats and preserves
- * them on output.
- *
- * @return zero on success, a negative value corresponding to an
- * AVERROR code otherwise
- */
- int (*query_formats)(AVFilterContext *);
-
- int priv_size; ///< size of private data to allocate for the filter
-
- int flags_internal; ///< Additional flags for avfilter internal use only.
-
- /**
- * Used by the filter registration system. Must not be touched by any other
- * code.
- */
- struct AVFilter *next;
-
- /**
- * Make the filter instance process a command.
- *
- * @param cmd the command to process, for handling simplicity all commands must be alphanumeric only
- * @param arg the argument for the command
- * @param res a buffer with size res_size where the filter(s) can return a response. This must not change when the command is not supported.
- * @param flags if AVFILTER_CMD_FLAG_FAST is set and the command would be
- * time consuming then a filter should treat it like an unsupported command
- *
- * @returns >=0 on success otherwise an error code.
- * AVERROR(ENOSYS) on unsupported commands
- */
- int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
-
- /**
- * Filter initialization function, alternative to the init()
- * callback. Args contains the user-supplied parameters, opaque is
- * used for providing binary data.
- */
- int (*init_opaque)(AVFilterContext *ctx, void *opaque);
-
- /**
- * Filter activation function.
- *
- * Called when any processing is needed from the filter, instead of any
- * filter_frame and request_frame on pads.
- *
- * The function must examine inlinks and outlinks and perform a single
- * step of processing. If there is nothing to do, the function must do
- * nothing and not return an error. If more steps are or may be
- * possible, it must use ff_filter_set_ready() to schedule another
- * activation.
- */
- int (*activate)(AVFilterContext *ctx);
-} AVFilter;
-
-/**
- * Process multiple parts of the frame concurrently.
- */
-#define AVFILTER_THREAD_SLICE (1 << 0)
-
-typedef struct AVFilterInternal AVFilterInternal;
-
-/** An instance of a filter */
-struct AVFilterContext {
- const AVClass *av_class; ///< needed for av_log() and filters common options
-
- const AVFilter *filter; ///< the AVFilter of which this is an instance
-
- char *name; ///< name of this filter instance
-
- AVFilterPad *input_pads; ///< array of input pads
- AVFilterLink **inputs; ///< array of pointers to input links
- unsigned nb_inputs; ///< number of input pads
-
- AVFilterPad *output_pads; ///< array of output pads
- AVFilterLink **outputs; ///< array of pointers to output links
- unsigned nb_outputs; ///< number of output pads
-
- void *priv; ///< private data for use by the filter
-
- struct AVFilterGraph *graph; ///< filtergraph this filter belongs to
-
- /**
- * Type of multithreading being allowed/used. A combination of
- * AVFILTER_THREAD_* flags.
- *
- * May be set by the caller before initializing the filter to forbid some
- * or all kinds of multithreading for this filter. The default is allowing
- * everything.
- *
- * When the filter is initialized, this field is combined using bit AND with
- * AVFilterGraph.thread_type to get the final mask used for determining
- * allowed threading types. I.e. a threading type needs to be set in both
- * to be allowed.
- *
- * After the filter is initialized, libavfilter sets this field to the
- * threading type that is actually used (0 for no multithreading).
- */
- int thread_type;
-
- /**
- * An opaque struct for libavfilter internal use.
- */
- AVFilterInternal *internal;
-
- struct AVFilterCommand *command_queue;
-
- char *enable_str; ///< enable expression string
- void *enable; ///< parsed expression (AVExpr*)
- double *var_values; ///< variable values for the enable expression
- int is_disabled; ///< the enabled state from the last expression evaluation
-
- /**
- * For filters which will create hardware frames, sets the device the
- * filter should create them in. All other filters will ignore this field:
- * in particular, a filter which consumes or processes hardware frames will
- * instead use the hw_frames_ctx field in AVFilterLink to carry the
- * hardware context information.
- */
- AVBufferRef *hw_device_ctx;
-
- /**
- * Max number of threads allowed in this filter instance.
- * If <= 0, its value is ignored.
- * Overrides global number of threads set per filter graph.
- */
- int nb_threads;
-
- /**
- * Ready status of the filter.
- * A non-0 value means that the filter needs activating;
- * a higher value suggests a more urgent activation.
- */
- unsigned ready;
-
- /**
- * Sets the number of extra hardware frames which the filter will
- * allocate on its output links for use in following filters or by
- * the caller.
- *
- * Some hardware filters require all frames that they will use for
- * output to be defined in advance before filtering starts. For such
- * filters, any hardware frame pools used for output must therefore be
- * of fixed size. The extra frames set here are on top of any number
- * that the filter needs internally in order to operate normally.
- *
- * This field must be set before the graph containing this filter is
- * configured.
- */
- int extra_hw_frames;
-};
-
-/**
- * A link between two filters. This contains pointers to the source and
- * destination filters between which this link exists, and the indexes of
- * the pads involved. In addition, this link also contains the parameters
- * which have been negotiated and agreed upon between the filter, such as
- * image dimensions, format, etc.
- *
- * Applications must not normally access the link structure directly.
- * Use the buffersrc and buffersink API instead.
- * In the future, access to the header may be reserved for filters
- * implementation.
- */
-struct AVFilterLink {
- AVFilterContext *src; ///< source filter
- AVFilterPad *srcpad; ///< output pad on the source filter
-
- AVFilterContext *dst; ///< dest filter
- AVFilterPad *dstpad; ///< input pad on the dest filter
-
- enum AVMediaType type; ///< filter media type
-
- /* These parameters apply only to video */
- int w; ///< agreed upon image width
- int h; ///< agreed upon image height
- AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
- /* These parameters apply only to audio */
- uint64_t channel_layout; ///< channel layout of current buffer (see libavutil/channel_layout.h)
- int sample_rate; ///< samples per second
-
- int format; ///< agreed upon media format
-
- /**
- * Define the time base used by the PTS of the frames/samples
- * which will pass through this link.
- * During the configuration stage, each filter is supposed to
- * change only the output timebase, while the timebase of the
- * input link is assumed to be an unchangeable property.
- */
- AVRational time_base;
-
- /*****************************************************************
- * All fields below this line are not part of the public API. They
- * may not be used outside of libavfilter and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
- /**
- * Lists of formats and channel layouts supported by the input and output
- * filters respectively. These lists are used for negotiating the format
- * to actually be used, which will be loaded into the format and
- * channel_layout members, above, when chosen.
- *
- */
- AVFilterFormats *in_formats;
- AVFilterFormats *out_formats;
-
- /**
- * Lists of channel layouts and sample rates used for automatic
- * negotiation.
- */
- AVFilterFormats *in_samplerates;
- AVFilterFormats *out_samplerates;
- struct AVFilterChannelLayouts *in_channel_layouts;
- struct AVFilterChannelLayouts *out_channel_layouts;
-
- /**
- * Audio only, the destination filter sets this to a non-zero value to
- * request that buffers with the given number of samples should be sent to
- * it. AVFilterPad.needs_fifo must also be set on the corresponding input
- * pad.
- * Last buffer before EOF will be padded with silence.
- */
- int request_samples;
-
- /** stage of the initialization of the link properties (dimensions, etc) */
- enum {
- AVLINK_UNINIT = 0, ///< not started
- AVLINK_STARTINIT, ///< started, but incomplete
- AVLINK_INIT ///< complete
- } init_state;
-
- /**
- * Graph the filter belongs to.
- */
- struct AVFilterGraph *graph;
-
- /**
- * Current timestamp of the link, as defined by the most recent
- * frame(s), in link time_base units.
- */
- int64_t current_pts;
-
- /**
- * Current timestamp of the link, as defined by the most recent
- * frame(s), in AV_TIME_BASE units.
- */
- int64_t current_pts_us;
-
- /**
- * Index in the age array.
- */
- int age_index;
-
- /**
- * Frame rate of the stream on the link, or 1/0 if unknown or variable;
- * if left to 0/0, will be automatically copied from the first input
- * of the source filter if it exists.
- *
- * Sources should set it to the best estimation of the real frame rate.
- * If the source frame rate is unknown or variable, set this to 1/0.
- * Filters should update it if necessary depending on their function.
- * Sinks can use it to set a default output frame rate.
- * It is similar to the r_frame_rate field in AVStream.
- */
- AVRational frame_rate;
-
- /**
- * Buffer partially filled with samples to achieve a fixed/minimum size.
- */
- AVFrame *partial_buf;
-
- /**
- * Size of the partial buffer to allocate.
- * Must be between min_samples and max_samples.
- */
- int partial_buf_size;
-
- /**
- * Minimum number of samples to filter at once. If filter_frame() is
- * called with fewer samples, it will accumulate them in partial_buf.
- * This field and the related ones must not be changed after filtering
- * has started.
- * If 0, all related fields are ignored.
- */
- int min_samples;
-
- /**
- * Maximum number of samples to filter at once. If filter_frame() is
- * called with more samples, it will split them.
- */
- int max_samples;
-
- /**
- * Number of channels.
- */
- int channels;
-
- /**
- * Link processing flags.
- */
- unsigned flags;
-
- /**
- * Number of past frames sent through the link.
- */
- int64_t frame_count_in, frame_count_out;
-
- /**
- * A pointer to a FFFramePool struct.
- */
- void *frame_pool;
-
- /**
- * True if a frame is currently wanted on the output of this filter.
- * Set when ff_request_frame() is called by the output,
- * cleared when a frame is filtered.
- */
- int frame_wanted_out;
-
- /**
- * For hwaccel pixel formats, this should be a reference to the
- * AVHWFramesContext describing the frames.
- */
- AVBufferRef *hw_frames_ctx;
-
-#ifndef FF_INTERNAL_FIELDS
-
- /**
- * Internal structure members.
- * The fields below this limit are internal for libavfilter's use
- * and must in no way be accessed by applications.
- */
- char reserved0xF000;
-
-#else /* FF_INTERNAL_FIELDS */
-
- /**
- * Queue of frames waiting to be filtered.
- */
- FFFrameQueue fifo;
-
- /**
- * If set, the source filter can not generate a frame as is.
- * The goal is to avoid repeatedly calling the request_frame() method on
- * the same link.
- */
- int frame_blocked_in;
-
- /**
- * Link input status.
- * If not zero, all attempts of filter_frame will fail with the
- * corresponding code.
- */
- int status_in;
-
- /**
- * Timestamp of the input status change.
- */
- int64_t status_in_pts;
-
- /**
- * Link output status.
- * If not zero, all attempts of request_frame will fail with the
- * corresponding code.
- */
- int status_out;
-
-#endif /* FF_INTERNAL_FIELDS */
-
-};
-
-/**
- * Link two filters together.
- *
- * @param src the source filter
- * @param srcpad index of the output pad on the source filter
- * @param dst the destination filter
- * @param dstpad index of the input pad on the destination filter
- * @return zero on success
- */
-int avfilter_link(AVFilterContext *src, unsigned srcpad,
- AVFilterContext *dst, unsigned dstpad);
-
-/**
- * Free the link in *link, and set its pointer to NULL.
- */
-void avfilter_link_free(AVFilterLink **link);
-
-#if FF_API_FILTER_GET_SET
-/**
- * Get the number of channels of a link.
- * @deprecated Use av_buffersink_get_channels()
- */
-attribute_deprecated
-int avfilter_link_get_channels(AVFilterLink *link);
-#endif
-
-/**
- * Set the closed field of a link.
- * @deprecated applications are not supposed to mess with links, they should
- * close the sinks.
- */
-attribute_deprecated
-void avfilter_link_set_closed(AVFilterLink *link, int closed);
-
-/**
- * Negotiate the media format, dimensions, etc of all inputs to a filter.
- *
- * @param filter the filter to negotiate the properties for its inputs
- * @return zero on successful negotiation
- */
-int avfilter_config_links(AVFilterContext *filter);
-
-#define AVFILTER_CMD_FLAG_ONE 1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
-#define AVFILTER_CMD_FLAG_FAST 2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw)
-
-/**
- * Make the filter instance process a command.
- * It is recommended to use avfilter_graph_send_command().
- */
-int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags);
-
-/**
- * Iterate over all registered filters.
- *
- * @param opaque a pointer where libavfilter will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered filter or NULL when the iteration is
- * finished
- */
-const AVFilter *av_filter_iterate(void **opaque);
-
-#if FF_API_NEXT
-/** Initialize the filter system. Register all builtin filters. */
-attribute_deprecated
-void avfilter_register_all(void);
-
-/**
- * Register a filter. This is only needed if you plan to use
- * avfilter_get_by_name later to lookup the AVFilter structure by name. A
- * filter can still by instantiated with avfilter_graph_alloc_filter even if it
- * is not registered.
- *
- * @param filter the filter to register
- * @return 0 if the registration was successful, a negative value
- * otherwise
- */
-attribute_deprecated
-int avfilter_register(AVFilter *filter);
-
-/**
- * Iterate over all registered filters.
- * @return If prev is non-NULL, next registered filter after prev or NULL if
- * prev is the last filter. If prev is NULL, return the first registered filter.
- */
-attribute_deprecated
-const AVFilter *avfilter_next(const AVFilter *prev);
-#endif
-
-/**
- * Get a filter definition matching the given name.
- *
- * @param name the filter name to find
- * @return the filter definition, if any matching one is registered.
- * NULL if none found.
- */
-const AVFilter *avfilter_get_by_name(const char *name);
-
-
-/**
- * Initialize a filter with the supplied parameters.
- *
- * @param ctx uninitialized filter context to initialize
- * @param args Options to initialize the filter with. This must be a
- * ':'-separated list of options in the 'key=value' form.
- * May be NULL if the options have been set directly using the
- * AVOptions API or there are no options that need to be set.
- * @return 0 on success, a negative AVERROR on failure
- */
-int avfilter_init_str(AVFilterContext *ctx, const char *args);
-
-/**
- * Initialize a filter with the supplied dictionary of options.
- *
- * @param ctx uninitialized filter context to initialize
- * @param options An AVDictionary filled with options for this filter. On
- * return this parameter will be destroyed and replaced with
- * a dict containing options that were not found. This dictionary
- * must be freed by the caller.
- * May be NULL, then this function is equivalent to
- * avfilter_init_str() with the second parameter set to NULL.
- * @return 0 on success, a negative AVERROR on failure
- *
- * @note This function and avfilter_init_str() do essentially the same thing,
- * the difference is in manner in which the options are passed. It is up to the
- * calling code to choose whichever is more preferable. The two functions also
- * behave differently when some of the provided options are not declared as
- * supported by the filter. In such a case, avfilter_init_str() will fail, but
- * this function will leave those extra options in the options AVDictionary and
- * continue as usual.
- */
-int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options);
-
-/**
- * Free a filter context. This will also remove the filter from its
- * filtergraph's list of filters.
- *
- * @param filter the filter to free
- */
-void avfilter_free(AVFilterContext *filter);
-
-/**
- * Insert a filter in the middle of an existing link.
- *
- * @param link the link into which the filter should be inserted
- * @param filt the filter to be inserted
- * @param filt_srcpad_idx the input pad on the filter to connect
- * @param filt_dstpad_idx the output pad on the filter to connect
- * @return zero on success
- */
-int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
- unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
-
-/**
- * @return AVClass for AVFilterContext.
- *
- * @see av_opt_find().
- */
-const AVClass *avfilter_get_class(void);
-
-typedef struct AVFilterGraphInternal AVFilterGraphInternal;
-
-/**
- * A function pointer passed to the @ref AVFilterGraph.execute callback to be
- * executed multiple times, possibly in parallel.
- *
- * @param ctx the filter context the job belongs to
- * @param arg an opaque parameter passed through from @ref
- * AVFilterGraph.execute
- * @param jobnr the index of the job being executed
- * @param nb_jobs the total number of jobs
- *
- * @return 0 on success, a negative AVERROR on error
- */
-typedef int (avfilter_action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
-
-/**
- * A function executing multiple jobs, possibly in parallel.
- *
- * @param ctx the filter context to which the jobs belong
- * @param func the function to be called multiple times
- * @param arg the argument to be passed to func
- * @param ret a nb_jobs-sized array to be filled with return values from each
- * invocation of func
- * @param nb_jobs the number of jobs to execute
- *
- * @return 0 on success, a negative AVERROR on error
- */
-typedef int (avfilter_execute_func)(AVFilterContext *ctx, avfilter_action_func *func,
- void *arg, int *ret, int nb_jobs);
-
-typedef struct AVFilterGraph {
- const AVClass *av_class;
- AVFilterContext **filters;
- unsigned nb_filters;
-
- char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters
-#if FF_API_LAVR_OPTS
- attribute_deprecated char *resample_lavr_opts; ///< libavresample options to use for the auto-inserted resample filters
-#endif
-
- /**
- * Type of multithreading allowed for filters in this graph. A combination
- * of AVFILTER_THREAD_* flags.
- *
- * May be set by the caller at any point, the setting will apply to all
- * filters initialized after that. The default is allowing everything.
- *
- * When a filter in this graph is initialized, this field is combined using
- * bit AND with AVFilterContext.thread_type to get the final mask used for
- * determining allowed threading types. I.e. a threading type needs to be
- * set in both to be allowed.
- */
- int thread_type;
-
- /**
- * Maximum number of threads used by filters in this graph. May be set by
- * the caller before adding any filters to the filtergraph. Zero (the
- * default) means that the number of threads is determined automatically.
- */
- int nb_threads;
-
- /**
- * Opaque object for libavfilter internal use.
- */
- AVFilterGraphInternal *internal;
-
- /**
- * Opaque user data. May be set by the caller to an arbitrary value, e.g. to
- * be used from callbacks like @ref AVFilterGraph.execute.
- * Libavfilter will not touch this field in any way.
- */
- void *opaque;
-
- /**
- * This callback may be set by the caller immediately after allocating the
- * graph and before adding any filters to it, to provide a custom
- * multithreading implementation.
- *
- * If set, filters with slice threading capability will call this callback
- * to execute multiple jobs in parallel.
- *
- * If this field is left unset, libavfilter will use its internal
- * implementation, which may or may not be multithreaded depending on the
- * platform and build options.
- */
- avfilter_execute_func *execute;
-
- char *aresample_swr_opts; ///< swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions
-
- /**
- * Private fields
- *
- * The following fields are for internal use only.
- * Their type, offset, number and semantic can change without notice.
- */
-
- AVFilterLink **sink_links;
- int sink_links_count;
-
- unsigned disable_auto_convert;
-} AVFilterGraph;
-
-/**
- * Allocate a filter graph.
- *
- * @return the allocated filter graph on success or NULL.
- */
-AVFilterGraph *avfilter_graph_alloc(void);
-
-/**
- * Create a new filter instance in a filter graph.
- *
- * @param graph graph in which the new filter will be used
- * @param filter the filter to create an instance of
- * @param name Name to give to the new instance (will be copied to
- * AVFilterContext.name). This may be used by the caller to identify
- * different filters, libavfilter itself assigns no semantics to
- * this parameter. May be NULL.
- *
- * @return the context of the newly created filter instance (note that it is
- * also retrievable directly through AVFilterGraph.filters or with
- * avfilter_graph_get_filter()) on success or NULL on failure.
- */
-AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
- const AVFilter *filter,
- const char *name);
-
-/**
- * Get a filter instance identified by instance name from graph.
- *
- * @param graph filter graph to search through.
- * @param name filter instance name (should be unique in the graph).
- * @return the pointer to the found filter instance or NULL if it
- * cannot be found.
- */
-AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, const char *name);
-
-/**
- * Create and add a filter instance into an existing graph.
- * The filter instance is created from the filter filt and inited
- * with the parameters args and opaque.
- *
- * In case of success put in *filt_ctx the pointer to the created
- * filter instance, otherwise set *filt_ctx to NULL.
- *
- * @param name the instance name to give to the created filter instance
- * @param graph_ctx the filter graph
- * @return a negative AVERROR error code in case of failure, a non
- * negative value otherwise
- */
-int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt,
- const char *name, const char *args, void *opaque,
- AVFilterGraph *graph_ctx);
-
-/**
- * Enable or disable automatic format conversion inside the graph.
- *
- * Note that format conversion can still happen inside explicitly inserted
- * scale and aresample filters.
- *
- * @param flags any of the AVFILTER_AUTO_CONVERT_* constants
- */
-void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags);
-
-enum {
- AVFILTER_AUTO_CONVERT_ALL = 0, /**< all automatic conversions enabled */
- AVFILTER_AUTO_CONVERT_NONE = -1, /**< all automatic conversions disabled */
-};
-
-/**
- * Check validity and configure all the links and formats in the graph.
- *
- * @param graphctx the filter graph
- * @param log_ctx context used for logging
- * @return >= 0 in case of success, a negative AVERROR code otherwise
- */
-int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx);
-
-/**
- * Free a graph, destroy its links, and set *graph to NULL.
- * If *graph is NULL, do nothing.
- */
-void avfilter_graph_free(AVFilterGraph **graph);
-
-/**
- * A linked-list of the inputs/outputs of the filter chain.
- *
- * This is mainly useful for avfilter_graph_parse() / avfilter_graph_parse2(),
- * where it is used to communicate open (unlinked) inputs and outputs from and
- * to the caller.
- * This struct specifies, per each not connected pad contained in the graph, the
- * filter context and the pad index required for establishing a link.
- */
-typedef struct AVFilterInOut {
- /** unique name for this input/output in the list */
- char *name;
-
- /** filter context associated to this input/output */
- AVFilterContext *filter_ctx;
-
- /** index of the filt_ctx pad to use for linking */
- int pad_idx;
-
- /** next input/input in the list, NULL if this is the last */
- struct AVFilterInOut *next;
-} AVFilterInOut;
-
-/**
- * Allocate a single AVFilterInOut entry.
- * Must be freed with avfilter_inout_free().
- * @return allocated AVFilterInOut on success, NULL on failure.
- */
-AVFilterInOut *avfilter_inout_alloc(void);
-
-/**
- * Free the supplied list of AVFilterInOut and set *inout to NULL.
- * If *inout is NULL, do nothing.
- */
-void avfilter_inout_free(AVFilterInOut **inout);
-
-/**
- * Add a graph described by a string to a graph.
- *
- * @note The caller must provide the lists of inputs and outputs,
- * which therefore must be known before calling the function.
- *
- * @note The inputs parameter describes inputs of the already existing
- * part of the graph; i.e. from the point of view of the newly created
- * part, they are outputs. Similarly the outputs parameter describes
- * outputs of the already existing filters, which are provided as
- * inputs to the parsed filters.
- *
- * @param graph the filter graph where to link the parsed graph context
- * @param filters string to be parsed
- * @param inputs linked list to the inputs of the graph
- * @param outputs linked list to the outputs of the graph
- * @return zero on success, a negative AVERROR code on error
- */
-int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
- AVFilterInOut *inputs, AVFilterInOut *outputs,
- void *log_ctx);
-
-/**
- * Add a graph described by a string to a graph.
- *
- * In the graph filters description, if the input label of the first
- * filter is not specified, "in" is assumed; if the output label of
- * the last filter is not specified, "out" is assumed.
- *
- * @param graph the filter graph where to link the parsed graph context
- * @param filters string to be parsed
- * @param inputs pointer to a linked list to the inputs of the graph, may be NULL.
- * If non-NULL, *inputs is updated to contain the list of open inputs
- * after the parsing, should be freed with avfilter_inout_free().
- * @param outputs pointer to a linked list to the outputs of the graph, may be NULL.
- * If non-NULL, *outputs is updated to contain the list of open outputs
- * after the parsing, should be freed with avfilter_inout_free().
- * @return non negative on success, a negative AVERROR code on error
- */
-int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
- AVFilterInOut **inputs, AVFilterInOut **outputs,
- void *log_ctx);
-
-/**
- * Add a graph described by a string to a graph.
- *
- * @paramin graph the filter graph where to link the parsed graph context
- * @paramin filters string to be parsed
- * @paramout inputs a linked list of all free (unlinked) inputs of the
- * parsed graph will be returned here. It is to be freed
- * by the caller using avfilter_inout_free().
- * @paramout outputs a linked list of all free (unlinked) outputs of the
- * parsed graph will be returned here. It is to be freed by the
- * caller using avfilter_inout_free().
- * @return zero on success, a negative AVERROR code on error
- *
- * @note This function returns the inputs and outputs that are left
- * unlinked after parsing the graph and the caller then deals with
- * them.
- * @note This function makes no reference whatsoever to already
- * existing parts of the graph and the inputs parameter will on return
- * contain inputs of the newly parsed part of the graph. Analogously
- * the outputs parameter will contain outputs of the newly created
- * filters.
- */
-int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
- AVFilterInOut **inputs,
- AVFilterInOut **outputs);
-
-/**
- * Send a command to one or more filter instances.
- *
- * @param graph the filter graph
- * @param target the filter(s) to which the command should be sent
- * "all" sends to all filters
- * otherwise it can be a filter or filter instance name
- * which will send the command to all matching filters.
- * @param cmd the command to send, for handling simplicity all commands must be alphanumeric only
- * @param arg the argument for the command
- * @param res a buffer with size res_size where the filter(s) can return a response.
- *
- * @returns >=0 on success otherwise an error code.
- * AVERROR(ENOSYS) on unsupported commands
- */
-int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags);
-
-/**
- * Queue a command for one or more filter instances.
- *
- * @param graph the filter graph
- * @param target the filter(s) to which the command should be sent
- * "all" sends to all filters
- * otherwise it can be a filter or filter instance name
- * which will send the command to all matching filters.
- * @param cmd the command to sent, for handling simplicity all commands must be alphanumeric only
- * @param arg the argument for the command
- * @param ts time at which the command should be sent to the filter
- *
- * @note As this executes commands after this function returns, no return code
- * from the filter is provided, also AVFILTER_CMD_FLAG_ONE is not supported.
- */
-int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts);
-
-
-/**
- * Dump a graph into a human-readable string representation.
- *
- * @param graph the graph to dump
- * @param options formatting options; currently ignored
- * @return a string, or NULL in case of memory allocation failure;
- * the string must be freed using av_free
- */
-char *avfilter_graph_dump(AVFilterGraph *graph, const char *options);
-
-/**
- * Request a frame on the oldest sink link.
- *
- * If the request returns AVERROR_EOF, try the next.
- *
- * Note that this function is not meant to be the sole scheduling mechanism
- * of a filtergraph, only a convenience function to help drain a filtergraph
- * in a balanced way under normal circumstances.
- *
- * Also note that AVERROR_EOF does not mean that frames did not arrive on
- * some of the sinks during the process.
- * When there are multiple sink links, in case the requested link
- * returns an EOF, this may cause a filter to flush pending frames
- * which are sent to another sink link, although unrequested.
- *
- * @return the return value of ff_request_frame(),
- * or AVERROR_EOF if all links returned AVERROR_EOF
- */
-int avfilter_graph_request_oldest(AVFilterGraph *graph);
-
-/**
- * @}
- */
-
-#endif /* AVFILTER_AVFILTER_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavfilter/buffersink.h Deleted

@@ -1,165 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVFILTER_BUFFERSINK_H
-#define AVFILTER_BUFFERSINK_H
-
-/**
- * @file
- * @ingroup lavfi_buffersink
- * memory buffer sink API for audio and video
- */
-
-#include "avfilter.h"
-
-/**
- * @defgroup lavfi_buffersink Buffer sink API
- * @ingroup lavfi
- * @{
- */
-
-/**
- * Get a frame with filtered data from sink and put it in frame.
- *
- * @param ctx pointer to a buffersink or abuffersink filter context.
- * @param frame pointer to an allocated frame that will be filled with data.
- * The data must be freed using av_frame_unref() / av_frame_free()
- * @param flags a combination of AV_BUFFERSINK_FLAG_* flags
- *
- * @return >= 0 in for success, a negative AVERROR code for failure.
- */
-int av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags);
-
-/**
- * Tell av_buffersink_get_buffer_ref() to read video/samples buffer
- * reference, but not remove it from the buffer. This is useful if you
- * need only to read a video/samples buffer, without to fetch it.
- */
-#define AV_BUFFERSINK_FLAG_PEEK 1
-
-/**
- * Tell av_buffersink_get_buffer_ref() not to request a frame from its input.
- * If a frame is already buffered, it is read (and removed from the buffer),
- * but if no frame is present, return AVERROR(EAGAIN).
- */
-#define AV_BUFFERSINK_FLAG_NO_REQUEST 2
-
-/**
- * Struct to use for initializing a buffersink context.
- */
-typedef struct AVBufferSinkParams {
- const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE
-} AVBufferSinkParams;
-
-/**
- * Create an AVBufferSinkParams structure.
- *
- * Must be freed with av_free().
- */
-AVBufferSinkParams *av_buffersink_params_alloc(void);
-
-/**
- * Struct to use for initializing an abuffersink context.
- */
-typedef struct AVABufferSinkParams {
- const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
- const int64_t *channel_layouts; ///< list of allowed channel layouts, terminated by -1
- const int *channel_counts; ///< list of allowed channel counts, terminated by -1
- int all_channel_counts; ///< if not 0, accept any channel count or layout
- int *sample_rates; ///< list of allowed sample rates, terminated by -1
-} AVABufferSinkParams;
-
-/**
- * Create an AVABufferSinkParams structure.
- *
- * Must be freed with av_free().
- */
-AVABufferSinkParams *av_abuffersink_params_alloc(void);
-
-/**
- * Set the frame size for an audio buffer sink.
- *
- * All calls to av_buffersink_get_buffer_ref will return a buffer with
- * exactly the specified number of samples, or AVERROR(EAGAIN) if there is
- * not enough. The last buffer at EOF will be padded with 0.
- */
-void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size);
-
-/**
- * @defgroup lavfi_buffersink_accessors Buffer sink accessors
- * Get the properties of the stream
- * @{
- */
-
-enum AVMediaType av_buffersink_get_type (const AVFilterContext *ctx);
-AVRational av_buffersink_get_time_base (const AVFilterContext *ctx);
-int av_buffersink_get_format (const AVFilterContext *ctx);
-
-AVRational av_buffersink_get_frame_rate (const AVFilterContext *ctx);
-int av_buffersink_get_w (const AVFilterContext *ctx);
-int av_buffersink_get_h (const AVFilterContext *ctx);
-AVRational av_buffersink_get_sample_aspect_ratio (const AVFilterContext *ctx);
-
-int av_buffersink_get_channels (const AVFilterContext *ctx);
-uint64_t av_buffersink_get_channel_layout (const AVFilterContext *ctx);
-int av_buffersink_get_sample_rate (const AVFilterContext *ctx);
-
-AVBufferRef * av_buffersink_get_hw_frames_ctx (const AVFilterContext *ctx);
-
-/** @} */
-
-/**
- * Get a frame with filtered data from sink and put it in frame.
- *
- * @param ctx pointer to a context of a buffersink or abuffersink AVFilter.
- * @param frame pointer to an allocated frame that will be filled with data.
- * The data must be freed using av_frame_unref() / av_frame_free()
- *
- * @return
- * - >= 0 if a frame was successfully returned.
- * - AVERROR(EAGAIN) if no frames are available at this point; more
- * input frames must be added to the filtergraph to get more output.
- * - AVERROR_EOF if there will be no more output frames on this sink.
- * - A different negative AVERROR code in other failure cases.
- */
-int av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame);
-
-/**
- * Same as av_buffersink_get_frame(), but with the ability to specify the number
- * of samples read. This function is less efficient than
- * av_buffersink_get_frame(), because it copies the data around.
- *
- * @param ctx pointer to a context of the abuffersink AVFilter.
- * @param frame pointer to an allocated frame that will be filled with data.
- * The data must be freed using av_frame_unref() / av_frame_free()
- * frame will contain exactly nb_samples audio samples, except at
- * the end of stream, when it can contain less than nb_samples.
- *
- * @return The return codes have the same meaning as for
- * av_buffersink_get_samples().
- *
- * @warning do not mix this function with av_buffersink_get_frame(). Use only one or
- * the other with a single sink, not both.
- */
-int av_buffersink_get_samples(AVFilterContext *ctx, AVFrame *frame, int nb_samples);
-
-/**
- * @}
- */
-
-#endif /* AVFILTER_BUFFERSINK_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavfilter/buffersrc.h Deleted

@@ -1,209 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVFILTER_BUFFERSRC_H
-#define AVFILTER_BUFFERSRC_H
-
-/**
- * @file
- * @ingroup lavfi_buffersrc
- * Memory buffer source API.
- */
-
-#include "avfilter.h"
-
-/**
- * @defgroup lavfi_buffersrc Buffer source API
- * @ingroup lavfi
- * @{
- */
-
-enum {
-
-    /**
-     * Do not check for format changes.
-     */
-    AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT = 1,
-
-    /**
-     * Immediately push the frame to the output.
-     */
-    AV_BUFFERSRC_FLAG_PUSH = 4,
-
-    /**
-     * Keep a reference to the frame.
-     * If the frame if reference-counted, create a new reference; otherwise
-     * copy the frame data.
-     */
-    AV_BUFFERSRC_FLAG_KEEP_REF = 8,
-
-};
-
-/**
- * Get the number of failed requests.
- *
- * A failed request is when the request_frame method is called while no
- * frame is present in the buffer.
- * The number is reset when a frame is added.
- */
-unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src);
-
-/**
- * This structure contains the parameters describing the frames that will be
- * passed to this filter.
- *
- * It should be allocated with av_buffersrc_parameters_alloc() and freed with
- * av_free(). All the allocated fields in it remain owned by the caller.
- */
-typedef struct AVBufferSrcParameters {
-    /**
-     * video: the pixel format, value corresponds to enum AVPixelFormat
-     * audio: the sample format, value corresponds to enum AVSampleFormat
-     */
-    int format;
-    /**
-     * The timebase to be used for the timestamps on the input frames.
-     */
-    AVRational time_base;
-
-    /**
-     * Video only, the display dimensions of the input frames.
-     */
-    int width, height;
-
-    /**
-     * Video only, the sample (pixel) aspect ratio.
-     */
-    AVRational sample_aspect_ratio;
-
-    /**
-     * Video only, the frame rate of the input video. This field must only be
-     * set to a non-zero value if input stream has a known constant framerate
-     * and should be left at its initial value if the framerate is variable or
-     * unknown.
-     */
-    AVRational frame_rate;
-
-    /**
-     * Video with a hwaccel pixel format only. This should be a reference to an
-     * AVHWFramesContext instance describing the input frames.
-     */
-    AVBufferRef *hw_frames_ctx;
-
-    /**
-     * Audio only, the audio sampling rate in samples per secon.
-     */
-    int sample_rate;
-
-    /**
-     * Audio only, the audio channel layout
-     */
-    uint64_t channel_layout;
-} AVBufferSrcParameters;
-
-/**
- * Allocate a new AVBufferSrcParameters instance. It should be freed by the
- * caller with av_free().
- */
-AVBufferSrcParameters *av_buffersrc_parameters_alloc(void);
-
-/**
- * Initialize the buffersrc or abuffersrc filter with the provided parameters.
- * This function may be called multiple times, the later calls override the
- * previous ones. Some of the parameters may also be set through AVOptions, then
- * whatever method is used last takes precedence.
- *
- * @param ctx an instance of the buffersrc or abuffersrc filter
- * @param param the stream parameters. The frames later passed to this filter
- *              must conform to those parameters. All the allocated fields in
- *              param remain owned by the caller, libavfilter will make internal
- *              copies or references when necessary.
- * @return 0 on success, a negative AVERROR code on failure.
- */
-int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param);
-
-/**
- * Add a frame to the buffer source.
- *
- * @param ctx   an instance of the buffersrc filter
- * @param frame frame to be added. If the frame is reference counted, this
- * function will make a new reference to it. Otherwise the frame data will be
- * copied.
- *
- * @return 0 on success, a negative AVERROR on error
- *
- * This function is equivalent to av_buffersrc_add_frame_flags() with the
- * AV_BUFFERSRC_FLAG_KEEP_REF flag.
- */
-av_warn_unused_result
-int av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame);
-
-/**
- * Add a frame to the buffer source.
- *
- * @param ctx   an instance of the buffersrc filter
- * @param frame frame to be added. If the frame is reference counted, this
- * function will take ownership of the reference(s) and reset the frame.
- * Otherwise the frame data will be copied. If this function returns an error,
- * the input frame is not touched.
- *
- * @return 0 on success, a negative AVERROR on error.
- *
- * @note the difference between this function and av_buffersrc_write_frame() is
- * that av_buffersrc_write_frame() creates a new reference to the input frame,
- * while this function takes ownership of the reference passed to it.
- *
- * This function is equivalent to av_buffersrc_add_frame_flags() without the
- * AV_BUFFERSRC_FLAG_KEEP_REF flag.
- */
-av_warn_unused_result
-int av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame);
-
-/**
- * Add a frame to the buffer source.
- *
- * By default, if the frame is reference-counted, this function will take
- * ownership of the reference(s) and reset the frame. This can be controlled
- * using the flags.
- *
- * If this function returns an error, the input frame is not touched.
- *
- * @param buffer_src  pointer to a buffer source context
- * @param frame       a frame, or NULL to mark EOF
- * @param flags       a combination of AV_BUFFERSRC_FLAG_*
- * @return            >= 0 in case of success, a negative AVERROR code
- *                    in case of failure
- */
-av_warn_unused_result
-int av_buffersrc_add_frame_flags(AVFilterContext *buffer_src,
-                                 AVFrame *frame, int flags);
-
-/**
- * Close the buffer source after EOF.
- *
- * This is similar to passing NULL to av_buffersrc_add_frame_flags()
- * except it takes the timestamp of the EOF, i.e. the timestamp of the end
- * of the last frame.
- */
-int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags);
-
-/**
- * @}
- */
-
-#endif /* AVFILTER_BUFFERSRC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavfilter/version.h Deleted

@@ -1,65 +0,0 @@
-/*
- * Version macros.
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVFILTER_VERSION_H
-#define AVFILTER_VERSION_H
-
-/**
- * @file
- * @ingroup lavfi
- * Libavfilter version macros
- */
-
-#include "libavutil/version.h"
-
-#define LIBAVFILTER_VERSION_MAJOR 7
-#define LIBAVFILTER_VERSION_MINOR 16
-#define LIBAVFILTER_VERSION_MICRO 100
-
-#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
- LIBAVFILTER_VERSION_MINOR, \
- LIBAVFILTER_VERSION_MICRO)
-#define LIBAVFILTER_VERSION AV_VERSION(LIBAVFILTER_VERSION_MAJOR, \
- LIBAVFILTER_VERSION_MINOR, \
- LIBAVFILTER_VERSION_MICRO)
-#define LIBAVFILTER_BUILD LIBAVFILTER_VERSION_INT
-
-#define LIBAVFILTER_IDENT "Lavfi" AV_STRINGIFY(LIBAVFILTER_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- */
-
-#ifndef FF_API_OLD_FILTER_OPTS_ERROR
-#define FF_API_OLD_FILTER_OPTS_ERROR (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
-#ifndef FF_API_LAVR_OPTS
-#define FF_API_LAVR_OPTS (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
-#ifndef FF_API_FILTER_GET_SET
-#define FF_API_FILTER_GET_SET (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
-#ifndef FF_API_NEXT
-#define FF_API_NEXT (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
-
-#endif /* AVFILTER_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavformat Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavformat/avformat.h Deleted

@@ -1,3067 +0,0 @@
-/*
- * copyright (c) 2001 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVFORMAT_AVFORMAT_H
-#define AVFORMAT_AVFORMAT_H
-
-/**
- * @file
- * @ingroup libavf
- * Main libavformat public API header
- */
-
-/**
- * @defgroup libavf libavformat
- * I/O and Muxing/Demuxing Library
- *
- * Libavformat (lavf) is a library for dealing with various media container
- * formats. Its main two purposes are demuxing - i.e. splitting a media file
- * into component streams, and the reverse process of muxing - writing supplied
- * data in a specified container format. It also has an @ref lavf_io
- * "I/O module" which supports a number of protocols for accessing the data (e.g.
- * file, tcp, http and others). Before using lavf, you need to call
- * av_register_all() to register all compiled muxers, demuxers and protocols.
- * Unless you are absolutely sure you won't use libavformat's network
- * capabilities, you should also call avformat_network_init().
- *
- * A supported input format is described by an AVInputFormat struct, conversely
- * an output format is described by AVOutputFormat. You can iterate over all
- * registered input/output formats using the av_iformat_next() /
- * av_oformat_next() functions. The protocols layer is not part of the public
- * API, so you can only get the names of supported protocols with the
- * avio_enum_protocols() function.
- *
- * Main lavf structure used for both muxing and demuxing is AVFormatContext,
- * which exports all information about the file being read or written. As with
- * most Libavformat structures, its size is not part of public ABI, so it cannot be
- * allocated on stack or directly with av_malloc(). To create an
- * AVFormatContext, use avformat_alloc_context() (some functions, like
- * avformat_open_input() might do that for you).
- *
- * Most importantly an AVFormatContext contains:
- * @li the @ref AVFormatContext.iformat "input" or @ref AVFormatContext.oformat
- * "output" format. It is either autodetected or set by user for input;
- * always set by user for output.
- * @li an @ref AVFormatContext.streams "array" of AVStreams, which describe all
- * elementary streams stored in the file. AVStreams are typically referred to
- * using their index in this array.
- * @li an @ref AVFormatContext.pb "I/O context". It is either opened by lavf or
- * set by user for input, always set by user for output (unless you are dealing
- * with an AVFMT_NOFILE format).
- *
- * @section lavf_options Passing options to (de)muxers
- * It is possible to configure lavf muxers and demuxers using the @ref avoptions
- * mechanism. Generic (format-independent) libavformat options are provided by
- * AVFormatContext, they can be examined from a user program by calling
- * av_opt_next() / av_opt_find() on an allocated AVFormatContext (or its AVClass
- * from avformat_get_class()). Private (format-specific) options are provided by
- * AVFormatContext.priv_data if and only if AVInputFormat.priv_class /
- * AVOutputFormat.priv_class of the corresponding format struct is non-NULL.
- * Further options may be provided by the @ref AVFormatContext.pb "I/O context",
- * if its AVClass is non-NULL, and the protocols layer. See the discussion on
- * nesting in @ref avoptions documentation to learn how to access those.
- *
- * @section urls
- * URL strings in libavformat are made of a scheme/protocol, a ':', and a
- * scheme specific string. URLs without a scheme and ':' used for local files
- * are supported but deprecated. "file:" should be used for local files.
- *
- * It is important that the scheme string is not taken from untrusted
- * sources without checks.
- *
- * Note that some schemes/protocols are quite powerful, allowing access to
- * both local and remote files, parts of them, concatenations of them, local
- * audio and video devices and so on.
- *
- * @{
- *
- * @defgroup lavf_decoding Demuxing
- * @{
- * Demuxers read a media file and split it into chunks of data (@em packets). A
- * @ref AVPacket "packet" contains one or more encoded frames which belongs to a
- * single elementary stream. In the lavf API this process is represented by the
- * avformat_open_input() function for opening a file, av_read_frame() for
- * reading a single packet and finally avformat_close_input(), which does the
- * cleanup.
- *
- * @section lavf_decoding_open Opening a media file
- * The minimum information required to open a file is its URL, which
- * is passed to avformat_open_input(), as in the following code:
- * @code
- * const char *url = "file:in.mp3";
- * AVFormatContext *s = NULL;
- * int ret = avformat_open_input(&s, url, NULL, NULL);
- * if (ret < 0)
- * abort();
- * @endcode
- * The above code attempts to allocate an AVFormatContext, open the
- * specified file (autodetecting the format) and read the header, exporting the
- * information stored there into s. Some formats do not have a header or do not
- * store enough information there, so it is recommended that you call the
- * avformat_find_stream_info() function which tries to read and decode a few
- * frames to find missing information.
- *
- * In some cases you might want to preallocate an AVFormatContext yourself with
- * avformat_alloc_context() and do some tweaking on it before passing it to
- * avformat_open_input(). One such case is when you want to use custom functions
- * for reading input data instead of lavf internal I/O layer.
- * To do that, create your own AVIOContext with avio_alloc_context(), passing
- * your reading callbacks to it. Then set the @em pb field of your
- * AVFormatContext to newly created AVIOContext.
- *
- * Since the format of the opened file is in general not known until after
- * avformat_open_input() has returned, it is not possible to set demuxer private
- * options on a preallocated context. Instead, the options should be passed to
- * avformat_open_input() wrapped in an AVDictionary:
- * @code
- * AVDictionary *options = NULL;
- * av_dict_set(&options, "video_size", "640x480", 0);
- * av_dict_set(&options, "pixel_format", "rgb24", 0);
- *
- * if (avformat_open_input(&s, url, NULL, &options) < 0)
- * abort();
- * av_dict_free(&options);
- * @endcode
- * This code passes the private options 'video_size' and 'pixel_format' to the
- * demuxer. They would be necessary for e.g. the rawvideo demuxer, since it
- * cannot know how to interpret raw video data otherwise. If the format turns
- * out to be something different than raw video, those options will not be
- * recognized by the demuxer and therefore will not be applied. Such unrecognized
- * options are then returned in the options dictionary (recognized options are
- * consumed). The calling program can handle such unrecognized options as it
- * wishes, e.g.
- * @code
- * AVDictionaryEntry *e;
- * if (e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX)) {
- * fprintf(stderr, "Option %s not recognized by the demuxer.\n", e->key);
- * abort();
- * }
- * @endcode
- *
- * After you have finished reading the file, you must close it with
- * avformat_close_input(). It will free everything associated with the file.
- *
- * @section lavf_decoding_read Reading from an opened file
- * Reading data from an opened AVFormatContext is done by repeatedly calling
- * av_read_frame() on it. Each call, if successful, will return an AVPacket
- * containing encoded data for one AVStream, identified by
- * AVPacket.stream_index. This packet may be passed straight into the libavcodec
- * decoding functions avcodec_send_packet() or avcodec_decode_subtitle2() if the
- * caller wishes to decode the data.
- *
- * AVPacket.pts, AVPacket.dts and AVPacket.duration timing information will be
- * set if known. They may also be unset (i.e. AV_NOPTS_VALUE for
- * pts/dts, 0 for duration) if the stream does not provide them. The timing
- * information will be in AVStream.time_base units, i.e. it has to be
- * multiplied by the timebase to convert them to seconds.
- *
- * If AVPacket.buf is set on the returned packet, then the packet is
- * allocated dynamically and the user may keep it indefinitely.
- * Otherwise, if AVPacket.buf is NULL, the packet data is backed by a
- * static storage somewhere inside the demuxer and the packet is only valid
- * until the next av_read_frame() call or closing the file. If the caller
- * requires a longer lifetime, av_dup_packet() will make an av_malloc()ed copy
- * of it.
- * In both cases, the packet must be freed with av_packet_unref() when it is no
- * longer needed.
- *
- * @section lavf_decoding_seek Seeking
- * @}
- *
- * @defgroup lavf_encoding Muxing
- * @{
- * Muxers take encoded data in the form of @ref AVPacket "AVPackets" and write
- * it into files or other output bytestreams in the specified container format.
- *
- * The main API functions for muxing are avformat_write_header() for writing the
- * file header, av_write_frame() / av_interleaved_write_frame() for writing the
- * packets and av_write_trailer() for finalizing the file.
- *
- * At the beginning of the muxing process, the caller must first call
- * avformat_alloc_context() to create a muxing context. The caller then sets up
- * the muxer by filling the various fields in this context:
- *
- * - The @ref AVFormatContext.oformat "oformat" field must be set to select the
- * muxer that will be used.
- * - Unless the format is of the AVFMT_NOFILE type, the @ref AVFormatContext.pb
- * "pb" field must be set to an opened IO context, either returned from
- * avio_open2() or a custom one.
- * - Unless the format is of the AVFMT_NOSTREAMS type, at least one stream must
- * be created with the avformat_new_stream() function. The caller should fill
- * the @ref AVStream.codecpar "stream codec parameters" information, such as the
- * codec @ref AVCodecParameters.codec_type "type", @ref AVCodecParameters.codec_id
- * "id" and other parameters (e.g. width / height, the pixel or sample format,
- * etc.) as known. The @ref AVStream.time_base "stream timebase" should
- * be set to the timebase that the caller desires to use for this stream (note
- * that the timebase actually used by the muxer can be different, as will be
- * described later).
- * - It is advised to manually initialize only the relevant fields in
- * AVCodecParameters, rather than using @ref avcodec_parameters_copy() during
- * remuxing: there is no guarantee that the codec context values remain valid
- * for both input and output format contexts.
- * - The caller may fill in additional information, such as @ref
- * AVFormatContext.metadata "global" or @ref AVStream.metadata "per-stream"
- * metadata, @ref AVFormatContext.chapters "chapters", @ref
- * AVFormatContext.programs "programs", etc. as described in the
- * AVFormatContext documentation. Whether such information will actually be
- * stored in the output depends on what the container format and the muxer
- * support.
- *
- * When the muxing context is fully set up, the caller must call
- * avformat_write_header() to initialize the muxer internals and write the file
- * header. Whether anything actually is written to the IO context at this step
- * depends on the muxer, but this function must always be called. Any muxer
- * private options must be passed in the options parameter to this function.
- *
- * The data is then sent to the muxer by repeatedly calling av_write_frame() or
- * av_interleaved_write_frame() (consult those functions' documentation for
- * discussion on the difference between them; only one of them may be used with
- * a single muxing context, they should not be mixed). Do note that the timing
- * information on the packets sent to the muxer must be in the corresponding
- * AVStream's timebase. That timebase is set by the muxer (in the
- * avformat_write_header() step) and may be different from the timebase
- * requested by the caller.
- *
- * Once all the data has been written, the caller must call av_write_trailer()
- * to flush any buffered packets and finalize the output file, then close the IO
- * context (if any) and finally free the muxing context with
- * avformat_free_context().
- * @}
- *
- * @defgroup lavf_io I/O Read/Write
- * @{
- * @section lavf_io_dirlist Directory listing
- * The directory listing API makes it possible to list files on remote servers.
- *
- * Some of possible use cases:
- * - an "open file" dialog to choose files from a remote location,
- * - a recursive media finder providing a player with an ability to play all
- * files from a given directory.
- *
- * @subsection lavf_io_dirlist_open Opening a directory
- * At first, a directory needs to be opened by calling avio_open_dir()
- * supplied with a URL and, optionally, ::AVDictionary containing
- * protocol-specific parameters. The function returns zero or positive
- * integer and allocates AVIODirContext on success.
- *
- * @code
- * AVIODirContext *ctx = NULL;
- * if (avio_open_dir(&ctx, "smb://example.com/some_dir", NULL) < 0) {
- * fprintf(stderr, "Cannot open directory.\n");
- * abort();
- * }
- * @endcode
- *
- * This code tries to open a sample directory using smb protocol without
- * any additional parameters.
- *
- * @subsection lavf_io_dirlist_read Reading entries
- * Each directory's entry (i.e. file, another directory, anything else
- * within ::AVIODirEntryType) is represented by AVIODirEntry.
- * Reading consecutive entries from an opened AVIODirContext is done by
- * repeatedly calling avio_read_dir() on it. Each call returns zero or
- * positive integer if successful. Reading can be stopped right after the
- * NULL entry has been read -- it means there are no entries left to be
- * read. The following code reads all entries from a directory associated
- * with ctx and prints their names to standard output.
- * @code
- * AVIODirEntry *entry = NULL;
- * for (;;) {
- * if (avio_read_dir(ctx, &entry) < 0) {
- * fprintf(stderr, "Cannot list directory.\n");
- * abort();
- * }
- * if (!entry)
- * break;
- * printf("%s\n", entry->name);
- * avio_free_directory_entry(&entry);
- * }
- * @endcode
- * @}
- *
- * @defgroup lavf_codec Demuxers
- * @{
- * @defgroup lavf_codec_native Native Demuxers
- * @{
- * @}
- * @defgroup lavf_codec_wrappers External library wrappers
- * @{
- * @}
- * @}
- * @defgroup lavf_protos I/O Protocols
- * @{
- * @}
- * @defgroup lavf_internal Internal
- * @{
- * @}
- * @}
- */
-
-#include <time.h>
-#include <stdio.h> /* FILE */
-#include "libavcodec/avcodec.h"
-#include "libavutil/dict.h"
-#include "libavutil/log.h"
-
-#include "avio.h"
-#include "libavformat/version.h"
-
-struct AVFormatContext;
-
-struct AVDeviceInfoList;
-struct AVDeviceCapabilitiesQuery;
-
-/**
- * @defgroup metadata_api Public Metadata API
- * @{
- * @ingroup libavf
- * The metadata API allows libavformat to export metadata tags to a client
- * application when demuxing. Conversely it allows a client application to
- * set metadata when muxing.
- *
- * Metadata is exported or set as pairs of key/value strings in the 'metadata'
- * fields of the AVFormatContext, AVStream, AVChapter and AVProgram structs
- * using the @ref lavu_dict "AVDictionary" API. Like all strings in FFmpeg,
- * metadata is assumed to be UTF-8 encoded Unicode. Note that metadata
- * exported by demuxers isn't checked to be valid UTF-8 in most cases.
- *
- * Important concepts to keep in mind:
- * - Keys are unique; there can never be 2 tags with the same key. This is
- * also meant semantically, i.e., a demuxer should not knowingly produce
- * several keys that are literally different but semantically identical.
- * E.g., key=Author5, key=Author6. In this example, all authors must be
- * placed in the same tag.
- * - Metadata is flat, not hierarchical; there are no subtags. If you
- * want to store, e.g., the email address of the child of producer Alice
- * and actor Bob, that could have key=alice_and_bobs_childs_email_address.
- * - Several modifiers can be applied to the tag name. This is done by
- * appending a dash character ('-') and the modifier name in the order
- * they appear in the list below -- e.g. foo-eng-sort, not foo-sort-eng.
- * - language -- a tag whose value is localized for a particular language
- * is appended with the ISO 639-2/B 3-letter language code.
- * For example: Author-ger=Michael, Author-eng=Mike
- * The original/default language is in the unqualified "Author" tag.
- * A demuxer should set a default if it sets any translated tag.
- * - sorting -- a modified version of a tag that should be used for
- * sorting will have '-sort' appended. E.g. artist="The Beatles",
- * artist-sort="Beatles, The".
- * - Some protocols and demuxers support metadata updates. After a successful
- * call to av_read_packet(), AVFormatContext.event_flags or AVStream.event_flags
- * will be updated to indicate if metadata changed. In order to detect metadata
- * changes on a stream, you need to loop through all streams in the AVFormatContext
- * and check their individual event_flags.
- *
- * - Demuxers attempt to export metadata in a generic format, however tags
- * with no generic equivalents are left as they are stored in the container.
- * Follows a list of generic tag names:
- *
- @verbatim
- album -- name of the set this work belongs to
- album_artist -- main creator of the set/album, if different from artist.
- e.g. "Various Artists" for compilation albums.
- artist -- main creator of the work
- comment -- any additional description of the file.
- composer -- who composed the work, if different from artist.
- copyright -- name of copyright holder.
- creation_time-- date when the file was created, preferably in ISO 8601.
- date -- date when the work was created, preferably in ISO 8601.
- disc -- number of a subset, e.g. disc in a multi-disc collection.
- encoder -- name/settings of the software/hardware that produced the file.
- encoded_by -- person/group who created the file.
- filename -- original name of the file.
- genre -- <self-evident>.
- language -- main language in which the work is performed, preferably
- in ISO 639-2 format. Multiple languages can be specified by
- separating them with commas.
- performer -- artist who performed the work, if different from artist.
- E.g for "Also sprach Zarathustra", artist would be "Richard
- Strauss" and performer "London Philharmonic Orchestra".
- publisher -- name of the label/publisher.
- service_name -- name of the service in broadcasting (channel name).
- service_provider -- name of the service provider in broadcasting.
- title -- name of the work.
- track -- number of this work in the set, can be in form current/total.
- variant_bitrate -- the total bitrate of the bitrate variant that the current stream is part of
- @endverbatim
- *
- * Look in the examples section for an application example how to use the Metadata API.
- *
- * @}
- */
-
-/* packet functions */
-
-
-/**
- * Allocate and read the payload of a packet and initialize its
- * fields with default values.
- *
- * @param s associated IO context
- * @param pkt packet
- * @param size desired payload size
- * @return >0 (read size) if OK, AVERROR_xxx otherwise
- */
-int av_get_packet(AVIOContext *s, AVPacket *pkt, int size);
-
-
-/**
- * Read data and append it to the current content of the AVPacket.
- * If pkt->size is 0 this is identical to av_get_packet.
- * Note that this uses av_grow_packet and thus involves a realloc
- * which is inefficient. Thus this function should only be used
- * when there is no reasonable way to know (an upper bound of)
- * the final size.
- *
- * @param s associated IO context
- * @param pkt packet
- * @param size amount of data to read
- * @return >0 (read size) if OK, AVERROR_xxx otherwise, previous data
- * will not be lost even if an error occurs.
- */
-int av_append_packet(AVIOContext *s, AVPacket *pkt, int size);
-
-/*************************************************/
-/* input/output formats */
-
-struct AVCodecTag;
-
-/**
- * This structure contains the data a format has to probe a file.
- */
-typedef struct AVProbeData {
- const char *filename;
- unsigned char *buf; /**< Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero. */
- int buf_size; /**< Size of buf except extra allocated bytes */
- const char *mime_type; /**< mime_type, when known. */
-} AVProbeData;
-
-#define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX/4)
-#define AVPROBE_SCORE_STREAM_RETRY (AVPROBE_SCORE_MAX/4-1)
-
-#define AVPROBE_SCORE_EXTENSION 50 ///< score for file extension
-#define AVPROBE_SCORE_MIME 75 ///< score for file mime type
-#define AVPROBE_SCORE_MAX 100 ///< maximum score
-
-#define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer
-
-/// Demuxer will use avio_open, no opened file should be provided by the caller.
-#define AVFMT_NOFILE 0x0001
-#define AVFMT_NEEDNUMBER 0x0002 /**< Needs '%d' in filename. */
-#define AVFMT_SHOW_IDS 0x0008 /**< Show format stream IDs numbers. */
-#define AVFMT_GLOBALHEADER 0x0040 /**< Format wants global header. */
-#define AVFMT_NOTIMESTAMPS 0x0080 /**< Format does not need / have any timestamps. */
-#define AVFMT_GENERIC_INDEX 0x0100 /**< Use generic index building code. */
-#define AVFMT_TS_DISCONT 0x0200 /**< Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps */
-#define AVFMT_VARIABLE_FPS 0x0400 /**< Format allows variable fps. */
-#define AVFMT_NODIMENSIONS 0x0800 /**< Format does not need width/height */
-#define AVFMT_NOSTREAMS 0x1000 /**< Format does not require any streams */
-#define AVFMT_NOBINSEARCH 0x2000 /**< Format does not allow to fall back on binary search via read_timestamp */
-#define AVFMT_NOGENSEARCH 0x4000 /**< Format does not allow to fall back on generic search */
-#define AVFMT_NO_BYTE_SEEK 0x8000 /**< Format does not allow seeking by bytes */
-#define AVFMT_ALLOW_FLUSH 0x10000 /**< Format allows flushing. If not set, the muxer will not receive a NULL packet in the write_packet function. */
-#define AVFMT_TS_NONSTRICT 0x20000 /**< Format does not require strictly
- increasing timestamps, but they must
- still be monotonic */
-#define AVFMT_TS_NEGATIVE 0x40000 /**< Format allows muxing negative
- timestamps. If not set the timestamp
- will be shifted in av_write_frame and
- av_interleaved_write_frame so they
- start from 0.
- The user or muxer can override this through
- AVFormatContext.avoid_negative_ts
- */
-
-#define AVFMT_SEEK_TO_PTS 0x4000000 /**< Seeking is based on PTS */
-
-/**
- * @addtogroup lavf_encoding
- * @{
- */
-typedef struct AVOutputFormat {
- const char *name;
- /**
- * Descriptive name for the format, meant to be more human-readable
- * than name. You should use the NULL_IF_CONFIG_SMALL() macro
- * to define it.
- */
- const char *long_name;
- const char *mime_type;
- const char *extensions; /**< comma-separated filename extensions */
- /* output support */
- enum AVCodecID audio_codec; /**< default audio codec */
- enum AVCodecID video_codec; /**< default video codec */
- enum AVCodecID subtitle_codec; /**< default subtitle codec */
- /**
- * can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER,
- * AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS,
- * AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH,
- * AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
- */
- int flags;
-
- /**
- * List of supported codec_id-codec_tag pairs, ordered by "better
- * choice first". The arrays are all terminated by AV_CODEC_ID_NONE.
- */
- const struct AVCodecTag * const *codec_tag;
-
-
- const AVClass *priv_class; ///< AVClass for the private context
-
- /*****************************************************************
- * No fields below this line are part of the public API. They
- * may not be used outside of libavformat and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
- struct AVOutputFormat *next;
- /**
- * size of private data so that it can be allocated in the wrapper
- */
- int priv_data_size;
-
- int (*write_header)(struct AVFormatContext *);
- /**
- * Write a packet. If AVFMT_ALLOW_FLUSH is set in flags,
- * pkt can be NULL in order to flush data buffered in the muxer.
- * When flushing, return 0 if there still is more data to flush,
- * or 1 if everything was flushed and there is no more buffered
- * data.
- */
- int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);
- int (*write_trailer)(struct AVFormatContext *);
- /**
- * Currently only used to set pixel format if not YUV420P.
- */
- int (*interleave_packet)(struct AVFormatContext *, AVPacket *out,
- AVPacket *in, int flush);
- /**
- * Test if the given codec can be stored in this container.
- *
- * @return 1 if the codec is supported, 0 if it is not.
- * A negative number if unknown.
- * MKTAG('A', 'P', 'I', 'C') if the codec is only supported as AV_DISPOSITION_ATTACHED_PIC
- */
- int (*query_codec)(enum AVCodecID id, int std_compliance);
-
- void (*get_output_timestamp)(struct AVFormatContext *s, int stream,
- int64_t *dts, int64_t *wall);
- /**
- * Allows sending messages from application to device.
- */
- int (*control_message)(struct AVFormatContext *s, int type,
- void *data, size_t data_size);
-
- /**
- * Write an uncoded AVFrame.
- *
- * See av_write_uncoded_frame() for details.
- *
- * The library will free *frame afterwards, but the muxer can prevent it
- * by setting the pointer to NULL.
- */
- int (*write_uncoded_frame)(struct AVFormatContext *, int stream_index,
- AVFrame **frame, unsigned flags);
- /**
- * Returns device list with it properties.
- * @see avdevice_list_devices() for more details.
- */
- int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
- /**
- * Initialize device capabilities submodule.
- * @see avdevice_capabilities_create() for more details.
- */
- int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
- /**
- * Free device capabilities submodule.
- * @see avdevice_capabilities_free() for more details.
- */
- int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
- enum AVCodecID data_codec; /**< default data codec */
- /**
- * Initialize format. May allocate data here, and set any AVFormatContext or
- * AVStream parameters that need to be set before packets are sent.
- * This method must not write output.
- *
- * Return 0 if streams were fully configured, 1 if not, negative AVERROR on failure
- *
- * Any allocations made here must be freed in deinit().
- */
- int (*init)(struct AVFormatContext *);
- /**
- * Deinitialize format. If present, this is called whenever the muxer is being
- * destroyed, regardless of whether or not the header has been written.
- *
- * If a trailer is being written, this is called after write_trailer().
- *
- * This is called if init() fails as well.
- */
- void (*deinit)(struct AVFormatContext *);
- /**
- * Set up any necessary bitstream filtering and extract any extra data needed
- * for the global header.
- * Return 0 if more packets from this stream must be checked; 1 if not.
- */
- int (*check_bitstream)(struct AVFormatContext *, const AVPacket *pkt);
-} AVOutputFormat;
-/**
- * @}
- */
-
-/**
- * @addtogroup lavf_decoding
- * @{
- */
-typedef struct AVInputFormat {
- /**
- * A comma separated list of short names for the format. New names
- * may be appended with a minor bump.
- */
- const char *name;
-
- /**
- * Descriptive name for the format, meant to be more human-readable
- * than name. You should use the NULL_IF_CONFIG_SMALL() macro
- * to define it.
- */
- const char *long_name;
-
- /**
- * Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS,
- * AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH,
- * AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
- */
- int flags;
-
- /**
- * If extensions are defined, then no probe is done. You should
- * usually not use extension format guessing because it is not
- * reliable enough
- */
- const char *extensions;
-
- const struct AVCodecTag * const *codec_tag;
-
- const AVClass *priv_class; ///< AVClass for the private context
-
- /**
- * Comma-separated list of mime types.
- * It is used check for matching mime types while probing.
- * @see av_probe_input_format2
- */
- const char *mime_type;
-
- /*****************************************************************
- * No fields below this line are part of the public API. They
- * may not be used outside of libavformat and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
- struct AVInputFormat *next;
-
- /**
- * Raw demuxers store their codec ID here.
- */
- int raw_codec_id;
-
- /**
- * Size of private data so that it can be allocated in the wrapper.
- */
- int priv_data_size;
-
- /**
- * Tell if a given file has a chance of being parsed as this format.
- * The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes
- * big so you do not have to check for that unless you need more.
- */
- int (*read_probe)(AVProbeData *);
-
- /**
- * Read the format header and initialize the AVFormatContext
- * structure. Return 0 if OK. 'avformat_new_stream' should be
- * called to create new streams.
- */
- int (*read_header)(struct AVFormatContext *);
-
- /**
- * Read one packet and put it in 'pkt'. pts and flags are also
- * set. 'avformat_new_stream' can be called only if the flag
- * AVFMTCTX_NOHEADER is used and only in the calling thread (not in a
- * background thread).
- * @return 0 on success, < 0 on error.
- * When returning an error, pkt must not have been allocated
- * or must be freed before returning
- */
- int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
-
- /**
- * Close the stream. The AVFormatContext and AVStreams are not
- * freed by this function
- */
- int (*read_close)(struct AVFormatContext *);
-
- /**
- * Seek to a given timestamp relative to the frames in
- * stream component stream_index.
- * @param stream_index Must not be -1.
- * @param flags Selects which direction should be preferred if no exact
- * match is available.
- * @return >= 0 on success (but not necessarily the new offset)
- */
- int (*read_seek)(struct AVFormatContext *,
- int stream_index, int64_t timestamp, int flags);
-
- /**
- * Get the next timestamp in streamstream_index.time_base units.
- * @return the timestamp or AV_NOPTS_VALUE if an error occurred
- */
- int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index,
- int64_t *pos, int64_t pos_limit);
-
- /**
- * Start/resume playing - only meaningful if using a network-based format
- * (RTSP).
- */
- int (*read_play)(struct AVFormatContext *);
-
- /**
- * Pause playing - only meaningful if using a network-based format
- * (RTSP).
- */
- int (*read_pause)(struct AVFormatContext *);
-
- /**
- * Seek to timestamp ts.
- * Seeking will be done so that the point from which all active streams
- * can be presented successfully will be closest to ts and within min/max_ts.
- * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
- */
- int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
-
- /**
- * Returns device list with it properties.
- * @see avdevice_list_devices() for more details.
- */
- int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
-
- /**
- * Initialize device capabilities submodule.
- * @see avdevice_capabilities_create() for more details.
- */
- int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
-
- /**
- * Free device capabilities submodule.
- * @see avdevice_capabilities_free() for more details.
- */
- int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
-} AVInputFormat;
-/**
- * @}
- */
-
-enum AVStreamParseType {
- AVSTREAM_PARSE_NONE,
- AVSTREAM_PARSE_FULL, /**< full parsing and repack */
- AVSTREAM_PARSE_HEADERS, /**< Only parse headers, do not repack. */
- AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on a packet boundary */
- AVSTREAM_PARSE_FULL_ONCE, /**< full parsing and repack of the first frame only, only implemented for H.264 currently */
- AVSTREAM_PARSE_FULL_RAW, /**< full parsing and repack with timestamp and position generation by parser for raw
- this assumes that each packet in the file contains no demuxer level headers and
- just codec level data, otherwise position generation would fail */
-};
-
-typedef struct AVIndexEntry {
- int64_t pos;
- int64_t timestamp; /**<
- * Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are available
- * when seeking to this entry. That means preferable PTS on keyframe based formats.
- * But demuxers can choose to store a different timestamp, if it is more convenient for the implementation or nothing better
- * is known
- */
-#define AVINDEX_KEYFRAME 0x0001
-#define AVINDEX_DISCARD_FRAME 0x0002 /**
- * Flag is used to indicate which frame should be discarded after decoding.
- */
- int flags:2;
- int size:30; //Yeah, trying to keep the size of this small to reduce memory requirements (it is 24 vs. 32 bytes due to possible 8-byte alignment).
- int min_distance; /**< Minimum distance between this and the previous keyframe, used to avoid unneeded searching. */
-} AVIndexEntry;
-
-#define AV_DISPOSITION_DEFAULT 0x0001
-#define AV_DISPOSITION_DUB 0x0002
-#define AV_DISPOSITION_ORIGINAL 0x0004
-#define AV_DISPOSITION_COMMENT 0x0008
-#define AV_DISPOSITION_LYRICS 0x0010
-#define AV_DISPOSITION_KARAOKE 0x0020
-
-/**
- * Track should be used during playback by default.
- * Useful for subtitle track that should be displayed
- * even when user did not explicitly ask for subtitles.
- */
-#define AV_DISPOSITION_FORCED 0x0040
-#define AV_DISPOSITION_HEARING_IMPAIRED 0x0080 /**< stream for hearing impaired audiences */
-#define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100 /**< stream for visual impaired audiences */
-#define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /**< stream without voice */
-/**
- * The stream is stored in the file as an attached picture/"cover art" (e.g.
- * APIC frame in ID3v2). The first (usually only) packet associated with it
- * will be returned among the first few packets read from the file unless
- * seeking takes place. It can also be accessed at any time in
- * AVStream.attached_pic.
- */
-#define AV_DISPOSITION_ATTACHED_PIC 0x0400
-/**
- * The stream is sparse, and contains thumbnail images, often corresponding
- * to chapter markers. Only ever used with AV_DISPOSITION_ATTACHED_PIC.
- */
-#define AV_DISPOSITION_TIMED_THUMBNAILS 0x0800
-
-typedef struct AVStreamInternal AVStreamInternal;
-
-/**
- * To specify text track kind (different from subtitles default).
- */
-#define AV_DISPOSITION_CAPTIONS 0x10000
-#define AV_DISPOSITION_DESCRIPTIONS 0x20000
-#define AV_DISPOSITION_METADATA 0x40000
-#define AV_DISPOSITION_DEPENDENT 0x80000 ///< dependent audio stream (mix_type=0 in mpegts)
-
-/**
- * Options for behavior on timestamp wrap detection.
- */
-#define AV_PTS_WRAP_IGNORE 0 ///< ignore the wrap
-#define AV_PTS_WRAP_ADD_OFFSET 1 ///< add the format specific offset on wrap detection
-#define AV_PTS_WRAP_SUB_OFFSET -1 ///< subtract the format specific offset on wrap detection
-
-/**
- * Stream structure.
- * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing fields require a major
- * version bump.
- * sizeof(AVStream) must not be used outside libav*.
- */
-typedef struct AVStream {
- int index; /**< stream index in AVFormatContext */
- /**
- * Format-specific stream ID.
- * decoding: set by libavformat
- * encoding: set by the user, replaced by libavformat if left unset
- */
- int id;
-#if FF_API_LAVF_AVCTX
- /**
- * @deprecated use the codecpar struct instead
- */
- attribute_deprecated
- AVCodecContext *codec;
-#endif
- void *priv_data;
-
- /**
- * This is the fundamental unit of time (in seconds) in terms
- * of which frame timestamps are represented.
- *
- * decoding: set by libavformat
- * encoding: May be set by the caller before avformat_write_header() to
- * provide a hint to the muxer about the desired timebase. In
- * avformat_write_header(), the muxer will overwrite this field
- * with the timebase that will actually be used for the timestamps
- * written into the file (which may or may not be related to the
- * user-provided one, depending on the format).
- */
- AVRational time_base;
-
- /**
- * Decoding: pts of the first frame of the stream in presentation order, in stream time base.
- * Only set this if you are absolutely 100% sure that the value you set
- * it to really is the pts of the first frame.
- * This may be undefined (AV_NOPTS_VALUE).
- * @note The ASF header does NOT contain a correct start_time the ASF
- * demuxer must NOT set this.
- */
- int64_t start_time;
-
- /**
- * Decoding: duration of the stream, in stream time base.
- * If a source file does not specify a duration, but does specify
- * a bitrate, this value will be estimated from bitrate and file size.
- *
- * Encoding: May be set by the caller before avformat_write_header() to
- * provide a hint to the muxer about the estimated duration.
- */
- int64_t duration;
-
- int64_t nb_frames; ///< number of frames in this stream if known or 0
-
- int disposition; /**< AV_DISPOSITION_* bit field */
-
- enum AVDiscard discard; ///< Selects which packets can be discarded at will and do not need to be demuxed.
-
- /**
- * sample aspect ratio (0 if unknown)
- * - encoding: Set by user.
- * - decoding: Set by libavformat.
- */
- AVRational sample_aspect_ratio;
-
- AVDictionary *metadata;
-
- /**
- * Average framerate
- *
- * - demuxing: May be set by libavformat when creating the stream or in
- * avformat_find_stream_info().
- * - muxing: May be set by the caller before avformat_write_header().
- */
- AVRational avg_frame_rate;
-
- /**
- * For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet
- * will contain the attached picture.
- *
- * decoding: set by libavformat, must not be modified by the caller.
- * encoding: unused
- */
- AVPacket attached_pic;
-
- /**
- * An array of side data that applies to the whole stream (i.e. the
- * container does not allow it to change between packets).
- *
- * There may be no overlap between the side data in this array and side data
- * in the packets. I.e. a given side data is either exported by the muxer
- * (demuxing) / set by the caller (muxing) in this array, then it never
- * appears in the packets, or the side data is exported / sent through
- * the packets (always in the first packet where the value becomes known or
- * changes), then it does not appear in this array.
- *
- * - demuxing: Set by libavformat when the stream is created.
- * - muxing: May be set by the caller before avformat_write_header().
- *
- * Freed by libavformat in avformat_free_context().
- *
- * @see av_format_inject_global_side_data()
- */
- AVPacketSideData *side_data;
- /**
- * The number of elements in the AVStream.side_data array.
- */
- int nb_side_data;
-
- /**
- * Flags for the user to detect events happening on the stream. Flags must
- * be cleared by the user once the event has been handled.
- * A combination of AVSTREAM_EVENT_FLAG_*.
- */
- int event_flags;
-#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001 ///< The call resulted in updated metadata.
-
- /**
- * Real base framerate of the stream.
- * This is the lowest framerate with which all timestamps can be
- * represented accurately (it is the least common multiple of all
- * framerates in the stream). Note, this value is just a guess!
- * For example, if the time base is 1/90000 and all frames have either
- * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1.
- */
- AVRational r_frame_rate;
-
-#if FF_API_LAVF_FFSERVER
- /**
- * String containing pairs of key and values describing recommended encoder configuration.
- * Pairs are separated by ','.
- * Keys are separated from values by '='.
- *
- * @deprecated unused
- */
- attribute_deprecated
- char *recommended_encoder_configuration;
-#endif
-
- /**
- * Codec parameters associated with this stream. Allocated and freed by
- * libavformat in avformat_new_stream() and avformat_free_context()
- * respectively.
- *
- * - demuxing: filled by libavformat on stream creation or in
- * avformat_find_stream_info()
- * - muxing: filled by the caller before avformat_write_header()
- */
- AVCodecParameters *codecpar;
-
- /*****************************************************************
- * All fields below this line are not part of the public API. They
- * may not be used outside of libavformat and can be changed and
- * removed at will.
- * Internal note: be aware that physically removing these fields
- * will break ABI. Replace removed fields with dummy fields, and
- * add new fields to AVStreamInternal.
- *****************************************************************
- */
-
-#define MAX_STD_TIMEBASES (30*12+30+3+6)
- /**
- * Stream information used internally by avformat_find_stream_info()
- */
- struct {
- int64_t last_dts;
- int64_t duration_gcd;
- int duration_count;
- int64_t rfps_duration_sum;
- double (*duration_error)2MAX_STD_TIMEBASES;
- int64_t codec_info_duration;
- int64_t codec_info_duration_fields;
- int frame_delay_evidence;
-
- /**
- * 0 -> decoder has not been searched for yet.
- * >0 -> decoder found
- * <0 -> decoder with codec_id == -found_decoder has not been found
- */
- int found_decoder;
-
- int64_t last_duration;
-
- /**
- * Those are used for average framerate estimation.
- */
- int64_t fps_first_dts;
- int fps_first_dts_idx;
- int64_t fps_last_dts;
- int fps_last_dts_idx;
-
- } *info;
-
- int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
-
- // Timestamp generation support:
- /**
- * Timestamp corresponding to the last dts sync point.
- *
- * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
- * a DTS is received from the underlying container. Otherwise set to
- * AV_NOPTS_VALUE by default.
- */
- int64_t first_dts;
- int64_t cur_dts;
- int64_t last_IP_pts;
- int last_IP_duration;
-
- /**
- * Number of packets to buffer for codec probing
- */
- int probe_packets;
-
- /**
- * Number of frames that have been demuxed during avformat_find_stream_info()
- */
- int codec_info_nb_frames;
-
- /* av_read_frame() support */
- enum AVStreamParseType need_parsing;
- struct AVCodecParserContext *parser;
-
- /**
- * last packet in packet_buffer for this stream when muxing.
- */
- struct AVPacketList *last_in_packet_buffer;
- AVProbeData probe_data;
-#define MAX_REORDER_DELAY 16
- int64_t pts_bufferMAX_REORDER_DELAY+1;
-
- AVIndexEntry *index_entries; /**< Only used if the format does not
- support seeking natively. */
- int nb_index_entries;
- unsigned int index_entries_allocated_size;
-
- /**
- * Stream Identifier
- * This is the MPEG-TS stream identifier +1
- * 0 means unknown
- */
- int stream_identifier;
-
- int64_t interleaver_chunk_size;
- int64_t interleaver_chunk_duration;
-
- /**
- * stream probing state
- * -1 -> probing finished
- * 0 -> no probing requested
- * rest -> perform probing with request_probe being the minimum score to accept.
- * NOT PART OF PUBLIC API
- */
- int request_probe;
- /**
- * Indicates that everything up to the next keyframe
- * should be discarded.
- */
- int skip_to_keyframe;
-
- /**
- * Number of samples to skip at the start of the frame decoded from the next packet.
- */
- int skip_samples;
-
- /**
- * If not 0, the number of samples that should be skipped from the start of
- * the stream (the samples are removed from packets with pts==0, which also
- * assumes negative timestamps do not happen).
- * Intended for use with formats such as mp3 with ad-hoc gapless audio
- * support.
- */
- int64_t start_skip_samples;
-
- /**
- * If not 0, the first audio sample that should be discarded from the stream.
- * This is broken by design (needs global sample count), but can't be
- * avoided for broken by design formats such as mp3 with ad-hoc gapless
- * audio support.
- */
- int64_t first_discard_sample;
-
- /**
- * The sample after last sample that is intended to be discarded after
- * first_discard_sample. Works on frame boundaries only. Used to prevent
- * early EOF if the gapless info is broken (considered concatenated mp3s).
- */
- int64_t last_discard_sample;
-
- /**
- * Number of internally decoded frames, used internally in libavformat, do not access
- * its lifetime differs from info which is why it is not in that structure.
- */
- int nb_decoded_frames;
-
- /**
- * Timestamp offset added to timestamps before muxing
- * NOT PART OF PUBLIC API
- */
- int64_t mux_ts_offset;
-
- /**
- * Internal data to check for wrapping of the time stamp
- */
- int64_t pts_wrap_reference;
-
- /**
- * Options for behavior, when a wrap is detected.
- *
- * Defined by AV_PTS_WRAP_ values.
- *
- * If correction is enabled, there are two possibilities:
- * If the first time stamp is near the wrap point, the wrap offset
- * will be subtracted, which will create negative time stamps.
- * Otherwise the offset will be added.
- */
- int pts_wrap_behavior;
-
- /**
- * Internal data to prevent doing update_initial_durations() twice
- */
- int update_initial_durations_done;
-
- /**
- * Internal data to generate dts from pts
- */
- int64_t pts_reorder_errorMAX_REORDER_DELAY+1;
- uint8_t pts_reorder_error_countMAX_REORDER_DELAY+1;
-
- /**
- * Internal data to analyze DTS and detect faulty mpeg streams
- */
- int64_t last_dts_for_order_check;
- uint8_t dts_ordered;
- uint8_t dts_misordered;
-
- /**
- * Internal data to inject global side data
- */
- int inject_global_side_data;
-
- /**
- * display aspect ratio (0 if unknown)
- * - encoding: unused
- * - decoding: Set by libavformat to calculate sample_aspect_ratio internally
- */
- AVRational display_aspect_ratio;
-
- /**
- * An opaque field for libavformat internal usage.
- * Must not be accessed in any way by callers.
- */
- AVStreamInternal *internal;
-} AVStream;
-
-#if FF_API_FORMAT_GET_SET
-/**
- * Accessors for some AVStream fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-AVRational av_stream_get_r_frame_rate(const AVStream *s);
-attribute_deprecated
-void av_stream_set_r_frame_rate(AVStream *s, AVRational r);
-#if FF_API_LAVF_FFSERVER
-attribute_deprecated
-char* av_stream_get_recommended_encoder_configuration(const AVStream *s);
-attribute_deprecated
-void av_stream_set_recommended_encoder_configuration(AVStream *s, char *configuration);
-#endif
-#endif
-
-struct AVCodecParserContext *av_stream_get_parser(const AVStream *s);
-
-/**
- * Returns the pts of the last muxed packet + its duration
- *
- * the retuned value is undefined when used with a demuxer.
- */
-int64_t av_stream_get_end_pts(const AVStream *st);
-
-#define AV_PROGRAM_RUNNING 1
-
-/**
- * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing fields require a major
- * version bump.
- * sizeof(AVProgram) must not be used outside libav*.
- */
-typedef struct AVProgram {
- int id;
- int flags;
- enum AVDiscard discard; ///< selects which program to discard and which to feed to the caller
- unsigned int *stream_index;
- unsigned int nb_stream_indexes;
- AVDictionary *metadata;
-
- int program_num;
- int pmt_pid;
- int pcr_pid;
-
- /*****************************************************************
- * All fields below this line are not part of the public API. They
- * may not be used outside of libavformat and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
- int64_t start_time;
- int64_t end_time;
-
- int64_t pts_wrap_reference; ///< reference dts for wrap detection
- int pts_wrap_behavior; ///< behavior on wrap detection
-} AVProgram;
-
-#define AVFMTCTX_NOHEADER 0x0001 /**< signal that no header is present
- (streams are added dynamically) */
-#define AVFMTCTX_UNSEEKABLE 0x0002 /**< signal that the stream is definitely
- not seekable, and attempts to call the
- seek function will fail. For some
- network protocols (e.g. HLS), this can
- change dynamically at runtime. */
-
-typedef struct AVChapter {
- int id; ///< unique ID to identify the chapter
- AVRational time_base; ///< time base in which the start/end timestamps are specified
- int64_t start, end; ///< chapter start/end time in time_base units
- AVDictionary *metadata;
-} AVChapter;
-
-
-/**
- * Callback used by devices to communicate with application.
- */
-typedef int (*av_format_control_message)(struct AVFormatContext *s, int type,
- void *data, size_t data_size);
-
-typedef int (*AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
- const AVIOInterruptCB *int_cb, AVDictionary **options);
-
-/**
- * The duration of a video can be estimated through various ways, and this enum can be used
- * to know how the duration was estimated.
- */
-enum AVDurationEstimationMethod {
- AVFMT_DURATION_FROM_PTS, ///< Duration accurately estimated from PTSes
- AVFMT_DURATION_FROM_STREAM, ///< Duration estimated from a stream with a known duration
- AVFMT_DURATION_FROM_BITRATE ///< Duration estimated from bitrate (less accurate)
-};
-
-typedef struct AVFormatInternal AVFormatInternal;
-
-/**
- * Format I/O context.
- * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing fields require a major
- * version bump.
- * sizeof(AVFormatContext) must not be used outside libav*, use
- * avformat_alloc_context() to create an AVFormatContext.
- *
- * Fields can be accessed through AVOptions (av_opt*),
- * the name string used matches the associated command line parameter name and
- * can be found in libavformat/options_table.h.
- * The AVOption/command line parameter names differ in some cases from the C
- * structure field names for historic reasons or brevity.
- */
-typedef struct AVFormatContext {
- /**
- * A class for logging and @ref avoptions. Set by avformat_alloc_context().
- * Exports (de)muxer private options if they exist.
- */
- const AVClass *av_class;
-
- /**
- * The input container format.
- *
- * Demuxing only, set by avformat_open_input().
- */
- struct AVInputFormat *iformat;
-
- /**
- * The output container format.
- *
- * Muxing only, must be set by the caller before avformat_write_header().
- */
- struct AVOutputFormat *oformat;
-
- /**
- * Format private data. This is an AVOptions-enabled struct
- * if and only if iformat/oformat.priv_class is not NULL.
- *
- * - muxing: set by avformat_write_header()
- * - demuxing: set by avformat_open_input()
- */
- void *priv_data;
-
- /**
- * I/O context.
- *
- * - demuxing: either set by the user before avformat_open_input() (then
- * the user must close it manually) or set by avformat_open_input().
- * - muxing: set by the user before avformat_write_header(). The caller must
- * take care of closing / freeing the IO context.
- *
- * Do NOT set this field if AVFMT_NOFILE flag is set in
- * iformat/oformat.flags. In such a case, the (de)muxer will handle
- * I/O in some other way and this field will be NULL.
- */
- AVIOContext *pb;
-
- /* stream info */
- /**
- * Flags signalling stream properties. A combination of AVFMTCTX_*.
- * Set by libavformat.
- */
- int ctx_flags;
-
- /**
- * Number of elements in AVFormatContext.streams.
- *
- * Set by avformat_new_stream(), must not be modified by any other code.
- */
- unsigned int nb_streams;
- /**
- * A list of all streams in the file. New streams are created with
- * avformat_new_stream().
- *
- * - demuxing: streams are created by libavformat in avformat_open_input().
- * If AVFMTCTX_NOHEADER is set in ctx_flags, then new streams may also
- * appear in av_read_frame().
- * - muxing: streams are created by the user before avformat_write_header().
- *
- * Freed by libavformat in avformat_free_context().
- */
- AVStream **streams;
-
-#if FF_API_FORMAT_FILENAME
- /**
- * input or output filename
- *
- * - demuxing: set by avformat_open_input()
- * - muxing: may be set by the caller before avformat_write_header()
- *
- * @deprecated Use url instead.
- */
- attribute_deprecated
- char filename1024;
-#endif
-
- /**
- * input or output URL. Unlike the old filename field, this field has no
- * length restriction.
- *
- * - demuxing: set by avformat_open_input(), initialized to an empty
- * string if url parameter was NULL in avformat_open_input().
- * - muxing: may be set by the caller before calling avformat_write_header()
- * (or avformat_init_output() if that is called first) to a string
- * which is freeable by av_free(). Set to an empty string if it
- * was NULL in avformat_init_output().
- *
- * Freed by libavformat in avformat_free_context().
- */
- char *url;
-
- /**
- * Position of the first frame of the component, in
- * AV_TIME_BASE fractional seconds. NEVER set this value directly:
- * It is deduced from the AVStream values.
- *
- * Demuxing only, set by libavformat.
- */
- int64_t start_time;
-
- /**
- * Duration of the stream, in AV_TIME_BASE fractional
- * seconds. Only set this value if you know none of the individual stream
- * durations and also do not set any of them. This is deduced from the
- * AVStream values if not set.
- *
- * Demuxing only, set by libavformat.
- */
- int64_t duration;
-
- /**
- * Total stream bitrate in bit/s, 0 if not
- * available. Never set it directly if the file_size and the
- * duration are known as FFmpeg can compute it automatically.
- */
- int64_t bit_rate;
-
- unsigned int packet_size;
- int max_delay;
-
- /**
- * Flags modifying the (de)muxer behaviour. A combination of AVFMT_FLAG_*.
- * Set by the user before avformat_open_input() / avformat_write_header().
- */
- int flags;
-#define AVFMT_FLAG_GENPTS 0x0001 ///< Generate missing pts even if it requires parsing future frames.
-#define AVFMT_FLAG_IGNIDX 0x0002 ///< Ignore index.
-#define AVFMT_FLAG_NONBLOCK 0x0004 ///< Do not block when reading packets from input.
-#define AVFMT_FLAG_IGNDTS 0x0008 ///< Ignore DTS on frames that contain both DTS & PTS
-#define AVFMT_FLAG_NOFILLIN 0x0010 ///< Do not infer any values from other values, just return what is stored in the container
-#define AVFMT_FLAG_NOPARSE 0x0020 ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled
-#define AVFMT_FLAG_NOBUFFER 0x0040 ///< Do not buffer frames when possible
-#define AVFMT_FLAG_CUSTOM_IO 0x0080 ///< The caller has supplied a custom AVIOContext, don't avio_close() it.
-#define AVFMT_FLAG_DISCARD_CORRUPT 0x0100 ///< Discard frames marked corrupted
-#define AVFMT_FLAG_FLUSH_PACKETS 0x0200 ///< Flush the AVIOContext every packet.
-/**
- * When muxing, try to avoid writing any random/volatile data to the output.
- * This includes any random IDs, real-time timestamps/dates, muxer version, etc.
- *
- * This flag is mainly intended for testing.
- */
-#define AVFMT_FLAG_BITEXACT 0x0400
-#define AVFMT_FLAG_MP4A_LATM 0x8000 ///< Enable RTP MP4A-LATM payload
-#define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
-#define AVFMT_FLAG_PRIV_OPT 0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
-#if FF_API_LAVF_KEEPSIDE_FLAG
-#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Deprecated, does nothing.
-#endif
-#define AVFMT_FLAG_FAST_SEEK 0x80000 ///< Enable fast, but inaccurate seeks for some formats
-#define AVFMT_FLAG_SHORTEST 0x100000 ///< Stop muxing when the shortest stream stops.
-#define AVFMT_FLAG_AUTO_BSF 0x200000 ///< Add bitstream filters as requested by the muxer
-
- /**
- * Maximum size of the data read from input for determining
- * the input container format.
- * Demuxing only, set by the caller before avformat_open_input().
- */
- int64_t probesize;
-
- /**
- * Maximum duration (in AV_TIME_BASE units) of the data read
- * from input in avformat_find_stream_info().
- * Demuxing only, set by the caller before avformat_find_stream_info().
- * Can be set to 0 to let avformat choose using a heuristic.
- */
- int64_t max_analyze_duration;
-
- const uint8_t *key;
- int keylen;
-
- unsigned int nb_programs;
- AVProgram **programs;
-
- /**
- * Forced video codec_id.
- * Demuxing: Set by user.
- */
- enum AVCodecID video_codec_id;
-
- /**
- * Forced audio codec_id.
- * Demuxing: Set by user.
- */
- enum AVCodecID audio_codec_id;
-
- /**
- * Forced subtitle codec_id.
- * Demuxing: Set by user.
- */
- enum AVCodecID subtitle_codec_id;
-
- /**
- * Maximum amount of memory in bytes to use for the index of each stream.
- * If the index exceeds this size, entries will be discarded as
- * needed to maintain a smaller size. This can lead to slower or less
- * accurate seeking (depends on demuxer).
- * Demuxers for which a full in-memory index is mandatory will ignore
- * this.
- * - muxing: unused
- * - demuxing: set by user
- */
- unsigned int max_index_size;
-
- /**
- * Maximum amount of memory in bytes to use for buffering frames
- * obtained from realtime capture devices.
- */
- unsigned int max_picture_buffer;
-
- /**
- * Number of chapters in AVChapter array.
- * When muxing, chapters are normally written in the file header,
- * so nb_chapters should normally be initialized before write_header
- * is called. Some muxers (e.g. mov and mkv) can also write chapters
- * in the trailer. To write chapters in the trailer, nb_chapters
- * must be zero when write_header is called and non-zero when
- * write_trailer is called.
- * - muxing: set by user
- * - demuxing: set by libavformat
- */
- unsigned int nb_chapters;
- AVChapter **chapters;
-
- /**
- * Metadata that applies to the whole file.
- *
- * - demuxing: set by libavformat in avformat_open_input()
- * - muxing: may be set by the caller before avformat_write_header()
- *
- * Freed by libavformat in avformat_free_context().
- */
- AVDictionary *metadata;
-
- /**
- * Start time of the stream in real world time, in microseconds
- * since the Unix epoch (00:00 1st January 1970). That is, pts=0 in the
- * stream was captured at this real world time.
- * - muxing: Set by the caller before avformat_write_header(). If set to
- * either 0 or AV_NOPTS_VALUE, then the current wall-time will
- * be used.
- * - demuxing: Set by libavformat. AV_NOPTS_VALUE if unknown. Note that
- * the value may become known after some number of frames
- * have been received.
- */
- int64_t start_time_realtime;
-
- /**
- * The number of frames used for determining the framerate in
- * avformat_find_stream_info().
- * Demuxing only, set by the caller before avformat_find_stream_info().
- */
- int fps_probe_size;
-
- /**
- * Error recognition; higher values will detect more errors but may
- * misdetect some more or less valid parts as errors.
- * Demuxing only, set by the caller before avformat_open_input().
- */
- int error_recognition;
-
- /**
- * Custom interrupt callbacks for the I/O layer.
- *
- * demuxing: set by the user before avformat_open_input().
- * muxing: set by the user before avformat_write_header()
- * (mainly useful for AVFMT_NOFILE formats). The callback
- * should also be passed to avio_open2() if it's used to
- * open the file.
- */
- AVIOInterruptCB interrupt_callback;
-
- /**
- * Flags to enable debugging.
- */
- int debug;
-#define FF_FDEBUG_TS 0x0001
-
- /**
- * Maximum buffering duration for interleaving.
- *
- * To ensure all the streams are interleaved correctly,
- * av_interleaved_write_frame() will wait until it has at least one packet
- * for each stream before actually writing any packets to the output file.
- * When some streams are "sparse" (i.e. there are large gaps between
- * successive packets), this can result in excessive buffering.
- *
- * This field specifies the maximum difference between the timestamps of the
- * first and the last packet in the muxing queue, above which libavformat
- * will output a packet regardless of whether it has queued a packet for all
- * the streams.
- *
- * Muxing only, set by the caller before avformat_write_header().
- */
- int64_t max_interleave_delta;
-
- /**
- * Allow non-standard and experimental extension
- * @see AVCodecContext.strict_std_compliance
- */
- int strict_std_compliance;
-
- /**
- * Flags for the user to detect events happening on the file. Flags must
- * be cleared by the user once the event has been handled.
- * A combination of AVFMT_EVENT_FLAG_*.
- */
- int event_flags;
-#define AVFMT_EVENT_FLAG_METADATA_UPDATED 0x0001 ///< The call resulted in updated metadata.
-
- /**
- * Maximum number of packets to read while waiting for the first timestamp.
- * Decoding only.
- */
- int max_ts_probe;
-
- /**
- * Avoid negative timestamps during muxing.
- * Any value of the AVFMT_AVOID_NEG_TS_* constants.
- * Note, this only works when using av_interleaved_write_frame. (interleave_packet_per_dts is in use)
- * - muxing: Set by user
- * - demuxing: unused
- */
- int avoid_negative_ts;
-#define AVFMT_AVOID_NEG_TS_AUTO -1 ///< Enabled when required by target format
-#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE 1 ///< Shift timestamps so they are non negative
-#define AVFMT_AVOID_NEG_TS_MAKE_ZERO 2 ///< Shift timestamps so that they start at 0
-
- /**
- * Transport stream id.
- * This will be moved into demuxer private options. Thus no API/ABI compatibility
- */
- int ts_id;
-
- /**
- * Audio preload in microseconds.
- * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
- * - encoding: Set by user
- * - decoding: unused
- */
- int audio_preload;
-
- /**
- * Max chunk time in microseconds.
- * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
- * - encoding: Set by user
- * - decoding: unused
- */
- int max_chunk_duration;
-
- /**
- * Max chunk size in bytes
- * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
- * - encoding: Set by user
- * - decoding: unused
- */
- int max_chunk_size;
-
- /**
- * forces the use of wallclock timestamps as pts/dts of packets
- * This has undefined results in the presence of B frames.
- * - encoding: unused
- * - decoding: Set by user
- */
- int use_wallclock_as_timestamps;
-
- /**
- * avio flags, used to force AVIO_FLAG_DIRECT.
- * - encoding: unused
- * - decoding: Set by user
- */
- int avio_flags;
-
- /**
- * The duration field can be estimated through various ways, and this field can be used
- * to know how the duration was estimated.
- * - encoding: unused
- * - decoding: Read by user
- */
- enum AVDurationEstimationMethod duration_estimation_method;
-
- /**
- * Skip initial bytes when opening stream
- * - encoding: unused
- * - decoding: Set by user
- */
- int64_t skip_initial_bytes;
-
- /**
- * Correct single timestamp overflows
- * - encoding: unused
- * - decoding: Set by user
- */
- unsigned int correct_ts_overflow;
-
- /**
- * Force seeking to any (also non key) frames.
- * - encoding: unused
- * - decoding: Set by user
- */
- int seek2any;
-
- /**
- * Flush the I/O context after each packet.
- * - encoding: Set by user
- * - decoding: unused
- */
- int flush_packets;
-
- /**
- * format probing score.
- * The maximal score is AVPROBE_SCORE_MAX, its set when the demuxer probes
- * the format.
- * - encoding: unused
- * - decoding: set by avformat, read by user
- */
- int probe_score;
-
- /**
- * number of bytes to read maximally to identify format.
- * - encoding: unused
- * - decoding: set by user
- */
- int format_probesize;
-
- /**
- * ',' separated list of allowed decoders.
- * If NULL then all are allowed
- * - encoding: unused
- * - decoding: set by user
- */
- char *codec_whitelist;
-
- /**
- * ',' separated list of allowed demuxers.
- * If NULL then all are allowed
- * - encoding: unused
- * - decoding: set by user
- */
- char *format_whitelist;
-
- /**
- * An opaque field for libavformat internal usage.
- * Must not be accessed in any way by callers.
- */
- AVFormatInternal *internal;
-
- /**
- * IO repositioned flag.
- * This is set by avformat when the underlaying IO context read pointer
- * is repositioned, for example when doing byte based seeking.
- * Demuxers can use the flag to detect such changes.
- */
- int io_repositioned;
-
- /**
- * Forced video codec.
- * This allows forcing a specific decoder, even when there are multiple with
- * the same codec_id.
- * Demuxing: Set by user
- */
- AVCodec *video_codec;
-
- /**
- * Forced audio codec.
- * This allows forcing a specific decoder, even when there are multiple with
- * the same codec_id.
- * Demuxing: Set by user
- */
- AVCodec *audio_codec;
-
- /**
- * Forced subtitle codec.
- * This allows forcing a specific decoder, even when there are multiple with
- * the same codec_id.
- * Demuxing: Set by user
- */
- AVCodec *subtitle_codec;
-
- /**
- * Forced data codec.
- * This allows forcing a specific decoder, even when there are multiple with
- * the same codec_id.
- * Demuxing: Set by user
- */
- AVCodec *data_codec;
-
- /**
- * Number of bytes to be written as padding in a metadata header.
- * Demuxing: Unused.
- * Muxing: Set by user via av_format_set_metadata_header_padding.
- */
- int metadata_header_padding;
-
- /**
- * User data.
- * This is a place for some private data of the user.
- */
- void *opaque;
-
- /**
- * Callback used by devices to communicate with application.
- */
- av_format_control_message control_message_cb;
-
- /**
- * Output timestamp offset, in microseconds.
- * Muxing: set by user
- */
- int64_t output_ts_offset;
-
- /**
- * dump format separator.
- * can be ", " or "\n " or anything else
- * - muxing: Set by user.
- * - demuxing: Set by user.
- */
- uint8_t *dump_separator;
-
- /**
- * Forced Data codec_id.
- * Demuxing: Set by user.
- */
- enum AVCodecID data_codec_id;
-
-#if FF_API_OLD_OPEN_CALLBACKS
- /**
- * Called to open further IO contexts when needed for demuxing.
- *
- * This can be set by the user application to perform security checks on
- * the URLs before opening them.
- * The function should behave like avio_open2(), AVFormatContext is provided
- * as contextual information and to reach AVFormatContext.opaque.
- *
- * If NULL then some simple checks are used together with avio_open2().
- *
- * Must not be accessed directly from outside avformat.
- * @See av_format_set_open_cb()
- *
- * Demuxing: Set by user.
- *
- * @deprecated Use io_open and io_close.
- */
- attribute_deprecated
- int (*open_cb)(struct AVFormatContext *s, AVIOContext **p, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options);
-#endif
-
- /**
- * ',' separated list of allowed protocols.
- * - encoding: unused
- * - decoding: set by user
- */
- char *protocol_whitelist;
-
- /**
- * A callback for opening new IO streams.
- *
- * Whenever a muxer or a demuxer needs to open an IO stream (typically from
- * avformat_open_input() for demuxers, but for certain formats can happen at
- * other times as well), it will call this callback to obtain an IO context.
- *
- * @param s the format context
- * @param pb on success, the newly opened IO context should be returned here
- * @param url the url to open
- * @param flags a combination of AVIO_FLAG_*
- * @param options a dictionary of additional options, with the same
- * semantics as in avio_open2()
- * @return 0 on success, a negative AVERROR code on failure
- *
- * @note Certain muxers and demuxers do nesting, i.e. they open one or more
- * additional internal format contexts. Thus the AVFormatContext pointer
- * passed to this callback may be different from the one facing the caller.
- * It will, however, have the same 'opaque' field.
- */
- int (*io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url,
- int flags, AVDictionary **options);
-
- /**
- * A callback for closing the streams opened with AVFormatContext.io_open().
- */
- void (*io_close)(struct AVFormatContext *s, AVIOContext *pb);
-
- /**
- * ',' separated list of disallowed protocols.
- * - encoding: unused
- * - decoding: set by user
- */
- char *protocol_blacklist;
-
- /**
- * The maximum number of streams.
- * - encoding: unused
- * - decoding: set by user
- */
- int max_streams;
-} AVFormatContext;
-
-#if FF_API_FORMAT_GET_SET
-/**
- * Accessors for some AVFormatContext fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-int av_format_get_probe_score(const AVFormatContext *s);
-attribute_deprecated
-AVCodec * av_format_get_video_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_video_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-AVCodec * av_format_get_audio_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_audio_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-AVCodec * av_format_get_subtitle_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-AVCodec * av_format_get_data_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_data_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-int av_format_get_metadata_header_padding(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_metadata_header_padding(AVFormatContext *s, int c);
-attribute_deprecated
-void * av_format_get_opaque(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_opaque(AVFormatContext *s, void *opaque);
-attribute_deprecated
-av_format_control_message av_format_get_control_message_cb(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_control_message_cb(AVFormatContext *s, av_format_control_message callback);
-#if FF_API_OLD_OPEN_CALLBACKS
-attribute_deprecated AVOpenCallback av_format_get_open_cb(const AVFormatContext *s);
-attribute_deprecated void av_format_set_open_cb(AVFormatContext *s, AVOpenCallback callback);
-#endif
-#endif
-
-/**
- * This function will cause global side data to be injected in the next packet
- * of each stream as well as after any subsequent seek.
- */
-void av_format_inject_global_side_data(AVFormatContext *s);
-
-/**
- * Returns the method used to set ctx->duration.
- *
- * @return AVFMT_DURATION_FROM_PTS, AVFMT_DURATION_FROM_STREAM, or AVFMT_DURATION_FROM_BITRATE.
- */
-enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method(const AVFormatContext* ctx);
-
-typedef struct AVPacketList {
- AVPacket pkt;
- struct AVPacketList *next;
-} AVPacketList;
-
-
-/**
- * @defgroup lavf_core Core functions
- * @ingroup libavf
- *
- * Functions for querying libavformat capabilities, allocating core structures,
- * etc.
- * @{
- */
-
-/**
- * Return the LIBAVFORMAT_VERSION_INT constant.
- */
-unsigned avformat_version(void);
-
-/**
- * Return the libavformat build-time configuration.
- */
-const char *avformat_configuration(void);
-
-/**
- * Return the libavformat license.
- */
-const char *avformat_license(void);
-
-#if FF_API_NEXT
-/**
- * Initialize libavformat and register all the muxers, demuxers and
- * protocols. If you do not call this function, then you can select
- * exactly which formats you want to support.
- *
- * @see av_register_input_format()
- * @see av_register_output_format()
- */
-attribute_deprecated
-void av_register_all(void);
-
-attribute_deprecated
-void av_register_input_format(AVInputFormat *format);
-attribute_deprecated
-void av_register_output_format(AVOutputFormat *format);
-#endif
-
-/**
- * Do global initialization of network libraries. This is optional,
- * and not recommended anymore.
- *
- * This functions only exists to work around thread-safety issues
- * with older GnuTLS or OpenSSL libraries. If libavformat is linked
- * to newer versions of those libraries, or if you do not use them,
- * calling this function is unnecessary. Otherwise, you need to call
- * this function before any other threads using them are started.
- *
- * This function will be deprecated once support for older GnuTLS and
- * OpenSSL libraries is removed, and this function has no purpose
- * anymore.
- */
-int avformat_network_init(void);
-
-/**
- * Undo the initialization done by avformat_network_init. Call it only
- * once for each time you called avformat_network_init.
- */
-int avformat_network_deinit(void);
-
-#if FF_API_NEXT
-/**
- * If f is NULL, returns the first registered input format,
- * if f is non-NULL, returns the next registered input format after f
- * or NULL if f is the last one.
- */
-attribute_deprecated
-AVInputFormat *av_iformat_next(const AVInputFormat *f);
-
-/**
- * If f is NULL, returns the first registered output format,
- * if f is non-NULL, returns the next registered output format after f
- * or NULL if f is the last one.
- */
-attribute_deprecated
-AVOutputFormat *av_oformat_next(const AVOutputFormat *f);
-#endif
-
-/**
- * Iterate over all registered muxers.
- *
- * @param opaque a pointer where libavformat will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered muxer or NULL when the iteration is
- * finished
- */
-const AVOutputFormat *av_muxer_iterate(void **opaque);
-
-/**
- * Iterate over all registered demuxers.
- *
- * @param opaque a pointer where libavformat will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered demuxer or NULL when the iteration is
- * finished
- */
-const AVInputFormat *av_demuxer_iterate(void **opaque);
-
-/**
- * Allocate an AVFormatContext.
- * avformat_free_context() can be used to free the context and everything
- * allocated by the framework within it.
- */
-AVFormatContext *avformat_alloc_context(void);
-
-/**
- * Free an AVFormatContext and all its streams.
- * @param s context to free
- */
-void avformat_free_context(AVFormatContext *s);
-
-/**
- * Get the AVClass for AVFormatContext. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- */
-const AVClass *avformat_get_class(void);
-
-/**
- * Add a new stream to a media file.
- *
- * When demuxing, it is called by the demuxer in read_header(). If the
- * flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also
- * be called in read_packet().
- *
- * When muxing, should be called by the user before avformat_write_header().
- *
- * User is required to call avcodec_close() and avformat_free_context() to
- * clean up the allocation by avformat_new_stream().
- *
- * @param s media file handle
- * @param c If non-NULL, the AVCodecContext corresponding to the new stream
- * will be initialized to use this codec. This is needed for e.g. codec-specific
- * defaults to be set, so codec should be provided if it is known.
- *
- * @return newly created stream or NULL on error.
- */
-AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c);
-
-/**
- * Wrap an existing array as stream side data.
- *
- * @param st stream
- * @param type side information type
- * @param data the side data array. It must be allocated with the av_malloc()
- * family of functions. The ownership of the data is transferred to
- * st.
- * @param size side information size
- * @return zero on success, a negative AVERROR code on failure. On failure,
- * the stream is unchanged and the data remains owned by the caller.
- */
-int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
- uint8_t *data, size_t size);
-
-/**
- * Allocate new information from stream.
- *
- * @param stream stream
- * @param type desired side information type
- * @param size side information size
- * @return pointer to fresh allocated data or NULL otherwise
- */
-uint8_t *av_stream_new_side_data(AVStream *stream,
- enum AVPacketSideDataType type, int size);
-/**
- * Get side information from stream.
- *
- * @param stream stream
- * @param type desired side information type
- * @param size pointer for side information size to store (optional)
- * @return pointer to data if present or NULL otherwise
- */
-uint8_t *av_stream_get_side_data(const AVStream *stream,
- enum AVPacketSideDataType type, int *size);
-
-AVProgram *av_new_program(AVFormatContext *s, int id);
-
-/**
- * @}
- */
-
-
-/**
- * Allocate an AVFormatContext for an output format.
- * avformat_free_context() can be used to free the context and
- * everything allocated by the framework within it.
- *
- * @param *ctx is set to the created format context, or to NULL in
- * case of failure
- * @param oformat format to use for allocating the context, if NULL
- * format_name and filename are used instead
- * @param format_name the name of output format to use for allocating the
- * context, if NULL filename is used instead
- * @param filename the name of the filename to use for allocating the
- * context, may be NULL
- * @return >= 0 in case of success, a negative AVERROR code in case of
- * failure
- */
-int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat,
- const char *format_name, const char *filename);
-
-/**
- * @addtogroup lavf_decoding
- * @{
- */
-
-/**
- * Find AVInputFormat based on the short name of the input format.
- */
-AVInputFormat *av_find_input_format(const char *short_name);
-
-/**
- * Guess the file format.
- *
- * @param pd data to be probed
- * @param is_opened Whether the file is already opened; determines whether
- * demuxers with or without AVFMT_NOFILE are probed.
- */
-AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);
-
-/**
- * Guess the file format.
- *
- * @param pd data to be probed
- * @param is_opened Whether the file is already opened; determines whether
- * demuxers with or without AVFMT_NOFILE are probed.
- * @param score_max A probe score larger that this is required to accept a
- * detection, the variable is set to the actual detection
- * score afterwards.
- * If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended
- * to retry with a larger probe buffer.
- */
-AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max);
-
-/**
- * Guess the file format.
- *
- * @param is_opened Whether the file is already opened; determines whether
- * demuxers with or without AVFMT_NOFILE are probed.
- * @param score_ret The score of the best detection.
- */
-AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret);
-
-/**
- * Probe a bytestream to determine the input format. Each time a probe returns
- * with a score that is too low, the probe buffer size is increased and another
- * attempt is made. When the maximum probe size is reached, the input format
- * with the highest score is returned.
- *
- * @param pb the bytestream to probe
- * @param fmt the input format is put here
- * @param url the url of the stream
- * @param logctx the log context
- * @param offset the offset within the bytestream to probe from
- * @param max_probe_size the maximum probe buffer size (zero for default)
- * @return the score in case of success, a negative value corresponding to an
- * the maximal score is AVPROBE_SCORE_MAX
- * AVERROR code otherwise
- */
-int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
- const char *url, void *logctx,
- unsigned int offset, unsigned int max_probe_size);
-
-/**
- * Like av_probe_input_buffer2() but returns 0 on success
- */
-int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
- const char *url, void *logctx,
- unsigned int offset, unsigned int max_probe_size);
-
-/**
- * Open an input stream and read the header. The codecs are not opened.
- * The stream must be closed with avformat_close_input().
- *
- * @param ps Pointer to user-supplied AVFormatContext (allocated by avformat_alloc_context).
- * May be a pointer to NULL, in which case an AVFormatContext is allocated by this
- * function and written into ps.
- * Note that a user-supplied AVFormatContext will be freed on failure.
- * @param url URL of the stream to open.
- * @param fmt If non-NULL, this parameter forces a specific input format.
- * Otherwise the format is autodetected.
- * @param options A dictionary filled with AVFormatContext and demuxer-private options.
- * On return this parameter will be destroyed and replaced with a dict containing
- * options that were not found. May be NULL.
- *
- * @return 0 on success, a negative AVERROR on failure.
- *
- * @note If you want to use custom IO, preallocate the format context and set its pb field.
- */
-int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options);
-
-attribute_deprecated
-int av_demuxer_open(AVFormatContext *ic);
-
-/**
- * Read packets of a media file to get stream information. This
- * is useful for file formats with no headers such as MPEG. This
- * function also computes the real framerate in case of MPEG-2 repeat
- * frame mode.
- * The logical file position is not changed by this function;
- * examined packets may be buffered for later processing.
- *
- * @param ic media file handle
- * @param options If non-NULL, an ic.nb_streams long array of pointers to
- * dictionaries, where i-th member contains options for
- * codec corresponding to i-th stream.
- * On return each dictionary will be filled with options that were not found.
- * @return >=0 if OK, AVERROR_xxx on error
- *
- * @note this function isn't guaranteed to open all the codecs, so
- * options being non-empty at return is a perfectly normal behavior.
- *
- * @todo Let the user decide somehow what information is needed so that
- * we do not waste time getting stuff the user does not need.
- */
-int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
-
-/**
- * Find the programs which belong to a given stream.
- *
- * @param ic media file handle
- * @param last the last found program, the search will start after this
- * program, or from the beginning if it is NULL
- * @param s stream index
- * @return the next program which belongs to s, NULL if no program is found or
- * the last program is not among the programs of ic.
- */
-AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s);
-
-void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx);
-
-/**
- * Find the "best" stream in the file.
- * The best stream is determined according to various heuristics as the most
- * likely to be what the user expects.
- * If the decoder parameter is non-NULL, av_find_best_stream will find the
- * default decoder for the stream's codec; streams for which no decoder can
- * be found are ignored.
- *
- * @param ic media file handle
- * @param type stream type: video, audio, subtitles, etc.
- * @param wanted_stream_nb user-requested stream number,
- * or -1 for automatic selection
- * @param related_stream try to find a stream related (eg. in the same
- * program) to this one, or -1 if none
- * @param decoder_ret if non-NULL, returns the decoder for the
- * selected stream
- * @param flags flags; none are currently defined
- * @return the non-negative stream number in case of success,
- * AVERROR_STREAM_NOT_FOUND if no stream with the requested type
- * could be found,
- * AVERROR_DECODER_NOT_FOUND if streams were found but no decoder
- * @note If av_find_best_stream returns successfully and decoder_ret is not
- * NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec.
- */
-int av_find_best_stream(AVFormatContext *ic,
- enum AVMediaType type,
- int wanted_stream_nb,
- int related_stream,
- AVCodec **decoder_ret,
- int flags);
-
-/**
- * Return the next frame of a stream.
- * This function returns what is stored in the file, and does not validate
- * that what is there are valid frames for the decoder. It will split what is
- * stored in the file into frames and return one for each call. It will not
- * omit invalid data between valid frames so as to give the decoder the maximum
- * information possible for decoding.
- *
- * If pkt->buf is NULL, then the packet is valid until the next
- * av_read_frame() or until avformat_close_input(). Otherwise the packet
- * is valid indefinitely. In both cases the packet must be freed with
- * av_packet_unref when it is no longer needed. For video, the packet contains
- * exactly one frame. For audio, it contains an integer number of frames if each
- * frame has a known fixed size (e.g. PCM or ADPCM data). If the audio frames
- * have a variable size (e.g. MPEG audio), then it contains one frame.
- *
- * pkt->pts, pkt->dts and pkt->duration are always set to correct
- * values in AVStream.time_base units (and guessed if the format cannot
- * provide them). pkt->pts can be AV_NOPTS_VALUE if the video format
- * has B-frames, so it is better to rely on pkt->dts if you do not
- * decompress the payload.
- *
- * @return 0 if OK, < 0 on error or end of file
- */
-int av_read_frame(AVFormatContext *s, AVPacket *pkt);
-
-/**
- * Seek to the keyframe at timestamp.
- * 'timestamp' in 'stream_index'.
- *
- * @param s media file handle
- * @param stream_index If stream_index is (-1), a default
- * stream is selected, and timestamp is automatically converted
- * from AV_TIME_BASE units to the stream specific time_base.
- * @param timestamp Timestamp in AVStream.time_base units
- * or, if no stream is specified, in AV_TIME_BASE units.
- * @param flags flags which select direction and seeking mode
- * @return >= 0 on success
- */
-int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
- int flags);
-
-/**
- * Seek to timestamp ts.
- * Seeking will be done so that the point from which all active streams
- * can be presented successfully will be closest to ts and within min/max_ts.
- * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
- *
- * If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in bytes and
- * are the file position (this may not be supported by all demuxers).
- * If flags contain AVSEEK_FLAG_FRAME, then all timestamps are in frames
- * in the stream with stream_index (this may not be supported by all demuxers).
- * Otherwise all timestamps are in units of the stream selected by stream_index
- * or if stream_index is -1, in AV_TIME_BASE units.
- * If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as
- * keyframes (this may not be supported by all demuxers).
- * If flags contain AVSEEK_FLAG_BACKWARD, it is ignored.
- *
- * @param s media file handle
- * @param stream_index index of the stream which is used as time base reference
- * @param min_ts smallest acceptable timestamp
- * @param ts target timestamp
- * @param max_ts largest acceptable timestamp
- * @param flags flags
- * @return >=0 on success, error code otherwise
- *
- * @note This is part of the new seek API which is still under construction.
- * Thus do not use this yet. It may change at any time, do not expect
- * ABI compatibility yet!
- */
-int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
-
-/**
- * Discard all internally buffered data. This can be useful when dealing with
- * discontinuities in the byte stream. Generally works only with formats that
- * can resync. This includes headerless formats like MPEG-TS/TS but should also
- * work with NUT, Ogg and in a limited way AVI for example.
- *
- * The set of streams, the detected duration, stream parameters and codecs do
- * not change when calling this function. If you want a complete reset, it's
- * better to open a new AVFormatContext.
- *
- * This does not flush the AVIOContext (s->pb). If necessary, call
- * avio_flush(s->pb) before calling this function.
- *
- * @param s media file handle
- * @return >=0 on success, error code otherwise
- */
-int avformat_flush(AVFormatContext *s);
-
-/**
- * Start playing a network-based stream (e.g. RTSP stream) at the
- * current position.
- */
-int av_read_play(AVFormatContext *s);
-
-/**
- * Pause a network-based stream (e.g. RTSP stream).
- *
- * Use av_read_play() to resume it.
- */
-int av_read_pause(AVFormatContext *s);
-
-/**
- * Close an opened input AVFormatContext. Free it and all its contents
- * and set *s to NULL.
- */
-void avformat_close_input(AVFormatContext **s);
-/**
- * @}
- */
-
-#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
-#define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
-#define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non-keyframes
-#define AVSEEK_FLAG_FRAME 8 ///< seeking based on frame number
-
-/**
- * @addtogroup lavf_encoding
- * @{
- */
-
-#define AVSTREAM_INIT_IN_WRITE_HEADER 0 ///< stream parameters initialized in avformat_write_header
-#define AVSTREAM_INIT_IN_INIT_OUTPUT 1 ///< stream parameters initialized in avformat_init_output
-
-/**
- * Allocate the stream private data and write the stream header to
- * an output media file.
- *
- * @param s Media file handle, must be allocated with avformat_alloc_context().
- * Its oformat field must be set to the desired output format;
- * Its pb field must be set to an already opened AVIOContext.
- * @param options An AVDictionary filled with AVFormatContext and muxer-private options.
- * On return this parameter will be destroyed and replaced with a dict containing
- * options that were not found. May be NULL.
- *
- * @return AVSTREAM_INIT_IN_WRITE_HEADER on success if the codec had not already been fully initialized in avformat_init,
- * AVSTREAM_INIT_IN_INIT_OUTPUT on success if the codec had already been fully initialized in avformat_init,
- * negative AVERROR on failure.
- *
- * @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_init_output.
- */
-av_warn_unused_result
-int avformat_write_header(AVFormatContext *s, AVDictionary **options);
-
-/**
- * Allocate the stream private data and initialize the codec, but do not write the header.
- * May optionally be used before avformat_write_header to initialize stream parameters
- * before actually writing the header.
- * If using this function, do not pass the same options to avformat_write_header.
- *
- * @param s Media file handle, must be allocated with avformat_alloc_context().
- * Its oformat field must be set to the desired output format;
- * Its pb field must be set to an already opened AVIOContext.
- * @param options An AVDictionary filled with AVFormatContext and muxer-private options.
- * On return this parameter will be destroyed and replaced with a dict containing
- * options that were not found. May be NULL.
- *
- * @return AVSTREAM_INIT_IN_WRITE_HEADER on success if the codec requires avformat_write_header to fully initialize,
- * AVSTREAM_INIT_IN_INIT_OUTPUT on success if the codec has been fully initialized,
- * negative AVERROR on failure.
- *
- * @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_write_header.
- */
-av_warn_unused_result
-int avformat_init_output(AVFormatContext *s, AVDictionary **options);
-
-/**
- * Write a packet to an output media file.
- *
- * This function passes the packet directly to the muxer, without any buffering
- * or reordering. The caller is responsible for correctly interleaving the
- * packets if the format requires it. Callers that want libavformat to handle
- * the interleaving should call av_interleaved_write_frame() instead of this
- * function.
- *
- * @param s media file handle
- * @param pkt The packet containing the data to be written. Note that unlike
- * av_interleaved_write_frame(), this function does not take
- * ownership of the packet passed to it (though some muxers may make
- * an internal reference to the input packet).
- * 
- * This parameter can be NULL (at any time, not just at the end), in
- * order to immediately flush data buffered within the muxer, for
- * muxers that buffer up data internally before writing it to the
- * output.
- * 
- * Packet's @ref AVPacket.stream_index "stream_index" field must be
- * set to the index of the corresponding stream in @ref
- * AVFormatContext.streams "s->streams".
- * 
- * The timestamps (@ref AVPacket.pts "pts", @ref AVPacket.dts "dts")
- * must be set to correct values in the stream's timebase (unless the
- * output format is flagged with the AVFMT_NOTIMESTAMPS flag, then
- * they can be set to AV_NOPTS_VALUE).
- * The dts for subsequent packets passed to this function must be strictly
- * increasing when compared in their respective timebases (unless the
- * output format is flagged with the AVFMT_TS_NONSTRICT, then they
- * merely have to be nondecreasing). @ref AVPacket.duration
- * "duration") should also be set if known.
- * @return < 0 on error, = 0 if OK, 1 if flushed and there is no more data to flush
- *
- * @see av_interleaved_write_frame()
- */
-int av_write_frame(AVFormatContext *s, AVPacket *pkt);
-
-/**
- * Write a packet to an output media file ensuring correct interleaving.
- *
- * This function will buffer the packets internally as needed to make sure the
- * packets in the output file are properly interleaved in the order of
- * increasing dts. Callers doing their own interleaving should call
- * av_write_frame() instead of this function.
- *
- * Using this function instead of av_write_frame() can give muxers advance
- * knowledge of future packets, improving e.g. the behaviour of the mp4
- * muxer for VFR content in fragmenting mode.
- *
- * @param s media file handle
- * @param pkt The packet containing the data to be written.
- * 
- * If the packet is reference-counted, this function will take
- * ownership of this reference and unreference it later when it sees
- * fit.
- * The caller must not access the data through this reference after
- * this function returns. If the packet is not reference-counted,
- * libavformat will make a copy.
- * 
- * This parameter can be NULL (at any time, not just at the end), to
- * flush the interleaving queues.
- * 
- * Packet's @ref AVPacket.stream_index "stream_index" field must be
- * set to the index of the corresponding stream in @ref
- * AVFormatContext.streams "s->streams".
- * 
- * The timestamps (@ref AVPacket.pts "pts", @ref AVPacket.dts "dts")
- * must be set to correct values in the stream's timebase (unless the
- * output format is flagged with the AVFMT_NOTIMESTAMPS flag, then
- * they can be set to AV_NOPTS_VALUE).
- * The dts for subsequent packets in one stream must be strictly
- * increasing (unless the output format is flagged with the
- * AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing).
- * @ref AVPacket.duration "duration") should also be set if known.
- *
- * @return 0 on success, a negative AVERROR on error. Libavformat will always
- * take care of freeing the packet, even if this function fails.
- *
- * @see av_write_frame(), AVFormatContext.max_interleave_delta
- */
-int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
-
-/**
- * Write an uncoded frame to an output media file.
- *
- * The frame must be correctly interleaved according to the container
- * specification; if not, then av_interleaved_write_frame() must be used.
- *
- * See av_interleaved_write_frame() for details.
- */
-int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
- AVFrame *frame);
-
-/**
- * Write an uncoded frame to an output media file.
- *
- * If the muxer supports it, this function makes it possible to write an AVFrame
- * structure directly, without encoding it into a packet.
- * It is mostly useful for devices and similar special muxers that use raw
- * video or PCM data and will not serialize it into a byte stream.
- *
- * To test whether it is possible to use it with a given muxer and stream,
- * use av_write_uncoded_frame_query().
- *
- * The caller gives up ownership of the frame and must not access it
- * afterwards.
- *
- * @return >=0 for success, a negative code on error
- */
-int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index,
- AVFrame *frame);
-
-/**
- * Test whether a muxer supports uncoded frame.
- *
- * @return >=0 if an uncoded frame can be written to that muxer and stream,
- * <0 if not
- */
-int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index);
-
-/**
- * Write the stream trailer to an output media file and free the
- * file private data.
- *
- * May only be called after a successful call to avformat_write_header.
- *
- * @param s media file handle
- * @return 0 if OK, AVERROR_xxx on error
- */
-int av_write_trailer(AVFormatContext *s);
-
-/**
- * Return the output format in the list of registered output formats
- * which best matches the provided parameters, or return NULL if
- * there is no match.
- *
- * @param short_name if non-NULL checks if short_name matches with the
- * names of the registered formats
- * @param filename if non-NULL checks if filename terminates with the
- * extensions of the registered formats
- * @param mime_type if non-NULL checks if mime_type matches with the
- * MIME type of the registered formats
- */
-AVOutputFormat *av_guess_format(const char *short_name,
- const char *filename,
- const char *mime_type);
-
-/**
- * Guess the codec ID based upon muxer and filename.
- */
-enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
- const char *filename, const char *mime_type,
- enum AVMediaType type);
-
-/**
- * Get timing information for the data currently output.
- * The exact meaning of "currently output" depends on the format.
- * It is mostly relevant for devices that have an internal buffer and/or
- * work in real time.
- * @param s media file handle
- * @param stream stream in the media file
- * @paramout dts DTS of the last packet output for the stream, in stream
- * time_base units
- * @paramout wall absolute time when that packet whas output,
- * in microsecond
- * @return 0 if OK, AVERROR(ENOSYS) if the format does not support it
- * Note: some formats or devices may not allow to measure dts and wall
- * atomically.
- */
-int av_get_output_timestamp(struct AVFormatContext *s, int stream,
- int64_t *dts, int64_t *wall);
-
-
-/**
- * @}
- */
-
-
-/**
- * @defgroup lavf_misc Utility functions
- * @ingroup libavf
- * @{
- *
- * Miscellaneous utility functions related to both muxing and demuxing
- * (or neither).
- */
-
-/**
- * Send a nice hexadecimal dump of a buffer to the specified file stream.
- *
- * @param f The file stream pointer where the dump should be sent to.
- * @param buf buffer
- * @param size buffer size
- *
- * @see av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2
- */
-void av_hex_dump(FILE *f, const uint8_t *buf, int size);
-
-/**
- * Send a nice hexadecimal dump of a buffer to the log.
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- * pointer to an AVClass struct.
- * @param level The importance level of the message, lower values signifying
- * higher importance.
- * @param buf buffer
- * @param size buffer size
- *
- * @see av_hex_dump, av_pkt_dump2, av_pkt_dump_log2
- */
-void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size);
-
-/**
- * Send a nice dump of a packet to the specified file stream.
- *
- * @param f The file stream pointer where the dump should be sent to.
- * @param pkt packet to dump
- * @param dump_payload True if the payload must be displayed, too.
- * @param st AVStream that the packet belongs to
- */
-void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st);
-
-
-/**
- * Send a nice dump of a packet to the log.
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- * pointer to an AVClass struct.
- * @param level The importance level of the message, lower values signifying
- * higher importance.
- * @param pkt packet to dump
- * @param dump_payload True if the payload must be displayed, too.
- * @param st AVStream that the packet belongs to
- */
-void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
- const AVStream *st);
-
-/**
- * Get the AVCodecID for the given codec tag tag.
- * If no codec id is found returns AV_CODEC_ID_NONE.
- *
- * @param tags list of supported codec_id-codec_tag pairs, as stored
- * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
- * @param tag codec tag to match to a codec ID
- */
-enum AVCodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
-
-/**
- * Get the codec tag for the given codec id id.
- * If no codec tag is found returns 0.
- *
- * @param tags list of supported codec_id-codec_tag pairs, as stored
- * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
- * @param id codec ID to match to a codec tag
- */
-unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum AVCodecID id);
-
-/**
- * Get the codec tag for the given codec id.
- *
- * @param tags list of supported codec_id - codec_tag pairs, as stored
- * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
- * @param id codec id that should be searched for in the list
- * @param tag A pointer to the found tag
- * @return 0 if id was not found in tags, > 0 if it was found
- */
-int av_codec_get_tag2(const struct AVCodecTag * const *tags, enum AVCodecID id,
- unsigned int *tag);
-
-int av_find_default_stream_index(AVFormatContext *s);
-
-/**
- * Get the index for a specific timestamp.
- *
- * @param st stream that the timestamp belongs to
- * @param timestamp timestamp to retrieve the index for
- * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond
- * to the timestamp which is <= the requested one, if backward
- * is 0, then it will be >=
- * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
- * @return < 0 if no such timestamp could be found
- */
-int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
-
-/**
- * Add an index entry into a sorted list. Update the entry if the list
- * already contains it.
- *
- * @param timestamp timestamp in the time base of the given stream
- */
-int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
- int size, int distance, int flags);
-
-
-/**
- * Split a URL string into components.
- *
- * The pointers to buffers for storing individual components may be null,
- * in order to ignore that component. Buffers for components not found are
- * set to empty strings. If the port is not found, it is set to a negative
- * value.
- *
- * @param proto the buffer for the protocol
- * @param proto_size the size of the proto buffer
- * @param authorization the buffer for the authorization
- * @param authorization_size the size of the authorization buffer
- * @param hostname the buffer for the host name
- * @param hostname_size the size of the hostname buffer
- * @param port_ptr a pointer to store the port number in
- * @param path the buffer for the path
- * @param path_size the size of the path buffer
- * @param url the URL to split
- */
-void av_url_split(char *proto, int proto_size,
- char *authorization, int authorization_size,
- char *hostname, int hostname_size,
- int *port_ptr,
- char *path, int path_size,
- const char *url);
-
-
-/**
- * Print detailed information about the input or output format, such as
- * duration, bitrate, streams, container, programs, metadata, side data,
- * codec and time base.
- *
- * @param ic the context to analyze
- * @param index index of the stream to dump information about
- * @param url the URL to print, such as source or destination file
- * @param is_output Select whether the specified context is an input(0) or output(1)
- */
-void av_dump_format(AVFormatContext *ic,
- int index,
- const char *url,
- int is_output);
-
-
-#define AV_FRAME_FILENAME_FLAGS_MULTIPLE 1 ///< Allow multiple %d
-
-/**
- * Return in 'buf' the path with '%d' replaced by a number.
- *
- * Also handles the '%0nd' format where 'n' is the total number
- * of digits and '%%'.
- *
- * @param buf destination buffer
- * @param buf_size destination buffer size
- * @param path numbered sequence string
- * @param number frame number
- * @param flags AV_FRAME_FILENAME_FLAGS_*
- * @return 0 if OK, -1 on format error
- */
-int av_get_frame_filename2(char *buf, int buf_size,
- const char *path, int number, int flags);
-
-int av_get_frame_filename(char *buf, int buf_size,
- const char *path, int number);
-
-/**
- * Check whether filename actually is a numbered sequence generator.
- *
- * @param filename possible numbered sequence string
- * @return 1 if a valid numbered sequence string, 0 otherwise
- */
-int av_filename_number_test(const char *filename);
-
-/**
- * Generate an SDP for an RTP session.
- *
- * Note, this overwrites the id values of AVStreams in the muxer contexts
- * for getting unique dynamic payload types.
- *
- * @param ac array of AVFormatContexts describing the RTP streams. If the
- * array is composed by only one context, such context can contain
- * multiple AVStreams (one AVStream per RTP stream). Otherwise,
- * all the contexts in the array (an AVCodecContext per RTP stream)
- * must contain only one AVStream.
- * @param n_files number of AVCodecContexts contained in ac
- * @param buf buffer where the SDP will be stored (must be allocated by
- * the caller)
- * @param size the size of the buffer
- * @return 0 if OK, AVERROR_xxx on error
- */
-int av_sdp_create(AVFormatContext *ac, int n_files, char *buf, int size);
-
-/**
- * Return a positive value if the given filename has one of the given
- * extensions, 0 otherwise.
- *
- * @param filename file name to check against the given extensions
- * @param extensions a comma-separated list of filename extensions
- */
-int av_match_ext(const char *filename, const char *extensions);
-
-/**
- * Test if the given container can store a codec.
- *
- * @param ofmt container to check for compatibility
- * @param codec_id codec to potentially store in container
- * @param std_compliance standards compliance level, one of FF_COMPLIANCE_*
- *
- * @return 1 if codec with ID codec_id can be stored in ofmt, 0 if it cannot.
- * A negative number if this information is not available.
- */
-int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
- int std_compliance);
-
-/**
- * @defgroup riff_fourcc RIFF FourCCs
- * @{
- * Get the tables mapping RIFF FourCCs to libavcodec AVCodecIDs. The tables are
- * meant to be passed to av_codec_get_id()/av_codec_get_tag() as in the
- * following code:
- * @code
- * uint32_t tag = MKTAG('H', '2', '6', '4');
- * const struct AVCodecTag *table = { avformat_get_riff_video_tags(), 0 };
- * enum AVCodecID id = av_codec_get_id(table, tag);
- * @endcode
- */
-/**
- * @return the table mapping RIFF FourCCs for video to libavcodec AVCodecID.
- */
-const struct AVCodecTag *avformat_get_riff_video_tags(void);
-/**
- * @return the table mapping RIFF FourCCs for audio to AVCodecID.
- */
-const struct AVCodecTag *avformat_get_riff_audio_tags(void);
-/**
- * @return the table mapping MOV FourCCs for video to libavcodec AVCodecID.
- */
-const struct AVCodecTag *avformat_get_mov_video_tags(void);
-/**
- * @return the table mapping MOV FourCCs for audio to AVCodecID.
- */
-const struct AVCodecTag *avformat_get_mov_audio_tags(void);
-
-/**
- * @}
- */
-
-/**
- * Guess the sample aspect ratio of a frame, based on both the stream and the
- * frame aspect ratio.
- *
- * Since the frame aspect ratio is set by the codec but the stream aspect ratio
- * is set by the demuxer, these two may not be equal. This function tries to
- * return the value that you should use if you would like to display the frame.
- *
- * Basic logic is to use the stream aspect ratio if it is set to something sane
- * otherwise use the frame aspect ratio. This way a container setting, which is
- * usually easy to modify can override the coded value in the frames.
- *
- * @param format the format context which the stream is part of
- * @param stream the stream which the frame is part of
- * @param frame the frame with the aspect ratio to be determined
- * @return the guessed (valid) sample_aspect_ratio, 0/1 if no idea
- */
-AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame);
-
-/**
- * Guess the frame rate, based on both the container and codec information.
- *
- * @param ctx the format context which the stream is part of
- * @param stream the stream which the frame is part of
- * @param frame the frame for which the frame rate should be determined, may be NULL
- * @return the guessed (valid) frame rate, 0/1 if no idea
- */
-AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame);
-
-/**
- * Check if the stream st contained in s is matched by the stream specifier
- * spec.
- *
- * See the "stream specifiers" chapter in the documentation for the syntax
- * of spec.
- *
- * @return >0 if st is matched by spec;
- * 0 if st is not matched by spec;
- * AVERROR code if spec is invalid
- *
- * @note A stream specifier can match several streams in the format.
- */
-int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
- const char *spec);
-
-int avformat_queue_attached_pictures(AVFormatContext *s);
-
-#if FF_API_OLD_BSF
-/**
- * Apply a list of bitstream filters to a packet.
- *
- * @param codec AVCodecContext, usually from an AVStream
- * @param pkt the packet to apply filters to. If, on success, the returned
- * packet has size == 0 and side_data_elems == 0, it indicates that
- * the packet should be dropped
- * @param bsfc a NULL-terminated list of filters to apply
- * @return >=0 on success;
- * AVERROR code on failure
- */
-attribute_deprecated
-int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
- AVBitStreamFilterContext *bsfc);
-#endif
-
-enum AVTimebaseSource {
- AVFMT_TBCF_AUTO = -1,
- AVFMT_TBCF_DECODER,
- AVFMT_TBCF_DEMUXER,
-#if FF_API_R_FRAME_RATE
- AVFMT_TBCF_R_FRAMERATE,
-#endif
-};
-
-/**
- * Transfer internal timing information from one stream to another.
- *
- * This function is useful when doing stream copy.
- *
- * @param ofmt target output format for ost
- * @param ost output stream which needs timings copy and adjustments
- * @param ist reference input stream to copy timings from
- * @param copy_tb define from where the stream codec timebase needs to be imported
- */
-int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
- AVStream *ost, const AVStream *ist,
- enum AVTimebaseSource copy_tb);
-
-/**
- * Get the internal codec timebase from a stream.
- *
- * @param st input stream to extract the timebase from
- */
-AVRational av_stream_get_codec_timebase(const AVStream *st);
-
-/**
- * @}
- */
-
-#endif /* AVFORMAT_AVFORMAT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavformat/avio.h Deleted

@@ -1,861 +0,0 @@
-/*
- * copyright (c) 2001 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-#ifndef AVFORMAT_AVIO_H
-#define AVFORMAT_AVIO_H
-
-/**
- * @file
- * @ingroup lavf_io
- * Buffered I/O operations
- */
-
-#include <stdint.h>
-
-#include "libavutil/common.h"
-#include "libavutil/dict.h"
-#include "libavutil/log.h"
-
-#include "libavformat/version.h"
-
-/**
- * Seeking works like for a local file.
- */
-#define AVIO_SEEKABLE_NORMAL (1 << 0)
-
-/**
- * Seeking by timestamp with avio_seek_time() is possible.
- */
-#define AVIO_SEEKABLE_TIME (1 << 1)
-
-/**
- * Callback for checking whether to abort blocking functions.
- * AVERROR_EXIT is returned in this case by the interrupted
- * function. During blocking operations, callback is called with
- * opaque as parameter. If the callback returns 1, the
- * blocking operation will be aborted.
- *
- * No members can be added to this struct without a major bump, if
- * new elements have been added after this struct in AVFormatContext
- * or AVIOContext.
- */
-typedef struct AVIOInterruptCB {
- int (*callback)(void*);
- void *opaque;
-} AVIOInterruptCB;
-
-/**
- * Directory entry types.
- */
-enum AVIODirEntryType {
- AVIO_ENTRY_UNKNOWN,
- AVIO_ENTRY_BLOCK_DEVICE,
- AVIO_ENTRY_CHARACTER_DEVICE,
- AVIO_ENTRY_DIRECTORY,
- AVIO_ENTRY_NAMED_PIPE,
- AVIO_ENTRY_SYMBOLIC_LINK,
- AVIO_ENTRY_SOCKET,
- AVIO_ENTRY_FILE,
- AVIO_ENTRY_SERVER,
- AVIO_ENTRY_SHARE,
- AVIO_ENTRY_WORKGROUP,
-};
-
-/**
- * Describes single entry of the directory.
- *
- * Only name and type fields are guaranteed be set.
- * Rest of fields are protocol or/and platform dependent and might be unknown.
- */
-typedef struct AVIODirEntry {
- char *name; /**< Filename */
- int type; /**< Type of the entry */
- int utf8; /**< Set to 1 when name is encoded with UTF-8, 0 otherwise.
- Name can be encoded with UTF-8 even though 0 is set. */
- int64_t size; /**< File size in bytes, -1 if unknown. */
- int64_t modification_timestamp; /**< Time of last modification in microseconds since unix
- epoch, -1 if unknown. */
- int64_t access_timestamp; /**< Time of last access in microseconds since unix epoch,
- -1 if unknown. */
- int64_t status_change_timestamp; /**< Time of last status change in microseconds since unix
- epoch, -1 if unknown. */
- int64_t user_id; /**< User ID of owner, -1 if unknown. */
- int64_t group_id; /**< Group ID of owner, -1 if unknown. */
- int64_t filemode; /**< Unix file mode, -1 if unknown. */
-} AVIODirEntry;
-
-typedef struct AVIODirContext {
- struct URLContext *url_context;
-} AVIODirContext;
-
-/**
- * Different data types that can be returned via the AVIO
- * write_data_type callback.
- */
-enum AVIODataMarkerType {
- /**
- * Header data; this needs to be present for the stream to be decodeable.
- */
- AVIO_DATA_MARKER_HEADER,
- /**
- * A point in the output bytestream where a decoder can start decoding
- * (i.e. a keyframe). A demuxer/decoder given the data flagged with
- * AVIO_DATA_MARKER_HEADER, followed by any AVIO_DATA_MARKER_SYNC_POINT,
- * should give decodeable results.
- */
- AVIO_DATA_MARKER_SYNC_POINT,
- /**
- * A point in the output bytestream where a demuxer can start parsing
- * (for non self synchronizing bytestream formats). That is, any
- * non-keyframe packet start point.
- */
- AVIO_DATA_MARKER_BOUNDARY_POINT,
- /**
- * This is any, unlabelled data. It can either be a muxer not marking
- * any positions at all, it can be an actual boundary/sync point
- * that the muxer chooses not to mark, or a later part of a packet/fragment
- * that is cut into multiple write callbacks due to limited IO buffer size.
- */
- AVIO_DATA_MARKER_UNKNOWN,
- /**
- * Trailer data, which doesn't contain actual content, but only for
- * finalizing the output file.
- */
- AVIO_DATA_MARKER_TRAILER,
- /**
- * A point in the output bytestream where the underlying AVIOContext might
- * flush the buffer depending on latency or buffering requirements. Typically
- * means the end of a packet.
- */
- AVIO_DATA_MARKER_FLUSH_POINT,
-};
-
-/**
- * Bytestream IO Context.
- * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing fields require a major
- * version bump.
- * sizeof(AVIOContext) must not be used outside libav*.
- *
- * @note None of the function pointers in AVIOContext should be called
- * directly, they should only be set by the client application
- * when implementing custom I/O. Normally these are set to the
- * function pointers specified in avio_alloc_context()
- */
-typedef struct AVIOContext {
- /**
- * A class for private options.
- *
- * If this AVIOContext is created by avio_open2(), av_class is set and
- * passes the options down to protocols.
- *
- * If this AVIOContext is manually allocated, then av_class may be set by
- * the caller.
- *
- * warning -- this field can be NULL, be sure to not pass this AVIOContext
- * to any av_opt_* functions in that case.
- */
- const AVClass *av_class;
-
- /*
- * The following shows the relationship between buffer, buf_ptr,
- * buf_ptr_max, buf_end, buf_size, and pos, when reading and when writing
- * (since AVIOContext is used for both):
- *
- **********************************************************************************
- * READING
- **********************************************************************************
- *
- * | buffer_size |
- * |---------------------------------------|
- * | |
- *
- * buffer buf_ptr buf_end
- * +---------------+-----------------------+
- * |/ / / / / / / /|/ / / / / / /| |
- * read buffer: |/ / consumed / | to be read /| |
- * |/ / / / / / / /|/ / / / / / /| |
- * +---------------+-----------------------+
- *
- * pos
- * +-------------------------------------------+-----------------+
- * input file: | | |
- * +-------------------------------------------+-----------------+
- *
- *
- **********************************************************************************
- * WRITING
- **********************************************************************************
- *
- * | buffer_size |
- * |--------------------------------------|
- * | |
- *
- * buf_ptr_max
- * buffer (buf_ptr) buf_end
- * +-----------------------+--------------+
- * |/ / / / / / / / / / / /| |
- * write buffer: | / / to be flushed / / | |
- * |/ / / / / / / / / / / /| |
- * +-----------------------+--------------+
- * buf_ptr can be in this
- * due to a backward seek
- *
- * pos
- * +-------------+----------------------------------------------+
- * output file: | | |
- * +-------------+----------------------------------------------+
- *
- */
- unsigned char *buffer; /**< Start of the buffer. */
- int buffer_size; /**< Maximum buffer size */
- unsigned char *buf_ptr; /**< Current position in the buffer */
- unsigned char *buf_end; /**< End of the data, may be less than
- buffer+buffer_size if the read function returned
- less data than requested, e.g. for streams where
- no more data has been received yet. */
- void *opaque; /**< A private pointer, passed to the read/write/seek/...
- functions. */
- int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
- int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
- int64_t (*seek)(void *opaque, int64_t offset, int whence);
- int64_t pos; /**< position in the file of the current buffer */
- int eof_reached; /**< true if eof reached */
- int write_flag; /**< true if open for writing */
- int max_packet_size;
- unsigned long checksum;
- unsigned char *checksum_ptr;
- unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
- int error; /**< contains the error code or 0 if no error happened */
- /**
- * Pause or resume playback for network streaming protocols - e.g. MMS.
- */
- int (*read_pause)(void *opaque, int pause);
- /**
- * Seek to a given timestamp in stream with the specified stream_index.
- * Needed for some network streaming protocols which don't support seeking
- * to byte position.
- */
- int64_t (*read_seek)(void *opaque, int stream_index,
- int64_t timestamp, int flags);
- /**
- * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
- */
- int seekable;
-
- /**
- * max filesize, used to limit allocations
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int64_t maxsize;
-
- /**
- * avio_read and avio_write should if possible be satisfied directly
- * instead of going through a buffer, and avio_seek will always
- * call the underlying seek function directly.
- */
- int direct;
-
- /**
- * Bytes read statistic
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int64_t bytes_read;
-
- /**
- * seek statistic
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int seek_count;
-
- /**
- * writeout statistic
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int writeout_count;
-
- /**
- * Original buffer size
- * used internally after probing and ensure seekback to reset the buffer size
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int orig_buffer_size;
-
- /**
- * Threshold to favor readahead over seek.
- * This is current internal only, do not use from outside.
- */
- int short_seek_threshold;
-
- /**
- * ',' separated list of allowed protocols.
- */
- const char *protocol_whitelist;
-
- /**
- * ',' separated list of disallowed protocols.
- */
- const char *protocol_blacklist;
-
- /**
- * A callback that is used instead of write_packet.
- */
- int (*write_data_type)(void *opaque, uint8_t *buf, int buf_size,
- enum AVIODataMarkerType type, int64_t time);
- /**
- * If set, don't call write_data_type separately for AVIO_DATA_MARKER_BOUNDARY_POINT,
- * but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly
- * small chunks of data returned from the callback).
- */
- int ignore_boundary_point;
-
- /**
- * Internal, not meant to be used from outside of AVIOContext.
- */
- enum AVIODataMarkerType current_type;
- int64_t last_time;
-
- /**
- * A callback that is used instead of short_seek_threshold.
- * This is current internal only, do not use from outside.
- */
- int (*short_seek_get)(void *opaque);
-
- int64_t written;
-
- /**
- * Maximum reached position before a backward seek in the write buffer,
- * used keeping track of already written data for a later flush.
- */
- unsigned char *buf_ptr_max;
-
- /**
- * Try to buffer at least this amount of data before flushing it
- */
- int min_packet_size;
-} AVIOContext;
-
-/**
- * Return the name of the protocol that will handle the passed URL.
- *
- * NULL is returned if no protocol could be found for the given URL.
- *
- * @return Name of the protocol or NULL.
- */
-const char *avio_find_protocol_name(const char *url);
-
-/**
- * Return AVIO_FLAG_* access flags corresponding to the access permissions
- * of the resource in url, or a negative value corresponding to an
- * AVERROR code in case of failure. The returned access flags are
- * masked by the value in flags.
- *
- * @note This function is intrinsically unsafe, in the sense that the
- * checked resource may change its existence or permission status from
- * one call to another. Thus you should not trust the returned value,
- * unless you are sure that no other processes are accessing the
- * checked resource.
- */
-int avio_check(const char *url, int flags);
-
-/**
- * Move or rename a resource.
- *
- * @note url_src and url_dst should share the same protocol and authority.
- *
- * @param url_src url to resource to be moved
- * @param url_dst new url to resource if the operation succeeded
- * @return >=0 on success or negative on error.
- */
-int avpriv_io_move(const char *url_src, const char *url_dst);
-
-/**
- * Delete a resource.
- *
- * @param url resource to be deleted.
- * @return >=0 on success or negative on error.
- */
-int avpriv_io_delete(const char *url);
-
-/**
- * Open directory for reading.
- *
- * @param s directory read context. Pointer to a NULL pointer must be passed.
- * @param url directory to be listed.
- * @param options A dictionary filled with protocol-private options. On return
- * this parameter will be destroyed and replaced with a dictionary
- * containing options that were not found. May be NULL.
- * @return >=0 on success or negative on error.
- */
-int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options);
-
-/**
- * Get next directory entry.
- *
- * Returned entry must be freed with avio_free_directory_entry(). In particular
- * it may outlive AVIODirContext.
- *
- * @param s directory read context.
- * @paramout next next entry or NULL when no more entries.
- * @return >=0 on success or negative on error. End of list is not considered an
- * error.
- */
-int avio_read_dir(AVIODirContext *s, AVIODirEntry **next);
-
-/**
- * Close directory.
- *
- * @note Entries created using avio_read_dir() are not deleted and must be
- * freeded with avio_free_directory_entry().
- *
- * @param s directory read context.
- * @return >=0 on success or negative on error.
- */
-int avio_close_dir(AVIODirContext **s);
-
-/**
- * Free entry allocated by avio_read_dir().
- *
- * @param entry entry to be freed.
- */
-void avio_free_directory_entry(AVIODirEntry **entry);
-
-/**
- * Allocate and initialize an AVIOContext for buffered I/O. It must be later
- * freed with avio_context_free().
- *
- * @param buffer Memory block for input/output operations via AVIOContext.
- * The buffer must be allocated with av_malloc() and friends.
- * It may be freed and replaced with a new buffer by libavformat.
- * AVIOContext.buffer holds the buffer currently in use,
- * which must be later freed with av_free().
- * @param buffer_size The buffer size is very important for performance.
- * For protocols with fixed blocksize it should be set to this blocksize.
- * For others a typical size is a cache page, e.g. 4kb.
- * @param write_flag Set to 1 if the buffer should be writable, 0 otherwise.
- * @param opaque An opaque pointer to user-specific data.
- * @param read_packet A function for refilling the buffer, may be NULL.
- * For stream protocols, must never return 0 but rather
- * a proper AVERROR code.
- * @param write_packet A function for writing the buffer contents, may be NULL.
- * The function may not change the input buffers content.
- * @param seek A function for seeking to specified byte position, may be NULL.
- *
- * @return Allocated AVIOContext or NULL on failure.
- */
-AVIOContext *avio_alloc_context(
- unsigned char *buffer,
- int buffer_size,
- int write_flag,
- void *opaque,
- int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
- int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
- int64_t (*seek)(void *opaque, int64_t offset, int whence));
-
-/**
- * Free the supplied IO context and everything associated with it.
- *
- * @param s Double pointer to the IO context. This function will write NULL
- * into s.
- */
-void avio_context_free(AVIOContext **s);
-
-void avio_w8(AVIOContext *s, int b);
-void avio_write(AVIOContext *s, const unsigned char *buf, int size);
-void avio_wl64(AVIOContext *s, uint64_t val);
-void avio_wb64(AVIOContext *s, uint64_t val);
-void avio_wl32(AVIOContext *s, unsigned int val);
-void avio_wb32(AVIOContext *s, unsigned int val);
-void avio_wl24(AVIOContext *s, unsigned int val);
-void avio_wb24(AVIOContext *s, unsigned int val);
-void avio_wl16(AVIOContext *s, unsigned int val);
-void avio_wb16(AVIOContext *s, unsigned int val);
-
-/**
- * Write a NULL-terminated string.
- * @return number of bytes written.
- */
-int avio_put_str(AVIOContext *s, const char *str);
-
-/**
- * Convert an UTF-8 string to UTF-16LE and write it.
- * @param s the AVIOContext
- * @param str NULL-terminated UTF-8 string
- *
- * @return number of bytes written.
- */
-int avio_put_str16le(AVIOContext *s, const char *str);
-
-/**
- * Convert an UTF-8 string to UTF-16BE and write it.
- * @param s the AVIOContext
- * @param str NULL-terminated UTF-8 string
- *
- * @return number of bytes written.
- */
-int avio_put_str16be(AVIOContext *s, const char *str);
-
-/**
- * Mark the written bytestream as a specific type.
- *
- * Zero-length ranges are omitted from the output.
- *
- * @param time the stream time the current bytestream pos corresponds to
- * (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not
- * applicable
- * @param type the kind of data written starting at the current pos
- */
-void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type);
-
-/**
- * ORing this as the "whence" parameter to a seek function causes it to
- * return the filesize without seeking anywhere. Supporting this is optional.
- * If it is not supported then the seek function will return <0.
- */
-#define AVSEEK_SIZE 0x10000
-
-/**
- * Passing this flag as the "whence" parameter to a seek function causes it to
- * seek by any means (like reopening and linear reading) or other normally unreasonable
- * means that can be extremely slow.
- * This may be ignored by the seek code.
- */
-#define AVSEEK_FORCE 0x20000
-
-/**
- * fseek() equivalent for AVIOContext.
- * @return new position or AVERROR.
- */
-int64_t avio_seek(AVIOContext *s, int64_t offset, int whence);
-
-/**
- * Skip given number of bytes forward
- * @return new position or AVERROR.
- */
-int64_t avio_skip(AVIOContext *s, int64_t offset);
-
-/**
- * ftell() equivalent for AVIOContext.
- * @return position or AVERROR.
- */
-static av_always_inline int64_t avio_tell(AVIOContext *s)
-{
- return avio_seek(s, 0, SEEK_CUR);
-}
-
-/**
- * Get the filesize.
- * @return filesize or AVERROR
- */
-int64_t avio_size(AVIOContext *s);
-
-/**
- * feof() equivalent for AVIOContext.
- * @return non zero if and only if end of file
- */
-int avio_feof(AVIOContext *s);
-
-/** @warning Writes up to 4 KiB per call */
-int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
-
-/**
- * Force flushing of buffered data.
- *
- * For write streams, force the buffered data to be immediately written to the output,
- * without to wait to fill the internal buffer.
- *
- * For read streams, discard all currently buffered data, and advance the
- * reported file position to that of the underlying stream. This does not
- * read new data, and does not perform any seeks.
- */
-void avio_flush(AVIOContext *s);
-
-/**
- * Read size bytes from AVIOContext into buf.
- * @return number of bytes read or AVERROR
- */
-int avio_read(AVIOContext *s, unsigned char *buf, int size);
-
-/**
- * Read size bytes from AVIOContext into buf. Unlike avio_read(), this is allowed
- * to read fewer bytes than requested. The missing bytes can be read in the next
- * call. This always tries to read at least 1 byte.
- * Useful to reduce latency in certain cases.
- * @return number of bytes read or AVERROR
- */
-int avio_read_partial(AVIOContext *s, unsigned char *buf, int size);
-
-/**
- * @name Functions for reading from AVIOContext
- * @{
- *
- * @note return 0 if EOF, so you cannot use it if EOF handling is
- * necessary
- */
-int avio_r8 (AVIOContext *s);
-unsigned int avio_rl16(AVIOContext *s);
-unsigned int avio_rl24(AVIOContext *s);
-unsigned int avio_rl32(AVIOContext *s);
-uint64_t avio_rl64(AVIOContext *s);
-unsigned int avio_rb16(AVIOContext *s);
-unsigned int avio_rb24(AVIOContext *s);
-unsigned int avio_rb32(AVIOContext *s);
-uint64_t avio_rb64(AVIOContext *s);
-/**
- * @}
- */
-
-/**
- * Read a string from pb into buf. The reading will terminate when either
- * a NULL character was encountered, maxlen bytes have been read, or nothing
- * more can be read from pb. The result is guaranteed to be NULL-terminated, it
- * will be truncated if buf is too small.
- * Note that the string is not interpreted or validated in any way, it
- * might get truncated in the middle of a sequence for multi-byte encodings.
- *
- * @return number of bytes read (is always <= maxlen).
- * If reading ends on EOF or error, the return value will be one more than
- * bytes actually read.
- */
-int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen);
-
-/**
- * Read a UTF-16 string from pb and convert it to UTF-8.
- * The reading will terminate when either a null or invalid character was
- * encountered or maxlen bytes have been read.
- * @return number of bytes read (is always <= maxlen)
- */
-int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
-int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
-
-
-/**
- * @name URL open modes
- * The flags argument to avio_open must be one of the following
- * constants, optionally ORed with other flags.
- * @{
- */
-#define AVIO_FLAG_READ 1 /**< read-only */
-#define AVIO_FLAG_WRITE 2 /**< write-only */
-#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE) /**< read-write pseudo flag */
-/**
- * @}
- */
-
-/**
- * Use non-blocking mode.
- * If this flag is set, operations on the context will return
- * AVERROR(EAGAIN) if they can not be performed immediately.
- * If this flag is not set, operations on the context will never return
- * AVERROR(EAGAIN).
- * Note that this flag does not affect the opening/connecting of the
- * context. Connecting a protocol will always block if necessary (e.g. on
- * network protocols) but never hang (e.g. on busy devices).
- * Warning: non-blocking protocols is work-in-progress; this flag may be
- * silently ignored.
- */
-#define AVIO_FLAG_NONBLOCK 8
-
-/**
- * Use direct mode.
- * avio_read and avio_write should if possible be satisfied directly
- * instead of going through a buffer, and avio_seek will always
- * call the underlying seek function directly.
- */
-#define AVIO_FLAG_DIRECT 0x8000
-
-/**
- * Create and initialize a AVIOContext for accessing the
- * resource indicated by url.
- * @note When the resource indicated by url has been opened in
- * read+write mode, the AVIOContext can be used only for writing.
- *
- * @param s Used to return the pointer to the created AVIOContext.
- * In case of failure the pointed to value is set to NULL.
- * @param url resource to access
- * @param flags flags which control how the resource indicated by url
- * is to be opened
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code in case of failure
- */
-int avio_open(AVIOContext **s, const char *url, int flags);
-
-/**
- * Create and initialize a AVIOContext for accessing the
- * resource indicated by url.
- * @note When the resource indicated by url has been opened in
- * read+write mode, the AVIOContext can be used only for writing.
- *
- * @param s Used to return the pointer to the created AVIOContext.
- * In case of failure the pointed to value is set to NULL.
- * @param url resource to access
- * @param flags flags which control how the resource indicated by url
- * is to be opened
- * @param int_cb an interrupt callback to be used at the protocols level
- * @param options A dictionary filled with protocol-private options. On return
- * this parameter will be destroyed and replaced with a dict containing options
- * that were not found. May be NULL.
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code in case of failure
- */
-int avio_open2(AVIOContext **s, const char *url, int flags,
- const AVIOInterruptCB *int_cb, AVDictionary **options);
-
-/**
- * Close the resource accessed by the AVIOContext s and free it.
- * This function can only be used if s was opened by avio_open().
- *
- * The internal buffer is automatically flushed before closing the
- * resource.
- *
- * @return 0 on success, an AVERROR < 0 on error.
- * @see avio_closep
- */
-int avio_close(AVIOContext *s);
-
-/**
- * Close the resource accessed by the AVIOContext *s, free it
- * and set the pointer pointing to it to NULL.
- * This function can only be used if s was opened by avio_open().
- *
- * The internal buffer is automatically flushed before closing the
- * resource.
- *
- * @return 0 on success, an AVERROR < 0 on error.
- * @see avio_close
- */
-int avio_closep(AVIOContext **s);
-
-
-/**
- * Open a write only memory stream.
- *
- * @param s new IO context
- * @return zero if no error.
- */
-int avio_open_dyn_buf(AVIOContext **s);
-
-/**
- * Return the written size and a pointer to the buffer.
- * The AVIOContext stream is left intact.
- * The buffer must NOT be freed.
- * No padding is added to the buffer.
- *
- * @param s IO context
- * @param pbuffer pointer to a byte buffer
- * @return the length of the byte buffer
- */
-int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
-
-/**
- * Return the written size and a pointer to the buffer. The buffer
- * must be freed with av_free().
- * Padding of AV_INPUT_BUFFER_PADDING_SIZE is added to the buffer.
- *
- * @param s IO context
- * @param pbuffer pointer to a byte buffer
- * @return the length of the byte buffer
- */
-int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
-
-/**
- * Iterate through names of available protocols.
- *
- * @param opaque A private pointer representing current protocol.
- * It must be a pointer to NULL on first iteration and will
- * be updated by successive calls to avio_enum_protocols.
- * @param output If set to 1, iterate over output protocols,
- * otherwise over input protocols.
- *
- * @return A static string containing the name of current protocol or NULL
- */
-const char *avio_enum_protocols(void **opaque, int output);
-
-/**
- * Pause and resume playing - only meaningful if using a network streaming
- * protocol (e.g. MMS).
- *
- * @param h IO context from which to call the read_pause function pointer
- * @param pause 1 for pause, 0 for resume
- */
-int avio_pause(AVIOContext *h, int pause);
-
-/**
- * Seek to a given timestamp relative to some component stream.
- * Only meaningful if using a network streaming protocol (e.g. MMS.).
- *
- * @param h IO context from which to call the seek function pointers
- * @param stream_index The stream index that the timestamp is relative to.
- * If stream_index is (-1) the timestamp should be in AV_TIME_BASE
- * units from the beginning of the presentation.
- * If a stream_index >= 0 is used and the protocol does not support
- * seeking based on component streams, the call will fail.
- * @param timestamp timestamp in AVStream.time_base units
- * or if there is no stream specified then in AV_TIME_BASE units.
- * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE
- * and AVSEEK_FLAG_ANY. The protocol may silently ignore
- * AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will
- * fail if used and not supported.
- * @return >= 0 on success
- * @see AVInputFormat::read_seek
- */
-int64_t avio_seek_time(AVIOContext *h, int stream_index,
- int64_t timestamp, int flags);
-
-/* Avoid a warning. The header can not be included because it breaks c++. */
-struct AVBPrint;
-
-/**
- * Read contents of h into print buffer, up to max_size bytes, or up to EOF.
- *
- * @return 0 for success (max_size bytes read or EOF reached), negative error
- * code otherwise
- */
-int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size);
-
-/**
- * Accept and allocate a client context on a server context.
- * @param s the server context
- * @param c the client context, must be unallocated
- * @return >= 0 on success or a negative value corresponding
- * to an AVERROR on failure
- */
-int avio_accept(AVIOContext *s, AVIOContext **c);
-
-/**
- * Perform one step of the protocol handshake to accept a new client.
- * This function must be called on a client returned by avio_accept() before
- * using it as a read/write context.
- * It is separate from avio_accept() because it may block.
- * A step of the handshake is defined by places where the application may
- * decide to change the proceedings.
- * For example, on a protocol with a request header and a reply header, each
- * one can constitute a step because the application may use the parameters
- * from the request to change parameters in the reply; or each individual
- * chunk of the request can constitute a step.
- * If the handshake is already finished, avio_handshake() does nothing and
- * returns 0 immediately.
- *
- * @param c the client context to perform the handshake on
- * @return 0 on a complete and successful handshake
- * > 0 if the handshake progressed, but is not complete
- * < 0 for an AVERROR code
- */
-int avio_handshake(AVIOContext *c);
-#endif /* AVFORMAT_AVIO_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavformat/version.h Deleted

@@ -1,102 +0,0 @@
-/*
- * Version macros.
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVFORMAT_VERSION_H
-#define AVFORMAT_VERSION_H
-
-/**
- * @file
- * @ingroup libavf
- * Libavformat version macros
- */
-
-#include "libavutil/version.h"
-
-// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
-// Also please add any ticket numbers that you believe might be affected here
-#define LIBAVFORMAT_VERSION_MAJOR 58
-#define LIBAVFORMAT_VERSION_MINOR 12
-#define LIBAVFORMAT_VERSION_MICRO 100
-
-#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
- LIBAVFORMAT_VERSION_MINOR, \
- LIBAVFORMAT_VERSION_MICRO)
-#define LIBAVFORMAT_VERSION AV_VERSION(LIBAVFORMAT_VERSION_MAJOR, \
- LIBAVFORMAT_VERSION_MINOR, \
- LIBAVFORMAT_VERSION_MICRO)
-#define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT
-
-#define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- *
- * @note, when bumping the major version it is recommended to manually
- * disable each FF_API_* in its own commit instead of disabling them all
- * at once through the bump. This improves the git bisect-ability of the change.
- *
- */
-#ifndef FF_API_COMPUTE_PKT_FIELDS2
-#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_OPEN_CALLBACKS
-#define FF_API_OLD_OPEN_CALLBACKS (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LAVF_AVCTX
-#define FF_API_LAVF_AVCTX (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_HTTP_USER_AGENT
-#define FF_API_HTTP_USER_AGENT (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_HLS_WRAP
-#define FF_API_HLS_WRAP (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LAVF_KEEPSIDE_FLAG
-#define FF_API_LAVF_KEEPSIDE_FLAG (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_ROTATE_API
-#define FF_API_OLD_ROTATE_API (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_FORMAT_GET_SET
-#define FF_API_FORMAT_GET_SET (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_AVIO_EOF_0
-#define FF_API_OLD_AVIO_EOF_0 (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LAVF_FFSERVER
-#define FF_API_LAVF_FFSERVER (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_FORMAT_FILENAME
-#define FF_API_FORMAT_FILENAME (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_RTSP_OPTIONS
-#define FF_API_OLD_RTSP_OPTIONS (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_NEXT
-#define FF_API_NEXT (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-
-
-#ifndef FF_API_R_FRAME_RATE
-#define FF_API_R_FRAME_RATE 1
-#endif
-#endif /* AVFORMAT_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/adler32.h Deleted

@@ -1,60 +0,0 @@
-/*
- * copyright (c) 2006 Mans Rullgard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_adler32
- * Public header for Adler-32 hash function implementation.
- */
-
-#ifndef AVUTIL_ADLER32_H
-#define AVUTIL_ADLER32_H
-
-#include <stdint.h>
-#include "attributes.h"
-
-/**
- * @defgroup lavu_adler32 Adler-32
- * @ingroup lavu_hash
- * Adler-32 hash function implementation.
- *
- * @{
- */
-
-/**
- * Calculate the Adler32 checksum of a buffer.
- *
- * Passing the return value to a subsequent av_adler32_update() call
- * allows the checksum of multiple buffers to be calculated as though
- * they were concatenated.
- *
- * @param adler initial checksum value
- * @param buf pointer to input buffer
- * @param len size of input buffer
- * @return updated checksum
- */
-unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf,
- unsigned int len) av_pure;
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_ADLER32_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/aes.h Deleted

@@ -1,65 +0,0 @@
-/*
- * copyright (c) 2007 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_AES_H
-#define AVUTIL_AES_H
-
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_aes AES
- * @ingroup lavu_crypto
- * @{
- */
-
-extern const int av_aes_size;
-
-struct AVAES;
-
-/**
- * Allocate an AVAES context.
- */
-struct AVAES *av_aes_alloc(void);
-
-/**
- * Initialize an AVAES context.
- * @param key_bits 128, 192 or 256
- * @param decrypt 0 for encryption, 1 for decryption
- */
-int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context.
- * @param count number of 16 byte blocks
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param iv initialization vector for CBC mode, if NULL then ECB will be used
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_AES_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/aes_ctr.h Deleted

@@ -1,88 +0,0 @@
-/*
- * AES-CTR cipher
- * Copyright (c) 2015 Eran Kornblau <erankor at gmail dot com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_AES_CTR_H
-#define AVUTIL_AES_CTR_H
-
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-#define AES_CTR_KEY_SIZE (16)
-#define AES_CTR_IV_SIZE (8)
-
-struct AVAESCTR;
-
-/**
- * Allocate an AVAESCTR context.
- */
-struct AVAESCTR *av_aes_ctr_alloc(void);
-
-/**
- * Initialize an AVAESCTR context.
- * @param key encryption key, must have a length of AES_CTR_KEY_SIZE
- */
-int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key);
-
-/**
- * Release an AVAESCTR context.
- */
-void av_aes_ctr_free(struct AVAESCTR *a);
-
-/**
- * Process a buffer using a previously initialized context.
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param size the size of src and dst
- */
-void av_aes_ctr_crypt(struct AVAESCTR *a, uint8_t *dst, const uint8_t *src, int size);
-
-/**
- * Get the current iv
- */
-const uint8_t* av_aes_ctr_get_iv(struct AVAESCTR *a);
-
-/**
- * Generate a random iv
- */
-void av_aes_ctr_set_random_iv(struct AVAESCTR *a);
-
-/**
- * Forcefully change the 8-byte iv
- */
-void av_aes_ctr_set_iv(struct AVAESCTR *a, const uint8_t* iv);
-
-/**
- * Forcefully change the "full" 16-byte iv, including the counter
- */
-void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t* iv);
-
-/**
- * Increment the top 64 bit of the iv (performed after each frame)
- */
-void av_aes_ctr_increment_iv(struct AVAESCTR *a);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_AES_CTR_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/attributes.h Deleted

@@ -1,167 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Macro definitions for various function/variable attributes
- */
-
-#ifndef AVUTIL_ATTRIBUTES_H
-#define AVUTIL_ATTRIBUTES_H
-
-#ifdef __GNUC__
-# define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
-# define AV_GCC_VERSION_AT_MOST(x,y) (__GNUC__ < (x) || __GNUC__ == (x) && __GNUC_MINOR__ <= (y))
-#else
-# define AV_GCC_VERSION_AT_LEAST(x,y) 0
-# define AV_GCC_VERSION_AT_MOST(x,y) 0
-#endif
-
-#ifndef av_always_inline
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-# define av_always_inline __attribute__((always_inline)) inline
-#elif defined(_MSC_VER)
-# define av_always_inline __forceinline
-#else
-# define av_always_inline inline
-#endif
-#endif
-
-#ifndef av_extern_inline
-#if defined(__ICL) && __ICL >= 1210 || defined(__GNUC_STDC_INLINE__)
-# define av_extern_inline extern inline
-#else
-# define av_extern_inline inline
-#endif
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,4)
-# define av_warn_unused_result __attribute__((warn_unused_result))
-#else
-# define av_warn_unused_result
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-# define av_noinline __attribute__((noinline))
-#elif defined(_MSC_VER)
-# define av_noinline __declspec(noinline)
-#else
-# define av_noinline
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__)
-# define av_pure __attribute__((pure))
-#else
-# define av_pure
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(2,6) || defined(__clang__)
-# define av_const __attribute__((const))
-#else
-# define av_const
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(4,3) || defined(__clang__)
-# define av_cold __attribute__((cold))
-#else
-# define av_cold
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(4,1) && !defined(__llvm__)
-# define av_flatten __attribute__((flatten))
-#else
-# define av_flatten
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-# define attribute_deprecated __attribute__((deprecated))
-#elif defined(_MSC_VER)
-# define attribute_deprecated __declspec(deprecated)
-#else
-# define attribute_deprecated
-#endif
-
-/**
- * Disable warnings about deprecated features
- * This is useful for sections of code kept for backward compatibility and
- * scheduled for removal.
- */
-#ifndef AV_NOWARN_DEPRECATED
-#if AV_GCC_VERSION_AT_LEAST(4,6)
-# define AV_NOWARN_DEPRECATED(code) \
- _Pragma("GCC diagnostic push") \
- _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \
- code \
- _Pragma("GCC diagnostic pop")
-#elif defined(_MSC_VER)
-# define AV_NOWARN_DEPRECATED(code) \
- __pragma(warning(push)) \
- __pragma(warning(disable : 4996)) \
- code; \
- __pragma(warning(pop))
-#else
-# define AV_NOWARN_DEPRECATED(code) code
-#endif
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-# define av_unused __attribute__((unused))
-#else
-# define av_unused
-#endif
-
-/**
- * Mark a variable as used and prevent the compiler from optimizing it
- * away. This is useful for variables accessed only from inline
- * assembler without the compiler being aware.
- */
-#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__)
-# define av_used __attribute__((used))
-#else
-# define av_used
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,3) || defined(__clang__)
-# define av_alias __attribute__((may_alias))
-#else
-# define av_alias
-#endif
-
-#if (defined(__GNUC__) || defined(__clang__)) && !defined(__INTEL_COMPILER)
-# define av_uninit(x) x=x
-#else
-# define av_uninit(x) x
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-# define av_builtin_constant_p __builtin_constant_p
-# define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos)))
-#else
-# define av_builtin_constant_p(x) 0
-# define av_printf_format(fmtpos, attrpos)
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(2,5) || defined(__clang__)
-# define av_noreturn __attribute__((noreturn))
-#else
-# define av_noreturn
-#endif
-
-#endif /* AVUTIL_ATTRIBUTES_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/audio_fifo.h Deleted

@@ -1,187 +0,0 @@
-/*
- * Audio FIFO
- * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Audio FIFO Buffer
- */
-
-#ifndef AVUTIL_AUDIO_FIFO_H
-#define AVUTIL_AUDIO_FIFO_H
-
-#include "avutil.h"
-#include "fifo.h"
-#include "samplefmt.h"
-
-/**
- * @addtogroup lavu_audio
- * @{
- *
- * @defgroup lavu_audiofifo Audio FIFO Buffer
- * @{
- */
-
-/**
- * Context for an Audio FIFO Buffer.
- *
- * - Operates at the sample level rather than the byte level.
- * - Supports multiple channels with either planar or packed sample format.
- * - Automatic reallocation when writing to a full buffer.
- */
-typedef struct AVAudioFifo AVAudioFifo;
-
-/**
- * Free an AVAudioFifo.
- *
- * @param af AVAudioFifo to free
- */
-void av_audio_fifo_free(AVAudioFifo *af);
-
-/**
- * Allocate an AVAudioFifo.
- *
- * @param sample_fmt sample format
- * @param channels number of channels
- * @param nb_samples initial allocation size, in samples
- * @return newly allocated AVAudioFifo, or NULL on error
- */
-AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels,
- int nb_samples);
-
-/**
- * Reallocate an AVAudioFifo.
- *
- * @param af AVAudioFifo to reallocate
- * @param nb_samples new allocation size, in samples
- * @return 0 if OK, or negative AVERROR code on failure
- */
-av_warn_unused_result
-int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples);
-
-/**
- * Write data to an AVAudioFifo.
- *
- * The AVAudioFifo will be reallocated automatically if the available space
- * is less than nb_samples.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @param af AVAudioFifo to write to
- * @param data audio data plane pointers
- * @param nb_samples number of samples to write
- * @return number of samples actually written, or negative AVERROR
- * code on failure. If successful, the number of samples
- * actually written will always be nb_samples.
- */
-int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples);
-
-/**
- * Peek data from an AVAudioFifo.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @param af AVAudioFifo to read from
- * @param data audio data plane pointers
- * @param nb_samples number of samples to peek
- * @return number of samples actually peek, or negative AVERROR code
- * on failure. The number of samples actually peek will not
- * be greater than nb_samples, and will only be less than
- * nb_samples if av_audio_fifo_size is less than nb_samples.
- */
-int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples);
-
-/**
- * Peek data from an AVAudioFifo.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @param af AVAudioFifo to read from
- * @param data audio data plane pointers
- * @param nb_samples number of samples to peek
- * @param offset offset from current read position
- * @return number of samples actually peek, or negative AVERROR code
- * on failure. The number of samples actually peek will not
- * be greater than nb_samples, and will only be less than
- * nb_samples if av_audio_fifo_size is less than nb_samples.
- */
-int av_audio_fifo_peek_at(AVAudioFifo *af, void **data, int nb_samples, int offset);
-
-/**
- * Read data from an AVAudioFifo.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @param af AVAudioFifo to read from
- * @param data audio data plane pointers
- * @param nb_samples number of samples to read
- * @return number of samples actually read, or negative AVERROR code
- * on failure. The number of samples actually read will not
- * be greater than nb_samples, and will only be less than
- * nb_samples if av_audio_fifo_size is less than nb_samples.
- */
-int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples);
-
-/**
- * Drain data from an AVAudioFifo.
- *
- * Removes the data without reading it.
- *
- * @param af AVAudioFifo to drain
- * @param nb_samples number of samples to drain
- * @return 0 if OK, or negative AVERROR code on failure
- */
-int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples);
-
-/**
- * Reset the AVAudioFifo buffer.
- *
- * This empties all data in the buffer.
- *
- * @param af AVAudioFifo to reset
- */
-void av_audio_fifo_reset(AVAudioFifo *af);
-
-/**
- * Get the current number of samples in the AVAudioFifo available for reading.
- *
- * @param af the AVAudioFifo to query
- * @return number of samples available for reading
- */
-int av_audio_fifo_size(AVAudioFifo *af);
-
-/**
- * Get the current number of samples in the AVAudioFifo available for writing.
- *
- * @param af the AVAudioFifo to query
- * @return number of samples available for writing
- */
-int av_audio_fifo_space(AVAudioFifo *af);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_AUDIO_FIFO_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/avassert.h Deleted

@@ -1,75 +0,0 @@
-/*
- * copyright (c) 2010 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * simple assert() macros that are a bit more flexible than ISO C assert().
- * @author Michael Niedermayer <michaelni@gmx.at>
- */
-
-#ifndef AVUTIL_AVASSERT_H
-#define AVUTIL_AVASSERT_H
-
-#include <stdlib.h>
-#include "avutil.h"
-#include "log.h"
-
-/**
- * assert() equivalent, that is always enabled.
- */
-#define av_assert0(cond) do { \
- if (!(cond)) { \
- av_log(NULL, AV_LOG_PANIC, "Assertion %s failed at %s:%d\n", \
- AV_STRINGIFY(cond), __FILE__, __LINE__); \
- abort(); \
- } \
-} while (0)
-
-
-/**
- * assert() equivalent, that does not lie in speed critical code.
- * These asserts() thus can be enabled without fearing speed loss.
- */
-#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 0
-#define av_assert1(cond) av_assert0(cond)
-#else
-#define av_assert1(cond) ((void)0)
-#endif
-
-
-/**
- * assert() equivalent, that does lie in speed critical code.
- */
-#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1
-#define av_assert2(cond) av_assert0(cond)
-#define av_assert2_fpu() av_assert0_fpu()
-#else
-#define av_assert2(cond) ((void)0)
-#define av_assert2_fpu() ((void)0)
-#endif
-
-/**
- * Assert that floating point opperations can be executed.
- *
- * This will av_assert0() that the cpu is not in MMX state on X86
- */
-void av_assert0_fpu(void);
-
-#endif /* AVUTIL_AVASSERT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/avconfig.h Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/avstring.h Deleted

@@ -1,407 +0,0 @@
-/*
- * Copyright (c) 2007 Mans Rullgard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_AVSTRING_H
-#define AVUTIL_AVSTRING_H
-
-#include <stddef.h>
-#include <stdint.h>
-#include "attributes.h"
-
-/**
- * @addtogroup lavu_string
- * @{
- */
-
-/**
- * Return non-zero if pfx is a prefix of str. If it is, *ptr is set to
- * the address of the first character in str after the prefix.
- *
- * @param str input string
- * @param pfx prefix to test
- * @param ptr updated if the prefix is matched inside str
- * @return non-zero if the prefix matches, zero otherwise
- */
-int av_strstart(const char *str, const char *pfx, const char **ptr);
-
-/**
- * Return non-zero if pfx is a prefix of str independent of case. If
- * it is, *ptr is set to the address of the first character in str
- * after the prefix.
- *
- * @param str input string
- * @param pfx prefix to test
- * @param ptr updated if the prefix is matched inside str
- * @return non-zero if the prefix matches, zero otherwise
- */
-int av_stristart(const char *str, const char *pfx, const char **ptr);
-
-/**
- * Locate the first case-independent occurrence in the string haystack
- * of the string needle. A zero-length string needle is considered to
- * match at the start of haystack.
- *
- * This function is a case-insensitive version of the standard strstr().
- *
- * @param haystack string to search in
- * @param needle string to search for
- * @return pointer to the located match within haystack
- * or a null pointer if no match
- */
-char *av_stristr(const char *haystack, const char *needle);
-
-/**
- * Locate the first occurrence of the string needle in the string haystack
- * where not more than hay_length characters are searched. A zero-length
- * string needle is considered to match at the start of haystack.
- *
- * This function is a length-limited version of the standard strstr().
- *
- * @param haystack string to search in
- * @param needle string to search for
- * @param hay_length length of string to search in
- * @return pointer to the located match within haystack
- * or a null pointer if no match
- */
-char *av_strnstr(const char *haystack, const char *needle, size_t hay_length);
-
-/**
- * Copy the string src to dst, but no more than size - 1 bytes, and
- * null-terminate dst.
- *
- * This function is the same as BSD strlcpy().
- *
- * @param dst destination buffer
- * @param src source string
- * @param size size of destination buffer
- * @return the length of src
- *
- * @warning since the return value is the length of src, src absolutely
- * _must_ be a properly 0-terminated string, otherwise this will read beyond
- * the end of the buffer and possibly crash.
- */
-size_t av_strlcpy(char *dst, const char *src, size_t size);
-
-/**
- * Append the string src to the string dst, but to a total length of
- * no more than size - 1 bytes, and null-terminate dst.
- *
- * This function is similar to BSD strlcat(), but differs when
- * size <= strlen(dst).
- *
- * @param dst destination buffer
- * @param src source string
- * @param size size of destination buffer
- * @return the total length of src and dst
- *
- * @warning since the return value use the length of src and dst, these
- * absolutely _must_ be a properly 0-terminated strings, otherwise this
- * will read beyond the end of the buffer and possibly crash.
- */
-size_t av_strlcat(char *dst, const char *src, size_t size);
-
-/**
- * Append output to a string, according to a format. Never write out of
- * the destination buffer, and always put a terminating 0 within
- * the buffer.
- * @param dst destination buffer (string to which the output is
- * appended)
- * @param size total size of the destination buffer
- * @param fmt printf-compatible format string, specifying how the
- * following parameters are used
- * @return the length of the string that would have been generated
- * if enough space had been available
- */
-size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_format(3, 4);
-
-/**
- * Get the count of continuous non zero chars starting from the beginning.
- *
- * @param len maximum number of characters to check in the string, that
- * is the maximum value which is returned by the function
- */
-static inline size_t av_strnlen(const char *s, size_t len)
-{
- size_t i;
- for (i = 0; i < len && si; i++)
- ;
- return i;
-}
-
-/**
- * Print arguments following specified format into a large enough auto
- * allocated buffer. It is similar to GNU asprintf().
- * @param fmt printf-compatible format string, specifying how the
- * following parameters are used.
- * @return the allocated string
- * @note You have to free the string yourself with av_free().
- */
-char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2);
-
-/**
- * Convert a number to an av_malloced string.
- */
-char *av_d2str(double d);
-
-/**
- * Unescape the given string until a non escaped terminating char,
- * and return the token corresponding to the unescaped string.
- *
- * The normal \ and ' escaping is supported. Leading and trailing
- * whitespaces are removed, unless they are escaped with '\' or are
- * enclosed between ''.
- *
- * @param buf the buffer to parse, buf will be updated to point to the
- * terminating char
- * @param term a 0-terminated list of terminating chars
- * @return the malloced unescaped string, which must be av_freed by
- * the user, NULL in case of allocation failure
- */
-char *av_get_token(const char **buf, const char *term);
-
-/**
- * Split the string into several tokens which can be accessed by
- * successive calls to av_strtok().
- *
- * A token is defined as a sequence of characters not belonging to the
- * set specified in delim.
- *
- * On the first call to av_strtok(), s should point to the string to
- * parse, and the value of saveptr is ignored. In subsequent calls, s
- * should be NULL, and saveptr should be unchanged since the previous
- * call.
- *
- * This function is similar to strtok_r() defined in POSIX.1.
- *
- * @param s the string to parse, may be NULL
- * @param delim 0-terminated list of token delimiters, must be non-NULL
- * @param saveptr user-provided pointer which points to stored
- * information necessary for av_strtok() to continue scanning the same
- * string. saveptr is updated to point to the next character after the
- * first delimiter found, or to NULL if the string was terminated
- * @return the found token, or NULL when no token is found
- */
-char *av_strtok(char *s, const char *delim, char **saveptr);
-
-/**
- * Locale-independent conversion of ASCII isdigit.
- */
-static inline av_const int av_isdigit(int c)
-{
- return c >= '0' && c <= '9';
-}
-
-/**
- * Locale-independent conversion of ASCII isgraph.
- */
-static inline av_const int av_isgraph(int c)
-{
- return c > 32 && c < 127;
-}
-
-/**
- * Locale-independent conversion of ASCII isspace.
- */
-static inline av_const int av_isspace(int c)
-{
- return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' ||
- c == '\v';
-}
-
-/**
- * Locale-independent conversion of ASCII characters to uppercase.
- */
-static inline av_const int av_toupper(int c)
-{
- if (c >= 'a' && c <= 'z')
- c ^= 0x20;
- return c;
-}
-
-/**
- * Locale-independent conversion of ASCII characters to lowercase.
- */
-static inline av_const int av_tolower(int c)
-{
- if (c >= 'A' && c <= 'Z')
- c ^= 0x20;
- return c;
-}
-
-/**
- * Locale-independent conversion of ASCII isxdigit.
- */
-static inline av_const int av_isxdigit(int c)
-{
- c = av_tolower(c);
- return av_isdigit(c) || (c >= 'a' && c <= 'f');
-}
-
-/**
- * Locale-independent case-insensitive compare.
- * @note This means only ASCII-range characters are case-insensitive
- */
-int av_strcasecmp(const char *a, const char *b);
-
-/**
- * Locale-independent case-insensitive compare.
- * @note This means only ASCII-range characters are case-insensitive
- */
-int av_strncasecmp(const char *a, const char *b, size_t n);
-
-/**
- * Locale-independent strings replace.
- * @note This means only ASCII-range characters are replace
- */
-char *av_strireplace(const char *str, const char *from, const char *to);
-
-/**
- * Thread safe basename.
- * @param path the path, on DOS both \ and / are considered separators.
- * @return pointer to the basename substring.
- */
-const char *av_basename(const char *path);
-
-/**
- * Thread safe dirname.
- * @param path the path, on DOS both \ and / are considered separators.
- * @return the path with the separator replaced by the string terminator or ".".
- * @note the function may change the input string.
- */
-const char *av_dirname(char *path);
-
-/**
- * Match instances of a name in a comma-separated list of names.
- * List entries are checked from the start to the end of the names list,
- * the first match ends further processing. If an entry prefixed with '-'
- * matches, then 0 is returned. The "ALL" list entry is considered to
- * match all names.
- *
- * @param name Name to look for.
- * @param names List of names.
- * @return 1 on match, 0 otherwise.
- */
-int av_match_name(const char *name, const char *names);
-
-/**
- * Append path component to the existing path.
- * Path separator '/' is placed between when needed.
- * Resulting string have to be freed with av_free().
- * @param path base path
- * @param component component to be appended
- * @return new path or NULL on error.
- */
-char *av_append_path_component(const char *path, const char *component);
-
-enum AVEscapeMode {
- AV_ESCAPE_MODE_AUTO, ///< Use auto-selected escaping mode.
- AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping.
- AV_ESCAPE_MODE_QUOTE, ///< Use single-quote escaping.
-};
-
-/**
- * Consider spaces special and escape them even in the middle of the
- * string.
- *
- * This is equivalent to adding the whitespace characters to the special
- * characters lists, except it is guaranteed to use the exact same list
- * of whitespace characters as the rest of libavutil.
- */
-#define AV_ESCAPE_FLAG_WHITESPACE (1 << 0)
-
-/**
- * Escape only specified special characters.
- * Without this flag, escape also any characters that may be considered
- * special by av_get_token(), such as the single quote.
- */
-#define AV_ESCAPE_FLAG_STRICT (1 << 1)
-
-/**
- * Escape string in src, and put the escaped string in an allocated
- * string in *dst, which must be freed with av_free().
- *
- * @param dst pointer where an allocated string is put
- * @param src string to escape, must be non-NULL
- * @param special_chars string containing the special characters which
- * need to be escaped, can be NULL
- * @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros.
- * Any unknown value for mode will be considered equivalent to
- * AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without
- * notice.
- * @param flags flags which control how to escape, see AV_ESCAPE_FLAG_ macros
- * @return the length of the allocated string, or a negative error code in case of error
- * @see av_bprint_escape()
- */
-av_warn_unused_result
-int av_escape(char **dst, const char *src, const char *special_chars,
- enum AVEscapeMode mode, int flags);
-
-#define AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES 1 ///< accept codepoints over 0x10FFFF
-#define AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS 2 ///< accept non-characters - 0xFFFE and 0xFFFF
-#define AV_UTF8_FLAG_ACCEPT_SURROGATES 4 ///< accept UTF-16 surrogates codes
-#define AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES 8 ///< exclude control codes not accepted by XML
-
-#define AV_UTF8_FLAG_ACCEPT_ALL \
- AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES|AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS|AV_UTF8_FLAG_ACCEPT_SURROGATES
-
-/**
- * Read and decode a single UTF-8 code point (character) from the
- * buffer in *buf, and update *buf to point to the next byte to
- * decode.
- *
- * In case of an invalid byte sequence, the pointer will be updated to
- * the next byte after the invalid sequence and the function will
- * return an error code.
- *
- * Depending on the specified flags, the function will also fail in
- * case the decoded code point does not belong to a valid range.
- *
- * @note For speed-relevant code a carefully implemented use of
- * GET_UTF8() may be preferred.
- *
- * @param codep pointer used to return the parsed code in case of success.
- * The value in *codep is set even in case the range check fails.
- * @param bufp pointer to the address the first byte of the sequence
- * to decode, updated by the function to point to the
- * byte next after the decoded sequence
- * @param buf_end pointer to the end of the buffer, points to the next
- * byte past the last in the buffer. This is used to
- * avoid buffer overreads (in case of an unfinished
- * UTF-8 sequence towards the end of the buffer).
- * @param flags a collection of AV_UTF8_FLAG_* flags
- * @return >= 0 in case a sequence was successfully read, a negative
- * value in case of invalid sequence
- */
-av_warn_unused_result
-int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,
- unsigned int flags);
-
-/**
- * Check if a name is in a list.
- * @returns 0 if not found, or the 1 based index where it has been found in the
- * list.
- */
-int av_match_list(const char *name, const char *list, char separator);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_AVSTRING_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/avutil.h Deleted

@@ -1,365 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_AVUTIL_H
-#define AVUTIL_AVUTIL_H
-
-/**
- * @file
- * @ingroup lavu
- * Convenience header that includes @ref lavu "libavutil"'s core.
- */
-
-/**
- * @mainpage
- *
- * @section ffmpeg_intro Introduction
- *
- * This document describes the usage of the different libraries
- * provided by FFmpeg.
- *
- * @li @ref libavc "libavcodec" encoding/decoding library
- * @li @ref lavfi "libavfilter" graph-based frame editing library
- * @li @ref libavf "libavformat" I/O and muxing/demuxing library
- * @li @ref lavd "libavdevice" special devices muxing/demuxing library
- * @li @ref lavu "libavutil" common utility library
- * @li @ref lswr "libswresample" audio resampling, format conversion and mixing
- * @li @ref lpp "libpostproc" post processing library
- * @li @ref libsws "libswscale" color conversion and scaling library
- *
- * @section ffmpeg_versioning Versioning and compatibility
- *
- * Each of the FFmpeg libraries contains a version.h header, which defines a
- * major, minor and micro version number with the
- * LIBRARYNAME_VERSION_{MAJOR,MINOR,MICRO} macros. The major version
- * number is incremented with backward incompatible changes - e.g. removing
- * parts of the public API, reordering public struct members, etc. The minor
- * version number is incremented for backward compatible API changes or major
- * new features - e.g. adding a new public function or a new decoder. The micro
- * version number is incremented for smaller changes that a calling program
- * might still want to check for - e.g. changing behavior in a previously
- * unspecified situation.
- *
- * FFmpeg guarantees backward API and ABI compatibility for each library as long
- * as its major version number is unchanged. This means that no public symbols
- * will be removed or renamed. Types and names of the public struct members and
- * values of public macros and enums will remain the same (unless they were
- * explicitly declared as not part of the public API). Documented behavior will
- * not change.
- *
- * In other words, any correct program that works with a given FFmpeg snapshot
- * should work just as well without any changes with any later snapshot with the
- * same major versions. This applies to both rebuilding the program against new
- * FFmpeg versions or to replacing the dynamic FFmpeg libraries that a program
- * links against.
- *
- * However, new public symbols may be added and new members may be appended to
- * public structs whose size is not part of public ABI (most public structs in
- * FFmpeg). New macros and enum values may be added. Behavior in undocumented
- * situations may change slightly (and be documented). All those are accompanied
- * by an entry in doc/APIchanges and incrementing either the minor or micro
- * version number.
- */
-
-/**
- * @defgroup lavu libavutil
- * Common code shared across all FFmpeg libraries.
- *
- * @note
- * libavutil is designed to be modular. In most cases, in order to use the
- * functions provided by one component of libavutil you must explicitly include
- * the specific header containing that feature. If you are only using
- * media-related components, you could simply include libavutil/avutil.h, which
- * brings in most of the "core" components.
- *
- * @{
- *
- * @defgroup lavu_crypto Crypto and Hashing
- *
- * @{
- * @}
- *
- * @defgroup lavu_math Mathematics
- * @{
- *
- * @}
- *
- * @defgroup lavu_string String Manipulation
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_mem Memory Management
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_data Data Structures
- * @{
- *
- * @}
- *
- * @defgroup lavu_video Video related
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_audio Audio related
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_error Error Codes
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_log Logging Facility
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_misc Other
- *
- * @{
- *
- * @defgroup preproc_misc Preprocessor String Macros
- *
- * @{
- *
- * @}
- *
- * @defgroup version_utils Library Version Macros
- *
- * @{
- *
- * @}
- */
-
-
-/**
- * @addtogroup lavu_ver
- * @{
- */
-
-/**
- * Return the LIBAVUTIL_VERSION_INT constant.
- */
-unsigned avutil_version(void);
-
-/**
- * Return an informative version string. This usually is the actual release
- * version number or a git commit description. This string has no fixed format
- * and can change any time. It should never be parsed by code.
- */
-const char *av_version_info(void);
-
-/**
- * Return the libavutil build-time configuration.
- */
-const char *avutil_configuration(void);
-
-/**
- * Return the libavutil license.
- */
-const char *avutil_license(void);
-
-/**
- * @}
- */
-
-/**
- * @addtogroup lavu_media Media Type
- * @brief Media Type
- */
-
-enum AVMediaType {
- AVMEDIA_TYPE_UNKNOWN = -1, ///< Usually treated as AVMEDIA_TYPE_DATA
- AVMEDIA_TYPE_VIDEO,
- AVMEDIA_TYPE_AUDIO,
- AVMEDIA_TYPE_DATA, ///< Opaque data information usually continuous
- AVMEDIA_TYPE_SUBTITLE,
- AVMEDIA_TYPE_ATTACHMENT, ///< Opaque data information usually sparse
- AVMEDIA_TYPE_NB
-};
-
-/**
- * Return a string describing the media_type enum, NULL if media_type
- * is unknown.
- */
-const char *av_get_media_type_string(enum AVMediaType media_type);
-
-/**
- * @defgroup lavu_const Constants
- * @{
- *
- * @defgroup lavu_enc Encoding specific
- *
- * @note those definition should move to avcodec
- * @{
- */
-
-#define FF_LAMBDA_SHIFT 7
-#define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT)
-#define FF_QP2LAMBDA 118 ///< factor to convert from H.263 QP to lambda
-#define FF_LAMBDA_MAX (256*128-1)
-
-#define FF_QUALITY_SCALE FF_LAMBDA_SCALE //FIXME maybe remove
-
-/**
- * @}
- * @defgroup lavu_time Timestamp specific
- *
- * FFmpeg internal timebase and timestamp definitions
- *
- * @{
- */
-
-/**
- * @brief Undefined timestamp value
- *
- * Usually reported by demuxer that work on containers that do not provide
- * either pts or dts.
- */
-
-#define AV_NOPTS_VALUE ((int64_t)UINT64_C(0x8000000000000000))
-
-/**
- * Internal time base represented as integer
- */
-
-#define AV_TIME_BASE 1000000
-
-/**
- * Internal time base represented as fractional value
- */
-
-#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}
-
-/**
- * @}
- * @}
- * @defgroup lavu_picture Image related
- *
- * AVPicture types, pixel formats and basic image planes manipulation.
- *
- * @{
- */
-
-enum AVPictureType {
- AV_PICTURE_TYPE_NONE = 0, ///< Undefined
- AV_PICTURE_TYPE_I, ///< Intra
- AV_PICTURE_TYPE_P, ///< Predicted
- AV_PICTURE_TYPE_B, ///< Bi-dir predicted
- AV_PICTURE_TYPE_S, ///< S(GMC)-VOP MPEG-4
- AV_PICTURE_TYPE_SI, ///< Switching Intra
- AV_PICTURE_TYPE_SP, ///< Switching Predicted
- AV_PICTURE_TYPE_BI, ///< BI type
-};
-
-/**
- * Return a single letter to describe the given picture type
- * pict_type.
- *
- * @paramin pict_type the picture type @return a single character
- * representing the picture type, '?' if pict_type is unknown
- */
-char av_get_picture_type_char(enum AVPictureType pict_type);
-
-/**
- * @}
- */
-
-#include "common.h"
-#include "error.h"
-#include "rational.h"
-#include "version.h"
-#include "macros.h"
-#include "mathematics.h"
-#include "log.h"
-#include "pixfmt.h"
-
-/**
- * Return x default pointer in case p is NULL.
- */
-static inline void *av_x_if_null(const void *p, const void *x)
-{
- return (void *)(intptr_t)(p ? p : x);
-}
-
-/**
- * Compute the length of an integer list.
- *
- * @param elsize size in bytes of each list element (only 1, 2, 4 or 8)
- * @param term list terminator (usually 0 or -1)
- * @param list pointer to the list
- * @return length of the list, in elements, not counting the terminator
- */
-unsigned av_int_list_length_for_size(unsigned elsize,
- const void *list, uint64_t term) av_pure;
-
-/**
- * Compute the length of an integer list.
- *
- * @param term list terminator (usually 0 or -1)
- * @param list pointer to the list
- * @return length of the list, in elements, not counting the terminator
- */
-#define av_int_list_length(list, term) \
- av_int_list_length_for_size(sizeof(*(list)), list, term)
-
-/**
- * Open a file using a UTF-8 filename.
- * The API of this function matches POSIX fopen(), errors are returned through
- * errno.
- */
-FILE *av_fopen_utf8(const char *path, const char *mode);
-
-/**
- * Return the fractional representation of the internal time base.
- */
-AVRational av_get_time_base_q(void);
-
-#define AV_FOURCC_MAX_STRING_SIZE 32
-
-#define av_fourcc2str(fourcc) av_fourcc_make_string((charAV_FOURCC_MAX_STRING_SIZE){0}, fourcc)
-
-/**
- * Fill the provided buffer with a string containing a FourCC (four-character
- * code) representation.
- *
- * @param buf a buffer with size in bytes of at least AV_FOURCC_MAX_STRING_SIZE
- * @param fourcc the fourcc to represent
- * @return the buffer in input
- */
-char *av_fourcc_make_string(char *buf, uint32_t fourcc);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_AVUTIL_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/base64.h Deleted

@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2006 Ryan Martell. (rdm4@martellventures.com)
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_BASE64_H
-#define AVUTIL_BASE64_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_base64 Base64
- * @ingroup lavu_crypto
- * @{
- */
-
-/**
- * Decode a base64-encoded string.
- *
- * @param out buffer for decoded data
- * @param in null-terminated input string
- * @param out_size size in bytes of the out buffer, must be at
- * least 3/4 of the length of in, that is AV_BASE64_DECODE_SIZE(strlen(in))
- * @return number of bytes written, or a negative value in case of
- * invalid input
- */
-int av_base64_decode(uint8_t *out, const char *in, int out_size);
-
-/**
- * Calculate the output size in bytes needed to decode a base64 string
- * with length x to a data buffer.
- */
-#define AV_BASE64_DECODE_SIZE(x) ((x) * 3LL / 4)
-
-/**
- * Encode data to base64 and null-terminate.
- *
- * @param out buffer for encoded data
- * @param out_size size in bytes of the out buffer (including the
- * null terminator), must be at least AV_BASE64_SIZE(in_size)
- * @param in input buffer containing the data to encode
- * @param in_size size in bytes of the in buffer
- * @return out or NULL in case of error
- */
-char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size);
-
-/**
- * Calculate the output size needed to base64-encode x bytes to a
- * null-terminated string.
- */
-#define AV_BASE64_SIZE(x) (((x)+2) / 3 * 4 + 1)
-
- /**
- * @}
- */
-
-#endif /* AVUTIL_BASE64_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/blowfish.h Deleted

@@ -1,82 +0,0 @@
-/*
- * Blowfish algorithm
- * Copyright (c) 2012 Samuel Pitoiset
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_BLOWFISH_H
-#define AVUTIL_BLOWFISH_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_blowfish Blowfish
- * @ingroup lavu_crypto
- * @{
- */
-
-#define AV_BF_ROUNDS 16
-
-typedef struct AVBlowfish {
- uint32_t pAV_BF_ROUNDS + 2;
- uint32_t s4256;
-} AVBlowfish;
-
-/**
- * Allocate an AVBlowfish context.
- */
-AVBlowfish *av_blowfish_alloc(void);
-
-/**
- * Initialize an AVBlowfish context.
- *
- * @param ctx an AVBlowfish context
- * @param key a key
- * @param key_len length of the key
- */
-void av_blowfish_init(struct AVBlowfish *ctx, const uint8_t *key, int key_len);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context.
- *
- * @param ctx an AVBlowfish context
- * @param xl left four bytes halves of input to be encrypted
- * @param xr right four bytes halves of input to be encrypted
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_blowfish_crypt_ecb(struct AVBlowfish *ctx, uint32_t *xl, uint32_t *xr,
- int decrypt);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context.
- *
- * @param ctx an AVBlowfish context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 8 byte blocks
- * @param iv initialization vector for CBC mode, if NULL ECB will be used
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_blowfish_crypt(struct AVBlowfish *ctx, uint8_t *dst, const uint8_t *src,
- int count, uint8_t *iv, int decrypt);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_BLOWFISH_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/bprint.h Deleted

@@ -1,219 +0,0 @@
-/*
- * Copyright (c) 2012 Nicolas George
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_BPRINT_H
-#define AVUTIL_BPRINT_H
-
-#include <stdarg.h>
-
-#include "attributes.h"
-#include "avstring.h"
-
-/**
- * Define a structure with extra padding to a fixed size
- * This helps ensuring binary compatibility with future versions.
- */
-
-#define FF_PAD_STRUCTURE(name, size, ...) \
-struct ff_pad_helper_##name { __VA_ARGS__ }; \
-typedef struct name { \
- __VA_ARGS__ \
- char reserved_paddingsize - sizeof(struct ff_pad_helper_##name); \
-} name;
-
-/**
- * Buffer to print data progressively
- *
- * The string buffer grows as necessary and is always 0-terminated.
- * The content of the string is never accessed, and thus is
- * encoding-agnostic and can even hold binary data.
- *
- * Small buffers are kept in the structure itself, and thus require no
- * memory allocation at all (unless the contents of the buffer is needed
- * after the structure goes out of scope). This is almost as lightweight as
- * declaring a local "char buf512".
- *
- * The length of the string can go beyond the allocated size: the buffer is
- * then truncated, but the functions still keep account of the actual total
- * length.
- *
- * In other words, buf->len can be greater than buf->size and records the
- * total length of what would have been to the buffer if there had been
- * enough memory.
- *
- * Append operations do not need to be tested for failure: if a memory
- * allocation fails, data stop being appended to the buffer, but the length
- * is still updated. This situation can be tested with
- * av_bprint_is_complete().
- *
- * The size_max field determines several possible behaviours:
- *
- * size_max = -1 (= UINT_MAX) or any large value will let the buffer be
- * reallocated as necessary, with an amortized linear cost.
- *
- * size_max = 0 prevents writing anything to the buffer: only the total
- * length is computed. The write operations can then possibly be repeated in
- * a buffer with exactly the necessary size
- * (using size_init = size_max = len + 1).
- *
- * size_max = 1 is automatically replaced by the exact size available in the
- * structure itself, thus ensuring no dynamic memory allocation. The
- * internal buffer is large enough to hold a reasonable paragraph of text,
- * such as the current paragraph.
- */
-
-FF_PAD_STRUCTURE(AVBPrint, 1024,
- char *str; /**< string so far */
- unsigned len; /**< length so far */
- unsigned size; /**< allocated memory */
- unsigned size_max; /**< maximum allocated memory */
- char reserved_internal_buffer1;
-)
-
-/**
- * Convenience macros for special values for av_bprint_init() size_max
- * parameter.
- */
-#define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1)
-#define AV_BPRINT_SIZE_AUTOMATIC 1
-#define AV_BPRINT_SIZE_COUNT_ONLY 0
-
-/**
- * Init a print buffer.
- *
- * @param buf buffer to init
- * @param size_init initial size (including the final 0)
- * @param size_max maximum size;
- * 0 means do not write anything, just count the length;
- * 1 is replaced by the maximum value for automatic storage;
- * any large value means that the internal buffer will be
- * reallocated as needed up to that limit; -1 is converted to
- * UINT_MAX, the largest limit possible.
- * Check also AV_BPRINT_SIZE_* macros.
- */
-void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max);
-
-/**
- * Init a print buffer using a pre-existing buffer.
- *
- * The buffer will not be reallocated.
- *
- * @param buf buffer structure to init
- * @param buffer byte buffer to use for the string data
- * @param size size of buffer
- */
-void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size);
-
-/**
- * Append a formatted string to a print buffer.
- */
-void av_bprintf(AVBPrint *buf, const char *fmt, ...) av_printf_format(2, 3);
-
-/**
- * Append a formatted string to a print buffer.
- */
-void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg);
-
-/**
- * Append char c n times to a print buffer.
- */
-void av_bprint_chars(AVBPrint *buf, char c, unsigned n);
-
-/**
- * Append data to a print buffer.
- *
- * param buf bprint buffer to use
- * param data pointer to data
- * param size size of data
- */
-void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size);
-
-struct tm;
-/**
- * Append a formatted date and time to a print buffer.
- *
- * param buf bprint buffer to use
- * param fmt date and time format string, see strftime()
- * param tm broken-down time structure to translate
- *
- * @note due to poor design of the standard strftime function, it may
- * produce poor results if the format string expands to a very long text and
- * the bprint buffer is near the limit stated by the size_max option.
- */
-void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm);
-
-/**
- * Allocate bytes in the buffer for external use.
- *
- * @paramin buf buffer structure
- * @paramin size required size
- * @paramout mem pointer to the memory area
- * @paramout actual_size size of the memory area after allocation;
- * can be larger or smaller than size
- */
-void av_bprint_get_buffer(AVBPrint *buf, unsigned size,
- unsigned char **mem, unsigned *actual_size);
-
-/**
- * Reset the string to "" but keep internal allocated data.
- */
-void av_bprint_clear(AVBPrint *buf);
-
-/**
- * Test if the print buffer is complete (not truncated).
- *
- * It may have been truncated due to a memory allocation failure
- * or the size_max limit (compare size and size_max if necessary).
- */
-static inline int av_bprint_is_complete(const AVBPrint *buf)
-{
- return buf->len < buf->size;
-}
-
-/**
- * Finalize a print buffer.
- *
- * The print buffer can no longer be used afterwards,
- * but the len and size fields are still valid.
- *
- * @argout ret_str if not NULL, used to return a permanent copy of the
- * buffer contents, or NULL if memory allocation fails;
- * if NULL, the buffer is discarded and freed
- * @return 0 for success or error code (probably AVERROR(ENOMEM))
- */
-int av_bprint_finalize(AVBPrint *buf, char **ret_str);
-
-/**
- * Escape the content in src and append it to dstbuf.
- *
- * @param dstbuf already inited destination bprint buffer
- * @param src string containing the text to escape
- * @param special_chars string containing the special characters which
- * need to be escaped, can be NULL
- * @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros.
- * Any unknown value for mode will be considered equivalent to
- * AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without
- * notice.
- * @param flags flags which control how to escape, see AV_ESCAPE_FLAG_* macros
- */
-void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars,
- enum AVEscapeMode mode, int flags);
-
-#endif /* AVUTIL_BPRINT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/bswap.h Deleted

@@ -1,109 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * byte swapping routines
- */
-
-#ifndef AVUTIL_BSWAP_H
-#define AVUTIL_BSWAP_H
-
-#include <stdint.h>
-#include "libavutil/avconfig.h"
-#include "attributes.h"
-
-#ifdef HAVE_AV_CONFIG_H
-
-#include "config.h"
-
-#if ARCH_AARCH64
-# include "aarch64/bswap.h"
-#elif ARCH_ARM
-# include "arm/bswap.h"
-#elif ARCH_AVR32
-# include "avr32/bswap.h"
-#elif ARCH_SH4
-# include "sh4/bswap.h"
-#elif ARCH_X86
-# include "x86/bswap.h"
-#endif
-
-#endif /* HAVE_AV_CONFIG_H */
-
-#define AV_BSWAP16C(x) (((x) << 8 & 0xff00) | ((x) >> 8 & 0x00ff))
-#define AV_BSWAP32C(x) (AV_BSWAP16C(x) << 16 | AV_BSWAP16C((x) >> 16))
-#define AV_BSWAP64C(x) (AV_BSWAP32C(x) << 32 | AV_BSWAP32C((x) >> 32))
-
-#define AV_BSWAPC(s, x) AV_BSWAP##s##C(x)
-
-#ifndef av_bswap16
-static av_always_inline av_const uint16_t av_bswap16(uint16_t x)
-{
- x= (x>>8) | (x<<8);
- return x;
-}
-#endif
-
-#ifndef av_bswap32
-static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
-{
- return AV_BSWAP32C(x);
-}
-#endif
-
-#ifndef av_bswap64
-static inline uint64_t av_const av_bswap64(uint64_t x)
-{
- return (uint64_t)av_bswap32(x) << 32 | av_bswap32(x >> 32);
-}
-#endif
-
-// be2ne ... big-endian to native-endian
-// le2ne ... little-endian to native-endian
-
-#if AV_HAVE_BIGENDIAN
-#define av_be2ne16(x) (x)
-#define av_be2ne32(x) (x)
-#define av_be2ne64(x) (x)
-#define av_le2ne16(x) av_bswap16(x)
-#define av_le2ne32(x) av_bswap32(x)
-#define av_le2ne64(x) av_bswap64(x)
-#define AV_BE2NEC(s, x) (x)
-#define AV_LE2NEC(s, x) AV_BSWAPC(s, x)
-#else
-#define av_be2ne16(x) av_bswap16(x)
-#define av_be2ne32(x) av_bswap32(x)
-#define av_be2ne64(x) av_bswap64(x)
-#define av_le2ne16(x) (x)
-#define av_le2ne32(x) (x)
-#define av_le2ne64(x) (x)
-#define AV_BE2NEC(s, x) AV_BSWAPC(s, x)
-#define AV_LE2NEC(s, x) (x)
-#endif
-
-#define AV_BE2NE16C(x) AV_BE2NEC(16, x)
-#define AV_BE2NE32C(x) AV_BE2NEC(32, x)
-#define AV_BE2NE64C(x) AV_BE2NEC(64, x)
-#define AV_LE2NE16C(x) AV_LE2NEC(16, x)
-#define AV_LE2NE32C(x) AV_LE2NEC(32, x)
-#define AV_LE2NE64C(x) AV_LE2NEC(64, x)
-
-#endif /* AVUTIL_BSWAP_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/buffer.h Deleted

@@ -1,291 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_buffer
- * refcounted data buffer API
- */
-
-#ifndef AVUTIL_BUFFER_H
-#define AVUTIL_BUFFER_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_buffer AVBuffer
- * @ingroup lavu_data
- *
- * @{
- * AVBuffer is an API for reference-counted data buffers.
- *
- * There are two core objects in this API -- AVBuffer and AVBufferRef. AVBuffer
- * represents the data buffer itself; it is opaque and not meant to be accessed
- * by the caller directly, but only through AVBufferRef. However, the caller may
- * e.g. compare two AVBuffer pointers to check whether two different references
- * are describing the same data buffer. AVBufferRef represents a single
- * reference to an AVBuffer and it is the object that may be manipulated by the
- * caller directly.
- *
- * There are two functions provided for creating a new AVBuffer with a single
- * reference -- av_buffer_alloc() to just allocate a new buffer, and
- * av_buffer_create() to wrap an existing array in an AVBuffer. From an existing
- * reference, additional references may be created with av_buffer_ref().
- * Use av_buffer_unref() to free a reference (this will automatically free the
- * data once all the references are freed).
- *
- * The convention throughout this API and the rest of FFmpeg is such that the
- * buffer is considered writable if there exists only one reference to it (and
- * it has not been marked as read-only). The av_buffer_is_writable() function is
- * provided to check whether this is true and av_buffer_make_writable() will
- * automatically create a new writable buffer when necessary.
- * Of course nothing prevents the calling code from violating this convention,
- * however that is safe only when all the existing references are under its
- * control.
- *
- * @note Referencing and unreferencing the buffers is thread-safe and thus
- * may be done from multiple threads simultaneously without any need for
- * additional locking.
- *
- * @note Two different references to the same buffer can point to different
- * parts of the buffer (i.e. their AVBufferRef.data will not be equal).
- */
-
-/**
- * A reference counted buffer type. It is opaque and is meant to be used through
- * references (AVBufferRef).
- */
-typedef struct AVBuffer AVBuffer;
-
-/**
- * A reference to a data buffer.
- *
- * The size of this struct is not a part of the public ABI and it is not meant
- * to be allocated directly.
- */
-typedef struct AVBufferRef {
- AVBuffer *buffer;
-
- /**
- * The data buffer. It is considered writable if and only if
- * this is the only reference to the buffer, in which case
- * av_buffer_is_writable() returns 1.
- */
- uint8_t *data;
- /**
- * Size of data in bytes.
- */
- int size;
-} AVBufferRef;
-
-/**
- * Allocate an AVBuffer of the given size using av_malloc().
- *
- * @return an AVBufferRef of given size or NULL when out of memory
- */
-AVBufferRef *av_buffer_alloc(int size);
-
-/**
- * Same as av_buffer_alloc(), except the returned buffer will be initialized
- * to zero.
- */
-AVBufferRef *av_buffer_allocz(int size);
-
-/**
- * Always treat the buffer as read-only, even when it has only one
- * reference.
- */
-#define AV_BUFFER_FLAG_READONLY (1 << 0)
-
-/**
- * Create an AVBuffer from an existing array.
- *
- * If this function is successful, data is owned by the AVBuffer. The caller may
- * only access data through the returned AVBufferRef and references derived from
- * it.
- * If this function fails, data is left untouched.
- * @param data data array
- * @param size size of data in bytes
- * @param free a callback for freeing this buffer's data
- * @param opaque parameter to be got for processing or passed to free
- * @param flags a combination of AV_BUFFER_FLAG_*
- *
- * @return an AVBufferRef referring to data on success, NULL on failure.
- */
-AVBufferRef *av_buffer_create(uint8_t *data, int size,
- void (*free)(void *opaque, uint8_t *data),
- void *opaque, int flags);
-
-/**
- * Default free callback, which calls av_free() on the buffer data.
- * This function is meant to be passed to av_buffer_create(), not called
- * directly.
- */
-void av_buffer_default_free(void *opaque, uint8_t *data);
-
-/**
- * Create a new reference to an AVBuffer.
- *
- * @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on
- * failure.
- */
-AVBufferRef *av_buffer_ref(AVBufferRef *buf);
-
-/**
- * Free a given reference and automatically free the buffer if there are no more
- * references to it.
- *
- * @param buf the reference to be freed. The pointer is set to NULL on return.
- */
-void av_buffer_unref(AVBufferRef **buf);
-
-/**
- * @return 1 if the caller may write to the data referred to by buf (which is
- * true if and only if buf is the only reference to the underlying AVBuffer).
- * Return 0 otherwise.
- * A positive answer is valid until av_buffer_ref() is called on buf.
- */
-int av_buffer_is_writable(const AVBufferRef *buf);
-
-/**
- * @return the opaque parameter set by av_buffer_create.
- */
-void *av_buffer_get_opaque(const AVBufferRef *buf);
-
-int av_buffer_get_ref_count(const AVBufferRef *buf);
-
-/**
- * Create a writable reference from a given buffer reference, avoiding data copy
- * if possible.
- *
- * @param buf buffer reference to make writable. On success, buf is either left
- * untouched, or it is unreferenced and a new writable AVBufferRef is
- * written in its place. On failure, buf is left untouched.
- * @return 0 on success, a negative AVERROR on failure.
- */
-int av_buffer_make_writable(AVBufferRef **buf);
-
-/**
- * Reallocate a given buffer.
- *
- * @param buf a buffer reference to reallocate. On success, buf will be
- * unreferenced and a new reference with the required size will be
- * written in its place. On failure buf will be left untouched. *buf
- * may be NULL, then a new buffer is allocated.
- * @param size required new buffer size.
- * @return 0 on success, a negative AVERROR on failure.
- *
- * @note the buffer is actually reallocated with av_realloc() only if it was
- * initially allocated through av_buffer_realloc(NULL) and there is only one
- * reference to it (i.e. the one passed to this function). In all other cases
- * a new buffer is allocated and the data is copied.
- */
-int av_buffer_realloc(AVBufferRef **buf, int size);
-
-/**
- * @}
- */
-
-/**
- * @defgroup lavu_bufferpool AVBufferPool
- * @ingroup lavu_data
- *
- * @{
- * AVBufferPool is an API for a lock-free thread-safe pool of AVBuffers.
- *
- * Frequently allocating and freeing large buffers may be slow. AVBufferPool is
- * meant to solve this in cases when the caller needs a set of buffers of the
- * same size (the most obvious use case being buffers for raw video or audio
- * frames).
- *
- * At the beginning, the user must call av_buffer_pool_init() to create the
- * buffer pool. Then whenever a buffer is needed, call av_buffer_pool_get() to
- * get a reference to a new buffer, similar to av_buffer_alloc(). This new
- * reference works in all aspects the same way as the one created by
- * av_buffer_alloc(). However, when the last reference to this buffer is
- * unreferenced, it is returned to the pool instead of being freed and will be
- * reused for subsequent av_buffer_pool_get() calls.
- *
- * When the caller is done with the pool and no longer needs to allocate any new
- * buffers, av_buffer_pool_uninit() must be called to mark the pool as freeable.
- * Once all the buffers are released, it will automatically be freed.
- *
- * Allocating and releasing buffers with this API is thread-safe as long as
- * either the default alloc callback is used, or the user-supplied one is
- * thread-safe.
- */
-
-/**
- * The buffer pool. This structure is opaque and not meant to be accessed
- * directly. It is allocated with av_buffer_pool_init() and freed with
- * av_buffer_pool_uninit().
- */
-typedef struct AVBufferPool AVBufferPool;
-
-/**
- * Allocate and initialize a buffer pool.
- *
- * @param size size of each buffer in this pool
- * @param alloc a function that will be used to allocate new buffers when the
- * pool is empty. May be NULL, then the default allocator will be used
- * (av_buffer_alloc()).
- * @return newly created buffer pool on success, NULL on error.
- */
-AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
-
-/**
- * Allocate and initialize a buffer pool with a more complex allocator.
- *
- * @param size size of each buffer in this pool
- * @param opaque arbitrary user data used by the allocator
- * @param alloc a function that will be used to allocate new buffers when the
- * pool is empty.
- * @param pool_free a function that will be called immediately before the pool
- * is freed. I.e. after av_buffer_pool_uninit() is called
- * by the caller and all the frames are returned to the pool
- * and freed. It is intended to uninitialize the user opaque
- * data.
- * @return newly created buffer pool on success, NULL on error.
- */
-AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
- AVBufferRef* (*alloc)(void *opaque, int size),
- void (*pool_free)(void *opaque));
-
-/**
- * Mark the pool as being available for freeing. It will actually be freed only
- * once all the allocated buffers associated with the pool are released. Thus it
- * is safe to call this function while some of the allocated buffers are still
- * in use.
- *
- * @param pool pointer to the pool to be freed. It will be set to NULL.
- */
-void av_buffer_pool_uninit(AVBufferPool **pool);
-
-/**
- * Allocate a new AVBuffer, reusing an old buffer from the pool when available.
- * This function may be called simultaneously from multiple threads.
- *
- * @return a reference to the new buffer on success, NULL on error.
- */
-AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_BUFFER_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/camellia.h Deleted

@@ -1,70 +0,0 @@
-/*
- * An implementation of the CAMELLIA algorithm as mentioned in RFC3713
- * Copyright (c) 2014 Supraja Meedinti
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CAMELLIA_H
-#define AVUTIL_CAMELLIA_H
-
-#include <stdint.h>
-
-
-/**
- * @file
- * @brief Public header for libavutil CAMELLIA algorithm
- * @defgroup lavu_camellia CAMELLIA
- * @ingroup lavu_crypto
- * @{
- */
-
-extern const int av_camellia_size;
-
-struct AVCAMELLIA;
-
-/**
- * Allocate an AVCAMELLIA context
- * To free the struct: av_free(ptr)
- */
-struct AVCAMELLIA *av_camellia_alloc(void);
-
-/**
- * Initialize an AVCAMELLIA context.
- *
- * @param ctx an AVCAMELLIA context
- * @param key a key of 16, 24, 32 bytes used for encryption/decryption
- * @param key_bits number of keybits: possible are 128, 192, 256
- */
-int av_camellia_init(struct AVCAMELLIA *ctx, const uint8_t *key, int key_bits);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context
- *
- * @param ctx an AVCAMELLIA context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 16 byte blocks
- * @paran iv initialization vector for CBC mode, NULL for ECB mode
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt);
-
-/**
- * @}
- */
-#endif /* AVUTIL_CAMELLIA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/cast5.h Deleted

@@ -1,80 +0,0 @@
-/*
- * An implementation of the CAST128 algorithm as mentioned in RFC2144
- * Copyright (c) 2014 Supraja Meedinti
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CAST5_H
-#define AVUTIL_CAST5_H
-
-#include <stdint.h>
-
-
-/**
- * @file
- * @brief Public header for libavutil CAST5 algorithm
- * @defgroup lavu_cast5 CAST5
- * @ingroup lavu_crypto
- * @{
- */
-
-extern const int av_cast5_size;
-
-struct AVCAST5;
-
-/**
- * Allocate an AVCAST5 context
- * To free the struct: av_free(ptr)
- */
-struct AVCAST5 *av_cast5_alloc(void);
-/**
- * Initialize an AVCAST5 context.
- *
- * @param ctx an AVCAST5 context
- * @param key a key of 5,6,...16 bytes used for encryption/decryption
- * @param key_bits number of keybits: possible are 40,48,...,128
- * @return 0 on success, less than 0 on failure
- */
-int av_cast5_init(struct AVCAST5 *ctx, const uint8_t *key, int key_bits);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context, ECB mode only
- *
- * @param ctx an AVCAST5 context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 8 byte blocks
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_cast5_crypt(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, int decrypt);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context
- *
- * @param ctx an AVCAST5 context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 8 byte blocks
- * @param iv initialization vector for CBC mode, NULL for ECB mode
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_cast5_crypt2(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
-/**
- * @}
- */
-#endif /* AVUTIL_CAST5_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/channel_layout.h Deleted

@@ -1,232 +0,0 @@
-/*
- * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- * Copyright (c) 2008 Peter Ross
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CHANNEL_LAYOUT_H
-#define AVUTIL_CHANNEL_LAYOUT_H
-
-#include <stdint.h>
-
-/**
- * @file
- * audio channel layout utility functions
- */
-
-/**
- * @addtogroup lavu_audio
- * @{
- */
-
-/**
- * @defgroup channel_masks Audio channel masks
- *
- * A channel layout is a 64-bits integer with a bit set for every channel.
- * The number of bits set must be equal to the number of channels.
- * The value 0 means that the channel layout is not known.
- * @note this data structure is not powerful enough to handle channels
- * combinations that have the same channel multiple times, such as
- * dual-mono.
- *
- * @{
- */
-#define AV_CH_FRONT_LEFT 0x00000001
-#define AV_CH_FRONT_RIGHT 0x00000002
-#define AV_CH_FRONT_CENTER 0x00000004
-#define AV_CH_LOW_FREQUENCY 0x00000008
-#define AV_CH_BACK_LEFT 0x00000010
-#define AV_CH_BACK_RIGHT 0x00000020
-#define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040
-#define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080
-#define AV_CH_BACK_CENTER 0x00000100
-#define AV_CH_SIDE_LEFT 0x00000200
-#define AV_CH_SIDE_RIGHT 0x00000400
-#define AV_CH_TOP_CENTER 0x00000800
-#define AV_CH_TOP_FRONT_LEFT 0x00001000
-#define AV_CH_TOP_FRONT_CENTER 0x00002000
-#define AV_CH_TOP_FRONT_RIGHT 0x00004000
-#define AV_CH_TOP_BACK_LEFT 0x00008000
-#define AV_CH_TOP_BACK_CENTER 0x00010000
-#define AV_CH_TOP_BACK_RIGHT 0x00020000
-#define AV_CH_STEREO_LEFT 0x20000000 ///< Stereo downmix.
-#define AV_CH_STEREO_RIGHT 0x40000000 ///< See AV_CH_STEREO_LEFT.
-#define AV_CH_WIDE_LEFT 0x0000000080000000ULL
-#define AV_CH_WIDE_RIGHT 0x0000000100000000ULL
-#define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL
-#define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL
-#define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL
-
-/** Channel mask value used for AVCodecContext.request_channel_layout
- to indicate that the user requests the channel order of the decoder output
- to be the native codec channel order. */
-#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL
-
-/**
- * @}
- * @defgroup channel_mask_c Audio channel layouts
- * @{
- * */
-#define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER)
-#define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
-#define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
-#define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
-#define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
-#define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_HEXADECAGONAL (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
-#define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
-
-enum AVMatrixEncoding {
- AV_MATRIX_ENCODING_NONE,
- AV_MATRIX_ENCODING_DOLBY,
- AV_MATRIX_ENCODING_DPLII,
- AV_MATRIX_ENCODING_DPLIIX,
- AV_MATRIX_ENCODING_DPLIIZ,
- AV_MATRIX_ENCODING_DOLBYEX,
- AV_MATRIX_ENCODING_DOLBYHEADPHONE,
- AV_MATRIX_ENCODING_NB
-};
-
-/**
- * Return a channel layout id that matches name, or 0 if no match is found.
- *
- * name can be one or several of the following notations,
- * separated by '+' or '|':
- * - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0,
- * 5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix);
- * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC,
- * SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR);
- * - a number of channels, in decimal, followed by 'c', yielding
- * the default channel layout for that number of channels (@see
- * av_get_default_channel_layout);
- * - a channel layout mask, in hexadecimal starting with "0x" (see the
- * AV_CH_* macros).
- *
- * Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7"
- */
-uint64_t av_get_channel_layout(const char *name);
-
-/**
- * Return a channel layout and the number of channels based on the specified name.
- *
- * This function is similar to (@see av_get_channel_layout), but can also parse
- * unknown channel layout specifications.
- *
- * @paramin name channel layout specification string
- * @paramout channel_layout parsed channel layout (0 if unknown)
- * @paramout nb_channels number of channels
- *
- * @return 0 on success, AVERROR(EINVAL) if the parsing fails.
- */
-int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels);
-
-/**
- * Return a description of a channel layout.
- * If nb_channels is <= 0, it is guessed from the channel_layout.
- *
- * @param buf put here the string containing the channel layout
- * @param buf_size size in bytes of the buffer
- */
-void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
-
-struct AVBPrint;
-/**
- * Append a description of a channel layout to a bprint buffer.
- */
-void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
-
-/**
- * Return the number of channels in the channel layout.
- */
-int av_get_channel_layout_nb_channels(uint64_t channel_layout);
-
-/**
- * Return default channel layout for a given number of channels.
- */
-int64_t av_get_default_channel_layout(int nb_channels);
-
-/**
- * Get the index of a channel in channel_layout.
- *
- * @param channel a channel layout describing exactly one channel which must be
- * present in channel_layout.
- *
- * @return index of channel in channel_layout on success, a negative AVERROR
- * on error.
- */
-int av_get_channel_layout_channel_index(uint64_t channel_layout,
- uint64_t channel);
-
-/**
- * Get the channel with the given index in channel_layout.
- */
-uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
-
-/**
- * Get the name of a given channel.
- *
- * @return channel name on success, NULL on error.
- */
-const char *av_get_channel_name(uint64_t channel);
-
-/**
- * Get the description of a given channel.
- *
- * @param channel a channel layout with a single channel
- * @return channel description on success, NULL on error
- */
-const char *av_get_channel_description(uint64_t channel);
-
-/**
- * Get the value and name of a standard channel layout.
- *
- * @paramin index index in an internal list, starting at 0
- * @paramout layout channel layout mask
- * @paramout name name of the layout
- * @return 0 if the layout exists,
- * <0 if index is beyond the limits
- */
-int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
- const char **name);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_CHANNEL_LAYOUT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/common.h Deleted

@@ -1,560 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * common internal and external API header
- */
-
-#ifndef AVUTIL_COMMON_H
-#define AVUTIL_COMMON_H
-
-#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) && !defined(UINT64_C)
-#error missing -D__STDC_CONSTANT_MACROS / #define __STDC_CONSTANT_MACROS
-#endif
-
-#include <errno.h>
-#include <inttypes.h>
-#include <limits.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "attributes.h"
-#include "macros.h"
-#include "version.h"
-#include "libavutil/avconfig.h"
-
-#if AV_HAVE_BIGENDIAN
-# define AV_NE(be, le) (be)
-#else
-# define AV_NE(be, le) (le)
-#endif
-
-//rounded division & shift
-#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
-/* assume b>0 */
-#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
-/* Fast a/(1<<b) rounded toward +inf. Assume a>=0 and b>=0 */
-#define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
- : ((a) + (1<<(b)) - 1) >> (b))
-/* Backwards compat. */
-#define FF_CEIL_RSHIFT AV_CEIL_RSHIFT
-
-#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b))
-#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b))
-
-/**
- * Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they
- * are not representable as absolute values of their type. This is the same
- * as with *abs()
- * @see FFNABS()
- */
-#define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
-#define FFSIGN(a) ((a) > 0 ? 1 : -1)
-
-/**
- * Negative Absolute value.
- * this works for all integers of all types.
- * As with many macros, this evaluates its argument twice, it thus must not have
- * a sideeffect, that is FFNABS(x++) has undefined behavior.
- */
-#define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
-
-/**
- * Comparator.
- * For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0
- * if x == y. This is useful for instance in a qsort comparator callback.
- * Furthermore, compilers are able to optimize this to branchless code, and
- * there is no risk of overflow with signed types.
- * As with many macros, this evaluates its argument multiple times, it thus
- * must not have a side-effect.
- */
-#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
-
-#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
-#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
-#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
-#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
-
-#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
-#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)0))
-
-/* misc math functions */
-
-#ifdef HAVE_AV_CONFIG_H
-# include "config.h"
-# include "intmath.h"
-#endif
-
-/* Pull in unguarded fallback defines at the end of this file. */
-#include "common.h"
-
-#ifndef av_log2
-av_const int av_log2(unsigned v);
-#endif
-
-#ifndef av_log2_16bit
-av_const int av_log2_16bit(unsigned v);
-#endif
-
-/**
- * Clip a signed integer value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
- if (amin > amax) abort();
-#endif
- if (a < amin) return amin;
- else if (a > amax) return amax;
- else return a;
-}
-
-/**
- * Clip a signed 64bit integer value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
- if (amin > amax) abort();
-#endif
- if (a < amin) return amin;
- else if (a > amax) return amax;
- else return a;
-}
-
-/**
- * Clip a signed integer value into the 0-255 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const uint8_t av_clip_uint8_c(int a)
-{
- if (a&(~0xFF)) return (~a)>>31;
- else return a;
-}
-
-/**
- * Clip a signed integer value into the -128,127 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const int8_t av_clip_int8_c(int a)
-{
- if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F;
- else return a;
-}
-
-/**
- * Clip a signed integer value into the 0-65535 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
-{
- if (a&(~0xFFFF)) return (~a)>>31;
- else return a;
-}
-
-/**
- * Clip a signed integer value into the -32768,32767 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const int16_t av_clip_int16_c(int a)
-{
- if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
- else return a;
-}
-
-/**
- * Clip a signed 64-bit integer value into the -2147483648,2147483647 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a)
-{
- if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
- else return (int32_t)a;
-}
-
-/**
- * Clip a signed integer into the -(2^p),(2^p-1) range.
- * @param a value to clip
- * @param p bit position to clip at
- * @return clipped value
- */
-static av_always_inline av_const int av_clip_intp2_c(int a, int p)
-{
- if (((unsigned)a + (1 << p)) & ~((2 << p) - 1))
- return (a >> 31) ^ ((1 << p) - 1);
- else
- return a;
-}
-
-/**
- * Clip a signed integer to an unsigned power of two range.
- * @param a value to clip
- * @param p bit position to clip at
- * @return clipped value
- */
-static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
-{
- if (a & ~((1<<p) - 1)) return (~a) >> 31 & ((1<<p) - 1);
- else return a;
-}
-
-/**
- * Clear high bits from an unsigned integer starting with specific bit position
- * @param a value to clip
- * @param p bit position to clip at
- * @return clipped value
- */
-static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
-{
- return a & ((1 << p) - 1);
-}
-
-/**
- * Add two signed 32-bit values with saturation.
- *
- * @param a one value
- * @param b another value
- * @return sum with signed saturation
- */
-static av_always_inline int av_sat_add32_c(int a, int b)
-{
- return av_clipl_int32((int64_t)a + b);
-}
-
-/**
- * Add a doubled value to another value with saturation at both stages.
- *
- * @param a first value
- * @param b value doubled and added to a
- * @return sum sat(a + sat(2*b)) with signed saturation
- */
-static av_always_inline int av_sat_dadd32_c(int a, int b)
-{
- return av_sat_add32(a, av_sat_add32(b, b));
-}
-
-/**
- * Subtract two signed 32-bit values with saturation.
- *
- * @param a one value
- * @param b another value
- * @return difference with signed saturation
- */
-static av_always_inline int av_sat_sub32_c(int a, int b)
-{
- return av_clipl_int32((int64_t)a - b);
-}
-
-/**
- * Subtract a doubled value from another value with saturation at both stages.
- *
- * @param a first value
- * @param b value doubled and subtracted from a
- * @return difference sat(a - sat(2*b)) with signed saturation
- */
-static av_always_inline int av_sat_dsub32_c(int a, int b)
-{
- return av_sat_sub32(a, av_sat_add32(b, b));
-}
-
-/**
- * Clip a float value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
- if (amin > amax) abort();
-#endif
- if (a < amin) return amin;
- else if (a > amax) return amax;
- else return a;
-}
-
-/**
- * Clip a double value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
- if (amin > amax) abort();
-#endif
- if (a < amin) return amin;
- else if (a > amax) return amax;
- else return a;
-}
-
-/** Compute ceil(log2(x)).
- * @param x value used to compute ceil(log2(x))
- * @return computed ceiling of log2(x)
- */
-static av_always_inline av_const int av_ceil_log2_c(int x)
-{
- return av_log2((x - 1) << 1);
-}
-
-/**
- * Count number of bits set to one in x
- * @param x value to count bits of
- * @return the number of bits set to one in x
- */
-static av_always_inline av_const int av_popcount_c(uint32_t x)
-{
- x -= (x >> 1) & 0x55555555;
- x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
- x = (x + (x >> 4)) & 0x0F0F0F0F;
- x += x >> 8;
- return (x + (x >> 16)) & 0x3F;
-}
-
-/**
- * Count number of bits set to one in x
- * @param x value to count bits of
- * @return the number of bits set to one in x
- */
-static av_always_inline av_const int av_popcount64_c(uint64_t x)
-{
- return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
-}
-
-static av_always_inline av_const int av_parity_c(uint32_t v)
-{
- return av_popcount(v) & 1;
-}
-
-#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
-#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
-
-/**
- * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
- *
- * @param val Output value, must be an lvalue of type uint32_t.
- * @param GET_BYTE Expression reading one byte from the input.
- * Evaluated up to 7 times (4 for the currently
- * assigned Unicode range). With a memory buffer
- * input, this could be *ptr++.
- * @param ERROR Expression to be evaluated on invalid input,
- * typically a goto statement.
- *
- * @warning ERROR should not contain a loop control statement which
- * could interact with the internal while loop, and should force an
- * exit from the macro code (e.g. through a goto or a return) in order
- * to prevent undefined results.
- */
-#define GET_UTF8(val, GET_BYTE, ERROR)\
- val= (GET_BYTE);\
- {\
- uint32_t top = (val & 128) >> 1;\
- if ((val & 0xc0) == 0x80 || val >= 0xFE)\
- ERROR\
- while (val & top) {\
- int tmp= (GET_BYTE) - 128;\
- if(tmp>>6)\
- ERROR\
- val= (val<<6) + tmp;\
- top <<= 5;\
- }\
- val &= (top << 1) - 1;\
- }
-
-/**
- * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
- *
- * @param val Output value, must be an lvalue of type uint32_t.
- * @param GET_16BIT Expression returning two bytes of UTF-16 data converted
- * to native byte order. Evaluated one or two times.
- * @param ERROR Expression to be evaluated on invalid input,
- * typically a goto statement.
- */
-#define GET_UTF16(val, GET_16BIT, ERROR)\
- val = GET_16BIT;\
- {\
- unsigned int hi = val - 0xD800;\
- if (hi < 0x800) {\
- val = GET_16BIT - 0xDC00;\
- if (val > 0x3FFU || hi > 0x3FFU)\
- ERROR\
- val += (hi<<10) + 0x10000;\
- }\
- }\
-
-/**
- * @def PUT_UTF8(val, tmp, PUT_BYTE)
- * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
- * @param val is an input-only argument and should be of type uint32_t. It holds
- * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
- * val is given as a function it is executed only once.
- * @param tmp is a temporary variable and should be of type uint8_t. It
- * represents an intermediate value during conversion that is to be
- * output by PUT_BYTE.
- * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
- * It could be a function or a statement, and uses tmp as the input byte.
- * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
- * executed up to 4 times for values in the valid UTF-8 range and up to
- * 7 times in the general case, depending on the length of the converted
- * Unicode character.
- */
-#define PUT_UTF8(val, tmp, PUT_BYTE)\
- {\
- int bytes, shift;\
- uint32_t in = val;\
- if (in < 0x80) {\
- tmp = in;\
- PUT_BYTE\
- } else {\
- bytes = (av_log2(in) + 4) / 5;\
- shift = (bytes - 1) * 6;\
- tmp = (256 - (256 >> bytes)) | (in >> shift);\
- PUT_BYTE\
- while (shift >= 6) {\
- shift -= 6;\
- tmp = 0x80 | ((in >> shift) & 0x3f);\
- PUT_BYTE\
- }\
- }\
- }
-
-/**
- * @def PUT_UTF16(val, tmp, PUT_16BIT)
- * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
- * @param val is an input-only argument and should be of type uint32_t. It holds
- * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
- * val is given as a function it is executed only once.
- * @param tmp is a temporary variable and should be of type uint16_t. It
- * represents an intermediate value during conversion that is to be
- * output by PUT_16BIT.
- * @param PUT_16BIT writes the converted UTF-16 data to any proper destination
- * in desired endianness. It could be a function or a statement, and uses tmp
- * as the input byte. For example, PUT_BYTE could be "*output++ = tmp;"
- * PUT_BYTE will be executed 1 or 2 times depending on input character.
- */
-#define PUT_UTF16(val, tmp, PUT_16BIT)\
- {\
- uint32_t in = val;\
- if (in < 0x10000) {\
- tmp = in;\
- PUT_16BIT\
- } else {\
- tmp = 0xD800 | ((in - 0x10000) >> 10);\
- PUT_16BIT\
- tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
- PUT_16BIT\
- }\
- }\
-
-
-
-#include "mem.h"
-
-#ifdef HAVE_AV_CONFIG_H
-# include "internal.h"
-#endif /* HAVE_AV_CONFIG_H */
-
-#endif /* AVUTIL_COMMON_H */
-
-/*
- * The following definitions are outside the multiple inclusion guard
- * to ensure they are immediately available in intmath.h.
- */
-
-#ifndef av_ceil_log2
-# define av_ceil_log2 av_ceil_log2_c
-#endif
-#ifndef av_clip
-# define av_clip av_clip_c
-#endif
-#ifndef av_clip64
-# define av_clip64 av_clip64_c
-#endif
-#ifndef av_clip_uint8
-# define av_clip_uint8 av_clip_uint8_c
-#endif
-#ifndef av_clip_int8
-# define av_clip_int8 av_clip_int8_c
-#endif
-#ifndef av_clip_uint16
-# define av_clip_uint16 av_clip_uint16_c
-#endif
-#ifndef av_clip_int16
-# define av_clip_int16 av_clip_int16_c
-#endif
-#ifndef av_clipl_int32
-# define av_clipl_int32 av_clipl_int32_c
-#endif
-#ifndef av_clip_intp2
-# define av_clip_intp2 av_clip_intp2_c
-#endif
-#ifndef av_clip_uintp2
-# define av_clip_uintp2 av_clip_uintp2_c
-#endif
-#ifndef av_mod_uintp2
-# define av_mod_uintp2 av_mod_uintp2_c
-#endif
-#ifndef av_sat_add32
-# define av_sat_add32 av_sat_add32_c
-#endif
-#ifndef av_sat_dadd32
-# define av_sat_dadd32 av_sat_dadd32_c
-#endif
-#ifndef av_sat_sub32
-# define av_sat_sub32 av_sat_sub32_c
-#endif
-#ifndef av_sat_dsub32
-# define av_sat_dsub32 av_sat_dsub32_c
-#endif
-#ifndef av_clipf
-# define av_clipf av_clipf_c
-#endif
-#ifndef av_clipd
-# define av_clipd av_clipd_c
-#endif
-#ifndef av_popcount
-# define av_popcount av_popcount_c
-#endif
-#ifndef av_popcount64
-# define av_popcount64 av_popcount64_c
-#endif
-#ifndef av_parity
-# define av_parity av_parity_c
-#endif

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/cpu.h Deleted

@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CPU_H
-#define AVUTIL_CPU_H
-
-#include <stddef.h>
-
-#include "attributes.h"
-
-#define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */
-
- /* lower 16 bits - CPU features */
-#define AV_CPU_FLAG_MMX 0x0001 ///< standard MMX
-#define AV_CPU_FLAG_MMXEXT 0x0002 ///< SSE integer functions or AMD MMX ext
-#define AV_CPU_FLAG_MMX2 0x0002 ///< SSE integer functions or AMD MMX ext
-#define AV_CPU_FLAG_3DNOW 0x0004 ///< AMD 3DNOW
-#define AV_CPU_FLAG_SSE 0x0008 ///< SSE functions
-#define AV_CPU_FLAG_SSE2 0x0010 ///< PIV SSE2 functions
-#define AV_CPU_FLAG_SSE2SLOW 0x40000000 ///< SSE2 supported, but usually not faster
- ///< than regular MMX/SSE (e.g. Core1)
-#define AV_CPU_FLAG_3DNOWEXT 0x0020 ///< AMD 3DNowExt
-#define AV_CPU_FLAG_SSE3 0x0040 ///< Prescott SSE3 functions
-#define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster
- ///< than regular MMX/SSE (e.g. Core1)
-#define AV_CPU_FLAG_SSSE3 0x0080 ///< Conroe SSSE3 functions
-#define AV_CPU_FLAG_SSSE3SLOW 0x4000000 ///< SSSE3 supported, but usually not faster
-#define AV_CPU_FLAG_ATOM 0x10000000 ///< Atom processor, some SSSE3 instructions are slower
-#define AV_CPU_FLAG_SSE4 0x0100 ///< Penryn SSE4.1 functions
-#define AV_CPU_FLAG_SSE42 0x0200 ///< Nehalem SSE4.2 functions
-#define AV_CPU_FLAG_AESNI 0x80000 ///< Advanced Encryption Standard functions
-#define AV_CPU_FLAG_AVX 0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used
-#define AV_CPU_FLAG_AVXSLOW 0x8000000 ///< AVX supported, but slow when using YMM registers (e.g. Bulldozer)
-#define AV_CPU_FLAG_XOP 0x0400 ///< Bulldozer XOP functions
-#define AV_CPU_FLAG_FMA4 0x0800 ///< Bulldozer FMA4 functions
-#define AV_CPU_FLAG_CMOV 0x1000 ///< supports cmov instruction
-#define AV_CPU_FLAG_AVX2 0x8000 ///< AVX2 functions: requires OS support even if YMM registers aren't used
-#define AV_CPU_FLAG_FMA3 0x10000 ///< Haswell FMA3 functions
-#define AV_CPU_FLAG_BMI1 0x20000 ///< Bit Manipulation Instruction Set 1
-#define AV_CPU_FLAG_BMI2 0x40000 ///< Bit Manipulation Instruction Set 2
-#define AV_CPU_FLAG_AVX512 0x100000 ///< AVX-512 functions: requires OS support even if YMM/ZMM registers aren't used
-
-#define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard
-#define AV_CPU_FLAG_VSX 0x0002 ///< ISA 2.06
-#define AV_CPU_FLAG_POWER8 0x0004 ///< ISA 2.07
-
-#define AV_CPU_FLAG_ARMV5TE (1 << 0)
-#define AV_CPU_FLAG_ARMV6 (1 << 1)
-#define AV_CPU_FLAG_ARMV6T2 (1 << 2)
-#define AV_CPU_FLAG_VFP (1 << 3)
-#define AV_CPU_FLAG_VFPV3 (1 << 4)
-#define AV_CPU_FLAG_NEON (1 << 5)
-#define AV_CPU_FLAG_ARMV8 (1 << 6)
-#define AV_CPU_FLAG_VFP_VM (1 << 7) ///< VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations
-#define AV_CPU_FLAG_SETEND (1 <<16)
-
-/**
- * Return the flags which specify extensions supported by the CPU.
- * The returned value is affected by av_force_cpu_flags() if that was used
- * before. So av_get_cpu_flags() can easily be used in an application to
- * detect the enabled cpu flags.
- */
-int av_get_cpu_flags(void);
-
-/**
- * Disables cpu detection and forces the specified flags.
- * -1 is a special case that disables forcing of specific flags.
- */
-void av_force_cpu_flags(int flags);
-
-/**
- * Set a mask on flags returned by av_get_cpu_flags().
- * This function is mainly useful for testing.
- * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible
- */
-attribute_deprecated void av_set_cpu_flags_mask(int mask);
-
-/**
- * Parse CPU flags from a string.
- *
- * The returned flags contain the specified flags as well as related unspecified flags.
- *
- * This function exists only for compatibility with libav.
- * Please use av_parse_cpu_caps() when possible.
- * @return a combination of AV_CPU_* flags, negative on error.
- */
-attribute_deprecated
-int av_parse_cpu_flags(const char *s);
-
-/**
- * Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
- *
- * @return negative on error.
- */
-int av_parse_cpu_caps(unsigned *flags, const char *s);
-
-/**
- * @return the number of logical CPU cores present.
- */
-int av_cpu_count(void);
-
-/**
- * Get the maximum data alignment that may be required by FFmpeg.
- *
- * Note that this is affected by the build configuration and the CPU flags mask,
- * so e.g. if the CPU supports AVX, but libavutil has been built with
- * --disable-avx or the AV_CPU_FLAG_AVX flag has been disabled through
- * av_set_cpu_flags_mask(), then this function will behave as if AVX is not
- * present.
- */
-size_t av_cpu_max_align(void);
-
-#endif /* AVUTIL_CPU_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/crc.h Deleted

@@ -1,100 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_crc32
- * Public header for CRC hash function implementation.
- */
-
-#ifndef AVUTIL_CRC_H
-#define AVUTIL_CRC_H
-
-#include <stdint.h>
-#include <stddef.h>
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_crc32 CRC
- * @ingroup lavu_hash
- * CRC (Cyclic Redundancy Check) hash function implementation.
- *
- * This module supports numerous CRC polynomials, in addition to the most
- * widely used CRC-32-IEEE. See @ref AVCRCId for a list of available
- * polynomials.
- *
- * @{
- */
-
-typedef uint32_t AVCRC;
-
-typedef enum {
- AV_CRC_8_ATM,
- AV_CRC_16_ANSI,
- AV_CRC_16_CCITT,
- AV_CRC_32_IEEE,
- AV_CRC_32_IEEE_LE, /*< reversed bitorder version of AV_CRC_32_IEEE */
- AV_CRC_16_ANSI_LE, /*< reversed bitorder version of AV_CRC_16_ANSI */
- AV_CRC_24_IEEE,
- AV_CRC_8_EBU,
- AV_CRC_MAX, /*< Not part of public API! Do not use outside libavutil. */
-}AVCRCId;
-
-/**
- * Initialize a CRC table.
- * @param ctx must be an array of size sizeof(AVCRC)*257 or sizeof(AVCRC)*1024
- * @param le If 1, the lowest bit represents the coefficient for the highest
- * exponent of the corresponding polynomial (both for poly and
- * actual CRC).
- * If 0, you must swap the CRC parameter and the result of av_crc
- * if you need the standard representation (can be simplified in
- * most cases to e.g. bswap16):
- * av_bswap32(crc << (32-bits))
- * @param bits number of bits for the CRC
- * @param poly generator polynomial without the x**bits coefficient, in the
- * representation as specified by le
- * @param ctx_size size of ctx in bytes
- * @return <0 on failure
- */
-int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size);
-
-/**
- * Get an initialized standard CRC table.
- * @param crc_id ID of a standard CRC
- * @return a pointer to the CRC table or NULL on failure
- */
-const AVCRC *av_crc_get_table(AVCRCId crc_id);
-
-/**
- * Calculate the CRC of a block.
- * @param crc CRC of previous blocks if any or initial value for CRC
- * @return CRC updated with the data from the given block
- *
- * @see av_crc_init() "le" parameter
- */
-uint32_t av_crc(const AVCRC *ctx, uint32_t crc,
- const uint8_t *buffer, size_t length) av_pure;
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_CRC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/des.h Deleted

@@ -1,77 +0,0 @@
-/*
- * DES encryption/decryption
- * Copyright (c) 2007 Reimar Doeffinger
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_DES_H
-#define AVUTIL_DES_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_des DES
- * @ingroup lavu_crypto
- * @{
- */
-
-typedef struct AVDES {
- uint64_t round_keys316;
- int triple_des;
-} AVDES;
-
-/**
- * Allocate an AVDES context.
- */
-AVDES *av_des_alloc(void);
-
-/**
- * @brief Initializes an AVDES context.
- *
- * @param key_bits must be 64 or 192
- * @param decrypt 0 for encryption/CBC-MAC, 1 for decryption
- * @return zero on success, negative value otherwise
- */
-int av_des_init(struct AVDES *d, const uint8_t *key, int key_bits, int decrypt);
-
-/**
- * @brief Encrypts / decrypts using the DES algorithm.
- *
- * @param count number of 8 byte blocks
- * @param dst destination array, can be equal to src, must be 8-byte aligned
- * @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
- * @param iv initialization vector for CBC mode, if NULL then ECB will be used,
- * must be 8-byte aligned
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_des_crypt(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
-
-/**
- * @brief Calculates CBC-MAC using the DES algorithm.
- *
- * @param count number of 8 byte blocks
- * @param dst destination array, can be equal to src, must be 8-byte aligned
- * @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
- */
-void av_des_mac(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_DES_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/dict.h Deleted

@@ -1,200 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Public dictionary API.
- * @deprecated
- * AVDictionary is provided for compatibility with libav. It is both in
- * implementation as well as API inefficient. It does not scale and is
- * extremely slow with large dictionaries.
- * It is recommended that new code uses our tree container from tree.c/h
- * where applicable, which uses AVL trees to achieve O(log n) performance.
- */
-
-#ifndef AVUTIL_DICT_H
-#define AVUTIL_DICT_H
-
-#include <stdint.h>
-
-#include "version.h"
-
-/**
- * @addtogroup lavu_dict AVDictionary
- * @ingroup lavu_data
- *
- * @brief Simple key:value store
- *
- * @{
- * Dictionaries are used for storing key:value pairs. To create
- * an AVDictionary, simply pass an address of a NULL pointer to
- * av_dict_set(). NULL can be used as an empty dictionary wherever
- * a pointer to an AVDictionary is required.
- * Use av_dict_get() to retrieve an entry or iterate over all
- * entries and finally av_dict_free() to free the dictionary
- * and all its contents.
- *
- @code
- AVDictionary *d = NULL; // "create" an empty dictionary
- AVDictionaryEntry *t = NULL;
-
- av_dict_set(&d, "foo", "bar", 0); // add an entry
-
- char *k = av_strdup("key"); // if your strings are already allocated,
- char *v = av_strdup("value"); // you can avoid copying them like this
- av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
-
- while (t = av_dict_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) {
- <....> // iterate over all entries in d
- }
- av_dict_free(&d);
- @endcode
- */
-
-#define AV_DICT_MATCH_CASE 1 /**< Only get an entry with exact-case key match. Only relevant in av_dict_get(). */
-#define AV_DICT_IGNORE_SUFFIX 2 /**< Return first entry in a dictionary whose first part corresponds to the search key,
- ignoring the suffix of the found key string. Only relevant in av_dict_get(). */
-#define AV_DICT_DONT_STRDUP_KEY 4 /**< Take ownership of a key that's been
- allocated with av_malloc() or another memory allocation function. */
-#define AV_DICT_DONT_STRDUP_VAL 8 /**< Take ownership of a value that's been
- allocated with av_malloc() or another memory allocation function. */
-#define AV_DICT_DONT_OVERWRITE 16 ///< Don't overwrite existing entries.
-#define AV_DICT_APPEND 32 /**< If the entry already exists, append to it. Note that no
- delimiter is added, the strings are simply concatenated. */
-#define AV_DICT_MULTIKEY 64 /**< Allow to store several equal keys in the dictionary */
-
-typedef struct AVDictionaryEntry {
- char *key;
- char *value;
-} AVDictionaryEntry;
-
-typedef struct AVDictionary AVDictionary;
-
-/**
- * Get a dictionary entry with matching key.
- *
- * The returned entry key or value must not be changed, or it will
- * cause undefined behavior.
- *
- * To iterate through all the dictionary entries, you can set the matching key
- * to the null string "" and set the AV_DICT_IGNORE_SUFFIX flag.
- *
- * @param prev Set to the previous matching element to find the next.
- * If set to NULL the first matching element is returned.
- * @param key matching key
- * @param flags a collection of AV_DICT_* flags controlling how the entry is retrieved
- * @return found entry or NULL in case no matching entry was found in the dictionary
- */
-AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key,
- const AVDictionaryEntry *prev, int flags);
-
-/**
- * Get number of entries in dictionary.
- *
- * @param m dictionary
- * @return number of entries in dictionary
- */
-int av_dict_count(const AVDictionary *m);
-
-/**
- * Set the given entry in *pm, overwriting an existing entry.
- *
- * Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set,
- * these arguments will be freed on error.
- *
- * Warning: Adding a new entry to a dictionary invalidates all existing entries
- * previously returned with av_dict_get.
- *
- * @param pm pointer to a pointer to a dictionary struct. If *pm is NULL
- * a dictionary struct is allocated and put in *pm.
- * @param key entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)
- * @param value entry value to add to *pm (will be av_strduped or added as a new key depending on flags).
- * Passing a NULL value will cause an existing entry to be deleted.
- * @return >= 0 on success otherwise an error code <0
- */
-int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
-
-/**
- * Convenience wrapper for av_dict_set that converts the value to a string
- * and stores it.
- *
- * Note: If AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error.
- */
-int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags);
-
-/**
- * Parse the key/value pairs list and add the parsed entries to a dictionary.
- *
- * In case of failure, all the successfully set entries are stored in
- * *pm. You may need to manually free the created dictionary.
- *
- * @param key_val_sep a 0-terminated list of characters used to separate
- * key from value
- * @param pairs_sep a 0-terminated list of characters used to separate
- * two pairs from each other
- * @param flags flags to use when adding to dictionary.
- * AV_DICT_DONT_STRDUP_KEY and AV_DICT_DONT_STRDUP_VAL
- * are ignored since the key/value tokens will always
- * be duplicated.
- * @return 0 on success, negative AVERROR code on failure
- */
-int av_dict_parse_string(AVDictionary **pm, const char *str,
- const char *key_val_sep, const char *pairs_sep,
- int flags);
-
-/**
- * Copy entries from one AVDictionary struct into another.
- * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL,
- * this function will allocate a struct for you and put it in *dst
- * @param src pointer to source AVDictionary struct
- * @param flags flags to use when setting entries in *dst
- * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag
- * @return 0 on success, negative AVERROR code on failure. If dst was allocated
- * by this function, callers should free the associated memory.
- */
-int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags);
-
-/**
- * Free all the memory allocated for an AVDictionary struct
- * and all keys and values.
- */
-void av_dict_free(AVDictionary **m);
-
-/**
- * Get dictionary entries as a string.
- *
- * Create a string containing dictionary's entries.
- * Such string may be passed back to av_dict_parse_string().
- * @note String is escaped with backslashes ('\').
- *
- * @paramin m dictionary
- * @paramout buffer Pointer to buffer that will be allocated with string containg entries.
- * Buffer must be freed by the caller when is no longer needed.
- * @paramin key_val_sep character used to separate key from value
- * @paramin pairs_sep character used to separate two pairs from each other
- * @return >= 0 on success, negative on error
- * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
- */
-int av_dict_get_string(const AVDictionary *m, char **buffer,
- const char key_val_sep, const char pairs_sep);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_DICT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/display.h Deleted

@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2014 Vittorio Giovara <vittorio.giovara@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Display matrix
- */
-
-#ifndef AVUTIL_DISPLAY_H
-#define AVUTIL_DISPLAY_H
-
-#include <stdint.h>
-#include "common.h"
-
-/**
- * @addtogroup lavu_video
- * @{
- *
- * @defgroup lavu_video_display Display transformation matrix functions
- * @{
- */
-
-/**
- * @addtogroup lavu_video_display
- * The display transformation matrix specifies an affine transformation that
- * should be applied to video frames for correct presentation. It is compatible
- * with the matrices stored in the ISO/IEC 14496-12 container format.
- *
- * The data is a 3x3 matrix represented as a 9-element array:
- *
- * @code{.unparsed}
- * | a b u |
- * (a, b, u, c, d, v, x, y, w) -> | c d v |
- * | x y w |
- * @endcode
- *
- * All numbers are stored in native endianness, as 16.16 fixed-point values,
- * except for u, v and w, which are stored as 2.30 fixed-point values.
- *
- * The transformation maps a point (p, q) in the source (pre-transformation)
- * frame to the point (p', q') in the destination (post-transformation) frame as
- * follows:
- *
- * @code{.unparsed}
- * | a b u |
- * (p, q, 1) . | c d v | = z * (p', q', 1)
- * | x y w |
- * @endcode
- *
- * The transformation can also be more explicitly written in components as
- * follows:
- *
- * @code{.unparsed}
- * p' = (a * p + c * q + x) / z;
- * q' = (b * p + d * q + y) / z;
- * z = u * p + v * q + w
- * @endcode
- */
-
-/**
- * Extract the rotation component of the transformation matrix.
- *
- * @param matrix the transformation matrix
- * @return the angle (in degrees) by which the transformation rotates the frame
- * counterclockwise. The angle will be in range -180.0, 180.0,
- * or NaN if the matrix is singular.
- *
- * @note floating point numbers are inherently inexact, so callers are
- * recommended to round the return value to nearest integer before use.
- */
-double av_display_rotation_get(const int32_t matrix9);
-
-/**
- * Initialize a transformation matrix describing a pure counterclockwise
- * rotation by the specified angle (in degrees).
- *
- * @param matrix an allocated transformation matrix (will be fully overwritten
- * by this function)
- * @param angle rotation angle in degrees.
- */
-void av_display_rotation_set(int32_t matrix9, double angle);
-
-/**
- * Flip the input matrix horizontally and/or vertically.
- *
- * @param matrix an allocated transformation matrix
- * @param hflip whether the matrix should be flipped horizontally
- * @param vflip whether the matrix should be flipped vertically
- */
-void av_display_matrix_flip(int32_t matrix9, int hflip, int vflip);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_DISPLAY_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/downmix_info.h Deleted

@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2014 Tim Walker <tdskywalker@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_DOWNMIX_INFO_H
-#define AVUTIL_DOWNMIX_INFO_H
-
-#include "frame.h"
-
-/**
- * @file
- * audio downmix medatata
- */
-
-/**
- * @addtogroup lavu_audio
- * @{
- */
-
-/**
- * @defgroup downmix_info Audio downmix metadata
- * @{
- */
-
-/**
- * Possible downmix types.
- */
-enum AVDownmixType {
- AV_DOWNMIX_TYPE_UNKNOWN, /**< Not indicated. */
- AV_DOWNMIX_TYPE_LORO, /**< Lo/Ro 2-channel downmix (Stereo). */
- AV_DOWNMIX_TYPE_LTRT, /**< Lt/Rt 2-channel downmix, Dolby Surround compatible. */
- AV_DOWNMIX_TYPE_DPLII, /**< Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible. */
- AV_DOWNMIX_TYPE_NB /**< Number of downmix types. Not part of ABI. */
-};
-
-/**
- * This structure describes optional metadata relevant to a downmix procedure.
- *
- * All fields are set by the decoder to the value indicated in the audio
- * bitstream (if present), or to a "sane" default otherwise.
- */
-typedef struct AVDownmixInfo {
- /**
- * Type of downmix preferred by the mastering engineer.
- */
- enum AVDownmixType preferred_downmix_type;
-
- /**
- * Absolute scale factor representing the nominal level of the center
- * channel during a regular downmix.
- */
- double center_mix_level;
-
- /**
- * Absolute scale factor representing the nominal level of the center
- * channel during an Lt/Rt compatible downmix.
- */
- double center_mix_level_ltrt;
-
- /**
- * Absolute scale factor representing the nominal level of the surround
- * channels during a regular downmix.
- */
- double surround_mix_level;
-
- /**
- * Absolute scale factor representing the nominal level of the surround
- * channels during an Lt/Rt compatible downmix.
- */
- double surround_mix_level_ltrt;
-
- /**
- * Absolute scale factor representing the level at which the LFE data is
- * mixed into L/R channels during downmixing.
- */
- double lfe_mix_level;
-} AVDownmixInfo;
-
-/**
- * Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing.
- *
- * If the side data is absent, it is created and added to the frame.
- *
- * @param frame the frame for which the side data is to be obtained or created
- *
- * @return the AVDownmixInfo structure to be edited by the caller, or NULL if
- * the structure cannot be allocated.
- */
-AVDownmixInfo *av_downmix_info_update_side_data(AVFrame *frame);
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_DOWNMIX_INFO_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/encryption_info.h Deleted

@@ -1,200 +0,0 @@
-/**
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_ENCRYPTION_INFO_H
-#define AVUTIL_ENCRYPTION_INFO_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-typedef struct AVSubsampleEncryptionInfo {
- /** The number of bytes that are clear. */
- unsigned int bytes_of_clear_data;
-
- /**
- * The number of bytes that are protected. If using pattern encryption,
- * the pattern applies to only the protected bytes; if not using pattern
- * encryption, all these bytes are encrypted.
- */
- unsigned int bytes_of_protected_data;
-} AVSubsampleEncryptionInfo;
-
-/**
- * This describes encryption info for a packet. This contains frame-specific
- * info for how to decrypt the packet before passing it to the decoder.
- *
- * The size of this struct is not part of the public ABI.
- */
-typedef struct AVEncryptionInfo {
- /** The fourcc encryption scheme. */
- uint32_t scheme;
-
- /**
- * Only used for pattern encryption. This is the number of 16-byte blocks
- * that are encrypted.
- */
- uint32_t crypt_byte_block;
-
- /**
- * Only used for pattern encryption. This is the number of 16-byte blocks
- * that are clear.
- */
- uint32_t skip_byte_block;
-
- /**
- * The ID of the key used to encrypt the packet. This should always be
- * 16 bytes long, but may be changed in the future.
- */
- uint8_t *key_id;
- uint32_t key_id_size;
-
- /**
- * The initialization vector. This may have been zero-filled to be the
- * correct block size. This should always be 16 bytes long, but may be
- * changed in the future.
- */
- uint8_t *iv;
- uint32_t iv_size;
-
- /**
- * An array of subsample encryption info specifying how parts of the sample
- * are encrypted. If there are no subsamples, then the whole sample is
- * encrypted.
- */
- AVSubsampleEncryptionInfo *subsamples;
- uint32_t subsample_count;
-} AVEncryptionInfo;
-
-/**
- * This describes info used to initialize an encryption key system.
- *
- * The size of this struct is not part of the public ABI.
- */
-typedef struct AVEncryptionInitInfo {
- /**
- * A unique identifier for the key system this is for, can be NULL if it
- * is not known. This should always be 16 bytes, but may change in the
- * future.
- */
- uint8_t* system_id;
- uint32_t system_id_size;
-
- /**
- * An array of key IDs this initialization data is for. All IDs are the
- * same length. Can be NULL if there are no known key IDs.
- */
- uint8_t** key_ids;
- /** The number of key IDs. */
- uint32_t num_key_ids;
- /**
- * The number of bytes in each key ID. This should always be 16, but may
- * change in the future.
- */
- uint32_t key_id_size;
-
- /**
- * Key-system specific initialization data. This data is copied directly
- * from the file and the format depends on the specific key system. This
- * can be NULL if there is no initialization data; in that case, there
- * will be at least one key ID.
- */
- uint8_t* data;
- uint32_t data_size;
-} AVEncryptionInitInfo;
-
-/**
- * Allocates an AVEncryptionInfo structure and sub-pointers to hold the given
- * number of subsamples. This will allocate pointers for the key ID, IV,
- * and subsample entries, set the size members, and zero-initialize the rest.
- *
- * @param subsample_count The number of subsamples.
- * @param key_id_size The number of bytes in the key ID, should be 16.
- * @param key_id_size The number of bytes in the IV, should be 16.
- *
- * @return The new AVEncryptionInfo structure, or NULL on error.
- */
-AVEncryptionInfo *av_encryption_info_alloc(uint32_t subsample_count, uint32_t key_id_size, uint32_t iv_size);
-
-/**
- * Allocates an AVEncryptionInfo structure with a copy of the given data.
- * @return The new AVEncryptionInfo structure, or NULL on error.
- */
-AVEncryptionInfo *av_encryption_info_clone(const AVEncryptionInfo *info);
-
-/**
- * Frees the given encryption info object. This MUST NOT be used to free the
- * side-data data pointer, that should use normal side-data methods.
- */
-void av_encryption_info_free(AVEncryptionInfo *info);
-
-/**
- * Creates a copy of the AVEncryptionInfo that is contained in the given side
- * data. The resulting object should be passed to av_encryption_info_free()
- * when done.
- *
- * @return The new AVEncryptionInfo structure, or NULL on error.
- */
-AVEncryptionInfo *av_encryption_info_get_side_data(const uint8_t *side_data, size_t side_data_size);
-
-/**
- * Allocates and initializes side data that holds a copy of the given encryption
- * info. The resulting pointer should be either freed using av_free or given
- * to av_packet_add_side_data().
- *
- * @return The new side-data pointer, or NULL.
- */
-uint8_t *av_encryption_info_add_side_data(
- const AVEncryptionInfo *info, size_t *side_data_size);
-
-
-/**
- * Allocates an AVEncryptionInitInfo structure and sub-pointers to hold the
- * given sizes. This will allocate pointers and set all the fields.
- *
- * @return The new AVEncryptionInitInfo structure, or NULL on error.
- */
-AVEncryptionInitInfo *av_encryption_init_info_alloc(
- uint32_t system_id_size, uint32_t num_key_ids, uint32_t key_id_size, uint32_t data_size);
-
-/**
- * Frees the given encryption init info object. This MUST NOT be used to free
- * the side-data data pointer, that should use normal side-data methods.
- */
-void av_encryption_init_info_free(AVEncryptionInitInfo* info);
-
-/**
- * Creates a copy of the AVEncryptionInitInfo that is contained in the given
- * side data. The resulting object should be passed to
- * av_encryption_init_info_free() when done.
- *
- * @return The new AVEncryptionInitInfo structure, or NULL on error.
- */
-AVEncryptionInitInfo *av_encryption_init_info_get_side_data(
- const uint8_t* side_data, size_t side_data_size);
-
-/**
- * Allocates and initializes side data that holds a copy of the given encryption
- * init info. The resulting pointer should be either freed using av_free or
- * given to av_packet_add_side_data().
- *
- * @return The new side-data pointer, or NULL.
- */
-uint8_t *av_encryption_init_info_add_side_data(
- const AVEncryptionInitInfo *info, size_t *side_data_size);
-
-#endif /* AVUTIL_ENCRYPTION_INFO_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/error.h Deleted

@@ -1,126 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * error code definitions
- */
-
-#ifndef AVUTIL_ERROR_H
-#define AVUTIL_ERROR_H
-
-#include <errno.h>
-#include <stddef.h>
-
-/**
- * @addtogroup lavu_error
- *
- * @{
- */
-
-
-/* error handling */
-#if EDOM > 0
-#define AVERROR(e) (-(e)) ///< Returns a negative error code from a POSIX error code, to return from library functions.
-#define AVUNERROR(e) (-(e)) ///< Returns a POSIX error code from a library function error return value.
-#else
-/* Some platforms have E* and errno already negated. */
-#define AVERROR(e) (e)
-#define AVUNERROR(e) (e)
-#endif
-
-#define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d))
-
-#define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F') ///< Bitstream filter not found
-#define AVERROR_BUG FFERRTAG( 'B','U','G','!') ///< Internal bug, also see AVERROR_BUG2
-#define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S') ///< Buffer too small
-#define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C') ///< Decoder not found
-#define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M') ///< Demuxer not found
-#define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C') ///< Encoder not found
-#define AVERROR_EOF FFERRTAG( 'E','O','F',' ') ///< End of file
-#define AVERROR_EXIT FFERRTAG( 'E','X','I','T') ///< Immediate exit was requested; the called function should not be restarted
-#define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ') ///< Generic error in an external library
-#define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L') ///< Filter not found
-#define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A') ///< Invalid data found when processing input
-#define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X') ///< Muxer not found
-#define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T') ///< Option not found
-#define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E') ///< Not yet implemented in FFmpeg, patches welcome
-#define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O') ///< Protocol not found
-
-#define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R') ///< Stream not found
-/**
- * This is semantically identical to AVERROR_BUG
- * it has been introduced in Libav after our AVERROR_BUG and with a modified value.
- */
-#define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ')
-#define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N') ///< Unknown error, typically from an external library
-#define AVERROR_EXPERIMENTAL (-0x2bb2afa8) ///< Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
-#define AVERROR_INPUT_CHANGED (-0x636e6701) ///< Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
-#define AVERROR_OUTPUT_CHANGED (-0x636e6702) ///< Output changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_INPUT_CHANGED)
-/* HTTP & RTSP errors */
-#define AVERROR_HTTP_BAD_REQUEST FFERRTAG(0xF8,'4','0','0')
-#define AVERROR_HTTP_UNAUTHORIZED FFERRTAG(0xF8,'4','0','1')
-#define AVERROR_HTTP_FORBIDDEN FFERRTAG(0xF8,'4','0','3')
-#define AVERROR_HTTP_NOT_FOUND FFERRTAG(0xF8,'4','0','4')
-#define AVERROR_HTTP_OTHER_4XX FFERRTAG(0xF8,'4','X','X')
-#define AVERROR_HTTP_SERVER_ERROR FFERRTAG(0xF8,'5','X','X')
-
-#define AV_ERROR_MAX_STRING_SIZE 64
-
-/**
- * Put a description of the AVERROR code errnum in errbuf.
- * In case of failure the global variable errno is set to indicate the
- * error. Even in case of failure av_strerror() will print a generic
- * error message indicating the errnum provided to errbuf.
- *
- * @param errnum error code to describe
- * @param errbuf buffer to which description is written
- * @param errbuf_size the size in bytes of errbuf
- * @return 0 on success, a negative value if a description for errnum
- * cannot be found
- */
-int av_strerror(int errnum, char *errbuf, size_t errbuf_size);
-
-/**
- * Fill the provided buffer with a string containing an error string
- * corresponding to the AVERROR code errnum.
- *
- * @param errbuf a buffer
- * @param errbuf_size size in bytes of errbuf
- * @param errnum error code to describe
- * @return the buffer in input, filled with the error description
- * @see av_strerror()
- */
-static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum)
-{
- av_strerror(errnum, errbuf, errbuf_size);
- return errbuf;
-}
-
-/**
- * Convenience macro, the return value should be used only directly in
- * function arguments but never stand-alone.
- */
-#define av_err2str(errnum) \
- av_make_error_string((charAV_ERROR_MAX_STRING_SIZE){0}, AV_ERROR_MAX_STRING_SIZE, errnum)
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_ERROR_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/eval.h Deleted

@@ -1,113 +0,0 @@
-/*
- * Copyright (c) 2002 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * simple arithmetic expression evaluator
- */
-
-#ifndef AVUTIL_EVAL_H
-#define AVUTIL_EVAL_H
-
-#include "avutil.h"
-
-typedef struct AVExpr AVExpr;
-
-/**
- * Parse and evaluate an expression.
- * Note, this is significantly slower than av_expr_eval().
- *
- * @param res a pointer to a double where is put the result value of
- * the expression, or NAN in case of error
- * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)"
- * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0}
- * @param const_values a zero terminated array of values for the identifiers from const_names
- * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers
- * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument
- * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
- * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
- * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
- * @param log_ctx parent logging context
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code otherwise
- */
-int av_expr_parse_and_eval(double *res, const char *s,
- const char * const *const_names, const double *const_values,
- const char * const *func1_names, double (* const *funcs1)(void *, double),
- const char * const *func2_names, double (* const *funcs2)(void *, double, double),
- void *opaque, int log_offset, void *log_ctx);
-
-/**
- * Parse an expression.
- *
- * @param expr a pointer where is put an AVExpr containing the parsed
- * value in case of successful parsing, or NULL otherwise.
- * The pointed to AVExpr must be freed with av_expr_free() by the user
- * when it is not needed anymore.
- * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)"
- * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0}
- * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers
- * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument
- * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
- * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
- * @param log_ctx parent logging context
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code otherwise
- */
-int av_expr_parse(AVExpr **expr, const char *s,
- const char * const *const_names,
- const char * const *func1_names, double (* const *funcs1)(void *, double),
- const char * const *func2_names, double (* const *funcs2)(void *, double, double),
- int log_offset, void *log_ctx);
-
-/**
- * Evaluate a previously parsed expression.
- *
- * @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names
- * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
- * @return the value of the expression
- */
-double av_expr_eval(AVExpr *e, const double *const_values, void *opaque);
-
-/**
- * Free a parsed expression previously created with av_expr_parse().
- */
-void av_expr_free(AVExpr *e);
-
-/**
- * Parse the string in numstr and return its value as a double. If
- * the string is empty, contains only whitespaces, or does not contain
- * an initial substring that has the expected syntax for a
- * floating-point number, no conversion is performed. In this case,
- * returns a value of zero and the value returned in tail is the value
- * of numstr.
- *
- * @param numstr a string representing a number, may contain one of
- * the International System number postfixes, for example 'K', 'M',
- * 'G'. If 'i' is appended after the postfix, powers of 2 are used
- * instead of powers of 10. The 'B' postfix multiplies the value by
- * 8, and can be appended after another postfix or used alone. This
- * allows using for example 'KB', 'MiB', 'G' and 'B' as postfix.
- * @param tail if non-NULL puts here the pointer to the char next
- * after the last parsed character
- */
-double av_strtod(const char *numstr, char **tail);
-
-#endif /* AVUTIL_EVAL_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/ffversion.h Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/fifo.h Deleted

@@ -1,179 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * a very simple circular buffer FIFO implementation
- */
-
-#ifndef AVUTIL_FIFO_H
-#define AVUTIL_FIFO_H
-
-#include <stdint.h>
-#include "avutil.h"
-#include "attributes.h"
-
-typedef struct AVFifoBuffer {
- uint8_t *buffer;
- uint8_t *rptr, *wptr, *end;
- uint32_t rndx, wndx;
-} AVFifoBuffer;
-
-/**
- * Initialize an AVFifoBuffer.
- * @param size of FIFO
- * @return AVFifoBuffer or NULL in case of memory allocation failure
- */
-AVFifoBuffer *av_fifo_alloc(unsigned int size);
-
-/**
- * Initialize an AVFifoBuffer.
- * @param nmemb number of elements
- * @param size size of the single element
- * @return AVFifoBuffer or NULL in case of memory allocation failure
- */
-AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size);
-
-/**
- * Free an AVFifoBuffer.
- * @param f AVFifoBuffer to free
- */
-void av_fifo_free(AVFifoBuffer *f);
-
-/**
- * Free an AVFifoBuffer and reset pointer to NULL.
- * @param f AVFifoBuffer to free
- */
-void av_fifo_freep(AVFifoBuffer **f);
-
-/**
- * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
- * @param f AVFifoBuffer to reset
- */
-void av_fifo_reset(AVFifoBuffer *f);
-
-/**
- * Return the amount of data in bytes in the AVFifoBuffer, that is the
- * amount of data you can read from it.
- * @param f AVFifoBuffer to read from
- * @return size
- */
-int av_fifo_size(const AVFifoBuffer *f);
-
-/**
- * Return the amount of space in bytes in the AVFifoBuffer, that is the
- * amount of data you can write into it.
- * @param f AVFifoBuffer to write into
- * @return size
- */
-int av_fifo_space(const AVFifoBuffer *f);
-
-/**
- * Feed data at specific position from an AVFifoBuffer to a user-supplied callback.
- * Similar as av_fifo_gereric_read but without discarding data.
- * @param f AVFifoBuffer to read from
- * @param offset offset from current read position
- * @param buf_size number of bytes to read
- * @param func generic read function
- * @param dest data destination
- */
-int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_size, void (*func)(void*, void*, int));
-
-/**
- * Feed data from an AVFifoBuffer to a user-supplied callback.
- * Similar as av_fifo_gereric_read but without discarding data.
- * @param f AVFifoBuffer to read from
- * @param buf_size number of bytes to read
- * @param func generic read function
- * @param dest data destination
- */
-int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
-
-/**
- * Feed data from an AVFifoBuffer to a user-supplied callback.
- * @param f AVFifoBuffer to read from
- * @param buf_size number of bytes to read
- * @param func generic read function
- * @param dest data destination
- */
-int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
-
-/**
- * Feed data from a user-supplied callback to an AVFifoBuffer.
- * @param f AVFifoBuffer to write to
- * @param src data source; non-const since it may be used as a
- * modifiable context by the function defined in func
- * @param size number of bytes to write
- * @param func generic write function; the first parameter is src,
- * the second is dest_buf, the third is dest_buf_size.
- * func must return the number of bytes written to dest_buf, or <= 0 to
- * indicate no more data available to write.
- * If func is NULL, src is interpreted as a simple byte array for source data.
- * @return the number of bytes written to the FIFO
- */
-int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int));
-
-/**
- * Resize an AVFifoBuffer.
- * In case of reallocation failure, the old FIFO is kept unchanged.
- *
- * @param f AVFifoBuffer to resize
- * @param size new AVFifoBuffer size in bytes
- * @return <0 for failure, >=0 otherwise
- */
-int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
-
-/**
- * Enlarge an AVFifoBuffer.
- * In case of reallocation failure, the old FIFO is kept unchanged.
- * The new fifo size may be larger than the requested size.
- *
- * @param f AVFifoBuffer to resize
- * @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size()
- * @return <0 for failure, >=0 otherwise
- */
-int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space);
-
-/**
- * Read and discard the specified amount of data from an AVFifoBuffer.
- * @param f AVFifoBuffer to read from
- * @param size amount of data to read in bytes
- */
-void av_fifo_drain(AVFifoBuffer *f, int size);
-
-/**
- * Return a pointer to the data stored in a FIFO buffer at a certain offset.
- * The FIFO buffer is not modified.
- *
- * @param f AVFifoBuffer to peek at, f must be non-NULL
- * @param offs an offset in bytes, its absolute value must be less
- * than the used buffer size or the returned pointer will
- * point outside to the buffer data.
- * The used buffer size can be checked with av_fifo_size().
- */
-static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
-{
- uint8_t *ptr = f->rptr + offs;
- if (ptr >= f->end)
- ptr = f->buffer + (ptr - f->end);
- else if (ptr < f->buffer)
- ptr = f->end - (f->buffer - ptr);
- return ptr;
-}
-
-#endif /* AVUTIL_FIFO_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/file.h Deleted

@@ -1,69 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_FILE_H
-#define AVUTIL_FILE_H
-
-#include <stdint.h>
-
-#include "avutil.h"
-
-/**
- * @file
- * Misc file utilities.
- */
-
-/**
- * Read the file with name filename, and put its content in a newly
- * allocated buffer or map it with mmap() when available.
- * In case of success set *bufptr to the read or mmapped buffer, and
- * *size to the size in bytes of the buffer in *bufptr.
- * The returned buffer must be released with av_file_unmap().
- *
- * @param log_offset loglevel offset used for logging
- * @param log_ctx context used for logging
- * @return a non negative number in case of success, a negative value
- * corresponding to an AVERROR error code in case of failure
- */
-av_warn_unused_result
-int av_file_map(const char *filename, uint8_t **bufptr, size_t *size,
- int log_offset, void *log_ctx);
-
-/**
- * Unmap or free the buffer bufptr created by av_file_map().
- *
- * @param size size in bytes of bufptr, must be the same as returned
- * by av_file_map()
- */
-void av_file_unmap(uint8_t *bufptr, size_t size);
-
-/**
- * Wrapper to work around the lack of mkstemp() on mingw.
- * Also, tries to create file in /tmp first, if possible.
- * *prefix can be a character constant; *filename will be allocated internally.
- * @return file descriptor of opened file (or negative value corresponding to an
- * AVERROR code on error)
- * and opened file name in **filename.
- * @note On very old libcs it is necessary to set a secure umask before
- * calling this, av_tempfile() can't call umask itself as it is used in
- * libraries and could interfere with the calling application.
- * @deprecated as fd numbers cannot be passed saftely between libs on some platforms
- */
-int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx);
-
-#endif /* AVUTIL_FILE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/frame.h Deleted

@@ -1,893 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_frame
- * reference-counted frame API
- */
-
-#ifndef AVUTIL_FRAME_H
-#define AVUTIL_FRAME_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "avutil.h"
-#include "buffer.h"
-#include "dict.h"
-#include "rational.h"
-#include "samplefmt.h"
-#include "pixfmt.h"
-#include "version.h"
-
-
-/**
- * @defgroup lavu_frame AVFrame
- * @ingroup lavu_data
- *
- * @{
- * AVFrame is an abstraction for reference-counted raw multimedia data.
- */
-
-enum AVFrameSideDataType {
- /**
- * The data is the AVPanScan struct defined in libavcodec.
- */
- AV_FRAME_DATA_PANSCAN,
- /**
- * ATSC A53 Part 4 Closed Captions.
- * A53 CC bitstream is stored as uint8_t in AVFrameSideData.data.
- * The number of bytes of CC data is AVFrameSideData.size.
- */
- AV_FRAME_DATA_A53_CC,
- /**
- * Stereoscopic 3d metadata.
- * The data is the AVStereo3D struct defined in libavutil/stereo3d.h.
- */
- AV_FRAME_DATA_STEREO3D,
- /**
- * The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
- */
- AV_FRAME_DATA_MATRIXENCODING,
- /**
- * Metadata relevant to a downmix procedure.
- * The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h.
- */
- AV_FRAME_DATA_DOWNMIX_INFO,
- /**
- * ReplayGain information in the form of the AVReplayGain struct.
- */
- AV_FRAME_DATA_REPLAYGAIN,
- /**
- * This side data contains a 3x3 transformation matrix describing an affine
- * transformation that needs to be applied to the frame for correct
- * presentation.
- *
- * See libavutil/display.h for a detailed description of the data.
- */
- AV_FRAME_DATA_DISPLAYMATRIX,
- /**
- * Active Format Description data consisting of a single byte as specified
- * in ETSI TS 101 154 using AVActiveFormatDescription enum.
- */
- AV_FRAME_DATA_AFD,
- /**
- * Motion vectors exported by some codecs (on demand through the export_mvs
- * flag set in the libavcodec AVCodecContext flags2 option).
- * The data is the AVMotionVector struct defined in
- * libavutil/motion_vector.h.
- */
- AV_FRAME_DATA_MOTION_VECTORS,
- /**
- * Recommmends skipping the specified number of samples. This is exported
- * only if the "skip_manual" AVOption is set in libavcodec.
- * This has the same format as AV_PKT_DATA_SKIP_SAMPLES.
- * @code
- * u32le number of samples to skip from start of this packet
- * u32le number of samples to skip from end of this packet
- * u8 reason for start skip
- * u8 reason for end skip (0=padding silence, 1=convergence)
- * @endcode
- */
- AV_FRAME_DATA_SKIP_SAMPLES,
- /**
- * This side data must be associated with an audio frame and corresponds to
- * enum AVAudioServiceType defined in avcodec.h.
- */
- AV_FRAME_DATA_AUDIO_SERVICE_TYPE,
- /**
- * Mastering display metadata associated with a video frame. The payload is
- * an AVMasteringDisplayMetadata type and contains information about the
- * mastering display color volume.
- */
- AV_FRAME_DATA_MASTERING_DISPLAY_METADATA,
- /**
- * The GOP timecode in 25 bit timecode format. Data format is 64-bit integer.
- * This is set on the first frame of a GOP that has a temporal reference of 0.
- */
- AV_FRAME_DATA_GOP_TIMECODE,
-
- /**
- * The data represents the AVSphericalMapping structure defined in
- * libavutil/spherical.h.
- */
- AV_FRAME_DATA_SPHERICAL,
-
- /**
- * Content light level (based on CTA-861.3). This payload contains data in
- * the form of the AVContentLightMetadata struct.
- */
- AV_FRAME_DATA_CONTENT_LIGHT_LEVEL,
-
- /**
- * The data contains an ICC profile as an opaque octet buffer following the
- * format described by ISO 15076-1 with an optional name defined in the
- * metadata key entry "name".
- */
- AV_FRAME_DATA_ICC_PROFILE,
-
-#if FF_API_FRAME_QP
- /**
- * Implementation-specific description of the format of AV_FRAME_QP_TABLE_DATA.
- * The contents of this side data are undocumented and internal; use
- * av_frame_set_qp_table() and av_frame_get_qp_table() to access this in a
- * meaningful way instead.
- */
- AV_FRAME_DATA_QP_TABLE_PROPERTIES,
-
- /**
- * Raw QP table data. Its format is described by
- * AV_FRAME_DATA_QP_TABLE_PROPERTIES. Use av_frame_set_qp_table() and
- * av_frame_get_qp_table() to access this instead.
- */
- AV_FRAME_DATA_QP_TABLE_DATA,
-#endif
-};
-
-enum AVActiveFormatDescription {
- AV_AFD_SAME = 8,
- AV_AFD_4_3 = 9,
- AV_AFD_16_9 = 10,
- AV_AFD_14_9 = 11,
- AV_AFD_4_3_SP_14_9 = 13,
- AV_AFD_16_9_SP_14_9 = 14,
- AV_AFD_SP_4_3 = 15,
-};
-
-
-/**
- * Structure to hold side data for an AVFrame.
- *
- * sizeof(AVFrameSideData) is not a part of the public ABI, so new fields may be added
- * to the end with a minor bump.
- */
-typedef struct AVFrameSideData {
- enum AVFrameSideDataType type;
- uint8_t *data;
- int size;
- AVDictionary *metadata;
- AVBufferRef *buf;
-} AVFrameSideData;
-
-/**
- * This structure describes decoded (raw) audio or video data.
- *
- * AVFrame must be allocated using av_frame_alloc(). Note that this only
- * allocates the AVFrame itself, the buffers for the data must be managed
- * through other means (see below).
- * AVFrame must be freed with av_frame_free().
- *
- * AVFrame is typically allocated once and then reused multiple times to hold
- * different data (e.g. a single AVFrame to hold frames received from a
- * decoder). In such a case, av_frame_unref() will free any references held by
- * the frame and reset it to its original clean state before it
- * is reused again.
- *
- * The data described by an AVFrame is usually reference counted through the
- * AVBuffer API. The underlying buffer references are stored in AVFrame.buf /
- * AVFrame.extended_buf. An AVFrame is considered to be reference counted if at
- * least one reference is set, i.e. if AVFrame.buf0 != NULL. In such a case,
- * every single data plane must be contained in one of the buffers in
- * AVFrame.buf or AVFrame.extended_buf.
- * There may be a single buffer for all the data, or one separate buffer for
- * each plane, or anything in between.
- *
- * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added
- * to the end with a minor bump.
- *
- * Fields can be accessed through AVOptions, the name string used, matches the
- * C structure field name for fields accessible through AVOptions. The AVClass
- * for AVFrame can be obtained from avcodec_get_frame_class()
- */
-typedef struct AVFrame {
-#define AV_NUM_DATA_POINTERS 8
- /**
- * pointer to the picture/channel planes.
- * This might be different from the first allocated byte
- *
- * Some decoders access areas outside 0,0 - width,height, please
- * see avcodec_align_dimensions2(). Some filters and swscale can read
- * up to 16 bytes beyond the planes, if these filters are to be used,
- * then 16 extra bytes must be allocated.
- *
- * NOTE: Except for hwaccel formats, pointers not needed by the format
- * MUST be set to NULL.
- */
- uint8_t *dataAV_NUM_DATA_POINTERS;
-
- /**
- * For video, size in bytes of each picture line.
- * For audio, size in bytes of each plane.
- *
- * For audio, only linesize0 may be set. For planar audio, each channel
- * plane must be the same size.
- *
- * For video the linesizes should be multiples of the CPUs alignment
- * preference, this is 16 or 32 for modern desktop CPUs.
- * Some code requires such alignment other code can be slower without
- * correct alignment, for yet other it makes no difference.
- *
- * @note The linesize may be larger than the size of usable data -- there
- * may be extra padding present for performance reasons.
- */
- int linesizeAV_NUM_DATA_POINTERS;
-
- /**
- * pointers to the data planes/channels.
- *
- * For video, this should simply point to data.
- *
- * For planar audio, each channel has a separate data pointer, and
- * linesize0 contains the size of each channel buffer.
- * For packed audio, there is just one data pointer, and linesize0
- * contains the total size of the buffer for all channels.
- *
- * Note: Both data and extended_data should always be set in a valid frame,
- * but for planar audio with more channels that can fit in data,
- * extended_data must be used in order to access all channels.
- */
- uint8_t **extended_data;
-
- /**
- * @name Video dimensions
- * Video frames only. The coded dimensions (in pixels) of the video frame,
- * i.e. the size of the rectangle that contains some well-defined values.
- *
- * @note The part of the frame intended for display/presentation is further
- * restricted by the @ref cropping "Cropping rectangle".
- * @{
- */
- int width, height;
- /**
- * @}
- */
-
- /**
- * number of audio samples (per channel) described by this frame
- */
- int nb_samples;
-
- /**
- * format of the frame, -1 if unknown or unset
- * Values correspond to enum AVPixelFormat for video frames,
- * enum AVSampleFormat for audio)
- */
- int format;
-
- /**
- * 1 -> keyframe, 0-> not
- */
- int key_frame;
-
- /**
- * Picture type of the frame.
- */
- enum AVPictureType pict_type;
-
- /**
- * Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
- */
- AVRational sample_aspect_ratio;
-
- /**
- * Presentation timestamp in time_base units (time when frame should be shown to user).
- */
- int64_t pts;
-
-#if FF_API_PKT_PTS
- /**
- * PTS copied from the AVPacket that was decoded to produce this frame.
- * @deprecated use the pts field instead
- */
- attribute_deprecated
- int64_t pkt_pts;
-#endif
-
- /**
- * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)
- * This is also the Presentation time of this AVFrame calculated from
- * only AVPacket.dts values without pts values.
- */
- int64_t pkt_dts;
-
- /**
- * picture number in bitstream order
- */
- int coded_picture_number;
- /**
- * picture number in display order
- */
- int display_picture_number;
-
- /**
- * quality (between 1 (good) and FF_LAMBDA_MAX (bad))
- */
- int quality;
-
- /**
- * for some private data of the user
- */
- void *opaque;
-
-#if FF_API_ERROR_FRAME
- /**
- * @deprecated unused
- */
- attribute_deprecated
- uint64_t errorAV_NUM_DATA_POINTERS;
-#endif
-
- /**
- * When decoding, this signals how much the picture must be delayed.
- * extra_delay = repeat_pict / (2*fps)
- */
- int repeat_pict;
-
- /**
- * The content of the picture is interlaced.
- */
- int interlaced_frame;
-
- /**
- * If the content is interlaced, is top field displayed first.
- */
- int top_field_first;
-
- /**
- * Tell user application that palette has changed from previous frame.
- */
- int palette_has_changed;
-
- /**
- * reordered opaque 64 bits (generally an integer or a double precision float
- * PTS but can be anything).
- * The user sets AVCodecContext.reordered_opaque to represent the input at
- * that time,
- * the decoder reorders values as needed and sets AVFrame.reordered_opaque
- * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque
- * @deprecated in favor of pkt_pts
- */
- int64_t reordered_opaque;
-
- /**
- * Sample rate of the audio data.
- */
- int sample_rate;
-
- /**
- * Channel layout of the audio data.
- */
- uint64_t channel_layout;
-
- /**
- * AVBuffer references backing the data for this frame. If all elements of
- * this array are NULL, then this frame is not reference counted. This array
- * must be filled contiguously -- if bufi is non-NULL then bufj must
- * also be non-NULL for all j < i.
- *
- * There may be at most one AVBuffer per data plane, so for video this array
- * always contains all the references. For planar audio with more than
- * AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in
- * this array. Then the extra AVBufferRef pointers are stored in the
- * extended_buf array.
- */
- AVBufferRef *bufAV_NUM_DATA_POINTERS;
-
- /**
- * For planar audio which requires more than AV_NUM_DATA_POINTERS
- * AVBufferRef pointers, this array will hold all the references which
- * cannot fit into AVFrame.buf.
- *
- * Note that this is different from AVFrame.extended_data, which always
- * contains all the pointers. This array only contains the extra pointers,
- * which cannot fit into AVFrame.buf.
- *
- * This array is always allocated using av_malloc() by whoever constructs
- * the frame. It is freed in av_frame_unref().
- */
- AVBufferRef **extended_buf;
- /**
- * Number of elements in extended_buf.
- */
- int nb_extended_buf;
-
- AVFrameSideData **side_data;
- int nb_side_data;
-
-/**
- * @defgroup lavu_frame_flags AV_FRAME_FLAGS
- * @ingroup lavu_frame
- * Flags describing additional frame properties.
- *
- * @{
- */
-
-/**
- * The frame data may be corrupted, e.g. due to decoding errors.
- */
-#define AV_FRAME_FLAG_CORRUPT (1 << 0)
-/**
- * A flag to mark the frames which need to be decoded, but shouldn't be output.
- */
-#define AV_FRAME_FLAG_DISCARD (1 << 2)
-/**
- * @}
- */
-
- /**
- * Frame flags, a combination of @ref lavu_frame_flags
- */
- int flags;
-
- /**
- * MPEG vs JPEG YUV range.
- * - encoding: Set by user
- * - decoding: Set by libavcodec
- */
- enum AVColorRange color_range;
-
- enum AVColorPrimaries color_primaries;
-
- enum AVColorTransferCharacteristic color_trc;
-
- /**
- * YUV colorspace type.
- * - encoding: Set by user
- * - decoding: Set by libavcodec
- */
- enum AVColorSpace colorspace;
-
- enum AVChromaLocation chroma_location;
-
- /**
- * frame timestamp estimated using various heuristics, in stream time base
- * - encoding: unused
- * - decoding: set by libavcodec, read by user.
- */
- int64_t best_effort_timestamp;
-
- /**
- * reordered pos from the last AVPacket that has been input into the decoder
- * - encoding: unused
- * - decoding: Read by user.
- */
- int64_t pkt_pos;
-
- /**
- * duration of the corresponding packet, expressed in
- * AVStream->time_base units, 0 if unknown.
- * - encoding: unused
- * - decoding: Read by user.
- */
- int64_t pkt_duration;
-
- /**
- * metadata.
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- AVDictionary *metadata;
-
- /**
- * decode error flags of the frame, set to a combination of
- * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there
- * were errors during the decoding.
- * - encoding: unused
- * - decoding: set by libavcodec, read by user.
- */
- int decode_error_flags;
-#define FF_DECODE_ERROR_INVALID_BITSTREAM 1
-#define FF_DECODE_ERROR_MISSING_REFERENCE 2
-
- /**
- * number of audio channels, only used for audio.
- * - encoding: unused
- * - decoding: Read by user.
- */
- int channels;
-
- /**
- * size of the corresponding packet containing the compressed
- * frame.
- * It is set to a negative value if unknown.
- * - encoding: unused
- * - decoding: set by libavcodec, read by user.
- */
- int pkt_size;
-
-#if FF_API_FRAME_QP
- /**
- * QP table
- */
- attribute_deprecated
- int8_t *qscale_table;
- /**
- * QP store stride
- */
- attribute_deprecated
- int qstride;
-
- attribute_deprecated
- int qscale_type;
-
- attribute_deprecated
- AVBufferRef *qp_table_buf;
-#endif
- /**
- * For hwaccel-format frames, this should be a reference to the
- * AVHWFramesContext describing the frame.
- */
- AVBufferRef *hw_frames_ctx;
-
- /**
- * AVBufferRef for free use by the API user. FFmpeg will never check the
- * contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when
- * the frame is unreferenced. av_frame_copy_props() calls create a new
- * reference with av_buffer_ref() for the target frame's opaque_ref field.
- *
- * This is unrelated to the opaque field, although it serves a similar
- * purpose.
- */
- AVBufferRef *opaque_ref;
-
- /**
- * @anchor cropping
- * @name Cropping
- * Video frames only. The number of pixels to discard from the the
- * top/bottom/left/right border of the frame to obtain the sub-rectangle of
- * the frame intended for presentation.
- * @{
- */
- size_t crop_top;
- size_t crop_bottom;
- size_t crop_left;
- size_t crop_right;
- /**
- * @}
- */
-
- /**
- * AVBufferRef for internal use by a single libav* library.
- * Must not be used to transfer data between libraries.
- * Has to be NULL when ownership of the frame leaves the respective library.
- *
- * Code outside the FFmpeg libs should never check or change the contents of the buffer ref.
- *
- * FFmpeg calls av_buffer_unref() on it when the frame is unreferenced.
- * av_frame_copy_props() calls create a new reference with av_buffer_ref()
- * for the target frame's private_ref field.
- */
- AVBufferRef *private_ref;
-} AVFrame;
-
-#if FF_API_FRAME_GET_SET
-/**
- * Accessors for some AVFrame fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
-attribute_deprecated
-int64_t av_frame_get_pkt_duration (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_pkt_duration (AVFrame *frame, int64_t val);
-attribute_deprecated
-int64_t av_frame_get_pkt_pos (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_pkt_pos (AVFrame *frame, int64_t val);
-attribute_deprecated
-int64_t av_frame_get_channel_layout (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_channel_layout (AVFrame *frame, int64_t val);
-attribute_deprecated
-int av_frame_get_channels (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_channels (AVFrame *frame, int val);
-attribute_deprecated
-int av_frame_get_sample_rate (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_sample_rate (AVFrame *frame, int val);
-attribute_deprecated
-AVDictionary *av_frame_get_metadata (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_metadata (AVFrame *frame, AVDictionary *val);
-attribute_deprecated
-int av_frame_get_decode_error_flags (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_decode_error_flags (AVFrame *frame, int val);
-attribute_deprecated
-int av_frame_get_pkt_size(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_pkt_size(AVFrame *frame, int val);
-#if FF_API_FRAME_QP
-attribute_deprecated
-int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
-attribute_deprecated
-int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
-#endif
-attribute_deprecated
-enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val);
-attribute_deprecated
-enum AVColorRange av_frame_get_color_range(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val);
-#endif
-
-/**
- * Get the name of a colorspace.
- * @return a static string identifying the colorspace; can be NULL.
- */
-const char *av_get_colorspace_name(enum AVColorSpace val);
-
-/**
- * Allocate an AVFrame and set its fields to default values. The resulting
- * struct must be freed using av_frame_free().
- *
- * @return An AVFrame filled with default values or NULL on failure.
- *
- * @note this only allocates the AVFrame itself, not the data buffers. Those
- * must be allocated through other means, e.g. with av_frame_get_buffer() or
- * manually.
- */
-AVFrame *av_frame_alloc(void);
-
-/**
- * Free the frame and any dynamically allocated objects in it,
- * e.g. extended_data. If the frame is reference counted, it will be
- * unreferenced first.
- *
- * @param frame frame to be freed. The pointer will be set to NULL.
- */
-void av_frame_free(AVFrame **frame);
-
-/**
- * Set up a new reference to the data described by the source frame.
- *
- * Copy frame properties from src to dst and create a new reference for each
- * AVBufferRef from src.
- *
- * If src is not reference counted, new buffers are allocated and the data is
- * copied.
- *
- * @warning: dst MUST have been either unreferenced with av_frame_unref(dst),
- * or newly allocated with av_frame_alloc() before calling this
- * function, or undefined behavior will occur.
- *
- * @return 0 on success, a negative AVERROR on error
- */
-int av_frame_ref(AVFrame *dst, const AVFrame *src);
-
-/**
- * Create a new frame that references the same data as src.
- *
- * This is a shortcut for av_frame_alloc()+av_frame_ref().
- *
- * @return newly created AVFrame on success, NULL on error.
- */
-AVFrame *av_frame_clone(const AVFrame *src);
-
-/**
- * Unreference all the buffers referenced by frame and reset the frame fields.
- */
-void av_frame_unref(AVFrame *frame);
-
-/**
- * Move everything contained in src to dst and reset src.
- *
- * @warning: dst is not unreferenced, but directly overwritten without reading
- * or deallocating its contents. Call av_frame_unref(dst) manually
- * before calling this function to ensure that no memory is leaked.
- */
-void av_frame_move_ref(AVFrame *dst, AVFrame *src);
-
-/**
- * Allocate new buffer(s) for audio or video data.
- *
- * The following fields must be set on frame before calling this function:
- * - format (pixel format for video, sample format for audio)
- * - width and height for video
- * - nb_samples and channel_layout for audio
- *
- * This function will fill AVFrame.data and AVFrame.buf arrays and, if
- * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.
- * For planar formats, one buffer will be allocated for each plane.
- *
- * @warning: if frame already has been allocated, calling this function will
- * leak memory. In addition, undefined behavior can occur in certain
- * cases.
- *
- * @param frame frame in which to store the new buffers.
- * @param align Required buffer size alignment. If equal to 0, alignment will be
- * chosen automatically for the current CPU. It is highly
- * recommended to pass 0 here unless you know what you are doing.
- *
- * @return 0 on success, a negative AVERROR on error.
- */
-int av_frame_get_buffer(AVFrame *frame, int align);
-
-/**
- * Check if the frame data is writable.
- *
- * @return A positive value if the frame data is writable (which is true if and
- * only if each of the underlying buffers has only one reference, namely the one
- * stored in this frame). Return 0 otherwise.
- *
- * If 1 is returned the answer is valid until av_buffer_ref() is called on any
- * of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly).
- *
- * @see av_frame_make_writable(), av_buffer_is_writable()
- */
-int av_frame_is_writable(AVFrame *frame);
-
-/**
- * Ensure that the frame data is writable, avoiding data copy if possible.
- *
- * Do nothing if the frame is writable, allocate new buffers and copy the data
- * if it is not.
- *
- * @return 0 on success, a negative AVERROR on error.
- *
- * @see av_frame_is_writable(), av_buffer_is_writable(),
- * av_buffer_make_writable()
- */
-int av_frame_make_writable(AVFrame *frame);
-
-/**
- * Copy the frame data from src to dst.
- *
- * This function does not allocate anything, dst must be already initialized and
- * allocated with the same parameters as src.
- *
- * This function only copies the frame data (i.e. the contents of the data /
- * extended data arrays), not any other properties.
- *
- * @return >= 0 on success, a negative AVERROR on error.
- */
-int av_frame_copy(AVFrame *dst, const AVFrame *src);
-
-/**
- * Copy only "metadata" fields from src to dst.
- *
- * Metadata for the purpose of this function are those fields that do not affect
- * the data layout in the buffers. E.g. pts, sample rate (for audio) or sample
- * aspect ratio (for video), but not width/height or channel layout.
- * Side data is also copied.
- */
-int av_frame_copy_props(AVFrame *dst, const AVFrame *src);
-
-/**
- * Get the buffer reference a given data plane is stored in.
- *
- * @param plane index of the data plane of interest in frame->extended_data.
- *
- * @return the buffer reference that contains the plane or NULL if the input
- * frame is not valid.
- */
-AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane);
-
-/**
- * Add a new side data to a frame.
- *
- * @param frame a frame to which the side data should be added
- * @param type type of the added side data
- * @param size size of the side data
- *
- * @return newly added side data on success, NULL on error
- */
-AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
- enum AVFrameSideDataType type,
- int size);
-
-/**
- * Add a new side data to a frame from an existing AVBufferRef
- *
- * @param frame a frame to which the side data should be added
- * @param type the type of the added side data
- * @param buf an AVBufferRef to add as side data. The ownership of
- * the reference is transferred to the frame.
- *
- * @return newly added side data on success, NULL on error. On failure
- * the frame is unchanged and the AVBufferRef remains owned by
- * the caller.
- */
-AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame,
- enum AVFrameSideDataType type,
- AVBufferRef *buf);
-
-/**
- * @return a pointer to the side data of a given type on success, NULL if there
- * is no side data with such type in this frame.
- */
-AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
- enum AVFrameSideDataType type);
-
-/**
- * If side data of the supplied type exists in the frame, free it and remove it
- * from the frame.
- */
-void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);
-
-
-/**
- * Flags for frame cropping.
- */
-enum {
- /**
- * Apply the maximum possible cropping, even if it requires setting the
- * AVFrame.data entries to unaligned pointers. Passing unaligned data
- * to FFmpeg API is generally not allowed, and causes undefined behavior
- * (such as crashes). You can pass unaligned data only to FFmpeg APIs that
- * are explicitly documented to accept it. Use this flag only if you
- * absolutely know what you are doing.
- */
- AV_FRAME_CROP_UNALIGNED = 1 << 0,
-};
-
-/**
- * Crop the given video AVFrame according to its crop_left/crop_top/crop_right/
- * crop_bottom fields. If cropping is successful, the function will adjust the
- * data pointers and the width/height fields, and set the crop fields to 0.
- *
- * In all cases, the cropping boundaries will be rounded to the inherent
- * alignment of the pixel format. In some cases, such as for opaque hwaccel
- * formats, the left/top cropping is ignored. The crop fields are set to 0 even
- * if the cropping was rounded or ignored.
- *
- * @param frame the frame which should be cropped
- * @param flags Some combination of AV_FRAME_CROP_* flags, or 0.
- *
- * @return >= 0 on success, a negative AVERROR on error. If the cropping fields
- * were invalid, AVERROR(ERANGE) is returned, and nothing is changed.
- */
-int av_frame_apply_cropping(AVFrame *frame, int flags);
-
-/**
- * @return a string identifying the side data type
- */
-const char *av_frame_side_data_name(enum AVFrameSideDataType type);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_FRAME_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hash.h Deleted

@@ -1,269 +0,0 @@
-/*
- * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_hash_generic
- * Generic hashing API
- */
-
-#ifndef AVUTIL_HASH_H
-#define AVUTIL_HASH_H
-
-#include <stdint.h>
-
-#include "version.h"
-
-/**
- * @defgroup lavu_hash Hash Functions
- * @ingroup lavu_crypto
- * Hash functions useful in multimedia.
- *
- * Hash functions are widely used in multimedia, from error checking and
- * concealment to internal regression testing. libavutil has efficient
- * implementations of a variety of hash functions that may be useful for
- * FFmpeg and other multimedia applications.
- *
- * @{
- *
- * @defgroup lavu_hash_generic Generic Hashing API
- * An abstraction layer for all hash functions supported by libavutil.
- *
- * If your application needs to support a wide range of different hash
- * functions, then the Generic Hashing API is for you. It provides a generic,
- * reusable API for @ref lavu_hash "all hash functions" implemented in libavutil.
- * If you just need to use one particular hash function, use the @ref lavu_hash
- * "individual hash" directly.
- *
- * @section Sample Code
- *
- * A basic template for using the Generic Hashing API follows:
- *
- * @code
- * struct AVHashContext *ctx = NULL;
- * const char *hash_name = NULL;
- * uint8_t *output_buf = NULL;
- *
- * // Select from a string returned by av_hash_names()
- * hash_name = ...;
- *
- * // Allocate a hash context
- * ret = av_hash_alloc(&ctx, hash_name);
- * if (ret < 0)
- * return ret;
- *
- * // Initialize the hash context
- * av_hash_init(ctx);
- *
- * // Update the hash context with data
- * while (data_left) {
- * av_hash_update(ctx, data, size);
- * }
- *
- * // Now we have no more data, so it is time to finalize the hash and get the
- * // output. But we need to first allocate an output buffer. Note that you can
- * // use any memory allocation function, including malloc(), not just
- * // av_malloc().
- * output_buf = av_malloc(av_hash_get_size(ctx));
- * if (!output_buf)
- * return AVERROR(ENOMEM);
- *
- * // Finalize the hash context.
- * // You can use any of the av_hash_final*() functions provided, for other
- * // output formats. If you do so, be sure to adjust the memory allocation
- * // above. See the function documentation below for the exact amount of extra
- * // memory needed.
- * av_hash_final(ctx, output_buffer);
- *
- * // Free the context
- * av_hash_freep(&ctx);
- * @endcode
- *
- * @section Hash Function-Specific Information
- * If the CRC32 hash is selected, the #AV_CRC_32_IEEE polynomial will be
- * used.
- *
- * If the Murmur3 hash is selected, the default seed will be used. See @ref
- * lavu_murmur3_seedinfo "Murmur3" for more information.
- *
- * @{
- */
-
-/**
- * @example ffhash.c
- * This example is a simple command line application that takes one or more
- * arguments. It demonstrates a typical use of the hashing API with allocation,
- * initialization, updating, and finalizing.
- */
-
-struct AVHashContext;
-
-/**
- * Allocate a hash context for the algorithm specified by name.
- *
- * @return >= 0 for success, a negative error code for failure
- *
- * @note The context is not initialized after a call to this function; you must
- * call av_hash_init() to do so.
- */
-int av_hash_alloc(struct AVHashContext **ctx, const char *name);
-
-/**
- * Get the names of available hash algorithms.
- *
- * This function can be used to enumerate the algorithms.
- *
- * @paramin i Index of the hash algorithm, starting from 0
- * @return Pointer to a static string or `NULL` if `i` is out of range
- */
-const char *av_hash_names(int i);
-
-/**
- * Get the name of the algorithm corresponding to the given hash context.
- */
-const char *av_hash_get_name(const struct AVHashContext *ctx);
-
-/**
- * Maximum value that av_hash_get_size() will currently return.
- *
- * You can use this if you absolutely want or need to use static allocation for
- * the output buffer and are fine with not supporting hashes newly added to
- * libavutil without recompilation.
- *
- * @warning
- * Adding new hashes with larger sizes, and increasing the macro while doing
- * so, will not be considered an ABI change. To prevent your code from
- * overflowing a buffer, either dynamically allocate the output buffer with
- * av_hash_get_size(), or limit your use of the Hashing API to hashes that are
- * already in FFmpeg during the time of compilation.
- */
-#define AV_HASH_MAX_SIZE 64
-
-/**
- * Get the size of the resulting hash value in bytes.
- *
- * The maximum value this function will currently return is available as macro
- * #AV_HASH_MAX_SIZE.
- *
- * @paramin ctx Hash context
- * @return Size of the hash value in bytes
- */
-int av_hash_get_size(const struct AVHashContext *ctx);
-
-/**
- * Initialize or reset a hash context.
- *
- * @paramin,out ctx Hash context
- */
-void av_hash_init(struct AVHashContext *ctx);
-
-/**
- * Update a hash context with additional data.
- *
- * @paramin,out ctx Hash context
- * @paramin src Data to be added to the hash context
- * @paramin len Size of the additional data
- */
-#if FF_API_CRYPTO_SIZE_T
-void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, int len);
-#else
-void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, size_t len);
-#endif
-
-/**
- * Finalize a hash context and compute the actual hash value.
- *
- * The minimum size of `dst` buffer is given by av_hash_get_size() or
- * #AV_HASH_MAX_SIZE. The use of the latter macro is discouraged.
- *
- * It is not safe to update or finalize a hash context again, if it has already
- * been finalized.
- *
- * @paramin,out ctx Hash context
- * @paramout dst Where the final hash value will be stored
- *
- * @see av_hash_final_bin() provides an alternative API
- */
-void av_hash_final(struct AVHashContext *ctx, uint8_t *dst);
-
-/**
- * Finalize a hash context and store the actual hash value in a buffer.
- *
- * It is not safe to update or finalize a hash context again, if it has already
- * been finalized.
- *
- * If `size` is smaller than the hash size (given by av_hash_get_size()), the
- * hash is truncated; if size is larger, the buffer is padded with 0.
- *
- * @paramin,out ctx Hash context
- * @paramout dst Where the final hash value will be stored
- * @paramin size Number of bytes to write to `dst`
- */
-void av_hash_final_bin(struct AVHashContext *ctx, uint8_t *dst, int size);
-
-/**
- * Finalize a hash context and store the hexadecimal representation of the
- * actual hash value as a string.
- *
- * It is not safe to update or finalize a hash context again, if it has already
- * been finalized.
- *
- * The string is always 0-terminated.
- *
- * If `size` is smaller than `2 * hash_size + 1`, where `hash_size` is the
- * value returned by av_hash_get_size(), the string will be truncated.
- *
- * @paramin,out ctx Hash context
- * @paramout dst Where the string will be stored
- * @paramin size Maximum number of bytes to write to `dst`
- */
-void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size);
-
-/**
- * Finalize a hash context and store the Base64 representation of the
- * actual hash value as a string.
- *
- * It is not safe to update or finalize a hash context again, if it has already
- * been finalized.
- *
- * The string is always 0-terminated.
- *
- * If `size` is smaller than AV_BASE64_SIZE(hash_size), where `hash_size` is
- * the value returned by av_hash_get_size(), the string will be truncated.
- *
- * @paramin,out ctx Hash context
- * @paramout dst Where the final hash value will be stored
- * @paramin size Maximum number of bytes to write to `dst`
- */
-void av_hash_final_b64(struct AVHashContext *ctx, uint8_t *dst, int size);
-
-/**
- * Free hash context and set hash context pointer to `NULL`.
- *
- * @paramin,out ctx Pointer to hash context
- */
-void av_hash_freep(struct AVHashContext **ctx);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_HASH_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hmac.h Deleted

@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2012 Martin Storsjo
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HMAC_H
-#define AVUTIL_HMAC_H
-
-#include <stdint.h>
-
-#include "version.h"
-/**
- * @defgroup lavu_hmac HMAC
- * @ingroup lavu_crypto
- * @{
- */
-
-enum AVHMACType {
- AV_HMAC_MD5,
- AV_HMAC_SHA1,
- AV_HMAC_SHA224,
- AV_HMAC_SHA256,
- AV_HMAC_SHA384,
- AV_HMAC_SHA512,
-};
-
-typedef struct AVHMAC AVHMAC;
-
-/**
- * Allocate an AVHMAC context.
- * @param type The hash function used for the HMAC.
- */
-AVHMAC *av_hmac_alloc(enum AVHMACType type);
-
-/**
- * Free an AVHMAC context.
- * @param ctx The context to free, may be NULL
- */
-void av_hmac_free(AVHMAC *ctx);
-
-/**
- * Initialize an AVHMAC context with an authentication key.
- * @param ctx The HMAC context
- * @param key The authentication key
- * @param keylen The length of the key, in bytes
- */
-void av_hmac_init(AVHMAC *ctx, const uint8_t *key, unsigned int keylen);
-
-/**
- * Hash data with the HMAC.
- * @param ctx The HMAC context
- * @param data The data to hash
- * @param len The length of the data, in bytes
- */
-void av_hmac_update(AVHMAC *ctx, const uint8_t *data, unsigned int len);
-
-/**
- * Finish hashing and output the HMAC digest.
- * @param ctx The HMAC context
- * @param out The output buffer to write the digest into
- * @param outlen The length of the out buffer, in bytes
- * @return The number of bytes written to out, or a negative error code.
- */
-int av_hmac_final(AVHMAC *ctx, uint8_t *out, unsigned int outlen);
-
-/**
- * Hash an array of data with a key.
- * @param ctx The HMAC context
- * @param data The data to hash
- * @param len The length of the data, in bytes
- * @param key The authentication key
- * @param keylen The length of the key, in bytes
- * @param out The output buffer to write the digest into
- * @param outlen The length of the out buffer, in bytes
- * @return The number of bytes written to out, or a negative error code.
- */
-int av_hmac_calc(AVHMAC *ctx, const uint8_t *data, unsigned int len,
- const uint8_t *key, unsigned int keylen,
- uint8_t *out, unsigned int outlen);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_HMAC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext.h Deleted

@@ -1,584 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_H
-#define AVUTIL_HWCONTEXT_H
-
-#include "buffer.h"
-#include "frame.h"
-#include "log.h"
-#include "pixfmt.h"
-
-enum AVHWDeviceType {
- AV_HWDEVICE_TYPE_NONE,
- AV_HWDEVICE_TYPE_VDPAU,
- AV_HWDEVICE_TYPE_CUDA,
- AV_HWDEVICE_TYPE_VAAPI,
- AV_HWDEVICE_TYPE_DXVA2,
- AV_HWDEVICE_TYPE_QSV,
- AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
- AV_HWDEVICE_TYPE_D3D11VA,
- AV_HWDEVICE_TYPE_DRM,
- AV_HWDEVICE_TYPE_OPENCL,
- AV_HWDEVICE_TYPE_MEDIACODEC,
-};
-
-typedef struct AVHWDeviceInternal AVHWDeviceInternal;
-
-/**
- * This struct aggregates all the (hardware/vendor-specific) "high-level" state,
- * i.e. state that is not tied to a concrete processing configuration.
- * E.g., in an API that supports hardware-accelerated encoding and decoding,
- * this struct will (if possible) wrap the state that is common to both encoding
- * and decoding and from which specific instances of encoders or decoders can be
- * derived.
- *
- * This struct is reference-counted with the AVBuffer mechanism. The
- * av_hwdevice_ctx_alloc() constructor yields a reference, whose data field
- * points to the actual AVHWDeviceContext. Further objects derived from
- * AVHWDeviceContext (such as AVHWFramesContext, describing a frame pool with
- * specific properties) will hold an internal reference to it. After all the
- * references are released, the AVHWDeviceContext itself will be freed,
- * optionally invoking a user-specified callback for uninitializing the hardware
- * state.
- */
-typedef struct AVHWDeviceContext {
- /**
- * A class for logging. Set by av_hwdevice_ctx_alloc().
- */
- const AVClass *av_class;
-
- /**
- * Private data used internally by libavutil. Must not be accessed in any
- * way by the caller.
- */
- AVHWDeviceInternal *internal;
-
- /**
- * This field identifies the underlying API used for hardware access.
- *
- * This field is set when this struct is allocated and never changed
- * afterwards.
- */
- enum AVHWDeviceType type;
-
- /**
- * The format-specific data, allocated and freed by libavutil along with
- * this context.
- *
- * Should be cast by the user to the format-specific context defined in the
- * corresponding header (hwcontext_*.h) and filled as described in the
- * documentation before calling av_hwdevice_ctx_init().
- *
- * After calling av_hwdevice_ctx_init() this struct should not be modified
- * by the caller.
- */
- void *hwctx;
-
- /**
- * This field may be set by the caller before calling av_hwdevice_ctx_init().
- *
- * If non-NULL, this callback will be called when the last reference to
- * this context is unreferenced, immediately before it is freed.
- *
- * @note when other objects (e.g an AVHWFramesContext) are derived from this
- * struct, this callback will be invoked after all such child objects
- * are fully uninitialized and their respective destructors invoked.
- */
- void (*free)(struct AVHWDeviceContext *ctx);
-
- /**
- * Arbitrary user data, to be used e.g. by the free() callback.
- */
- void *user_opaque;
-} AVHWDeviceContext;
-
-typedef struct AVHWFramesInternal AVHWFramesInternal;
-
-/**
- * This struct describes a set or pool of "hardware" frames (i.e. those with
- * data not located in normal system memory). All the frames in the pool are
- * assumed to be allocated in the same way and interchangeable.
- *
- * This struct is reference-counted with the AVBuffer mechanism and tied to a
- * given AVHWDeviceContext instance. The av_hwframe_ctx_alloc() constructor
- * yields a reference, whose data field points to the actual AVHWFramesContext
- * struct.
- */
-typedef struct AVHWFramesContext {
- /**
- * A class for logging.
- */
- const AVClass *av_class;
-
- /**
- * Private data used internally by libavutil. Must not be accessed in any
- * way by the caller.
- */
- AVHWFramesInternal *internal;
-
- /**
- * A reference to the parent AVHWDeviceContext. This reference is owned and
- * managed by the enclosing AVHWFramesContext, but the caller may derive
- * additional references from it.
- */
- AVBufferRef *device_ref;
-
- /**
- * The parent AVHWDeviceContext. This is simply a pointer to
- * device_ref->data provided for convenience.
- *
- * Set by libavutil in av_hwframe_ctx_init().
- */
- AVHWDeviceContext *device_ctx;
-
- /**
- * The format-specific data, allocated and freed automatically along with
- * this context.
- *
- * Should be cast by the user to the format-specific context defined in the
- * corresponding header (hwframe_*.h) and filled as described in the
- * documentation before calling av_hwframe_ctx_init().
- *
- * After any frames using this context are created, the contents of this
- * struct should not be modified by the caller.
- */
- void *hwctx;
-
- /**
- * This field may be set by the caller before calling av_hwframe_ctx_init().
- *
- * If non-NULL, this callback will be called when the last reference to
- * this context is unreferenced, immediately before it is freed.
- */
- void (*free)(struct AVHWFramesContext *ctx);
-
- /**
- * Arbitrary user data, to be used e.g. by the free() callback.
- */
- void *user_opaque;
-
- /**
- * A pool from which the frames are allocated by av_hwframe_get_buffer().
- * This field may be set by the caller before calling av_hwframe_ctx_init().
- * The buffers returned by calling av_buffer_pool_get() on this pool must
- * have the properties described in the documentation in the corresponding hw
- * type's header (hwcontext_*.h). The pool will be freed strictly before
- * this struct's free() callback is invoked.
- *
- * This field may be NULL, then libavutil will attempt to allocate a pool
- * internally. Note that certain device types enforce pools allocated at
- * fixed size (frame count), which cannot be extended dynamically. In such a
- * case, initial_pool_size must be set appropriately.
- */
- AVBufferPool *pool;
-
- /**
- * Initial size of the frame pool. If a device type does not support
- * dynamically resizing the pool, then this is also the maximum pool size.
- *
- * May be set by the caller before calling av_hwframe_ctx_init(). Must be
- * set if pool is NULL and the device type does not support dynamic pools.
- */
- int initial_pool_size;
-
- /**
- * The pixel format identifying the underlying HW surface type.
- *
- * Must be a hwaccel format, i.e. the corresponding descriptor must have the
- * AV_PIX_FMT_FLAG_HWACCEL flag set.
- *
- * Must be set by the user before calling av_hwframe_ctx_init().
- */
- enum AVPixelFormat format;
-
- /**
- * The pixel format identifying the actual data layout of the hardware
- * frames.
- *
- * Must be set by the caller before calling av_hwframe_ctx_init().
- *
- * @note when the underlying API does not provide the exact data layout, but
- * only the colorspace/bit depth, this field should be set to the fully
- * planar version of that format (e.g. for 8-bit 420 YUV it should be
- * AV_PIX_FMT_YUV420P, not AV_PIX_FMT_NV12 or anything else).
- */
- enum AVPixelFormat sw_format;
-
- /**
- * The allocated dimensions of the frames in this pool.
- *
- * Must be set by the user before calling av_hwframe_ctx_init().
- */
- int width, height;
-} AVHWFramesContext;
-
-/**
- * Look up an AVHWDeviceType by name.
- *
- * @param name String name of the device type (case-insensitive).
- * @return The type from enum AVHWDeviceType, or AV_HWDEVICE_TYPE_NONE if
- * not found.
- */
-enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name);
-
-/** Get the string name of an AVHWDeviceType.
- *
- * @param type Type from enum AVHWDeviceType.
- * @return Pointer to a static string containing the name, or NULL if the type
- * is not valid.
- */
-const char *av_hwdevice_get_type_name(enum AVHWDeviceType type);
-
-/**
- * Iterate over supported device types.
- *
- * @param type AV_HWDEVICE_TYPE_NONE initially, then the previous type
- * returned by this function in subsequent iterations.
- * @return The next usable device type from enum AVHWDeviceType, or
- * AV_HWDEVICE_TYPE_NONE if there are no more.
- */
-enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev);
-
-/**
- * Allocate an AVHWDeviceContext for a given hardware type.
- *
- * @param type the type of the hardware device to allocate.
- * @return a reference to the newly created AVHWDeviceContext on success or NULL
- * on failure.
- */
-AVBufferRef *av_hwdevice_ctx_alloc(enum AVHWDeviceType type);
-
-/**
- * Finalize the device context before use. This function must be called after
- * the context is filled with all the required information and before it is
- * used in any way.
- *
- * @param ref a reference to the AVHWDeviceContext
- * @return 0 on success, a negative AVERROR code on failure
- */
-int av_hwdevice_ctx_init(AVBufferRef *ref);
-
-/**
- * Open a device of the specified type and create an AVHWDeviceContext for it.
- *
- * This is a convenience function intended to cover the simple cases. Callers
- * who need to fine-tune device creation/management should open the device
- * manually and then wrap it in an AVHWDeviceContext using
- * av_hwdevice_ctx_alloc()/av_hwdevice_ctx_init().
- *
- * The returned context is already initialized and ready for use, the caller
- * should not call av_hwdevice_ctx_init() on it. The user_opaque/free fields of
- * the created AVHWDeviceContext are set by this function and should not be
- * touched by the caller.
- *
- * @param device_ctx On success, a reference to the newly-created device context
- * will be written here. The reference is owned by the caller
- * and must be released with av_buffer_unref() when no longer
- * needed. On failure, NULL will be written to this pointer.
- * @param type The type of the device to create.
- * @param device A type-specific string identifying the device to open.
- * @param opts A dictionary of additional (type-specific) options to use in
- * opening the device. The dictionary remains owned by the caller.
- * @param flags currently unused
- *
- * @return 0 on success, a negative AVERROR code on failure.
- */
-int av_hwdevice_ctx_create(AVBufferRef **device_ctx, enum AVHWDeviceType type,
- const char *device, AVDictionary *opts, int flags);
-
-/**
- * Create a new device of the specified type from an existing device.
- *
- * If the source device is a device of the target type or was originally
- * derived from such a device (possibly through one or more intermediate
- * devices of other types), then this will return a reference to the
- * existing device of the same type as is requested.
- *
- * Otherwise, it will attempt to derive a new device from the given source
- * device. If direct derivation to the new type is not implemented, it will
- * attempt the same derivation from each ancestor of the source device in
- * turn looking for an implemented derivation method.
- *
- * @param dst_ctx On success, a reference to the newly-created
- * AVHWDeviceContext.
- * @param type The type of the new device to create.
- * @param src_ctx A reference to an existing AVHWDeviceContext which will be
- * used to create the new device.
- * @param flags Currently unused; should be set to zero.
- * @return Zero on success, a negative AVERROR code on failure.
- */
-int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ctx,
- enum AVHWDeviceType type,
- AVBufferRef *src_ctx, int flags);
-
-
-/**
- * Allocate an AVHWFramesContext tied to a given device context.
- *
- * @param device_ctx a reference to a AVHWDeviceContext. This function will make
- * a new reference for internal use, the one passed to the
- * function remains owned by the caller.
- * @return a reference to the newly created AVHWFramesContext on success or NULL
- * on failure.
- */
-AVBufferRef *av_hwframe_ctx_alloc(AVBufferRef *device_ctx);
-
-/**
- * Finalize the context before use. This function must be called after the
- * context is filled with all the required information and before it is attached
- * to any frames.
- *
- * @param ref a reference to the AVHWFramesContext
- * @return 0 on success, a negative AVERROR code on failure
- */
-int av_hwframe_ctx_init(AVBufferRef *ref);
-
-/**
- * Allocate a new frame attached to the given AVHWFramesContext.
- *
- * @param hwframe_ctx a reference to an AVHWFramesContext
- * @param frame an empty (freshly allocated or unreffed) frame to be filled with
- * newly allocated buffers.
- * @param flags currently unused, should be set to zero
- * @return 0 on success, a negative AVERROR code on failure
- */
-int av_hwframe_get_buffer(AVBufferRef *hwframe_ctx, AVFrame *frame, int flags);
-
-/**
- * Copy data to or from a hw surface. At least one of dst/src must have an
- * AVHWFramesContext attached.
- *
- * If src has an AVHWFramesContext attached, then the format of dst (if set)
- * must use one of the formats returned by av_hwframe_transfer_get_formats(src,
- * AV_HWFRAME_TRANSFER_DIRECTION_FROM).
- * If dst has an AVHWFramesContext attached, then the format of src must use one
- * of the formats returned by av_hwframe_transfer_get_formats(dst,
- * AV_HWFRAME_TRANSFER_DIRECTION_TO)
- *
- * dst may be "clean" (i.e. with data/buf pointers unset), in which case the
- * data buffers will be allocated by this function using av_frame_get_buffer().
- * If dst->format is set, then this format will be used, otherwise (when
- * dst->format is AV_PIX_FMT_NONE) the first acceptable format will be chosen.
- *
- * The two frames must have matching allocated dimensions (i.e. equal to
- * AVHWFramesContext.width/height), since not all device types support
- * transferring a sub-rectangle of the whole surface. The display dimensions
- * (i.e. AVFrame.width/height) may be smaller than the allocated dimensions, but
- * also have to be equal for both frames. When the display dimensions are
- * smaller than the allocated dimensions, the content of the padding in the
- * destination frame is unspecified.
- *
- * @param dst the destination frame. dst is not touched on failure.
- * @param src the source frame.
- * @param flags currently unused, should be set to zero
- * @return 0 on success, a negative AVERROR error code on failure.
- */
-int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags);
-
-enum AVHWFrameTransferDirection {
- /**
- * Transfer the data from the queried hw frame.
- */
- AV_HWFRAME_TRANSFER_DIRECTION_FROM,
-
- /**
- * Transfer the data to the queried hw frame.
- */
- AV_HWFRAME_TRANSFER_DIRECTION_TO,
-};
-
-/**
- * Get a list of possible source or target formats usable in
- * av_hwframe_transfer_data().
- *
- * @param hwframe_ctx the frame context to obtain the information for
- * @param dir the direction of the transfer
- * @param formats the pointer to the output format list will be written here.
- * The list is terminated with AV_PIX_FMT_NONE and must be freed
- * by the caller when no longer needed using av_free().
- * If this function returns successfully, the format list will
- * have at least one item (not counting the terminator).
- * On failure, the contents of this pointer are unspecified.
- * @param flags currently unused, should be set to zero
- * @return 0 on success, a negative AVERROR code on failure.
- */
-int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ctx,
- enum AVHWFrameTransferDirection dir,
- enum AVPixelFormat **formats, int flags);
-
-
-/**
- * This struct describes the constraints on hardware frames attached to
- * a given device with a hardware-specific configuration. This is returned
- * by av_hwdevice_get_hwframe_constraints() and must be freed by
- * av_hwframe_constraints_free() after use.
- */
-typedef struct AVHWFramesConstraints {
- /**
- * A list of possible values for format in the hw_frames_ctx,
- * terminated by AV_PIX_FMT_NONE. This member will always be filled.
- */
- enum AVPixelFormat *valid_hw_formats;
-
- /**
- * A list of possible values for sw_format in the hw_frames_ctx,
- * terminated by AV_PIX_FMT_NONE. Can be NULL if this information is
- * not known.
- */
- enum AVPixelFormat *valid_sw_formats;
-
- /**
- * The minimum size of frames in this hw_frames_ctx.
- * (Zero if not known.)
- */
- int min_width;
- int min_height;
-
- /**
- * The maximum size of frames in this hw_frames_ctx.
- * (INT_MAX if not known / no limit.)
- */
- int max_width;
- int max_height;
-} AVHWFramesConstraints;
-
-/**
- * Allocate a HW-specific configuration structure for a given HW device.
- * After use, the user must free all members as required by the specific
- * hardware structure being used, then free the structure itself with
- * av_free().
- *
- * @param device_ctx a reference to the associated AVHWDeviceContext.
- * @return The newly created HW-specific configuration structure on
- * success or NULL on failure.
- */
-void *av_hwdevice_hwconfig_alloc(AVBufferRef *device_ctx);
-
-/**
- * Get the constraints on HW frames given a device and the HW-specific
- * configuration to be used with that device. If no HW-specific
- * configuration is provided, returns the maximum possible capabilities
- * of the device.
- *
- * @param ref a reference to the associated AVHWDeviceContext.
- * @param hwconfig a filled HW-specific configuration structure, or NULL
- * to return the maximum possible capabilities of the device.
- * @return AVHWFramesConstraints structure describing the constraints
- * on the device, or NULL if not available.
- */
-AVHWFramesConstraints *av_hwdevice_get_hwframe_constraints(AVBufferRef *ref,
- const void *hwconfig);
-
-/**
- * Free an AVHWFrameConstraints structure.
- *
- * @param constraints The (filled or unfilled) AVHWFrameConstraints structure.
- */
-void av_hwframe_constraints_free(AVHWFramesConstraints **constraints);
-
-
-/**
- * Flags to apply to frame mappings.
- */
-enum {
- /**
- * The mapping must be readable.
- */
- AV_HWFRAME_MAP_READ = 1 << 0,
- /**
- * The mapping must be writeable.
- */
- AV_HWFRAME_MAP_WRITE = 1 << 1,
- /**
- * The mapped frame will be overwritten completely in subsequent
- * operations, so the current frame data need not be loaded. Any values
- * which are not overwritten are unspecified.
- */
- AV_HWFRAME_MAP_OVERWRITE = 1 << 2,
- /**
- * The mapping must be direct. That is, there must not be any copying in
- * the map or unmap steps. Note that performance of direct mappings may
- * be much lower than normal memory.
- */
- AV_HWFRAME_MAP_DIRECT = 1 << 3,
-};
-
-/**
- * Map a hardware frame.
- *
- * This has a number of different possible effects, depending on the format
- * and origin of the src and dst frames. On input, src should be a usable
- * frame with valid buffers and dst should be blank (typically as just created
- * by av_frame_alloc()). src should have an associated hwframe context, and
- * dst may optionally have a format and associated hwframe context.
- *
- * If src was created by mapping a frame from the hwframe context of dst,
- * then this function undoes the mapping - dst is replaced by a reference to
- * the frame that src was originally mapped from.
- *
- * If both src and dst have an associated hwframe context, then this function
- * attempts to map the src frame from its hardware context to that of dst and
- * then fill dst with appropriate data to be usable there. This will only be
- * possible if the hwframe contexts and associated devices are compatible -
- * given compatible devices, av_hwframe_ctx_create_derived() can be used to
- * create a hwframe context for dst in which mapping should be possible.
- *
- * If src has a hwframe context but dst does not, then the src frame is
- * mapped to normal memory and should thereafter be usable as a normal frame.
- * If the format is set on dst, then the mapping will attempt to create dst
- * with that format and fail if it is not possible. If format is unset (is
- * AV_PIX_FMT_NONE) then dst will be mapped with whatever the most appropriate
- * format to use is (probably the sw_format of the src hwframe context).
- *
- * A return value of AVERROR(ENOSYS) indicates that the mapping is not
- * possible with the given arguments and hwframe setup, while other return
- * values indicate that it failed somehow.
- *
- * @param dst Destination frame, to contain the mapping.
- * @param src Source frame, to be mapped.
- * @param flags Some combination of AV_HWFRAME_MAP_* flags.
- * @return Zero on success, negative AVERROR code on failure.
- */
-int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags);
-
-
-/**
- * Create and initialise an AVHWFramesContext as a mapping of another existing
- * AVHWFramesContext on a different device.
- *
- * av_hwframe_ctx_init() should not be called after this.
- *
- * @param derived_frame_ctx On success, a reference to the newly created
- * AVHWFramesContext.
- * @param derived_device_ctx A reference to the device to create the new
- * AVHWFramesContext on.
- * @param source_frame_ctx A reference to an existing AVHWFramesContext
- * which will be mapped to the derived context.
- * @param flags Some combination of AV_HWFRAME_MAP_* flags, defining the
- * mapping parameters to apply to frames which are allocated
- * in the derived device.
- * @return Zero on success, negative AVERROR code on failure.
- */
-int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx,
- enum AVPixelFormat format,
- AVBufferRef *derived_device_ctx,
- AVBufferRef *source_frame_ctx,
- int flags);
-
-#endif /* AVUTIL_HWCONTEXT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_cuda.h Deleted

@@ -1,51 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#ifndef AVUTIL_HWCONTEXT_CUDA_H
-#define AVUTIL_HWCONTEXT_CUDA_H
-
-#ifndef CUDA_VERSION
-#include <cuda.h>
-#endif
-
-#include "pixfmt.h"
-
-/**
- * @file
- * An API-specific header for AV_HWDEVICE_TYPE_CUDA.
- *
- * This API supports dynamic frame pools. AVHWFramesContext.pool must return
- * AVBufferRefs whose data pointer is a CUdeviceptr.
- */
-
-typedef struct AVCUDADeviceContextInternal AVCUDADeviceContextInternal;
-
-/**
- * This struct is allocated as AVHWDeviceContext.hwctx
- */
-typedef struct AVCUDADeviceContext {
- CUcontext cuda_ctx;
- AVCUDADeviceContextInternal *internal;
-} AVCUDADeviceContext;
-
-/**
- * AVHWFramesContext.hwctx is currently not used
- */
-
-#endif /* AVUTIL_HWCONTEXT_CUDA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_d3d11va.h Deleted

@@ -1,169 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_D3D11VA_H
-#define AVUTIL_HWCONTEXT_D3D11VA_H
-
-/**
- * @file
- * An API-specific header for AV_HWDEVICE_TYPE_D3D11VA.
- *
- * The default pool implementation will be fixed-size if initial_pool_size is
- * set (and allocate elements from an array texture). Otherwise it will allocate
- * individual textures. Be aware that decoding requires a single array texture.
- *
- * Using sw_format==AV_PIX_FMT_YUV420P has special semantics, and maps to
- * DXGI_FORMAT_420_OPAQUE. av_hwframe_transfer_data() is not supported for
- * this format. Refer to MSDN for details.
- *
- * av_hwdevice_ctx_create() for this device type supports a key named "debug"
- * for the AVDictionary entry. If this is set to any value, the device creation
- * code will try to load various supported D3D debugging layers.
- */
-
-#include <d3d11.h>
-#include <stdint.h>
-
-/**
- * This struct is allocated as AVHWDeviceContext.hwctx
- */
-typedef struct AVD3D11VADeviceContext {
- /**
- * Device used for texture creation and access. This can also be used to
- * set the libavcodec decoding device.
- *
- * Must be set by the user. This is the only mandatory field - the other
- * device context fields are set from this and are available for convenience.
- *
- * Deallocating the AVHWDeviceContext will always release this interface,
- * and it does not matter whether it was user-allocated.
- */
- ID3D11Device *device;
-
- /**
- * If unset, this will be set from the device field on init.
- *
- * Deallocating the AVHWDeviceContext will always release this interface,
- * and it does not matter whether it was user-allocated.
- */
- ID3D11DeviceContext *device_context;
-
- /**
- * If unset, this will be set from the device field on init.
- *
- * Deallocating the AVHWDeviceContext will always release this interface,
- * and it does not matter whether it was user-allocated.
- */
- ID3D11VideoDevice *video_device;
-
- /**
- * If unset, this will be set from the device_context field on init.
- *
- * Deallocating the AVHWDeviceContext will always release this interface,
- * and it does not matter whether it was user-allocated.
- */
- ID3D11VideoContext *video_context;
-
- /**
- * Callbacks for locking. They protect accesses to device_context and
- * video_context calls. They also protect access to the internal staging
- * texture (for av_hwframe_transfer_data() calls). They do NOT protect
- * access to hwcontext or decoder state in general.
- *
- * If unset on init, the hwcontext implementation will set them to use an
- * internal mutex.
- *
- * The underlying lock must be recursive. lock_ctx is for free use by the
- * locking implementation.
- */
- void (*lock)(void *lock_ctx);
- void (*unlock)(void *lock_ctx);
- void *lock_ctx;
-} AVD3D11VADeviceContext;
-
-/**
- * D3D11 frame descriptor for pool allocation.
- *
- * In user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
- * with the data pointer pointing at an object of this type describing the
- * planes of the frame.
- *
- * This has no use outside of custom allocation, and AVFrame AVBufferRef do not
- * necessarily point to an instance of this struct.
- */
-typedef struct AVD3D11FrameDescriptor {
- /**
- * The texture in which the frame is located. The reference count is
- * managed by the AVBufferRef, and destroying the reference will release
- * the interface.
- *
- * Normally stored in AVFrame.data0.
- */
- ID3D11Texture2D *texture;
-
- /**
- * The index into the array texture element representing the frame, or 0
- * if the texture is not an array texture.
- *
- * Normally stored in AVFrame.data1 (cast from intptr_t).
- */
- intptr_t index;
-} AVD3D11FrameDescriptor;
-
-/**
- * This struct is allocated as AVHWFramesContext.hwctx
- */
-typedef struct AVD3D11VAFramesContext {
- /**
- * The canonical texture used for pool allocation. If this is set to NULL
- * on init, the hwframes implementation will allocate and set an array
- * texture if initial_pool_size > 0.
- *
- * The only situation when the API user should set this is:
- * - the user wants to do manual pool allocation (setting
- * AVHWFramesContext.pool), instead of letting AVHWFramesContext
- * allocate the pool
- * - of an array texture
- * - and wants it to use it for decoding
- * - this has to be done before calling av_hwframe_ctx_init()
- *
- * Deallocating the AVHWFramesContext will always release this interface,
- * and it does not matter whether it was user-allocated.
- *
- * This is in particular used by the libavcodec D3D11VA hwaccel, which
- * requires a single array texture. It will create ID3D11VideoDecoderOutputView
- * objects for each array texture element on decoder initialization.
- */
- ID3D11Texture2D *texture;
-
- /**
- * D3D11_TEXTURE2D_DESC.BindFlags used for texture creation. The user must
- * at least set D3D11_BIND_DECODER if the frames context is to be used for
- * video decoding.
- * This field is ignored/invalid if a user-allocated texture is provided.
- */
- UINT BindFlags;
-
- /**
- * D3D11_TEXTURE2D_DESC.MiscFlags used for texture creation.
- * This field is ignored/invalid if a user-allocated texture is provided.
- */
- UINT MiscFlags;
-} AVD3D11VAFramesContext;
-
-#endif /* AVUTIL_HWCONTEXT_D3D11VA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_drm.h Deleted

@@ -1,169 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_DRM_H
-#define AVUTIL_HWCONTEXT_DRM_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-/**
- * @file
- * API-specific header for AV_HWDEVICE_TYPE_DRM.
- *
- * Internal frame allocation is not currently supported - all frames
- * must be allocated by the user. Thus AVHWFramesContext is always
- * NULL, though this may change if support for frame allocation is
- * added in future.
- */
-
-enum {
- /**
- * The maximum number of layers/planes in a DRM frame.
- */
- AV_DRM_MAX_PLANES = 4
-};
-
-/**
- * DRM object descriptor.
- *
- * Describes a single DRM object, addressing it as a PRIME file
- * descriptor.
- */
-typedef struct AVDRMObjectDescriptor {
- /**
- * DRM PRIME fd for the object.
- */
- int fd;
- /**
- * Total size of the object.
- *
- * (This includes any parts not which do not contain image data.)
- */
- size_t size;
- /**
- * Format modifier applied to the object (DRM_FORMAT_MOD_*).
- *
- * If the format modifier is unknown then this should be set to
- * DRM_FORMAT_MOD_INVALID.
- */
- uint64_t format_modifier;
-} AVDRMObjectDescriptor;
-
-/**
- * DRM plane descriptor.
- *
- * Describes a single plane of a layer, which is contained within
- * a single object.
- */
-typedef struct AVDRMPlaneDescriptor {
- /**
- * Index of the object containing this plane in the objects
- * array of the enclosing frame descriptor.
- */
- int object_index;
- /**
- * Offset within that object of this plane.
- */
- ptrdiff_t offset;
- /**
- * Pitch (linesize) of this plane.
- */
- ptrdiff_t pitch;
-} AVDRMPlaneDescriptor;
-
-/**
- * DRM layer descriptor.
- *
- * Describes a single layer within a frame. This has the structure
- * defined by its format, and will contain one or more planes.
- */
-typedef struct AVDRMLayerDescriptor {
- /**
- * Format of the layer (DRM_FORMAT_*).
- */
- uint32_t format;
- /**
- * Number of planes in the layer.
- *
- * This must match the number of planes required by format.
- */
- int nb_planes;
- /**
- * Array of planes in this layer.
- */
- AVDRMPlaneDescriptor planesAV_DRM_MAX_PLANES;
-} AVDRMLayerDescriptor;
-
-/**
- * DRM frame descriptor.
- *
- * This is used as the data pointer for AV_PIX_FMT_DRM_PRIME frames.
- * It is also used by user-allocated frame pools - allocating in
- * AVHWFramesContext.pool must return AVBufferRefs which contain
- * an object of this type.
- *
- * The fields of this structure should be set such it can be
- * imported directly by EGL using the EGL_EXT_image_dma_buf_import
- * and EGL_EXT_image_dma_buf_import_modifiers extensions.
- * (Note that the exact layout of a particular format may vary between
- * platforms - we only specify that the same platform should be able
- * to import it.)
- *
- * The total number of planes must not exceed AV_DRM_MAX_PLANES, and
- * the order of the planes by increasing layer index followed by
- * increasing plane index must be the same as the order which would
- * be used for the data pointers in the equivalent software format.
- */
-typedef struct AVDRMFrameDescriptor {
- /**
- * Number of DRM objects making up this frame.
- */
- int nb_objects;
- /**
- * Array of objects making up the frame.
- */
- AVDRMObjectDescriptor objectsAV_DRM_MAX_PLANES;
- /**
- * Number of layers in the frame.
- */
- int nb_layers;
- /**
- * Array of layers in the frame.
- */
- AVDRMLayerDescriptor layersAV_DRM_MAX_PLANES;
-} AVDRMFrameDescriptor;
-
-/**
- * DRM device.
- *
- * Allocated as AVHWDeviceContext.hwctx.
- */
-typedef struct AVDRMDeviceContext {
- /**
- * File descriptor of DRM device.
- *
- * This is used as the device to create frames on, and may also be
- * used in some derivation and mapping operations.
- *
- * If no device is required, set to -1.
- */
- int fd;
-} AVDRMDeviceContext;
-
-#endif /* AVUTIL_HWCONTEXT_DRM_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_dxva2.h Deleted

@@ -1,75 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#ifndef AVUTIL_HWCONTEXT_DXVA2_H
-#define AVUTIL_HWCONTEXT_DXVA2_H
-
-/**
- * @file
- * An API-specific header for AV_HWDEVICE_TYPE_DXVA2.
- *
- * Only fixed-size pools are supported.
- *
- * For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
- * with the data pointer set to a pointer to IDirect3DSurface9.
- */
-
-#include <d3d9.h>
-#include <dxva2api.h>
-
-/**
- * This struct is allocated as AVHWDeviceContext.hwctx
- */
-typedef struct AVDXVA2DeviceContext {
- IDirect3DDeviceManager9 *devmgr;
-} AVDXVA2DeviceContext;
-
-/**
- * This struct is allocated as AVHWFramesContext.hwctx
- */
-typedef struct AVDXVA2FramesContext {
- /**
- * The surface type (e.g. DXVA2_VideoProcessorRenderTarget or
- * DXVA2_VideoDecoderRenderTarget). Must be set by the caller.
- */
- DWORD surface_type;
-
- /**
- * The surface pool. When an external pool is not provided by the caller,
- * this will be managed (allocated and filled on init, freed on uninit) by
- * libavutil.
- */
- IDirect3DSurface9 **surfaces;
- int nb_surfaces;
-
- /**
- * Certain drivers require the decoder to be destroyed before the surfaces.
- * To allow internally managed pools to work properly in such cases, this
- * field is provided.
- *
- * If it is non-NULL, libavutil will call IDirectXVideoDecoder_Release() on
- * it just before the internal surface pool is freed.
- *
- * This is for convenience only. Some code uses other methods to manage the
- * decoder reference.
- */
- IDirectXVideoDecoder *decoder_to_release;
-} AVDXVA2FramesContext;
-
-#endif /* AVUTIL_HWCONTEXT_DXVA2_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_mediacodec.h Deleted

@@ -1,36 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_MEDIACODEC_H
-#define AVUTIL_HWCONTEXT_MEDIACODEC_H
-
-/**
- * MediaCodec details.
- *
- * Allocated as AVHWDeviceContext.hwctx
- */
-typedef struct AVMediaCodecDeviceContext {
-    /**
-     * android/view/Surface handle, to be filled by the user.
-     *
-     * This is the default surface used by decoders on this device.
-     */
-    void *surface;
-} AVMediaCodecDeviceContext;
-
-#endif /* AVUTIL_HWCONTEXT_MEDIACODEC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_qsv.h Deleted

@@ -1,53 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_QSV_H
-#define AVUTIL_HWCONTEXT_QSV_H
-
-#include <mfx/mfxvideo.h>
-
-/**
- * @file
- * An API-specific header for AV_HWDEVICE_TYPE_QSV.
- *
- * This API does not support dynamic frame pools. AVHWFramesContext.pool must
- * contain AVBufferRefs whose data pointer points to an mfxFrameSurface1 struct.
- */
-
-/**
- * This struct is allocated as AVHWDeviceContext.hwctx
- */
-typedef struct AVQSVDeviceContext {
- mfxSession session;
-} AVQSVDeviceContext;
-
-/**
- * This struct is allocated as AVHWFramesContext.hwctx
- */
-typedef struct AVQSVFramesContext {
- mfxFrameSurface1 *surfaces;
- int nb_surfaces;
-
- /**
- * A combination of MFX_MEMTYPE_* describing the frame pool.
- */
- int frame_type;
-} AVQSVFramesContext;
-
-#endif /* AVUTIL_HWCONTEXT_QSV_H */
-

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_vaapi.h Deleted

@@ -1,117 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_VAAPI_H
-#define AVUTIL_HWCONTEXT_VAAPI_H
-
-#include <va/va.h>
-
-/**
- * @file
- * API-specific header for AV_HWDEVICE_TYPE_VAAPI.
- *
- * Dynamic frame pools are supported, but note that any pool used as a render
- * target is required to be of fixed size in order to be be usable as an
- * argument to vaCreateContext().
- *
- * For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
- * with the data pointer set to a VASurfaceID.
- */
-
-enum {
- /**
- * The quirks field has been set by the user and should not be detected
- * automatically by av_hwdevice_ctx_init().
- */
- AV_VAAPI_DRIVER_QUIRK_USER_SET = (1 << 0),
- /**
- * The driver does not destroy parameter buffers when they are used by
- * vaRenderPicture(). Additional code will be required to destroy them
- * separately afterwards.
- */
- AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS = (1 << 1),
-
- /**
- * The driver does not support the VASurfaceAttribMemoryType attribute,
- * so the surface allocation code will not try to use it.
- */
- AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE = (1 << 2),
-
- /**
- * The driver does not support surface attributes at all.
- * The surface allocation code will never pass them to surface allocation,
- * and the results of the vaQuerySurfaceAttributes() call will be faked.
- */
- AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES = (1 << 3),
-};
-
-/**
- * VAAPI connection details.
- *
- * Allocated as AVHWDeviceContext.hwctx
- */
-typedef struct AVVAAPIDeviceContext {
- /**
- * The VADisplay handle, to be filled by the user.
- */
- VADisplay display;
- /**
- * Driver quirks to apply - this is filled by av_hwdevice_ctx_init(),
- * with reference to a table of known drivers, unless the
- * AV_VAAPI_DRIVER_QUIRK_USER_SET bit is already present. The user
- * may need to refer to this field when performing any later
- * operations using VAAPI with the same VADisplay.
- */
- unsigned int driver_quirks;
-} AVVAAPIDeviceContext;
-
-/**
- * VAAPI-specific data associated with a frame pool.
- *
- * Allocated as AVHWFramesContext.hwctx.
- */
-typedef struct AVVAAPIFramesContext {
- /**
- * Set by the user to apply surface attributes to all surfaces in
- * the frame pool. If null, default settings are used.
- */
- VASurfaceAttrib *attributes;
- int nb_attributes;
- /**
- * The surfaces IDs of all surfaces in the pool after creation.
- * Only valid if AVHWFramesContext.initial_pool_size was positive.
- * These are intended to be used as the render_targets arguments to
- * vaCreateContext().
- */
- VASurfaceID *surface_ids;
- int nb_surfaces;
-} AVVAAPIFramesContext;
-
-/**
- * VAAPI hardware pipeline configuration details.
- *
- * Allocated with av_hwdevice_hwconfig_alloc().
- */
-typedef struct AVVAAPIHWConfig {
- /**
- * ID of a VAAPI pipeline configuration.
- */
- VAConfigID config_id;
-} AVVAAPIHWConfig;
-
-#endif /* AVUTIL_HWCONTEXT_VAAPI_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_vdpau.h Deleted

@@ -1,44 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_VDPAU_H
-#define AVUTIL_HWCONTEXT_VDPAU_H
-
-#include <vdpau/vdpau.h>
-
-/**
- * @file
- * An API-specific header for AV_HWDEVICE_TYPE_VDPAU.
- *
- * This API supports dynamic frame pools. AVHWFramesContext.pool must return
- * AVBufferRefs whose data pointer is a VdpVideoSurface.
- */
-
-/**
- * This struct is allocated as AVHWDeviceContext.hwctx
- */
-typedef struct AVVDPAUDeviceContext {
- VdpDevice device;
- VdpGetProcAddress *get_proc_address;
-} AVVDPAUDeviceContext;
-
-/**
- * AVHWFramesContext.hwctx is currently not used
- */
-
-#endif /* AVUTIL_HWCONTEXT_VDPAU_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/hwcontext_videotoolbox.h Deleted

@@ -1,54 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H
-#define AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H
-
-#include <stdint.h>
-
-#include <VideoToolbox/VideoToolbox.h>
-
-#include "pixfmt.h"
-
-/**
- * @file
- * An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX.
- *
- * This API currently does not support frame allocation, as the raw VideoToolbox
- * API does allocation, and FFmpeg itself never has the need to allocate frames.
- *
- * If the API user sets a custom pool, AVHWFramesContext.pool must return
- * AVBufferRefs whose data pointer is a CVImageBufferRef or CVPixelBufferRef.
- *
- * Currently AVHWDeviceContext.hwctx and AVHWFramesContext.hwctx are always
- * NULL.
- */
-
-/**
- * Convert a VideoToolbox (actually CoreVideo) format to AVPixelFormat.
- * Returns AV_PIX_FMT_NONE if no known equivalent was found.
- */
-enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt);
-
-/**
- * Convert an AVPixelFormat to a VideoToolbox (actually CoreVideo) format.
- * Returns 0 if no known equivalent was found.
- */
-uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt);
-
-#endif /* AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/imgutils.h Deleted

@@ -1,277 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_IMGUTILS_H
-#define AVUTIL_IMGUTILS_H
-
-/**
- * @file
- * misc image utilities
- *
- * @addtogroup lavu_picture
- * @{
- */
-
-#include "avutil.h"
-#include "pixdesc.h"
-#include "rational.h"
-
-/**
- * Compute the max pixel step for each plane of an image with a
- * format described by pixdesc.
- *
- * The pixel step is the distance in bytes between the first byte of
- * the group of bytes which describe a pixel component and the first
- * byte of the successive group in the same plane for the same
- * component.
- *
- * @param max_pixsteps an array which is filled with the max pixel step
- * for each plane. Since a plane may contain different pixel
- * components, the computed max_pixstepsplane is relative to the
- * component in the plane with the max pixel step.
- * @param max_pixstep_comps an array which is filled with the component
- * for each plane which has the max pixel step. May be NULL.
- */
-void av_image_fill_max_pixsteps(int max_pixsteps4, int max_pixstep_comps4,
-                                const AVPixFmtDescriptor *pixdesc);
-
-/**
- * Compute the size of an image line with format pix_fmt and width
- * width for the plane plane.
- *
- * @return the computed size in bytes
- */
-int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane);
-
-/**
- * Fill plane linesizes for an image with pixel format pix_fmt and
- * width width.
- *
- * @param linesizes array to be filled with the linesize for each plane
- * @return >= 0 in case of success, a negative error code otherwise
- */
-int av_image_fill_linesizes(int linesizes4, enum AVPixelFormat pix_fmt, int width);
-
-/**
- * Fill plane data pointers for an image with pixel format pix_fmt and
- * height height.
- *
- * @param data pointers array to be filled with the pointer for each image plane
- * @param ptr the pointer to a buffer which will contain the image
- * @param linesizes the array containing the linesize for each
- * plane, should be filled by av_image_fill_linesizes()
- * @return the size in bytes required for the image buffer, a negative
- * error code in case of failure
- */
-int av_image_fill_pointers(uint8_t *data4, enum AVPixelFormat pix_fmt, int height,
-                           uint8_t *ptr, const int linesizes4);
-
-/**
- * Allocate an image with size w and h and pixel format pix_fmt, and
- * fill pointers and linesizes accordingly.
- * The allocated image buffer has to be freed by using
- * av_freep(&pointers0).
- *
- * @param align the value to use for buffer size alignment
- * @return the size in bytes required for the image buffer, a negative
- * error code in case of failure
- */
-int av_image_alloc(uint8_t *pointers4, int linesizes4,
-                   int w, int h, enum AVPixelFormat pix_fmt, int align);
-
-/**
- * Copy image plane from src to dst.
- * That is, copy "height" number of lines of "bytewidth" bytes each.
- * The first byte of each successive line is separated by *_linesize
- * bytes.
- *
- * bytewidth must be contained by both absolute values of dst_linesize
- * and src_linesize, otherwise the function behavior is undefined.
- *
- * @param dst_linesize linesize for the image plane in dst
- * @param src_linesize linesize for the image plane in src
- */
-void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
-                         const uint8_t *src, int src_linesize,
-                         int bytewidth, int height);
-
-/**
- * Copy image in src_data to dst_data.
- *
- * @param dst_linesizes linesizes for the image in dst_data
- * @param src_linesizes linesizes for the image in src_data
- */
-void av_image_copy(uint8_t *dst_data4, int dst_linesizes4,
-                   const uint8_t *src_data4, const int src_linesizes4,
-                   enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * Copy image data located in uncacheable (e.g. GPU mapped) memory. Where
- * available, this function will use special functionality for reading from such
- * memory, which may result in greatly improved performance compared to plain
- * av_image_copy().
- *
- * The data pointers and the linesizes must be aligned to the maximum required
- * by the CPU architecture.
- *
- * @note The linesize parameters have the type ptrdiff_t here, while they are
- *       int for av_image_copy().
- * @note On x86, the linesizes currently need to be aligned to the cacheline
- *       size (i.e. 64) to get improved performance.
- */
-void av_image_copy_uc_from(uint8_t *dst_data4,       const ptrdiff_t dst_linesizes4,
-                           const uint8_t *src_data4, const ptrdiff_t src_linesizes4,
-                           enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * Setup the data pointers and linesizes based on the specified image
- * parameters and the provided array.
- *
- * The fields of the given image are filled in by using the src
- * address which points to the image data buffer. Depending on the
- * specified pixel format, one or multiple image data pointers and
- * line sizes will be set.  If a planar format is specified, several
- * pointers will be set pointing to the different picture planes and
- * the line sizes of the different planes will be stored in the
- * lines_sizes array. Call with src == NULL to get the required
- * size for the src buffer.
- *
- * To allocate the buffer and fill in the dst_data and dst_linesize in
- * one call, use av_image_alloc().
- *
- * @param dst_data      data pointers to be filled in
- * @param dst_linesize  linesizes for the image in dst_data to be filled in
- * @param src           buffer which will contain or contains the actual image data, can be NULL
- * @param pix_fmt       the pixel format of the image
- * @param width         the width of the image in pixels
- * @param height        the height of the image in pixels
- * @param align         the value used in src for linesize alignment
- * @return the size in bytes required for src, a negative error code
- * in case of failure
- */
-int av_image_fill_arrays(uint8_t *dst_data4, int dst_linesize4,
-                         const uint8_t *src,
-                         enum AVPixelFormat pix_fmt, int width, int height, int align);
-
-/**
- * Return the size in bytes of the amount of data required to store an
- * image with the given parameters.
- *
- * @param pix_fmt  the pixel format of the image
- * @param width    the width of the image in pixels
- * @param height   the height of the image in pixels
- * @param align    the assumed linesize alignment
- * @return the buffer size in bytes, a negative error code in case of failure
- */
-int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align);
-
-/**
- * Copy image data from an image into a buffer.
- *
- * av_image_get_buffer_size() can be used to compute the required size
- * for the buffer to fill.
- *
- * @param dst           a buffer into which picture data will be copied
- * @param dst_size      the size in bytes of dst
- * @param src_data      pointers containing the source image data
- * @param src_linesize  linesizes for the image in src_data
- * @param pix_fmt       the pixel format of the source image
- * @param width         the width of the source image in pixels
- * @param height        the height of the source image in pixels
- * @param align         the assumed linesize alignment for dst
- * @return the number of bytes written to dst, or a negative value
- * (error code) on error
- */
-int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
-                            const uint8_t * const src_data4, const int src_linesize4,
-                            enum AVPixelFormat pix_fmt, int width, int height, int align);
-
-/**
- * Check if the given dimension of an image is valid, meaning that all
- * bytes of the image can be addressed with a signed int.
- *
- * @param w the width of the picture
- * @param h the height of the picture
- * @param log_offset the offset to sum to the log level for logging with log_ctx
- * @param log_ctx the parent logging context, it may be NULL
- * @return >= 0 if valid, a negative error code otherwise
- */
-int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx);
-
-/**
- * Check if the given dimension of an image is valid, meaning that all
- * bytes of a plane of an image with the specified pix_fmt can be addressed
- * with a signed int.
- *
- * @param w the width of the picture
- * @param h the height of the picture
- * @param max_pixels the maximum number of pixels the user wants to accept
- * @param pix_fmt the pixel format, can be AV_PIX_FMT_NONE if unknown.
- * @param log_offset the offset to sum to the log level for logging with log_ctx
- * @param log_ctx the parent logging context, it may be NULL
- * @return >= 0 if valid, a negative error code otherwise
- */
-int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx);
-
-/**
- * Check if the given sample aspect ratio of an image is valid.
- *
- * It is considered invalid if the denominator is 0 or if applying the ratio
- * to the image size would make the smaller dimension less than 1. If the
- * sar numerator is 0, it is considered unknown and will return as valid.
- *
- * @param w width of the image
- * @param h height of the image
- * @param sar sample aspect ratio of the image
- * @return 0 if valid, a negative AVERROR code otherwise
- */
-int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar);
-
-/**
- * Overwrite the image data with black. This is suitable for filling a
- * sub-rectangle of an image, meaning the padding between the right most pixel
- * and the left most pixel on the next line will not be overwritten. For some
- * formats, the image size might be rounded up due to inherent alignment.
- *
- * If the pixel format has alpha, the alpha is cleared to opaque.
- *
- * This can return an error if the pixel format is not supported. Normally, all
- * non-hwaccel pixel formats should be supported.
- *
- * Passing NULL for dst_data is allowed. Then the function returns whether the
- * operation would have succeeded. (It can return an error if the pix_fmt is
- * not supported.)
- *
- * @param dst_data      data pointers to destination image
- * @param dst_linesize  linesizes for the destination image
- * @param pix_fmt       the pixel format of the image
- * @param range         the color range of the image (important for colorspaces such as YUV)
- * @param width         the width of the image in pixels
- * @param height        the height of the image in pixels
- * @return 0 if the image data was cleared, a negative AVERROR code otherwise
- */
-int av_image_fill_black(uint8_t *dst_data4, const ptrdiff_t dst_linesize4,
-                        enum AVPixelFormat pix_fmt, enum AVColorRange range,
-                        int width, int height);
-
-/**
- * @}
- */
-
-
-#endif /* AVUTIL_IMGUTILS_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/intfloat.h Deleted

@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2011 Mans Rullgard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_INTFLOAT_H
-#define AVUTIL_INTFLOAT_H
-
-#include <stdint.h>
-#include "attributes.h"
-
-union av_intfloat32 {
- uint32_t i;
- float f;
-};
-
-union av_intfloat64 {
- uint64_t i;
- double f;
-};
-
-/**
- * Reinterpret a 32-bit integer as a float.
- */
-static av_always_inline float av_int2float(uint32_t i)
-{
- union av_intfloat32 v;
- v.i = i;
- return v.f;
-}
-
-/**
- * Reinterpret a float as a 32-bit integer.
- */
-static av_always_inline uint32_t av_float2int(float f)
-{
- union av_intfloat32 v;
- v.f = f;
- return v.i;
-}
-
-/**
- * Reinterpret a 64-bit integer as a double.
- */
-static av_always_inline double av_int2double(uint64_t i)
-{
- union av_intfloat64 v;
- v.i = i;
- return v.f;
-}
-
-/**
- * Reinterpret a double as a 64-bit integer.
- */
-static av_always_inline uint64_t av_double2int(double f)
-{
- union av_intfloat64 v;
- v.f = f;
- return v.i;
-}
-
-#endif /* AVUTIL_INTFLOAT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/intreadwrite.h Deleted

@@ -1,629 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_INTREADWRITE_H
-#define AVUTIL_INTREADWRITE_H
-
-#include <stdint.h>
-#include "libavutil/avconfig.h"
-#include "attributes.h"
-#include "bswap.h"
-
-typedef union {
- uint64_t u64;
- uint32_t u322;
- uint16_t u164;
- uint8_t u8 8;
- double f64;
- float f322;
-} av_alias av_alias64;
-
-typedef union {
- uint32_t u32;
- uint16_t u162;
- uint8_t u8 4;
- float f32;
-} av_alias av_alias32;
-
-typedef union {
- uint16_t u16;
- uint8_t u8 2;
-} av_alias av_alias16;
-
-/*
- * Arch-specific headers can provide any combination of
- * AV_RWBLN(16|24|32|48|64) and AV_(COPY|SWAP|ZERO)(64|128) macros.
- * Preprocessor symbols must be defined, even if these are implemented
- * as inline functions.
- *
- * R/W means read/write, B/L/N means big/little/native endianness.
- * The following macros require aligned access, compared to their
- * unaligned variants: AV_(COPY|SWAP|ZERO)(64|128), AV_RWN8-64A.
- * Incorrect usage may range from abysmal performance to crash
- * depending on the platform.
- *
- * The unaligned variants are AV_RWBLN8-64 and AV_COPY*U.
- */
-
-#ifdef HAVE_AV_CONFIG_H
-
-#include "config.h"
-
-#if ARCH_ARM
-# include "arm/intreadwrite.h"
-#elif ARCH_AVR32
-# include "avr32/intreadwrite.h"
-#elif ARCH_MIPS
-# include "mips/intreadwrite.h"
-#elif ARCH_PPC
-# include "ppc/intreadwrite.h"
-#elif ARCH_TOMI
-# include "tomi/intreadwrite.h"
-#elif ARCH_X86
-# include "x86/intreadwrite.h"
-#endif
-
-#endif /* HAVE_AV_CONFIG_H */
-
-/*
- * Map AV_RNXX <-> AV_RBLXX for all variants provided by per-arch headers.
- */
-
-#if AV_HAVE_BIGENDIAN
-
-# if defined(AV_RN16) && !defined(AV_RB16)
-# define AV_RB16(p) AV_RN16(p)
-# elif !defined(AV_RN16) && defined(AV_RB16)
-# define AV_RN16(p) AV_RB16(p)
-# endif
-
-# if defined(AV_WN16) && !defined(AV_WB16)
-# define AV_WB16(p, v) AV_WN16(p, v)
-# elif !defined(AV_WN16) && defined(AV_WB16)
-# define AV_WN16(p, v) AV_WB16(p, v)
-# endif
-
-# if defined(AV_RN24) && !defined(AV_RB24)
-# define AV_RB24(p) AV_RN24(p)
-# elif !defined(AV_RN24) && defined(AV_RB24)
-# define AV_RN24(p) AV_RB24(p)
-# endif
-
-# if defined(AV_WN24) && !defined(AV_WB24)
-# define AV_WB24(p, v) AV_WN24(p, v)
-# elif !defined(AV_WN24) && defined(AV_WB24)
-# define AV_WN24(p, v) AV_WB24(p, v)
-# endif
-
-# if defined(AV_RN32) && !defined(AV_RB32)
-# define AV_RB32(p) AV_RN32(p)
-# elif !defined(AV_RN32) && defined(AV_RB32)
-# define AV_RN32(p) AV_RB32(p)
-# endif
-
-# if defined(AV_WN32) && !defined(AV_WB32)
-# define AV_WB32(p, v) AV_WN32(p, v)
-# elif !defined(AV_WN32) && defined(AV_WB32)
-# define AV_WN32(p, v) AV_WB32(p, v)
-# endif
-
-# if defined(AV_RN48) && !defined(AV_RB48)
-# define AV_RB48(p) AV_RN48(p)
-# elif !defined(AV_RN48) && defined(AV_RB48)
-# define AV_RN48(p) AV_RB48(p)
-# endif
-
-# if defined(AV_WN48) && !defined(AV_WB48)
-# define AV_WB48(p, v) AV_WN48(p, v)
-# elif !defined(AV_WN48) && defined(AV_WB48)
-# define AV_WN48(p, v) AV_WB48(p, v)
-# endif
-
-# if defined(AV_RN64) && !defined(AV_RB64)
-# define AV_RB64(p) AV_RN64(p)
-# elif !defined(AV_RN64) && defined(AV_RB64)
-# define AV_RN64(p) AV_RB64(p)
-# endif
-
-# if defined(AV_WN64) && !defined(AV_WB64)
-# define AV_WB64(p, v) AV_WN64(p, v)
-# elif !defined(AV_WN64) && defined(AV_WB64)
-# define AV_WN64(p, v) AV_WB64(p, v)
-# endif
-
-#else /* AV_HAVE_BIGENDIAN */
-
-# if defined(AV_RN16) && !defined(AV_RL16)
-# define AV_RL16(p) AV_RN16(p)
-# elif !defined(AV_RN16) && defined(AV_RL16)
-# define AV_RN16(p) AV_RL16(p)
-# endif
-
-# if defined(AV_WN16) && !defined(AV_WL16)
-# define AV_WL16(p, v) AV_WN16(p, v)
-# elif !defined(AV_WN16) && defined(AV_WL16)
-# define AV_WN16(p, v) AV_WL16(p, v)
-# endif
-
-# if defined(AV_RN24) && !defined(AV_RL24)
-# define AV_RL24(p) AV_RN24(p)
-# elif !defined(AV_RN24) && defined(AV_RL24)
-# define AV_RN24(p) AV_RL24(p)
-# endif
-
-# if defined(AV_WN24) && !defined(AV_WL24)
-# define AV_WL24(p, v) AV_WN24(p, v)
-# elif !defined(AV_WN24) && defined(AV_WL24)
-# define AV_WN24(p, v) AV_WL24(p, v)
-# endif
-
-# if defined(AV_RN32) && !defined(AV_RL32)
-# define AV_RL32(p) AV_RN32(p)
-# elif !defined(AV_RN32) && defined(AV_RL32)
-# define AV_RN32(p) AV_RL32(p)
-# endif
-
-# if defined(AV_WN32) && !defined(AV_WL32)
-# define AV_WL32(p, v) AV_WN32(p, v)
-# elif !defined(AV_WN32) && defined(AV_WL32)
-# define AV_WN32(p, v) AV_WL32(p, v)
-# endif
-
-# if defined(AV_RN48) && !defined(AV_RL48)
-# define AV_RL48(p) AV_RN48(p)
-# elif !defined(AV_RN48) && defined(AV_RL48)
-# define AV_RN48(p) AV_RL48(p)
-# endif
-
-# if defined(AV_WN48) && !defined(AV_WL48)
-# define AV_WL48(p, v) AV_WN48(p, v)
-# elif !defined(AV_WN48) && defined(AV_WL48)
-# define AV_WN48(p, v) AV_WL48(p, v)
-# endif
-
-# if defined(AV_RN64) && !defined(AV_RL64)
-# define AV_RL64(p) AV_RN64(p)
-# elif !defined(AV_RN64) && defined(AV_RL64)
-# define AV_RN64(p) AV_RL64(p)
-# endif
-
-# if defined(AV_WN64) && !defined(AV_WL64)
-# define AV_WL64(p, v) AV_WN64(p, v)
-# elif !defined(AV_WN64) && defined(AV_WL64)
-# define AV_WN64(p, v) AV_WL64(p, v)
-# endif
-
-#endif /* !AV_HAVE_BIGENDIAN */
-
-/*
- * Define AV_RWN helper macros to simplify definitions not provided
- * by per-arch headers.
- */
-
-#if defined(__GNUC__)
-
-union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias;
-union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias;
-union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
-
-# define AV_RN(s, p) (((const union unaligned_##s *) (p))->l)
-# define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v))
-
-#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_X64) || defined(_M_ARM64)) && AV_HAVE_FAST_UNALIGNED
-
-# define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
-# define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
-
-#elif AV_HAVE_FAST_UNALIGNED
-
-# define AV_RN(s, p) (((const av_alias##s*)(p))->u##s)
-# define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v))
-
-#else
-
-#ifndef AV_RB16
-# define AV_RB16(x) \
- ((((const uint8_t*)(x))0 << 8) | \
- ((const uint8_t*)(x))1)
-#endif
-#ifndef AV_WB16
-# define AV_WB16(p, val) do { \
- uint16_t d = (val); \
- ((uint8_t*)(p))1 = (d); \
- ((uint8_t*)(p))0 = (d)>>8; \
- } while(0)
-#endif
-
-#ifndef AV_RL16
-# define AV_RL16(x) \
- ((((const uint8_t*)(x))1 << 8) | \
- ((const uint8_t*)(x))0)
-#endif
-#ifndef AV_WL16
-# define AV_WL16(p, val) do { \
- uint16_t d = (val); \
- ((uint8_t*)(p))0 = (d); \
- ((uint8_t*)(p))1 = (d)>>8; \
- } while(0)
-#endif
-
-#ifndef AV_RB32
-# define AV_RB32(x) \
- (((uint32_t)((const uint8_t*)(x))0 << 24) | \
- (((const uint8_t*)(x))1 << 16) | \
- (((const uint8_t*)(x))2 << 8) | \
- ((const uint8_t*)(x))3)
-#endif
-#ifndef AV_WB32
-# define AV_WB32(p, val) do { \
- uint32_t d = (val); \
- ((uint8_t*)(p))3 = (d); \
- ((uint8_t*)(p))2 = (d)>>8; \
- ((uint8_t*)(p))1 = (d)>>16; \
- ((uint8_t*)(p))0 = (d)>>24; \
- } while(0)
-#endif
-
-#ifndef AV_RL32
-# define AV_RL32(x) \
- (((uint32_t)((const uint8_t*)(x))3 << 24) | \
- (((const uint8_t*)(x))2 << 16) | \
- (((const uint8_t*)(x))1 << 8) | \
- ((const uint8_t*)(x))0)
-#endif
-#ifndef AV_WL32
-# define AV_WL32(p, val) do { \
- uint32_t d = (val); \
- ((uint8_t*)(p))0 = (d); \
- ((uint8_t*)(p))1 = (d)>>8; \
- ((uint8_t*)(p))2 = (d)>>16; \
- ((uint8_t*)(p))3 = (d)>>24; \
- } while(0)
-#endif
-
-#ifndef AV_RB64
-# define AV_RB64(x) \
- (((uint64_t)((const uint8_t*)(x))0 << 56) | \
- ((uint64_t)((const uint8_t*)(x))1 << 48) | \
- ((uint64_t)((const uint8_t*)(x))2 << 40) | \
- ((uint64_t)((const uint8_t*)(x))3 << 32) | \
- ((uint64_t)((const uint8_t*)(x))4 << 24) | \
- ((uint64_t)((const uint8_t*)(x))5 << 16) | \
- ((uint64_t)((const uint8_t*)(x))6 << 8) | \
- (uint64_t)((const uint8_t*)(x))7)
-#endif
-#ifndef AV_WB64
-# define AV_WB64(p, val) do { \
- uint64_t d = (val); \
- ((uint8_t*)(p))7 = (d); \
- ((uint8_t*)(p))6 = (d)>>8; \
- ((uint8_t*)(p))5 = (d)>>16; \
- ((uint8_t*)(p))4 = (d)>>24; \
- ((uint8_t*)(p))3 = (d)>>32; \
- ((uint8_t*)(p))2 = (d)>>40; \
- ((uint8_t*)(p))1 = (d)>>48; \
- ((uint8_t*)(p))0 = (d)>>56; \
- } while(0)
-#endif
-
-#ifndef AV_RL64
-# define AV_RL64(x) \
- (((uint64_t)((const uint8_t*)(x))7 << 56) | \
- ((uint64_t)((const uint8_t*)(x))6 << 48) | \
- ((uint64_t)((const uint8_t*)(x))5 << 40) | \
- ((uint64_t)((const uint8_t*)(x))4 << 32) | \
- ((uint64_t)((const uint8_t*)(x))3 << 24) | \
- ((uint64_t)((const uint8_t*)(x))2 << 16) | \
- ((uint64_t)((const uint8_t*)(x))1 << 8) | \
- (uint64_t)((const uint8_t*)(x))0)
-#endif
-#ifndef AV_WL64
-# define AV_WL64(p, val) do { \
- uint64_t d = (val); \
- ((uint8_t*)(p))0 = (d); \
- ((uint8_t*)(p))1 = (d)>>8; \
- ((uint8_t*)(p))2 = (d)>>16; \
- ((uint8_t*)(p))3 = (d)>>24; \
- ((uint8_t*)(p))4 = (d)>>32; \
- ((uint8_t*)(p))5 = (d)>>40; \
- ((uint8_t*)(p))6 = (d)>>48; \
- ((uint8_t*)(p))7 = (d)>>56; \
- } while(0)
-#endif
-
-#if AV_HAVE_BIGENDIAN
-# define AV_RN(s, p) AV_RB##s(p)
-# define AV_WN(s, p, v) AV_WB##s(p, v)
-#else
-# define AV_RN(s, p) AV_RL##s(p)
-# define AV_WN(s, p, v) AV_WL##s(p, v)
-#endif
-
-#endif /* HAVE_FAST_UNALIGNED */
-
-#ifndef AV_RN16
-# define AV_RN16(p) AV_RN(16, p)
-#endif
-
-#ifndef AV_RN32
-# define AV_RN32(p) AV_RN(32, p)
-#endif
-
-#ifndef AV_RN64
-# define AV_RN64(p) AV_RN(64, p)
-#endif
-
-#ifndef AV_WN16
-# define AV_WN16(p, v) AV_WN(16, p, v)
-#endif
-
-#ifndef AV_WN32
-# define AV_WN32(p, v) AV_WN(32, p, v)
-#endif
-
-#ifndef AV_WN64
-# define AV_WN64(p, v) AV_WN(64, p, v)
-#endif
-
-#if AV_HAVE_BIGENDIAN
-# define AV_RB(s, p) AV_RN##s(p)
-# define AV_WB(s, p, v) AV_WN##s(p, v)
-# define AV_RL(s, p) av_bswap##s(AV_RN##s(p))
-# define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v))
-#else
-# define AV_RB(s, p) av_bswap##s(AV_RN##s(p))
-# define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v))
-# define AV_RL(s, p) AV_RN##s(p)
-# define AV_WL(s, p, v) AV_WN##s(p, v)
-#endif
-
-#define AV_RB8(x) (((const uint8_t*)(x))0)
-#define AV_WB8(p, d) do { ((uint8_t*)(p))0 = (d); } while(0)
-
-#define AV_RL8(x) AV_RB8(x)
-#define AV_WL8(p, d) AV_WB8(p, d)
-
-#ifndef AV_RB16
-# define AV_RB16(p) AV_RB(16, p)
-#endif
-#ifndef AV_WB16
-# define AV_WB16(p, v) AV_WB(16, p, v)
-#endif
-
-#ifndef AV_RL16
-# define AV_RL16(p) AV_RL(16, p)
-#endif
-#ifndef AV_WL16
-# define AV_WL16(p, v) AV_WL(16, p, v)
-#endif
-
-#ifndef AV_RB32
-# define AV_RB32(p) AV_RB(32, p)
-#endif
-#ifndef AV_WB32
-# define AV_WB32(p, v) AV_WB(32, p, v)
-#endif
-
-#ifndef AV_RL32
-# define AV_RL32(p) AV_RL(32, p)
-#endif
-#ifndef AV_WL32
-# define AV_WL32(p, v) AV_WL(32, p, v)
-#endif
-
-#ifndef AV_RB64
-# define AV_RB64(p) AV_RB(64, p)
-#endif
-#ifndef AV_WB64
-# define AV_WB64(p, v) AV_WB(64, p, v)
-#endif
-
-#ifndef AV_RL64
-# define AV_RL64(p) AV_RL(64, p)
-#endif
-#ifndef AV_WL64
-# define AV_WL64(p, v) AV_WL(64, p, v)
-#endif
-
-#ifndef AV_RB24
-# define AV_RB24(x) \
- ((((const uint8_t*)(x))0 << 16) | \
- (((const uint8_t*)(x))1 << 8) | \
- ((const uint8_t*)(x))2)
-#endif
-#ifndef AV_WB24
-# define AV_WB24(p, d) do { \
- ((uint8_t*)(p))2 = (d); \
- ((uint8_t*)(p))1 = (d)>>8; \
- ((uint8_t*)(p))0 = (d)>>16; \
- } while(0)
-#endif
-
-#ifndef AV_RL24
-# define AV_RL24(x) \
- ((((const uint8_t*)(x))2 << 16) | \
- (((const uint8_t*)(x))1 << 8) | \
- ((const uint8_t*)(x))0)
-#endif
-#ifndef AV_WL24
-# define AV_WL24(p, d) do { \
- ((uint8_t*)(p))0 = (d); \
- ((uint8_t*)(p))1 = (d)>>8; \
- ((uint8_t*)(p))2 = (d)>>16; \
- } while(0)
-#endif
-
-#ifndef AV_RB48
-# define AV_RB48(x) \
- (((uint64_t)((const uint8_t*)(x))0 << 40) | \
- ((uint64_t)((const uint8_t*)(x))1 << 32) | \
- ((uint64_t)((const uint8_t*)(x))2 << 24) | \
- ((uint64_t)((const uint8_t*)(x))3 << 16) | \
- ((uint64_t)((const uint8_t*)(x))4 << 8) | \
- (uint64_t)((const uint8_t*)(x))5)
-#endif
-#ifndef AV_WB48
-# define AV_WB48(p, darg) do { \
- uint64_t d = (darg); \
- ((uint8_t*)(p))5 = (d); \
- ((uint8_t*)(p))4 = (d)>>8; \
- ((uint8_t*)(p))3 = (d)>>16; \
- ((uint8_t*)(p))2 = (d)>>24; \
- ((uint8_t*)(p))1 = (d)>>32; \
- ((uint8_t*)(p))0 = (d)>>40; \
- } while(0)
-#endif
-
-#ifndef AV_RL48
-# define AV_RL48(x) \
- (((uint64_t)((const uint8_t*)(x))5 << 40) | \
- ((uint64_t)((const uint8_t*)(x))4 << 32) | \
- ((uint64_t)((const uint8_t*)(x))3 << 24) | \
- ((uint64_t)((const uint8_t*)(x))2 << 16) | \
- ((uint64_t)((const uint8_t*)(x))1 << 8) | \
- (uint64_t)((const uint8_t*)(x))0)
-#endif
-#ifndef AV_WL48
-# define AV_WL48(p, darg) do { \
- uint64_t d = (darg); \
- ((uint8_t*)(p))0 = (d); \
- ((uint8_t*)(p))1 = (d)>>8; \
- ((uint8_t*)(p))2 = (d)>>16; \
- ((uint8_t*)(p))3 = (d)>>24; \
- ((uint8_t*)(p))4 = (d)>>32; \
- ((uint8_t*)(p))5 = (d)>>40; \
- } while(0)
-#endif
-
-/*
- * The AV_RWNA macros access naturally aligned data
- * in a type-safe way.
- */
-
-#define AV_RNA(s, p) (((const av_alias##s*)(p))->u##s)
-#define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v))
-
-#ifndef AV_RN16A
-# define AV_RN16A(p) AV_RNA(16, p)
-#endif
-
-#ifndef AV_RN32A
-# define AV_RN32A(p) AV_RNA(32, p)
-#endif
-
-#ifndef AV_RN64A
-# define AV_RN64A(p) AV_RNA(64, p)
-#endif
-
-#ifndef AV_WN16A
-# define AV_WN16A(p, v) AV_WNA(16, p, v)
-#endif
-
-#ifndef AV_WN32A
-# define AV_WN32A(p, v) AV_WNA(32, p, v)
-#endif
-
-#ifndef AV_WN64A
-# define AV_WN64A(p, v) AV_WNA(64, p, v)
-#endif
-
-/*
- * The AV_COPYxxU macros are suitable for copying data to/from unaligned
- * memory locations.
- */
-
-#define AV_COPYU(n, d, s) AV_WN##n(d, AV_RN##n(s));
-
-#ifndef AV_COPY16U
-# define AV_COPY16U(d, s) AV_COPYU(16, d, s)
-#endif
-
-#ifndef AV_COPY32U
-# define AV_COPY32U(d, s) AV_COPYU(32, d, s)
-#endif
-
-#ifndef AV_COPY64U
-# define AV_COPY64U(d, s) AV_COPYU(64, d, s)
-#endif
-
-#ifndef AV_COPY128U
-# define AV_COPY128U(d, s) \
- do { \
- AV_COPY64U(d, s); \
- AV_COPY64U((char *)(d) + 8, (const char *)(s) + 8); \
- } while(0)
-#endif
-
-/* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be
- * naturally aligned. They may be implemented using MMX,
- * so emms_c() must be called before using any float code
- * afterwards.
- */
-
-#define AV_COPY(n, d, s) \
- (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n)
-
-#ifndef AV_COPY16
-# define AV_COPY16(d, s) AV_COPY(16, d, s)
-#endif
-
-#ifndef AV_COPY32
-# define AV_COPY32(d, s) AV_COPY(32, d, s)
-#endif
-
-#ifndef AV_COPY64
-# define AV_COPY64(d, s) AV_COPY(64, d, s)
-#endif
-
-#ifndef AV_COPY128
-# define AV_COPY128(d, s) \
- do { \
- AV_COPY64(d, s); \
- AV_COPY64((char*)(d)+8, (char*)(s)+8); \
- } while(0)
-#endif
-
-#define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b))
-
-#ifndef AV_SWAP64
-# define AV_SWAP64(a, b) AV_SWAP(64, a, b)
-#endif
-
-#define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0)
-
-#ifndef AV_ZERO16
-# define AV_ZERO16(d) AV_ZERO(16, d)
-#endif
-
-#ifndef AV_ZERO32
-# define AV_ZERO32(d) AV_ZERO(32, d)
-#endif
-
-#ifndef AV_ZERO64
-# define AV_ZERO64(d) AV_ZERO(64, d)
-#endif
-
-#ifndef AV_ZERO128
-# define AV_ZERO128(d) \
- do { \
- AV_ZERO64(d); \
- AV_ZERO64((char*)(d)+8); \
- } while(0)
-#endif
-
-#endif /* AVUTIL_INTREADWRITE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/lfg.h Deleted

@@ -1,71 +0,0 @@
-/*
- * Lagged Fibonacci PRNG
- * Copyright (c) 2008 Michael Niedermayer
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_LFG_H
-#define AVUTIL_LFG_H
-
-#include <stdint.h>
-
-typedef struct AVLFG {
- unsigned int state64;
- int index;
-} AVLFG;
-
-void av_lfg_init(AVLFG *c, unsigned int seed);
-
-/**
- * Seed the state of the ALFG using binary data.
- *
- * Return value: 0 on success, negative value (AVERROR) on failure.
- */
-int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length);
-
-/**
- * Get the next random unsigned 32-bit number using an ALFG.
- *
- * Please also consider a simple LCG like state= state*1664525+1013904223,
- * it may be good enough and faster for your specific use case.
- */
-static inline unsigned int av_lfg_get(AVLFG *c){
- c->statec->index & 63 = c->state(c->index-24) & 63 + c->state(c->index-55) & 63;
- return c->statec->index++ & 63;
-}
-
-/**
- * Get the next random unsigned 32-bit number using a MLFG.
- *
- * Please also consider av_lfg_get() above, it is faster.
- */
-static inline unsigned int av_mlfg_get(AVLFG *c){
- unsigned int a= c->state(c->index-55) & 63;
- unsigned int b= c->state(c->index-24) & 63;
- return c->statec->index++ & 63 = 2*a*b+a+b;
-}
-
-/**
- * Get the next two numbers generated by a Box-Muller Gaussian
- * generator using the random numbers issued by lfg.
- *
- * @param out array where the two generated numbers are placed
- */
-void av_bmg_get(AVLFG *lfg, double out2);
-
-#endif /* AVUTIL_LFG_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/log.h Deleted

@@ -1,362 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_LOG_H
-#define AVUTIL_LOG_H
-
-#include <stdarg.h>
-#include "avutil.h"
-#include "attributes.h"
-#include "version.h"
-
-typedef enum {
- AV_CLASS_CATEGORY_NA = 0,
- AV_CLASS_CATEGORY_INPUT,
- AV_CLASS_CATEGORY_OUTPUT,
- AV_CLASS_CATEGORY_MUXER,
- AV_CLASS_CATEGORY_DEMUXER,
- AV_CLASS_CATEGORY_ENCODER,
- AV_CLASS_CATEGORY_DECODER,
- AV_CLASS_CATEGORY_FILTER,
- AV_CLASS_CATEGORY_BITSTREAM_FILTER,
- AV_CLASS_CATEGORY_SWSCALER,
- AV_CLASS_CATEGORY_SWRESAMPLER,
- AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40,
- AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
- AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
- AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT,
- AV_CLASS_CATEGORY_DEVICE_OUTPUT,
- AV_CLASS_CATEGORY_DEVICE_INPUT,
- AV_CLASS_CATEGORY_NB ///< not part of ABI/API
-}AVClassCategory;
-
-#define AV_IS_INPUT_DEVICE(category) \
- (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT) || \
- ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT) || \
- ((category) == AV_CLASS_CATEGORY_DEVICE_INPUT))
-
-#define AV_IS_OUTPUT_DEVICE(category) \
- (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT) || \
- ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT) || \
- ((category) == AV_CLASS_CATEGORY_DEVICE_OUTPUT))
-
-struct AVOptionRanges;
-
-/**
- * Describe the class of an AVClass context structure. That is an
- * arbitrary struct of which the first field is a pointer to an
- * AVClass struct (e.g. AVCodecContext, AVFormatContext etc.).
- */
-typedef struct AVClass {
- /**
- * The name of the class; usually it is the same name as the
- * context structure type to which the AVClass is associated.
- */
- const char* class_name;
-
- /**
- * A pointer to a function which returns the name of a context
- * instance ctx associated with the class.
- */
- const char* (*item_name)(void* ctx);
-
- /**
- * a pointer to the first option specified in the class if any or NULL
- *
- * @see av_set_default_options()
- */
- const struct AVOption *option;
-
- /**
- * LIBAVUTIL_VERSION with which this structure was created.
- * This is used to allow fields to be added without requiring major
- * version bumps everywhere.
- */
-
- int version;
-
- /**
- * Offset in the structure where log_level_offset is stored.
- * 0 means there is no such variable
- */
- int log_level_offset_offset;
-
- /**
- * Offset in the structure where a pointer to the parent context for
- * logging is stored. For example a decoder could pass its AVCodecContext
- * to eval as such a parent context, which an av_log() implementation
- * could then leverage to display the parent context.
- * The offset can be NULL.
- */
- int parent_log_context_offset;
-
- /**
- * Return next AVOptions-enabled child or NULL
- */
- void* (*child_next)(void *obj, void *prev);
-
- /**
- * Return an AVClass corresponding to the next potential
- * AVOptions-enabled child.
- *
- * The difference between child_next and this is that
- * child_next iterates over _already existing_ objects, while
- * child_class_next iterates over _all possible_ children.
- */
- const struct AVClass* (*child_class_next)(const struct AVClass *prev);
-
- /**
- * Category used for visualization (like color)
- * This is only set if the category is equal for all objects using this class.
- * available since version (51 << 16 | 56 << 8 | 100)
- */
- AVClassCategory category;
-
- /**
- * Callback to return the category.
- * available since version (51 << 16 | 59 << 8 | 100)
- */
- AVClassCategory (*get_category)(void* ctx);
-
- /**
- * Callback to return the supported/allowed ranges.
- * available since version (52.12)
- */
- int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
-} AVClass;
-
-/**
- * @addtogroup lavu_log
- *
- * @{
- *
- * @defgroup lavu_log_constants Logging Constants
- *
- * @{
- */
-
-/**
- * Print no output.
- */
-#define AV_LOG_QUIET -8
-
-/**
- * Something went really wrong and we will crash now.
- */
-#define AV_LOG_PANIC 0
-
-/**
- * Something went wrong and recovery is not possible.
- * For example, no header was found for a format which depends
- * on headers or an illegal combination of parameters is used.
- */
-#define AV_LOG_FATAL 8
-
-/**
- * Something went wrong and cannot losslessly be recovered.
- * However, not all future data is affected.
- */
-#define AV_LOG_ERROR 16
-
-/**
- * Something somehow does not look correct. This may or may not
- * lead to problems. An example would be the use of '-vstrict -2'.
- */
-#define AV_LOG_WARNING 24
-
-/**
- * Standard information.
- */
-#define AV_LOG_INFO 32
-
-/**
- * Detailed information.
- */
-#define AV_LOG_VERBOSE 40
-
-/**
- * Stuff which is only useful for libav* developers.
- */
-#define AV_LOG_DEBUG 48
-
-/**
- * Extremely verbose debugging, useful for libav* development.
- */
-#define AV_LOG_TRACE 56
-
-#define AV_LOG_MAX_OFFSET (AV_LOG_TRACE - AV_LOG_QUIET)
-
-/**
- * @}
- */
-
-/**
- * Sets additional colors for extended debugging sessions.
- * @code
- av_log(ctx, AV_LOG_DEBUG|AV_LOG_C(134), "Message in purple\n");
- @endcode
- * Requires 256color terminal support. Uses outside debugging is not
- * recommended.
- */
-#define AV_LOG_C(x) ((x) << 8)
-
-/**
- * Send the specified message to the log if the level is less than or equal
- * to the current av_log_level. By default, all logging messages are sent to
- * stderr. This behavior can be altered by setting a different logging callback
- * function.
- * @see av_log_set_callback
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- * pointer to an AVClass struct or NULL if general log.
- * @param level The importance level of the message expressed using a @ref
- * lavu_log_constants "Logging Constant".
- * @param fmt The format string (printf-compatible) that specifies how
- * subsequent arguments are converted to output.
- */
-void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
-
-
-/**
- * Send the specified message to the log if the level is less than or equal
- * to the current av_log_level. By default, all logging messages are sent to
- * stderr. This behavior can be altered by setting a different logging callback
- * function.
- * @see av_log_set_callback
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- * pointer to an AVClass struct.
- * @param level The importance level of the message expressed using a @ref
- * lavu_log_constants "Logging Constant".
- * @param fmt The format string (printf-compatible) that specifies how
- * subsequent arguments are converted to output.
- * @param vl The arguments referenced by the format string.
- */
-void av_vlog(void *avcl, int level, const char *fmt, va_list vl);
-
-/**
- * Get the current log level
- *
- * @see lavu_log_constants
- *
- * @return Current log level
- */
-int av_log_get_level(void);
-
-/**
- * Set the log level
- *
- * @see lavu_log_constants
- *
- * @param level Logging level
- */
-void av_log_set_level(int level);
-
-/**
- * Set the logging callback
- *
- * @note The callback must be thread safe, even if the application does not use
- * threads itself as some codecs are multithreaded.
- *
- * @see av_log_default_callback
- *
- * @param callback A logging function with a compatible signature.
- */
-void av_log_set_callback(void (*callback)(void*, int, const char*, va_list));
-
-/**
- * Default logging callback
- *
- * It prints the message to stderr, optionally colorizing it.
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- * pointer to an AVClass struct.
- * @param level The importance level of the message expressed using a @ref
- * lavu_log_constants "Logging Constant".
- * @param fmt The format string (printf-compatible) that specifies how
- * subsequent arguments are converted to output.
- * @param vl The arguments referenced by the format string.
- */
-void av_log_default_callback(void *avcl, int level, const char *fmt,
- va_list vl);
-
-/**
- * Return the context name
- *
- * @param ctx The AVClass context
- *
- * @return The AVClass class_name
- */
-const char* av_default_item_name(void* ctx);
-AVClassCategory av_default_get_category(void *ptr);
-
-/**
- * Format a line of log the same way as the default callback.
- * @param line buffer to receive the formatted line
- * @param line_size size of the buffer
- * @param print_prefix used to store whether the prefix must be printed;
- * must point to a persistent integer initially set to 1
- */
-void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
- char *line, int line_size, int *print_prefix);
-
-/**
- * Format a line of log the same way as the default callback.
- * @param line buffer to receive the formatted line;
- * may be NULL if line_size is 0
- * @param line_size size of the buffer; at most line_size-1 characters will
- * be written to the buffer, plus one null terminator
- * @param print_prefix used to store whether the prefix must be printed;
- * must point to a persistent integer initially set to 1
- * @return Returns a negative value if an error occurred, otherwise returns
- * the number of characters that would have been written for a
- * sufficiently large buffer, not including the terminating null
- * character. If the return value is not less than line_size, it means
- * that the log message was truncated to fit the buffer.
- */
-int av_log_format_line2(void *ptr, int level, const char *fmt, va_list vl,
- char *line, int line_size, int *print_prefix);
-
-/**
- * Skip repeated messages, this requires the user app to use av_log() instead of
- * (f)printf as the 2 would otherwise interfere and lead to
- * "Last message repeated x times" messages below (f)printf messages with some
- * bad luck.
- * Also to receive the last, "last repeated" line if any, the user app must
- * call av_log(NULL, AV_LOG_QUIET, "%s", ""); at the end
- */
-#define AV_LOG_SKIP_REPEATED 1
-
-/**
- * Include the log severity in messages originating from codecs.
- *
- * Results in messages such as:
- * rawvideo @ 0xDEADBEEF error encode did not produce valid pts
- */
-#define AV_LOG_PRINT_LEVEL 2
-
-void av_log_set_flags(int arg);
-int av_log_get_flags(void);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_LOG_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/lzo.h Deleted

@@ -1,66 +0,0 @@
-/*
- * LZO 1x decompression
- * copyright (c) 2006 Reimar Doeffinger
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_LZO_H
-#define AVUTIL_LZO_H
-
-/**
- * @defgroup lavu_lzo LZO
- * @ingroup lavu_crypto
- *
- * @{
- */
-
-#include <stdint.h>
-
-/** @name Error flags returned by av_lzo1x_decode
- * @{ */
-/// end of the input buffer reached before decoding finished
-#define AV_LZO_INPUT_DEPLETED 1
-/// decoded data did not fit into output buffer
-#define AV_LZO_OUTPUT_FULL 2
-/// a reference to previously decoded data was wrong
-#define AV_LZO_INVALID_BACKPTR 4
-/// a non-specific error in the compressed bitstream
-#define AV_LZO_ERROR 8
-/** @} */
-
-#define AV_LZO_INPUT_PADDING 8
-#define AV_LZO_OUTPUT_PADDING 12
-
-/**
- * @brief Decodes LZO 1x compressed data.
- * @param out output buffer
- * @param outlen size of output buffer, number of bytes left are returned here
- * @param in input buffer
- * @param inlen size of input buffer, number of bytes left are returned here
- * @return 0 on success, otherwise a combination of the error flags above
- *
- * Make sure all buffers are appropriately padded, in must provide
- * AV_LZO_INPUT_PADDING, out must provide AV_LZO_OUTPUT_PADDING additional bytes.
- */
-int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_LZO_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/macros.h Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/mastering_display_metadata.h Deleted

@@ -1,128 +0,0 @@
-/*
- * Copyright (c) 2016 Neil Birkbeck <neil.birkbeck@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_MASTERING_DISPLAY_METADATA_H
-#define AVUTIL_MASTERING_DISPLAY_METADATA_H
-
-#include "frame.h"
-#include "rational.h"
-
-
-/**
- * Mastering display metadata capable of representing the color volume of
- * the display used to master the content (SMPTE 2086:2014).
- *
- * To be used as payload of a AVFrameSideData or AVPacketSideData with the
- * appropriate type.
- *
- * @note The struct should be allocated with av_mastering_display_metadata_alloc()
- * and its size is not a part of the public ABI.
- */
-typedef struct AVMasteringDisplayMetadata {
- /**
- * CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
- */
- AVRational display_primaries32;
-
- /**
- * CIE 1931 xy chromaticity coords of white point.
- */
- AVRational white_point2;
-
- /**
- * Min luminance of mastering display (cd/m^2).
- */
- AVRational min_luminance;
-
- /**
- * Max luminance of mastering display (cd/m^2).
- */
- AVRational max_luminance;
-
- /**
- * Flag indicating whether the display primaries (and white point) are set.
- */
- int has_primaries;
-
- /**
- * Flag indicating whether the luminance (min_ and max_) have been set.
- */
- int has_luminance;
-
-} AVMasteringDisplayMetadata;
-
-/**
- * Allocate an AVMasteringDisplayMetadata structure and set its fields to
- * default values. The resulting struct can be freed using av_freep().
- *
- * @return An AVMasteringDisplayMetadata filled with default values or NULL
- * on failure.
- */
-AVMasteringDisplayMetadata *av_mastering_display_metadata_alloc(void);
-
-/**
- * Allocate a complete AVMasteringDisplayMetadata and add it to the frame.
- *
- * @param frame The frame which side data is added to.
- *
- * @return The AVMasteringDisplayMetadata structure to be filled by caller.
- */
-AVMasteringDisplayMetadata *av_mastering_display_metadata_create_side_data(AVFrame *frame);
-
-/**
- * Content light level needed by to transmit HDR over HDMI (CTA-861.3).
- *
- * To be used as payload of a AVFrameSideData or AVPacketSideData with the
- * appropriate type.
- *
- * @note The struct should be allocated with av_content_light_metadata_alloc()
- * and its size is not a part of the public ABI.
- */
-typedef struct AVContentLightMetadata {
- /**
- * Max content light level (cd/m^2).
- */
- unsigned MaxCLL;
-
- /**
- * Max average light level per frame (cd/m^2).
- */
- unsigned MaxFALL;
-} AVContentLightMetadata;
-
-/**
- * Allocate an AVContentLightMetadata structure and set its fields to
- * default values. The resulting struct can be freed using av_freep().
- *
- * @return An AVContentLightMetadata filled with default values or NULL
- * on failure.
- */
-AVContentLightMetadata *av_content_light_metadata_alloc(size_t *size);
-
-/**
- * Allocate a complete AVContentLightMetadata and add it to the frame.
- *
- * @param frame The frame which side data is added to.
- *
- * @return The AVContentLightMetadata structure to be filled by caller.
- */
-AVContentLightMetadata *av_content_light_metadata_create_side_data(AVFrame *frame);
-
-#endif /* AVUTIL_MASTERING_DISPLAY_METADATA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/mathematics.h Deleted

@@ -1,242 +0,0 @@
-/*
- * copyright (c) 2005-2012 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @addtogroup lavu_math
- * Mathematical utilities for working with timestamp and time base.
- */
-
-#ifndef AVUTIL_MATHEMATICS_H
-#define AVUTIL_MATHEMATICS_H
-
-#include <stdint.h>
-#include <math.h>
-#include "attributes.h"
-#include "rational.h"
-#include "intfloat.h"
-
-#ifndef M_E
-#define M_E 2.7182818284590452354 /* e */
-#endif
-#ifndef M_LN2
-#define M_LN2 0.69314718055994530942 /* log_e 2 */
-#endif
-#ifndef M_LN10
-#define M_LN10 2.30258509299404568402 /* log_e 10 */
-#endif
-#ifndef M_LOG2_10
-#define M_LOG2_10 3.32192809488736234787 /* log_2 10 */
-#endif
-#ifndef M_PHI
-#define M_PHI 1.61803398874989484820 /* phi / golden ratio */
-#endif
-#ifndef M_PI
-#define M_PI 3.14159265358979323846 /* pi */
-#endif
-#ifndef M_PI_2
-#define M_PI_2 1.57079632679489661923 /* pi/2 */
-#endif
-#ifndef M_SQRT1_2
-#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
-#endif
-#ifndef M_SQRT2
-#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
-#endif
-#ifndef NAN
-#define NAN av_int2float(0x7fc00000)
-#endif
-#ifndef INFINITY
-#define INFINITY av_int2float(0x7f800000)
-#endif
-
-/**
- * @addtogroup lavu_math
- *
- * @{
- */
-
-/**
- * Rounding methods.
- */
-enum AVRounding {
- AV_ROUND_ZERO = 0, ///< Round toward zero.
- AV_ROUND_INF = 1, ///< Round away from zero.
- AV_ROUND_DOWN = 2, ///< Round toward -infinity.
- AV_ROUND_UP = 3, ///< Round toward +infinity.
- AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero.
- /**
- * Flag telling rescaling functions to pass `INT64_MIN`/`MAX` through
- * unchanged, avoiding special cases for #AV_NOPTS_VALUE.
- *
- * Unlike other values of the enumeration AVRounding, this value is a
- * bitmask that must be used in conjunction with another value of the
- * enumeration through a bitwise OR, in order to set behavior for normal
- * cases.
- *
- * @code{.c}
- * av_rescale_rnd(3, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
- * // Rescaling 3:
- * // Calculating 3 * 1 / 2
- * // 3 / 2 is rounded up to 2
- * // => 2
- *
- * av_rescale_rnd(AV_NOPTS_VALUE, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
- * // Rescaling AV_NOPTS_VALUE:
- * // AV_NOPTS_VALUE == INT64_MIN
- * // AV_NOPTS_VALUE is passed through
- * // => AV_NOPTS_VALUE
- * @endcode
- */
- AV_ROUND_PASS_MINMAX = 8192,
-};
-
-/**
- * Compute the greatest common divisor of two integer operands.
- *
- * @param a,b Operands
- * @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0;
- * if a == 0 and b == 0, returns 0.
- */
-int64_t av_const av_gcd(int64_t a, int64_t b);
-
-/**
- * Rescale a 64-bit integer with rounding to nearest.
- *
- * The operation is mathematically equivalent to `a * b / c`, but writing that
- * directly can overflow.
- *
- * This function is equivalent to av_rescale_rnd() with #AV_ROUND_NEAR_INF.
- *
- * @see av_rescale_rnd(), av_rescale_q(), av_rescale_q_rnd()
- */
-int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
-
-/**
- * Rescale a 64-bit integer with specified rounding.
- *
- * The operation is mathematically equivalent to `a * b / c`, but writing that
- * directly can overflow, and does not support different rounding methods.
- *
- * @see av_rescale(), av_rescale_q(), av_rescale_q_rnd()
- */
-int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const;
-
-/**
- * Rescale a 64-bit integer by 2 rational numbers.
- *
- * The operation is mathematically equivalent to `a * bq / cq`.
- *
- * This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF.
- *
- * @see av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()
- */
-int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
-
-/**
- * Rescale a 64-bit integer by 2 rational numbers with specified rounding.
- *
- * The operation is mathematically equivalent to `a * bq / cq`.
- *
- * @see av_rescale(), av_rescale_rnd(), av_rescale_q()
- */
-int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
- enum AVRounding rnd) av_const;
-
-/**
- * Compare two timestamps each in its own time base.
- *
- * @return One of the following values:
- * - -1 if `ts_a` is before `ts_b`
- * - 1 if `ts_a` is after `ts_b`
- * - 0 if they represent the same position
- *
- * @warning
- * The result of the function is undefined if one of the timestamps is outside
- * the `int64_t` range when represented in the other's timebase.
- */
-int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
-
-/**
- * Compare the remainders of two integer operands divided by a common divisor.
- *
- * In other words, compare the least significant `log2(mod)` bits of integers
- * `a` and `b`.
- *
- * @code{.c}
- * av_compare_mod(0x11, 0x02, 0x10) < 0 // since 0x11 % 0x10 (0x1) < 0x02 % 0x10 (0x2)
- * av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)
- * @endcode
- *
- * @param a,b Operands
- * @param mod Divisor; must be a power of 2
- * @return
- * - a negative value if `a % mod b % mod`
- * - zero if `a % mod == b % mod`
- */
-int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
-
-/**
- * Rescale a timestamp while preserving known durations.
- *
- * This function is designed to be called per audio packet to scale the input
- * timestamp to a different time base. Compared to a simple av_rescale_q()
- * call, this function is robust against possible inconsistent frame durations.
- *
- * The `last` parameter is a state variable that must be preserved for all
- * subsequent calls for the same stream. For the first call, `*last` should be
- * initialized to #AV_NOPTS_VALUE.
- *
- * @paramin in_tb Input time base
- * @paramin in_ts Input timestamp
- * @paramin fs_tb Duration time base; typically this is finer-grained
- * (greater) than `in_tb` and `out_tb`
- * @paramin duration Duration till the next call to this function (i.e.
- * duration of the current packet/frame)
- * @paramin,out last Pointer to a timestamp expressed in terms of
- * `fs_tb`, acting as a state variable
- * @paramin out_tb Output timebase
- * @return Timestamp expressed in terms of `out_tb`
- *
- * @note In the context of this function, "duration" is in term of samples, not
- * seconds.
- */
-int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb);
-
-/**
- * Add a value to a timestamp.
- *
- * This function guarantees that when the same value is repeatly added that
- * no accumulation of rounding errors occurs.
- *
- * @paramin ts Input timestamp
- * @paramin ts_tb Input timestamp time base
- * @paramin inc Value to be added
- * @paramin inc_tb Time base of `inc`
- */
-int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);
-
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_MATHEMATICS_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/md5.h Deleted

@@ -1,98 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_md5
- * Public header for MD5 hash function implementation.
- */
-
-#ifndef AVUTIL_MD5_H
-#define AVUTIL_MD5_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_md5 MD5
- * @ingroup lavu_hash
- * MD5 hash function implementation.
- *
- * @{
- */
-
-extern const int av_md5_size;
-
-struct AVMD5;
-
-/**
- * Allocate an AVMD5 context.
- */
-struct AVMD5 *av_md5_alloc(void);
-
-/**
- * Initialize MD5 hashing.
- *
- * @param ctx pointer to the function context (of size av_md5_size)
- */
-void av_md5_init(struct AVMD5 *ctx);
-
-/**
- * Update hash value.
- *
- * @param ctx hash function context
- * @param src input data to update hash with
- * @param len input data length
- */
-#if FF_API_CRYPTO_SIZE_T
-void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len);
-#else
-void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, size_t len);
-#endif
-
-/**
- * Finish hashing and output digest value.
- *
- * @param ctx hash function context
- * @param dst buffer where output digest value is stored
- */
-void av_md5_final(struct AVMD5 *ctx, uint8_t *dst);
-
-/**
- * Hash an array of data.
- *
- * @param dst The output buffer to write the digest into
- * @param src The data to hash
- * @param len The length of the data, in bytes
- */
-#if FF_API_CRYPTO_SIZE_T
-void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len);
-#else
-void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len);
-#endif
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_MD5_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/mem.h Deleted

@@ -1,700 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_mem
- * Memory handling functions
- */
-
-#ifndef AVUTIL_MEM_H
-#define AVUTIL_MEM_H
-
-#include <limits.h>
-#include <stdint.h>
-
-#include "attributes.h"
-#include "error.h"
-#include "avutil.h"
-
-/**
- * @addtogroup lavu_mem
- * Utilities for manipulating memory.
- *
- * FFmpeg has several applications of memory that are not required of a typical
- * program. For example, the computing-heavy components like video decoding and
- * encoding can be sped up significantly through the use of aligned memory.
- *
- * However, for each of FFmpeg's applications of memory, there might not be a
- * recognized or standardized API for that specific use. Memory alignment, for
- * instance, varies wildly depending on operating systems, architectures, and
- * compilers. Hence, this component of @ref libavutil is created to make
- * dealing with memory consistently possible on all platforms.
- *
- * @{
- *
- * @defgroup lavu_mem_macros Alignment Macros
- * Helper macros for declaring aligned variables.
- * @{
- */
-
-/**
- * @def DECLARE_ALIGNED(n,t,v)
- * Declare a variable that is aligned in memory.
- *
- * @code{.c}
- * DECLARE_ALIGNED(16, uint16_t, aligned_int) = 42;
- * DECLARE_ALIGNED(32, uint8_t, aligned_array)128;
- *
- * // The default-alignment equivalent would be
- * uint16_t aligned_int = 42;
- * uint8_t aligned_array128;
- * @endcode
- *
- * @param n Minimum alignment in bytes
- * @param t Type of the variable (or array element)
- * @param v Name of the variable
- */
-
-/**
- * @def DECLARE_ASM_ALIGNED(n,t,v)
- * Declare an aligned variable appropriate for use in inline assembly code.
- *
- * @code{.c}
- * DECLARE_ASM_ALIGNED(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008);
- * @endcode
- *
- * @param n Minimum alignment in bytes
- * @param t Type of the variable (or array element)
- * @param v Name of the variable
- */
-
-/**
- * @def DECLARE_ASM_CONST(n,t,v)
- * Declare a static constant aligned variable appropriate for use in inline
- * assembly code.
- *
- * @code{.c}
- * DECLARE_ASM_CONST(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008);
- * @endcode
- *
- * @param n Minimum alignment in bytes
- * @param t Type of the variable (or array element)
- * @param v Name of the variable
- */
-
-#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
- #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
- #define DECLARE_ASM_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
- #define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v
-#elif defined(__DJGPP__)
- #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (FFMIN(n, 16)))) v
- #define DECLARE_ASM_ALIGNED(n,t,v) t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v
- #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v
-#elif defined(__GNUC__) || defined(__clang__)
- #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v
- #define DECLARE_ASM_ALIGNED(n,t,v) t av_used __attribute__ ((aligned (n))) v
- #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v
-#elif defined(_MSC_VER)
- #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v
- #define DECLARE_ASM_ALIGNED(n,t,v) __declspec(align(n)) t v
- #define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v
-#else
- #define DECLARE_ALIGNED(n,t,v) t v
- #define DECLARE_ASM_ALIGNED(n,t,v) t v
- #define DECLARE_ASM_CONST(n,t,v) static const t v
-#endif
-
-/**
- * @}
- */
-
-/**
- * @defgroup lavu_mem_attrs Function Attributes
- * Function attributes applicable to memory handling functions.
- *
- * These function attributes can help compilers emit more useful warnings, or
- * generate better code.
- * @{
- */
-
-/**
- * @def av_malloc_attrib
- * Function attribute denoting a malloc-like function.
- *
- * @see <a href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-g_t_0040code_007bmalloc_007d-function-attribute-3251">Function attribute `malloc` in GCC's documentation</a>
- */
-
-#if AV_GCC_VERSION_AT_LEAST(3,1)
- #define av_malloc_attrib __attribute__((__malloc__))
-#else
- #define av_malloc_attrib
-#endif
-
-/**
- * @def av_alloc_size(...)
- * Function attribute used on a function that allocates memory, whose size is
- * given by the specified parameter(s).
- *
- * @code{.c}
- * void *av_malloc(size_t size) av_alloc_size(1);
- * void *av_calloc(size_t nmemb, size_t size) av_alloc_size(1, 2);
- * @endcode
- *
- * @param ... One or two parameter indexes, separated by a comma
- *
- * @see <a href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-g_t_0040code_007balloc_005fsize_007d-function-attribute-3220">Function attribute `alloc_size` in GCC's documentation</a>
- */
-
-#if AV_GCC_VERSION_AT_LEAST(4,3)
- #define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
-#else
- #define av_alloc_size(...)
-#endif
-
-/**
- * @}
- */
-
-/**
- * @defgroup lavu_mem_funcs Heap Management
- * Functions responsible for allocating, freeing, and copying memory.
- *
- * All memory allocation functions have a built-in upper limit of `INT_MAX`
- * bytes. This may be changed with av_max_alloc(), although exercise extreme
- * caution when doing so.
- *
- * @{
- */
-
-/**
- * Allocate a memory block with alignment suitable for all memory accesses
- * (including vectors if available on the CPU).
- *
- * @param size Size in bytes for the memory block to be allocated
- * @return Pointer to the allocated block, or `NULL` if the block cannot
- * be allocated
- * @see av_mallocz()
- */
-void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
-
-/**
- * Allocate a memory block with alignment suitable for all memory accesses
- * (including vectors if available on the CPU) and zero all the bytes of the
- * block.
- *
- * @param size Size in bytes for the memory block to be allocated
- * @return Pointer to the allocated block, or `NULL` if it cannot be allocated
- * @see av_malloc()
- */
-void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
-
-/**
- * Allocate a memory block for an array with av_malloc().
- *
- * The allocated memory will have size `size * nmemb` bytes.
- *
- * @param nmemb Number of element
- * @param size Size of a single element
- * @return Pointer to the allocated block, or `NULL` if the block cannot
- * be allocated
- * @see av_malloc()
- */
-av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size);
-
-/**
- * Allocate a memory block for an array with av_mallocz().
- *
- * The allocated memory will have size `size * nmemb` bytes.
- *
- * @param nmemb Number of elements
- * @param size Size of the single element
- * @return Pointer to the allocated block, or `NULL` if the block cannot
- * be allocated
- *
- * @see av_mallocz()
- * @see av_malloc_array()
- */
-av_alloc_size(1, 2) void *av_mallocz_array(size_t nmemb, size_t size);
-
-/**
- * Non-inlined equivalent of av_mallocz_array().
- *
- * Created for symmetry with the calloc() C function.
- */
-void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
-
-/**
- * Allocate, reallocate, or free a block of memory.
- *
- * If `ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is
- * zero, free the memory block pointed to by `ptr`. Otherwise, expand or
- * shrink that block of memory according to `size`.
- *
- * @param ptr Pointer to a memory block already allocated with
- * av_realloc() or `NULL`
- * @param size Size in bytes of the memory block to be allocated or
- * reallocated
- *
- * @return Pointer to a newly-reallocated block or `NULL` if the block
- * cannot be reallocated or the function is used to free the memory block
- *
- * @warning Unlike av_malloc(), the returned pointer is not guaranteed to be
- * correctly aligned.
- * @see av_fast_realloc()
- * @see av_reallocp()
- */
-void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
-
-/**
- * Allocate, reallocate, or free a block of memory through a pointer to a
- * pointer.
- *
- * If `*ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is
- * zero, free the memory block pointed to by `*ptr`. Otherwise, expand or
- * shrink that block of memory according to `size`.
- *
- * @paramin,out ptr Pointer to a pointer to a memory block already allocated
- * with av_realloc(), or a pointer to `NULL`. The pointer
- * is updated on success, or freed on failure.
- * @paramin size Size in bytes for the memory block to be allocated or
- * reallocated
- *
- * @return Zero on success, an AVERROR error code on failure
- *
- * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
- * correctly aligned.
- */
-av_warn_unused_result
-int av_reallocp(void *ptr, size_t size);
-
-/**
- * Allocate, reallocate, or free a block of memory.
- *
- * This function does the same thing as av_realloc(), except:
- * - It takes two size arguments and allocates `nelem * elsize` bytes,
- * after checking the result of the multiplication for integer overflow.
- * - It frees the input block in case of failure, thus avoiding the memory
- * leak with the classic
- * @code{.c}
- * buf = realloc(buf);
- * if (!buf)
- * return -1;
- * @endcode
- * pattern.
- */
-void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
-
-/**
- * Allocate, reallocate, or free an array.
- *
- * If `ptr` is `NULL` and `nmemb` > 0, allocate a new block. If
- * `nmemb` is zero, free the memory block pointed to by `ptr`.
- *
- * @param ptr Pointer to a memory block already allocated with
- * av_realloc() or `NULL`
- * @param nmemb Number of elements in the array
- * @param size Size of the single element of the array
- *
- * @return Pointer to a newly-reallocated block or NULL if the block
- * cannot be reallocated or the function is used to free the memory block
- *
- * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
- * correctly aligned.
- * @see av_reallocp_array()
- */
-av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
-
-/**
- * Allocate, reallocate, or free an array through a pointer to a pointer.
- *
- * If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block. If `nmemb` is
- * zero, free the memory block pointed to by `*ptr`.
- *
- * @paramin,out ptr Pointer to a pointer to a memory block already
- * allocated with av_realloc(), or a pointer to `NULL`.
- * The pointer is updated on success, or freed on failure.
- * @paramin nmemb Number of elements
- * @paramin size Size of the single element
- *
- * @return Zero on success, an AVERROR error code on failure
- *
- * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
- * correctly aligned.
- */
-av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
-
-/**
- * Reallocate the given buffer if it is not large enough, otherwise do nothing.
- *
- * If the given buffer is `NULL`, then a new uninitialized buffer is allocated.
- *
- * If the given buffer is not large enough, and reallocation fails, `NULL` is
- * returned and `*size` is set to 0, but the original buffer is not changed or
- * freed.
- *
- * A typical use pattern follows:
- *
- * @code{.c}
- * uint8_t *buf = ...;
- * uint8_t *new_buf = av_fast_realloc(buf, &current_size, size_needed);
- * if (!new_buf) {
- * // Allocation failed; clean up original buffer
- * av_freep(&buf);
- * return AVERROR(ENOMEM);
- * }
- * @endcode
- *
- * @paramin,out ptr Already allocated buffer, or `NULL`
- * @paramin,out size Pointer to current size of buffer `ptr`. `*size` is
- * changed to `min_size` in case of success or 0 in
- * case of failure
- * @paramin min_size New size of buffer `ptr`
- * @return `ptr` if the buffer is large enough, a pointer to newly reallocated
- * buffer if the buffer was not large enough, or `NULL` in case of
- * error
- * @see av_realloc()
- * @see av_fast_malloc()
- */
-void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
-
-/**
- * Allocate a buffer, reusing the given one if large enough.
- *
- * Contrary to av_fast_realloc(), the current buffer contents might not be
- * preserved and on error the old buffer is freed, thus no special handling to
- * avoid memleaks is necessary.
- *
- * `*ptr` is allowed to be `NULL`, in which case allocation always happens if
- * `size_needed` is greater than 0.
- *
- * @code{.c}
- * uint8_t *buf = ...;
- * av_fast_malloc(&buf, &current_size, size_needed);
- * if (!buf) {
- * // Allocation failed; buf already freed
- * return AVERROR(ENOMEM);
- * }
- * @endcode
- *
- * @paramin,out ptr Pointer to pointer to an already allocated buffer.
- * `*ptr` will be overwritten with pointer to new
- * buffer on success or `NULL` on failure
- * @paramin,out size Pointer to current size of buffer `*ptr`. `*size` is
- * changed to `min_size` in case of success or 0 in
- * case of failure
- * @paramin min_size New size of buffer `*ptr`
- * @see av_realloc()
- * @see av_fast_mallocz()
- */
-void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
-
-/**
- * Allocate and clear a buffer, reusing the given one if large enough.
- *
- * Like av_fast_malloc(), but all newly allocated space is initially cleared.
- * Reused buffer is not cleared.
- *
- * `*ptr` is allowed to be `NULL`, in which case allocation always happens if
- * `size_needed` is greater than 0.
- *
- * @paramin,out ptr Pointer to pointer to an already allocated buffer.
- * `*ptr` will be overwritten with pointer to new
- * buffer on success or `NULL` on failure
- * @paramin,out size Pointer to current size of buffer `*ptr`. `*size` is
- * changed to `min_size` in case of success or 0 in
- * case of failure
- * @paramin min_size New size of buffer `*ptr`
- * @see av_fast_malloc()
- */
-void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size);
-
-/**
- * Free a memory block which has been allocated with a function of av_malloc()
- * or av_realloc() family.
- *
- * @param ptr Pointer to the memory block which should be freed.
- *
- * @note `ptr = NULL` is explicitly allowed.
- * @note It is recommended that you use av_freep() instead, to prevent leaving
- * behind dangling pointers.
- * @see av_freep()
- */
-void av_free(void *ptr);
-
-/**
- * Free a memory block which has been allocated with a function of av_malloc()
- * or av_realloc() family, and set the pointer pointing to it to `NULL`.
- *
- * @code{.c}
- * uint8_t *buf = av_malloc(16);
- * av_free(buf);
- * // buf now contains a dangling pointer to freed memory, and accidental
- * // dereference of buf will result in a use-after-free, which may be a
- * // security risk.
- *
- * uint8_t *buf = av_malloc(16);
- * av_freep(&buf);
- * // buf is now NULL, and accidental dereference will only result in a
- * // NULL-pointer dereference.
- * @endcode
- *
- * @param ptr Pointer to the pointer to the memory block which should be freed
- * @note `*ptr = NULL` is safe and leads to no action.
- * @see av_free()
- */
-void av_freep(void *ptr);
-
-/**
- * Duplicate a string.
- *
- * @param s String to be duplicated
- * @return Pointer to a newly-allocated string containing a
- * copy of `s` or `NULL` if the string cannot be allocated
- * @see av_strndup()
- */
-char *av_strdup(const char *s) av_malloc_attrib;
-
-/**
- * Duplicate a substring of a string.
- *
- * @param s String to be duplicated
- * @param len Maximum length of the resulting string (not counting the
- * terminating byte)
- * @return Pointer to a newly-allocated string containing a
- * substring of `s` or `NULL` if the string cannot be allocated
- */
-char *av_strndup(const char *s, size_t len) av_malloc_attrib;
-
-/**
- * Duplicate a buffer with av_malloc().
- *
- * @param p Buffer to be duplicated
- * @param size Size in bytes of the buffer copied
- * @return Pointer to a newly allocated buffer containing a
- * copy of `p` or `NULL` if the buffer cannot be allocated
- */
-void *av_memdup(const void *p, size_t size);
-
-/**
- * Overlapping memcpy() implementation.
- *
- * @param dst Destination buffer
- * @param back Number of bytes back to start copying (i.e. the initial size of
- * the overlapping window); must be > 0
- * @param cnt Number of bytes to copy; must be >= 0
- *
- * @note `cnt > back` is valid, this will copy the bytes we just copied,
- * thus creating a repeating pattern with a period length of `back`.
- */
-void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
-
-/**
- * @}
- */
-
-/**
- * @defgroup lavu_mem_dynarray Dynamic Array
- *
- * Utilities to make an array grow when needed.
- *
- * Sometimes, the programmer would want to have an array that can grow when
- * needed. The libavutil dynamic array utilities fill that need.
- *
- * libavutil supports two systems of appending elements onto a dynamically
- * allocated array, the first one storing the pointer to the value in the
- * array, and the second storing the value directly. In both systems, the
- * caller is responsible for maintaining a variable containing the length of
- * the array, as well as freeing of the array after use.
- *
- * The first system stores pointers to values in a block of dynamically
- * allocated memory. Since only pointers are stored, the function does not need
- * to know the size of the type. Both av_dynarray_add() and
- * av_dynarray_add_nofree() implement this system.
- *
- * @code
- * type **array = NULL; //< an array of pointers to values
- * int nb = 0; //< a variable to keep track of the length of the array
- *
- * type to_be_added = ...;
- * type to_be_added2 = ...;
- *
- * av_dynarray_add(&array, &nb, &to_be_added);
- * if (nb == 0)
- * return AVERROR(ENOMEM);
- *
- * av_dynarray_add(&array, &nb, &to_be_added2);
- * if (nb == 0)
- * return AVERROR(ENOMEM);
- *
- * // Now:
- * // nb == 2
- * // &to_be_added == array0
- * // &to_be_added2 == array1
- *
- * av_freep(&array);
- * @endcode
- *
- * The second system stores the value directly in a block of memory. As a
- * result, the function has to know the size of the type. av_dynarray2_add()
- * implements this mechanism.
- *
- * @code
- * type *array = NULL; //< an array of values
- * int nb = 0; //< a variable to keep track of the length of the array
- *
- * type to_be_added = ...;
- * type to_be_added2 = ...;
- *
- * type *addr = av_dynarray2_add((void **)&array, &nb, sizeof(*array), NULL);
- * if (!addr)
- * return AVERROR(ENOMEM);
- * memcpy(addr, &to_be_added, sizeof(to_be_added));
- *
- * // Shortcut of the above.
- * type *addr = av_dynarray2_add((void **)&array, &nb, sizeof(*array),
- * (const void *)&to_be_added2);
- * if (!addr)
- * return AVERROR(ENOMEM);
- *
- * // Now:
- * // nb == 2
- * // to_be_added == array0
- * // to_be_added2 == array1
- *
- * av_freep(&array);
- * @endcode
- *
- * @{
- */
-
-/**
- * Add the pointer to an element to a dynamic array.
- *
- * The array to grow is supposed to be an array of pointers to
- * structures, and the element to add must be a pointer to an already
- * allocated structure.
- *
- * The array is reallocated when its size reaches powers of 2.
- * Therefore, the amortized cost of adding an element is constant.
- *
- * In case of success, the pointer to the array is updated in order to
- * point to the new grown array, and the number pointed to by `nb_ptr`
- * is incremented.
- * In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and
- * `*nb_ptr` is set to 0.
- *
- * @paramin,out tab_ptr Pointer to the array to grow
- * @paramin,out nb_ptr Pointer to the number of elements in the array
- * @paramin elem Element to add
- * @see av_dynarray_add_nofree(), av_dynarray2_add()
- */
-void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
-
-/**
- * Add an element to a dynamic array.
- *
- * Function has the same functionality as av_dynarray_add(),
- * but it doesn't free memory on fails. It returns error code
- * instead and leave current buffer untouched.
- *
- * @return >=0 on success, negative otherwise
- * @see av_dynarray_add(), av_dynarray2_add()
- */
-av_warn_unused_result
-int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem);
-
-/**
- * Add an element of size `elem_size` to a dynamic array.
- *
- * The array is reallocated when its number of elements reaches powers of 2.
- * Therefore, the amortized cost of adding an element is constant.
- *
- * In case of success, the pointer to the array is updated in order to
- * point to the new grown array, and the number pointed to by `nb_ptr`
- * is incremented.
- * In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and
- * `*nb_ptr` is set to 0.
- *
- * @paramin,out tab_ptr Pointer to the array to grow
- * @paramin,out nb_ptr Pointer to the number of elements in the array
- * @paramin elem_size Size in bytes of an element in the array
- * @paramin elem_data Pointer to the data of the element to add. If
- * `NULL`, the space of the newly added element is
- * allocated but left uninitialized.
- *
- * @return Pointer to the data of the element to copy in the newly allocated
- * space
- * @see av_dynarray_add(), av_dynarray_add_nofree()
- */
-void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
- const uint8_t *elem_data);
-
-/**
- * @}
- */
-
-/**
- * @defgroup lavu_mem_misc Miscellaneous Functions
- *
- * Other functions related to memory allocation.
- *
- * @{
- */
-
-/**
- * Multiply two `size_t` values checking for overflow.
- *
- * @paramin a,b Operands of multiplication
- * @paramout r Pointer to the result of the operation
- * @return 0 on success, AVERROR(EINVAL) on overflow
- */
-static inline int av_size_mult(size_t a, size_t b, size_t *r)
-{
- size_t t = a * b;
- /* Hack inspired from glibc: don't try the division if nelem and elsize
- * are both less than sqrt(SIZE_MAX). */
- if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
- return AVERROR(EINVAL);
- *r = t;
- return 0;
-}
-
-/**
- * Set the maximum size that may be allocated in one block.
- *
- * The value specified with this function is effective for all libavutil's @ref
- * lavu_mem_funcs "heap management functions."
- *
- * By default, the max value is defined as `INT_MAX`.
- *
- * @param max Value to be set as the new maximum size
- *
- * @warning Exercise extreme caution when using this function. Don't touch
- * this if you do not understand the full consequence of doing so.
- */
-void av_max_alloc(size_t max);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_MEM_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/motion_vector.h Deleted

@@ -1,57 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_MOTION_VECTOR_H
-#define AVUTIL_MOTION_VECTOR_H
-
-#include <stdint.h>
-
-typedef struct AVMotionVector {
- /**
- * Where the current macroblock comes from; negative value when it comes
- * from the past, positive value when it comes from the future.
- * XXX: set exact relative ref frame reference instead of a +/- 1 "direction".
- */
- int32_t source;
- /**
- * Width and height of the block.
- */
- uint8_t w, h;
- /**
- * Absolute source position. Can be outside the frame area.
- */
- int16_t src_x, src_y;
- /**
- * Absolute destination position. Can be outside the frame area.
- */
- int16_t dst_x, dst_y;
- /**
- * Extra flag information.
- * Currently unused.
- */
- uint64_t flags;
- /**
- * Motion vector
- * src_x = dst_x + motion_x / motion_scale
- * src_y = dst_y + motion_y / motion_scale
- */
- int32_t motion_x, motion_y;
- uint16_t motion_scale;
-} AVMotionVector;
-
-#endif /* AVUTIL_MOTION_VECTOR_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/murmur3.h Deleted

@@ -1,120 +0,0 @@
-/*
- * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_murmur3
- * Public header for MurmurHash3 hash function implementation.
- */
-
-#ifndef AVUTIL_MURMUR3_H
-#define AVUTIL_MURMUR3_H
-
-#include <stdint.h>
-
-#include "version.h"
-
-/**
- * @defgroup lavu_murmur3 Murmur3
- * @ingroup lavu_hash
- * MurmurHash3 hash function implementation.
- *
- * MurmurHash3 is a non-cryptographic hash function, of which three
- * incompatible versions were created by its inventor Austin Appleby:
- *
- * - 32-bit output
- * - 128-bit output for 32-bit platforms
- * - 128-bit output for 64-bit platforms
- *
- * FFmpeg only implements the last variant: 128-bit output designed for 64-bit
- * platforms. Even though the hash function was designed for 64-bit platforms,
- * the function in reality works on 32-bit systems too, only with reduced
- * performance.
- *
- * @anchor lavu_murmur3_seedinfo
- * By design, MurmurHash3 requires a seed to operate. In response to this,
- * libavutil provides two functions for hash initiation, one that requires a
- * seed (av_murmur3_init_seeded()) and one that uses a fixed arbitrary integer
- * as the seed, and therefore does not (av_murmur3_init()).
- *
- * To make hashes comparable, you should provide the same seed for all calls to
- * this hash function -- if you are supplying one yourself, that is.
- *
- * @{
- */
-
-/**
- * Allocate an AVMurMur3 hash context.
- *
- * @return Uninitialized hash context or `NULL` in case of error
- */
-struct AVMurMur3 *av_murmur3_alloc(void);
-
-/**
- * Initialize or reinitialize an AVMurMur3 hash context with a seed.
- *
- * @paramout c Hash context
- * @paramin seed Random seed
- *
- * @see av_murmur3_init()
- * @see @ref lavu_murmur3_seedinfo "Detailed description" on a discussion of
- * seeds for MurmurHash3.
- */
-void av_murmur3_init_seeded(struct AVMurMur3 *c, uint64_t seed);
-
-/**
- * Initialize or reinitialize an AVMurMur3 hash context.
- *
- * Equivalent to av_murmur3_init_seeded() with a built-in seed.
- *
- * @paramout c Hash context
- *
- * @see av_murmur3_init_seeded()
- * @see @ref lavu_murmur3_seedinfo "Detailed description" on a discussion of
- * seeds for MurmurHash3.
- */
-void av_murmur3_init(struct AVMurMur3 *c);
-
-/**
- * Update hash context with new data.
- *
- * @paramout c Hash context
- * @paramin src Input data to update hash with
- * @paramin len Number of bytes to read from `src`
- */
-#if FF_API_CRYPTO_SIZE_T
-void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len);
-#else
-void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, size_t len);
-#endif
-
-/**
- * Finish hashing and output digest value.
- *
- * @paramin,out c Hash context
- * @paramout dst Buffer where output digest value is stored
- */
-void av_murmur3_final(struct AVMurMur3 *c, uint8_t dst16);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_MURMUR3_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/opt.h Deleted

@@ -1,864 +0,0 @@
-/*
- * AVOptions
- * copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_OPT_H
-#define AVUTIL_OPT_H
-
-/**
- * @file
- * AVOptions
- */
-
-#include "rational.h"
-#include "avutil.h"
-#include "dict.h"
-#include "log.h"
-#include "pixfmt.h"
-#include "samplefmt.h"
-#include "version.h"
-
-/**
- * @defgroup avoptions AVOptions
- * @ingroup lavu_data
- * @{
- * AVOptions provide a generic system to declare options on arbitrary structs
- * ("objects"). An option can have a help text, a type and a range of possible
- * values. Options may then be enumerated, read and written to.
- *
- * @section avoptions_implement Implementing AVOptions
- * This section describes how to add AVOptions capabilities to a struct.
- *
- * All AVOptions-related information is stored in an AVClass. Therefore
- * the first member of the struct should be a pointer to an AVClass describing it.
- * The option field of the AVClass must be set to a NULL-terminated static array
- * of AVOptions. Each AVOption must have a non-empty name, a type, a default
- * value and for number-type AVOptions also a range of allowed values. It must
- * also declare an offset in bytes from the start of the struct, where the field
- * associated with this AVOption is located. Other fields in the AVOption struct
- * should also be set when applicable, but are not required.
- *
- * The following example illustrates an AVOptions-enabled struct:
- * @code
- * typedef struct test_struct {
- * const AVClass *class;
- * int int_opt;
- * char *str_opt;
- * uint8_t *bin_opt;
- * int bin_len;
- * } test_struct;
- *
- * static const AVOption test_options = {
- * { "test_int", "This is a test option of int type.", offsetof(test_struct, int_opt),
- * AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX },
- * { "test_str", "This is a test option of string type.", offsetof(test_struct, str_opt),
- * AV_OPT_TYPE_STRING },
- * { "test_bin", "This is a test option of binary type.", offsetof(test_struct, bin_opt),
- * AV_OPT_TYPE_BINARY },
- * { NULL },
- * };
- *
- * static const AVClass test_class = {
- * .class_name = "test class",
- * .item_name = av_default_item_name,
- * .option = test_options,
- * .version = LIBAVUTIL_VERSION_INT,
- * };
- * @endcode
- *
- * Next, when allocating your struct, you must ensure that the AVClass pointer
- * is set to the correct value. Then, av_opt_set_defaults() can be called to
- * initialize defaults. After that the struct is ready to be used with the
- * AVOptions API.
- *
- * When cleaning up, you may use the av_opt_free() function to automatically
- * free all the allocated string and binary options.
- *
- * Continuing with the above example:
- *
- * @code
- * test_struct *alloc_test_struct(void)
- * {
- * test_struct *ret = av_mallocz(sizeof(*ret));
- * ret->class = &test_class;
- * av_opt_set_defaults(ret);
- * return ret;
- * }
- * void free_test_struct(test_struct **foo)
- * {
- * av_opt_free(*foo);
- * av_freep(foo);
- * }
- * @endcode
- *
- * @subsection avoptions_implement_nesting Nesting
- * It may happen that an AVOptions-enabled struct contains another
- * AVOptions-enabled struct as a member (e.g. AVCodecContext in
- * libavcodec exports generic options, while its priv_data field exports
- * codec-specific options). In such a case, it is possible to set up the
- * parent struct to export a child's options. To do that, simply
- * implement AVClass.child_next() and AVClass.child_class_next() in the
- * parent struct's AVClass.
- * Assuming that the test_struct from above now also contains a
- * child_struct field:
- *
- * @code
- * typedef struct child_struct {
- * AVClass *class;
- * int flags_opt;
- * } child_struct;
- * static const AVOption child_opts = {
- * { "test_flags", "This is a test option of flags type.",
- * offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX },
- * { NULL },
- * };
- * static const AVClass child_class = {
- * .class_name = "child class",
- * .item_name = av_default_item_name,
- * .option = child_opts,
- * .version = LIBAVUTIL_VERSION_INT,
- * };
- *
- * void *child_next(void *obj, void *prev)
- * {
- * test_struct *t = obj;
- * if (!prev && t->child_struct)
- * return t->child_struct;
- * return NULL
- * }
- * const AVClass child_class_next(const AVClass *prev)
- * {
- * return prev ? NULL : &child_class;
- * }
- * @endcode
- * Putting child_next() and child_class_next() as defined above into
- * test_class will now make child_struct's options accessible through
- * test_struct (again, proper setup as described above needs to be done on
- * child_struct right after it is created).
- *
- * From the above example it might not be clear why both child_next()
- * and child_class_next() are needed. The distinction is that child_next()
- * iterates over actually existing objects, while child_class_next()
- * iterates over all possible child classes. E.g. if an AVCodecContext
- * was initialized to use a codec which has private options, then its
- * child_next() will return AVCodecContext.priv_data and finish
- * iterating. OTOH child_class_next() on AVCodecContext.av_class will
- * iterate over all available codecs with private options.
- *
- * @subsection avoptions_implement_named_constants Named constants
- * It is possible to create named constants for options. Simply set the unit
- * field of the option the constants should apply to a string and
- * create the constants themselves as options of type AV_OPT_TYPE_CONST
- * with their unit field set to the same string.
- * Their default_val field should contain the value of the named
- * constant.
- * For example, to add some named constants for the test_flags option
- * above, put the following into the child_opts array:
- * @code
- * { "test_flags", "This is a test option of flags type.",
- * offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, "test_unit" },
- * { "flag1", "This is a flag with value 16", 0, AV_OPT_TYPE_CONST, { .i64 = 16 }, 0, 0, "test_unit" },
- * @endcode
- *
- * @section avoptions_use Using AVOptions
- * This section deals with accessing options in an AVOptions-enabled struct.
- * Such structs in FFmpeg are e.g. AVCodecContext in libavcodec or
- * AVFormatContext in libavformat.
- *
- * @subsection avoptions_use_examine Examining AVOptions
- * The basic functions for examining options are av_opt_next(), which iterates
- * over all options defined for one object, and av_opt_find(), which searches
- * for an option with the given name.
- *
- * The situation is more complicated with nesting. An AVOptions-enabled struct
- * may have AVOptions-enabled children. Passing the AV_OPT_SEARCH_CHILDREN flag
- * to av_opt_find() will make the function search children recursively.
- *
- * For enumerating there are basically two cases. The first is when you want to
- * get all options that may potentially exist on the struct and its children
- * (e.g. when constructing documentation). In that case you should call
- * av_opt_child_class_next() recursively on the parent struct's AVClass. The
- * second case is when you have an already initialized struct with all its
- * children and you want to get all options that can be actually written or read
- * from it. In that case you should call av_opt_child_next() recursively (and
- * av_opt_next() on each result).
- *
- * @subsection avoptions_use_get_set Reading and writing AVOptions
- * When setting options, you often have a string read directly from the
- * user. In such a case, simply passing it to av_opt_set() is enough. For
- * non-string type options, av_opt_set() will parse the string according to the
- * option type.
- *
- * Similarly av_opt_get() will read any option type and convert it to a string
- * which will be returned. Do not forget that the string is allocated, so you
- * have to free it with av_free().
- *
- * In some cases it may be more convenient to put all options into an
- * AVDictionary and call av_opt_set_dict() on it. A specific case of this
- * are the format/codec open functions in lavf/lavc which take a dictionary
- * filled with option as a parameter. This makes it possible to set some options
- * that cannot be set otherwise, since e.g. the input file format is not known
- * before the file is actually opened.
- */
-
-enum AVOptionType{
- AV_OPT_TYPE_FLAGS,
- AV_OPT_TYPE_INT,
- AV_OPT_TYPE_INT64,
- AV_OPT_TYPE_DOUBLE,
- AV_OPT_TYPE_FLOAT,
- AV_OPT_TYPE_STRING,
- AV_OPT_TYPE_RATIONAL,
- AV_OPT_TYPE_BINARY, ///< offset must point to a pointer immediately followed by an int for the length
- AV_OPT_TYPE_DICT,
- AV_OPT_TYPE_UINT64,
- AV_OPT_TYPE_CONST,
- AV_OPT_TYPE_IMAGE_SIZE, ///< offset must point to two consecutive integers
- AV_OPT_TYPE_PIXEL_FMT,
- AV_OPT_TYPE_SAMPLE_FMT,
- AV_OPT_TYPE_VIDEO_RATE, ///< offset must point to AVRational
- AV_OPT_TYPE_DURATION,
- AV_OPT_TYPE_COLOR,
- AV_OPT_TYPE_CHANNEL_LAYOUT,
- AV_OPT_TYPE_BOOL,
-};
-
-/**
- * AVOption
- */
-typedef struct AVOption {
- const char *name;
-
- /**
- * short English help text
- * @todo What about other languages?
- */
- const char *help;
-
- /**
- * The offset relative to the context structure where the option
- * value is stored. It should be 0 for named constants.
- */
- int offset;
- enum AVOptionType type;
-
- /**
- * the default value for scalar options
- */
- union {
- int64_t i64;
- double dbl;
- const char *str;
- /* TODO those are unused now */
- AVRational q;
- } default_val;
- double min; ///< minimum valid value for the option
- double max; ///< maximum valid value for the option
-
- int flags;
-#define AV_OPT_FLAG_ENCODING_PARAM 1 ///< a generic parameter which can be set by the user for muxing or encoding
-#define AV_OPT_FLAG_DECODING_PARAM 2 ///< a generic parameter which can be set by the user for demuxing or decoding
-#define AV_OPT_FLAG_AUDIO_PARAM 8
-#define AV_OPT_FLAG_VIDEO_PARAM 16
-#define AV_OPT_FLAG_SUBTITLE_PARAM 32
-/**
- * The option is intended for exporting values to the caller.
- */
-#define AV_OPT_FLAG_EXPORT 64
-/**
- * The option may not be set through the AVOptions API, only read.
- * This flag only makes sense when AV_OPT_FLAG_EXPORT is also set.
- */
-#define AV_OPT_FLAG_READONLY 128
-#define AV_OPT_FLAG_BSF_PARAM (1<<8) ///< a generic parameter which can be set by the user for bit stream filtering
-#define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
-//FIXME think about enc-audio, ... style flags
-
- /**
- * The logical unit to which the option belongs. Non-constant
- * options and corresponding named constants share the same
- * unit. May be NULL.
- */
- const char *unit;
-} AVOption;
-
-/**
- * A single allowed range of values, or a single allowed value.
- */
-typedef struct AVOptionRange {
- const char *str;
- /**
- * Value range.
- * For string ranges this represents the min/max length.
- * For dimensions this represents the min/max pixel count or width/height in multi-component case.
- */
- double value_min, value_max;
- /**
- * Value's component range.
- * For string this represents the unicode range for chars, 0-127 limits to ASCII.
- */
- double component_min, component_max;
- /**
- * Range flag.
- * If set to 1 the struct encodes a range, if set to 0 a single value.
- */
- int is_range;
-} AVOptionRange;
-
-/**
- * List of AVOptionRange structs.
- */
-typedef struct AVOptionRanges {
- /**
- * Array of option ranges.
- *
- * Most of option types use just one component.
- * Following describes multi-component option types:
- *
- * AV_OPT_TYPE_IMAGE_SIZE:
- * component index 0: range of pixel count (width * height).
- * component index 1: range of width.
- * component index 2: range of height.
- *
- * @note To obtain multi-component version of this structure, user must
- * provide AV_OPT_MULTI_COMPONENT_RANGE to av_opt_query_ranges or
- * av_opt_query_ranges_default function.
- *
- * Multi-component range can be read as in following example:
- *
- * @code
- * int range_index, component_index;
- * AVOptionRanges *ranges;
- * AVOptionRange *range3; //may require more than 3 in the future.
- * av_opt_query_ranges(&ranges, obj, key, AV_OPT_MULTI_COMPONENT_RANGE);
- * for (range_index = 0; range_index < ranges->nb_ranges; range_index++) {
- * for (component_index = 0; component_index < ranges->nb_components; component_index++)
- * rangecomponent_index = ranges->rangeranges->nb_ranges * component_index + range_index;
- * //do something with range here.
- * }
- * av_opt_freep_ranges(&ranges);
- * @endcode
- */
- AVOptionRange **range;
- /**
- * Number of ranges per component.
- */
- int nb_ranges;
- /**
- * Number of componentes.
- */
- int nb_components;
-} AVOptionRanges;
-
-/**
- * Show the obj options.
- *
- * @param req_flags requested flags for the options to show. Show only the
- * options for which it is opt->flags & req_flags.
- * @param rej_flags rejected flags for the options to show. Show only the
- * options for which it is !(opt->flags & req_flags).
- * @param av_log_obj log context to use for showing the options
- */
-int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags);
-
-/**
- * Set the values of all AVOption fields to their default values.
- *
- * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
- */
-void av_opt_set_defaults(void *s);
-
-/**
- * Set the values of all AVOption fields to their default values. Only these
- * AVOption fields for which (opt->flags & mask) == flags will have their
- * default applied to s.
- *
- * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
- * @param mask combination of AV_OPT_FLAG_*
- * @param flags combination of AV_OPT_FLAG_*
- */
-void av_opt_set_defaults2(void *s, int mask, int flags);
-
-/**
- * Parse the key/value pairs list in opts. For each key/value pair
- * found, stores the value in the field in ctx that is named like the
- * key. ctx must be an AVClass context, storing is done using
- * AVOptions.
- *
- * @param opts options string to parse, may be NULL
- * @param key_val_sep a 0-terminated list of characters used to
- * separate key from value
- * @param pairs_sep a 0-terminated list of characters used to separate
- * two pairs from each other
- * @return the number of successfully set key/value pairs, or a negative
- * value corresponding to an AVERROR code in case of error:
- * AVERROR(EINVAL) if opts cannot be parsed,
- * the error code issued by av_opt_set() if a key/value pair
- * cannot be set
- */
-int av_set_options_string(void *ctx, const char *opts,
- const char *key_val_sep, const char *pairs_sep);
-
-/**
- * Parse the key-value pairs list in opts. For each key=value pair found,
- * set the value of the corresponding option in ctx.
- *
- * @param ctx the AVClass object to set options on
- * @param opts the options string, key-value pairs separated by a
- * delimiter
- * @param shorthand a NULL-terminated array of options names for shorthand
- * notation: if the first field in opts has no key part,
- * the key is taken from the first element of shorthand;
- * then again for the second, etc., until either opts is
- * finished, shorthand is finished or a named option is
- * found; after that, all options must be named
- * @param key_val_sep a 0-terminated list of characters used to separate
- * key from value, for example '='
- * @param pairs_sep a 0-terminated list of characters used to separate
- * two pairs from each other, for example ':' or ','
- * @return the number of successfully set key=value pairs, or a negative
- * value corresponding to an AVERROR code in case of error:
- * AVERROR(EINVAL) if opts cannot be parsed,
- * the error code issued by av_set_string3() if a key/value pair
- * cannot be set
- *
- * Options names must use only the following characters: a-z A-Z 0-9 - . / _
- * Separators must use characters distinct from option names and from each
- * other.
- */
-int av_opt_set_from_string(void *ctx, const char *opts,
- const char *const *shorthand,
- const char *key_val_sep, const char *pairs_sep);
-/**
- * Free all allocated objects in obj.
- */
-void av_opt_free(void *obj);
-
-/**
- * Check whether a particular flag is set in a flags field.
- *
- * @param field_name the name of the flag field option
- * @param flag_name the name of the flag to check
- * @return non-zero if the flag is set, zero if the flag isn't set,
- * isn't of the right type, or the flags field doesn't exist.
- */
-int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name);
-
-/**
- * Set all the options from a given dictionary on an object.
- *
- * @param obj a struct whose first element is a pointer to AVClass
- * @param options options to process. This dictionary will be freed and replaced
- * by a new one containing all options not found in obj.
- * Of course this new dictionary needs to be freed by caller
- * with av_dict_free().
- *
- * @return 0 on success, a negative AVERROR if some option was found in obj,
- * but could not be set.
- *
- * @see av_dict_copy()
- */
-int av_opt_set_dict(void *obj, struct AVDictionary **options);
-
-
-/**
- * Set all the options from a given dictionary on an object.
- *
- * @param obj a struct whose first element is a pointer to AVClass
- * @param options options to process. This dictionary will be freed and replaced
- * by a new one containing all options not found in obj.
- * Of course this new dictionary needs to be freed by caller
- * with av_dict_free().
- * @param search_flags A combination of AV_OPT_SEARCH_*.
- *
- * @return 0 on success, a negative AVERROR if some option was found in obj,
- * but could not be set.
- *
- * @see av_dict_copy()
- */
-int av_opt_set_dict2(void *obj, struct AVDictionary **options, int search_flags);
-
-/**
- * Extract a key-value pair from the beginning of a string.
- *
- * @param ropts pointer to the options string, will be updated to
- * point to the rest of the string (one of the pairs_sep
- * or the final NUL)
- * @param key_val_sep a 0-terminated list of characters used to separate
- * key from value, for example '='
- * @param pairs_sep a 0-terminated list of characters used to separate
- * two pairs from each other, for example ':' or ','
- * @param flags flags; see the AV_OPT_FLAG_* values below
- * @param rkey parsed key; must be freed using av_free()
- * @param rval parsed value; must be freed using av_free()
- *
- * @return >=0 for success, or a negative value corresponding to an
- * AVERROR code in case of error; in particular:
- * AVERROR(EINVAL) if no key is present
- *
- */
-int av_opt_get_key_value(const char **ropts,
- const char *key_val_sep, const char *pairs_sep,
- unsigned flags,
- char **rkey, char **rval);
-
-enum {
-
- /**
- * Accept to parse a value without a key; the key will then be returned
- * as NULL.
- */
- AV_OPT_FLAG_IMPLICIT_KEY = 1,
-};
-
-/**
- * @defgroup opt_eval_funcs Evaluating option strings
- * @{
- * This group of functions can be used to evaluate option strings
- * and get numbers out of them. They do the same thing as av_opt_set(),
- * except the result is written into the caller-supplied pointer.
- *
- * @param obj a struct whose first element is a pointer to AVClass.
- * @param o an option for which the string is to be evaluated.
- * @param val string to be evaluated.
- * @param *_out value of the string will be written here.
- *
- * @return 0 on success, a negative number on failure.
- */
-int av_opt_eval_flags (void *obj, const AVOption *o, const char *val, int *flags_out);
-int av_opt_eval_int (void *obj, const AVOption *o, const char *val, int *int_out);
-int av_opt_eval_int64 (void *obj, const AVOption *o, const char *val, int64_t *int64_out);
-int av_opt_eval_float (void *obj, const AVOption *o, const char *val, float *float_out);
-int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double *double_out);
-int av_opt_eval_q (void *obj, const AVOption *o, const char *val, AVRational *q_out);
-/**
- * @}
- */
-
-#define AV_OPT_SEARCH_CHILDREN (1 << 0) /**< Search in possible children of the
- given object first. */
-/**
- * The obj passed to av_opt_find() is fake -- only a double pointer to AVClass
- * instead of a required pointer to a struct containing AVClass. This is
- * useful for searching for options without needing to allocate the corresponding
- * object.
- */
-#define AV_OPT_SEARCH_FAKE_OBJ (1 << 1)
-
-/**
- * In av_opt_get, return NULL if the option has a pointer type and is set to NULL,
- * rather than returning an empty string.
- */
-#define AV_OPT_ALLOW_NULL (1 << 2)
-
-/**
- * Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than
- * one component for certain option types.
- * @see AVOptionRanges for details.
- */
-#define AV_OPT_MULTI_COMPONENT_RANGE (1 << 12)
-
-/**
- * Look for an option in an object. Consider only options which
- * have all the specified flags set.
- *
- * @paramin obj A pointer to a struct whose first element is a
- * pointer to an AVClass.
- * Alternatively a double pointer to an AVClass, if
- * AV_OPT_SEARCH_FAKE_OBJ search flag is set.
- * @paramin name The name of the option to look for.
- * @paramin unit When searching for named constants, name of the unit
- * it belongs to.
- * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
- * @param search_flags A combination of AV_OPT_SEARCH_*.
- *
- * @return A pointer to the option found, or NULL if no option
- * was found.
- *
- * @note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable
- * directly with av_opt_set(). Use special calls which take an options
- * AVDictionary (e.g. avformat_open_input()) to set options found with this
- * flag.
- */
-const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
- int opt_flags, int search_flags);
-
-/**
- * Look for an option in an object. Consider only options which
- * have all the specified flags set.
- *
- * @paramin obj A pointer to a struct whose first element is a
- * pointer to an AVClass.
- * Alternatively a double pointer to an AVClass, if
- * AV_OPT_SEARCH_FAKE_OBJ search flag is set.
- * @paramin name The name of the option to look for.
- * @paramin unit When searching for named constants, name of the unit
- * it belongs to.
- * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
- * @param search_flags A combination of AV_OPT_SEARCH_*.
- * @paramout target_obj if non-NULL, an object to which the option belongs will be
- * written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present
- * in search_flags. This parameter is ignored if search_flags contain
- * AV_OPT_SEARCH_FAKE_OBJ.
- *
- * @return A pointer to the option found, or NULL if no option
- * was found.
- */
-const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
- int opt_flags, int search_flags, void **target_obj);
-
-/**
- * Iterate over all AVOptions belonging to obj.
- *
- * @param obj an AVOptions-enabled struct or a double pointer to an
- * AVClass describing it.
- * @param prev result of the previous call to av_opt_next() on this object
- * or NULL
- * @return next AVOption or NULL
- */
-const AVOption *av_opt_next(const void *obj, const AVOption *prev);
-
-/**
- * Iterate over AVOptions-enabled children of obj.
- *
- * @param prev result of a previous call to this function or NULL
- * @return next AVOptions-enabled child or NULL
- */
-void *av_opt_child_next(void *obj, void *prev);
-
-/**
- * Iterate over potential AVOptions-enabled children of parent.
- *
- * @param prev result of a previous call to this function or NULL
- * @return AVClass corresponding to next potential child or NULL
- */
-const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev);
-
-/**
- * @defgroup opt_set_funcs Option setting functions
- * @{
- * Those functions set the field of obj with the given name to value.
- *
- * @paramin obj A struct whose first element is a pointer to an AVClass.
- * @paramin name the name of the field to set
- * @paramin val The value to set. In case of av_opt_set() if the field is not
- * of a string type, then the given string is parsed.
- * SI postfixes and some named scalars are supported.
- * If the field is of a numeric type, it has to be a numeric or named
- * scalar. Behavior with more than one scalar and +- infix operators
- * is undefined.
- * If the field is of a flags type, it has to be a sequence of numeric
- * scalars or named flags separated by '+' or '-'. Prefixing a flag
- * with '+' causes it to be set without affecting the other flags;
- * similarly, '-' unsets a flag.
- * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
- * is passed here, then the option may be set on a child of obj.
- *
- * @return 0 if the value has been set, or an AVERROR code in case of
- * error:
- * AVERROR_OPTION_NOT_FOUND if no matching option exists
- * AVERROR(ERANGE) if the value is out of range
- * AVERROR(EINVAL) if the value is not valid
- */
-int av_opt_set (void *obj, const char *name, const char *val, int search_flags);
-int av_opt_set_int (void *obj, const char *name, int64_t val, int search_flags);
-int av_opt_set_double (void *obj, const char *name, double val, int search_flags);
-int av_opt_set_q (void *obj, const char *name, AVRational val, int search_flags);
-int av_opt_set_bin (void *obj, const char *name, const uint8_t *val, int size, int search_flags);
-int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags);
-int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags);
-int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags);
-int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags);
-int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags);
-/**
- * @note Any old dictionary present is discarded and replaced with a copy of the new one. The
- * caller still owns val is and responsible for freeing it.
- */
-int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags);
-
-/**
- * Set a binary option to an integer list.
- *
- * @param obj AVClass object to set options on
- * @param name name of the binary option
- * @param val pointer to an integer list (must have the correct type with
- * regard to the contents of the list)
- * @param term list terminator (usually 0 or -1)
- * @param flags search flags
- */
-#define av_opt_set_int_list(obj, name, val, term, flags) \
- (av_int_list_length(val, term) > INT_MAX / sizeof(*(val)) ? \
- AVERROR(EINVAL) : \
- av_opt_set_bin(obj, name, (const uint8_t *)(val), \
- av_int_list_length(val, term) * sizeof(*(val)), flags))
-
-/**
- * @}
- */
-
-/**
- * @defgroup opt_get_funcs Option getting functions
- * @{
- * Those functions get a value of the option with the given name from an object.
- *
- * @paramin obj a struct whose first element is a pointer to an AVClass.
- * @paramin name name of the option to get.
- * @paramin search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
- * is passed here, then the option may be found in a child of obj.
- * @paramout out_val value of the option will be written here
- * @return >=0 on success, a negative error code otherwise
- */
-/**
- * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
- *
- * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has
- * AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set
- * to NULL instead of an allocated empty string.
- */
-int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val);
-int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val);
-int av_opt_get_double (void *obj, const char *name, int search_flags, double *out_val);
-int av_opt_get_q (void *obj, const char *name, int search_flags, AVRational *out_val);
-int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out);
-int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt);
-int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt);
-int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val);
-int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout);
-/**
- * @paramout out_val The returned dictionary is a copy of the actual value and must
- * be freed with av_dict_free() by the caller
- */
-int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val);
-/**
- * @}
- */
-/**
- * Gets a pointer to the requested field in a struct.
- * This function allows accessing a struct even when its fields are moved or
- * renamed since the application making the access has been compiled,
- *
- * @returns a pointer to the field, it can be cast to the correct type and read
- * or written to.
- */
-void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name);
-
-/**
- * Free an AVOptionRanges struct and set it to NULL.
- */
-void av_opt_freep_ranges(AVOptionRanges **ranges);
-
-/**
- * Get a list of allowed ranges for the given option.
- *
- * The returned list may depend on other fields in obj like for example profile.
- *
- * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
- * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
- * AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
- *
- * The result must be freed with av_opt_freep_ranges.
- *
- * @return number of compontents returned on success, a negative errro code otherwise
- */
-int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags);
-
-/**
- * Copy options from src object into dest object.
- *
- * Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object.
- * Original memory allocated for such options is freed unless both src and dest options points to the same memory.
- *
- * @param dest Object to copy from
- * @param src Object to copy into
- * @return 0 on success, negative on error
- */
-int av_opt_copy(void *dest, const void *src);
-
-/**
- * Get a default list of allowed ranges for the given option.
- *
- * This list is constructed without using the AVClass.query_ranges() callback
- * and can be used as fallback from within the callback.
- *
- * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
- * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
- * AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
- *
- * The result must be freed with av_opt_free_ranges.
- *
- * @return number of compontents returned on success, a negative errro code otherwise
- */
-int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags);
-
-/**
- * Check if given option is set to its default value.
- *
- * Options o must belong to the obj. This function must not be called to check child's options state.
- * @see av_opt_is_set_to_default_by_name().
- *
- * @param obj AVClass object to check option on
- * @param o option to be checked
- * @return >0 when option is set to its default,
- * 0 when option is not set its default,
- * <0 on error
- */
-int av_opt_is_set_to_default(void *obj, const AVOption *o);
-
-/**
- * Check if given option is set to its default value.
- *
- * @param obj AVClass object to check option on
- * @param name option name
- * @param search_flags combination of AV_OPT_SEARCH_*
- * @return >0 when option is set to its default,
- * 0 when option is not set its default,
- * <0 on error
- */
-int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags);
-
-
-#define AV_OPT_SERIALIZE_SKIP_DEFAULTS 0x00000001 ///< Serialize options that are not set to default values only.
-#define AV_OPT_SERIALIZE_OPT_FLAGS_EXACT 0x00000002 ///< Serialize options that exactly match opt_flags only.
-
-/**
- * Serialize object's options.
- *
- * Create a string containing object's serialized options.
- * Such string may be passed back to av_opt_set_from_string() in order to restore option values.
- * A key/value or pairs separator occurring in the serialized value or
- * name string are escaped through the av_escape() function.
- *
- * @paramin obj AVClass object to serialize
- * @paramin opt_flags serialize options with all the specified flags set (AV_OPT_FLAG)
- * @paramin flags combination of AV_OPT_SERIALIZE_* flags
- * @paramout buffer Pointer to buffer that will be allocated with string containg serialized options.
- * Buffer must be freed by the caller when is no longer needed.
- * @paramin key_val_sep character used to separate key from value
- * @paramin pairs_sep character used to separate two pairs from each other
- * @return >= 0 on success, negative on error
- * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
- */
-int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
- const char key_val_sep, const char pairs_sep);
-/**
- * @}
- */
-
-#endif /* AVUTIL_OPT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/parseutils.h Deleted

@@ -1,193 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_PARSEUTILS_H
-#define AVUTIL_PARSEUTILS_H
-
-#include <time.h>
-
-#include "rational.h"
-
-/**
- * @file
- * misc parsing utilities
- */
-
-/**
- * Parse str and store the parsed ratio in q.
- *
- * Note that a ratio with infinite (1/0) or negative value is
- * considered valid, so you should check on the returned value if you
- * want to exclude those values.
- *
- * The undefined value can be expressed using the "0:0" string.
- *
- * @paramin,out q pointer to the AVRational which will contain the ratio
- * @paramin str the string to parse: it has to be a string in the format
- * num:den, a float number or an expression
- * @paramin max the maximum allowed numerator and denominator
- * @paramin log_offset log level offset which is applied to the log
- * level of log_ctx
- * @paramin log_ctx parent logging context
- * @return >= 0 on success, a negative error code otherwise
- */
-int av_parse_ratio(AVRational *q, const char *str, int max,
- int log_offset, void *log_ctx);
-
-#define av_parse_ratio_quiet(rate, str, max) \
- av_parse_ratio(rate, str, max, AV_LOG_MAX_OFFSET, NULL)
-
-/**
- * Parse str and put in width_ptr and height_ptr the detected values.
- *
- * @paramin,out width_ptr pointer to the variable which will contain the detected
- * width value
- * @paramin,out height_ptr pointer to the variable which will contain the detected
- * height value
- * @paramin str the string to parse: it has to be a string in the format
- * width x height or a valid video size abbreviation.
- * @return >= 0 on success, a negative error code otherwise
- */
-int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str);
-
-/**
- * Parse str and store the detected values in *rate.
- *
- * @paramin,out rate pointer to the AVRational which will contain the detected
- * frame rate
- * @paramin str the string to parse: it has to be a string in the format
- * rate_num / rate_den, a float number or a valid video rate abbreviation
- * @return >= 0 on success, a negative error code otherwise
- */
-int av_parse_video_rate(AVRational *rate, const char *str);
-
-/**
- * Put the RGBA values that correspond to color_string in rgba_color.
- *
- * @param color_string a string specifying a color. It can be the name of
- * a color (case insensitive match) or a 0x|#RRGGBBAA sequence,
- * possibly followed by "@" and a string representing the alpha
- * component.
- * The alpha component may be a string composed by "0x" followed by an
- * hexadecimal number or a decimal number between 0.0 and 1.0, which
- * represents the opacity value (0x00/0.0 means completely transparent,
- * 0xff/1.0 completely opaque).
- * If the alpha component is not specified then 0xff is assumed.
- * The string "random" will result in a random color.
- * @param slen length of the initial part of color_string containing the
- * color. It can be set to -1 if color_string is a null terminated string
- * containing nothing else than the color.
- * @return >= 0 in case of success, a negative value in case of
- * failure (for example if color_string cannot be parsed).
- */
-int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
- void *log_ctx);
-
-/**
- * Get the name of a color from the internal table of hard-coded named
- * colors.
- *
- * This function is meant to enumerate the color names recognized by
- * av_parse_color().
- *
- * @param color_idx index of the requested color, starting from 0
- * @param rgbp if not NULL, will point to a 3-elements array with the color value in RGB
- * @return the color name string or NULL if color_idx is not in the array
- */
-const char *av_get_known_color_name(int color_idx, const uint8_t **rgb);
-
-/**
- * Parse timestr and return in *time a corresponding number of
- * microseconds.
- *
- * @param timeval puts here the number of microseconds corresponding
- * to the string in timestr. If the string represents a duration, it
- * is the number of microseconds contained in the time interval. If
- * the string is a date, is the number of microseconds since 1st of
- * January, 1970 up to the time of the parsed date. If timestr cannot
- * be successfully parsed, set *time to INT64_MIN.
-
- * @param timestr a string representing a date or a duration.
- * - If a date the syntax is:
- * @code
- * {YYYY-MM-DD|YYYYMMDD}T|t| {{HH:MM:SS.m...}|{HHMMSS.m...}}Z
- * now
- * @endcode
- * If the value is "now" it takes the current time.
- * Time is local time unless Z is appended, in which case it is
- * interpreted as UTC.
- * If the year-month-day part is not specified it takes the current
- * year-month-day.
- * - If a duration the syntax is:
- * @code
- * -HH:MM:SS.m...
- * -S+.m...
- * @endcode
- * @param duration flag which tells how to interpret timestr, if not
- * zero timestr is interpreted as a duration, otherwise as a date
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code otherwise
- */
-int av_parse_time(int64_t *timeval, const char *timestr, int duration);
-
-/**
- * Attempt to find a specific tag in a URL.
- *
- * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
- * Return 1 if found.
- */
-int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);
-
-/**
- * Simplified version of strptime
- *
- * Parse the input string p according to the format string fmt and
- * store its results in the structure dt.
- * This implementation supports only a subset of the formats supported
- * by the standard strptime().
- *
- * The supported input field descriptors are listed below.
- * - %H: the hour as a decimal number, using a 24-hour clock, in the
- * range '00' through '23'
- * - %J: hours as a decimal number, in the range '0' through INT_MAX
- * - %M: the minute as a decimal number, using a 24-hour clock, in the
- * range '00' through '59'
- * - %S: the second as a decimal number, using a 24-hour clock, in the
- * range '00' through '59'
- * - %Y: the year as a decimal number, using the Gregorian calendar
- * - %m: the month as a decimal number, in the range '1' through '12'
- * - %d: the day of the month as a decimal number, in the range '1'
- * through '31'
- * - %T: alias for '%H:%M:%S'
- * - %%: a literal '%'
- *
- * @return a pointer to the first character not processed in this function
- * call. In case the input string contains more characters than
- * required by the format string the return value points right after
- * the last consumed input character. In case the whole input string
- * is consumed the return value points to the null byte at the end of
- * the string. On failure NULL is returned.
- */
-char *av_small_strptime(const char *p, const char *fmt, struct tm *dt);
-
-/**
- * Convert the decomposed UTC time in tm to a time_t value.
- */
-time_t av_timegm(struct tm *tm);
-
-#endif /* AVUTIL_PARSEUTILS_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/pixdesc.h Deleted

@@ -1,433 +0,0 @@
-/*
- * pixel format descriptor
- * Copyright (c) 2009 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_PIXDESC_H
-#define AVUTIL_PIXDESC_H
-
-#include <inttypes.h>
-
-#include "attributes.h"
-#include "pixfmt.h"
-#include "version.h"
-
-typedef struct AVComponentDescriptor {
- /**
- * Which of the 4 planes contains the component.
- */
- int plane;
-
- /**
- * Number of elements between 2 horizontally consecutive pixels.
- * Elements are bits for bitstream formats, bytes otherwise.
- */
- int step;
-
- /**
- * Number of elements before the component of the first pixel.
- * Elements are bits for bitstream formats, bytes otherwise.
- */
- int offset;
-
- /**
- * Number of least significant bits that must be shifted away
- * to get the value.
- */
- int shift;
-
- /**
- * Number of bits in the component.
- */
- int depth;
-
-#if FF_API_PLUS1_MINUS1
- /** deprecated, use step instead */
- attribute_deprecated int step_minus1;
-
- /** deprecated, use depth instead */
- attribute_deprecated int depth_minus1;
-
- /** deprecated, use offset instead */
- attribute_deprecated int offset_plus1;
-#endif
-} AVComponentDescriptor;
-
-/**
- * Descriptor that unambiguously describes how the bits of a pixel are
- * stored in the up to 4 data planes of an image. It also stores the
- * subsampling factors and number of components.
- *
- * @note This is separate of the colorspace (RGB, YCbCr, YPbPr, JPEG-style YUV
- * and all the YUV variants) AVPixFmtDescriptor just stores how values
- * are stored not what these values represent.
- */
-typedef struct AVPixFmtDescriptor {
- const char *name;
- uint8_t nb_components; ///< The number of components each pixel has, (1-4)
-
- /**
- * Amount to shift the luma width right to find the chroma width.
- * For YV12 this is 1 for example.
- * chroma_width = AV_CEIL_RSHIFT(luma_width, log2_chroma_w)
- * The note above is needed to ensure rounding up.
- * This value only refers to the chroma components.
- */
- uint8_t log2_chroma_w;
-
- /**
- * Amount to shift the luma height right to find the chroma height.
- * For YV12 this is 1 for example.
- * chroma_height= AV_CEIL_RSHIFT(luma_height, log2_chroma_h)
- * The note above is needed to ensure rounding up.
- * This value only refers to the chroma components.
- */
- uint8_t log2_chroma_h;
-
- /**
- * Combination of AV_PIX_FMT_FLAG_... flags.
- */
- uint64_t flags;
-
- /**
- * Parameters that describe how pixels are packed.
- * If the format has 1 or 2 components, then luma is 0.
- * If the format has 3 or 4 components:
- * if the RGB flag is set then 0 is red, 1 is green and 2 is blue;
- * otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V.
- *
- * If present, the Alpha channel is always the last component.
- */
- AVComponentDescriptor comp4;
-
- /**
- * Alternative comma-separated names.
- */
- const char *alias;
-} AVPixFmtDescriptor;
-
-/**
- * Pixel format is big-endian.
- */
-#define AV_PIX_FMT_FLAG_BE (1 << 0)
-/**
- * Pixel format has a palette in data1, values are indexes in this palette.
- */
-#define AV_PIX_FMT_FLAG_PAL (1 << 1)
-/**
- * All values of a component are bit-wise packed end to end.
- */
-#define AV_PIX_FMT_FLAG_BITSTREAM (1 << 2)
-/**
- * Pixel format is an HW accelerated format.
- */
-#define AV_PIX_FMT_FLAG_HWACCEL (1 << 3)
-/**
- * At least one pixel component is not in the first data plane.
- */
-#define AV_PIX_FMT_FLAG_PLANAR (1 << 4)
-/**
- * The pixel format contains RGB-like data (as opposed to YUV/grayscale).
- */
-#define AV_PIX_FMT_FLAG_RGB (1 << 5)
-
-/**
- * The pixel format is "pseudo-paletted". This means that it contains a
- * fixed palette in the 2nd plane but the palette is fixed/constant for each
- * PIX_FMT. This allows interpreting the data as if it was PAL8, which can
- * in some cases be simpler. Or the data can be interpreted purely based on
- * the pixel format without using the palette.
- * An example of a pseudo-paletted format is AV_PIX_FMT_GRAY8
- *
- * @deprecated This flag is deprecated, and will be removed. When it is removed,
- * the extra palette allocation in AVFrame.data1 is removed as well. Only
- * actual paletted formats (as indicated by AV_PIX_FMT_FLAG_PAL) will have a
- * palette. Starting with FFmpeg versions which have this flag deprecated, the
- * extra "pseudo" palette is already ignored, and API users are not required to
- * allocate a palette for AV_PIX_FMT_FLAG_PSEUDOPAL formats (it was required
- * before the deprecation, though).
- */
-#define AV_PIX_FMT_FLAG_PSEUDOPAL (1 << 6)
-
-/**
- * The pixel format has an alpha channel. This is set on all formats that
- * support alpha in some way. The exception is AV_PIX_FMT_PAL8, which can
- * carry alpha as part of the palette. Details are explained in the
- * AVPixelFormat enum, and are also encoded in the corresponding
- * AVPixFmtDescriptor.
- *
- * The alpha is always straight, never pre-multiplied.
- *
- * If a codec or a filter does not support alpha, it should set all alpha to
- * opaque, or use the equivalent pixel formats without alpha component, e.g.
- * AV_PIX_FMT_RGB0 (or AV_PIX_FMT_RGB24 etc.) instead of AV_PIX_FMT_RGBA.
- */
-#define AV_PIX_FMT_FLAG_ALPHA (1 << 7)
-
-/**
- * The pixel format is following a Bayer pattern
- */
-#define AV_PIX_FMT_FLAG_BAYER (1 << 8)
-
-/**
- * The pixel format contains IEEE-754 floating point values. Precision (double,
- * single, or half) should be determined by the pixel size (64, 32, or 16 bits).
- */
-#define AV_PIX_FMT_FLAG_FLOAT (1 << 9)
-
-/**
- * Return the number of bits per pixel used by the pixel format
- * described by pixdesc. Note that this is not the same as the number
- * of bits per sample.
- *
- * The returned number of bits refers to the number of bits actually
- * used for storing the pixel information, that is padding bits are
- * not counted.
- */
-int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc);
-
-/**
- * Return the number of bits per pixel for the pixel format
- * described by pixdesc, including any padding or unused bits.
- */
-int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc);
-
-/**
- * @return a pixel format descriptor for provided pixel format or NULL if
- * this pixel format is unknown.
- */
-const AVPixFmtDescriptor *av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt);
-
-/**
- * Iterate over all pixel format descriptors known to libavutil.
- *
- * @param prev previous descriptor. NULL to get the first descriptor.
- *
- * @return next descriptor or NULL after the last descriptor
- */
-const AVPixFmtDescriptor *av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev);
-
-/**
- * @return an AVPixelFormat id described by desc, or AV_PIX_FMT_NONE if desc
- * is not a valid pointer to a pixel format descriptor.
- */
-enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc);
-
-/**
- * Utility function to access log2_chroma_w log2_chroma_h from
- * the pixel format AVPixFmtDescriptor.
- *
- * @paramin pix_fmt the pixel format
- * @paramout h_shift store log2_chroma_w (horizontal/width shift)
- * @paramout v_shift store log2_chroma_h (vertical/height shift)
- *
- * @return 0 on success, AVERROR(ENOSYS) on invalid or unknown pixel format
- */
-int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt,
- int *h_shift, int *v_shift);
-
-/**
- * @return number of planes in pix_fmt, a negative AVERROR if pix_fmt is not a
- * valid pixel format.
- */
-int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt);
-
-/**
- * @return the name for provided color range or NULL if unknown.
- */
-const char *av_color_range_name(enum AVColorRange range);
-
-/**
- * @return the AVColorRange value for name or an AVError if not found.
- */
-int av_color_range_from_name(const char *name);
-
-/**
- * @return the name for provided color primaries or NULL if unknown.
- */
-const char *av_color_primaries_name(enum AVColorPrimaries primaries);
-
-/**
- * @return the AVColorPrimaries value for name or an AVError if not found.
- */
-int av_color_primaries_from_name(const char *name);
-
-/**
- * @return the name for provided color transfer or NULL if unknown.
- */
-const char *av_color_transfer_name(enum AVColorTransferCharacteristic transfer);
-
-/**
- * @return the AVColorTransferCharacteristic value for name or an AVError if not found.
- */
-int av_color_transfer_from_name(const char *name);
-
-/**
- * @return the name for provided color space or NULL if unknown.
- */
-const char *av_color_space_name(enum AVColorSpace space);
-
-/**
- * @return the AVColorSpace value for name or an AVError if not found.
- */
-int av_color_space_from_name(const char *name);
-
-/**
- * @return the name for provided chroma location or NULL if unknown.
- */
-const char *av_chroma_location_name(enum AVChromaLocation location);
-
-/**
- * @return the AVChromaLocation value for name or an AVError if not found.
- */
-int av_chroma_location_from_name(const char *name);
-
-/**
- * Return the pixel format corresponding to name.
- *
- * If there is no pixel format with name name, then looks for a
- * pixel format with the name corresponding to the native endian
- * format of name.
- * For example in a little-endian system, first looks for "gray16",
- * then for "gray16le".
- *
- * Finally if no pixel format has been found, returns AV_PIX_FMT_NONE.
- */
-enum AVPixelFormat av_get_pix_fmt(const char *name);
-
-/**
- * Return the short name for a pixel format, NULL in case pix_fmt is
- * unknown.
- *
- * @see av_get_pix_fmt(), av_get_pix_fmt_string()
- */
-const char *av_get_pix_fmt_name(enum AVPixelFormat pix_fmt);
-
-/**
- * Print in buf the string corresponding to the pixel format with
- * number pix_fmt, or a header if pix_fmt is negative.
- *
- * @param buf the buffer where to write the string
- * @param buf_size the size of buf
- * @param pix_fmt the number of the pixel format to print the
- * corresponding info string, or a negative value to print the
- * corresponding header.
- */
-char *av_get_pix_fmt_string(char *buf, int buf_size,
- enum AVPixelFormat pix_fmt);
-
-/**
- * Read a line from an image, and write the values of the
- * pixel format component c to dst.
- *
- * @param data the array containing the pointers to the planes of the image
- * @param linesize the array containing the linesizes of the image
- * @param desc the pixel format descriptor for the image
- * @param x the horizontal coordinate of the first pixel to read
- * @param y the vertical coordinate of the first pixel to read
- * @param w the width of the line to read, that is the number of
- * values to write to dst
- * @param read_pal_component if not zero and the format is a paletted
- * format writes the values corresponding to the palette
- * component c in data1 to dst, rather than the palette indexes in
- * data0. The behavior is undefined if the format is not paletted.
- */
-void av_read_image_line(uint16_t *dst, const uint8_t *data4,
- const int linesize4, const AVPixFmtDescriptor *desc,
- int x, int y, int c, int w, int read_pal_component);
-
-/**
- * Write the values from src to the pixel format component c of an
- * image line.
- *
- * @param src array containing the values to write
- * @param data the array containing the pointers to the planes of the
- * image to write into. It is supposed to be zeroed.
- * @param linesize the array containing the linesizes of the image
- * @param desc the pixel format descriptor for the image
- * @param x the horizontal coordinate of the first pixel to write
- * @param y the vertical coordinate of the first pixel to write
- * @param w the width of the line to write, that is the number of
- * values to write to the image line
- */
-void av_write_image_line(const uint16_t *src, uint8_t *data4,
- const int linesize4, const AVPixFmtDescriptor *desc,
- int x, int y, int c, int w);
-
-/**
- * Utility function to swap the endianness of a pixel format.
- *
- * @paramin pix_fmt the pixel format
- *
- * @return pixel format with swapped endianness if it exists,
- * otherwise AV_PIX_FMT_NONE
- */
-enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt);
-
-#define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */
-#define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */
-#define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */
-#define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */
-#define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */
-#define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */
-
-/**
- * Compute what kind of losses will occur when converting from one specific
- * pixel format to another.
- * When converting from one pixel format to another, information loss may occur.
- * For example, when converting from RGB24 to GRAY, the color information will
- * be lost. Similarly, other losses occur when converting from some formats to
- * other formats. These losses can involve loss of chroma, but also loss of
- * resolution, loss of color depth, loss due to the color space conversion, loss
- * of the alpha bits or loss due to color quantization.
- * av_get_fix_fmt_loss() informs you about the various types of losses
- * which will occur when converting from one pixel format to another.
- *
- * @paramin dst_pix_fmt destination pixel format
- * @paramin src_pix_fmt source pixel format
- * @paramin has_alpha Whether the source pixel format alpha channel is used.
- * @return Combination of flags informing you what kind of losses will occur
- * (maximum loss for an invalid dst_pix_fmt).
- */
-int av_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt,
- enum AVPixelFormat src_pix_fmt,
- int has_alpha);
-
-/**
- * Compute what kind of losses will occur when converting from one specific
- * pixel format to another.
- * When converting from one pixel format to another, information loss may occur.
- * For example, when converting from RGB24 to GRAY, the color information will
- * be lost. Similarly, other losses occur when converting from some formats to
- * other formats. These losses can involve loss of chroma, but also loss of
- * resolution, loss of color depth, loss due to the color space conversion, loss
- * of the alpha bits or loss due to color quantization.
- * av_get_fix_fmt_loss() informs you about the various types of losses
- * which will occur when converting from one pixel format to another.
- *
- * @paramin dst_pix_fmt destination pixel format
- * @paramin src_pix_fmt source pixel format
- * @paramin has_alpha Whether the source pixel format alpha channel is used.
- * @return Combination of flags informing you what kind of losses will occur
- * (maximum loss for an invalid dst_pix_fmt).
- */
-enum AVPixelFormat av_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
- enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
-
-#endif /* AVUTIL_PIXDESC_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/pixelutils.h Deleted

@@ -1,52 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_PIXELUTILS_H
-#define AVUTIL_PIXELUTILS_H
-
-#include <stddef.h>
-#include <stdint.h>
-#include "common.h"
-
-/**
- * Sum of abs(src1x - src2x)
- */
-typedef int (*av_pixelutils_sad_fn)(const uint8_t *src1, ptrdiff_t stride1,
- const uint8_t *src2, ptrdiff_t stride2);
-
-/**
- * Get a potentially optimized pointer to a Sum-of-absolute-differences
- * function (see the av_pixelutils_sad_fn prototype).
- *
- * @param w_bits 1<<w_bits is the requested width of the block size
- * @param h_bits 1<<h_bits is the requested height of the block size
- * @param aligned If set to 2, the returned sad function will assume src1 and
- * src2 addresses are aligned on the block size.
- * If set to 1, the returned sad function will assume src1 is
- * aligned on the block size.
- * If set to 0, the returned sad function assume no particular
- * alignment.
- * @param log_ctx context used for logging, can be NULL
- *
- * @return a pointer to the SAD function or NULL in case of error (because of
- * invalid parameters)
- */
-av_pixelutils_sad_fn av_pixelutils_get_sad_fn(int w_bits, int h_bits,
- int aligned, void *log_ctx);
-
-#endif /* AVUTIL_PIXELUTILS_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/pixfmt.h Deleted

@@ -1,529 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_PIXFMT_H
-#define AVUTIL_PIXFMT_H
-
-/**
- * @file
- * pixel format definitions
- */
-
-#include "libavutil/avconfig.h"
-#include "version.h"
-
-#define AVPALETTE_SIZE 1024
-#define AVPALETTE_COUNT 256
-
-/**
- * Pixel format.
- *
- * @note
- * AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
- * color is put together as:
- * (A << 24) | (R << 16) | (G << 8) | B
- * This is stored as BGRA on little-endian CPU architectures and ARGB on
- * big-endian CPUs.
- *
- * @par
- * When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized
- * image data is stored in AVFrame.data0. The palette is transported in
- * AVFrame.data1, is 1024 bytes long (256 4-byte entries) and is
- * formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is
- * also endian-specific). Note also that the individual RGB32 palette
- * components stored in AVFrame.data1 should be in the range 0..255.
- * This is important as many custom PAL8 video codecs that were designed
- * to run on the IBM VGA graphics adapter use 6-bit palette components.
- *
- * @par
- * For all the 8 bits per pixel formats, an RGB32 palette is in data1 like
- * for pal8. This palette is filled in automatically by the function
- * allocating the picture.
- */
-enum AVPixelFormat {
- AV_PIX_FMT_NONE = -1,
- AV_PIX_FMT_YUV420P, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
- AV_PIX_FMT_YUYV422, ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
- AV_PIX_FMT_RGB24, ///< packed RGB 8:8:8, 24bpp, RGBRGB...
- AV_PIX_FMT_BGR24, ///< packed RGB 8:8:8, 24bpp, BGRBGR...
- AV_PIX_FMT_YUV422P, ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
- AV_PIX_FMT_YUV444P, ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
- AV_PIX_FMT_YUV410P, ///< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
- AV_PIX_FMT_YUV411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
- AV_PIX_FMT_GRAY8, ///< Y , 8bpp
- AV_PIX_FMT_MONOWHITE, ///< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
- AV_PIX_FMT_MONOBLACK, ///< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
- AV_PIX_FMT_PAL8, ///< 8 bits with AV_PIX_FMT_RGB32 palette
- AV_PIX_FMT_YUVJ420P, ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range
- AV_PIX_FMT_YUVJ422P, ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range
- AV_PIX_FMT_YUVJ444P, ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range
- AV_PIX_FMT_UYVY422, ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
- AV_PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
- AV_PIX_FMT_BGR8, ///< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
- AV_PIX_FMT_BGR4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
- AV_PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
- AV_PIX_FMT_RGB8, ///< packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
- AV_PIX_FMT_RGB4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
- AV_PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
- AV_PIX_FMT_NV12, ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
- AV_PIX_FMT_NV21, ///< as above, but U and V bytes are swapped
-
- AV_PIX_FMT_ARGB, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
- AV_PIX_FMT_RGBA, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
- AV_PIX_FMT_ABGR, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
- AV_PIX_FMT_BGRA, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
-
- AV_PIX_FMT_GRAY16BE, ///< Y , 16bpp, big-endian
- AV_PIX_FMT_GRAY16LE, ///< Y , 16bpp, little-endian
- AV_PIX_FMT_YUV440P, ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
- AV_PIX_FMT_YUVJ440P, ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
- AV_PIX_FMT_YUVA420P, ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
- AV_PIX_FMT_RGB48BE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
- AV_PIX_FMT_RGB48LE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
-
- AV_PIX_FMT_RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
- AV_PIX_FMT_RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
- AV_PIX_FMT_RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
- AV_PIX_FMT_RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
-
- AV_PIX_FMT_BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
- AV_PIX_FMT_BGR565LE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
- AV_PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
- AV_PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
-
-#if FF_API_VAAPI
- /** @name Deprecated pixel formats */
- /**@{*/
- AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data3 contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
- AV_PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data3 contains a vaapi_render_state struct which contains fields extracted from headers
- AV_PIX_FMT_VAAPI_VLD, ///< HW decoding through VA API, Picture.data3 contains a VASurfaceID
- /**@}*/
- AV_PIX_FMT_VAAPI = AV_PIX_FMT_VAAPI_VLD,
-#else
- /**
- * Hardware acceleration through VA-API, data3 contains a
- * VASurfaceID.
- */
- AV_PIX_FMT_VAAPI,
-#endif
-
- AV_PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
- AV_PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
- AV_PIX_FMT_YUV422P16LE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
- AV_PIX_FMT_YUV422P16BE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
- AV_PIX_FMT_YUV444P16LE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
- AV_PIX_FMT_YUV444P16BE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
- AV_PIX_FMT_DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data3 contains a LPDIRECT3DSURFACE9 pointer
-
- AV_PIX_FMT_RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
- AV_PIX_FMT_RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
- AV_PIX_FMT_BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
- AV_PIX_FMT_BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
- AV_PIX_FMT_YA8, ///< 8 bits gray, 8 bits alpha
-
- AV_PIX_FMT_Y400A = AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8
- AV_PIX_FMT_GRAY8A= AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8
-
- AV_PIX_FMT_BGR48BE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
- AV_PIX_FMT_BGR48LE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
-
- /**
- * The following 12 formats have the disadvantage of needing 1 format for each bit depth.
- * Notice that each 9/10 bits sample is stored in 16 bits with extra padding.
- * If you want to support multiple bit depths, then using AV_PIX_FMT_YUV420P16* with the bpp stored separately is better.
- */
- AV_PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
- AV_PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
- AV_PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
- AV_PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
- AV_PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
- AV_PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
- AV_PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
- AV_PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
- AV_PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
- AV_PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
- AV_PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
- AV_PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
- AV_PIX_FMT_GBRP, ///< planar GBR 4:4:4 24bpp
- AV_PIX_FMT_GBR24P = AV_PIX_FMT_GBRP, // alias for #AV_PIX_FMT_GBRP
- AV_PIX_FMT_GBRP9BE, ///< planar GBR 4:4:4 27bpp, big-endian
- AV_PIX_FMT_GBRP9LE, ///< planar GBR 4:4:4 27bpp, little-endian
- AV_PIX_FMT_GBRP10BE, ///< planar GBR 4:4:4 30bpp, big-endian
- AV_PIX_FMT_GBRP10LE, ///< planar GBR 4:4:4 30bpp, little-endian
- AV_PIX_FMT_GBRP16BE, ///< planar GBR 4:4:4 48bpp, big-endian
- AV_PIX_FMT_GBRP16LE, ///< planar GBR 4:4:4 48bpp, little-endian
- AV_PIX_FMT_YUVA422P, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
- AV_PIX_FMT_YUVA444P, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
- AV_PIX_FMT_YUVA420P9BE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
- AV_PIX_FMT_YUVA420P9LE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
- AV_PIX_FMT_YUVA422P9BE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
- AV_PIX_FMT_YUVA422P9LE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
- AV_PIX_FMT_YUVA444P9BE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
- AV_PIX_FMT_YUVA444P9LE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
- AV_PIX_FMT_YUVA420P10BE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
- AV_PIX_FMT_YUVA420P10LE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
- AV_PIX_FMT_YUVA422P10BE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
- AV_PIX_FMT_YUVA422P10LE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
- AV_PIX_FMT_YUVA444P10BE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
- AV_PIX_FMT_YUVA444P10LE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
- AV_PIX_FMT_YUVA420P16BE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
- AV_PIX_FMT_YUVA420P16LE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
- AV_PIX_FMT_YUVA422P16BE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
- AV_PIX_FMT_YUVA422P16LE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
- AV_PIX_FMT_YUVA444P16BE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
- AV_PIX_FMT_YUVA444P16LE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
-
- AV_PIX_FMT_VDPAU, ///< HW acceleration through VDPAU, Picture.data3 contains a VdpVideoSurface
-
- AV_PIX_FMT_XYZ12LE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0
- AV_PIX_FMT_XYZ12BE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0
- AV_PIX_FMT_NV16, ///< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
- AV_PIX_FMT_NV20LE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
- AV_PIX_FMT_NV20BE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
-
- AV_PIX_FMT_RGBA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
- AV_PIX_FMT_RGBA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
- AV_PIX_FMT_BGRA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
- AV_PIX_FMT_BGRA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
-
- AV_PIX_FMT_YVYU422, ///< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
-
- AV_PIX_FMT_YA16BE, ///< 16 bits gray, 16 bits alpha (big-endian)
- AV_PIX_FMT_YA16LE, ///< 16 bits gray, 16 bits alpha (little-endian)
-
- AV_PIX_FMT_GBRAP, ///< planar GBRA 4:4:4:4 32bpp
- AV_PIX_FMT_GBRAP16BE, ///< planar GBRA 4:4:4:4 64bpp, big-endian
- AV_PIX_FMT_GBRAP16LE, ///< planar GBRA 4:4:4:4 64bpp, little-endian
- /**
- * HW acceleration through QSV, data3 contains a pointer to the
- * mfxFrameSurface1 structure.
- */
- AV_PIX_FMT_QSV,
- /**
- * HW acceleration though MMAL, data3 contains a pointer to the
- * MMAL_BUFFER_HEADER_T structure.
- */
- AV_PIX_FMT_MMAL,
-
- AV_PIX_FMT_D3D11VA_VLD, ///< HW decoding through Direct3D11 via old API, Picture.data3 contains a ID3D11VideoDecoderOutputView pointer
-
- /**
- * HW acceleration through CUDA. datai contain CUdeviceptr pointers
- * exactly as for system memory frames.
- */
- AV_PIX_FMT_CUDA,
-
- AV_PIX_FMT_0RGB, ///< packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
- AV_PIX_FMT_RGB0, ///< packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
- AV_PIX_FMT_0BGR, ///< packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
- AV_PIX_FMT_BGR0, ///< packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
-
- AV_PIX_FMT_YUV420P12BE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
- AV_PIX_FMT_YUV420P12LE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
- AV_PIX_FMT_YUV420P14BE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
- AV_PIX_FMT_YUV420P14LE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
- AV_PIX_FMT_YUV422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
- AV_PIX_FMT_YUV422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
- AV_PIX_FMT_YUV422P14BE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
- AV_PIX_FMT_YUV422P14LE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
- AV_PIX_FMT_YUV444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
- AV_PIX_FMT_YUV444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
- AV_PIX_FMT_YUV444P14BE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
- AV_PIX_FMT_YUV444P14LE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
- AV_PIX_FMT_GBRP12BE, ///< planar GBR 4:4:4 36bpp, big-endian
- AV_PIX_FMT_GBRP12LE, ///< planar GBR 4:4:4 36bpp, little-endian
- AV_PIX_FMT_GBRP14BE, ///< planar GBR 4:4:4 42bpp, big-endian
- AV_PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian
- AV_PIX_FMT_YUVJ411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
-
- AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian */
- AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian */
- AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian */
- AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian */
-
- AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing
-
- AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
- AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
- AV_PIX_FMT_YUV440P12LE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
- AV_PIX_FMT_YUV440P12BE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
- AV_PIX_FMT_AYUV64LE, ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
- AV_PIX_FMT_AYUV64BE, ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
-
- AV_PIX_FMT_VIDEOTOOLBOX, ///< hardware decoding through Videotoolbox
-
- AV_PIX_FMT_P010LE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian
- AV_PIX_FMT_P010BE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
-
- AV_PIX_FMT_GBRAP12BE, ///< planar GBR 4:4:4:4 48bpp, big-endian
- AV_PIX_FMT_GBRAP12LE, ///< planar GBR 4:4:4:4 48bpp, little-endian
-
- AV_PIX_FMT_GBRAP10BE, ///< planar GBR 4:4:4:4 40bpp, big-endian
- AV_PIX_FMT_GBRAP10LE, ///< planar GBR 4:4:4:4 40bpp, little-endian
-
- AV_PIX_FMT_MEDIACODEC, ///< hardware decoding through MediaCodec
-
- AV_PIX_FMT_GRAY12BE, ///< Y , 12bpp, big-endian
- AV_PIX_FMT_GRAY12LE, ///< Y , 12bpp, little-endian
- AV_PIX_FMT_GRAY10BE, ///< Y , 10bpp, big-endian
- AV_PIX_FMT_GRAY10LE, ///< Y , 10bpp, little-endian
-
- AV_PIX_FMT_P016LE, ///< like NV12, with 16bpp per component, little-endian
- AV_PIX_FMT_P016BE, ///< like NV12, with 16bpp per component, big-endian
-
- /**
- * Hardware surfaces for Direct3D11.
- *
- * This is preferred over the legacy AV_PIX_FMT_D3D11VA_VLD. The new D3D11
- * hwaccel API and filtering support AV_PIX_FMT_D3D11 only.
- *
- * data0 contains a ID3D11Texture2D pointer, and data1 contains the
- * texture array index of the frame as intptr_t if the ID3D11Texture2D is
- * an array texture (or always 0 if it's a normal texture).
- */
- AV_PIX_FMT_D3D11,
-
- AV_PIX_FMT_GRAY9BE, ///< Y , 9bpp, big-endian
- AV_PIX_FMT_GRAY9LE, ///< Y , 9bpp, little-endian
-
- AV_PIX_FMT_GBRPF32BE, ///< IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian
- AV_PIX_FMT_GBRPF32LE, ///< IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian
- AV_PIX_FMT_GBRAPF32BE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian
- AV_PIX_FMT_GBRAPF32LE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian
-
- /**
- * DRM-managed buffers exposed through PRIME buffer sharing.
- *
- * data0 points to an AVDRMFrameDescriptor.
- */
- AV_PIX_FMT_DRM_PRIME,
- /**
- * Hardware surfaces for OpenCL.
- *
- * datai contain 2D image objects (typed in C as cl_mem, used
- * in OpenCL as image2d_t) for each plane of the surface.
- */
- AV_PIX_FMT_OPENCL,
-
- AV_PIX_FMT_NB ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
-};
-
-#if AV_HAVE_BIGENDIAN
-# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##be
-#else
-# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le
-#endif
-
-#define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA)
-#define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR)
-#define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA)
-#define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB)
-#define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0)
-#define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0)
-
-#define AV_PIX_FMT_GRAY9 AV_PIX_FMT_NE(GRAY9BE, GRAY9LE)
-#define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE)
-#define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE)
-#define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
-#define AV_PIX_FMT_YA16 AV_PIX_FMT_NE(YA16BE, YA16LE)
-#define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE)
-#define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE)
-#define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE)
-#define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE)
-#define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE)
-#define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE)
-#define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE)
-#define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE)
-#define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE)
-#define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE)
-
-#define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE)
-#define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE)
-#define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE)
-#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
-#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
-#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE)
-#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE)
-#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE)
-#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE)
-#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE)
-#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE)
-#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE)
-#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE)
-#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE)
-#define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE)
-#define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE)
-#define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE)
-
-#define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE)
-#define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE)
-#define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE)
-#define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE)
-#define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE)
-#define AV_PIX_FMT_GBRAP10 AV_PIX_FMT_NE(GBRAP10BE, GBRAP10LE)
-#define AV_PIX_FMT_GBRAP12 AV_PIX_FMT_NE(GBRAP12BE, GBRAP12LE)
-#define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE)
-
-#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE)
-#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE)
-#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE)
-#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE)
-
-#define AV_PIX_FMT_GBRPF32 AV_PIX_FMT_NE(GBRPF32BE, GBRPF32LE)
-#define AV_PIX_FMT_GBRAPF32 AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)
-
-#define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
-#define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
-#define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
-#define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE)
-#define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE)
-#define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE)
-#define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE)
-#define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE)
-#define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE)
-
-#define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE)
-#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE)
-#define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
-#define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE)
-#define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE)
-
-/**
- * Chromaticity coordinates of the source primaries.
- * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.1.
- */
-enum AVColorPrimaries {
- AVCOL_PRI_RESERVED0 = 0,
- AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
- AVCOL_PRI_UNSPECIFIED = 2,
- AVCOL_PRI_RESERVED = 3,
- AVCOL_PRI_BT470M = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
-
- AVCOL_PRI_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
- AVCOL_PRI_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
- AVCOL_PRI_SMPTE240M = 7, ///< functionally identical to above
- AVCOL_PRI_FILM = 8, ///< colour filters using Illuminant C
- AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020
- AVCOL_PRI_SMPTE428 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
- AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428,
- AVCOL_PRI_SMPTE431 = 11, ///< SMPTE ST 431-2 (2011) / DCI P3
- AVCOL_PRI_SMPTE432 = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3
- AVCOL_PRI_JEDEC_P22 = 22, ///< JEDEC P22 phosphors
- AVCOL_PRI_NB ///< Not part of ABI
-};
-
-/**
- * Color Transfer Characteristic.
- * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.2.
- */
-enum AVColorTransferCharacteristic {
- AVCOL_TRC_RESERVED0 = 0,
- AVCOL_TRC_BT709 = 1, ///< also ITU-R BT1361
- AVCOL_TRC_UNSPECIFIED = 2,
- AVCOL_TRC_RESERVED = 3,
- AVCOL_TRC_GAMMA22 = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
- AVCOL_TRC_GAMMA28 = 5, ///< also ITU-R BT470BG
- AVCOL_TRC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
- AVCOL_TRC_SMPTE240M = 7,
- AVCOL_TRC_LINEAR = 8, ///< "Linear transfer characteristics"
- AVCOL_TRC_LOG = 9, ///< "Logarithmic transfer characteristic (100:1 range)"
- AVCOL_TRC_LOG_SQRT = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
- AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4
- AVCOL_TRC_BT1361_ECG = 12, ///< ITU-R BT1361 Extended Colour Gamut
- AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC)
- AVCOL_TRC_BT2020_10 = 14, ///< ITU-R BT2020 for 10-bit system
- AVCOL_TRC_BT2020_12 = 15, ///< ITU-R BT2020 for 12-bit system
- AVCOL_TRC_SMPTE2084 = 16, ///< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems
- AVCOL_TRC_SMPTEST2084 = AVCOL_TRC_SMPTE2084,
- AVCOL_TRC_SMPTE428 = 17, ///< SMPTE ST 428-1
- AVCOL_TRC_SMPTEST428_1 = AVCOL_TRC_SMPTE428,
- AVCOL_TRC_ARIB_STD_B67 = 18, ///< ARIB STD-B67, known as "Hybrid log-gamma"
- AVCOL_TRC_NB ///< Not part of ABI
-};
-
-/**
- * YUV colorspace type.
- * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.3.
- */
-enum AVColorSpace {
- AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
- AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
- AVCOL_SPC_UNSPECIFIED = 2,
- AVCOL_SPC_RESERVED = 3,
- AVCOL_SPC_FCC = 4, ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
- AVCOL_SPC_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
- AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
- AVCOL_SPC_SMPTE240M = 7, ///< functionally identical to above
- AVCOL_SPC_YCGCO = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
- AVCOL_SPC_YCOCG = AVCOL_SPC_YCGCO,
- AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system
- AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system
- AVCOL_SPC_SMPTE2085 = 11, ///< SMPTE 2085, Y'D'zD'x
- AVCOL_SPC_CHROMA_DERIVED_NCL = 12, ///< Chromaticity-derived non-constant luminance system
- AVCOL_SPC_CHROMA_DERIVED_CL = 13, ///< Chromaticity-derived constant luminance system
- AVCOL_SPC_ICTCP = 14, ///< ITU-R BT.2100-0, ICtCp
- AVCOL_SPC_NB ///< Not part of ABI
-};
-
-/**
- * MPEG vs JPEG YUV range.
- */
-enum AVColorRange {
- AVCOL_RANGE_UNSPECIFIED = 0,
- AVCOL_RANGE_MPEG = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
- AVCOL_RANGE_JPEG = 2, ///< the normal 2^n-1 "JPEG" YUV ranges
- AVCOL_RANGE_NB ///< Not part of ABI
-};
-
-/**
- * Location of chroma samples.
- *
- * Illustration showing the location of the first (top left) chroma sample of the
- * image, the left shows only luma, the right
- * shows the location of the chroma sample, the 2 could be imagined to overlay
- * each other but are drawn separately due to limitations of ASCII
- *
- * 1st 2nd 1st 2nd horizontal luma sample positions
- * v v v v
- * ______ ______
- *1st luma line > |X X ... |3 4 X ... X are luma samples,
- * | |1 2 1-6 are possible chroma positions
- *2nd luma line > |X X ... |5 6 X ... 0 is undefined/unknown position
- */
-enum AVChromaLocation {
- AVCHROMA_LOC_UNSPECIFIED = 0,
- AVCHROMA_LOC_LEFT = 1, ///< MPEG-2/4 4:2:0, H.264 default for 4:2:0
- AVCHROMA_LOC_CENTER = 2, ///< MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0
- AVCHROMA_LOC_TOPLEFT = 3, ///< ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2
- AVCHROMA_LOC_TOP = 4,
- AVCHROMA_LOC_BOTTOMLEFT = 5,
- AVCHROMA_LOC_BOTTOM = 6,
- AVCHROMA_LOC_NB ///< Not part of ABI
-};
-
-#endif /* AVUTIL_PIXFMT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/random_seed.h Deleted

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2009 Baptiste Coudurier <baptiste.coudurier@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_RANDOM_SEED_H
-#define AVUTIL_RANDOM_SEED_H
-
-#include <stdint.h>
-/**
- * @addtogroup lavu_crypto
- * @{
- */
-
-/**
- * Get a seed to use in conjunction with random functions.
- * This function tries to provide a good seed at a best effort bases.
- * Its possible to call this function multiple times if more bits are needed.
- * It can be quite slow, which is why it should only be used as seed for a faster
- * PRNG. The quality of the seed depends on the platform.
- */
-uint32_t av_get_random_seed(void);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_RANDOM_SEED_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/rational.h Deleted

@@ -1,214 +0,0 @@
-/*
- * rational numbers
- * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_math_rational
- * Utilties for rational number calculation.
- * @author Michael Niedermayer <michaelni@gmx.at>
- */
-
-#ifndef AVUTIL_RATIONAL_H
-#define AVUTIL_RATIONAL_H
-
-#include <stdint.h>
-#include <limits.h>
-#include "attributes.h"
-
-/**
- * @defgroup lavu_math_rational AVRational
- * @ingroup lavu_math
- * Rational number calculation.
- *
- * While rational numbers can be expressed as floating-point numbers, the
- * conversion process is a lossy one, so are floating-point operations. On the
- * other hand, the nature of FFmpeg demands highly accurate calculation of
- * timestamps. This set of rational number utilities serves as a generic
- * interface for manipulating rational numbers as pairs of numerators and
- * denominators.
- *
- * Many of the functions that operate on AVRational's have the suffix `_q`, in
- * reference to the mathematical symbol "ℚ" (Q) which denotes the set of all
- * rational numbers.
- *
- * @{
- */
-
-/**
- * Rational number (pair of numerator and denominator).
- */
-typedef struct AVRational{
- int num; ///< Numerator
- int den; ///< Denominator
-} AVRational;
-
-/**
- * Create an AVRational.
- *
- * Useful for compilers that do not support compound literals.
- *
- * @note The return value is not reduced.
- * @see av_reduce()
- */
-static inline AVRational av_make_q(int num, int den)
-{
- AVRational r = { num, den };
- return r;
-}
-
-/**
- * Compare two rationals.
- *
- * @param a First rational
- * @param b Second rational
- *
- * @return One of the following values:
- * - 0 if `a == b`
- * - 1 if `a > b`
- * - -1 if `a < b`
- * - `INT_MIN` if one of the values is of the form `0 / 0`
- */
-static inline int av_cmp_q(AVRational a, AVRational b){
- const int64_t tmp= a.num * (int64_t)b.den - b.num * (int64_t)a.den;
-
- if(tmp) return (int)((tmp ^ a.den ^ b.den)>>63)|1;
- else if(b.den && a.den) return 0;
- else if(a.num && b.num) return (a.num>>31) - (b.num>>31);
- else return INT_MIN;
-}
-
-/**
- * Convert an AVRational to a `double`.
- * @param a AVRational to convert
- * @return `a` in floating-point form
- * @see av_d2q()
- */
-static inline double av_q2d(AVRational a){
- return a.num / (double) a.den;
-}
-
-/**
- * Reduce a fraction.
- *
- * This is useful for framerate calculations.
- *
- * @paramout dst_num Destination numerator
- * @paramout dst_den Destination denominator
- * @paramin num Source numerator
- * @paramin den Source denominator
- * @paramin max Maximum allowed values for `dst_num` & `dst_den`
- * @return 1 if the operation is exact, 0 otherwise
- */
-int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max);
-
-/**
- * Multiply two rationals.
- * @param b First rational
- * @param c Second rational
- * @return b*c
- */
-AVRational av_mul_q(AVRational b, AVRational c) av_const;
-
-/**
- * Divide one rational by another.
- * @param b First rational
- * @param c Second rational
- * @return b/c
- */
-AVRational av_div_q(AVRational b, AVRational c) av_const;
-
-/**
- * Add two rationals.
- * @param b First rational
- * @param c Second rational
- * @return b+c
- */
-AVRational av_add_q(AVRational b, AVRational c) av_const;
-
-/**
- * Subtract one rational from another.
- * @param b First rational
- * @param c Second rational
- * @return b-c
- */
-AVRational av_sub_q(AVRational b, AVRational c) av_const;
-
-/**
- * Invert a rational.
- * @param q value
- * @return 1 / q
- */
-static av_always_inline AVRational av_inv_q(AVRational q)
-{
- AVRational r = { q.den, q.num };
- return r;
-}
-
-/**
- * Convert a double precision floating point number to a rational.
- *
- * In case of infinity, the returned value is expressed as `{1, 0}` or
- * `{-1, 0}` depending on the sign.
- *
- * @param d `double` to convert
- * @param max Maximum allowed numerator and denominator
- * @return `d` in AVRational form
- * @see av_q2d()
- */
-AVRational av_d2q(double d, int max) av_const;
-
-/**
- * Find which of the two rationals is closer to another rational.
- *
- * @param q Rational to be compared against
- * @param q1,q2 Rationals to be tested
- * @return One of the following values:
- * - 1 if `q1` is nearer to `q` than `q2`
- * - -1 if `q2` is nearer to `q` than `q1`
- * - 0 if they have the same distance
- */
-int av_nearer_q(AVRational q, AVRational q1, AVRational q2);
-
-/**
- * Find the value in a list of rationals nearest a given reference rational.
- *
- * @param q Reference rational
- * @param q_list Array of rationals terminated by `{0, 0}`
- * @return Index of the nearest value found in the array
- */
-int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);
-
-/**
- * Convert an AVRational to a IEEE 32-bit `float` expressed in fixed-point
- * format.
- *
- * @param q Rational to be converted
- * @return Equivalent floating-point value, expressed as an unsigned 32-bit
- * integer.
- * @note The returned value is platform-indepedant.
- */
-uint32_t av_q2intfloat(AVRational q);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_RATIONAL_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/rc4.h Deleted

@@ -1,66 +0,0 @@
-/*
- * RC4 encryption/decryption/pseudo-random number generator
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_RC4_H
-#define AVUTIL_RC4_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_rc4 RC4
- * @ingroup lavu_crypto
- * @{
- */
-
-typedef struct AVRC4 {
- uint8_t state256;
- int x, y;
-} AVRC4;
-
-/**
- * Allocate an AVRC4 context.
- */
-AVRC4 *av_rc4_alloc(void);
-
-/**
- * @brief Initializes an AVRC4 context.
- *
- * @param key_bits must be a multiple of 8
- * @param decrypt 0 for encryption, 1 for decryption, currently has no effect
- * @return zero on success, negative value otherwise
- */
-int av_rc4_init(struct AVRC4 *d, const uint8_t *key, int key_bits, int decrypt);
-
-/**
- * @brief Encrypts / decrypts using the RC4 algorithm.
- *
- * @param count number of bytes
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst, may be NULL
- * @param iv not (yet) used for RC4, should be NULL
- * @param decrypt 0 for encryption, 1 for decryption, not (yet) used
- */
-void av_rc4_crypt(struct AVRC4 *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_RC4_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/replaygain.h Deleted

@@ -1,50 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_REPLAYGAIN_H
-#define AVUTIL_REPLAYGAIN_H
-
-#include <stdint.h>
-
-/**
- * ReplayGain information (see
- * http://wiki.hydrogenaudio.org/index.php?title=ReplayGain_1.0_specification).
- * The size of this struct is a part of the public ABI.
- */
-typedef struct AVReplayGain {
- /**
- * Track replay gain in microbels (divide by 100000 to get the value in dB).
- * Should be set to INT32_MIN when unknown.
- */
- int32_t track_gain;
- /**
- * Peak track amplitude, with 100000 representing full scale (but values
- * may overflow). 0 when unknown.
- */
- uint32_t track_peak;
- /**
- * Same as track_gain, but for the whole album.
- */
- int32_t album_gain;
- /**
- * Same as track_peak, but for the whole album,
- */
- uint32_t album_peak;
-} AVReplayGain;
-
-#endif /* AVUTIL_REPLAYGAIN_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/ripemd.h Deleted

@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
- * Copyright (C) 2013 James Almer <jamrial@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_ripemd
- * Public header for RIPEMD hash function implementation.
- */
-
-#ifndef AVUTIL_RIPEMD_H
-#define AVUTIL_RIPEMD_H
-
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_ripemd RIPEMD
- * @ingroup lavu_hash
- * RIPEMD hash function implementation.
- *
- * @{
- */
-
-extern const int av_ripemd_size;
-
-struct AVRIPEMD;
-
-/**
- * Allocate an AVRIPEMD context.
- */
-struct AVRIPEMD *av_ripemd_alloc(void);
-
-/**
- * Initialize RIPEMD hashing.
- *
- * @param context pointer to the function context (of size av_ripemd_size)
- * @param bits number of bits in digest (128, 160, 256 or 320 bits)
- * @return zero if initialization succeeded, -1 otherwise
- */
-int av_ripemd_init(struct AVRIPEMD* context, int bits);
-
-/**
- * Update hash value.
- *
- * @param context hash function context
- * @param data input data to update hash with
- * @param len input data length
- */
-#if FF_API_CRYPTO_SIZE_T
-void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, unsigned int len);
-#else
-void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, size_t len);
-#endif
-
-/**
- * Finish hashing and output digest value.
- *
- * @param context hash function context
- * @param digest buffer where output digest value is stored
- */
-void av_ripemd_final(struct AVRIPEMD* context, uint8_t *digest);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_RIPEMD_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/samplefmt.h Deleted

@@ -1,272 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_SAMPLEFMT_H
-#define AVUTIL_SAMPLEFMT_H
-
-#include <stdint.h>
-
-#include "avutil.h"
-#include "attributes.h"
-
-/**
- * @addtogroup lavu_audio
- * @{
- *
- * @defgroup lavu_sampfmts Audio sample formats
- *
- * Audio sample format enumeration and related convenience functions.
- * @{
- */
-
-/**
- * Audio sample formats
- *
- * - The data described by the sample format is always in native-endian order.
- * Sample values can be expressed by native C types, hence the lack of a signed
- * 24-bit sample format even though it is a common raw audio data format.
- *
- * - The floating-point formats are based on full volume being in the range
- * -1.0, 1.0. Any values outside this range are beyond full volume level.
- *
- * - The data layout as used in av_samples_fill_arrays() and elsewhere in FFmpeg
- * (such as AVFrame in libavcodec) is as follows:
- *
- * @par
- * For planar sample formats, each audio channel is in a separate data plane,
- * and linesize is the buffer size, in bytes, for a single plane. All data
- * planes must be the same size. For packed sample formats, only the first data
- * plane is used, and samples for each channel are interleaved. In this case,
- * linesize is the buffer size, in bytes, for the 1 plane.
- *
- */
-enum AVSampleFormat {
- AV_SAMPLE_FMT_NONE = -1,
- AV_SAMPLE_FMT_U8, ///< unsigned 8 bits
- AV_SAMPLE_FMT_S16, ///< signed 16 bits
- AV_SAMPLE_FMT_S32, ///< signed 32 bits
- AV_SAMPLE_FMT_FLT, ///< float
- AV_SAMPLE_FMT_DBL, ///< double
-
- AV_SAMPLE_FMT_U8P, ///< unsigned 8 bits, planar
- AV_SAMPLE_FMT_S16P, ///< signed 16 bits, planar
- AV_SAMPLE_FMT_S32P, ///< signed 32 bits, planar
- AV_SAMPLE_FMT_FLTP, ///< float, planar
- AV_SAMPLE_FMT_DBLP, ///< double, planar
- AV_SAMPLE_FMT_S64, ///< signed 64 bits
- AV_SAMPLE_FMT_S64P, ///< signed 64 bits, planar
-
- AV_SAMPLE_FMT_NB ///< Number of sample formats. DO NOT USE if linking dynamically
-};
-
-/**
- * Return the name of sample_fmt, or NULL if sample_fmt is not
- * recognized.
- */
-const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt);
-
-/**
- * Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE
- * on error.
- */
-enum AVSampleFormat av_get_sample_fmt(const char *name);
-
-/**
- * Return the planar<->packed alternative form of the given sample format, or
- * AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the
- * requested planar/packed format, the format returned is the same as the
- * input.
- */
-enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar);
-
-/**
- * Get the packed alternative form of the given sample format.
- *
- * If the passed sample_fmt is already in packed format, the format returned is
- * the same as the input.
- *
- * @return the packed alternative form of the given sample format or
- AV_SAMPLE_FMT_NONE on error.
- */
-enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt);
-
-/**
- * Get the planar alternative form of the given sample format.
- *
- * If the passed sample_fmt is already in planar format, the format returned is
- * the same as the input.
- *
- * @return the planar alternative form of the given sample format or
- AV_SAMPLE_FMT_NONE on error.
- */
-enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt);
-
-/**
- * Generate a string corresponding to the sample format with
- * sample_fmt, or a header if sample_fmt is negative.
- *
- * @param buf the buffer where to write the string
- * @param buf_size the size of buf
- * @param sample_fmt the number of the sample format to print the
- * corresponding info string, or a negative value to print the
- * corresponding header.
- * @return the pointer to the filled buffer or NULL if sample_fmt is
- * unknown or in case of other errors
- */
-char *av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt);
-
-/**
- * Return number of bytes per sample.
- *
- * @param sample_fmt the sample format
- * @return number of bytes per sample or zero if unknown for the given
- * sample format
- */
-int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt);
-
-/**
- * Check if the sample format is planar.
- *
- * @param sample_fmt the sample format to inspect
- * @return 1 if the sample format is planar, 0 if it is interleaved
- */
-int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt);
-
-/**
- * Get the required buffer size for the given audio parameters.
- *
- * @paramout linesize calculated linesize, may be NULL
- * @param nb_channels the number of channels
- * @param nb_samples the number of samples in a single channel
- * @param sample_fmt the sample format
- * @param align buffer size alignment (0 = default, 1 = no alignment)
- * @return required buffer size, or negative error code on failure
- */
-int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
- enum AVSampleFormat sample_fmt, int align);
-
-/**
- * @}
- *
- * @defgroup lavu_sampmanip Samples manipulation
- *
- * Functions that manipulate audio samples
- * @{
- */
-
-/**
- * Fill plane data pointers and linesize for samples with sample
- * format sample_fmt.
- *
- * The audio_data array is filled with the pointers to the samples data planes:
- * for planar, set the start point of each channel's data within the buffer,
- * for packed, set the start point of the entire buffer only.
- *
- * The value pointed to by linesize is set to the aligned size of each
- * channel's data buffer for planar layout, or to the aligned size of the
- * buffer for all channels for packed layout.
- *
- * The buffer in buf must be big enough to contain all the samples
- * (use av_samples_get_buffer_size() to compute its minimum size),
- * otherwise the audio_data pointers will point to invalid data.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @paramout audio_data array to be filled with the pointer for each channel
- * @paramout linesize calculated linesize, may be NULL
- * @param buf the pointer to a buffer containing the samples
- * @param nb_channels the number of channels
- * @param nb_samples the number of samples in a single channel
- * @param sample_fmt the sample format
- * @param align buffer size alignment (0 = default, 1 = no alignment)
- * @return >=0 on success or a negative error code on failure
- * @todo return minimum size in bytes required for the buffer in case
- * of success at the next bump
- */
-int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
- const uint8_t *buf,
- int nb_channels, int nb_samples,
- enum AVSampleFormat sample_fmt, int align);
-
-/**
- * Allocate a samples buffer for nb_samples samples, and fill data pointers and
- * linesize accordingly.
- * The allocated samples buffer can be freed by using av_freep(&audio_data0)
- * Allocated data will be initialized to silence.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @paramout audio_data array to be filled with the pointer for each channel
- * @paramout linesize aligned size for audio buffer(s), may be NULL
- * @param nb_channels number of audio channels
- * @param nb_samples number of samples per channel
- * @param align buffer size alignment (0 = default, 1 = no alignment)
- * @return >=0 on success or a negative error code on failure
- * @todo return the size of the allocated buffer in case of success at the next bump
- * @see av_samples_fill_arrays()
- * @see av_samples_alloc_array_and_samples()
- */
-int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
- int nb_samples, enum AVSampleFormat sample_fmt, int align);
-
-/**
- * Allocate a data pointers array, samples buffer for nb_samples
- * samples, and fill data pointers and linesize accordingly.
- *
- * This is the same as av_samples_alloc(), but also allocates the data
- * pointers array.
- *
- * @see av_samples_alloc()
- */
-int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels,
- int nb_samples, enum AVSampleFormat sample_fmt, int align);
-
-/**
- * Copy samples from src to dst.
- *
- * @param dst destination array of pointers to data planes
- * @param src source array of pointers to data planes
- * @param dst_offset offset in samples at which the data will be written to dst
- * @param src_offset offset in samples at which the data will be read from src
- * @param nb_samples number of samples to be copied
- * @param nb_channels number of audio channels
- * @param sample_fmt audio sample format
- */
-int av_samples_copy(uint8_t **dst, uint8_t * const *src, int dst_offset,
- int src_offset, int nb_samples, int nb_channels,
- enum AVSampleFormat sample_fmt);
-
-/**
- * Fill an audio buffer with silence.
- *
- * @param audio_data array of pointers to data planes
- * @param offset offset in samples at which to start filling
- * @param nb_samples number of samples to fill
- * @param nb_channels number of audio channels
- * @param sample_fmt audio sample format
- */
-int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples,
- int nb_channels, enum AVSampleFormat sample_fmt);
-
-/**
- * @}
- * @}
- */
-#endif /* AVUTIL_SAMPLEFMT_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/sha.h Deleted

@@ -1,95 +0,0 @@
-/*
- * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_sha
- * Public header for SHA-1 & SHA-256 hash function implementations.
- */
-
-#ifndef AVUTIL_SHA_H
-#define AVUTIL_SHA_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_sha SHA
- * @ingroup lavu_hash
- * SHA-1 and SHA-256 (Secure Hash Algorithm) hash function implementations.
- *
- * This module supports the following SHA hash functions:
- *
- * - SHA-1: 160 bits
- * - SHA-224: 224 bits, as a variant of SHA-2
- * - SHA-256: 256 bits, as a variant of SHA-2
- *
- * @see For SHA-384, SHA-512, and variants thereof, see @ref lavu_sha512.
- *
- * @{
- */
-
-extern const int av_sha_size;
-
-struct AVSHA;
-
-/**
- * Allocate an AVSHA context.
- */
-struct AVSHA *av_sha_alloc(void);
-
-/**
- * Initialize SHA-1 or SHA-2 hashing.
- *
- * @param context pointer to the function context (of size av_sha_size)
- * @param bits number of bits in digest (SHA-1 - 160 bits, SHA-2 224 or 256 bits)
- * @return zero if initialization succeeded, -1 otherwise
- */
-int av_sha_init(struct AVSHA* context, int bits);
-
-/**
- * Update hash value.
- *
- * @param ctx hash function context
- * @param data input data to update hash with
- * @param len input data length
- */
-#if FF_API_CRYPTO_SIZE_T
-void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len);
-#else
-void av_sha_update(struct AVSHA *ctx, const uint8_t *data, size_t len);
-#endif
-
-/**
- * Finish hashing and output digest value.
- *
- * @param context hash function context
- * @param digest buffer where output digest value is stored
- */
-void av_sha_final(struct AVSHA* context, uint8_t *digest);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_SHA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/sha512.h Deleted

@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
- * Copyright (C) 2013 James Almer <jamrial@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_sha512
- * Public header for SHA-512 implementation.
- */
-
-#ifndef AVUTIL_SHA512_H
-#define AVUTIL_SHA512_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_sha512 SHA-512
- * @ingroup lavu_hash
- * SHA-512 (Secure Hash Algorithm) hash function implementations.
- *
- * This module supports the following SHA-2 hash functions:
- *
- * - SHA-512/224: 224 bits
- * - SHA-512/256: 256 bits
- * - SHA-384: 384 bits
- * - SHA-512: 512 bits
- *
- * @see For SHA-1, SHA-256, and variants thereof, see @ref lavu_sha.
- *
- * @{
- */
-
-extern const int av_sha512_size;
-
-struct AVSHA512;
-
-/**
- * Allocate an AVSHA512 context.
- */
-struct AVSHA512 *av_sha512_alloc(void);
-
-/**
- * Initialize SHA-2 512 hashing.
- *
- * @param context pointer to the function context (of size av_sha512_size)
- * @param bits number of bits in digest (224, 256, 384 or 512 bits)
- * @return zero if initialization succeeded, -1 otherwise
- */
-int av_sha512_init(struct AVSHA512* context, int bits);
-
-/**
- * Update hash value.
- *
- * @param context hash function context
- * @param data input data to update hash with
- * @param len input data length
- */
-#if FF_API_CRYPTO_SIZE_T
-void av_sha512_update(struct AVSHA512* context, const uint8_t* data, unsigned int len);
-#else
-void av_sha512_update(struct AVSHA512* context, const uint8_t* data, size_t len);
-#endif
-
-/**
- * Finish hashing and output digest value.
- *
- * @param context hash function context
- * @param digest buffer where output digest value is stored
- */
-void av_sha512_final(struct AVSHA512* context, uint8_t *digest);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_SHA512_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/spherical.h Deleted

@@ -1,232 +0,0 @@
-/*
- * Copyright (c) 2016 Vittorio Giovara <vittorio.giovara@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Spherical video
- */
-
-#ifndef AVUTIL_SPHERICAL_H
-#define AVUTIL_SPHERICAL_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-/**
- * @addtogroup lavu_video
- * @{
- *
- * @defgroup lavu_video_spherical Spherical video mapping
- * @{
- */
-
-/**
- * @addtogroup lavu_video_spherical
- * A spherical video file contains surfaces that need to be mapped onto a
- * sphere. Depending on how the frame was converted, a different distortion
- * transformation or surface recomposition function needs to be applied before
- * the video should be mapped and displayed.
- */
-
-/**
- * Projection of the video surface(s) on a sphere.
- */
-enum AVSphericalProjection {
- /**
- * Video represents a sphere mapped on a flat surface using
- * equirectangular projection.
- */
- AV_SPHERICAL_EQUIRECTANGULAR,
-
- /**
- * Video frame is split into 6 faces of a cube, and arranged on a
- * 3x2 layout. Faces are oriented upwards for the front, left, right,
- * and back faces. The up face is oriented so the top of the face is
- * forwards and the down face is oriented so the top of the face is
- * to the back.
- */
- AV_SPHERICAL_CUBEMAP,
-
- /**
- * Video represents a portion of a sphere mapped on a flat surface
- * using equirectangular projection. The @ref bounding fields indicate
- * the position of the current video in a larger surface.
- */
- AV_SPHERICAL_EQUIRECTANGULAR_TILE,
-};
-
-/**
- * This structure describes how to handle spherical videos, outlining
- * information about projection, initial layout, and any other view modifier.
- *
- * @note The struct must be allocated with av_spherical_alloc() and
- * its size is not a part of the public ABI.
- */
-typedef struct AVSphericalMapping {
- /**
- * Projection type.
- */
- enum AVSphericalProjection projection;
-
- /**
- * @name Initial orientation
- * @{
- * There fields describe additional rotations applied to the sphere after
- * the video frame is mapped onto it. The sphere is rotated around the
- * viewer, who remains stationary. The order of transformation is always
- * yaw, followed by pitch, and finally by roll.
- *
- * The coordinate system matches the one defined in OpenGL, where the
- * forward vector (z) is coming out of screen, and it is equivalent to
- * a rotation matrix of R = r_y(yaw) * r_x(pitch) * r_z(roll).
- *
- * A positive yaw rotates the portion of the sphere in front of the viewer
- * toward their right. A positive pitch rotates the portion of the sphere
- * in front of the viewer upwards. A positive roll tilts the portion of
- * the sphere in front of the viewer to the viewer's right.
- *
- * These values are exported as 16.16 fixed point.
- *
- * See this equirectangular projection as example:
- *
- * @code{.unparsed}
- * Yaw
- * -180 0 180
- * 90 +-------------+-------------+ 180
- * | | | up
- * P | | | y| forward
- * i | ^ | | /z
- * t 0 +-------------X-------------+ 0 Roll | /
- * c | | | | /
- * h | | | 0|/_____right
- * | | | x
- * -90 +-------------+-------------+ -180
- *
- * X - the default camera center
- * ^ - the default up vector
- * @endcode
- */
- int32_t yaw; ///< Rotation around the up vector -180, 180.
- int32_t pitch; ///< Rotation around the right vector -90, 90.
- int32_t roll; ///< Rotation around the forward vector -180, 180.
- /**
- * @}
- */
-
- /**
- * @name Bounding rectangle
- * @anchor bounding
- * @{
- * These fields indicate the location of the current tile, and where
- * it should be mapped relative to the original surface. They are
- * exported as 0.32 fixed point, and can be converted to classic
- * pixel values with av_spherical_bounds().
- *
- * @code{.unparsed}
- * +----------------+----------+
- * | |bound_top |
- * | +--------+ |
- * | bound_left |tile | |
- * +<---------->| |<--->+bound_right
- * | +--------+ |
- * | | |
- * | bound_bottom| |
- * +----------------+----------+
- * @endcode
- *
- * If needed, the original video surface dimensions can be derived
- * by adding the current stream or frame size to the related bounds,
- * like in the following example:
- *
- * @code{c}
- * original_width = tile->width + bound_left + bound_right;
- * original_height = tile->height + bound_top + bound_bottom;
- * @endcode
- *
- * @note These values are valid only for the tiled equirectangular
- * projection type (@ref AV_SPHERICAL_EQUIRECTANGULAR_TILE),
- * and should be ignored in all other cases.
- */
- uint32_t bound_left; ///< Distance from the left edge
- uint32_t bound_top; ///< Distance from the top edge
- uint32_t bound_right; ///< Distance from the right edge
- uint32_t bound_bottom; ///< Distance from the bottom edge
- /**
- * @}
- */
-
- /**
- * Number of pixels to pad from the edge of each cube face.
- *
- * @note This value is valid for only for the cubemap projection type
- * (@ref AV_SPHERICAL_CUBEMAP), and should be ignored in all other
- * cases.
- */
- uint32_t padding;
-} AVSphericalMapping;
-
-/**
- * Allocate a AVSphericalVideo structure and initialize its fields to default
- * values.
- *
- * @return the newly allocated struct or NULL on failure
- */
-AVSphericalMapping *av_spherical_alloc(size_t *size);
-
-/**
- * Convert the @ref bounding fields from an AVSphericalVideo
- * from 0.32 fixed point to pixels.
- *
- * @param map The AVSphericalVideo map to read bound values from.
- * @param width Width of the current frame or stream.
- * @param height Height of the current frame or stream.
- * @param left Pixels from the left edge.
- * @param top Pixels from the top edge.
- * @param right Pixels from the right edge.
- * @param bottom Pixels from the bottom edge.
- */
-void av_spherical_tile_bounds(const AVSphericalMapping *map,
- size_t width, size_t height,
- size_t *left, size_t *top,
- size_t *right, size_t *bottom);
-
-/**
- * Provide a human-readable name of a given AVSphericalProjection.
- *
- * @param projection The input AVSphericalProjection.
- *
- * @return The name of the AVSphericalProjection, or "unknown".
- */
-const char *av_spherical_projection_name(enum AVSphericalProjection projection);
-
-/**
- * Get the AVSphericalProjection form a human-readable name.
- *
- * @param name The input string.
- *
- * @return The AVSphericalProjection value, or -1 if not found.
- */
-int av_spherical_from_name(const char *name);
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_SPHERICAL_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/stereo3d.h Deleted

@@ -1,233 +0,0 @@
-/*
- * Copyright (c) 2013 Vittorio Giovara <vittorio.giovara@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Stereoscopic video
- */
-
-#ifndef AVUTIL_STEREO3D_H
-#define AVUTIL_STEREO3D_H
-
-#include <stdint.h>
-
-#include "frame.h"
-
-/**
- * @addtogroup lavu_video
- * @{
- *
- * @defgroup lavu_video_stereo3d Stereo3D types and functions
- * @{
- */
-
-/**
- * @addtogroup lavu_video_stereo3d
- * A stereoscopic video file consists in multiple views embedded in a single
- * frame, usually describing two views of a scene. This file describes all
- * possible codec-independent view arrangements.
- * */
-
-/**
- * List of possible 3D Types
- */
-enum AVStereo3DType {
- /**
- * Video is not stereoscopic (and metadata has to be there).
- */
- AV_STEREO3D_2D,
-
- /**
- * Views are next to each other.
- *
- * @code{.unparsed}
- * LLLLRRRR
- * LLLLRRRR
- * LLLLRRRR
- * ...
- * @endcode
- */
- AV_STEREO3D_SIDEBYSIDE,
-
- /**
- * Views are on top of each other.
- *
- * @code{.unparsed}
- * LLLLLLLL
- * LLLLLLLL
- * RRRRRRRR
- * RRRRRRRR
- * @endcode
- */
- AV_STEREO3D_TOPBOTTOM,
-
- /**
- * Views are alternated temporally.
- *
- * @code{.unparsed}
- * frame0 frame1 frame2 ...
- * LLLLLLLL RRRRRRRR LLLLLLLL
- * LLLLLLLL RRRRRRRR LLLLLLLL
- * LLLLLLLL RRRRRRRR LLLLLLLL
- * ... ... ...
- * @endcode
- */
- AV_STEREO3D_FRAMESEQUENCE,
-
- /**
- * Views are packed in a checkerboard-like structure per pixel.
- *
- * @code{.unparsed}
- * LRLRLRLR
- * RLRLRLRL
- * LRLRLRLR
- * ...
- * @endcode
- */
- AV_STEREO3D_CHECKERBOARD,
-
- /**
- * Views are next to each other, but when upscaling
- * apply a checkerboard pattern.
- *
- * @code{.unparsed}
- * LLLLRRRR L L L L R R R R
- * LLLLRRRR => L L L L R R R R
- * LLLLRRRR L L L L R R R R
- * LLLLRRRR L L L L R R R R
- * @endcode
- */
- AV_STEREO3D_SIDEBYSIDE_QUINCUNX,
-
- /**
- * Views are packed per line, as if interlaced.
- *
- * @code{.unparsed}
- * LLLLLLLL
- * RRRRRRRR
- * LLLLLLLL
- * ...
- * @endcode
- */
- AV_STEREO3D_LINES,
-
- /**
- * Views are packed per column.
- *
- * @code{.unparsed}
- * LRLRLRLR
- * LRLRLRLR
- * LRLRLRLR
- * ...
- * @endcode
- */
- AV_STEREO3D_COLUMNS,
-};
-
-/**
- * List of possible view types.
- */
-enum AVStereo3DView {
- /**
- * Frame contains two packed views.
- */
- AV_STEREO3D_VIEW_PACKED,
-
- /**
- * Frame contains only the left view.
- */
- AV_STEREO3D_VIEW_LEFT,
-
- /**
- * Frame contains only the right view.
- */
- AV_STEREO3D_VIEW_RIGHT,
-};
-
-/**
- * Inverted views, Right/Bottom represents the left view.
- */
-#define AV_STEREO3D_FLAG_INVERT (1 << 0)
-
-/**
- * Stereo 3D type: this structure describes how two videos are packed
- * within a single video surface, with additional information as needed.
- *
- * @note The struct must be allocated with av_stereo3d_alloc() and
- * its size is not a part of the public ABI.
- */
-typedef struct AVStereo3D {
- /**
- * How views are packed within the video.
- */
- enum AVStereo3DType type;
-
- /**
- * Additional information about the frame packing.
- */
- int flags;
-
- /**
- * Determines which views are packed.
- */
- enum AVStereo3DView view;
-} AVStereo3D;
-
-/**
- * Allocate an AVStereo3D structure and set its fields to default values.
- * The resulting struct can be freed using av_freep().
- *
- * @return An AVStereo3D filled with default values or NULL on failure.
- */
-AVStereo3D *av_stereo3d_alloc(void);
-
-/**
- * Allocate a complete AVFrameSideData and add it to the frame.
- *
- * @param frame The frame which side data is added to.
- *
- * @return The AVStereo3D structure to be filled by caller.
- */
-AVStereo3D *av_stereo3d_create_side_data(AVFrame *frame);
-
-/**
- * Provide a human-readable name of a given stereo3d type.
- *
- * @param type The input stereo3d type value.
- *
- * @return The name of the stereo3d value, or "unknown".
- */
-const char *av_stereo3d_type_name(unsigned int type);
-
-/**
- * Get the AVStereo3DType form a human-readable name.
- *
- * @param name The input string.
- *
- * @return The AVStereo3DType value, or -1 if not found.
- */
-int av_stereo3d_from_name(const char *name);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_STEREO3D_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/tea.h Deleted

@@ -1,71 +0,0 @@
-/*
- * A 32-bit implementation of the TEA algorithm
- * Copyright (c) 2015 Vesselin Bontchev
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_TEA_H
-#define AVUTIL_TEA_H
-
-#include <stdint.h>
-
-/**
- * @file
- * @brief Public header for libavutil TEA algorithm
- * @defgroup lavu_tea TEA
- * @ingroup lavu_crypto
- * @{
- */
-
-extern const int av_tea_size;
-
-struct AVTEA;
-
-/**
- * Allocate an AVTEA context
- * To free the struct: av_free(ptr)
- */
-struct AVTEA *av_tea_alloc(void);
-
-/**
- * Initialize an AVTEA context.
- *
- * @param ctx an AVTEA context
- * @param key a key of 16 bytes used for encryption/decryption
- * @param rounds the number of rounds in TEA (64 is the "standard")
- */
-void av_tea_init(struct AVTEA *ctx, const uint8_t key16, int rounds);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context.
- *
- * @param ctx an AVTEA context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 8 byte blocks
- * @param iv initialization vector for CBC mode, if NULL then ECB will be used
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_tea_crypt(struct AVTEA *ctx, uint8_t *dst, const uint8_t *src,
- int count, uint8_t *iv, int decrypt);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_TEA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/threadmessage.h Deleted

@@ -1,107 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_THREADMESSAGE_H
-#define AVUTIL_THREADMESSAGE_H
-
-typedef struct AVThreadMessageQueue AVThreadMessageQueue;
-
-typedef enum AVThreadMessageFlags {
-
- /**
- * Perform non-blocking operation.
- * If this flag is set, send and recv operations are non-blocking and
- * return AVERROR(EAGAIN) immediately if they can not proceed.
- */
- AV_THREAD_MESSAGE_NONBLOCK = 1,
-
-} AVThreadMessageFlags;
-
-/**
- * Allocate a new message queue.
- *
- * @param mq pointer to the message queue
- * @param nelem maximum number of elements in the queue
- * @param elsize size of each element in the queue
- * @return >=0 for success; <0 for error, in particular AVERROR(ENOSYS) if
- * lavu was built without thread support
- */
-int av_thread_message_queue_alloc(AVThreadMessageQueue **mq,
- unsigned nelem,
- unsigned elsize);
-
-/**
- * Free a message queue.
- *
- * The message queue must no longer be in use by another thread.
- */
-void av_thread_message_queue_free(AVThreadMessageQueue **mq);
-
-/**
- * Send a message on the queue.
- */
-int av_thread_message_queue_send(AVThreadMessageQueue *mq,
- void *msg,
- unsigned flags);
-
-/**
- * Receive a message from the queue.
- */
-int av_thread_message_queue_recv(AVThreadMessageQueue *mq,
- void *msg,
- unsigned flags);
-
-/**
- * Set the sending error code.
- *
- * If the error code is set to non-zero, av_thread_message_queue_send() will
- * return it immediately. Conventional values, such as AVERROR_EOF or
- * AVERROR(EAGAIN), can be used to cause the sending thread to stop or
- * suspend its operation.
- */
-void av_thread_message_queue_set_err_send(AVThreadMessageQueue *mq,
- int err);
-
-/**
- * Set the receiving error code.
- *
- * If the error code is set to non-zero, av_thread_message_queue_recv() will
- * return it immediately when there are no longer available messages.
- * Conventional values, such as AVERROR_EOF or AVERROR(EAGAIN), can be used
- * to cause the receiving thread to stop or suspend its operation.
- */
-void av_thread_message_queue_set_err_recv(AVThreadMessageQueue *mq,
- int err);
-
-/**
- * Set the optional free message callback function which will be called if an
- * operation is removing messages from the queue.
- */
-void av_thread_message_queue_set_free_func(AVThreadMessageQueue *mq,
- void (*free_func)(void *msg));
-
-/**
- * Flush the message queue
- *
- * This function is mostly equivalent to reading and free-ing every message
- * except that it will be done in a single operation (no lock/unlock between
- * reads).
- */
-void av_thread_message_flush(AVThreadMessageQueue *mq);
-
-#endif /* AVUTIL_THREADMESSAGE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/time.h Deleted

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2000-2003 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_TIME_H
-#define AVUTIL_TIME_H
-
-#include <stdint.h>
-
-/**
- * Get the current time in microseconds.
- */
-int64_t av_gettime(void);
-
-/**
- * Get the current time in microseconds since some unspecified starting point.
- * On platforms that support it, the time comes from a monotonic clock
- * This property makes this time source ideal for measuring relative time.
- * The returned values may not be monotonic on platforms where a monotonic
- * clock is not available.
- */
-int64_t av_gettime_relative(void);
-
-/**
- * Indicates with a boolean result if the av_gettime_relative() time source
- * is monotonic.
- */
-int av_gettime_relative_is_monotonic(void);
-
-/**
- * Sleep for a period of time. Although the duration is expressed in
- * microseconds, the actual delay may be rounded to the precision of the
- * system timer.
- *
- * @param usec Number of microseconds to sleep.
- * @return zero on success or (negative) error code.
- */
-int av_usleep(unsigned usec);
-
-#endif /* AVUTIL_TIME_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/timecode.h Deleted

@@ -1,140 +0,0 @@
-/*
- * Copyright (c) 2006 Smartjog S.A.S, Baptiste Coudurier <baptiste.coudurier@gmail.com>
- * Copyright (c) 2011-2012 Smartjog S.A.S, Clément Bœsch <clement.boesch@smartjog.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Timecode helpers header
- */
-
-#ifndef AVUTIL_TIMECODE_H
-#define AVUTIL_TIMECODE_H
-
-#include <stdint.h>
-#include "rational.h"
-
-#define AV_TIMECODE_STR_SIZE 23
-
-enum AVTimecodeFlag {
- AV_TIMECODE_FLAG_DROPFRAME = 1<<0, ///< timecode is drop frame
- AV_TIMECODE_FLAG_24HOURSMAX = 1<<1, ///< timecode wraps after 24 hours
- AV_TIMECODE_FLAG_ALLOWNEGATIVE = 1<<2, ///< negative time values are allowed
-};
-
-typedef struct {
- int start; ///< timecode frame start (first base frame number)
- uint32_t flags; ///< flags such as drop frame, +24 hours support, ...
- AVRational rate; ///< frame rate in rational form
- unsigned fps; ///< frame per second; must be consistent with the rate field
-} AVTimecode;
-
-/**
- * Adjust frame number for NTSC drop frame time code.
- *
- * @param framenum frame number to adjust
- * @param fps frame per second, 30 or 60
- * @return adjusted frame number
- * @warning adjustment is only valid in NTSC 29.97 and 59.94
- */
-int av_timecode_adjust_ntsc_framenum2(int framenum, int fps);
-
-/**
- * Convert frame number to SMPTE 12M binary representation.
- *
- * @param tc timecode data correctly initialized
- * @param framenum frame number
- * @return the SMPTE binary representation
- *
- * @note Frame number adjustment is automatically done in case of drop timecode,
- * you do NOT have to call av_timecode_adjust_ntsc_framenum2().
- * @note The frame number is relative to tc->start.
- * @note Color frame (CF), binary group flags (BGF) and biphase mark polarity
- * correction (PC) bits are set to zero.
- */
-uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum);
-
-/**
- * Load timecode string in buf.
- *
- * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long
- * @param tc timecode data correctly initialized
- * @param framenum frame number
- * @return the buf parameter
- *
- * @note Timecode representation can be a negative timecode and have more than
- * 24 hours, but will only be honored if the flags are correctly set.
- * @note The frame number is relative to tc->start.
- */
-char *av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum);
-
-/**
- * Get the timecode string from the SMPTE timecode format.
- *
- * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long
- * @param tcsmpte the 32-bit SMPTE timecode
- * @param prevent_df prevent the use of a drop flag when it is known the DF bit
- * is arbitrary
- * @return the buf parameter
- */
-char *av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df);
-
-/**
- * Get the timecode string from the 25-bit timecode format (MPEG GOP format).
- *
- * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long
- * @param tc25bit the 25-bits timecode
- * @return the buf parameter
- */
-char *av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit);
-
-/**
- * Init a timecode struct with the passed parameters.
- *
- * @param log_ctx a pointer to an arbitrary struct of which the first field
- * is a pointer to an AVClass struct (used for av_log)
- * @param tc pointer to an allocated AVTimecode
- * @param rate frame rate in rational form
- * @param flags miscellaneous flags such as drop frame, +24 hours, ...
- * (see AVTimecodeFlag)
- * @param frame_start the first frame number
- * @return 0 on success, AVERROR otherwise
- */
-int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx);
-
-/**
- * Parse timecode representation (hh:mm:ss:;.ff).
- *
- * @param log_ctx a pointer to an arbitrary struct of which the first field is a
- * pointer to an AVClass struct (used for av_log).
- * @param tc pointer to an allocated AVTimecode
- * @param rate frame rate in rational form
- * @param str timecode string which will determine the frame start
- * @return 0 on success, AVERROR otherwise
- */
-int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx);
-
-/**
- * Check if the timecode feature is available for the given frame rate
- *
- * @return 0 if supported, <0 otherwise
- */
-int av_timecode_check_frame_rate(AVRational rate);
-
-#endif /* AVUTIL_TIMECODE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/timestamp.h Deleted

@@ -1,78 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * timestamp utils, mostly useful for debugging/logging purposes
- */
-
-#ifndef AVUTIL_TIMESTAMP_H
-#define AVUTIL_TIMESTAMP_H
-
-#include "common.h"
-
-#if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS) && !defined(PRId64)
-#error missing -D__STDC_FORMAT_MACROS / #define __STDC_FORMAT_MACROS
-#endif
-
-#define AV_TS_MAX_STRING_SIZE 32
-
-/**
- * Fill the provided buffer with a string containing a timestamp
- * representation.
- *
- * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE
- * @param ts the timestamp to represent
- * @return the buffer in input
- */
-static inline char *av_ts_make_string(char *buf, int64_t ts)
-{
-    if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS");
-    else                      snprintf(buf, AV_TS_MAX_STRING_SIZE, "%" PRId64, ts);
-    return buf;
-}
-
-/**
- * Convenience macro, the return value should be used only directly in
- * function arguments but never stand-alone.
- */
-#define av_ts2str(ts) av_ts_make_string((charAV_TS_MAX_STRING_SIZE){0}, ts)
-
-/**
- * Fill the provided buffer with a string containing a timestamp time
- * representation.
- *
- * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE
- * @param ts the timestamp to represent
- * @param tb the timebase of the timestamp
- * @return the buffer in input
- */
-static inline char *av_ts_make_time_string(char *buf, int64_t ts, AVRational *tb)
-{
-    if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS");
-    else                      snprintf(buf, AV_TS_MAX_STRING_SIZE, "%.6g", av_q2d(*tb) * ts);
-    return buf;
-}
-
-/**
- * Convenience macro, the return value should be used only directly in
- * function arguments but never stand-alone.
- */
-#define av_ts2timestr(ts, tb) av_ts_make_time_string((charAV_TS_MAX_STRING_SIZE){0}, ts, tb)
-
-#endif /* AVUTIL_TIMESTAMP_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/tree.h Deleted

@@ -1,138 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * A tree container.
- * @author Michael Niedermayer <michaelni@gmx.at>
- */
-
-#ifndef AVUTIL_TREE_H
-#define AVUTIL_TREE_H
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @addtogroup lavu_tree AVTree
- * @ingroup lavu_data
- *
- * Low-complexity tree container
- *
- * Insertion, removal, finding equal, largest which is smaller than and
- * smallest which is larger than, all have O(log n) worst-case complexity.
- * @{
- */
-
-
-struct AVTreeNode;
-extern const int av_tree_node_size;
-
-/**
- * Allocate an AVTreeNode.
- */
-struct AVTreeNode *av_tree_node_alloc(void);
-
-/**
- * Find an element.
- * @param root a pointer to the root node of the tree
- * @param next If next is not NULL, then next0 will contain the previous
- * element and next1 the next element. If either does not exist,
- * then the corresponding entry in next is unchanged.
- * @param cmp compare function used to compare elements in the tree,
- * API identical to that of Standard C's qsort
- * It is guaranteed that the first and only the first argument to cmp()
- * will be the key parameter to av_tree_find(), thus it could if the
- * user wants, be a different type (like an opaque context).
- * @return An element with cmp(key, elem) == 0 or NULL if no such element
- * exists in the tree.
- */
-void *av_tree_find(const struct AVTreeNode *root, void *key,
- int (*cmp)(const void *key, const void *b), void *next2);
-
-/**
- * Insert or remove an element.
- *
- * If *next is NULL, then the supplied element will be removed if it exists.
- * If *next is non-NULL, then the supplied element will be inserted, unless
- * it already exists in the tree.
- *
- * @param rootp A pointer to a pointer to the root node of the tree; note that
- * the root node can change during insertions, this is required
- * to keep the tree balanced.
- * @param key pointer to the element key to insert in the tree
- * @param next Used to allocate and free AVTreeNodes. For insertion the user
- * must set it to an allocated and zeroed object of at least
- * av_tree_node_size bytes size. av_tree_insert() will set it to
- * NULL if it has been consumed.
- * For deleting elements *next is set to NULL by the user and
- * av_tree_insert() will set it to the AVTreeNode which was
- * used for the removed element.
- * This allows the use of flat arrays, which have
- * lower overhead compared to many malloced elements.
- * You might want to define a function like:
- * @code
- * void *tree_insert(struct AVTreeNode **rootp, void *key,
- * int (*cmp)(void *key, const void *b),
- * AVTreeNode **next)
- * {
- * if (!*next)
- * *next = av_mallocz(av_tree_node_size);
- * return av_tree_insert(rootp, key, cmp, next);
- * }
- * void *tree_remove(struct AVTreeNode **rootp, void *key,
- * int (*cmp)(void *key, const void *b, AVTreeNode **next))
- * {
- * av_freep(next);
- * return av_tree_insert(rootp, key, cmp, next);
- * }
- * @endcode
- * @param cmp compare function used to compare elements in the tree, API identical
- * to that of Standard C's qsort
- * @return If no insertion happened, the found element; if an insertion or
- * removal happened, then either key or NULL will be returned.
- * Which one it is depends on the tree state and the implementation. You
- * should make no assumptions that it's one or the other in the code.
- */
-void *av_tree_insert(struct AVTreeNode **rootp, void *key,
- int (*cmp)(const void *key, const void *b),
- struct AVTreeNode **next);
-
-void av_tree_destroy(struct AVTreeNode *t);
-
-/**
- * Apply enu(opaque, &elem) to all the elements in the tree in a given range.
- *
- * @param cmp a comparison function that returns < 0 for an element below the
- * range, > 0 for an element above the range and == 0 for an
- * element inside the range
- *
- * @note The cmp function should use the same ordering used to construct the
- * tree.
- */
-void av_tree_enumerate(struct AVTreeNode *t, void *opaque,
- int (*cmp)(void *opaque, void *elem),
- int (*enu)(void *opaque, void *elem));
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_TREE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/twofish.h Deleted

@@ -1,70 +0,0 @@
-/*
- * An implementation of the TwoFish algorithm
- * Copyright (c) 2015 Supraja Meedinti
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_TWOFISH_H
-#define AVUTIL_TWOFISH_H
-
-#include <stdint.h>
-
-
-/**
- * @file
- * @brief Public header for libavutil TWOFISH algorithm
- * @defgroup lavu_twofish TWOFISH
- * @ingroup lavu_crypto
- * @{
- */
-
-extern const int av_twofish_size;
-
-struct AVTWOFISH;
-
-/**
- * Allocate an AVTWOFISH context
- * To free the struct: av_free(ptr)
- */
-struct AVTWOFISH *av_twofish_alloc(void);
-
-/**
- * Initialize an AVTWOFISH context.
- *
- * @param ctx an AVTWOFISH context
- * @param key a key of size ranging from 1 to 32 bytes used for encryption/decryption
- * @param key_bits number of keybits: 128, 192, 256 If less than the required, padded with zeroes to nearest valid value; return value is 0 if key_bits is 128/192/256, -1 if less than 0, 1 otherwise
- */
-int av_twofish_init(struct AVTWOFISH *ctx, const uint8_t *key, int key_bits);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context
- *
- * @param ctx an AVTWOFISH context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 16 byte blocks
- * @paran iv initialization vector for CBC mode, NULL for ECB mode
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_twofish_crypt(struct AVTWOFISH *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt);
-
-/**
- * @}
- */
-#endif /* AVUTIL_TWOFISH_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/version.h Deleted

@@ -1,139 +0,0 @@
-/*
- * copyright (c) 2003 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu
- * Libavutil version macros
- */
-
-#ifndef AVUTIL_VERSION_H
-#define AVUTIL_VERSION_H
-
-#include "macros.h"
-
-/**
- * @addtogroup version_utils
- *
- * Useful to check and match library version in order to maintain
- * backward compatibility.
- *
- * The FFmpeg libraries follow a versioning sheme very similar to
- * Semantic Versioning (http://semver.org/)
- * The difference is that the component called PATCH is called MICRO in FFmpeg
- * and its value is reset to 100 instead of 0 to keep it above or equal to 100.
- * Also we do not increase MICRO for every bugfix or change in git master.
- *
- * Prior to FFmpeg 3.2 point releases did not change any lib version number to
- * avoid aliassing different git master checkouts.
- * Starting with FFmpeg 3.2, the released library versions will occupy
- * a separate MAJOR.MINOR that is not used on the master development branch.
- * That is if we branch a release of master 55.10.123 we will bump to 55.11.100
- * for the release and master will continue at 55.12.100 after it. Each new
- * point release will then bump the MICRO improving the usefulness of the lib
- * versions.
- *
- * @{
- */
-
-#define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
-#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
-#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
-
-/**
- * Extract version components from the full ::AV_VERSION_INT int as returned
- * by functions like ::avformat_version() and ::avcodec_version()
- */
-#define AV_VERSION_MAJOR(a) ((a) >> 16)
-#define AV_VERSION_MINOR(a) (((a) & 0x00FF00) >> 8)
-#define AV_VERSION_MICRO(a) ((a) & 0xFF)
-
-/**
- * @}
- */
-
-/**
- * @defgroup lavu_ver Version and Build diagnostics
- *
- * Macros and function useful to check at compiletime and at runtime
- * which version of libavutil is in use.
- *
- * @{
- */
-
-#define LIBAVUTIL_VERSION_MAJOR 56
-#define LIBAVUTIL_VERSION_MINOR 14
-#define LIBAVUTIL_VERSION_MICRO 100
-
-#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
- LIBAVUTIL_VERSION_MINOR, \
- LIBAVUTIL_VERSION_MICRO)
-#define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \
- LIBAVUTIL_VERSION_MINOR, \
- LIBAVUTIL_VERSION_MICRO)
-#define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT
-
-#define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
-
-/**
- * @defgroup lavu_depr_guards Deprecation Guards
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- *
- * @note, when bumping the major version it is recommended to manually
- * disable each FF_API_* in its own commit instead of disabling them all
- * at once through the bump. This improves the git bisect-ability of the change.
- *
- * @{
- */
-
-#ifndef FF_API_VAAPI
-#define FF_API_VAAPI (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_FRAME_QP
-#define FF_API_FRAME_QP (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_PLUS1_MINUS1
-#define FF_API_PLUS1_MINUS1 (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_ERROR_FRAME
-#define FF_API_ERROR_FRAME (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_PKT_PTS
-#define FF_API_PKT_PTS (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_CRYPTO_SIZE_T
-#define FF_API_CRYPTO_SIZE_T (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_FRAME_GET_SET
-#define FF_API_FRAME_GET_SET (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_PSEUDOPAL
-#define FF_API_PSEUDOPAL (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libavutil/xtea.h Deleted

@@ -1,94 +0,0 @@
-/*
- * A 32-bit implementation of the XTEA algorithm
- * Copyright (c) 2012 Samuel Pitoiset
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_XTEA_H
-#define AVUTIL_XTEA_H
-
-#include <stdint.h>
-
-/**
- * @file
- * @brief Public header for libavutil XTEA algorithm
- * @defgroup lavu_xtea XTEA
- * @ingroup lavu_crypto
- * @{
- */
-
-typedef struct AVXTEA {
- uint32_t key16;
-} AVXTEA;
-
-/**
- * Allocate an AVXTEA context.
- */
-AVXTEA *av_xtea_alloc(void);
-
-/**
- * Initialize an AVXTEA context.
- *
- * @param ctx an AVXTEA context
- * @param key a key of 16 bytes used for encryption/decryption,
- * interpreted as big endian 32 bit numbers
- */
-void av_xtea_init(struct AVXTEA *ctx, const uint8_t key16);
-
-/**
- * Initialize an AVXTEA context.
- *
- * @param ctx an AVXTEA context
- * @param key a key of 16 bytes used for encryption/decryption,
- * interpreted as little endian 32 bit numbers
- */
-void av_xtea_le_init(struct AVXTEA *ctx, const uint8_t key16);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context,
- * in big endian format.
- *
- * @param ctx an AVXTEA context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 8 byte blocks
- * @param iv initialization vector for CBC mode, if NULL then ECB will be used
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_xtea_crypt(struct AVXTEA *ctx, uint8_t *dst, const uint8_t *src,
- int count, uint8_t *iv, int decrypt);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context,
- * in little endian format.
- *
- * @param ctx an AVXTEA context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 8 byte blocks
- * @param iv initialization vector for CBC mode, if NULL then ECB will be used
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_xtea_le_crypt(struct AVXTEA *ctx, uint8_t *dst, const uint8_t *src,
- int count, uint8_t *iv, int decrypt);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_XTEA_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libswresample Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libswresample/swresample.h Deleted

@@ -1,579 +0,0 @@
-/*
- * Copyright (C) 2011-2013 Michael Niedermayer (michaelni@gmx.at)
- *
- * This file is part of libswresample
- *
- * libswresample is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * libswresample is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with libswresample; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef SWRESAMPLE_SWRESAMPLE_H
-#define SWRESAMPLE_SWRESAMPLE_H
-
-/**
- * @file
- * @ingroup lswr
- * libswresample public header
- */
-
-/**
- * @defgroup lswr libswresample
- * @{
- *
- * Audio resampling, sample format conversion and mixing library.
- *
- * Interaction with lswr is done through SwrContext, which is
- * allocated with swr_alloc() or swr_alloc_set_opts(). It is opaque, so all parameters
- * must be set with the @ref avoptions API.
- *
- * The first thing you will need to do in order to use lswr is to allocate
- * SwrContext. This can be done with swr_alloc() or swr_alloc_set_opts(). If you
- * are using the former, you must set options through the @ref avoptions API.
- * The latter function provides the same feature, but it allows you to set some
- * common options in the same statement.
- *
- * For example the following code will setup conversion from planar float sample
- * format to interleaved signed 16-bit integer, downsampling from 48kHz to
- * 44.1kHz and downmixing from 5.1 channels to stereo (using the default mixing
- * matrix). This is using the swr_alloc() function.
- * @code
- * SwrContext *swr = swr_alloc();
- * av_opt_set_channel_layout(swr, "in_channel_layout", AV_CH_LAYOUT_5POINT1, 0);
- * av_opt_set_channel_layout(swr, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
- * av_opt_set_int(swr, "in_sample_rate", 48000, 0);
- * av_opt_set_int(swr, "out_sample_rate", 44100, 0);
- * av_opt_set_sample_fmt(swr, "in_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
- * av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
- * @endcode
- *
- * The same job can be done using swr_alloc_set_opts() as well:
- * @code
- * SwrContext *swr = swr_alloc_set_opts(NULL, // we're allocating a new context
- * AV_CH_LAYOUT_STEREO, // out_ch_layout
- * AV_SAMPLE_FMT_S16, // out_sample_fmt
- * 44100, // out_sample_rate
- * AV_CH_LAYOUT_5POINT1, // in_ch_layout
- * AV_SAMPLE_FMT_FLTP, // in_sample_fmt
- * 48000, // in_sample_rate
- * 0, // log_offset
- * NULL); // log_ctx
- * @endcode
- *
- * Once all values have been set, it must be initialized with swr_init(). If
- * you need to change the conversion parameters, you can change the parameters
- * using @ref AVOptions, as described above in the first example; or by using
- * swr_alloc_set_opts(), but with the first argument the allocated context.
- * You must then call swr_init() again.
- *
- * The conversion itself is done by repeatedly calling swr_convert().
- * Note that the samples may get buffered in swr if you provide insufficient
- * output space or if sample rate conversion is done, which requires "future"
- * samples. Samples that do not require future input can be retrieved at any
- * time by using swr_convert() (in_count can be set to 0).
- * At the end of conversion the resampling buffer can be flushed by calling
- * swr_convert() with NULL in and 0 in_count.
- *
- * The samples used in the conversion process can be managed with the libavutil
- * @ref lavu_sampmanip "samples manipulation" API, including av_samples_alloc()
- * function used in the following example.
- *
- * The delay between input and output, can at any time be found by using
- * swr_get_delay().
- *
- * The following code demonstrates the conversion loop assuming the parameters
- * from above and caller-defined functions get_input() and handle_output():
- * @code
- * uint8_t **input;
- * int in_samples;
- *
- * while (get_input(&input, &in_samples)) {
- * uint8_t *output;
- * int out_samples = av_rescale_rnd(swr_get_delay(swr, 48000) +
- * in_samples, 44100, 48000, AV_ROUND_UP);
- * av_samples_alloc(&output, NULL, 2, out_samples,
- * AV_SAMPLE_FMT_S16, 0);
- * out_samples = swr_convert(swr, &output, out_samples,
- * input, in_samples);
- * handle_output(output, out_samples);
- * av_freep(&output);
- * }
- * @endcode
- *
- * When the conversion is finished, the conversion
- * context and everything associated with it must be freed with swr_free().
- * A swr_close() function is also available, but it exists mainly for
- * compatibility with libavresample, and is not required to be called.
- *
- * There will be no memory leak if the data is not completely flushed before
- * swr_free().
- */
-
-#include <stdint.h>
-#include "libavutil/channel_layout.h"
-#include "libavutil/frame.h"
-#include "libavutil/samplefmt.h"
-
-#include "libswresample/version.h"
-
-/**
- * @name Option constants
- * These constants are used for the @ref avoptions interface for lswr.
- * @{
- *
- */
-
-#define SWR_FLAG_RESAMPLE 1 ///< Force resampling even if equal sample rate
-//TODO use int resample ?
-//long term TODO can we enable this dynamically?
-
-/** Dithering algorithms */
-enum SwrDitherType {
- SWR_DITHER_NONE = 0,
- SWR_DITHER_RECTANGULAR,
- SWR_DITHER_TRIANGULAR,
- SWR_DITHER_TRIANGULAR_HIGHPASS,
-
- SWR_DITHER_NS = 64, ///< not part of API/ABI
- SWR_DITHER_NS_LIPSHITZ,
- SWR_DITHER_NS_F_WEIGHTED,
- SWR_DITHER_NS_MODIFIED_E_WEIGHTED,
- SWR_DITHER_NS_IMPROVED_E_WEIGHTED,
- SWR_DITHER_NS_SHIBATA,
- SWR_DITHER_NS_LOW_SHIBATA,
- SWR_DITHER_NS_HIGH_SHIBATA,
- SWR_DITHER_NB, ///< not part of API/ABI
-};
-
-/** Resampling Engines */
-enum SwrEngine {
- SWR_ENGINE_SWR, /**< SW Resampler */
- SWR_ENGINE_SOXR, /**< SoX Resampler */
- SWR_ENGINE_NB, ///< not part of API/ABI
-};
-
-/** Resampling Filter Types */
-enum SwrFilterType {
- SWR_FILTER_TYPE_CUBIC, /**< Cubic */
- SWR_FILTER_TYPE_BLACKMAN_NUTTALL, /**< Blackman Nuttall windowed sinc */
- SWR_FILTER_TYPE_KAISER, /**< Kaiser windowed sinc */
-};
-
-/**
- * @}
- */
-
-/**
- * The libswresample context. Unlike libavcodec and libavformat, this structure
- * is opaque. This means that if you would like to set options, you must use
- * the @ref avoptions API and cannot directly set values to members of the
- * structure.
- */
-typedef struct SwrContext SwrContext;
-
-/**
- * Get the AVClass for SwrContext. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- * @return the AVClass of SwrContext
- */
-const AVClass *swr_get_class(void);
-
-/**
- * @name SwrContext constructor functions
- * @{
- */
-
-/**
- * Allocate SwrContext.
- *
- * If you use this function you will need to set the parameters (manually or
- * with swr_alloc_set_opts()) before calling swr_init().
- *
- * @see swr_alloc_set_opts(), swr_init(), swr_free()
- * @return NULL on error, allocated context otherwise
- */
-struct SwrContext *swr_alloc(void);
-
-/**
- * Initialize context after user parameters have been set.
- * @note The context must be configured using the AVOption API.
- *
- * @see av_opt_set_int()
- * @see av_opt_set_dict()
- *
- * @paramin,out s Swr context to initialize
- * @return AVERROR error code in case of failure.
- */
-int swr_init(struct SwrContext *s);
-
-/**
- * Check whether an swr context has been initialized or not.
- *
- * @paramin s Swr context to check
- * @see swr_init()
- * @return positive if it has been initialized, 0 if not initialized
- */
-int swr_is_initialized(struct SwrContext *s);
-
-/**
- * Allocate SwrContext if needed and set/reset common parameters.
- *
- * This function does not require s to be allocated with swr_alloc(). On the
- * other hand, swr_alloc() can use swr_alloc_set_opts() to set the parameters
- * on the allocated context.
- *
- * @param s existing Swr context if available, or NULL if not
- * @param out_ch_layout output channel layout (AV_CH_LAYOUT_*)
- * @param out_sample_fmt output sample format (AV_SAMPLE_FMT_*).
- * @param out_sample_rate output sample rate (frequency in Hz)
- * @param in_ch_layout input channel layout (AV_CH_LAYOUT_*)
- * @param in_sample_fmt input sample format (AV_SAMPLE_FMT_*).
- * @param in_sample_rate input sample rate (frequency in Hz)
- * @param log_offset logging level offset
- * @param log_ctx parent logging context, can be NULL
- *
- * @see swr_init(), swr_free()
- * @return NULL on error, allocated context otherwise
- */
-struct SwrContext *swr_alloc_set_opts(struct SwrContext *s,
- int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
- int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate,
- int log_offset, void *log_ctx);
-
-/**
- * @}
- *
- * @name SwrContext destructor functions
- * @{
- */
-
-/**
- * Free the given SwrContext and set the pointer to NULL.
- *
- * @paramin s a pointer to a pointer to Swr context
- */
-void swr_free(struct SwrContext **s);
-
-/**
- * Closes the context so that swr_is_initialized() returns 0.
- *
- * The context can be brought back to life by running swr_init(),
- * swr_init() can also be used without swr_close().
- * This function is mainly provided for simplifying the usecase
- * where one tries to support libavresample and libswresample.
- *
- * @paramin,out s Swr context to be closed
- */
-void swr_close(struct SwrContext *s);
-
-/**
- * @}
- *
- * @name Core conversion functions
- * @{
- */
-
-/** Convert audio.
- *
- * in and in_count can be set to 0 to flush the last few samples out at the
- * end.
- *
- * If more input is provided than output space, then the input will be buffered.
- * You can avoid this buffering by using swr_get_out_samples() to retrieve an
- * upper bound on the required number of output samples for the given number of
- * input samples. Conversion will run directly without copying whenever possible.
- *
- * @param s allocated Swr context, with parameters set
- * @param out output buffers, only the first one need be set in case of packed audio
- * @param out_count amount of space available for output in samples per channel
- * @param in input buffers, only the first one need to be set in case of packed audio
- * @param in_count number of input samples available in one channel
- *
- * @return number of samples output per channel, negative value on error
- */
-int swr_convert(struct SwrContext *s, uint8_t **out, int out_count,
- const uint8_t **in , int in_count);
-
-/**
- * Convert the next timestamp from input to output
- * timestamps are in 1/(in_sample_rate * out_sample_rate) units.
- *
- * @note There are 2 slightly differently behaving modes.
- * @li When automatic timestamp compensation is not used, (min_compensation >= FLT_MAX)
- * in this case timestamps will be passed through with delays compensated
- * @li When automatic timestamp compensation is used, (min_compensation < FLT_MAX)
- * in this case the output timestamps will match output sample numbers.
- * See ffmpeg-resampler(1) for the two modes of compensation.
- *
- * @param sin initialized Swr context
- * @param ptsin timestamp for the next input sample, INT64_MIN if unknown
- * @see swr_set_compensation(), swr_drop_output(), and swr_inject_silence() are
- * function used internally for timestamp compensation.
- * @return the output timestamp for the next output sample
- */
-int64_t swr_next_pts(struct SwrContext *s, int64_t pts);
-
-/**
- * @}
- *
- * @name Low-level option setting functions
- * These functons provide a means to set low-level options that is not possible
- * with the AVOption API.
- * @{
- */
-
-/**
- * Activate resampling compensation ("soft" compensation). This function is
- * internally called when needed in swr_next_pts().
- *
- * @paramin,out s allocated Swr context. If it is not initialized,
- * or SWR_FLAG_RESAMPLE is not set, swr_init() is
- * called with the flag set.
- * @paramin sample_delta delta in PTS per sample
- * @paramin compensation_distance number of samples to compensate for
- * @return >= 0 on success, AVERROR error codes if:
- * @li @c s is NULL,
- * @li @c compensation_distance is less than 0,
- * @li @c compensation_distance is 0 but sample_delta is not,
- * @li compensation unsupported by resampler, or
- * @li swr_init() fails when called.
- */
-int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance);
-
-/**
- * Set a customized input channel mapping.
- *
- * @paramin,out s allocated Swr context, not yet initialized
- * @paramin channel_map customized input channel mapping (array of channel
- * indexes, -1 for a muted channel)
- * @return >= 0 on success, or AVERROR error code in case of failure.
- */
-int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map);
-
-/**
- * Generate a channel mixing matrix.
- *
- * This function is the one used internally by libswresample for building the
- * default mixing matrix. It is made public just as a utility function for
- * building custom matrices.
- *
- * @param in_layout input channel layout
- * @param out_layout output channel layout
- * @param center_mix_level mix level for the center channel
- * @param surround_mix_level mix level for the surround channel(s)
- * @param lfe_mix_level mix level for the low-frequency effects channel
- * @param rematrix_maxval if 1.0, coefficients will be normalized to prevent
- * overflow. if INT_MAX, coefficients will not be
- * normalized.
- * @paramout matrix mixing coefficients; matrixi + stride * o is
- * the weight of input channel i in output channel o.
- * @param stride distance between adjacent input channels in the
- * matrix array
- * @param matrix_encoding matrixed stereo downmix mode (e.g. dplii)
- * @param log_ctx parent logging context, can be NULL
- * @return 0 on success, negative AVERROR code on failure
- */
-int swr_build_matrix(uint64_t in_layout, uint64_t out_layout,
- double center_mix_level, double surround_mix_level,
- double lfe_mix_level, double rematrix_maxval,
- double rematrix_volume, double *matrix,
- int stride, enum AVMatrixEncoding matrix_encoding,
- void *log_ctx);
-
-/**
- * Set a customized remix matrix.
- *
- * @param s allocated Swr context, not yet initialized
- * @param matrix remix coefficients; matrixi + stride * o is
- * the weight of input channel i in output channel o
- * @param stride offset between lines of the matrix
- * @return >= 0 on success, or AVERROR error code in case of failure.
- */
-int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride);
-
-/**
- * @}
- *
- * @name Sample handling functions
- * @{
- */
-
-/**
- * Drops the specified number of output samples.
- *
- * This function, along with swr_inject_silence(), is called by swr_next_pts()
- * if needed for "hard" compensation.
- *
- * @param s allocated Swr context
- * @param count number of samples to be dropped
- *
- * @return >= 0 on success, or a negative AVERROR code on failure
- */
-int swr_drop_output(struct SwrContext *s, int count);
-
-/**
- * Injects the specified number of silence samples.
- *
- * This function, along with swr_drop_output(), is called by swr_next_pts()
- * if needed for "hard" compensation.
- *
- * @param s allocated Swr context
- * @param count number of samples to be dropped
- *
- * @return >= 0 on success, or a negative AVERROR code on failure
- */
-int swr_inject_silence(struct SwrContext *s, int count);
-
-/**
- * Gets the delay the next input sample will experience relative to the next output sample.
- *
- * Swresample can buffer data if more input has been provided than available
- * output space, also converting between sample rates needs a delay.
- * This function returns the sum of all such delays.
- * The exact delay is not necessarily an integer value in either input or
- * output sample rate. Especially when downsampling by a large value, the
- * output sample rate may be a poor choice to represent the delay, similarly
- * for upsampling and the input sample rate.
- *
- * @param s swr context
- * @param base timebase in which the returned delay will be:
- * @li if it's set to 1 the returned delay is in seconds
- * @li if it's set to 1000 the returned delay is in milliseconds
- * @li if it's set to the input sample rate then the returned
- * delay is in input samples
- * @li if it's set to the output sample rate then the returned
- * delay is in output samples
- * @li if it's the least common multiple of in_sample_rate and
- * out_sample_rate then an exact rounding-free delay will be
- * returned
- * @returns the delay in 1 / @c base units.
- */
-int64_t swr_get_delay(struct SwrContext *s, int64_t base);
-
-/**
- * Find an upper bound on the number of samples that the next swr_convert
- * call will output, if called with in_samples of input samples. This
- * depends on the internal state, and anything changing the internal state
- * (like further swr_convert() calls) will may change the number of samples
- * swr_get_out_samples() returns for the same number of input samples.
- *
- * @param in_samples number of input samples.
- * @note any call to swr_inject_silence(), swr_convert(), swr_next_pts()
- * or swr_set_compensation() invalidates this limit
- * @note it is recommended to pass the correct available buffer size
- * to all functions like swr_convert() even if swr_get_out_samples()
- * indicates that less would be used.
- * @returns an upper bound on the number of samples that the next swr_convert
- * will output or a negative value to indicate an error
- */
-int swr_get_out_samples(struct SwrContext *s, int in_samples);
-
-/**
- * @}
- *
- * @name Configuration accessors
- * @{
- */
-
-/**
- * Return the @ref LIBSWRESAMPLE_VERSION_INT constant.
- *
- * This is useful to check if the build-time libswresample has the same version
- * as the run-time one.
- *
- * @returns the unsigned int-typed version
- */
-unsigned swresample_version(void);
-
-/**
- * Return the swr build-time configuration.
- *
- * @returns the build-time @c ./configure flags
- */
-const char *swresample_configuration(void);
-
-/**
- * Return the swr license.
- *
- * @returns the license of libswresample, determined at build-time
- */
-const char *swresample_license(void);
-
-/**
- * @}
- *
- * @name AVFrame based API
- * @{
- */
-
-/**
- * Convert the samples in the input AVFrame and write them to the output AVFrame.
- *
- * Input and output AVFrames must have channel_layout, sample_rate and format set.
- *
- * If the output AVFrame does not have the data pointers allocated the nb_samples
- * field will be set using av_frame_get_buffer()
- * is called to allocate the frame.
- *
- * The output AVFrame can be NULL or have fewer allocated samples than required.
- * In this case, any remaining samples not written to the output will be added
- * to an internal FIFO buffer, to be returned at the next call to this function
- * or to swr_convert().
- *
- * If converting sample rate, there may be data remaining in the internal
- * resampling delay buffer. swr_get_delay() tells the number of
- * remaining samples. To get this data as output, call this function or
- * swr_convert() with NULL input.
- *
- * If the SwrContext configuration does not match the output and
- * input AVFrame settings the conversion does not take place and depending on
- * which AVFrame is not matching AVERROR_OUTPUT_CHANGED, AVERROR_INPUT_CHANGED
- * or the result of a bitwise-OR of them is returned.
- *
- * @see swr_delay()
- * @see swr_convert()
- * @see swr_get_delay()
- *
- * @param swr audio resample context
- * @param output output AVFrame
- * @param input input AVFrame
- * @return 0 on success, AVERROR on failure or nonmatching
- * configuration.
- */
-int swr_convert_frame(SwrContext *swr,
- AVFrame *output, const AVFrame *input);
-
-/**
- * Configure or reconfigure the SwrContext using the information
- * provided by the AVFrames.
- *
- * The original resampling context is reset even on failure.
- * The function calls swr_close() internally if the context is open.
- *
- * @see swr_close();
- *
- * @param swr audio resample context
- * @param output output AVFrame
- * @param input input AVFrame
- * @return 0 on success, AVERROR on failure.
- */
-int swr_config_frame(SwrContext *swr, const AVFrame *out, const AVFrame *in);
-
-/**
- * @}
- * @}
- */
-
-#endif /* SWRESAMPLE_SWRESAMPLE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libswresample/version.h Deleted

@@ -1,45 +0,0 @@
-/*
- * Version macros.
- *
- * This file is part of libswresample
- *
- * libswresample is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * libswresample is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with libswresample; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef SWRESAMPLE_VERSION_H
-#define SWRESAMPLE_VERSION_H
-
-/**
- * @file
- * Libswresample version macros
- */
-
-#include "libavutil/avutil.h"
-
-#define LIBSWRESAMPLE_VERSION_MAJOR   3
-#define LIBSWRESAMPLE_VERSION_MINOR   1
-#define LIBSWRESAMPLE_VERSION_MICRO 100
-
-#define LIBSWRESAMPLE_VERSION_INT  AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \
-                                                  LIBSWRESAMPLE_VERSION_MINOR, \
-                                                  LIBSWRESAMPLE_VERSION_MICRO)
-#define LIBSWRESAMPLE_VERSION      AV_VERSION(LIBSWRESAMPLE_VERSION_MAJOR, \
-                                              LIBSWRESAMPLE_VERSION_MINOR, \
-                                              LIBSWRESAMPLE_VERSION_MICRO)
-#define LIBSWRESAMPLE_BUILD        LIBSWRESAMPLE_VERSION_INT
-
-#define LIBSWRESAMPLE_IDENT        "SwR" AV_STRINGIFY(LIBSWRESAMPLE_VERSION)
-
-#endif /* SWRESAMPLE_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libswscale Deleted

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libswscale/swscale.h Deleted

@@ -1,336 +0,0 @@
-/*
- * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef SWSCALE_SWSCALE_H
-#define SWSCALE_SWSCALE_H
-
-/**
- * @file
- * @ingroup libsws
- * external API header
- */
-
-#include <stdint.h>
-
-#include "libavutil/avutil.h"
-#include "libavutil/log.h"
-#include "libavutil/pixfmt.h"
-#include "version.h"
-
-/**
- * @defgroup libsws libswscale
- * Color conversion and scaling library.
- *
- * @{
- *
- * Return the LIBSWSCALE_VERSION_INT constant.
- */
-unsigned swscale_version(void);
-
-/**
- * Return the libswscale build-time configuration.
- */
-const char *swscale_configuration(void);
-
-/**
- * Return the libswscale license.
- */
-const char *swscale_license(void);
-
-/* values for the flags, the stuff on the command line is different */
-#define SWS_FAST_BILINEAR 1
-#define SWS_BILINEAR 2
-#define SWS_BICUBIC 4
-#define SWS_X 8
-#define SWS_POINT 0x10
-#define SWS_AREA 0x20
-#define SWS_BICUBLIN 0x40
-#define SWS_GAUSS 0x80
-#define SWS_SINC 0x100
-#define SWS_LANCZOS 0x200
-#define SWS_SPLINE 0x400
-
-#define SWS_SRC_V_CHR_DROP_MASK 0x30000
-#define SWS_SRC_V_CHR_DROP_SHIFT 16
-
-#define SWS_PARAM_DEFAULT 123456
-
-#define SWS_PRINT_INFO 0x1000
-
-//the following 3 flags are not completely implemented
-//internal chrominance subsampling info
-#define SWS_FULL_CHR_H_INT 0x2000
-//input subsampling info
-#define SWS_FULL_CHR_H_INP 0x4000
-#define SWS_DIRECT_BGR 0x8000
-#define SWS_ACCURATE_RND 0x40000
-#define SWS_BITEXACT 0x80000
-#define SWS_ERROR_DIFFUSION 0x800000
-
-#define SWS_MAX_REDUCE_CUTOFF 0.002
-
-#define SWS_CS_ITU709 1
-#define SWS_CS_FCC 4
-#define SWS_CS_ITU601 5
-#define SWS_CS_ITU624 5
-#define SWS_CS_SMPTE170M 5
-#define SWS_CS_SMPTE240M 7
-#define SWS_CS_DEFAULT 5
-#define SWS_CS_BT2020 9
-
-/**
- * Return a pointer to yuv<->rgb coefficients for the given colorspace
- * suitable for sws_setColorspaceDetails().
- *
- * @param colorspace One of the SWS_CS_* macros. If invalid,
- * SWS_CS_DEFAULT is used.
- */
-const int *sws_getCoefficients(int colorspace);
-
-// when used for filters they must have an odd number of elements
-// coeffs cannot be shared between vectors
-typedef struct SwsVector {
- double *coeff; ///< pointer to the list of coefficients
- int length; ///< number of coefficients in the vector
-} SwsVector;
-
-// vectors can be shared
-typedef struct SwsFilter {
- SwsVector *lumH;
- SwsVector *lumV;
- SwsVector *chrH;
- SwsVector *chrV;
-} SwsFilter;
-
-struct SwsContext;
-
-/**
- * Return a positive value if pix_fmt is a supported input format, 0
- * otherwise.
- */
-int sws_isSupportedInput(enum AVPixelFormat pix_fmt);
-
-/**
- * Return a positive value if pix_fmt is a supported output format, 0
- * otherwise.
- */
-int sws_isSupportedOutput(enum AVPixelFormat pix_fmt);
-
-/**
- * @paramin pix_fmt the pixel format
- * @return a positive value if an endianness conversion for pix_fmt is
- * supported, 0 otherwise.
- */
-int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt);
-
-/**
- * Allocate an empty SwsContext. This must be filled and passed to
- * sws_init_context(). For filling see AVOptions, options.c and
- * sws_setColorspaceDetails().
- */
-struct SwsContext *sws_alloc_context(void);
-
-/**
- * Initialize the swscaler context sws_context.
- *
- * @return zero or positive value on success, a negative value on
- * error
- */
-av_warn_unused_result
-int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter);
-
-/**
- * Free the swscaler context swsContext.
- * If swsContext is NULL, then does nothing.
- */
-void sws_freeContext(struct SwsContext *swsContext);
-
-/**
- * Allocate and return an SwsContext. You need it to perform
- * scaling/conversion operations using sws_scale().
- *
- * @param srcW the width of the source image
- * @param srcH the height of the source image
- * @param srcFormat the source image format
- * @param dstW the width of the destination image
- * @param dstH the height of the destination image
- * @param dstFormat the destination image format
- * @param flags specify which algorithm and options to use for rescaling
- * @param param extra parameters to tune the used scaler
- * For SWS_BICUBIC param0 and 1 tune the shape of the basis
- * function, param0 tunes f(1) and param1 f´(1)
- * For SWS_GAUSS param0 tunes the exponent and thus cutoff
- * frequency
- * For SWS_LANCZOS param0 tunes the width of the window function
- * @return a pointer to an allocated context, or NULL in case of error
- * @note this function is to be removed after a saner alternative is
- * written
- */
-struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
- int dstW, int dstH, enum AVPixelFormat dstFormat,
- int flags, SwsFilter *srcFilter,
- SwsFilter *dstFilter, const double *param);
-
-/**
- * Scale the image slice in srcSlice and put the resulting scaled
- * slice in the image in dst. A slice is a sequence of consecutive
- * rows in an image.
- *
- * Slices have to be provided in sequential order, either in
- * top-bottom or bottom-top order. If slices are provided in
- * non-sequential order the behavior of the function is undefined.
- *
- * @param c the scaling context previously created with
- * sws_getContext()
- * @param srcSlice the array containing the pointers to the planes of
- * the source slice
- * @param srcStride the array containing the strides for each plane of
- * the source image
- * @param srcSliceY the position in the source image of the slice to
- * process, that is the number (counted starting from
- * zero) in the image of the first row of the slice
- * @param srcSliceH the height of the source slice, that is the number
- * of rows in the slice
- * @param dst the array containing the pointers to the planes of
- * the destination image
- * @param dstStride the array containing the strides for each plane of
- * the destination image
- * @return the height of the output slice
- */
-int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice,
- const int srcStride, int srcSliceY, int srcSliceH,
- uint8_t *const dst, const int dstStride);
-
-/**
- * @param dstRange flag indicating the while-black range of the output (1=jpeg / 0=mpeg)
- * @param srcRange flag indicating the while-black range of the input (1=jpeg / 0=mpeg)
- * @param table the yuv2rgb coefficients describing the output yuv space, normally ff_yuv2rgb_coeffsx
- * @param inv_table the yuv2rgb coefficients describing the input yuv space, normally ff_yuv2rgb_coeffsx
- * @param brightness 16.16 fixed point brightness correction
- * @param contrast 16.16 fixed point contrast correction
- * @param saturation 16.16 fixed point saturation correction
- * @return -1 if not supported
- */
-int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table4,
- int srcRange, const int table4, int dstRange,
- int brightness, int contrast, int saturation);
-
-/**
- * @return -1 if not supported
- */
-int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
- int *srcRange, int **table, int *dstRange,
- int *brightness, int *contrast, int *saturation);
-
-/**
- * Allocate and return an uninitialized vector with length coefficients.
- */
-SwsVector *sws_allocVec(int length);
-
-/**
- * Return a normalized Gaussian curve used to filter stuff
- * quality = 3 is high quality, lower is lower quality.
- */
-SwsVector *sws_getGaussianVec(double variance, double quality);
-
-/**
- * Scale all the coefficients of a by the scalar value.
- */
-void sws_scaleVec(SwsVector *a, double scalar);
-
-/**
- * Scale all the coefficients of a so that their sum equals height.
- */
-void sws_normalizeVec(SwsVector *a, double height);
-
-#if FF_API_SWS_VECTOR
-attribute_deprecated SwsVector *sws_getConstVec(double c, int length);
-attribute_deprecated SwsVector *sws_getIdentityVec(void);
-attribute_deprecated void sws_convVec(SwsVector *a, SwsVector *b);
-attribute_deprecated void sws_addVec(SwsVector *a, SwsVector *b);
-attribute_deprecated void sws_subVec(SwsVector *a, SwsVector *b);
-attribute_deprecated void sws_shiftVec(SwsVector *a, int shift);
-attribute_deprecated SwsVector *sws_cloneVec(SwsVector *a);
-attribute_deprecated void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);
-#endif
-
-void sws_freeVec(SwsVector *a);
-
-SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
- float lumaSharpen, float chromaSharpen,
- float chromaHShift, float chromaVShift,
- int verbose);
-void sws_freeFilter(SwsFilter *filter);
-
-/**
- * Check if context can be reused, otherwise reallocate a new one.
- *
- * If context is NULL, just calls sws_getContext() to get a new
- * context. Otherwise, checks if the parameters are the ones already
- * saved in context. If that is the case, returns the current
- * context. Otherwise, frees context and gets a new context with
- * the new parameters.
- *
- * Be warned that srcFilter and dstFilter are not checked, they
- * are assumed to remain the same.
- */
-struct SwsContext *sws_getCachedContext(struct SwsContext *context,
- int srcW, int srcH, enum AVPixelFormat srcFormat,
- int dstW, int dstH, enum AVPixelFormat dstFormat,
- int flags, SwsFilter *srcFilter,
- SwsFilter *dstFilter, const double *param);
-
-/**
- * Convert an 8-bit paletted frame into a frame with a color depth of 32 bits.
- *
- * The output frame will have the same packed format as the palette.
- *
- * @param src source frame buffer
- * @param dst destination frame buffer
- * @param num_pixels number of pixels to convert
- * @param palette array with 256 entries, which must match color arrangement (RGB or BGR) of src
- */
-void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
-
-/**
- * Convert an 8-bit paletted frame into a frame with a color depth of 24 bits.
- *
- * With the palette format "ABCD", the destination frame ends up with the format "ABC".
- *
- * @param src source frame buffer
- * @param dst destination frame buffer
- * @param num_pixels number of pixels to convert
- * @param palette array with 256 entries, which must match color arrangement (RGB or BGR) of src
- */
-void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
-
-/**
- * Get the AVClass for swsContext. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- */
-const AVClass *sws_get_class(void);
-
-/**
- * @}
- */
-
-#endif /* SWSCALE_SWSCALE_H */

gpac-2.0.0.tar.gz/extra_lib/include/ffmpeg_android/libswscale/version.h Deleted

@@ -1,53 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef SWSCALE_VERSION_H
-#define SWSCALE_VERSION_H
-
-/**
- * @file
- * swscale version macros
- */
-
-#include "libavutil/version.h"
-
-#define LIBSWSCALE_VERSION_MAJOR 5
-#define LIBSWSCALE_VERSION_MINOR 1
-#define LIBSWSCALE_VERSION_MICRO 100
-
-#define LIBSWSCALE_VERSION_INT AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \
- LIBSWSCALE_VERSION_MINOR, \
- LIBSWSCALE_VERSION_MICRO)
-#define LIBSWSCALE_VERSION AV_VERSION(LIBSWSCALE_VERSION_MAJOR, \
- LIBSWSCALE_VERSION_MINOR, \
- LIBSWSCALE_VERSION_MICRO)
-#define LIBSWSCALE_BUILD LIBSWSCALE_VERSION_INT
-
-#define LIBSWSCALE_IDENT "SwS" AV_STRINGIFY(LIBSWSCALE_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- */
-
-#ifndef FF_API_SWS_VECTOR
-#define FF_API_SWS_VECTOR (LIBSWSCALE_VERSION_MAJOR < 6)
-#endif
-
-#endif /* SWSCALE_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavcodec/vaapi.h Deleted

gpac-2.0.0.tar.gz/include/gpac/options.h Deleted

@@ -1,336 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2022
- *					All rights reserved
- *
- * This file is part of GPAC / Stream Management sub-project
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-
-#ifndef _GF_OPTIONS_H_
-#define _GF_OPTIONS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/*!
-\file <gpac/options.h>
-\brief Compositor and terminal options.
-*/
-	
-/*!
-\addtogroup compose_grp Compositor
-\ingroup playback_grp
-\brief GPAC A/V/2D/3D compositor/rendering.
-
-This section documents the compositor of GPAC? in charge of assembling audio, images, video, text, 2D and 3D graphics with in a timed way
-
-@{
- */
-	
-/*! AspectRatio Type */
-enum
-{
-	 /*! keep AR*/
-	GF_ASPECT_RATIO_KEEP = 0,
-	/*! keep 16/9*/
-	GF_ASPECT_RATIO_16_9,
-	/*! keep 4/3*/
-	GF_ASPECT_RATIO_4_3,
-	/*! none (all rendering area used)*/
-	GF_ASPECT_RATIO_FILL_SCREEN
-};
-
-/*! AntiAlias settings*/
-enum
-{
-	/*! no antialiasing*/
-	GF_ANTIALIAS_NONE = 0,
-	/*! only text has antialiasing*/
-	GF_ANTIALIAS_TEXT,
-	/*! full antialiasing*/
-	GF_ANTIALIAS_FULL
-};
-
-/*! PlayState settings*/
-enum
-{
-	/*! terminal is playing (get only)*/
-	GF_STATE_PLAYING = 0,
-	/*! terminal is paused (get only)*/
-	GF_STATE_PAUSED,
-	/*! On set, terminal will pause after next frame (simulation tick). On get, indicates that rendering step hasn't performed yet*/
-	GF_STATE_STEP_PAUSE,
-	/*! indicates resume shall restart from live point if any rather than pause point (set only)*/
-	GF_STATE_PLAY_LIVE = 10
-};
-
-/*! interaction level settings
-\note GF_INTERACT_NORMAL and GF_INTERACT_NAVIGATION filter events. If set, any event processed by these 2 modules won't be forwarded to the user
-*/
-enum
-{
-	/*! regular interactions enabled (touch sensors)*/
-	GF_INTERACT_NORMAL = 1,
-	/*! InputSensor interactions enabled (mouse and keyboard)*/
-	GF_INTERACT_INPUT_SENSOR = 2,
-	/*! all navigation interactions enabled (mouse and keyboard)*/
-	GF_INTERACT_NAVIGATION = 4,
-};
-
-/*! BoundingVolume settings*/
-enum
-{
-	/*! doesn't draw bounding volume*/
-	GF_BOUNDS_NONE = 0,
-	/*! draw object bounding box / rect*/
-	GF_BOUNDS_BOX,
-	/*! draw object AABB tree (3D only) */
-	GF_BOUNDS_AABB
-};
-
-/*! Wireframe settings*/
-enum
-{
-	/*! draw solid volumes*/
-	GF_WIREFRAME_NONE = 0,
-	/*! draw only wireframe*/
-	GF_WIREFRAME_ONLY,
-	/*! draw wireframe on solid object*/
-	GF_WIREFRAME_SOLID
-};
-
-
-/*! navigation type*/
-enum
-{
-	/*! navigation is disabled by content and cannot be forced by user*/
-	GF_NAVIGATE_TYPE_NONE,
-	/*! 2D navigation modes only can be used*/
-	GF_NAVIGATE_TYPE_2D,
-	/*! 3D navigation modes only can be used*/
-	GF_NAVIGATE_TYPE_3D
-};
-
-/*! navigation modes - non-VRML ones are simply blaxxun contact ones*/
-enum
-{
-	/*! no navigation*/
-	GF_NAVIGATE_NONE = 0,
-	/*! 3D navigation modes*/
-	/*! walk navigation*/
-	GF_NAVIGATE_WALK,
-	/*! fly navigation*/
-	GF_NAVIGATE_FLY,
-	/*! pan navigation*/
-	GF_NAVIGATE_PAN,
-	/*! game navigation*/
-	GF_NAVIGATE_GAME,
-	/*! slide navigation, for 2D and 3D*/
-	GF_NAVIGATE_SLIDE,
-	/*! all modes below disable collision detection & gravity in 3D*/
-	/*examine navigation, for 2D and 3D */
-	GF_NAVIGATE_EXAMINE,
-	/*! orbit navigation - 3D only*/
-	GF_NAVIGATE_ORBIT,
-	/*! QT-VR like navigation - 3D only*/
-	GF_NAVIGATE_VR,
-};
-
-/*! collision flags*/
-enum
-{
-	/*! no collision*/
-	GF_COLLISION_NONE,
-	/*! regular collision*/
-	GF_COLLISION_NORMAL,
-	/*! collision with camera displacement*/
-	GF_COLLISION_DISPLACEMENT,
-};
-
-/*! TextTexturing settings*/
-enum
-{
-	/*! text drawn as texture in 3D mode, regular in 2D mode*/
-	GF_TEXTURE_TEXT_DEFAULT = 0,
-	/*! text never drawn as texture*/
-	GF_TEXTURE_TEXT_NEVER,
-	/*! text always drawn*/
-	GF_TEXTURE_TEXT_ALWAYS
-};
-
-/*! Normal drawing settings*/
-enum
-{
-	/*! normals never drawn*/
-	GF_NORMALS_NONE = 0,
-	/*! normals drawn per face (at barycenter)*/
-	GF_NORMALS_FACE,
-	/*! normals drawn per vertex*/
-	GF_NORMALS_VERTEX
-};
-
-
-/*! Back-face culling mode*/
-enum
-{
-	/*! backface culling disabled*/
-	GF_BACK_CULL_OFF = 0,
-	/*! backface culliong enabled*/
-	GF_BACK_CULL_ON,
-	/*! backface culling enabled also for transparent meshes*/
-	GF_BACK_CULL_ALPHA,
-};
-
-/*! 2D drawing mode*/
-enum
-{
-	/*! defer draw mode (only modified parts of the canvas are drawn)*/
-	GF_DRAW_MODE_DEFER=0,
-	/*! immediate draw mode (canvas always redrawn)*/
-	GF_DRAW_MODE_IMMEDIATE,
-	/*! defer debug draw mode (only modified parts of the canvas are drawn, the rest of the canvas is erased)*/
-	GF_DRAW_MODE_DEFER_DEBUG,
-};
-
-/*! high-level options*/
-enum
-{
-	/*! set/get antialias flag (value: one of the AntiAlias enum) - may be ignored in OpenGL mode depending on graphic cards*/
-	GF_OPT_ANTIALIAS =0,
-	/*! set/get fast mode (value: boolean) */
-	GF_OPT_HIGHSPEED,
-	/*! set/get fullscreen flag (value: boolean) */
-	GF_OPT_FULLSCREEN,
-	/*! reset top-level transform to original (value: boolean)*/
-	GF_OPT_ORIGINAL_VIEW,
-	/*! overrides BIFS size info for simple AV - this is not recommended since
-	it will resize the window to the size of the biggest texture (thus some elements
-	may be lost)*/
-	GF_OPT_OVERRIDE_SIZE,
-	/*! set / get audio volume (value is intensity between 0 and 100) */
-	GF_OPT_AUDIO_VOLUME,
-	/*! set / get audio pan (value is pan between 0 (all left) and 100(all right) )*/
-	GF_OPT_AUDIO_PAN,
-	/*! set / get audio mute*/
-	GF_OPT_AUDIO_MUTE,
-	/*! get javascript flag (no set, depends on compil) - value: boolean, true if JS enabled in build*/
-	GF_OPT_HAS_JAVASCRIPT,
-	/*! get selectable stream flag (no set) - value: boolean, true if audio/video/subtitle stream selection is
-	possible with content (if an MPEG-4 scene description is not present). Use regular OD browsing to get streams*/
-	GF_OPT_CAN_SELECT_STREAMS,
-	/*! set/get control interaction, OR'ed combination of interaction flags*/
-	GF_OPT_INTERACTION_LEVEL,
-	/*! set display window visible / get show/hide state*/
-	GF_OPT_VISIBLE,
-	/*! set freeze display on/off / get freeze state freeze_display prevents any screen updates
-	needed when output driver uses direct video memory access*/
-	GF_OPT_FREEZE_DISPLAY,
-	/*! Returns 1 if file playback is considered as done (all streams finished, no active time sensors
-	and no user interactions in the scene)*/
-	GF_OPT_IS_FINISHED,
-	/*! Returns 1 if file timeline is considered as done (all streams finished, no active time sensors)*/
-	GF_OPT_IS_OVER,
-	/*! set/get aspect ratio (value: one of AspectRatio enum) */
-	GF_OPT_ASPECT_RATIO,
-	/*! send a redraw message (SetOption only): all graphics info (display list, vectorial path) is
-	recomputed, and textures are reloaded in HW*/
-	GF_OPT_REFRESH,
-	/*! set/get stress mode (value: boolean) - in stress mode a GF_OPT_FORCE_REDRAW is emulated at each frame*/
-	GF_OPT_STRESS_MODE,
-	/*! get/set bounding volume drawing (value: one of the above option)*/
-	GF_OPT_DRAW_BOUNDS,
-	/*! get/set texture text option - when enabled and usable (that depends on content), text is first rendered
-	to a texture and only the texture is drawn, rather than drawing all the text each time (CPU intensive)*/
-	GF_OPT_TEXTURE_TEXT,
-	/*! reload config file (set only), including drivers. Plugins configs are not reloaded*/
-	GF_OPT_RELOAD_CONFIG,
-	/*! get: returns whether the content enable navigation and if it's 2D or 3D.
-	set: reset viewpoint (whatever value is given)*/
-	GF_OPT_NAVIGATION_TYPE,
-	/*! get current navigation mode - set navigation mode if allowed by content - this is not a resident
-	option (eg not stored in cfg)*/
-	GF_OPT_NAVIGATION,
-	/*! get/set Play state - cf above states for set*/
-	GF_OPT_PLAY_STATE,
-	/*! get only: returns 1 if main addon is playing, 0 if regular scene is playing*/
-	GF_OPT_MAIN_ADDON,
-	/*! get/set bench mode - if enabled, video frames are drawn as soon as possible witthout checking synchronisation*/
-	GF_OPT_VIDEO_BENCH,
-	/*! get/set OpenGL force mode - returns error if OpenGL is not supported*/
-	GF_OPT_USE_OPENGL,
-	/*! set/get draw mode*/
-	GF_OPT_DRAW_MODE,
-	/*! set/get scalable zoom (value: boolean)*/
-	GF_OPT_SCALABLE_ZOOM,
-	/*! set/get YUV acceleration (value: boolean) */
-	GF_OPT_YUV_HARDWARE,
-	/*! get (set not supported yet) hardware YUV format (value: YUV 4CC) */
-	GF_OPT_YUV_FORMAT,
-	/*! max video cache size in kbytes*/
-	GF_OPT_VIDEO_CACHE_SIZE,
-	/*! max HTTP download rate in bits per second, 0 if no limit*/
-	GF_OPT_HTTP_MAX_RATE,
-	/*! set only (value: boolean). If set, the main audio mixer can no longer be reconfigured. */
-	GF_OPT_FORCE_AUDIO_CONFIG,
-
-	/*!		3D ONLY OPTIONS		*/
-	/*! set/get raster outline flag (value: boolean) - when set, no vectorial outlining is done, only OpenGL raster outline*/
-	GF_OPT_RASTER_OUTLINES,
-	/*! set/get pow2 emulation flag (value: boolean) - when set, video textures with non power of 2 dimensions
-	are emulated as pow2 by expanding the video buffer (image is not scaled). Otherwise the entire image
-	is rescaled. This flag does not affect image textures, which are always rescaled*/
-	GF_OPT_EMULATE_POW2,
-	/*! get/set polygon antialiasing flag (value: boolean) (may be ugly with some cards)*/
-	GF_OPT_POLYGON_ANTIALIAS,
-	/*! get/set wireframe flag (value: cf above) (may be ugly with some cards)*/
-	GF_OPT_WIREFRAME,
-	/*! get/set wireframe flag (value: cf above) (may be ugly with some cards)*/
-	GF_OPT_NORMALS,
-	/*! disable backface culling*/
-	GF_OPT_BACK_CULL,
-	/*! get/set RECT Ext flag (value: boolean) - when set, GL rectangular texture extension is not used
-	(but NPO2 texturing is if available)*/
-	GF_OPT_NO_RECT_TEXTURE,
-	/*! set/get headlight (value: boolean)*/
-	GF_OPT_HEADLIGHT,
-	/*! set/get collision (value: cf above)*/
-	GF_OPT_COLLISION,
-	/*! set/get gravity*/
-	GF_OPT_GRAVITY,
-	/*! get the number of offscreen views in stereo mode, or 1 if no offscreen stereo views are available*/
-	GF_OPT_NUM_STEREO_VIEWS,
-	/*! set the mode of display of HEVC multiview videos, 0 to display the two views/layers and 1 to display just the first view/layer*/
-	GF_OPT_MULTIVIEW_MODE,
-	/*! get orientation sensors flag, true if sensors are activated false if not*/
-	GF_OPT_ORIENTATION_SENSORS_ACTIVE,
-};
-
-/*! @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif	/*_GF_USER_H_*/
-

gpac-2.0.0.tar.gz/include/gpac/term_info.h Deleted

@@ -1,298 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
- *					All rights reserved
- *
- * This file is part of GPAC / Stream Management sub-project
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-
-#ifndef _GF_TERM_INFO_H_
-#define _GF_TERM_INFO_H_
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
-\file <gpac/term_info.h>
-\brief GPAC media object browsing of the player.
-*/
-	
-/*!
-\addtogroup terminfo_grp Terminal Info
-\ingroup playback_grp
-\brief GPAC media object browsing of the player.
-
-This section documents how a user can get information on running media object in the player.
-
-@{
- */
-	
-
-/*
-	OD Browsing API - YOU MUST INCLUDE <gpac/terminal.h> before
-	(this has been separated from terminal.h to limit dependency of core to mpeg4_odf.h header)
-	ALL ITEMS ARE READ-ONLY AND SHALL NOT BE MODIFIED
-*/
-#include <gpac/mpeg4_odf.h>
-#include <gpac/terminal.h>
-
-/*! Media object manager*/
-typedef struct _od_manager GF_ObjectManager;
-
-/*! gets top-level OD of the presentation
-\param term the target terminal
-\return the root object descriptor or NULL if not connected*/
-GF_ObjectManager *gf_term_get_root_object(GF_Terminal *term);
-
-/*! gets number of objects in sub scene of object
-\param term the target terminal
-\param scene_od the OD to browse for resources. This must be an inline OD
-\return the number of objects in the scene described by the OD*/
-u32 gf_term_get_object_count(GF_Terminal *term, GF_ObjectManager *scene_od);
-
-/*! gets an OD manager in the scene
-\param term the target terminal
-\param scene_od the OD to browse for resources. This must be an inline OD
-\param index 0-based index of the obhect to query
-\return the object manager or NULL if not found
-*/
-GF_ObjectManager *gf_term_get_object(GF_Terminal *term, GF_ObjectManager *scene_od, u32 index);
-
-/*! gets the type of the associated subscene
-\param term the target terminal
-\param odm the object to query
-\return	0: regular media object, not inline, 1: root scene, 2: inline scene, 3: externProto library
-*/
-u32 gf_term_object_subscene_type(GF_Terminal *term, GF_ObjectManager *odm);
-
-/*! selects a given object when stream selection is available
-\param term the target terminal
-\param odm the object to select
-*/
-void gf_term_select_object(GF_Terminal *term, GF_ObjectManager *odm);
-
-/*! selects service by given ID for multiplexed services (MPEG-2 TS)
-\param term the target terminal
-\param odm an object in the scene attached to the same multiplex
-\param service_id the service ID to select
-*/
-void gf_term_select_service(GF_Terminal *term, GF_ObjectManager *odm, u32 service_id);
-
-/*! sets addon on or off (only one addon possible for now). When OFF, the associated service is shut down
-\param term the target terminal
-\param show_addons if GF_TRUE, displays addons otheriwse hides the addons
-*/
-void gf_term_toggle_addons(GF_Terminal *term, Bool show_addons);
-
-/*! checks for an existing service ID in a session
-\param term the target terminal
-\param odm an object in the scene attached to the same multiplex
-\param service_id the ID of the service to find
-\return GF_TRUE if given service ID is declared*/
-Bool gf_term_find_service(GF_Terminal *term, GF_ObjectManager *odm, u32 service_id);
-
-/*! Media Object information*/
-typedef struct
-{
-	u32 ODID;
-	u32 ServiceID;
-	u32 pid_id, ocr_id;
-	Double duration;
-	Double current_time;
-	/*0: stopped, 1: playing, 2: paused, 3: not setup, 4; setup failed.*/
-	u32 status;
-
-	Bool raw_media;
-	Bool generated_scene;
-
-	/*name of module handling the service service */
-	const char *service_handler;
-	/*name of service*/
-	const char *service_url;
-	/*service redirect object*/
-	const char *remote_url;
-	/*set if the service is owned by this object*/
-	Bool owns_service;
-
-	/*stream buffer:
-		-2: stream is not playing
-		-1: stream has no buffering
-		>=0: amount of media data present in buffer, in ms
-	*/
-	s32 buffer;
-	u32 min_buffer, max_buffer;
-	/*number of AUs in DB (cumulated on all input channels)*/
-	u32 db_unit_count;
-	/*number of CUs in composition memory (if any) and CM capacity*/
-	u32 cb_unit_count, cb_max_count;
-	/*inidciate that thye composition memory is bypassed for this decoder (video only) */
-	Bool direct_video_memory;
-	/*clock delay in ms of object clock: this is the delay set by the audio renderer to keep AV in sync
-	and corresponds to the amount of ms to delay non-audio streams to keep sync*/
-	s32 clock_drift;
-	/*codec name*/
-	const char *codec_name;
-	/*object type - match streamType (cf constants.h)*/
-	u32 od_type;
-	/*audio properties*/
-	u32 sample_rate, afmt, num_channels;
-	/*video properties (w & h also used for scene codecs)*/
-	u32 width, height, pixelFormat, par;
-
-	/*average birate over last second and max bitrate over one second at decoder input according to media timeline - expressed in bits per sec*/
-	u32 avg_bitrate, max_bitrate;
-	/*average birate over last second and max bitrate over one second at decoder input according to processing time - expressed in bits per sec*/
-	u32 avg_process_bitrate, max_process_bitrate;
-	u32 nb_dec_frames, nb_dropped;
-	u32 first_frame_time, last_frame_time;
-	u64 total_dec_time, irap_total_dec_time;
-	u32 max_dec_time, irap_max_dec_time;
-	u32 au_duration;
-	u32 nb_iraps;
-	s32 ntp_diff;
-	//0 if mono, 2 or more otherwise
-	u32 nb_views;
-
-	/*4CC of original protection scheme used*/
-	u32 protection;
-
-	u32 lang;
-	const char *lang_code;
-
-	/*name of media if not defined in OD framework*/
-	const char *media_url;
-} GF_MediaInfo;
-
-/*! gets information on an object
-\param term the target terminal
-\param odm the object manager to query
-\param info filled with object manager properties
-\return error if any
-*/
-GF_Err gf_term_get_object_info(GF_Terminal *term, GF_ObjectManager *odm, GF_MediaInfo *info);
-
-/*! gets current downloads info for the service - only use if ODM owns the service, returns 0 otherwise.
-\param term the target terminal
-\param odm the object manager to query
-\param d_enum in/out current enum - shall start to 0, incremented at each call. fct returns 0 if no more downloads
-\param url service URL
-\param bytes_done bytes downloaded for this service
-\param total_bytes total bytes for this service, may be 0 (eg http streaming)
-\param bytes_per_sec download speed
-\return GF_TRUE if success, GF_FALSE otherwise
-*/
-Bool gf_term_get_download_info(GF_Terminal *term, GF_ObjectManager *odm, u32 *d_enum, const char **url, u32 *bytes_done, u32 *total_bytes, u32 *bytes_per_sec);
-
-/*! Net statistics gathering object*/
-typedef struct
-{
-	/*percentage of packet loss from network. This cannot be figured out by the app since there is no
-	one-to-one mapping between the protocol packets and the final SL packet (cf RTP payloads)*/
-	Float pck_loss_percentage;
-	/*channel port, control channel port if any (eg RTCP)*/
-	u16 port, ctrl_port;
-	/*bandwidth used by channel & its control channel if any (both up and down) - expressed in bits per second
-	for HTTP connections, typically only bw_down is used*/
-	u32 bw_up, bw_down, ctrl_bw_down, ctrl_bw_up;
-	/*set to 0 if channel is not part of a multiplex. Otherwise set to the multiplex port, and
-	above port info shall be identifiers in the multiplex - note that multiplexing overhead is ignored
-	in GPAC for the current time*/
-	u16 multiplex_port;
-} GF_TermNetStats;
-
-/*! gets network statistics for the given channel in the given object
-\param term the target terminal
-\param odm the object manager to query
-\param d_enum in/out current enum - shall start to 0, incremented at each call. fct returns 0 if no more downloads
-\param chid set to the channel identifier
-\param net_stats filled with the channel network statistics
-\param ret_code set to the error code if error
-\return GF_TRUE if success, GF_FALSE otherwise
-*/
-Bool gf_term_get_channel_net_info(GF_Terminal *term, GF_ObjectManager *odm, u32 *d_enum, u32 *chid, GF_TermNetStats *net_stats, GF_Err *ret_code);
-
-/*! URL information for current session*/
-typedef struct
-{
-	u32 service_id;
-	u16 track_num;
-	u16 track_total;
-	u32 genre;
-	const char *album;
-	const char *artist;
-	const char *comment;
-	const char *composer;
-	const char *name;
-	const char *writer;
-	const char *provider;
-	//as in MPEG_DASH role
-	const char *role;
-	const char *accessibility;
-	const char *rating;
-} GF_TermURLInfo;
-/*! gets meta information about the service
-\param term the target terminal
-\param odm the object manager to query
-\param info filled with service information
-\return error if any
-*/
-GF_Err gf_term_get_service_info(GF_Terminal *term, GF_ObjectManager *odm, GF_TermURLInfo *info);
-
-/*! retrieves world info of the scene of an object.
-\param term the target terminal
-\param scene_od the object manager to query. If this is an inline OD, the world info of the inline content is retrieved. If NULL, the world info of the main scene is retrieved
-\param descriptions any textual descriptions is stored here (const strings not allocated, do NOT modify)
-\return NULL if no WorldInfo available or world title if available
-*/
-const char *gf_term_get_world_info(GF_Terminal *term, GF_ObjectManager *scene_od, GF_List *descriptions);
-
-/*! dumps scene graph in specified file, in BT or XMT format
-\param term the target terminal
-\param rad_name file radical (NULL for stdout) - if not NULL MUST BE GF_MAX_PATH length
-\param filename sets to the complete filename (rad + ext) and shall be destroyed by caller (optional can be NULL)
-\param xml_dump if GF_TRUE, duimps using XML format (XMT-A, X3D) for scene graphs having both XML and simple text representations
-\param skip_proto is GF_TRUE, proto declarations are not dumped
-\param odm if this is an inline OD, the inline scene is dumped; if this is NULL, the main scene is dumped; otherwise the parent scene is dumped
-\return error if any
-*/
-GF_Err gf_term_dump_scene(GF_Terminal *term, char *rad_name, char **filename, Bool xml_dump, Bool skip_proto, GF_ObjectManager *odm);
-
-/*! prints filter session statistics as log tool app log level debuf
-\param term the target terminal
-*/
-void gf_term_print_stats(GF_Terminal *term);
-
-/*! prints filter session graph as log tool app log level debuf
-\param term the target terminal
-*/
-void gf_term_print_graph(GF_Terminal *term);
-
-/*! @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif	/*_GF_TERM_INFO_H_*/

gpac-2.0.0.tar.gz/include/gpac/terminal.h Deleted

@@ -1,328 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
- *					All rights reserved
- *
- * This file is part of GPAC / Stream Management sub-project
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#ifndef _GF_TERMINAL_H_
-#define _GF_TERMINAL_H_
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/*!
-\file <gpac/terminal.h>
-\brief GPAC media player API.
- */
-	
-/*!
-\addtogroup playback_grp Media Player
-\brief GPAC media player (streaming engine and compositor).
-*/
-	
-/*!
-\addtogroup terminal_grp Terminal
-\ingroup playback_grp
-\brief GPAC media player APIs.
-
-This section documents the user-level API of the GPAC media player.
-
-@{
-*/
-	
-
-
-#include <gpac/user.h>
-
-/*! creates a new terminal for a userApp callback
-\param user a user description
-\return a new terminal*/
-GF_Terminal *gf_term_new(GF_User *user);
-
-/*! deletes a terminal - stop is done automatically
-\param term the target terminal
-\return error if any (GF_IO_ERR if client couldn't be shutdown normally)*/
-GF_Err gf_term_del(GF_Terminal *term);
-
-/*! connects to a URL - connection OK or error is acknowledged via the user callback
-\param term the target terminal
-\param URL the target URL
-*/
-void gf_term_connect(GF_Terminal *term, const char *URL);
-/*! disconnects the current url
-\param term the target terminal
-*/
-void gf_term_disconnect(GF_Terminal *term);
-
-/*! navigates to a given destination or shutdown/restart the current one if any.
-This is the only safe way of restarting/jumping a presentation from inside the EventProc
-where doing a disconnect/connect could deadlock if toURL is NULL, uses the current URL
-\param term the target terminal
-\param toURL the new target URL
-*/
-void gf_term_navigate_to(GF_Terminal *term, const char *toURL);
-
-/*! restarts url from given time (in ms).
-\param term the target terminal
-\param from_time restart time in milliseconds
-\param pause_at_first_frame if 1, pauses at the first frame. If 2, pauses at the first frame only if the terminal is in paused state.
-\return	0: service is not connected yet, 1: service has no seeking capabilities, 2: service has been seeked
-*/
-u32 gf_term_play_from_time(GF_Terminal *term, u64 from_time, u32 pause_at_first_frame);
-
-/*! connects URL and seek right away - only needed when reloading the complete player (avoids waiting
-for connection and post a seek..)
-
-\param term the target terminal
-\param URL the target URL
-\param time_in_ms connect time in milliseconds
-\param pause_at_first_frame if 1, pauses rendering and streaming when starting, if 2 pauses only rendering
-*/
-void gf_term_connect_from_time(GF_Terminal *term, const char *URL, u64 time_in_ms, u32 pause_at_first_frame);
-
-/*! connects a URL but specify a parent path for this URL
-\param term the target terminal
-\param URL the target URL
-\param parent_URL the parent URL of the connected service
-*/
-void gf_term_connect_with_path(GF_Terminal *term, const char *URL, const char *parent_URL);
-
-/*! gets framerate
-\param term the target terminal
-\param absoluteFPS if GF_TRUE, the return value is the absolute framerate, eg NbFrameCount/NbTimeSpent regardless of whether a frame has been drawn or not, which means the FPS returned can be much greater than the target rendering framerate. If GF_FALSE, the return value is the FPS taking into account not drawn frames (eg, less than	or equal to compositor FPS)
-\return current framerate
-*/
-Double gf_term_get_framerate(GF_Terminal *term, Bool absoluteFPS);
-/*! gets main scene current time
-\param term the target terminal
-\return time in milliseconds
-*/
-u32 gf_term_get_time_in_ms(GF_Terminal *term);
-
-/*! gets elapsed time since loading of the scene - may be different from scene time when seeking or live content
-\param term the target terminal
-\return time elapsed in milliseconds
-*/
-u32 gf_term_get_elapsed_time_in_ms(GF_Terminal *term);
-
-/*! gets current URL
-\param term the target terminal
-\return the current URL
-*/
-const char *gf_term_get_url(GF_Terminal *term);
-
-/*! gets viewpoints/viewports for main scene
-\param term the target terminal
-\param viewpoint_idx 1-based index of the viewport to query
-\param outName set to the name of the viewport
-\param is_bound set to GF_TRUE of that viewport is bound
-\return error if any, GF_EOS if index is greater than number of viewpoints
-*/
-GF_Err gf_term_get_viewpoint(GF_Terminal *term, u32 viewpoint_idx, const char **outName, Bool *is_bound);
-
-/*! sets active viewpoints/viewports for main scene given its name
-\note if only one viewpoint is present in the scene
-\param term the target terminal
-\param viewpoint_idx 1-based index of the viewport to set or 0 to set by viewpoint name
-\param viewpoint_name name of the viewport
-\return error if any, GF_EOS if index is greater than number of viewpoints
-*/
-GF_Err gf_term_set_viewpoint(GF_Terminal *term, u32 viewpoint_idx, const char *viewpoint_name);
-
-/*! adds an object to the scene - only possible if scene has selectable streams (cf GF_OPT_CAN_SELECT_STREAMS option)
-\param term the target terminal
-\param url the URL of the object to inject
-\param auto_play selcts the object for playback when inserting it
-\return error if any
-*/
-GF_Err gf_term_add_object(GF_Terminal *term, const char *url, Bool auto_play);
-
-/*! sets option - most of the terminal cfg is done through options, please refer to options.h for details
-\param term the target terminal
-\param opt_type option to set
-\param opt_value option value
-\return error if any
-*/
-GF_Err gf_term_set_option(GF_Terminal *term, u32 opt_type, u32 opt_value);
-
-/*! gets option - most of the terminal cfg is done through options, please refer to options.h for details
-\param term the target terminal
-\param opt_type option to set
-\return option value
-*/
-u32 gf_term_get_option(GF_Terminal *term, u32 opt_type);
-
-/*! checks if given URL is understood by client.
-\param term the target terminal
-\param URL the URL to check
-\param use_parent_url if GF_TRUE, relative URLs are solved against the current presentation URL
-\param no_mime_check if GF_TRUE, checks by file extension only
-\return GF_TRUE if client should be able to handle the URL*/
-Bool gf_term_is_supported_url(GF_Terminal *term, const char *URL, Bool use_parent_url, Bool no_mime_check);
-
-/*! get the current service ID for MPEG-2 TS mux
-\param term the target terminal
-\return service ID or 0 if no service ID is associated or not loaded yet
-*/
-u32 gf_term_get_current_service_id(GF_Terminal *term);
-
-/*! gets simulation frame rate
-\param term the target terminal
-\param nb_frames_drawn set to the number of frames drawn
-\return simulation frames per seconds
-*/
-Double gf_term_get_simulation_frame_rate(GF_Terminal *term, u32 *nb_frames_drawn);
-
-/*! gets visual output size (current window/display size)
-\param term the target terminal
-\param width set to the display width
-\param height set to the display height
-\return error if any
-*/
-GF_Err gf_term_get_visual_output_size(GF_Terminal *term, u32 *width, u32 *height);
-/*! sets playback speed
-\param term the target terminal
-\param speed the requested speed
-\return error if any
-*/
-GF_Err gf_term_set_speed(GF_Terminal *term, Fixed speed);
-
-/*! sends a set of scene commands (BT, XMT, X3D, LASeR+XML) to the scene
-\param term the target terminal
-\param type indicates the language used - accepted values are
-	"model/x3d+xml" or "x3d": commands is an X3D+XML scene
-	"model/x3d+vrml" or "xrdv": commands is an X3D+VRML scene
-	"model/vrml" or "vrml": commands is an VRML scene
-	"application/x-xmt" or "xmt": commands is an XMT-A scene or a list of XMT-A updates
-	"application/x-bt" or "bt": commands is a BT scene or a list of BT updates
-	"image/svg+xml" or "svg": commands is an SVG scene
-	"application/x-laser+xml" or "laser": commands is an SVG/LASeR+XML scene or a list of LASeR+XML updates
-	if not specified, the type will be guessed from the current root node if any
-\param com the textual update
-\return error if any
-*/
-GF_Err gf_term_scene_update(GF_Terminal *term, char *type, char *com);
-
-/*! sets visual output size change:
-	* NOT NEEDED WHEN THE TERMINAL IS HANDLING THE DISPLAY WINDOW (cf user.h)
-	* if the user app manages the output window it shall resize it before calling this
-
-\param term the target terminal
-\param NewWidth the output width in pixels
-\param NewHeight the output height in pixels
-\return error if any
-*/
-GF_Err gf_term_set_size(GF_Terminal *term, u32 NewWidth, u32 NewHeight);
-
-/*! returns current text selection.
-\param term the target terminal
-\param probe_only if GF_TRUE, simply returns a non-NULL string ("") if some text is selected
-\return text selection if any, or NULL otherwise. */
-const char *gf_term_get_text_selection(GF_Terminal *term, Bool probe_only);
-
-/*! pastes text into current selection if any.
-\param term the target terminal
-\param txt the text to set
-\param probe_only if GF_TRUE, only check if text is currently edited
-\return error if any
-*/
-GF_Err gf_term_paste_text(GF_Terminal *term, const char *txt, Bool probe_only);
-
-/*! processes pending tasks in the media session
-\note If filter session regulation is not disabled, the function will sleep for until next frame should be drawn before returning.
-\param term the target terminal
-\return GF_TRUE if a new frame was drawn, GF_FALSE otherwise
-*/
-Bool gf_term_process_step(GF_Terminal *term);
-
-/*! post user interaction to terminal
-\param term the target terminal
-\param event the event to post
-\return GF_TRUE if event was directly consumed
-*/
-Bool gf_term_user_event(GF_Terminal *term, GF_Event *event);
-
-/*! post event to terminal
-\warning NOT NEEDED WHEN THE TERMINAL IS HANDLING THE DISPLAY WINDOW (cf user.h)
-\param term the target terminal
-\param evt the event to post
-\return GF_TRUE if event was directly consumed
-*/
-Bool gf_term_send_event(GF_Terminal *term, GF_Event *evt);
-
-
-
-
-/*framebuffer access*/
-#include <gpac/color.h>
-
-/*! gets screen buffer
-\note the screen buffer is released by calling gf_term_release_screen_buffer
-\param term the target terminal
-\param framebuffer set to the framebuffer information
-\return error if any
-*/
-GF_Err gf_term_get_screen_buffer(GF_Terminal *term, GF_VideoSurface *framebuffer);
-
-/*! gets view buffer - this locks the scene graph too until released is called
-\note the screen buffer is released by calling gf_term_release_screen_buffer
-\param term the target terminal
-\param framebuffer set to the framebuffer information
-\param view_idx indicates the view index, and ranges from 0 to GF_OPT_NUM_STEREO_VIEWS value
-\param depth_buffer_type indicates the depth buffer mode
-\return error if any
-*/
-GF_Err gf_term_get_offscreen_buffer(GF_Terminal *term, GF_VideoSurface *framebuffer, u32 view_idx, GF_CompositorGrabMode depth_buffer_type);
-
-/*! releases screen buffer and unlocks graph
-\param term the target terminal
-\param framebuffer the pointer passed to \ref gf_term_get_screen_buffer
-\return error if any
-*/
-GF_Err gf_term_release_screen_buffer(GF_Terminal *term, GF_VideoSurface *framebuffer);
-
-/*! switches quality up or down - can be called several time in the same direction
-this will call all decoders to adjust their quality levels
-
-\param term the target terminal
-\param up if GF_TRUE, switches quality up,otherwise down
-*/
-void gf_term_switch_quality(GF_Terminal *term, Bool up);
-
-/*! checks if a mime type is supported
-\param term the target terminal
-\param mime the mime type to check
-\return GF_TRUE if supported
-*/
-Bool gf_term_is_type_supported(GF_Terminal *term, const char* mime);
-
-/*! @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif	/*_GF_TERMINAL_H_*/

gpac-2.0.0.tar.gz/include/gpac/user.h Deleted

@@ -1,122 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
- *					All rights reserved
- *
- * This file is part of GPAC / Stream Management sub-project
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-
-#ifndef _GF_USER_H_
-#define _GF_USER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/*!
-\file <gpac/user.h>
-\brief GPAC terminal <-> user API.
-*/
-
-/*!
-\addtogroup termuser_grp Terminal User
-\ingroup playback_grp
-\brief GPAC terminal <-> user API.
-
-This section documents the user-level API of the GPAC media player.
-
-@{
-*/
-
-
-
-
-#include <gpac/events.h>
-#include <gpac/module.h>
-
-/*! GPAC client terminal*/
-typedef struct _tag_terminal GF_Terminal;
-/*! GPAC user structure*/
-typedef struct _tag_user GF_User;
-
-/*! terminal creation flags*/
-enum
-{
-	/*display should be hidden upon initialization*/
-	GF_TERM_INIT_HIDE = 1,
-	/*no audio renderer will be created*/
-	GF_TERM_NO_AUDIO = 1<<1,
-	/*initializes client without a default audio out - used for dump modes where audio playback is not needed*/
-	GF_TERM_NO_DEF_AUDIO_OUT = 1<<2,
-	/*disables video output module - used for bench mode without video*/
-	GF_TERM_NO_VIDEO = 1<<3,
-	/*works without window thread*/
-	GF_TERM_WINDOW_NO_THREAD = 1<<4,
-	/*lets the main user handle window events (needed for browser plugins)*/
-	GF_TERM_NO_WINDOWPROC_OVERRIDE = 1<<5,
-	/*works without title bar*/
-	GF_TERM_WINDOW_NO_DECORATION = 1<<6,
-
-	/*framebuffer works in 32 bit alpha mode - experimental, only supported on Win32*/
-	GF_TERM_WINDOW_TRANSPARENT = 1<<7,
-	/*works in windowless mode - experimental, only supported on Win32*/
-	GF_TERM_WINDOWLESS = 1<<8
-};
-
-/*user object for all callbacks*/
-struct _tag_user
-{
-	/*! user defined callback for all functions - cannot be NULL*/
-	void *opaque;
-	/*! the event proc. Return value depend on the event type, usually 0
-	cannot be NULL if os_window_handler is specified and dont_override_window_proc is set
-	may be NULL otherwise*/
-	Bool (*EventProc)(void *opaque, GF_Event *event);
-
-	/*! optional os window handler (HWND on win32/winCE, XWindow for X11)
-	if not set the video outut will create and manage the display window.*/
-	void *os_window_handler;
-	/*! for now, only used by X11 (indicates display the window is on)*/
-	void *os_display;
-
-	/*! init flags bypassing GPAC config file	*/
-	u32 init_flags;
-};
-
-/*! compositor screen buffer grab mode*/
-typedef enum
-{
-	GF_SC_GRAB_DEPTH_NONE = 0,
-	GF_SC_GRAB_DEPTH_ONLY = 1,
-	GF_SC_GRAB_DEPTH_RGBD = 2,
-	GF_SC_GRAB_DEPTH_RGBDS = 3
-} GF_CompositorGrabMode;
-
-/*! @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif	/*_GF_USER_H_*/
-

gpac-2.0.0.tar.gz/modules/droid_cam Deleted

gpac-2.0.0.tar.gz/modules/droid_cam/droid_cam.c Deleted

@@ -1,725 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Ivica Arsov, Jean Le Feuvre
- *			Copyright (c) Mines-Telecom 2009-
- *					All rights reserved
- *
- * This file is part of GPAC / Android camera module
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <gpac/terminal.h>
-#include <gpac/internal/terminal_dev.h>
-#include <gpac/internal/compositor_dev.h>
-#include <gpac/modules/codec.h>
-#include <gpac/constants.h>
-#include <gpac/modules/service.h>
-#include <gpac/thread.h>
-#include <gpac/media_tools.h>
-
-#include <jni.h>
-#include <android/log.h>
-
-#define LOG_TAG "ANDROID_CAMERA"
-#ifdef ANDROID
-# define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-# define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
-#else
-# define QUOTEME_(x) #x
-# define QUOTEME(x) QUOTEME_(x)
-# define LOGI(...) fprintf(stderr, "I/" LOG_TAG " (" __FILE__ ":" QUOTEME(__LINE__) "): " __VA_ARGS__)
-# define LOGE(...) fprintf(stderr, "E/" LOG_TAG "(" ")" __VA_ARGS__)
-#endif
-
-static JavaVM* javaVM = 0;
-static jclass camCtrlClass;
-static jmethodID cid;
-static jmethodID startCamera;
-static jmethodID stopCamera;
-static jmethodID startProcessing;
-static jmethodID stopProcessing;
-static jmethodID getImageFormat;
-static jmethodID getImageHeight;
-static jmethodID getImageWidth;
-static jmethodID getBitsPerPixel;
-
-#ifndef GPAC_STATIC_MODULES
-jint JNI_OnLoad(JavaVM* vm, void* reserved)
-#else
-jint static_JNI_OnLoad(JavaVM* vm, void* reserved)
-#endif
-{
-	JNIEnv* env = 0;
-	javaVM = vm;
-
-	if ( (*javaVM)->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
-		return -1;
-
-	// Get the class and its methods in the main env
-
-	// Get the CameraController class
-	// This is just a local refenrece. Cannot be used in the other JNI calls.
-	camCtrlClass = (*env)->FindClass(env, "com/gpac/Osmo4/Preview");
-	if (camCtrlClass == 0)
-	{
-		LOGE("CameraController class = null myCamera.c, startCameraNative()");
-		return -1;
-	}
-
-	// Get Global Reference to be able to use the class
-	camCtrlClass = (*env)->NewGlobalRef(env, camCtrlClass);
-	if ( camCtrlClass == 0 )
-	{
-		LOGE("MPEG-V_IN Cannot create Global Reference\n");
-		return -1;
-	}
-
-	// Get the method ID for the CameraController constructor.
-	cid = (*env)->GetMethodID(env, camCtrlClass, "<init>", "()V");
-	if (cid == 0)
-	{
-		LOGE("Method ID for CameraController constructor is null myCamera.c, startCameraNative()");
-		return -1;
-	}
-
-	// Get startCamera() method from class CameraController
-	startCamera = (*env)->GetMethodID(env, camCtrlClass, "initializeCamera", "(Z)Z");
-	if (startCamera == 0)
-	{
-		LOGE("ANDROID_CAMERA Function startCamera not found");
-		return -1;
-	}
-
-	stopCamera = (*env)->GetMethodID(env, camCtrlClass, "stopCamera", "()V");
-	if (stopCamera == 0)
-	{
-		LOGE("ANDROID_CAMERA Function stopCamera not found");
-		return -1;
-	}
-
-	startProcessing = (*env)->GetMethodID(env, camCtrlClass, "resumePreview", "()V");
-	if (startProcessing == 0)
-	{
-		LOGE("ANDROID_CAMERA Function startProcessing not found");
-		return -1;
-	}
-
-	stopProcessing = (*env)->GetMethodID(env, camCtrlClass, "pausePreview", "()V");
-	if (stopProcessing == 0)
-	{
-		LOGE("ANDROID_CAMERA Function stopProcessing not found");
-		return -1;
-	}
-
-	getImageFormat = (*env)->GetMethodID(env, camCtrlClass, "getPreviewFormat", "()I");
-	if (getImageFormat == 0)
-	{
-		LOGE("ANDROID_CAMERA Function getImageFormat not found");
-		return -1;
-	}
-
-	getImageHeight = (*env)->GetMethodID(env, camCtrlClass, "getImageHeight", "()I");
-	if (getImageHeight == 0)
-	{
-		LOGE("ANDROID_CAMERA Function getImageHeight not found");
-		return -1;
-	}
-
-	getImageWidth = (*env)->GetMethodID(env, camCtrlClass, "getImageWidth", "()I");
-	if (getImageWidth == 0)
-	{
-		LOGE("ANDROID_CAMERA Function getImageWidth not found");
-		return -1;
-	}
-
-	getBitsPerPixel = (*env)->GetMethodID(env, camCtrlClass, "getBitsPerPixel", "()I");
-	if (getBitsPerPixel == 0)
-	{
-		LOGE("ANDROID_CAMERA Function getBitsPerPixel not found");
-		return -1;
-	}
-
-	return JNI_VERSION_1_2;
-}
-
-#ifndef GPAC_STATIC_MODULES
-//----------------------------------------------------------------------
-JavaVM* GetJavaVM()
-{
-	return javaVM;
-}
-
-JNIEnv* GetEnv()
-{
-	JNIEnv* env;
-	if ( (*GetJavaVM())->GetEnv(GetJavaVM(), (void**)&env, JNI_VERSION_1_2) != JNI_OK )
-		return NULL;
-
-	return env;
-}
-#else
-JavaVM* GetJavaVM();
-JNIEnv* GetEnv();
-
-#endif
-
-void JNI_OnUnload(JavaVM *vm, void *reserved)
-{
-	JNIEnv* env = 0;
-
-	if ( (*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
-		return;
-
-	(*env)->DeleteGlobalRef(env, camCtrlClass);
-}
-//----------------------------------------------------------------------
-
-
-//#define CAM_PIXEL_FORMAT GF_PIXEL_NV21
-//GF_PIXEL_RGB_32
-//#define CAM_PIXEL_SIZE 1.5f
-//4
-#define CAM_WIDTH 640
-#define CAM_HEIGHT 480
-
-//GF_PIXEL_RGB_24;
-
-typedef struct
-{
-	GF_InputService *input;
-	/*the service we're responsible for*/
-	GF_ClientService *service;
-	LPNETCHANNEL channel;
-
-	/*input file*/
-	u32 time_scale;
-
-	u32 base_track_id;
-
-	struct _tag_terminal *term;
-
-	u32 cntr;
-
-	u32 width;
-	u32 height;
-
-	Bool started;
-
-	JNIEnv* env;
-	u8 isAttached;
-	jclass camCtrlClass;
-	jmethodID cid;
-	jobject camCtrlObj;
-	jmethodID startCamera;
-	jmethodID stopCamera;
-	jmethodID startProcessing;
-	jmethodID stopProcessing;
-	jmethodID getImageFormat;
-	jmethodID getImageHeight;
-	jmethodID getImageWidth;
-	jmethodID getBitsPerPixel;
-
-} ISOMReader;
-
-ISOMReader* globReader;
-
-void loadCameraControler(ISOMReader *read);
-void camStartCamera(ISOMReader *read);
-void camStopCamera(ISOMReader *read);
-
-Bool CAM_CanHandleURL(GF_InputService *plug, const char *url)
-{
-	if (!strnicmp(url, "hw://camera", 11)) return 1;
-
-	return 0;
-}
-
-void unloadCameraControler(ISOMReader *read)
-{
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA unloadCameraControler: %d\n", gf_th_id()));
-	if ( read->isAttached )
-	{
-		//(*rc->env)->PopLocalFrame(rc->env, NULL);
-		(*GetJavaVM())->DetachCurrentThread(GetJavaVM());
-		read->isAttached = 0;
-	}
-
-	read->env = NULL;
-}
-
-u32 unregisterFunc(void* data)
-{
-	unloadCameraControler(globReader);
-	return 0;
-}
-
-void loadCameraControler(ISOMReader *read)
-{
-	JNIEnv* env = NULL;
-	jint res = 0;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA loadCameraControler: %d\n", gf_th_id()));
-
-	// Get the JNI interface pointer
-	res = (*GetJavaVM())->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2);
-	if ( res == JNI_EDETACHED )
-	{
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA The current thread is not attached to the VM, assuming native thread\n"));
-		res = (*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
-		if ( res )
-		{
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("ANDROID_CAMERA Attach current thread failed: %d\n", res));
-			return;
-		}
-		gf_register_before_exit_function(gf_th_current(), unregisterFunc);
-		read->isAttached = 1;
-		//(*rc->env)->PushLocalFrame(rc->env, 2);
-	}
-	else if ( res == JNI_EVERSION )
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("ANDROID_CAMERA The specified version is not supported\n"));
-		return;
-	}
-
-	read->env = env;
-	read->camCtrlClass = camCtrlClass;
-	read->cid = cid;
-	read->startCamera = startCamera;
-	read->stopCamera = stopCamera;
-	read->startProcessing = startProcessing;
-	read->stopProcessing = stopProcessing;
-	read->getImageFormat = getImageFormat;
-	read->getImageHeight = getImageHeight;
-	read->getImageWidth = getImageWidth;
-	read->getBitsPerPixel = getBitsPerPixel;
-
-	// Create the object.
-	read->camCtrlObj = (*env)->NewObject(env, read->camCtrlClass, read->cid);
-	if (read->camCtrlObj == 0)
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CameraController object creation failed. myCamera.c, startCameraNative()"));
-		return;
-	}
-}
-
-GF_Err CAM_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
-{
-	ISOMReader *read;
-	if (!plug || !plug->priv || !serv) return GF_SERVICE_ERROR;
-	read = (ISOMReader *) plug->priv;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_ConnectService: %d\n", gf_th_id()));
-
-	read->input = plug;
-	read->service = serv;
-	read->base_track_id = 1;
-	read->time_scale = 1000;
-
-	read->term = serv->term;
-
-	loadCameraControler(read);
-
-	camStartCamera(read);
-
-	/*reply to user*/
-	gf_service_connect_ack(serv, NULL, GF_OK);
-	//if (read->no_service_desc) isor_declare_objects(read);
-
-	return GF_OK;
-}
-
-GF_Err CAM_CloseService(GF_InputService *plug)
-{
-	GF_Err reply;
-	ISOMReader *read;
-	if (!plug || !plug->priv) return GF_SERVICE_ERROR;
-	read = (ISOMReader *) plug->priv;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_CloseService: %d\n", gf_th_id()));
-
-	reply = GF_OK;
-
-	(*GetEnv())->DeleteLocalRef( GetEnv(), read->camCtrlObj );
-	read->camCtrlObj = NULL;
-
-	//unloadCameraControler(read);
-
-	gf_service_disconnect_ack(read->service, NULL, reply);
-	return GF_OK;
-}
-
-u32 getWidth(ISOMReader *read);
-u32 getHeight(ISOMReader *read);
-u32 getFormat(ISOMReader *read);
-u32 getBitsPerPix(ISOMReader *read);
-
-static GF_Descriptor *CAM_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
-{
-	u32 trackID;
-	ISOMReader *read;
-	char *buf;
-	u32 buf_size;
-	if (!plug || !plug->priv) return NULL;
-	read = (ISOMReader *) plug->priv;
-
-	trackID = read->base_track_id;
-	read->base_track_id = 0;
-
-	if (trackID && (expect_type==GF_MEDIA_OBJECT_VIDEO) ) {
-		GF_BitStream *bs;
-		GF_ESD *esd;
-		GF_ObjectDescriptor *od;
-		od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
-		od->objectDescriptorID = 1;
-
-		esd = gf_odf_desc_esd_new(0);
-		esd->slConfig->timestampResolution = 1000;
-		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
-		esd->ESID = 1;
-		esd->decoderConfig->objectTypeIndication = GPAC_OTI_RAW_MEDIA_STREAM;
-
-		bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-
-		read->width = getWidth(read);
-		read->height = getHeight(read);
-
-		gf_bs_write_u32(bs, getFormat(read)); // fourcc
-		gf_bs_write_u16(bs, read->width); // width
-		gf_bs_write_u16(bs, read->height); // height
-		gf_bs_write_u32(bs, read->width * read->height * getBitsPerPix(read) / 8); // framesize
-		gf_bs_write_u32(bs, read->width); // stride
-
-		gf_bs_align(bs);
-		gf_bs_get_content(bs, &buf, &buf_size);
-		gf_bs_del(bs);
-
-		esd->decoderConfig->decoderSpecificInfo->data = buf;
-		esd->decoderConfig->decoderSpecificInfo->dataLength = buf_size;
-
-		gf_list_add(od->ESDescriptors, esd);
-		return (GF_Descriptor *) od;
-	}
-
-	return NULL;
-}
-
-
-
-
-GF_Err CAM_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
-{
-	GF_Err e;
-	ISOMReader *read;
-	if (!plug || !plug->priv) return GF_SERVICE_ERROR;
-	read = (ISOMReader *) plug->priv;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_ConnectChannel: %d\n", gf_th_id()));
-
-	e = GF_OK;
-	if (upstream) {
-		e = GF_ISOM_INVALID_FILE;
-	}
-
-	read->channel = channel;
-
-	gf_service_connect_ack(read->service, channel, e);
-	return e;
-}
-
-GF_Err CAM_DisconnectChannel(GF_InputService *plug, LPNETCHANNEL channel)
-{
-	GF_Err e;
-	ISOMReader *read;
-	if (!plug || !plug->priv) return GF_SERVICE_ERROR;
-	read = (ISOMReader *) plug->priv;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_DisconnectChannel: %d\n", gf_th_id()));
-
-	e = GF_OK;
-
-	camStopCamera(read);
-
-	gf_service_disconnect_ack(read->service, channel, e);
-	return e;
-}
-
-void Java_com_gpac_Osmo4_Preview_processFrameBuf( JNIEnv* env, jobject thiz, jbyteArray arr)
-{
-	ISOMReader* ctx = globReader;
-	if ( ctx
-	 	&& ctx->started
-	 	&& ctx->term
-	 	&& ctx->term->compositor
-	 	&& ctx->term->compositor->audio_renderer
-	) {
-
-		u8* data;
-		u32 datasize;
-		GF_SLHeader hdr;
-		u32 cts = 0;
-		//u32 convTime = 0;
-		//u32 j = 0;
-		jbyte *jdata;
-		jsize len;
-
-		len = (*env)->GetArrayLength(env, arr);
-		if ( len <= 0 ) return;
-		jdata = (*env)->GetByteArrayElements(env,arr,0);
-
-		//convTime = gf_term_get_time(ctx->term);
-
-		data = (u8*)jdata;//(u8*)decodeYUV420SP((char*)jdata, ctx->width, ctx->height); //
-		datasize = len;//ctx->width * ctx->height * CAM_PIXEL_SIZE;//
-
-		cts = gf_term_get_time(ctx->term);
-
-		//convTime = cts - convTime;
-
-		memset(&hdr, 0, sizeof(hdr));
-		hdr.compositionTimeStampFlag = 1;
-		hdr.compositionTimeStamp = cts;
-		gf_service_send_packet(ctx->service, ctx->channel, (void*)data, datasize, &hdr, GF_OK);
-
-		//gf_free(data);
-
-		(*env)->ReleaseByteArrayElements(env,arr,jdata,JNI_ABORT);
-
-		//GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Camera Frame Sent %d\n", gf_sys_clock()));
-	}
-}
-
-void CallCamMethod(ISOMReader *read, jmethodID methodID)
-{
-	JNIEnv* env = NULL;
-	jint res = 0;
-	u8 isAttached = 0;
-
-	// Get the JNI interface pointer
-	res = (*GetJavaVM())->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2);
-	if ( res == JNI_EDETACHED )
-	{
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA The current thread is not attached to the VM, assuming native thread\n"));
-		res = (*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
-		if ( res ) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("ANDROID_CAMERA Attach current thread failed: %d\n", res));
-			return;
-		}
-		if ( env != read->env )
-			isAttached = 1;
-	}
-
-	(*env)->CallNonvirtualVoidMethod(env, read->camCtrlObj, read->camCtrlClass, methodID);
-
-	if (isAttached)
-	{
-		(*GetJavaVM())->DetachCurrentThread(GetJavaVM());
-	}
-}
-
-void camStartCamera(ISOMReader *read)
-{
-	JNIEnv* env;
-	jboolean isPortrait = JNI_FALSE;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA startCamera: %d\n", gf_th_id()));
-
-	// Get the JNI interface pointer
-	env = read->env;
-
-	(*env)->CallNonvirtualBooleanMethod(env, read->camCtrlObj, read->camCtrlClass, read->startCamera, isPortrait);
-}
-
-void camStopCamera(ISOMReader *read)
-{
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA stopCamera: %d\n", gf_th_id()));
-
-	CallCamMethod(read, read->stopCamera);
-}
-
-void pauseCamera(ISOMReader *read)
-{
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA pauseCamera: %d\n", gf_th_id()));
-
-	read->started = 0;
-	CallCamMethod(read, read->stopProcessing);
-}
-
-void resumeCamera(ISOMReader *read)
-{
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA resumeCamera: %d\n", gf_th_id()));
-
-	read->started = 1;
-	CallCamMethod(read, read->startProcessing);
-}
-
-u32 getWidth(ISOMReader *read)
-{
-	JNIEnv* env;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getWidth: %d\n", gf_th_id()));
-
-	// Get the JNI interface pointer
-	env = read->env;
-
-	return (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getImageWidth);
-}
-
-u32 getHeight(ISOMReader *read)
-{
-	JNIEnv* env;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getHeight: %d\n", gf_th_id()));
-
-	// Get the JNI interface pointer
-	env = read->env;
-
-	return (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getImageHeight);
-}
-
-u32 getFormat(ISOMReader *read)
-{
-	JNIEnv* env;
-	u32 pixel_format;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getFormat: %d\n", gf_th_id()));
-
-	// Get the JNI interface pointer
-	env = read->env;
-
-	pixel_format = (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getImageFormat);
-	switch (pixel_format) {
-	case 17: //NV21
-		return GF_PIXEL_NV21;
-	case 842094169: //YV12
-		return GF_PIXEL_YV12;
-	default:
-		return 0; //should never be here
-	}
-}
-
-u32 getBitsPerPix(ISOMReader *read)
-{
-	JNIEnv* env;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getBitsPerPix: %d\n", gf_th_id()));
-
-	// Get the JNI interface pointer
-	env = read->env;
-
-	return (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getBitsPerPixel);
-}
-
-GF_Err CAM_ServiceCommand(GF_InputService *plug, GF_NetworkCommand *com)
-{
-	ISOMReader *read;
-	if (!plug || !plug->priv || !com) return GF_SERVICE_ERROR;
-	read = (ISOMReader *) plug->priv;
-
-	if (com->command_type==GF_NET_SERVICE_INFO) {
-		return GF_OK;
-	}
-	if (com->command_type==GF_NET_SERVICE_HAS_AUDIO) {
-		return GF_NOT_SUPPORTED;
-	}
-	if (!com->base.on_channel) return GF_NOT_SUPPORTED;
-
-	switch (com->command_type) {
-	case GF_NET_CHAN_INTERACTIVE:
-		return GF_OK;
-	case GF_NET_CHAN_BUFFER:
-		com->buffer.max = com->buffer.min = 0;
-		return GF_OK;
-	case GF_NET_CHAN_PLAY:
-		resumeCamera(read);
-		return GF_OK;
-	case GF_NET_CHAN_STOP:
-		pauseCamera(read);
-		return GF_OK;
-	/*nothing to do on MP4 for channel config*/
-	case GF_NET_CHAN_CONFIG:
-		return GF_OK;
-	default:
-		break;
-	}
-	return GF_NOT_SUPPORTED;
-}
-
-GF_InputService *CAM_client_load()
-{
-	ISOMReader *reader;
-	GF_InputService *plug;
-	GF_SAFEALLOC(plug, GF_InputService);
-	GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC Camera Plugin", "gpac distribution")
-	plug->CanHandleURL = CAM_CanHandleURL;
-	plug->ConnectService = CAM_ConnectService;
-	plug->CloseService = CAM_CloseService;
-	plug->GetServiceDescriptor = CAM_GetServiceDesc;
-	plug->ConnectChannel = CAM_ConnectChannel;
-	plug->DisconnectChannel = CAM_DisconnectChannel;
-	plug->ServiceCommand = CAM_ServiceCommand;
-
-	GF_SAFEALLOC(reader, ISOMReader);
-	plug->priv = reader;
-	globReader = reader;
-
-
-#ifdef GPAC_STATIC_MODULES
-	static_JNI_OnLoad(GetJavaVM(), NULL);
-#endif
-
-	return plug;
-}
-
-void CAM_client_del(GF_BaseInterface *bi)
-{
-	GF_InputService *plug = (GF_InputService *) bi;
-	ISOMReader *read = (ISOMReader *)plug->priv;
-
-	gf_free(read);
-	gf_free(bi);
-}
-
-GPAC_MODULE_EXPORT
-const u32 *QueryInterfaces()
-{
-	static u32 si = {
-		GF_NET_CLIENT_INTERFACE,
-		0
-	};
-	return si;
-}
-
-GPAC_MODULE_EXPORT
-GF_BaseInterface *LoadInterface(u32 InterfaceType)
-{
-	if (InterfaceType == GF_NET_CLIENT_INTERFACE)
-		return (GF_BaseInterface *)CAM_client_load();
-	return NULL;
-}
-
-GPAC_MODULE_EXPORT
-void ShutdownInterface(GF_BaseInterface *ifce)
-{
-	switch (ifce->InterfaceType) {
-	case GF_NET_CLIENT_INTERFACE:
-		CAM_client_del(ifce);
-		break;
-	}
-}
-
-GPAC_MODULE_STATIC_DECLARATION( droid_cam )

gpac-2.0.0.tar.gz/modules/droid_mpegv Deleted

gpac-2.0.0.tar.gz/modules/droid_mpegv/droid_mpegv.c Deleted

@@ -1,495 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Ivica Arsov, Jean Le Feuvre
- *			Copyright (c) Mines-Telecom 2009-
- *					All rights reserved
- *
- * This file is part of GPAC / MPEG-V Input sensor for android
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <jni.h>
-#include <android/log.h>
-
-/*driver interfaces*/
-
-#include <gpac/list.h>
-#include <gpac/constants.h>
-
-#include <gpac/setup.h>
-
-#include <gpac/modules/codec.h>
-#include <gpac/scenegraph_vrml.h>
-
-#include <gpac/thread.h>
-
-#define LOG_TAG "MPEG-V_IN"
-#ifdef ANDROID
-# define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-# define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
-#else
-# define QUOTEME_(x) #x
-# define QUOTEME(x) QUOTEME_(x)
-# define LOGI(...) fprintf(stderr, "I/" LOG_TAG " (" __FILE__ ":" QUOTEME(__LINE__) "): " __VA_ARGS__)
-# define LOGE(...) fprintf(stderr, "E/" LOG_TAG "(" ")" __VA_ARGS__)
-#endif
-
-JNIEXPORT void JNICALL Java_com_gpac_Osmo4_MPEGVSensor_sendData( JNIEnv* env, jobject thiz, jint ptr, jstring data);
-
-static JavaVM* javaVM = 0;
-static jclass sensCtrlClass;
-static jmethodID cid;
-static jmethodID startSensor;
-static jmethodID stopSensor;
-
-#ifndef GPAC_STATIC_MODULES
-
-//----------------------------------------------------------------------
-jint JNI_OnLoad(JavaVM* vm, void* reserved)
-{
-	JNIEnv* env = 0;
-	javaVM = vm;
-
-	if ( (*javaVM)->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
-		return -1;
-
-	// Get the class and its methods in the main env
-
-	// Get the CameraController class
-	// This is just a local refenrece. Cannot be used in the other JNI calls.
-	sensCtrlClass = (*env)->FindClass(env, "com/gpac/Osmo4/MPEGVSensor");
-	if (sensCtrlClass == 0)
-	{
-		LOGE("MPEG-V_IN Class MPEGVSensor not found\n");
-		return -1;
-	}
-
-	// Get Global Reference to be able to use the class
-	sensCtrlClass = (*env)->NewGlobalRef(env, sensCtrlClass);
-	if ( sensCtrlClass == 0 )
-	{
-		LOGE("MPEG-V_IN Caanot create Global Reference\n");
-		return -1;
-	}
-
-	// Get the method ID for the CameraController constructor.
-	cid = (*env)->GetMethodID(env, sensCtrlClass, "<init>", "()V");
-	if (cid == 0)
-	{
-		LOGE("MPEG-V_IN MPEGVSensor Constructor not found\n");
-		return -1;
-	}
-
-	// Get startCamera() method from class CameraController
-	startSensor = (*env)->GetMethodID(env, sensCtrlClass, "startSensor", "(II)V");
-	if (startSensor == 0)
-	{
-		LOGE("MPEG-V_IN Function startSensor not found\n");
-		return -1;
-	}
-
-	stopSensor = (*env)->GetMethodID(env, sensCtrlClass, "stopSensor", "()V");
-	if (stopSensor == 0)
-	{
-		LOGE("MPEG-V_IN Function stopSensor not found\n");
-		return -1;
-	}
-
-	return JNI_VERSION_1_2;
-}
-
-void JNI_OnUnload(JavaVM *vm, void *reserved)
-{
-	JNIEnv* env = 0;
-
-	if ( (*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
-		return;
-
-	(*env)->DeleteGlobalRef(env, sensCtrlClass);
-}
-
-//----------------------------------------------------------------------
-JavaVM* GetJavaVM()
-{
-	return javaVM;
-}
-//----------------------------------------------------------------------
-#else
-JavaVM* GetJavaVM();
-JNIEnv* GetEnv();
-
-#endif
-
-typedef struct
-{
-	char sensor50;
-	u16 sensorAndroidType;
-	u8 isAttached;
-
-	GF_Thread *trd;
-	u8 stop;
-
-	JNIEnv* env;
-	jclass sensCtrlClass;
-	jmethodID cid;
-	jobject sensCtrlObj;
-	jmethodID startSensor;
-	jmethodID stopSensor;
-} MPEGVSensorContext;
-
-#define MPEGVSCTX	MPEGVSensorContext *rc = (MPEGVSensorContext *)dr->udta
-
-void unloadSensorController(MPEGVSensorContext *rc)
-{
-	if ( rc->isAttached )
-	{
-		(*rc->env)->PopLocalFrame(rc->env, NULL);
-		(*GetJavaVM())->DetachCurrentThread(GetJavaVM());
-		rc->isAttached = 0;
-	}
-
-	rc->env = NULL;
-}
-
-void loadSensorControler(MPEGVSensorContext *rc)
-{
-	JNIEnv* env = NULL;
-	jint res = 0;
-
-	// Here we can be in a thread
-
-	res = (*GetJavaVM())->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2);
-	if ( res == JNI_EDETACHED )
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN The current thread is not attached to the VM, assuming native thread\n"));
-		res = (*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
-		if ( res )
-		{
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Attach current thread failed: %d\n", res));
-			return;
-		}
-		rc->isAttached = 1;
-		(*env)->PushLocalFrame(env, 2);
-	}
-	else if ( res == JNI_EVERSION )
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN The specified version is not supported\n"));
-		return;
-	}
-
-	rc->env = env;
-	rc->sensCtrlClass = sensCtrlClass;
-	rc->cid = cid;
-	rc->startSensor = startSensor;
-	rc->stopSensor = stopSensor;
-
-	// Create the sensor object in the thread
-	rc->sensCtrlObj = (*rc->env)->NewObject(rc->env, rc->sensCtrlClass, rc->cid);
-	if (rc->sensCtrlObj == 0)
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Cannot create MPEGVSensor object\n"));
-		return;
-	}
-}
-
-Bool MPEGVS_RegisterDevice(struct __input_device *dr, const char *urn, const char *dsi, u32 dsi_size, void (*AddField)(struct __input_device *_this, u32 fieldType, const char *name))
-{
-	MPEGVSCTX;
-
-	//"MPEG-V:siv:OrientationSensorType"
-
-	if ( strnicmp(urn, "MPEG-V", 6) )
-		return 0;
-
-	if ( strlen(urn) <= 6 )
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("MPEG-V No sensor type specified\n"));
-		return 0;
-	}
-
-	if ( strnicmp(urn+6, ":siv:", 5) )
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("MPEG-V Not valid sensor type specified\n"));
-		return 0;
-	}
-
-	strcpy(rc->sensor, urn+11);
-
-	if ( !strcmp(rc->sensor, "OrientationSensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFVEC3F, "Orientation");
-
-		rc->sensorAndroidType = 3;
-
-		return 1;
-	}
-	else if ( !strcmp(rc->sensor, "AccelerationSensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFVEC3F, "Acceleration");
-
-		rc->sensorAndroidType = 1;
-
-		return 1;
-	}
-	else if ( !strcmp(rc->sensor, "AngularVelocitySensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFVEC3F, "AngularVelocity");
-
-		rc->sensorAndroidType = 4;
-
-		return 1;
-	}
-	else if ( !strcmp(rc->sensor, "MagneticFieldSensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFVEC3F, "MagneticField");
-
-		rc->sensorAndroidType = 2;
-
-		return 1;
-	}
-	else if ( !strcmp(rc->sensor, "LightSensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFFLOAT, "Light");
-
-		rc->sensorAndroidType = 5;
-
-		return 1;
-	}
-	else if ( !strcmp(rc->sensor, "AtmosphericPressureSensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFFLOAT, "AtmosphericPressure");
-
-		rc->sensorAndroidType = 6;
-
-		return 1;
-	}
-	else if ( !strcmp(rc->sensor, "RotationVectorSensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFVEC3F, "RotationVector");
-
-		rc->sensorAndroidType = 11;
-
-		return 1;
-	}
-	else if ( !strcmp(rc->sensor, "GlobalPositionSensorType") )
-	{
-		AddField(dr, GF_SG_VRML_SFVEC3F, "Position");
-		AddField(dr, GF_SG_VRML_SFFLOAT, "Accuracy");
-		AddField(dr, GF_SG_VRML_SFFLOAT, "Bearing");
-
-		rc->sensorAndroidType = 100;
-
-		return 1;
-	}
-	else
-	{
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("MPEG-V_IN Unsupported sensor type: %s\n", rc->sensor));
-		return 0;
-	}
-}
-
-u32 MPEGVS_OnData(struct __input_device * dr, const char* data)
-{
-	GF_BitStream *bs;
-	u8 *buf;
-	u32 buf_size;
-	float x, y, z, /*q,*/ a, b;
-	MPEGVSCTX;
-
-	bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-
-	if ( rc->sensorAndroidType == 1
-	 || rc->sensorAndroidType == 2
-	 || rc->sensorAndroidType == 3
-	 || rc->sensorAndroidType == 4 )
-	{
-		sscanf(data, "%f;%f;%f;", &x, &y, &z);
-		gf_bs_write_int(bs, 1, 1);
-		gf_bs_write_float(bs, x);
-		gf_bs_write_float(bs, y);
-		gf_bs_write_float(bs, z);
-	}
-	else if ( rc->sensorAndroidType == 5
-	 || rc->sensorAndroidType == 6 )
-	{
-		sscanf(data, "%f;", &x);
-
-		gf_bs_write_int(bs, 1, 1);
-		gf_bs_write_float(bs, x);
-	}
-	else if ( rc->sensorAndroidType == 11 )
-	{
-		sscanf(data, "%f;%f;%f;", &x, &y, &z);
-
-		gf_bs_write_int(bs, 1, 1);
-		gf_bs_write_float(bs, x);
-		gf_bs_write_float(bs, y);
-		gf_bs_write_float(bs, z);
-		/*gf_bs_write_float(bs, q);*/
-	}
-	else if ( rc->sensorAndroidType == 100 )
-	{
-		sscanf(data, "%f;%f;%f;%f;%f;", &x, &y, &z, &a, &b);
-
-		gf_bs_write_int(bs, 1, 1);
-		gf_bs_write_float(bs, x);
-		gf_bs_write_float(bs, y);
-		gf_bs_write_float(bs, z);
-		gf_bs_write_int(bs, 1, 1);
-		gf_bs_write_float(bs, a);
-		gf_bs_write_int(bs, 1, 1);
-		gf_bs_write_float(bs, b);
-		/*gf_bs_write_float(bs, q);*/
-	}
-
-	gf_bs_align(bs);
-	gf_bs_get_content(bs, &buf, &buf_size);
-	gf_bs_del(bs);
-
-	dr->DispatchFrame(dr, (u8*)buf, buf_size);
-	gf_free(buf);
-
-	return GF_OK;
-}
-
-JNIEXPORT void Java_com_gpac_Osmo4_MPEGVSensor_sendData( JNIEnv* env, jobject thiz, jint ptr, jstring data)
-{
-	jboolean isCopy;
-	const char * cData = (*env)->GetStringUTFChars(env, data, &isCopy);
-
-	MPEGVS_OnData((struct __input_device *)ptr, cData);
-
-	(*env)->ReleaseStringUTFChars(env, data, cData);
-}
-
-u32 ThreadRun(void* param)
-{
-	struct __input_device * dr = (struct __input_device *)param;
-	MPEGVSCTX;
-
-	GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Start: %d\n", gf_th_id()));
-
-	loadSensorControler(rc);
-
-	if (!rc->env || !rc->sensCtrlObj)
-		return GF_OK;
-
-	(*rc->env)->CallNonvirtualVoidMethod(rc->env, rc->sensCtrlObj, rc->sensCtrlClass, rc->startSensor, (s32)dr, rc->sensorAndroidType);
-
-	while (!rc->stop)
-		gf_sleep(10);
-
-	GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Stop: %d\n", gf_th_id()));
-
-	if (!rc->env)
-		return GF_OK;
-
-	if ( rc->sensCtrlObj )
-	{
-		(*rc->env)->CallNonvirtualVoidMethod(rc->env, rc->sensCtrlObj, rc->sensCtrlClass, rc->stopSensor);
-
-		(*rc->env)->DeleteLocalRef( rc->env, rc->sensCtrlObj );
-	}
-
-	unloadSensorController(rc);
-	return GF_OK;
-}
-
-void MPEGVS_Start(struct __input_device * dr)
-{
-	MPEGVSCTX;
-
-	rc->trd = gf_th_new("MPEG-V_IN");
-	gf_th_run(rc->trd, ThreadRun, dr);
-}
-
-void MPEGVS_Stop(struct __input_device * dr)
-{
-	MPEGVSCTX;
-
-	if ( rc->trd )
-	{
-		rc->stop = 1;
-		while ( gf_th_status(rc->trd) == GF_THREAD_STATUS_RUN )
-			gf_sleep(5);
-
-		gf_th_del(rc->trd);
-		rc->trd = NULL;
-		rc->stop = 0;
-	}
-}
-
-GF_InputSensorDevice* NewMPEGVSInputSesor()
-{
-	MPEGVSensorContext* ctx;
-	GF_InputSensorDevice* driv;
-
-	driv = (GF_InputSensorDevice *) gf_malloc(sizeof(GF_InputSensorDevice));
-	memset(driv, 0, sizeof(GF_InputSensorDevice));
-	GF_REGISTER_MODULE_INTERFACE(driv, GF_INPUT_DEVICE_INTERFACE, "MPEG-V Sensors Input Module", "gpac distribution");
-
-	driv->RegisterDevice = MPEGVS_RegisterDevice;
-	driv->Start = MPEGVS_Start;
-	driv->Stop = MPEGVS_Stop;
-
-	ctx = (MPEGVSensorContext*) gf_malloc (sizeof(MPEGVSensorContext));
-	memset(ctx, 0, sizeof(MPEGVSensorContext));
-
-	driv->udta = (void*)ctx;
-
-	return driv;
-}
-
-void DeleteMPEGVSInputSensor(GF_InputSensorDevice* dev)
-{
-	MPEGVS_Stop(dev);
-	gf_free(dev->udta);
-	gf_free(dev);
-}
-
-/*interface query*/
-GPAC_MODULE_EXPORT
-const u32 *QueryInterfaces()
-{
-	static u32 si = {
-		GF_INPUT_DEVICE_INTERFACE,
-		0
-	};
-	return si;
-}
-
-/*interface create*/
-GPAC_MODULE_EXPORT
-GF_BaseInterface *LoadInterface(u32 InterfaceType)
-{
-	if (InterfaceType == GF_INPUT_DEVICE_INTERFACE) return (GF_BaseInterface *) NewMPEGVSInputSesor();
-	return NULL;
-}
-
-/*interface destroy*/
-GPAC_MODULE_EXPORT
-void ShutdownInterface(GF_BaseInterface *ifce)
-{
-	switch (ifce->InterfaceType) {
-	case GF_INPUT_DEVICE_INTERFACE:
-		DeleteMPEGVSInputSensor((GF_InputSensorDevice *)ifce);
-		break;
-	}
-}
-
-GPAC_MODULE_STATIC_DECLARATION( droid_mpegv )

gpac-2.0.0.tar.gz/modules/ios_cam Deleted

gpac-2.0.0.tar.gz/modules/ios_mpegv Deleted

gpac-2.0.0.tar.gz/share/doc/configuration.html Deleted

@@ -1,103 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-	<title>GPAC Configuration documentation </title>
-</head>
-
-
- 
-GPAC Configuration file documentation
- GPAC Version 2.0
-
-
- 
-
-<a name="Overview"></a>Overview
-Applications in the GPAC framework use a configuration file common to libgpac and modules (video and audio output, compositor modules). This configuration file is called GPAC.cfg. It is located:
-<ul>
-<li>on Windows platforms, in C:\\Users\\FOO\\AppData\\Roaming\\GPAC, or in C:\\Program Files\\GPAC.</li>
-<li>on iOS platforms, in a .gpac folder in the app storage directory.</li>
-<li>on Android platforms, in /sdcard/osmo/ or, if not found there, created in /data/data/com.gpac.Osmo4.</li>
-<li>on other platforms, in a .gpac folder in the user home directory (for ex, /home/foo/.gpac/ or /Users/foo/.gpac/).</li>
-</ul>
-GPAC can use different configuration profiles other than the default, check <a href="https://github.com/gpac/gpac/wiki/core_config">GPAC wiki</a>.
- 
-The config file is structured in sections, each made of one or more keys. A section is declared as SectionName, and key is declared as keyName=value. The key value is not interpreted and always handled as ASCII text.
-
-This document describes player-specific options defined in section <a href="#General" style="text-decoration: underline;">General</a> and old DirectFB options described in section <a href="#DirectFB" style="text-decoration: underline;">DirectFB</a>.
- 
-Check GPAC wiki for the documentation of <a href="https://github.com/gpac/gpac/wiki/core_options">libgpac core options</a> and <a href="https://github.com/gpac/gpac/wiki/core_config">filter options</a> configuration.
-
- 
-
-
-Note on module names
- Module names as given in the config file are names exported by each interface and not name of the physical library file (.dll, .so, ...). The physical file name can however be used to identify a module - it will then be replaced by the module name.
-
-
- 
-
-<a name="General"></a>
-Section "General" <a href="#Overview">Back to top</a>
-
-The General section of the config file holds player-specific options.
-
-StartupFile value: filename
-
-Specifies file to load upon startup of most clients (Osmo4/MP4Client). If not specified, no file is loaded.
-
-
-LogFile value: filename, Android only
-
-Specifies where to output GPAC's log. By default, the logs are written to stdout. Note that GPAC may be compiled without log support. This is not used by MP4Client.
-
-Logs value: tool:tool@level:tool:tool@level, Android only
-
-Specifies log level for each tool. For more information on available tools and levels, check <a href=-"https://github.com/gpac/gpac/wiki/core_logs">GPAC wiki</a>.
-
-
-
-NoMIMETypeFetch value: "yes" "no"
-
-Specifies whether mime type should be fetched when checking a link to a new file (currently deprecated).
-
-LastWorkingDir value: string
-
-Indicates the last directory from which a file was opened.
-
-iOSDocumentsDir value: string, iOS only
-
-Path to the iOS document directory for the client (automatically set upon first launch of the player).
-
-
- 
-
-<a name="DirectFB"></a>
-Section "DirectFB" <a href="#Overview">Back to top</a>
-
-The "DirectFB" section of the config file holds the configuration options for the DirectFB output module. You may also want to check the <a href="http://directfb.org/wiki/index.php/Configuring_DirectFB">official documentation</a>.
-
-DisableAcceleration value: "yes" "no"
-
-Forces to disable hardware acceleration.
-DisableDisplay value: "yes" "no"
-
-Specifies the DisableDisplay parameter value.
-FlipSyncMode value: "waitsync" "wait" "sync" "swap"
-
-Specifies the flip sync mode.
-DisableBlit value: "yes" "no"
-
-Forces to disable hardware blitting.
-WindowMode value: "X11" "SDL"
-
-Specifies the underlying windowing library.
-
-
- 
-
-
-</body>
-</html>

gpac-2.0.0.tar.gz/share/doc/man/mp4client.1 Deleted

@@ -1,266 +0,0 @@
-.TH MP4Client 1 2019 MP4Client GPAC
-.
-.SH NAME
-.LP
-MP4Client \- GPAC command-line media player
-.SH SYNOPSIS
-.LP
-.B MP4Client
-.RI options \ file
-.br
-.
-.SH "DESCRIPTION"
-.LP
-MP4Client is GPAC command-line media player. It supports all GPAC playback features (2D and 3D support, local playback, RTP streaming, HTTP faststart, many audio and video codecs ...).
-.br
-Specific URLs shortcuts are available, see gpac -h compositor
-.
-.
-.SH OPTIONS
-.TP
-.B \-mem-track
-.br
-enable memory tracker
-.br
-.TP
-.B \-mem-track-stack
-.br
-enable memory tracker with stack dumping
-.br
-.TP
-.B \-rti (string)
-.br
-log run-time info (FPS, CPU, Mem usage) to given file
-.br
-.TP
-.B \-rtix (string)
-.br
-same as -rti but driven by GPAC logs
-.br
-.TP
-.B \-size (string)
-.br
-specify visual size WxH. If not set, scene size or video size is used
-.br
-.TP
-.B \-rti-refresh (int)
-.br
-set refresh time in ms between two runt-time counters queries (default is 200)
-.br
-.TP
-.B \-no-thread
-.br
-disable thread usage (except for depending on driver audio)
-.br
-.TP
-.B \-no-audio
-.br
-disable audio
-.br
-.TP
-.B \-pause
-.br
-pause at first frame
-.br
-.TP
-.B \-play-from (number)
-.br
-start playback from given time in seconds in media
-.br
-.TP
-.B \-speed (number)
-.br
-start playback wit given speed
-.br
-.TP
-.B \-loop
-.br
-loop playback
-.br
-.TP
-.B \-fs
-.br
-start in fullscreen mode
-.br
-.TP
-.B \-exit
-.br
-exit when presentation is over
-.br
-.TP
-.B \-run-for
-.br
-run for indicated time in seconds and exits
-.br
-.TP
-.B \-service (int)
-.br
-auto-tune to given service ID in a multiplex
-.br
-.TP
-.B \-no-save
-.br
-do not save configuration file on exit
-.br
-.TP
-.B \-no-addon
-.br
-disable automatic loading of media addons declared in source URL
-.br
-.TP
-.B \-gui
-.br
-start in GUI mode. The GUI is indicated in the configuration file GeneralStartupFile
-.br
-.TP
-.B \-p (string)
-.br
-use indicated profile for the global GPAC config. If not found, config file is created. If a file path is indicated, this will load profile from that file. Otherwise, this will create a directory of the specified name and store new config there. Reserved name 0 means a new profile, not stored to disk. Works using -p=NAME or -p NAME
-.br
-.TP
-.B \-stats
-.br
-dump filter session stats after playback
-.br
-.TP
-.B \-graph
-.br
-dump filter session graph after playback
-.br
-.TP
-.B \-nk
-.br
-disable keyboard interaction
-.br
-.TP
-.B \-h,-help
-.br
-show this help. Use -hx to show expert help
-.br
-.TP
-.B \-hc
-.br
-show libgpac core options
-.br
-.TP
-.B \-hr
-.br
-show runtime options when keybard interaction is enabled
-.br
-.SH MP4Client runtime commands
-.LP
-.br
-.SS Prompt Interaction
-.br
-The following keys are used for prompt interaction:
-.br
-q: quit
-.br
-X: kill
-.br
-r: reload current presentation
-.br
-o: connect to the specified URL
-.br
-O: connect to the specified playlist
-.br
-N: switch to the next URL in the playlist. Also works with \n
-.br
-P: jump to a given number ahead in the playlist
-.br
-D: disconnect the current presentation
-.br
-G: select object or service ID
-.br
-p: play/pause the presentation
-.br
-s: step one frame ahead
-.br
-z: seek into presentation by percentage
-.br
-T: seek into presentation by time
-.br
-t: print current timing
-.br
-u: send a command (BIFS or LASeR) to the main scene
-.br
-e: evaluate JavaScript code in the main scene
-.br
-Z: dump current output frame to PNG
-.br
-w: view world info
-.br
-v: view list of active media objects in scene
-.br
-i: view Object Descriptor info (by ID)
-.br
-j: view Object Descriptor info (by number)
-.br
-b: view media objects timing and buffering info
-.br
-m: view media objects buffering and memory info
-.br
-d: dump scene graph
-.br
-k: turn stress mode on/off
-.br
-n: change navigation mode
-.br
-x: reset to last active viewpoint
-.br
-3: switch OpenGL on or off for 2D scenes
-.br
-4: force 4/3 Aspect Ratio
-.br
-5: force 16/9 Aspect Ratio
-.br
-6: force no Aspect Ratio (always fill screen)
-.br
-7: force original Aspect Ratio (default)
-.br
-H: set HTTP max download rate
-.br
-E: force reload of compositor options
-.br
-L: change to new log tool/level. CF MP4Client usage for possible values
-.br
-R: toggle run-time info display in window title bar on/off
-.br
-F: toggle displaying of FPS in stderr on/off
-.br
-f: print filter session stats
-.br
-g: print filter session graph
-.br
-h: print this message
-.br
-M: specify video cache memory for 2D objects ! experimental !
-.br
-
-.br
-.SS Content interaction
-.br
-It is possible to interact with content (interactive or not) using mouse and keyboard.
-.br
-The following commands are available:
-.br
-TODO
-.br
-
-.br
-.SH EXAMPLES
-.TP
-Basic and advanced examples are available at https://wiki.gpac.io/mp4client
-.SH MORE
-.LP
-Authors: GPAC developers, see git repo history (-log)
-.br
-For bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac
-.br
-build: 1.1.0-DEV-rev1777-gb91a8dad3-master
-.br
-Copyright: (c) 2000-2022 Telecom Paris distributed under LGPL v2.1+ - http://gpac.io
-.br
-.SH SEE ALSO
-.LP
-gpac(1), MP4Box(1)

gpac-2.0.0.tar.gz/share/python/libgpac.py Deleted

@@ -1,4500 +0,0 @@
-#
-# GPAC - Multimedia Framework C SDK
-#
-# Authors: Jean Le Feuvre
-# Copyright (c) Telecom Paris 2020-2022
-# All rights reserved
-#
-# Python ctypes bindings for GPAC (core initialization and filters API only)
-#
-# GPAC is free software; you can redistribute it and/or modify
-# it under the terfsess of the GNU Lesser General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-#
-# GPAC is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; see the file COPYING. If not, write to
-# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-
-
-## 
-# \defgroup pyapi_grp Python APIs
-# \brief Python API for libgpac.
-#
-# # Foreword
-# This module provides ctypes(https://docs.python.org/3/library/ctypes.html) bindings for libgpac. These bindings currently allow:
-# - initializing libgpac, setting global arguments for the library
-# - creation, running and destruction of a filter session in blocking mode or non-blocking mode
-# - inspection of filters in a session
-# - user tasks scheduling
-# - Creation of custom filters in Python
-#
-# \note This is an initial work and more bindings might be needed, feel free to contribute/PR on https://github.com/gpac/gpac
-#
-# # Error handling
-#
-# Errors are handled through raising exceptions, except callback methods wich must return a \ref GF_Err value. 
-# # Properties handling
-#
-# Properties types are automatically converted to and from string. If the property name is not a built-in property type, the property is assumed to be a user-defined property. 
-# For example, when querying or setting a stream type property, use the property name `StreamType`.
-# See `gpac -h props`(https://github.com/gpac/gpac/wiki/filters_properties) for the complete list of built-in property names.
-#
-# Properties values are automatically converted to or from python types whenever possible. Types with no python equivalent (vectors, fractions) are defined as classes in python.
-# For example:
-# - when setting a UIntList property, pass a python list of ints 
-# - when reading a UIntList property, a python list of ints will be returned 
-# - when setting a PropVec2i property, pass a PropVec2i object 
-# - when setting a PropVec2iList property, pass a python list of PropVec2i 
-#
-# 4CCs are handled as strings in python, and list of 4CCs are handled as list of strings
-#
-# The following builtin property types are always handled as strings in Python instead of int in libgpac :
-# - StreamType: string containing the streamtype name
-# - CodecID: string containing the codec name
-# - Enumeration properties (PixelFormat, AudioFormat, ...): string containing the corresponding name
-#
-# # Basic setup
-#
-# You can initialize libgpac before any other calls to set memory tracker or profile. When importing the module, libgpac is by default initialized with no memory tracking and using the default profile.
-# You currently must uninintialize it after everything gpac-related is done.
-# You also must destroy explicitly the filter session, as otherwise the garbage collection on the filter session object could happen after libgpac shutdown and will likely crash
-#
-# \code
-# import libgpac as gpac
-# gpac.init()
-# #create a session in blocking mode
-# fs = gpac.FilterSession()
-# #setup all your filters
-# ...
-# #run the session
-# fs.run()
-# fs.delete()
-# gpac.close()
-# \endcode
-#
-# You can specify global options of libgpac and filters (e.g. --opt) by assigning arguments to libgpac:
-# \code
-# #set global arguments, here inherited from command line
-# gpac.set_args(sys.argv)
-# \endcode
-#
-# You can also specify the log levels you want
-# \code
-# gpac.set_logs("all@info")
-# \endcode
-# # Session using built-in filters
-#
-# Filters are loaded as usual in gpac as a string description
-# \code
-# src = fs.load_src("$URL:opt:opt2=val")
-# dst = fs.load_dst("$URL2:opt3:opt4=val")
-# f = fs.load("filtername:optX")
-# \endcode
-#
-# By default the filter session will run with implicit linking.
-#
-# It is possible to assign sources of a filter (much like the `@` command in `gpac`):
-# \code
-# dst.set_source(f)
-# \endcode
-#
-#
-# # Posting user tasks
-# 
-# You can post tasks to the session scheduler to get called back (useful when running the session in blocking mode)
-# Tasks must derive FilterTask class and implement their own `execute` method
-# \code
-# class MyTask(FilterTask): 
-# def exectute(self):
-# do_something()
-# #last scheduled task (session is over), abort
-# if self.session.last_task:
-# return -1 
-# //keep task active, reschedule in 500 ms 
-# return 500 
-#
-# task = MyTask('CustomTask')
-# fs.post_task(task)
-# \endcode
-#
-# # Creating custom filters
-#
-# A custom filter allows your application to interact closely with the media pipeline, but cannot be used in graph resolution.
-# Custom filters can be sources, sinks, or intermediate filters. The following limitations however exist:
-#- custom filters will not be cloned
-#- custom filters cannot be used as sources of filters loading a source filter graph dynamically, such as the dashin filter.
-#- custom filters cannot be used as destination of filters loading a destination filter graph dynamically, such as the dasher filters.
-#
-# A custom filter must implement the \ref FilterCustom class, and optionally provide the following methods
-# - configure_pid: callback for PID configuration, mandatory if your filter is not a source
-# - process: callback for processing
-# - process_event: callback for processing and event
-# - probe_data: callback for probing a data format
-# - reconfigure_output: callback for output reconfiguration (PID capability negociation)
-#
-# A custom filter must also declare its capabilities, input and output, using push_cap method 
-# \code
-# class MyFilter(FilterTask): 
-# def __init__(self, session):
-# # !! call constructor of parent class first !!
-# gpac.FilterCustom.__init__(self, session, "PYnspect")
-# #indicate what we accept and produce - this can be done either in the constructor or after, but before calling \ref run or \ref run_step 
-# #here we indicate we accept anything of type visual, and produce anything of type visual
-# self.push_cap("StreamType", "Visual", gpac.GF_CAPS_INPUT_OUTPUT)
-#
-# #we accept input pids, we must configure them
-# #def configure_pid(self, pid, is_remove):
-# #do something, return value is a GF_Err value
-# #pid being removed
-# if is_remove:
-# #pid being reconfigured
-# elif pid in self.ipids:
-# #pid first connection
-# else:
-#
-# #process
-# #def process(self):
-# #do something, return value is a GF_Err value
-#
-# #process_event takes a \ref FilterEvent parameter
-# #def process_event(self, evt):
-# #do something, return value is True (cancelled) or False
-#
-# #probe_data takes a NumPy array if numpy is available (and _size can be ignored) or a POINTER(c_ubyte) otherwise
-# #def probe_data(self, data, _size):
-# #do something, return value is mime type or None
-#
-# #probe_data takes the target output pid as parameter
-# #def reconfigure_output(self, opid):
-# #do something, return value is a GF_Err value
-#
-# \endcode
-#
-# \note
-# The \ref FilterCustom object has a list of input and output PIDs created. Before a callback to configure_pid, the input PID is not registered to the list 
-# of input PIDs if this is the first time the PID is configured.
-#
-# \code
-# src = fs.load_src("$URL:opt:opt2=val")
-# dst = fs.load_dst("$URL2:opt3:opt4=val")
-# #load a custom filter
-# my_filter = MyFilter(fs)
-# #make sure dst only consumes from our custom filter
-# dst.set_source(f)
-# \endcode
-# @{
-#
-
-
-## 
-# \defgroup pycore_grp libgpac core tools
-# \ingroup pyapi_grp Python APIs
-# \brief Core tools for libgpac.
-#
-# @{
-
-
-from ctypes import *
-from ctypes.util import find_library
-import datetime
-import types
-import os
-import copy
-
-## set to True if numpy was successfully loaded
-##\hideinitializer
-numpy_support=True
-
-try:
- import numpy as np
-except ImportError:
- numpy_support = False
- print("\nWARNING! numpy not present, packet data type is ctypes POINTER(c_ubyte)\n")
-
-##ctypes instance of libgpac
-##\hideinitializer
-_libgpac=None
-
-## \cond private
-#load libgpac
-try:
- dll_path = find_library("libgpac.dll")
- if not dll_path:
- raise OSError("No libgpac.dll")
-
- _libgpac = cdll.LoadLibrary(os.path.abspath(dll_path))
-except OSError:
- try:
- _libgpac = cdll.LoadLibrary("libgpac.so")
- except OSError:
- try:
- _libgpac = cdll.LoadLibrary("libgpac.dylib")
- except OSError:
- print('Failed to locate libgpac (.so/.dll/.dylib) - make sure it is in your system path')
- os._exit(1)
-
-#change this to reflect API we encapsulate. An incomatibility in either of these will throw a warning
-GF_ABI_MAJOR=11
-GF_ABI_MINOR=0
-
-gpac_abi_major=_libgpac.gf_gpac_abi_major()
-gpac_abi_minor=_libgpac.gf_gpac_abi_minor()
-
-## \endcond private
-
-## Set to true if mismatch was detected between the ABI version the Python wrapper was designed and the libgpac shared library ABI version
-# A warning is thrown if mismatched, but it is left up to the pythin script to decide whether it still wants to use libgpac wrapper
-_libgpac_abi_mismatch=False
-
-## \cond private
-if (gpac_abi_major != GF_ABI_MAJOR) or (gpac_abi_minor != GF_ABI_MINOR):
- abi_mismatch=True
- print('WARNING: this python wrapper is for GPAC ABI ' + str(GF_ABI_MAJOR) + '.' + str(GF_ABI_MINOR) + ' but native libgpac ABI is ' + str(gpac_abi_major) + '.' + str(gpac_abi_minor) + '\n\tUndefined behavior or crashes might happen, please update libgpac.py')
-
-## \endcond private
-
-#
-# Type definitions
-#
-
-##\cond private
-_gf_filter_session = c_void_p
-_gf_filter = c_void_p
-_gf_filter_pid = c_void_p
-_gf_filter_packet = c_void_p
-_gf_property_entry = c_void_p
-_gf_list = c_void_p
-gf_bool = c_uint
-
-##\endcond
-
-
-
-
-##\cond private
-#error to string helper
-_libgpac.gf_error_to_string.argtypes = c_int
-_libgpac.gf_error_to_string.restype = c_char_p
- 
-_libgpac.gf_gpac_version.restype = c_char_p
-_libgpac.gf_gpac_copyright.restype = c_char_p
-_libgpac.gf_gpac_copyright_cite.restype = c_char_p
-
-_libgpac.gf_sys_set_args.argtypes = c_int, POINTER(POINTER(c_char))
-
-_libgpac.gf_sys_init.argtypes = c_int, c_char_p
-_libgpac.gf_log_set_tools_levels.argtypes = c_char_p, c_int
-_libgpac.gf_props_get_type_name.argtypes = c_uint
-_libgpac.gf_props_get_type_name.restype = c_char_p
-
-_libgpac.gf_sys_clock.restype = c_uint
-_libgpac.gf_sys_clock_high_res.restype = c_ulonglong
-
-_libgpac.gf_sys_profiler_send.argtypes = c_char_p
-_libgpac.gf_sys_profiler_sampling_enabled.restype = gf_bool
-_libgpac.gf_sys_profiler_enable_sampling.argtypes = gf_bool
-
-_libgpac.gf_4cc_to_str.argtypes = c_uint
-_libgpac.gf_4cc_to_str.restype = c_char_p
-
-_libgpac.gf_4cc_parse.argtypes = c_char_p
-_libgpac.gf_4cc_parse.restype = c_uint
-
-_libgpac.gf_sleep.argtypes = c_uint
-_libgpac.gf_sleep.restype = c_uint
-
-#default init of libgpac
-_libgpac.user_init = False
-err = _libgpac.gf_sys_init(0, None)
-if err<0:
-	raise Exception('Failed to initialize libgpac: ' + e2s(err))
-
-#\endcond
-
-##libgpac version (string)
-#\hideinitializer
-version = _libgpac.gf_gpac_version().decode("utf-8")
-##libgpac copyright notice (string)
-#\hideinitializer
-copyright = _libgpac.gf_gpac_copyright().decode("utf-8")
-##libgpac full copyright notice (string)
-#\hideinitializer
-copyright_cite = _libgpac.gf_gpac_copyright_cite().decode("utf-8")
-
-## convert error value to string message
-# \param err gpac error code (int)
-# \return string
-def e2s(err):
- return _libgpac.gf_error_to_string(err).decode('utf-8')
-
-
-## initialize libgpac - see \ref gf_sys_init
-# \param mem_track
-# \param profile
-# \return
-#
-def init(mem_track=0, profile=None):
- if _libgpac.user_init:
- return
- _libgpac.user_init = True
- _libgpac.gf_sys_close()
- err = _libgpac.gf_sys_init(mem_track, profile)
- if err<0:
- raise Exception('Failed to initialize libgpac: ' + e2s(err))
-
-
-## close libgpac - see \ref gf_sys_close
-# \note Make sure you have destroyed all associated gpac resources before calling this !
-# \return
-#
-def close():
- _libgpac.gf_sys_close()
- if hasattr(_libgpac, 'gf_memory_size'):
- if _libgpac.gf_memory_size() or _libgpac.gf_file_handles_count():
- set_logs("mem@info")
- _libgpac.gf_memory_print()
- return 2
- return 0
-
-## set log tools and levels - see \ref gf_log_set_tools_levels
-# \note Make sure you have destroyed all associated gpac resources before calling this !
-# \param logs
-# \param reset if true, resets all logs to default
-# \return
-def set_logs(logs, reset=False):
- _libgpac.gf_log_set_tools_levels(logs.encode('utf-8'), reset)
-
-## get clock - see \ref gf_sys_clock
-# \return clock in milliseconds
-def sys_clock():
- return _libgpac.gf_sys_clock()
-
-## get high res clock - see \ref gf_sys_clock_high_res
-# \return clock in microseconds
-def sys_clock_high_res():
- return _libgpac.gf_sys_clock_high_res()
-
-##\cond private
-
-#keep args at libgpac level to avoid python GC
-_libgpac._args=None
-
-##\endcond private
-
-## set libgpac arguments - see \ref gf_sys_set_args
-# \param args list of strings, the first string is ignored (considered to be the executable name)
-# \return
-def set_args(args):
- _libgpac.user_init = True
- nb_args = len(args)
- _libgpac._args = (POINTER(c_char)*nb_args)()
- for i, arg in enumerate(args):
- enc_arg = arg.encode('utf-8')
- _libgpac._argsi = create_string_buffer(enc_arg)
- _libgpac.gf_sys_set_args(nb_args, cast(_libgpac._args, POINTER(POINTER(c_char))) )
-
-
-##\cond private
-_libgpac.gf_sys_profiler_set_callback.argtypes = py_object, c_void_p
-@CFUNCTYPE(c_int, c_void_p, c_char_p)
-def rmt_fun_cbk(_udta, text):
- obj = cast(_udta, py_object).value
- obj.on_rmt_event(text.decode('utf-8'))
- return 0
-##\endcond private
-
-
-## set profiler (Remotery) callback - see \ref gf_sys_profiler_set_callback
-# \param callback_obj object to call back, must have a method `on_rmt_event` taking a single string parameter
-# \return True if success, False if no Remotery support
-def set_rmt_fun(callback_obj):
- _libgpac.user_init = True
- if hasattr(callback_obj, 'on_rmt_event')==False:
- raise Exception('No on_rmt_event function on callback')
- err = _libgpac.gf_sys_profiler_set_callback(py_object(callback_obj), rmt_fun_cbk)
- if err<0:
- return False
- return True
-
-## send message to profiler (Remotery) - see \ref gf_sys_profiler_send
-# \param text text to send
-# \return True if success, False if no Remotery support
-def rmt_send(text):
- err = _libgpac.gf_sys_profiler_send(text.encode('utf-8'))
- if err<0:
- return False
- return True
-
-## check if profiler (Remotery) sampling is enabled - see \ref gf_sys_profiler_sampling_enabled
-# \return True if enabled, False otherwise
-def rmt_on():
- return _libgpac.gf_sys_profiler_sampling_enabled()
-
-## enable or disable sampling in profiler (Remotery) - see \ref gf_sys_profiler_enable_sampling
-# \param value enable or disable sampling
-# \return
-def rmt_enable(value):
- _libgpac.user_init = True
- _libgpac.gf_sys_profiler_enable_sampling(value)
- 
-
-## sleep for given time in milliseconds
-# \param value time to sleep
-# \return
-def sleep(value):
- _libgpac.gf_sleep(value)
-
-
-## @}
-
-
-## 
-# \defgroup pystruct_grp Structure Wrappers
-# \ingroup pyapi_grp
-# \brief Python Structures 
-#
-# Python Wrappers for gpac C structures used in this API
-#
-# @{
-
-## fraction object, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_Fraction
-class Fraction(Structure):
- ## \cond private
- def __init(self, num, den):
- self.num = num
- self.den = den
- _fields_ = ("num", c_int), ("den", c_uint)
- def __str__(self):
- return str(self.num)+'/' + str(self.den)
- ## \endcond
-
-## large fraction object, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_Fraction64
-class Fraction64(Structure):
- ## \cond private
- _fields_ = ("num", c_longlong), ("den", c_ulonglong)
- def __str__(self):
- return str(self.num)+'/' + str(self.den)
- ## \endcond
-
-## filter statistics object, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FilterStats
-class FilterStats(Structure):
- ## \cond private
-	_fields_ = 
-		("filter", _gf_filter),
-		("filter_alias", _gf_filter),
-		("nb_tasks_done", c_ulonglong),
-		("nb_pck_processed", c_ulonglong),
-		("nb_bytes_processed", c_ulonglong),
-		("nb_pck_sent", c_ulonglong),
-		("nb_hw_pck_sent", c_ulonglong),
-		("nb_errors", c_uint),
-		("nb_bytes_sent", c_ulonglong),
-		("time_process", c_ulonglong),
-		("percent", c_int),
-		("status", c_char_p),
-		("report_updated", gf_bool),
-		("name", c_char_p),
-		("reg_name", c_char_p),
-		("filter_id", c_char_p),
-		("done", gf_bool),
-		("nb_pid_in", c_uint),
-		("nb_in_pck", c_ulonglong),
-		("nb_pid_out", c_uint),
-		("nb_out_pck", c_ulonglong),
-		("in_eos", gf_bool),
-		("type", c_int),
-		("stream_type", c_int),
-		("codecid", c_int),
-		("last_ts_sent", Fraction64),
-		("last_ts_drop", Fraction64)
-	
- ## \endcond
-
-## filter argument object, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FilterArgs
-class FilterArg(Structure):
- ## \cond private
- _fields_ = 
- ("name", c_char_p),
- ("reserved", c_int),
- ("description", c_char_p),
- ("type", c_int),
- ("default", c_char_p),
- ("min_max_enum", c_char_p),
- ("flags", c_uint)
- 
- def __str__(self):
- res = '- ' + self.name.decode('utf-8') + ' (' + _libgpac.gf_props_get_type_name(self.type).decode('utf-8') + '): ' + self.description.decode('utf-8')
- if self.default or self.min_max_enum:
- res += ' ('
- if self.default:
- res += 'default: ' + self.default.decode('utf-8')
- if self.min_max_enum:
- res += ' min_max_enum: ' + self.min_max_enum.decode('utf-8')
- res += ')'
- return res
- ## \endcond
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropVec2i
-class PropVec2i(Structure):
- ## \cond private
- _fields_ = ("x", c_int), ("y", c_int)
- def __str__(self):
- return str(self.x)+'x' + str(self.y)
- ## \endcond
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropVec2
-class PropVec2(Structure):
- ## \cond private
- _fields_ = ("x", c_double),("y", c_double)
- def __str__(self):
- return str(self.x)+'x' + str(self.y)
- ## \endcond
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropVec3i
-class PropVec3i(Structure):
- ## \cond private
- _fields_ = ("x", c_int), ("y", c_int), ("z", c_int)
- def __str__(self):
- return str(self.x)+'x' + str(self.y)+'x' + str(self.z)
- ## \endcond
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropVec4i
-class PropVec4i(Structure):
- ## \cond private
- _fields_ = ("x", c_int), ("y", c_int), ("z", c_int), ("w", c_int)
- def __str__(self):
- return str(self.x)+'x' + str(self.y)+'x' + str(self.z)+'x' + str(self.w)
- ## \endcond
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropData
-class PropData(Structure):
- ## \cond private
- _fields_ = ("ptr", c_void_p), ("size", c_uint)
- def __str__(self):
- return 'data,size:'+str(self.size)
- ## \endcond
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropUIntList
-class PropStringList(Structure):
- ## \cond private
- _fields_ = ("vals", POINTER(c_char_p)), ("nb_items", c_uint)
- def __str__(self):
- res=''
- for i in range(self.nb_items):
- if i:
- res += ','
- res += self.valsi.decode('utf-8')
- return res
- ## \endcond private
-
-## \cond private
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropUIntList
-class PropUIntList(Structure):
- _fields_ = ("vals", POINTER(c_uint)), ("nb_items", c_uint)
- def __str__(self):
- res=''
- for i in range(self.nb_items):
- if i:
- res += ','
- res += str(self.valsi)
- return res
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropIntList
-class PropIntList(Structure):
- _fields_ = ("vals", POINTER(c_int)), ("nb_items", c_uint)
- def __str__(self):
- res=''
- for i in range(self.nb_items):
- if i:
- res += ','
- res += str(self.valsi)
- return res
-
-## filter prop type, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_PropVec2iList
-class PropVec2iList(Structure):
- _fields_ = ("vals", POINTER(PropVec2i)), ("nb_items", c_uint)
- def __str__(self):
- res=''
- for i in range(self.nb_items):
- if i:
- res += ','
- res += str(self.valsi.x) + 'x' + str(self.valsi.y)
- return res
-
-## filter property union value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as GF_PropertyValue
-class PropertyValueUnion(Union):
-	_fields_ = 
-		("longuint", c_ulonglong),
-		("longsint", c_longlong),
-		("sint", c_int),
-		("uint", c_uint),
-		("boolean", gf_bool),
-		("frac", Fraction),
-		("lfrac", Fraction64),
-		("fnumber", c_float),
-		("number", c_double),
-		("vec2i", PropVec2i),
-		("vec2", PropVec2),
-		("vec3i", PropVec3i),
-		("vec4i", PropVec3i),
-		("data", PropData),
-		("string", c_char_p),
-		("ptr", c_void_p),
- ("string_list", PropStringList),
- ("uint_list", PropUIntList),
-		("sint_list", PropIntList),
-		("v2i_list", PropVec2iList)
-	
-
-## filter property value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as GF_PropertyValue
-class PropertyValue(Structure):
-	_fields_ = 
-		("type", c_uint),
-		("value", PropertyValueUnion)
-	
-
-## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_Base
-class FEVT_Base(Structure):
- ## \cond private
- _fields_ = ("type", c_uint), ("on_pid", _gf_filter_pid)
- ## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_Play
-class FEVT_Play(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("start_range", c_double),
- ("end_range", c_double),
- ("speed", c_double),
- ("from_pck", c_uint),
- ("hw_buffer_reset", c_ubyte),
- ("initial_broadcast_play", c_ubyte),
- ("timestamp_based", c_ubyte),
- ("full_file_only", c_ubyte),
- ("forced_dash_segment_switch", c_ubyte),
- ("drop_non_ref", c_ubyte),
- ("no_byterange_forward", c_ubyte)
- 
- ## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_SourceSeek
-class FEVT_SourceSeek(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("start_offset", c_ulonglong),
- ("end_offset", c_ulonglong),
- ("source_switch", c_char_p),
- ("is_init_segment", c_ubyte),
- ("skip_cache_expiration", c_ubyte),
- ("hint_block_size", c_uint)
- 
- ## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_SegmentSize
-class FEVT_SegmentSize(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("seg_url", c_char_p),
- ("is_init", gf_bool),
- ("media_range_start", c_ulonglong),
- ("media_range_end", c_ulonglong),
- ("idx_range_start", c_ulonglong),
- ("idx_range_end", c_ulonglong)
- 
- ## \endcond
-
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_AttachScene
-class FEVT_AttachScene(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("odm", c_void_p),
- ("node", c_void_p)
- 
- ## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_QualitySwitch
-class FEVT_QualitySwitch(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("up", gf_bool),
- ("dependent_group_index", c_uint),
- ("q_idx", c_int),
- ("set_tile_mode_plus_one", c_uint),
- ("quality_degradation", c_uint)
- 
- ## \endcond
-
-#TODO GF_FEVT_Event;
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_FileDelete
-class FEVT_FileDelete(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("url", c_char_p)
- 
- ## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_VisibilityHint
-class FEVT_VisibilityHint(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("min_x", c_uint),
- ("max_x", c_uint),
- ("min_y", c_uint),
- ("max_y", c_uint),
- ("is_gaze", gf_bool)
- 
- ## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as \ref GF_FEVT_BufferRequirement
-class FEVT_BufferRequirement(Structure):
- ## \cond private
- _fields_ = 
- ("type", c_uint),
- ("on_pid", _gf_filter_pid),
- ("max_buffer_us", c_uint),
- ("max_playout_us", c_uint),
- ("min_playout_us", c_uint),
- ("pid_only", gf_bool)
- 
- ## \endcond
-
-## event value, as defined in libgpac and usable as a Python object
-#Fields have the same types, names and semantics as GF_FilterEvent
-class FilterEvent(Union):
- ## constructor
- #\param type type of event
- def __init__(self, type=0):
- self.base.type = type
- ## \cond private
- _libgpac.user_init = True
-
- _fields_ = 
- ("base", FEVT_Base),
- ("play", FEVT_Play),
- ("seek", FEVT_SourceSeek),
- ("attach_scene", FEVT_AttachScene),
- #("user_event", FEVT_Event,
- ("quality_switch", FEVT_QualitySwitch),
- ("visibility_hint", FEVT_VisibilityHint),
- ("buffer_req", FEVT_BufferRequirement),
- ("seg_size", FEVT_SegmentSize),
- ("file_del", FEVT_FileDelete)
- 
- ## \endcond
-
-
-## Buffer occupancy object 
-class BufferOccupancy:
- ##\cond private
- def __init__(self, max_units, nb_pck, max_dur, dur, is_final_flush):
- ##\endcond
- ##maximum number of packets (partial or full AU) allowed in buffer
- self.max_units = max_units
- ##number of block allowed in buffer
- self.nb_pck = nb_pck
- ##maximum buffer duration in microseconds
- self.max_dur = max_dur
- ## buffer duration in microseconds
- self.dur = dur
- ##if true, the session has been aborted and this is the final flush for this buffer
- self.is_final_flush = is_final_flush
-
-
-## @}
-
-
-## 
-# \defgroup pycst_grp Constants
-# \ingroup pyapi_grp
-# \brief Constants definitions
-#
-# Python Wrappers for gpac C constants used in this API
-#
-# @{
-
-
-# scheduler type definitions
-##\hideinitializer
-#see \ref GF_FS_SCHEDULER_LOCK_FREE
-GF_FS_SCHEDULER_LOCK_FREE=0
-##\hideinitializer
-##see \ref GF_FS_SCHEDULER_LOCK
-GF_FS_SCHEDULER_LOCK=1
-##\hideinitializer
-##see \ref GF_FS_SCHEDULER_LOCK_FREE_X
-GF_FS_SCHEDULER_LOCK_FREE_X=2
-##\hideinitializer
-##see \ref GF_FS_SCHEDULER_LOCK_FORCE
-GF_FS_SCHEDULER_LOCK_FORCE=3
-##\hideinitializer
-##see \ref GF_FS_SCHEDULER_DIRECT
-GF_FS_SCHEDULER_DIRECT=4
-
-#session flags
-##\hideinitializer
-#see \ref GF_FS_FLAG_LOAD_META
-GF_FS_FLAG_LOAD_META=1<<1
-##\hideinitializer
-#see \ref GF_FS_FLAG_NON_BLOCKING
-GF_FS_FLAG_NON_BLOCKING=1<<2
-##\hideinitializer
-#see \ref GF_FS_FLAG_NO_GRAPH_CACHE
-GF_FS_FLAG_NO_GRAPH_CACHE=1<<3
-##\hideinitializer
-#see \ref GF_FS_FLAG_NO_REGULATION
-GF_FS_FLAG_NO_REGULATION=1<<4
-##\hideinitializer
-#see \ref GF_FS_FLAG_NO_PROBE
-GF_FS_FLAG_NO_PROBE=1<<5
-##\hideinitializer
-#see \ref GF_FS_FLAG_NO_REASSIGN
-GF_FS_FLAG_NO_REASSIGN=1<<6
-##\hideinitializer
-#see \ref GF_FS_FLAG_PRINT_CONNECTIONS
-GF_FS_FLAG_PRINT_CONNECTIONS=1<<7
-##\hideinitializer
-#see \ref GF_FS_FLAG_NO_ARG_CHECK
-GF_FS_FLAG_NO_ARG_CHECK=1<<8
-##\hideinitializer
-#see \ref GF_FS_FLAG_NO_RESERVOIR
-GF_FS_FLAG_NO_RESERVOIR=1<<0
-##\hideinitializer
-#see \ref GF_FS_FLAG_FULL_LINK
-GF_FS_FLAG_FULL_LINK=1<<10
-##\hideinitializer
-#see \ref GF_FS_FLAG_NO_IMPLICIT
-GF_FS_FLAG_NO_IMPLICIT=1<<11
-
-
-##\hideinitializer
-#see \ref GF_PROP_FORBIDEN
-GF_PROP_FORBIDEN=0
-##\hideinitializer
-#see \ref GF_PROP_SINT
-GF_PROP_SINT=1
-##\hideinitializer
-#see \ref GF_PROP_UINT
-GF_PROP_UINT=2
-##\hideinitializer
-#see \ref GF_PROP_LSINT
-GF_PROP_LSINT=3
-##\hideinitializer
-#see \ref GF_PROP_LUINT
-GF_PROP_LUINT=4
-##\hideinitializer
-#see \ref GF_PROP_BOOL
-GF_PROP_BOOL=5
-##\hideinitializer
-#see \ref GF_PROP_FRACTION
-GF_PROP_FRACTION=6
-##\hideinitializer
-#see \ref GF_PROP_FRACTION64
-GF_PROP_FRACTION64=7
-##\hideinitializer
-#see \ref GF_PROP_FLOAT
-GF_PROP_FLOAT=8
-##\hideinitializer
-#see \ref GF_PROP_DOUBLE
-GF_PROP_DOUBLE=9
-##\hideinitializer
-#see \ref GF_PROP_VEC2I
-GF_PROP_VEC2I=10
-##\hideinitializer
-#see \ref GF_PROP_VEC2
-GF_PROP_VEC2=11
-##\hideinitializer
-#see \ref GF_PROP_VEC3I
-GF_PROP_VEC3I=12
-##\hideinitializer
-#see \ref GF_PROP_VEC4I
-GF_PROP_VEC4I=13
-##\hideinitializer
-#see \ref GF_PROP_STRING
-GF_PROP_STRING=14
-##\hideinitializer
-#see \ref GF_PROP_STRING_NO_COPY
-GF_PROP_STRING_NO_COPY=15
-##\hideinitializer
-#see \ref GF_PROP_DATA
-GF_PROP_DATA=16
-##\hideinitializer
-#see \ref GF_PROP_NAME
-GF_PROP_NAME=17
-##\hideinitializer
-#see \ref GF_PROP_DATA_NO_COPY
-GF_PROP_DATA_NO_COPY=18
-##\hideinitializer
-#see \ref GF_PROP_CONST_DATA
-GF_PROP_CONST_DATA=19
-##\hideinitializer
-#see \ref GF_PROP_POINTER
-GF_PROP_POINTER=20
-##\hideinitializer
-#see \ref GF_PROP_STRING_LIST
-GF_PROP_STRING_LIST=21
-##\hideinitializer
-#see \ref GF_PROP_UINT_LIST
-GF_PROP_UINT_LIST=22
-##\hideinitializer
-#see \ref GF_PROP_SINT_LIST
-GF_PROP_SINT_LIST=23
-##\hideinitializer
-#see \ref GF_PROP_VEC2I_LIST
-GF_PROP_VEC2I_LIST=24
-##\hideinitializer
-#see \ref GF_PROP_4CC
-GF_PROP_4CC=25
-##\hideinitializer
-#see \ref GF_PROP_4CC_LIST
-GF_PROP_4CC_LIST=26
-
-##\hideinitializer
-#see \ref GF_PROP_FIRST_ENUM
-GF_PROP_FIRST_ENUM=40
-##\hideinitializer
-#see \ref GF_PROP_PIXFMT
-GF_PROP_PIXFMT=GF_PROP_FIRST_ENUM
-##\hideinitializer
-#see \ref GF_PROP_PCMFMT
-GF_PROP_PCMFMT=GF_PROP_FIRST_ENUM+1
-##\hideinitializer
-#see \ref GF_PROP_CICP_COL_PRIM
-GF_PROP_CICP_COL_PRIM=GF_PROP_FIRST_ENUM+2
-##\hideinitializer
-#see \ref GF_PROP_CICP_COL_TFC
-GF_PROP_CICP_COL_TFC=GF_PROP_FIRST_ENUM+3
-##\hideinitializer
-#see \ref GF_PROP_CICP_COL_MX
-GF_PROP_CICP_COL_MX=GF_PROP_FIRST_ENUM+4
-
-##\hideinitializer
-#see GF_FEVT_PLAY
-GF_FEVT_PLAY = 1
-##\hideinitializer
-#see GF_FEVT_SET_SPEED
-GF_FEVT_SET_SPEED = 2
-##\hideinitializer
-#see GF_FEVT_STOP
-GF_FEVT_STOP = 3
-##\hideinitializer
-#see GF_FEVT_PAUSE
-GF_FEVT_PAUSE = 4
-##\hideinitializer
-#see GF_FEVT_RESUME
-GF_FEVT_RESUME = 5
-##\hideinitializer
-#see GF_FEVT_SOURCE_SEEK
-GF_FEVT_SOURCE_SEEK = 6
-##\hideinitializer
-#see GF_FEVT_SOURCE_SWITCH
-GF_FEVT_SOURCE_SWITCH = 7
-##\hideinitializer
-#see GF_FEVT_SEGMENT_SIZE
-GF_FEVT_SEGMENT_SIZE = 8
-##\hideinitializer
-#see GF_FEVT_ATTACH_SCENE
-GF_FEVT_ATTACH_SCENE = 9
-##\hideinitializer
-#see GF_FEVT_RESET_SCENE
-GF_FEVT_RESET_SCENE = 10
-##\hideinitializer
-#see GF_FEVT_QUALITY_SWITCH
-GF_FEVT_QUALITY_SWITCH = 11
-##\hideinitializer
-#see GF_FEVT_VISIBILITY_HINT
-GF_FEVT_VISIBILITY_HINT = 12
-##\hideinitializer
-#see GF_FEVT_INFO_UPDATE
-GF_FEVT_INFO_UPDATE = 13
-##\hideinitializer
-#see GF_FEVT_BUFFER_REQ
-GF_FEVT_BUFFER_REQ = 14
-##\hideinitializer
-#see GF_FEVT_CAPS_CHANGE
-GF_FEVT_CAPS_CHANGE = 15
-##\hideinitializer
-#see GF_FEVT_CONNECT_FAIL
-GF_FEVT_CONNECT_FAIL = 16
-##\hideinitializer
-#see GF_FEVT_USER
-GF_FEVT_USER = 17
-##\hideinitializer
-#see GF_FEVT_PLAY_HINT
-GF_FEVT_PLAY_HINT = 18
-##\hideinitializer
-#see GF_FEVT_FILE_DELETE
-GF_FEVT_FILE_DELETE = 19
-
-
-##\hideinitializer
-#see GF_FS_ARG_HINT_NORMAL
-GF_FS_ARG_HINT_NORMAL = 0
-##\hideinitializer
-#see GF_FS_ARG_HINT_ADVANCED
-GF_FS_ARG_HINT_ADVANCED = 1<<1
-##\hideinitializer
-#see GF_FS_ARG_HINT_EXPERT
-GF_FS_ARG_HINT_EXPERT = 1<<2
-##\hideinitializer
-#see GF_FS_ARG_HINT_HIDE
-GF_FS_ARG_HINT_HIDE = 1<<3
-##\hideinitializer
-#see GF_FS_ARG_UPDATE
-GF_FS_ARG_UPDATE = 1<<4
-##\hideinitializer
-#see GF_FS_ARG_META
-GF_FS_ARG_META = 1<<5
-##\hideinitializer
-#see GF_FS_ARG_META_ALLOC
-GF_FS_ARG_META_ALLOC = 1<<6
-##\hideinitializer
-#see GF_FS_ARG_SINK_ALIAS
-GF_FS_ARG_SINK_ALIAS = 1<<7
-
-
-##\hideinitializer
-#see GF_CAPFLAG_IN_BUNDLE
-GF_CAPFLAG_IN_BUNDLE = 1
-##\hideinitializer
-#see GF_CAPFLAG_INPUT
-GF_CAPFLAG_INPUT = 1<<1
-##\hideinitializer
-#see GF_CAPFLAG_OUTPUT
-GF_CAPFLAG_OUTPUT = 1<<2
-##\hideinitializer
-#see GF_CAPFLAG_EXCLUDED
-GF_CAPFLAG_EXCLUDED = 1<<3
-##\hideinitializer
-#see GF_CAPFLAG_LOADED_FILTER
-GF_CAPFLAG_LOADED_FILTER = 1<<4
-##\hideinitializer
-#see GF_CAPFLAG_STATIC
-GF_CAPFLAG_STATIC = 1<<5
-##\hideinitializer
-#see GF_CAPFLAG_OPTIONAL
-GF_CAPFLAG_OPTIONAL = 1<<6
-
-#helpers
-##\hideinitializer
-#see GF_CAPS_INPUT
-GF_CAPS_INPUT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT)
-##\hideinitializer
-#see GF_CAPS_INPUT_OPT
-GF_CAPS_INPUT_OPT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OPTIONAL)
-##\hideinitializer
-#see GF_CAPS_INPUT_STATIC
-GF_CAPS_INPUT_STATIC = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_STATIC)
-##\hideinitializer
-#see GF_CAPS_INPUT_STATIC_OPT
-GF_CAPS_INPUT_STATIC_OPT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_STATIC|GF_CAPFLAG_OPTIONAL)
-##\hideinitializer
-#see GF_CAPS_INPUT_EXCLUDED
-GF_CAPS_INPUT_EXCLUDED = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_EXCLUDED)
-##\hideinitializer
-#see GF_CAPS_INPUT_LOADED_FILTER
-GF_CAPS_INPUT_LOADED_FILTER = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_LOADED_FILTER)
-##\hideinitializer
-#see GF_CAPS_OUTPUT
-GF_CAPS_OUTPUT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT)
-##\hideinitializer
-#see GF_CAPS_OUTPUT_LOADED_FILTER
-GF_CAPS_OUTPUT_LOADED_FILTER = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_LOADED_FILTER)
-##\hideinitializer
-#see GF_CAPS_OUTPUT_EXCLUDED
-GF_CAPS_OUTPUT_EXCLUDED = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_EXCLUDED)
-##\hideinitializer
-#see GF_CAPS_OUTPUT_STATIC
-GF_CAPS_OUTPUT_STATIC = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_STATIC)
-##\hideinitializer
-#see GF_CAPS_OUTPUT_STATIC_EXCLUDED
-GF_CAPS_OUTPUT_STATIC_EXCLUDED = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_EXCLUDED|GF_CAPFLAG_STATIC)
-##\hideinitializer
-#see GF_CAPS_INPUT_OUTPUT
-GF_CAPS_INPUT_OUTPUT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OUTPUT)
-##\hideinitializer
-#see GF_CAPS_INPUT_OUTPUT_OPT
-GF_CAPS_INPUT_OUTPUT_OPT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_OPTIONAL)
-
-
-##\hideinitializer
-#see \ref GF_SCRIPT_INFO
-GF_SCRIPT_INFO = 3
-##\hideinitializer
-#see \ref GF_PENDING_PACKET
-GF_PENDING_PACKET = 2
-##\hideinitializer
-#see \ref GF_EOS
-GF_EOS = 1
-##\hideinitializer
-#see \ref GF_OK
-GF_OK = 0
-##\hideinitializer
-#see \ref GF_BAD_PARAM
-GF_BAD_PARAM = -1
-##\hideinitializer
-#see \ref GF_OUT_OF_MEM
-GF_OUT_OF_MEM = -2
-##\hideinitializer
-#see \ref GF_IO_ERR
-GF_IO_ERR = -3
-##\hideinitializer
-#see \ref GF_NOT_SUPPORTED
-GF_NOT_SUPPORTED = -4
-##\hideinitializer
-#see \ref GF_CORRUPTED_DATA
-GF_CORRUPTED_DATA = -5
-##\hideinitializer
-#see \ref GF_SCRIPT_ERROR
-GF_SCRIPT_ERROR = -8
-##\hideinitializer
-#see \ref GF_BUFFER_TOO_SMALL
-GF_BUFFER_TOO_SMALL = -9
-##\hideinitializer
-#see \ref GF_NON_COMPLIANT_BITSTREAM
-GF_NON_COMPLIANT_BITSTREAM = -10
-##\hideinitializer
-#see \ref GF_FILTER_NOT_FOUND
-GF_FILTER_NOT_FOUND = -11
-##\hideinitializer
-#see \ref GF_URL_ERROR
-GF_URL_ERROR = -12
-##\hideinitializer
-#see \ref GF_SERVICE_ERROR
-GF_SERVICE_ERROR = -13
-##\hideinitializer
-#see \ref GF_REMOTE_SERVICE_ERROR
-GF_REMOTE_SERVICE_ERROR = -14
-##\hideinitializer
-#see \ref GF_STREAM_NOT_FOUND
-GF_STREAM_NOT_FOUND = -15
-##\hideinitializer
-#see \ref GF_URL_REMOVED
-GF_URL_REMOVED = -16
-##\hideinitializer
-#see \ref GF_IP_ADDRESS_NOT_FOUND
-GF_IP_ADDRESS_NOT_FOUND = -40
-##\hideinitializer
-#see \ref GF_IP_CONNECTION_FAILURE
-GF_IP_CONNECTION_FAILURE = -41
-##\hideinitializer
-#see \ref GF_IP_NETWORK_FAILURE
-GF_IP_NETWORK_FAILURE = -42
-##\hideinitializer
-#see \ref GF_IP_CONNECTION_CLOSED
-GF_IP_CONNECTION_CLOSED = -43
-##\hideinitializer
-#see \ref GF_IP_NETWORK_EMPTY
-GF_IP_NETWORK_EMPTY = -44
-##\hideinitializer
-#see \ref GF_IP_SOCK_WOULD_BLOCK
-GF_IP_SOCK_WOULD_BLOCK = -45
-##\hideinitializer
-#see \ref GF_IP_UDP_TIMEOUT
-GF_IP_UDP_TIMEOUT = -46
-##\hideinitializer
-#see \ref GF_AUTHENTICATION_FAILURE
-GF_AUTHENTICATION_FAILURE = -50
-##\hideinitializer
-#see \ref GF_SCRIPT_NOT_READY
-GF_SCRIPT_NOT_READY = -51
-##\hideinitializer
-#see \ref GF_INVALID_CONFIGURATION
-GF_INVALID_CONFIGURATION = -52
-##\hideinitializer
-#see \ref GF_NOT_FOUND
-GF_NOT_FOUND = -53
-##\hideinitializer
-#see \ref GF_PROFILE_NOT_SUPPORTED
-GF_PROFILE_NOT_SUPPORTED = -54
-##\hideinitializer
-#see \ref GF_REQUIRES_NEW_INSTANCE
-GF_REQUIRES_NEW_INSTANCE = -56
-##\hideinitializer
-#see \ref GF_FILTER_NOT_SUPPORTED
-GF_FILTER_NOT_SUPPORTED = -57
-
-##notification is a setup error, the filter chain was never connected
-GF_SETUP_ERROR=0
-##notification is an error but keep the filter chain connected
-GF_NOTIF_ERROR=1
-##notification is an error and disconnect the filter chain
-GF_NOTIF_ERROR_AND_DISCONNECT=2
-
-
-##Do not flush session: everything is discarded, potentially breaking output files
-GF_FS_FLUSH_NONE=0,
-##Flush all pending data before closing sessions: sources will be forced into end of stream and all emitted packets will be processed
-GF_FS_FLUSH_ALL=1
-##Stop session (resetting buffers) and flush pipeline
-GF_FS_FLUSH_FAST=2
-
-## @}
-
-##\cond private
-
-_gf_filter_session = c_void_p
-_gf_filter = c_void_p
-_gf_filter_pid = c_void_p
-
-#
-# filter session bindings
-#
-
-_libgpac.gf_fs_new.argtypes = c_int, c_int, c_int, c_char_p
-_libgpac.gf_fs_new.restype = _gf_filter_session
-
-_libgpac.gf_fs_del.argtypes = _gf_filter_session
-_libgpac.gf_fs_del.restype = None
-
-_libgpac.gf_fs_run.argtypes = _gf_filter_session
-
-_libgpac.gf_fs_load_source.argtypes = _gf_filter_session, c_char_p, c_char_p, c_char_p, POINTER(c_int)
-_libgpac.gf_fs_load_source.restype = _gf_filter
-
-_libgpac.gf_fs_load_destination.argtypes = _gf_filter_session, c_char_p, c_char_p, c_char_p, POINTER(c_int)
-_libgpac.gf_fs_load_destination.restype = _gf_filter
-
-_libgpac.gf_fs_load_filter.argtypes = _gf_filter_session, c_char_p, POINTER(c_int)
-_libgpac.gf_fs_load_filter.restype = _gf_filter
-
-_libgpac.gf_fs_new_filter.argtypes = _gf_filter_session, c_char_p, c_uint, POINTER(c_int)
-_libgpac.gf_fs_new_filter.restype = _gf_filter
-
-
-_libgpac.gf_fs_post_user_task.argtypes = _gf_filter_session, c_void_p, py_object, c_char_p
-_libgpac.gf_fs_post_user_task.restype = c_int
-
-_libgpac.gf_fs_is_last_task.argtypes = _gf_filter_session
-_libgpac.gf_fs_is_last_task.restype = gf_bool
-
-_libgpac.gf_fs_get_filters_count.argtypes = _gf_filter_session
-_libgpac.gf_fs_get_filter.argtypes = _gf_filter_session, c_int
-_libgpac.gf_fs_get_filter.restype = _gf_filter
-
-_libgpac.gf_fs_abort.argtypes = _gf_filter_session, c_int
-
-_libgpac.gf_fs_get_http_max_rate.argtypes = _gf_filter_session
-_libgpac.gf_fs_get_http_rate.argtypes = _gf_filter_session
-_libgpac.gf_fs_set_http_max_rate.argtypes = _gf_filter_session, c_uint
-
-_libgpac.gf_fs_lock_filters.argtypes = _gf_filter_session, gf_bool
-_libgpac.gf_fs_enable_reporting.argtypes = _gf_filter_session, gf_bool
-
-_libgpac.gf_fs_print_stats.argtypes = _gf_filter_session
-_libgpac.gf_fs_print_connections.argtypes = _gf_filter_session
-
-_libgpac.gf_fs_fire_event.argtypes = _gf_filter_session, _gf_filter, POINTER(FilterEvent), gf_bool
-_libgpac.gf_fs_fire_event.restype = gf_bool
-
-_libgpac.gf_fs_is_supported_mime.argtypes = _gf_filter_session, c_char_p
-_libgpac.gf_fs_is_supported_mime.restype = gf_bool
-
-_libgpac.gf_fs_is_supported_mime.argtypes = _gf_filter_session, c_char_p
-_libgpac.gf_fs_is_supported_mime.restype = gf_bool
-
-_libgpac.gf_fs_is_supported_source.argtypes = _gf_filter_session, c_char_p, c_char_p
-_libgpac.gf_fs_is_supported_source.restype = gf_bool
-
-_libgpac.gf_pixel_fmt_sname.argtypes = c_uint
-_libgpac.gf_pixel_fmt_sname.restype = c_char_p
-
-
-@CFUNCTYPE(c_int, _gf_filter_session, c_void_p, POINTER(c_uint))
-def fs_task_fun(sess, cbk, resched):
- obj = cast(cbk, py_object).value
- res = obj.execute()
- if res==None or res<0:
- obj.session.rem_task(obj)
- return 0
- resched.contents.value=res
- return 1
-
-
-
-_libgpac.gf_fs_set_filter_creation_callback.argtypes = _gf_filter_session, c_void_p, py_object, gf_bool
-@CFUNCTYPE(c_int, c_void_p, _gf_filter, gf_bool)
-def on_filter_new_del(cbk, _filter, is_del):
- sess = cast(cbk, py_object).value
- f = sess._to_filter(_filter)
- if is_del:
- if hasattr(sess, 'on_filter_del'):
- sess.on_filter_del(f)
- sess._filters.remove(f)
- elif hasattr(sess, 'on_filter_new'):
- sess.on_filter_new(f)
-
- return 0
-
-##\endcond
-
-
-## Task object for user callbacks from libgpac scheduler 
-class FilterTask:
- ## constructor for tasks
- #\param name name of the task (used for logging)
- def __init__(self, name):
- ##Task name
- #\hideinitializer
- self.name = name
- ##Filter session
- #\hideinitializer
- self.session = None
- ## task execution function
- #\return -1 or less to remove the task from the scheduler, 0 or more to indicate the number of milliseconds to wait before calling the task again
- def execute(self):
- return -1
-
-
-## filter session object - see \ref GF_FilterSession
-class FilterSession:
- ## constructor for filter session - see \ref gf_fs_new
- #\param flags session flags (int)
- #\param blacklist list of blacklisted filters
- #\param nb_threads number of threads to use (int)
- #\param sched_type session scheduler type
- def __init__(self, flags=0, blacklist=None, nb_threads=0, sched_type=0):
- ##\cond private
- _libgpac.user_init = True
- self._sess = None
- if blacklist:
- self._sess = _libgpac.gf_fs_new(nb_threads, sched_type, flags, blacklist.encode('utf-8'))
- else:
- self._sess = _libgpac.gf_fs_new(nb_threads, sched_type, flags, None)
- if not self._sess:
- raise Exception('Failed to create new filter session')
- self._filters = 
- self._tasks = 
- #for now force sync user tasks and filter management to run on main thread, not tested otherwise
- _libgpac.gf_fs_set_filter_creation_callback(self._sess, on_filter_new_del, py_object(self), True)
-
- ##\endcond
- #hack for doxygen to generate member vars (not support for parsing @property)
- if 0:
- ##set to true if this is the last task running, readonly - see \ref gf_fs_is_last_task
- self.last_task=0
- ##number of filters in session, readonly - see \ref gf_fs_get_filters_count
- self.nb_filters=0
- ##current HTTP cumulated download rate, readonly - see \ref gf_fs_get_http_rate
- self.http_bitrate=0
- ##HTTP max download rate - see \ref gf_fs_get_http_max_rate and \ref gf_fs_set_http_max_rate
- self.http_max_bitrate=0
-
-
- ## delete an existing filter session - see \ref gf_fs_del
- #\warning The filter session must be explicitly destroyed if close (\ref gf_sys_close) is called after that 
- #\return
- def delete(self):
- ##\cond private
- if self._sess:
- _libgpac.gf_fs_del(self._sess)
- self._sess=None
- ##\endcond private
-
- ## called whenever a new filter is added, typically used by classes deriving from FilterSession
- #\param filter Filter object being added
- #\return
- def on_filter_new(self, filter):
- pass
-
- ## called whenever a filter is destroyed, typically used by classes deriving from FilterSession
- #\param filter Filter object being removed
- #\return
- def on_filter_del(self, filter):
- pass
-
- ##\cond private
- def _to_filter(self, f):
- for i, a_f in enumerate(self._filters):
- if a_f._filter == f:
- return a_f
- filter = Filter(self, f)
- self._filters.append(filter)
- return filter
- ##\endcond private
-
- ##run the session - see \ref gf_fs_run
- #\return
- def run(self):
- err = _libgpac.gf_fs_run(self._sess)
- if err<0: 
- raise Exception('Failed to run session: ' + e2s(err))
-
- ##load source filter - see \ref gf_fs_load_source
- #\param URL source URL to load
- #\param parentURL URL of parent resource for relative path resolution
- #\return new Filter object
- def load_src(self, URL, parentURL=None):
- errp = c_int(0)
- if parentURL:
- filter = _libgpac.gf_fs_load_source(self._sess, URL.encode('utf-8'), None, parentURL.encode('utf-8'), byref(errp))
- else:
- filter = _libgpac.gf_fs_load_source(self._sess, URL.encode('utf-8'), None, None, byref(errp))
- err = errp.value
- if err<0: 
- raise Exception('Failed to load source filter ' + URL + ': ' + e2s(err))
- return self._to_filter(filter)
-
- ##load destination filter - see \ref gf_fs_load_destination
- #\param URL source URL to load
- #\param parentURL URL of parent resource for relative path resolution
- #\return new Filter object
- def load_dst(self, URL, parentURL=None):
- errp = c_int(0)
- if parentURL:
- filter = _libgpac.gf_fs_load_destination(self._sess, URL.encode('utf-8'), None, parentURL.encode('utf-8'), byref(errp))
- else:
- filter = _libgpac.gf_fs_load_destination(self._sess, URL.encode('utf-8'), None, None, byref(errp))
- err = errp.value
- if err<0: 
- raise Exception('Failed to load destination filter ' + URL + ': ' + e2s(err))
- return self._to_filter(filter)
-
-
- ##load a filter - see \ref gf_fs_load_filter
- #\param fname filter name and options
- #\return new Filter object
- def load(self, fname):
- errp = c_int(0)
- filter = _libgpac.gf_fs_load_filter(self._sess, fname.encode('utf-8'), byref(errp))
- err = errp.value
- if err<0: 
- raise Exception('Failed to load filter ' + fname + ': ' + e2s(err))
- return self._to_filter(filter)
-
- ##post a user task to the filter sesison - see \ref gf_fs_post_user_task
- #\param task task object to post
- #\return
- def post(self, task):
- task.session = self
- err = _libgpac.gf_fs_post_user_task(self._sess, fs_task_fun, py_object(task), task.name.encode('utf-8'))
- if err<0: 
- raise Exception('Failed to post task ' + task.name + ': ' + e2s(err))
- self._tasks.append(task)
-
- ##\cond private
- #\return
- def rem_task(self, task):
- task.session = None
- self._tasks.remove(task)
- ##\endcond
-
- ##abort the session - see \ref gf_fs_abort
- #\param flush flush pipeline before abort
- #\return
- def abort(self, flush=0):
- _libgpac.gf_fs_abort(self._sess, flush)
- 
- ##get a filter by index - see \ref gf_fs_get_filter
- #\param index index of filter
- #\return Filter object
- def get_filter(self, index):
- f = _libgpac.gf_fs_get_filter(self._sess, index)
- if not f:
- raise Exception('Failed to get filter at index ' + str(index) )
- return self._to_filter(f)
-
- 
- ##lock the session - see \ref gf_fs_lock_filters
- #\param lock if True, locks otherwise unlocks
- #\return
- def lock(self, lock):
- _libgpac.gf_fs_lock_filters(self._sess, lock)
-
- ##enable status reporting by filters - see \ref gf_fs_enable_reporting
- #\param do_report if True, enables reporting
- #\return
- def reporting(self, do_report):
- _libgpac.gf_fs_enable_reporting(self._sess, do_report)
-
- ##print statistics on stderr - see \ref gf_fs_print_stats
- #\return
- def print_stats(self):
- _libgpac.gf_fs_print_stats(self._sess)
-
- ##print graph on stderr - see \ref gf_fs_print_connections
- #\return
- def print_graph(self):
- _libgpac.gf_fs_print_connections(self._sess)
-
- ##fire an event on the given filter if any, or on any filter accepting user events
- # \param evt FilterEvent to fire
- # \param filter Filter to use as target
- # \param upstream if true, walks the chain towards the sink, otehrwise towards the source
- #\return
- def fire_event(self, evt, filter=None, upstream=False):
- if filter:
- return _libgpac.gf_fs_fire_event(self._sess, filter._filter, byref(evt), upstream)
- return _libgpac.gf_fs_fire_event(self._sess, None, byref(evt), upstream)
-
- ##checks if a given mime is supported - see \ref gf_fs_is_supported_mime
- # \param mime mime type to check
- # \return true or false
- def is_supported_mime(self, mime):
- return _libgpac.gf_fs_is_supported_mime(self._sess, mime.encode('utf-8'))
-
- ##checks if a given source URL is supported - see \ref gf_fs_is_supported_source
- # \param url URL to check
- # \param parent parent URL for relative URLs
- # \return true or false
- def is_supported_source(self, url, parent=None):
- if parent:
- return _libgpac.gf_fs_is_supported_source(self._sess, url.encode('utf-8'), parent.encode('utf-8'))
- return _libgpac.gf_fs_is_supported_source(self._sess, url.encode('utf-8'), None)
-
-
- ##\cond private: until end, properties
- @property
- def last_task(self):
- if _libgpac.gf_fs_is_last_task(self._sess):
- return True
- return False
-
- @property
- def nb_filters(self):
- return _libgpac.gf_fs_get_filters_count(self._sess)
-
- @property
- def http_bitrate(self):
- return _libgpac.gf_fs_get_http_rate(self._sess)
- 
- @property
- def http_max_bitrate(self):
- return _libgpac.gf_fs_get_http_max_rate(self._sess)
-
- @http_max_bitrate.setter
- def http_max_bitrate(self, value):
- return _libgpac.gf_fs_set_http_max_rate(self._sess, value)
-
- ##\endcond
-
-
- #TODO
- #global session: session caps ?
-
- #missing features available in JSFilterSession API but with no native direct equivalents:
- #set_new_filter_fun, set_del_filter_fun, set_event_fun
-
-
-
-## \cond private
-#
-# filter bindings
-#
-_libgpac.gf_filter_get_name.argtypes = _gf_filter
-_libgpac.gf_filter_get_name.restype = c_char_p
-_libgpac.gf_filter_get_id.argtypes = _gf_filter
-_libgpac.gf_filter_get_id.restype = c_char_p
-_libgpac.gf_filter_get_ipid_count.argtypes = _gf_filter
-_libgpac.gf_filter_get_opid_count.argtypes = _gf_filter
-
-
-
-_libgpac.gf_filter_get_stats.argtypes = _gf_filter, POINTER(FilterStats)
-_libgpac.gf_filter_remove.argtypes = _gf_filter
-_libgpac.gf_fs_send_update.argtypes = _gf_filter_session, c_char_p, _gf_filter, c_char_p, c_char_p, c_uint
-_libgpac.gf_filter_set_source.argtypes = _gf_filter, _gf_filter, c_char_p
-_libgpac.gf_filter_set_source_restricted.argtypes = _gf_filter, _gf_filter, c_char_p
-_libgpac.gf_filter_reconnect_output.argtypes = _gf_filter
-
-_libgpac.gf_props_get_id.argtypes = c_char_p
-_libgpac.gf_filter_get_ipid.argtypes = _gf_filter, c_uint
-_libgpac.gf_filter_get_ipid.restype = _gf_filter_pid
-_libgpac.gf_filter_get_opid.argtypes = _gf_filter, c_uint
-_libgpac.gf_filter_get_opid.restype = _gf_filter_pid
-_libgpac.gf_filter_pid_get_property.argtypes = _gf_filter_pid, c_uint
-_libgpac.gf_filter_pid_get_property.restype = POINTER(PropertyValue)
-_libgpac.gf_filter_pid_get_property_str.argtypes = _gf_filter_pid, c_char_p
-_libgpac.gf_filter_pid_get_property_str.restype = POINTER(PropertyValue)
-
-_libgpac.gf_filter_pid_get_info.argtypes = _gf_filter_pid, c_uint, POINTER(POINTER(_gf_property_entry))
-_libgpac.gf_filter_pid_get_info.restype = POINTER(PropertyValue)
-_libgpac.gf_filter_pid_get_info_str.argtypes = _gf_filter_pid, c_char_p, POINTER(POINTER(_gf_property_entry))
-_libgpac.gf_filter_pid_get_info_str.restype = POINTER(PropertyValue)
-_libgpac.gf_filter_release_property.argtypes = POINTER(_gf_property_entry)
-
-_libgpac.gf_props_type_is_enum.argtypes = c_uint
-_libgpac.gf_props_type_is_enum.restype = c_int
-
-_libgpac.gf_props_parse_enum.argtypes = c_uint, c_char_p
-_libgpac.gf_props_parse_enum.restype = c_uint
-
-_libgpac.gf_pixel_fmt_name.argtypes = c_uint
-_libgpac.gf_pixel_fmt_name.restype = c_char_p
-
-_libgpac.gf_audio_fmt_name.argtypes = c_uint
-_libgpac.gf_audio_fmt_name.restype = c_char_p
-
-_libgpac.gf_filter_pid_enum_properties.argtypes = _gf_filter_pid, POINTER(c_uint), POINTER(c_uint), POINTER(c_char_p)
-_libgpac.gf_filter_pid_enum_properties.restype = POINTER(PropertyValue)
-
-_libgpac.gf_props_4cc_get_name.argtypes = c_uint
-_libgpac.gf_props_4cc_get_name.restype = c_char_p
-
-_libgpac.gf_stream_type_name.argtypes = c_uint
-_libgpac.gf_stream_type_name.restype = c_char_p
-
-_libgpac.gf_codecid_file_ext.argtypes = c_uint
-_libgpac.gf_codecid_file_ext.restype = c_char_p
-
-_libgpac.gf_filter_pid_get_source_filter.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_source_filter.restype = _gf_filter
-
-_libgpac.gf_filter_pid_enum_destinations.argtypes = _gf_filter_pid, c_uint
-_libgpac.gf_filter_pid_enum_destinations.restype = _gf_filter
-
-_libgpac.gf_filter_enumerate_args.argtypes = _gf_filter, c_uint
-_libgpac.gf_filter_enumerate_args.restype = POINTER(FilterArg)
-
-_libgpac.gf_filter_get_info.argtypes = _gf_filter, c_uint, POINTER(POINTER(_gf_property_entry))
-_libgpac.gf_filter_get_info.restype = POINTER(PropertyValue)
-_libgpac.gf_filter_get_info_str.argtypes = _gf_filter, c_char_p, POINTER(POINTER(_gf_property_entry))
-_libgpac.gf_filter_get_info_str.restype = POINTER(PropertyValue)
-
-_libgpac.gf_filter_require_source_id.argtypes = _gf_filter
-
-_libgpac.gf_filter_bind_dash_algo_callbacks.argtypes = _gf_filter, py_object, c_void_p, c_void_p, c_void_p, c_void_p
-@CFUNCTYPE(c_int, c_void_p, c_uint)
-def dash_period_reset(cbk, reset_type):
- obj = cast(cbk, py_object).value
- if hasattr(obj, 'on_period_reset'):
- obj.on_period_reset(reset_type)
- if not reset_type:
- obj.groups = 
- return 0
-
-class DASHQualityInfoNat(Structure):
- _fields_ = 
- ("bandwidth", c_uint),
- ("ID", c_char_p),
- ("mime", c_char_p),
- ("codec", c_char_p),
- ("width", c_uint),
- ("height", c_uint),
- ("interlaced", gf_bool),
- ("fps_num", c_uint),
- ("fps_den", c_uint),
- ("sar_num", c_uint),
- ("sar_den", c_uint),
- ("sample_rate", c_uint),
- ("nb_channels", c_uint),
- ("disabled", gf_bool),
- ("is_selected", gf_bool),
- ("ast_offset", c_double),
- ("avg_duration", c_double),
- ("sizes", _gf_list),
- 
-
-class DASHByteRange(Structure):
- _fields_ = 
- ("start", c_ulonglong),
- ("end", c_ulonglong)
- 
-
-class DASHSegURL(Structure):
- _fields_ = 
- ("media", c_char_p),
- ("media_range", POINTER(DASHByteRange))
- #ignore the rest
- 
-
-
-_libgpac.gf_dash_group_get_num_qualities.argtypes = c_void_p, c_uint
-_libgpac.gf_dash_get_period_duration.argtypes = c_void_p
-_libgpac.gf_dash_group_get_quality_info.argtypes = c_void_p, c_uint, c_uint, POINTER(DASHQualityInfoNat) 
-
-_libgpac.gf_dash_group_get_srd_info.argtypes = c_void_p, c_uint, POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint) 
-
-_libgpac.gf_list_count.argtypes = c_void_p
-_libgpac.gf_list_count.restype = c_uint
-
-_libgpac.gf_list_get.argtypes = c_void_p, c_uint
-_libgpac.gf_list_get.restype = c_void_p
-
-
-## \endcond
-
-## 
-# \defgroup pydash_grp DASH custom algorithm
-# \ingroup pyapi_grp
-# \brief Python API for libgpac.
-#
-# @{
-
-## DASH media quality information (Representation info)
-class DASHQualityInfo:
- ## \cond priv
- def __init__(self, qinfon):
- ## \endcond
- ## bandwidth in bits per second
- self.bandwidth = qinfon.bandwidth
- ## ID (representation ID in DASH)
- self.ID = qinfon.ID.decode('utf-8')
- ## MIME type
- self.mime = qinfon.mime.decode('utf-8')
- ## codec parameter string
- self.codec = qinfon.codec.decode('utf-8')
- ## width in pixels, 0 if not visual
- self.width = qinfon.width
- ## height in pixels, 0 if not visual
- self.height = qinfon.height
- ## interlaced flag, false 0 if not visual
- self.interlaced = qinfon.interlaced
- ## Frame Rate (Fraction), 0/0 if not visual
- self.fps = Fraction(qinfon.fps_num, qinfon.fps_den)
- ## Sample Aspect Ration (Fraction), 0/0 if not visual
- self.sar = Fraction(qinfon.sar_num, qinfon.sar_den)
- ## Samplerate, 0 if not audio
- self.sample_rate = qinfon.sample_rate
- ## Number of channels, 0 if not audio
- self.nb_channels = qinfon.nb_channels
- ## set to true if quality is disabled (no playback support)
- self.disabled = qinfon.disabled
- ## set to true if quality is selected
- self.is_selected = qinfon.is_selected
- ## AST offset for DASH low latency mode, 0 otherwise
- self.ast_offset = qinfon.ast_offset
- ## Average segment duration in seconds, 0 if unknown
- self.avg_duration = qinfon.avg_duration
- ## list of segment sizes for VoD cases, None otherwise or if unknown
- self.sizes = None
- ## \cond priv
- if qinfon.sizes == None:
- return
- count = _libgpac.gf_list_count(qinfon.sizes)
- self.sizes = 
- for i in range(count):
- surl = cast(_libgpac.gf_list_get(qinfon.sizes, i), POINTER(DASHSegURL)).contents
- self.sizes.append( surl.media_range.contents.end - surl.media_range.contents.start + 1)
- ## \endcond priv
-
-##DASH Spatial Relation Descriptor object, used for tiling
-class DASHSRD:
- ## \cond priv
- def __init__(self, id, x, y, w, h, fw, fh):
- ## \endcond
- ## ID of SRD source - all SRD with same source describe the same video composition, possibly with different grid sizes
- self.id = id
- ## X coordinate of SRD for this tile
- self.x = x
- ## Y coordinate of SRD for this tile
- self.y = y
- ## width of SRD for this tile - 0 for tile base track
- self.w = w
- ## height of SRD for this tile - 0 for tile base track
- self.h = h
- ## total width of SRD descriptor for this tile
- self.fw = fw
- ## total height of SRD descriptor for this tile
- self.fh = fh
-
-##\cond priv
-def make_srd(dashptr, groupidx):
- srd_id=c_uint(0)
- srd_x=c_uint(0)
- srd_y=c_uint(0)
- srd_w=c_uint(0)
- srd_h=c_uint(0)
- srd_fw=c_uint(0)
- srd_fh=c_uint(0)
- _libgpac.gf_dash_group_get_srd_info(dashptr, groupidx, byref(srd_id), byref(srd_x), byref(srd_y), byref(srd_w), byref(srd_h), byref(srd_fw), byref(srd_fh) )
- if not srd_fw.value or not srd_fh.value:
- return None
- return DASHSRD(srd_id.value, srd_x.value, srd_y.value, srd_w.value, srd_h.value, srd_fw.value, srd_fh.value)
-
-##\endcond
-
-## DASH group object
-class DASHGroup:
- ## \cond priv
- def __init__(self, ptr_dash, groupidx):
- ## \endcond
- ## Index of group, as used in callbacks
- self.idx = groupidx
- ## List of DASHQualityInfo for group
- self.qualities = 
- ## period duration in milliseconds, 0 if unknwon
- self.duration = _libgpac.gf_dash_get_period_duration(ptr_dash)
- ## SRD object or None if no SRD defined
- self.SRD = make_srd(ptr_dash, groupidx)
- ## \cond priv
- self._dash = ptr_dash
- nb_qualities = _libgpac.gf_dash_group_get_num_qualities(ptr_dash, groupidx)
- for i in range(nb_qualities):
- qinfo = DASHQualityInfoNat()
- _libgpac.gf_dash_group_get_quality_info(ptr_dash, groupidx, i, byref(qinfo))
-
- self.qualities.append( DASHQualityInfo(qinfo) )
- ## \endcond
-
-## DASH groups statistics object
-class DASHGroupStatistics(Structure):
- ## \cond priv
- def __init__(self):
- ## \endcond
- ##download rate of last segment in bits per second, divided by current playback speed
- self.download_rate = 0
- ##size of last segment in bytes
- self.filesize = 0
- ##current playback speed
- self.speed = 0
- ##max playback speed based on associated codec runtime statistics
- self.max_available_speed = 0
- ##display width in pixels of object
- self.display_width = 0
- ##display height in pixels of object
- self.display_height = 0
- ##index of current quality
- self.active_quality_idx = 0
- ##minimum buffer in milliseconds, below witch rebuffer occurs
- self.buffer_min = 0
- ##maximum buffer in milliseconds, algorithm should not fill more than this
- self.buffer_max = 0
- ##current buffer in milliseconds
- self.buffer = 0
- ##degradation hint, 0 means no degradation, 100 means tile completely hidden
- self.quality_degradation_hint = 0
- ##cumulated download rate of all active groups - 0 means all files are local
- self.total_rate = 0
-
- ## \cond private
- _fields_ = 
- ("download_rate", c_uint),
- ("filesize", c_uint),
- ("speed", c_double),
- ("max_available_speed", c_double),
- ("display_width", c_uint),
- ("display_height", c_uint),
- ("active_quality_idx", c_uint),
- ("buffer_min", c_uint),
- ("buffer_max", c_uint),
- ("buffer", c_uint),
- ("degradation_hint", c_uint),
- ("total_rate", c_uint)
- 
- def __str__(self):
- res = 'active_quality_idx ' + str(self.active_quality_idx)
- res += ' rate ' + str(self.download_rate) + ' speed ' + str(self.speed) + ' max_speed ' + str(self.max_available_speed)
- res += ' display_width ' + str(self.display_width) + ' display_height ' + str(self.display_height)
- res += ' buffer_min ' + str(self.buffer_min) + ' buffer_max ' + str(self.buffer_max) + ' buffer ' + str(self.buffer)
- return res
- ## \endcond
-
-## DASH group current segment download statistics object
-class DASHGroupDownloadStatistics(Structure):
- ## \cond priv
- def __init__(self):
- ## \endcond
- ##download rate of last segment in bits per second
- self.bits_per_sec = 0
- ##total number of bytes in segment
- self.total_bytes = 0
- ##number of downloaded bytes from segment (starting from first byte)
- self.bytes_done = 0
- ##number of microseconds elapsed since segment was scheduled for download
- self.time_since_start = 0
- ##current buffer length in milliseconds
- self.buffer_dur = 0
- ##duration of segment being downloaded, in milliseconds - 0 if unknown
- self.current_seg_dur = 0
-
- ## \cond private
- _fields_ = 
- ("bits_per_sec", c_uint),
- ("total_bytes", c_ulonglong),
- ("bytes_done", c_ulonglong),
- ("time_since_start", c_ulonglong),
- ("buffer_dur", c_uint),
- ("current_seg_dur", c_uint),
- 
-
- def __str__(self):
- res = 'bits_per_sec ' + str(self.bits_per_sec)
- res += ' - total_bytes ' + str(self.total_bytes) + ' bytes_done ' + str(self.bytes_done)
- res += ' - time_since_start ' + str(self.time_since_start) + ' us - buffer_dur ' + str(self.buffer_dur) + ' ms - current_seg_dur ' + str(self.current_seg_dur) + ' ms'
- return res
- ## \endcond
-
-
-
-## DASH custom algo
-# Upon successful binding to the dashin filter, the object will be assigned a list member called `groups`, containing the declared group for the active period
-class DASHCustomAlgorithm:
-
- ##Callback (optional) called upon a period reset.
- #\param reset_type indicate the type of period reset. Values can be:
- # - 0: end of period (groups are no longer valid)
- # - 1: start of a static period
- # - 2: start of a dynamic (live) period
- #\return 
- def on_period_reset(self, reset_type):
- pass
-
- ##Callback (optional) called when a new group (adaptation set) is created
- #\param group the newly created \ref DASHGroup
- #\return 
- def on_new_group(self, group):
- pass
-
-
- ##Callback (mandatory) called at the end of the segment download to perform rate adaptation
- #\param group the \ref DASHGroup on which to perform adaptation
- #\param base_group the associated base \ref DASHGroup (tiling only), or None if no base group
- #\param force_low_complexity indicates that the client would like a lower complexity (typically because it is dropping frames)
- #\param stats the \ref DASHGroupStatistics for the downloaded segment
- #\return value can be:
- # - new quality index,
- # - -1 to take no decision
- # - -2 to disable quality (debug, will drop segment)
- # - other negative values are handled as error
- def on_rate_adaptation(self, group, base_group, force_low_complexity, stats):
- pass
-
- ##Callback (optional) called on regular basis during a segment download
- #\param group the \ref DASHGroup associated with the current download
- #\param stats the \ref DASHGroupDownloadStatistics for the download
- #\return value can be:
- # - `-1` to continue download
- # - `-2` to abort download but without retrying to downloading the same segment at lower quality
- # - the index of the new quality to download for the same segment index (same time)
- def on_download_monitor(self, group, stats):
- pass
-
-## @}
-
-
-## \cond priv
-
-
-@CFUNCTYPE(c_int, c_void_p, c_uint, c_void_p)
-def dash_group_new(cbk, groupidx, _dashobj):
- obj = cast(cbk, py_object).value
- if not hasattr(obj, 'on_new_group'):
- return 0
- new_group = DASHGroup(_dashobj, groupidx)
- obj.groups.append(new_group)
- obj.on_new_group(new_group)
- return 0
-
-
-
-@CFUNCTYPE(c_int, c_void_p, c_uint, c_uint, gf_bool, POINTER(DASHGroupStatistics))
-def dash_rate_adaptation(cbk, groupidx, base_groupidx, force_low_complex, stats):
- obj = cast(cbk, py_object).value
- group = None
- base_group = None
- for i in range(len(obj.groups)):
- if obj.groupsi.idx==groupidx:
- group = obj.groupsi
- if obj.groupsi.idx==base_groupidx:
- base_group = obj.groupsi
-
- return obj.on_rate_adaptation(group, base_group, force_low_complex, stats.contents)
-
-
-@CFUNCTYPE(c_int, c_void_p, c_uint, POINTER(DASHGroupDownloadStatistics))
-def dash_download_monitor(cbk, groupidx, stats):
- obj = cast(cbk, py_object).value
- group = None
- for i in range(len(obj.groups)):
- if obj.groupsi.idx==groupidx:
- group = obj.groupsi
- break
-
- return obj.on_download_monitor(group, stats.contents)
-
-
-def _prop_to_python(pname, prop):
- type = prop.type
-
- if type==GF_PROP_SINT:
- return prop.value.sint
- if type==GF_PROP_UINT:
- if pname=="StreamType":
- return _libgpac.gf_stream_type_name(prop.value.uint).decode('utf-8')
- if pname=="PixelFormat":
- return _libgpac.gf_pixel_fmt_sname(prop.value.uint).decode('utf-8')
- if pname=="CodecID":
- cid = _libgpac.gf_codecid_file_ext(prop.value.uint).decode('utf-8')
- names=cid.split('|')
- return names0
- return prop.value.uint
-
- if _libgpac.gf_props_type_is_enum(type):
- pname = _libgpac.gf_props_enum_name(type, prop.value.uint)
- return pname.decode('utf-8')
-
- if type==GF_PROP_4CC:
- return _libgpac.gf_4cc_to_str(prop.value.uint).decode('utf-8')
- if type==GF_PROP_LSINT:
- return prop.value.longsint
- if type==GF_PROP_LUINT:
- return prop.value.longuint
- if type==GF_PROP_BOOL:
- return prop.value.boolean
- if type==GF_PROP_FRACTION:
- return prop.value.frac
- if type==GF_PROP_FRACTION64:
- return prop.value.lfrac
- if type==GF_PROP_FLOAT:
- return prop.value.fnumber
- if type==GF_PROP_DOUBLE:
- return prop.value.number
- if type==GF_PROP_VEC2I:
- return prop.value.vec2i
- if type==GF_PROP_VEC2:
- return prop.value.vec2
- if type==GF_PROP_VEC3I:
- return prop.value.vec3i
- if type==GF_PROP_VEC4I:
- return prop.value.vec4i
- if type==GF_PROP_STRING or type==GF_PROP_STRING_NO_COPY or type==GF_PROP_NAME:
- return prop.value.string.decode('utf-8')
- if type==GF_PROP_DATA or type==GF_PROP_DATA_NO_COPY or type==GF_PROP_CONST_DATA:
- return prop.value.data
- if type==GF_PROP_POINTER:
- return prop.value.ptr
- if type==GF_PROP_STRING_LIST:
- res = 
- for i in range(prop.value.string_list.nb_items):
- val = prop.value.string_list.valsi.decode('utf-8')
- res.append(val)
- return res
- if type==GF_PROP_UINT_LIST:
- res = 
- for i in range(prop.value.uint_list.nb_items):
- val = prop.value.uint_list.valsi
- res.append(val)
- return res
- if type==GF_PROP_4CC_LIST:
- res = 
- for i in range(prop.value.uint_list.nb_items):
- val = _libgpac.gf_4cc_to_str(prop.value.uint).decode('utf-8')
- res.append(val)
- return res
- if type==GF_PROP_SINT_LIST:
- res = 
- for i in range(prop.value.uint_list.nb_items):
- val = prop.value.sint_list.valsi
- res.append(val)
- return res
- if type==GF_PROP_VEC2I_LIST:
- res = 
- for i in range(prop.value.v2i_list.nb_items):
- val = prop.value.v2i_list.valsi
- res.append(val)
- return res
-
- raise Exception('Unknown property type ' + str(type))
-
-## \endcond
-
-
-## filter object
-class Filter:
- ## \cond private
- def __init__(self, session, filter):
- self._filter = filter
- self._session = session
- ## \endcond
- #hack for doxygen to generate member vars (not support for parsing @property)
- if 0:
- ##name of the filter, readonly - see \ref gf_filter_get_name
- #\hideinitializer
- self.name=0
- ##ID of the filter, readonly - see \ref gf_filter_get_id
- #\hideinitializer
- self.ID=0
- ##number of input pids for that filter, readonly - see \ref gf_filter_get_ipid_count
- #\hideinitializer
- self.nb_ipid=0
- ##number of output pids for that filter, readonly - see \ref gf_filter_get_opid_count
- #\hideinitializer
- self.nb_opid=0
-
-
- ## \cond private
- def __str__(self):
- return self.name
- ## \endcond
-
- ## remove this filter - see \ref gf_filter_remove
- #\return
- def remove(self):
- _libgpac.gf_filter_remove(self._filter)
-
- ## send option update to this filter - see \ref gf_fs_send_update
- #\param name name of option (string)
- #\param value value of option (string)
- #\return
- def update(self, name, value):
- _libgpac.gf_fs_send_update(None, None, self._filter, name, value, 0)
-
- ## set a given filter as source for this filter - see \ref gf_filter_set_source
- #
- #\note Setting a source will force the filter session linker to run in explicit linking mode.
- #\param f source Filter
- #\param link_args link options (string)
- #\return
- def set_source(self, f, link_args=None):
- if f:
- _libgpac.gf_filter_set_source(self._filter, f._filter, link_args)
-
- ## set a given filter as restricted source for this filter - see \ref gf_filter_set_source_restricted
- #\param f source Filter
- #\param link_args link options (string)
- #\return
- def set_source_restricted(self, f, link_args=None):
- if f:
- _libgpac.gf_filter_set_source_restricted(self._filter, f._filter, link_args)
-
-
- ## insert a given filter after this filter - see \ref gf_filter_set_source and \ref gf_filter_reconnect_output
- #\param f Filter to insert
- #\param link_args link options (string)
- #\return
- def insert(self, f, link_args=None):
- if f:
- _libgpac.gf_filter_set_source(f._filter, self._filter, link_args)
- _libgpac.gf_filter_reconnect_output(f._filter)
-
- ## \cond private
- def _pid_prop_ex(self, prop_name, pid, IsInfo):
- _name = prop_name.encode('utf-8')
- p4cc = _libgpac.gf_props_get_id(_name)
- if IsInfo:
- pe = POINTER(_gf_property_entry)()
- if p4cc:
- prop = _libgpac.gf_filter_pid_get_info(pid, p4cc, byref(pe))
- else:
- prop = _libgpac.gf_filter_pid_get_info_str(pid, _name, byref(pe))
- if prop:
- res = _prop_to_python(prop_name, prop.contents)
- _libgpac.gf_filter_release_property(pe)
- return res
- return None
-
- if p4cc:
- prop = _libgpac.gf_filter_pid_get_property(pid, p4cc)
- else:
- prop = _libgpac.gf_filter_pid_get_property_str(pid, _name)
- if prop:
- return _prop_to_python(prop_name, prop.contents)
- return None
-
- def _pid_prop(self, idx, prop_name, IsInput):
- if IsInput:
- pid = _libgpac.gf_filter_get_ipid(self._filter, idx)
- else:
- pid = _libgpac.gf_filter_get_opid(self._filter, idx)
- if not pid:
- raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
- return self._pid_prop_ex(self, prop_name, pid, False)
-
- def _pid_enum_props_ex(self, callback_obj, _pid):
- if hasattr(callback_obj, 'on_prop_enum')==False:
- raise Exception('No on_prop_enum function on callback')
-
- pidx=c_uint(0)
- while True:
- _p4cc=c_uint(0)
- _pname=c_char_p(0)
- prop = _libgpac.gf_filter_pid_enum_properties(_pid, byref(pidx), byref(_p4cc), byref(_pname))
- if prop:
- p4cc=_p4cc.value
- pname=None
- if _pname:
- pname=_pname.value.decode('utf-8')
- else:
- pname=_libgpac.gf_props_4cc_get_name(p4cc).decode('utf-8')
- pval = _prop_to_python(pname, prop.contents)
- callback_obj.on_prop_enum(pname, pval)
- else:
- break
-
- def _pid_enum_props(self, idx, callback_obj, IsInput):
- if IsInput:
- pid = _libgpac.gf_filter_get_ipid(self._filter, idx)
- else:
- pid = _libgpac.gf_filter_get_opid(self._filter, idx)
-
- if not pid:
- raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
-
- self._pid_enum_props_ex(callback_obj, pid)
-
- ## \endcond 
-
- ##get an input pid property by name
- #\param idx index of input pid
- #\param prop_name name of property
- #\return property value or None if not found
- def ipid_prop(self, idx, prop_name):
- return self._pid_prop(idx, prop_name, True)
- ##enumerate an input pid properties
- #\param idx index of input pid
- #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval(property value)
- #\return
- def ipid_enum_props(self, idx, callback_obj):
- self._pid_enum_props(idx, callback_obj, True)
- ##get an output pid property by name
- #\param idx index of output pid
- #\param prop_name name of property
- #\return property value or None if not found
- def opid_prop(self, idx, prop_name):
- return self._pid_prop(idx, prop_name, False)
- ##enumerate an output pid properties
- #\param idx index of output pid
- #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval(property value)
- #\return
- def opid_enum_props(self, idx, callback_obj):
- self._pid_enum_props(idx, callback_obj, False)
-
- ##gets the filter at the source of an input pid
- #\param idx index of input PID
- #\return Filter or None if error
- def ipid_source(self, idx):
- pid = _libgpac.gf_filter_get_ipid(self._filter, idx)
- if not pid:
- raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
- f = _libgpac.gf_filter_pid_get_source_filter(pid)
- if not f:
- return None
- return self._session._to_filter(f)
-
- ##gets the list of destination filters of an output pid
- #\param idx index of output PID
- #\return list of Filter
- def opid_sinks(self, idx):
- pid = _libgpac.gf_filter_get_opid(self._filter, idx)
- if not pid:
- raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
- res=
- f_idx=0
- while True:
- f = _libgpac.gf_filter_pid_enum_destinations(pid, f_idx)
- f_idx+=1 
- if f==None:
- break
- filter = self._session._to_filter(f)
- res.append(filter)
- return res
-
- ##gets all defined options / arguments for a filter
- #\return list of FilterArg
- def all_args(self):
- res=
- a_idx=0
- while True:
- arg = _libgpac.gf_filter_enumerate_args(self._filter, a_idx)
- if arg:
- arg_val = arg.contents
- res.append(arg_val)
- else:
- break
- a_idx+=1
- return res
-
- ##gets a property info on a filter - see \ref gf_filter_get_info and \ref gf_filter_get_info_str
- #\param prop_name property to query
- #\return property value or None if not found
- def get_info(self, prop_name):
- _name = prop_name.encode('utf-8')
- p4cc = _libgpac.gf_props_get_id(_name)
- pe = POINTER(_gf_property_entry)()
- if p4cc:
- prop = _libgpac.gf_filter_get_info(self._filter, p4cc, byref(pe))
- else:
- prop = _libgpac.gf_filter_get_info_str(self._filter, _name, byref(pe))
- if prop:
- res = _prop_to_python(prop_name, prop.contents)
- _libgpac.gf_filter_release_property(pe)
- return res
- return None
-
- ##Gets the statistics of a filter - see \ref gf_filter_get_stats
- #\return FilterStats object
- def get_statistics(self):
- stats = FilterStats()
- err = _libgpac.gf_filter_get_stats(self._filter, byref(stats))
- if err<0: 
- raise Exception('Failed to fetch filter stats: ' + e2s(err))
- return stats
-
- ##enforces sourceID to be present for output pids of this filter - see \ref gf_filter_require_source_id
- #\return
- def require_source_id(self):
- err = _libgpac.gf_filter_require_source_id(self._filter)
- if err<0:
- raise Exception('Failed to require sourceID for filter: ' + e2s(err))
- return
-
- ##\cond private
- def _bind_dash_algo(self, object):
- if not hasattr(object, 'on_rate_adaptation'):
- raise Exception('Missing on_rate_adaptation member function on object, cannot bind')
- object.groups = 
- if hasattr(object, 'on_download_monitor'):
- err = _libgpac.gf_filter_bind_dash_algo_callbacks(self._filter, py_object(object), dash_period_reset, dash_group_new, dash_rate_adaptation, dash_download_monitor)
- else:
- err = _libgpac.gf_filter_bind_dash_algo_callbacks(self._filter, py_object(object), dash_period_reset, dash_group_new, dash_rate_adaptation, None)
- if err<0: 
- raise Exception('Failed to bind dash algo: ' + e2s(err))
- return 0
- ##\endcond private
-
-
- ## \brief binds a given object to the filter
- #
- #Binds the given object to the underlying filter for callbacks override - only supported by DASH demuxer for the current time
- #
- #For DASH, the object must derive from or implement the methods of the \ref DASHCustomAlgorithm class:
- #
- #\param object object to bind
- #\return
- def bind(self, object):
- if self.name=="dashin":
- return self._bind_dash_algo(object)
- raise Exception('No possible binding to filter class ' + self.name)
-
- ##\cond private: until end, properties
-
- @property
- def name(self):
- return _libgpac.gf_filter_get_name(self._filter).decode('utf-8')
-
- @property
- def ID(self):
- return _libgpac.gf_filter_get_id(self._filter).decode('utf-8')
-
- @property
- def nb_ipid(self):
- return _libgpac.gf_filter_get_ipid_count(self._filter)
-
- @property
- def nb_opid(self):
- return _libgpac.gf_filter_get_opid_count(self._filter)
-
- ##\endcond 
-
-
-
-##\cond private
-
-#
-# custom filter bindings
-#
-
-_libgpac.gf_filter_push_caps.argtypes = _gf_filter, c_uint, POINTER(PropertyValue), c_char_p, c_uint, c_uint
-_libgpac.gf_props_4cc_get_type.argtypes = c_uint
-_libgpac.gf_stream_type_by_name.argtypes = c_char_p
-_libgpac.gf_stream_type_by_name.restype = c_uint
-
-_libgpac.gf_codecid_parse.argtypes = c_char_p
-_libgpac.gf_codecid_parse.restype = c_uint
-
-_libgpac.gf_pixel_fmt_parse.argtypes = c_char_p
-_libgpac.gf_pixel_fmt_parse.restype = c_uint
-
-_libgpac.gf_audio_fmt_parse.argtypes = c_char_p
-_libgpac.gf_audio_fmt_parse.restype = c_uint
-
-_libgpac.gf_cicp_color_primaries_name.argtypes = c_uint
-_libgpac.gf_cicp_color_primaries_name.restype = c_char_p
-_libgpac.gf_cicp_color_transfer_name.argtypes = c_uint
-_libgpac.gf_cicp_color_transfer_name.restype = c_char_p
-_libgpac.gf_cicp_color_matrix_name.argtypes = c_uint
-_libgpac.gf_cicp_color_matrix_name.restype = c_char_p
-
-_libgpac.gf_cicp_parse_color_primaries.argtypes = c_char_p
-_libgpac.gf_cicp_parse_color_primaries.restype = c_uint
-_libgpac.gf_cicp_parse_color_transfer.argtypes = c_char_p
-_libgpac.gf_cicp_parse_color_transfer.restype = c_uint
-_libgpac.gf_cicp_parse_color_matrix.argtypes = c_char_p
-_libgpac.gf_cicp_parse_color_matrix.restype = c_uint
-
-
-
-def _make_prop(prop4cc, propname, prop, custom_type=0):
- prop_val = PropertyValue()
- if prop4cc==0:
- if not custom_type:
- prop_val.type = GF_PROP_STRING
- prop_val.value.string = str(prop).encode('utf-8')
- return prop_val
- type = custom_type
- else:
- type = _libgpac.gf_props_4cc_get_type(prop4cc)
-
- prop_val.type = type
- if propname=="StreamType":
- prop_val.value.uint = _libgpac.gf_stream_type_by_name(prop.encode('utf-8'))
- return prop_val
- elif propname=="CodecID":
- prop_val.value.uint = _libgpac.gf_codecid_parse(prop.encode('utf-8'))
- return prop_val
-
- if type==GF_PROP_SINT:
- prop_val.value.sint = prop
- elif type==GF_PROP_UINT:
- prop_val.value.uint = prop
- elif type==GF_PROP_4CC:
- prop_val.value.uint = _libgpac.gf_4cc_parse(prop.encode('utf-8'))
- elif type==GF_PROP_LSINT:
- prop_val.value.longsint = prop
- elif type==GF_PROP_LUINT:
- prop_val.value.longuint = prop
- elif type==GF_PROP_BOOL:
- prop_val.value.boolean = prop
- elif type==GF_PROP_FRACTION:
- if hasattr(prop, 'den') and hasattr(prop, 'num'):
- prop_val.value.frac.num = prop.num
- prop_val.value.frac.den = prop.den
- elif is_integer(prop):
- prop_val.value.frac.num = prop
- prop_val.value.frac.den = 1
- else:
- prop_val.value.frac.num = 1000*prop
- prop_val.value.frac.den = 1000
- elif type==GF_PROP_FRACTION64:
- if hasattr(prop, 'den') and hasattr(prop, 'num'):
- prop_val.value.lfrac.num = prop.num
- prop_val.value.lfrac.den = prop.den
- elif is_integer(prop):
- prop_val.value.lfrac.num = prop
- prop_val.value.lfrac.den = 1
- else:
- prop_val.value.lfrac.num = 1000000*prop
- prop_val.value.lfrac.den = 1000000
- elif type==GF_PROP_FLOAT:
- prop_val.value.fnumber = prop
- elif type==GF_PROP_DOUBLE:
- prop_val.value.number = prop
- elif type==GF_PROP_VEC2I:
- if hasattr(prop, 'x') and hasattr(prop, 'y'):
- prop_val.value.vec2i.x = prop.x
- prop_val.value.vec2i.y = prop.y
- else:
- raise Exception('Invalid property value for vec2i: ' + str(prop))
- elif type==GF_PROP_VEC2:
- if hasattr(prop, 'x') and hasattr(prop, 'y'):
- prop_val.value.vec2.x = prop.x
- prop_val.value.vec2.y = prop.y
- else:
- raise Exception('Invalid property value for vec2: ' + str(prop))
- elif type==GF_PROP_VEC3I:
- if hasattr(prop, 'x') and hasattr(prop, 'y') and hasattr(prop, 'z'):
- prop_val.value.vec3i.x = prop.x
- prop_val.value.vec3i.y = prop.y
- prop_val.value.vec3i.z = prop.z
- else:
- raise Exception('Invalid property value for vec3i: ' + str(prop))
- elif type==GF_PROP_VEC4I:
- if hasattr(prop, 'x') and hasattr(prop, 'y') and hasattr(prop, 'z') and hasattr(prop, 'w'):
- prop_val.value.vec4i.x = prop.x
- prop_val.value.vec4i.y = prop.y
- prop_val.value.vec4i.z = prop.z
- prop_val.value.vec4i.w = prop.w
- else:
- raise Exception('Invalid property value for vec4i: ' + str(prop))
- elif type==GF_PROP_STRING or type==GF_PROP_STRING_NO_COPY or type==GF_PROP_NAME:
- prop_val.value.string = str(prop).encode('utf-8')
- elif type==GF_PROP_DATA or type==GF_PROP_DATA_NO_COPY or type==GF_PROP_CONST_DATA:
- raise Exception('Setting data property from python not yet implemented !')
- elif type==GF_PROP_POINTER:
- raise Exception('Setting pointer property from python not yet implemented !')
- elif type==GF_PROP_STRING_LIST:
- if isinstance(prop, list)==False:
- raise Exception('Property is not a list')
- prop_val.value.string_list.nb_items = len(prop)
- prop_val.value.string_list.vals = (ctypes.c_char_p * len(prop))
- i=0
- for str in list:
- prop_val.value.string_list.valsi = str.encode('utf-8')
- i+=1
- elif type==GF_PROP_UINT_LIST:
- if isinstance(prop, list)==False:
- raise Exception('Property is not a list')
- prop_val.value.uint_list.nb_items = len(prop)
- prop_val.value.uint_list.vals = (ctypes.c_uint * len(prop))(*prop)
- elif type==GF_PROP_4CC_LIST:
- if isinstance(prop, list)==False:
- raise Exception('Property is not a list')
- prop_val.value.uint_list.nb_items = len(prop)
- prop_val.value.uint_list.vals = (ctypes.c_uint * len(prop))
- i=0
- for str in list:
- prop_val.value.uint_list.valsi = _libgpac.gf_4cc_parse( str.encode('utf-8') )
- i+=1
- elif type==GF_PROP_SINT_LIST:
- if isinstance(prop, list)==False:
- raise Exception('Property is not a list')
- prop_val.value.sint_list.nb_items = len(prop)
- prop_val.value.sint_list.vals = (ctypes.c_int * len(prop))(*prop)
- elif type==GF_PROP_VEC2I_LIST:
- if isinstance(prop, list)==False:
- raise Exception('Property is not a list')
- prop_val.value.sint_list.nb_items = len(prop)
- prop_val.value.v2i_list.vals = (GF_PropVec2i * len(prop))
- for i in range (len(prop)):
- prop_val.value.v2i_list.valsi.x = propi.x
- prop_val.value.v2i_list.valsi.y = propi.y
-
- elif _libgpac.gf_props_type_is_enum(type):
- prop_val.value.uint = _libgpac.gf_props_parse_enum(type, prop.encode('utf-8'))
- return prop_val
- else:
- raise Exception('Unsupported property type ' + str(type) )
-
- return prop_val
-
-
-_libgpac.gf_filter_set_rt_udta.argtypes = _gf_filter, py_object
-_libgpac.gf_filter_get_rt_udta.argtypes = _gf_filter
-_libgpac.gf_filter_get_rt_udta.restype = c_void_p
-
-_libgpac.gf_filter_pid_set_udta.argtypes = _gf_filter, py_object
-_libgpac.gf_filter_pid_get_udta.argtypes = _gf_filter
-_libgpac.gf_filter_pid_get_udta.restype = c_void_p
-
-_libgpac.gf_filter_pid_send_event.argtypes = _gf_filter_pid, POINTER(FilterEvent)
-
-
-_libgpac.gf_filter_set_configure_ckb.argtypes = _gf_filter, c_void_p
-@CFUNCTYPE(c_int, _gf_filter, _gf_filter_pid, gf_bool)
-def filter_cbk_configure(_f, _pid, is_remove):
- obj = _libgpac.gf_filter_get_rt_udta(_f)
- filter = cast(obj, py_object).value
- obj = _libgpac.gf_filter_pid_get_udta(_pid)
- if obj:
- pid_obj = cast(obj, py_object).value
- else:
- pid_obj=None
-
- first=True
- if pid_obj:
- first=False
- else:
- pid_obj = FilterPid(filter, _pid, True)
- _libgpac.gf_filter_pid_set_udta(_pid, py_object(pid_obj))
- res = filter.configure_pid(pid_obj, is_remove)
-
- if is_remove:
- _libgpac.gf_filter_pid_set_udta(_pid, None)
- filter.ipids.remove(pid_obj)
- return
-
- if first:
- filter.ipids.append(pid_obj)
-
- return res
-
-
-_libgpac.gf_filter_set_process_ckb.argtypes = _gf_filter, c_void_p
-@CFUNCTYPE(c_int, _gf_filter)
-def filter_cbk_process(_f):
- obj = _libgpac.gf_filter_get_rt_udta(_f)
- filter = cast(obj, py_object).value
- return filter.process()
-
-_libgpac.gf_filter_set_process_event_ckb.argtypes = _gf_filter, c_void_p
-@CFUNCTYPE(c_int, _gf_filter, POINTER(FilterEvent) )
-def filter_cbk_process_event(_f, _evt):
- obj = _libgpac.gf_filter_get_rt_udta(_f)
- filter = cast(obj, py_object).value
- res = filter.process_event(_evt.contents)
- if res:
- return 1
- return 0
-
-_libgpac.gf_filter_set_probe_data_cbk.argtypes = _gf_filter, c_void_p
-@CFUNCTYPE(c_int, POINTER(c_ubyte), c_uint, POINTER(c_uint) )
-def filter_cbk_probe_data(_data, _size, _probe):
- obj = _libgpac.gf_filter_get_rt_udta(_f)
- filter = cast(obj, py_object).value
- if numpy_support:
- ar_data = np.ctypeslib.as_array(_data, (_size,))
- ar_data.flags.writeable=False
- res = filter.probe_data(ar_data, _size)
- else:
- res = filter.probe_data(_data, _size)
- if res==None:
- _probe.contents=0
- return None
- _probe.contents=2 #GF_FPROBE_MAYBE_SUPPORTED
- return res.encode('utf-8')
-
-
-_libgpac.gf_filter_set_reconfigure_output_ckb.argtypes = _gf_filter, c_void_p
-@CFUNCTYPE(c_int, _gf_filter, _gf_filter_pid )
-def filter_cbk_reconfigure_output(_f, _pid):
- obj = _libgpac.gf_filter_get_rt_udta(_f)
- filter = cast(obj, py_object).value
- obj = _libgpac.gf_filter_pid_get_udta(_pid)
- if obj:
- pid_obj = cast(obj, py_object).value
- else:
- pid_obj=None
- if pid_obj:
- return filter.reconfigure_output(_f)
- raise Exception('Reconfigure on unknown output pid !')
-
-
-_libgpac.gf_filter_pid_get_packet.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_packet.restype = _gf_filter_packet
-
-_libgpac.gf_filter_pid_drop_packet.argtypes = _gf_filter_pid
-
-_libgpac.gf_filter_pid_new.argtypes = _gf_filter
-_libgpac.gf_filter_pid_new.restype = _gf_filter_pid
-
-_libgpac.gf_filter_update_status.argtypes = _gf_filter, c_uint, c_char_p
-
-_libgpac.gf_filter_ask_rt_reschedule.argtypes = _gf_filter
-_libgpac.gf_filter_post_process_task.argtypes = _gf_filter
-
-
-_libgpac.gf_filter_ask_rt_reschedule.argtypes = _gf_filter, c_int, gf_bool
-_libgpac.gf_filter_setup_failure.argtypes = _gf_filter, c_int
-_libgpac.gf_filter_make_sticky.argtypes = _gf_filter
-_libgpac.gf_filter_prevent_blocking.argtypes = _gf_filter, gf_bool
-_libgpac.gf_filter_block_eos.argtypes = _gf_filter, gf_bool
-_libgpac.gf_filter_set_max_extra_input_pids.argtypes = _gf_filter, c_uint
-_libgpac.gf_filter_block_enabled.argtypes = _gf_filter
-_libgpac.gf_filter_block_enabled.restype = gf_bool
-_libgpac.gf_filter_get_output_buffer_max.argtypes = _gf_filter, POINTER(c_uint), POINTER(c_uint)
-_libgpac.gf_filter_all_sinks_done.argtypes = _gf_filter
-_libgpac.gf_filter_all_sinks_done.restype = gf_bool
-_libgpac.gf_filter_get_num_events_queued.argtypes = _gf_filter
-
-_libgpac.gf_filter_get_clock_hint.argtypes = _gf_filter, POINTER(c_ulonglong), POINTER(Fraction64)
-_libgpac.gf_filter_connections_pending.argtypes = _gf_filter
-_libgpac.gf_filter_connections_pending.restype = gf_bool
-_libgpac.gf_filter_hint_single_clock.argtypes = _gf_filter, c_ulonglong, Fraction64
-
-GF_FS_REG_MAIN_THREAD=1<<1
-
-##\endcond
-
-## Base class used to create custom filters in python
-class FilterCustom(Filter):
-
- ##constructor, see \ref gf_fs_new_filter
- #\param session FilterSession object
- #\param fname name of the filter
- #\param flags flags for the filter
- def __init__(self, session, fname="Custom", flags=0):
- errp = c_int(0)
- _filter = _libgpac.gf_fs_new_filter(session._sess, fname.encode('utf-8'), flags | GF_FS_REG_MAIN_THREAD, byref(errp))
- err = errp.value
- if err<0: 
- raise Exception('Failed to create filter ' + URL + ': ' + e2s(err))
- #create base class
- Filter.__init__(self, session, _filter)
- #register with our filter bank
- session._filters.append(self)
-
- #setup callback udta and callback functions
- _libgpac.gf_filter_set_rt_udta(_filter, py_object(self) )
- if hasattr(self, 'configure_pid'):
- _libgpac.gf_filter_set_configure_ckb(self._filter, filter_cbk_configure)
-
- if hasattr(self, 'process'):
- _libgpac.gf_filter_set_process_ckb(self._filter, filter_cbk_process)
-
- if hasattr(self, 'process_event'):
- _libgpac.gf_filter_set_process_event_ckb(self._filter, filter_cbk_process_event)
-
- if hasattr(self, 'probe_data'):
- _libgpac.gf_filter_set_probe_data_ckb(self._filter, filter_cbk_probe_data)
-
- if hasattr(self, 'reconfigure_output'):
- _libgpac.gf_filter_set_reconfigure_output_ckb(self._filter, filter_cbk_reconfigure_output)
-
- ##List of input FilterPid
- self.ipids=
- ##List of output FilterPid
- self.opids=
-
- #hack for doxygen to generate member vars (not support for parsing @property)
- if 0:
- ##filter blocking is enabled, readonly - see \ref gf_filter_block_enabled
- #\hideinitializer
- self.block_enabled=0
- ##maximum output buffer time, readonly - see \ref gf_filter_get_output_buffer_max
- #\hideinitializer
- self.output_buffer=0
- ##maximum plyaout buffer time, readonly - see \ref gf_filter_get_output_buffer_max
- #\hideinitializer
- self.playout_buffer=0
- ##all sinks are done for this filter, readonly - see \ref gf_filter_all_sinks_done
- #\hideinitializer
- self.sinks_done=0
- ##number of queued events on the filter, readonly - see \ref gf_filter_get_num_events_queued
- #\hideinitializer
- self.nb_evts_queued=0
- ##clock hint value in microseconds, readonly - see \ref gf_filter_get_clock_hint
- #\hideinitializer
- self.clock_hint_time=0
- ##clock hint media time as Fraction64, readonly - see \ref gf_filter_get_clock_hint
- #\hideinitializer
- self.clock_hint_mediatime=0
- ##boolean indicating connections are pending on the filter, readonly - see \ref gf_filter_connections_pending
- #\hideinitializer
- self.connections_pending=0
-
-
-
- ##push a capability in the current capability bundle - see \ref gf_filter_push_caps
- #\param pcode capability name (property type)
- #\param prop capability value
- #\param flag capability flags (input, output, etc)
- #\param priority capability priority
- #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
- #\return
- def push_cap(self, pcode, prop, flag, priority=0, custom_type=0):
- prop_4cc = pcode
- prop_name = None
- if isinstance(pcode, str):
- _pname = pcode.encode('utf-8')
- prop_4cc = _libgpac.gf_props_get_id(_pname)
- if prop_4cc==0:
- prop_name = _pname
-
- prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
- err = _libgpac.gf_filter_push_caps(self._filter, prop_4cc, byref(prop_val), prop_name, flag, priority)
- if err<0: 
- raise Exception('Failed to push cap: ' + e2s(err))
-
- ##create a new output pid for this filter - see \ref gf_filter_pid_new
- #\return FilterPid object
- def new_pid(self):
- _pid = _libgpac.gf_filter_pid_new(self._filter)
- if _pid:
- pid_obj = FilterPid(self, _pid, False)
- _libgpac.gf_filter_pid_set_udta(_pid, py_object(pid_obj))
- self.opids.append(pid_obj)
- pid_obj.pck_refs = 
- return pid_obj
- raise Exception('Failed to create output pid')
-
- ##update filter status - see \ref gf_filter_update_status
- #\param status status string
- #\param percent progress in per 10000, int
- #\return
- def update_status(self, status, percent):
- _libgpac.gf_filter_update_status(self._filter, percent, status.encode('utf-8'))
-
- ##reschedule the filter after a given delay - see \ref gf_filter_ask_rt_reschedule and \ref gf_filter_post_process_task
- #\param when delay in microseconds
- #\return
- def reschedule(self, when=0):
- if when:
- _libgpac.gf_filter_ask_rt_reschedule(self._filter, when)
- else:
- _libgpac.gf_filter_post_process_task(self._filter)
-
- ##notify an internal failure of the filter has happend - see \ref gf_filter_notification_failure and \ref gf_filter_setup_failure
- #\param err the failure reason (gpac error code, int)
- #\param error_type the failure notification type
- #\return
- def notify_failure(self, err, error_type=GF_SETUP_ERROR):
- if error_type==GF_NOTIF_ERROR:
- _libgpac.gf_filter_notification_failure(self._filter, err, False)
- elif error_type==GF_NOTIF_ERROR_AND_DISCONNECT:
- _libgpac.gf_filter_notification_failure(self._filter, err, True)
- else:
- _libgpac.gf_filter_setup_failure(self._filter, err)
-
- ##make the filter sticky - see \ref gf_filter_make_sticky
- #\return
- def make_sticky(self):
- _libgpac.gf_filter_make_sticky(self._filter)
-
- ##prevent blocking on the filter - see \ref gf_filter_prevent_blocking
- #\param enable if True, blocking prevention is enabled
- #\return
- def prevent_blocking(self, enable):
- _libgpac.gf_filter_prevent_blocking(self._filter, enable)
-
- ##block eos signaling on the filter - see \ref gf_filter_block_eos
- #\param enable if True, eos blocking is enabled
- #\return
- def block_eos(self, enable):
- _libgpac.gf_filter_block_eos(self._filter, enable)
-
- ##set maximum number of extra pids accepted by this filter - see \ref gf_filter_set_max_extra_input_pids
- #\param max_pids number of extra pids
- #\return
- def set_max_pids(self, max_pids):
- _libgpac.gf_filter_set_max_extra_input_pids(self._filter, max_pids)
-
- ##set clock hint - see \ref gf_filter_hint_single_clock
- #\param clock_us clock in microseconds
- #\param media_time media time as Fraction64
- #\return
- def hint_clock(self, clock_us, media_time):
- _libgpac.gf_filter_hint_single_clock(self._filter, clock_us, media_time)
-
-
- ##\cond private: until end, properties
-
- @property
- def block_enabled(self):
- return _libgpac.gf_filter_block_enabled(self._filter)
-
- @property
- def output_buffer(self):
- val = c_uint(0)
- _libgpac.gf_filter_get_output_buffer_max(self._filter, byref(val), None)
- return val.value
-
- @property
- def playout_buffer(self):
- val = c_uint(0)
- _libgpac.gf_filter_get_output_buffer_max(self._filter, None, byref(val))
- return val.value
-
- @property
- def sinks_done(self):
- return _libgpac.gf_filter_all_sinks_done(self._filter)
-
- @property
- def nb_evts_queued(self):
- return _libgpac.gf_filter_get_num_events_queued(self._filter)
-
- @property 
- def clock_hint_time(self):
- val = c_ulonglong(0)
- _libgpac.gf_filter_get_clock_hint(self._filter, byref(val), None)
- return val.value
-
- @property 
- def clock_hint_mediatime(self):
- val = Fraction64
- _libgpac.gf_filter_get_clock_hint(self._filter, None, byref(val))
- return val.value
-
- @property 
- def connections_pending(self):
- return _libgpac.gf_filter_connections_pending(self._filter)
-
- ##\endcond
-
- #todo
- #add_source, add_destination, add_filter: not needed, acces to filter session
-
-
-
-#
-# filter PID bindings
-#
-
-## \cond private
-_libgpac.gf_filter_pid_copy_properties.argtypes = _gf_filter_pid, _gf_filter_pid
-_libgpac.gf_filter_pck_forward.argtypes = _gf_filter_packet, _gf_filter_pid
-
-_libgpac.gf_filter_pid_set_property.argtypes = _gf_filter_pid, c_uint, POINTER(PropertyValue)
-_libgpac.gf_filter_pid_set_property_str.argtypes = _gf_filter_pid, c_char_p, POINTER(PropertyValue)
-_libgpac.gf_filter_pid_set_info.argtypes = _gf_filter_pid, c_uint, POINTER(PropertyValue)
-_libgpac.gf_filter_pid_set_info_str.argtypes = _gf_filter_pid, c_char_p, POINTER(PropertyValue)
-_libgpac.gf_filter_pid_clear_eos.argtypes = _gf_filter_pid, gf_bool
-_libgpac.gf_filter_pid_check_caps.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_check_caps.restype = gf_bool
-_libgpac.gf_filter_pid_discard_block.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_allow_direct_dispatch.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_reset_properties.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_clock_info.argtypes = _gf_filter_pid, POINTER(c_longlong), POINTER(c_uint)
-_libgpac.gf_filter_pid_remove.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_is_filter_in_parents.argtypes = _gf_filter_pid, _gf_filter
-_libgpac.gf_filter_pid_is_filter_in_parents.restype = gf_bool
-
-_libgpac.gf_filter_pid_get_name.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_name.restype = c_char_p
-_libgpac.gf_filter_pid_set_name.argtypes = _gf_filter_pid, c_char_p
-
-_libgpac.gf_filter_pid_is_eos.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_is_eos.restype = gf_bool
-_libgpac.gf_filter_pid_set_eos.argtypes = _gf_filter_pid
-
-_libgpac.gf_filter_pid_has_seen_eos.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_has_seen_eos.restype = gf_bool
-
-_libgpac.gf_filter_pid_eos_received.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_eos_received.restype = gf_bool
-
-_libgpac.gf_filter_pid_would_block.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_would_block.restype = gf_bool
-_libgpac.gf_filter_pid_set_loose_connect.argtypes = _gf_filter_pid
-
-_libgpac.gf_filter_pid_set_framing_mode.argtypes = _gf_filter_pid, gf_bool
-
-_libgpac.gf_filter_pid_get_max_buffer.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_max_buffer.restype = c_uint
-_libgpac.gf_filter_pid_set_max_buffer.argtypes = _gf_filter_pid, c_uint
-
-_libgpac.gf_filter_pid_query_buffer_duration.argtypes = _gf_filter_pid, gf_bool
-_libgpac.gf_filter_pid_query_buffer_duration.restype = c_ulonglong
-
-_libgpac.gf_filter_pid_first_packet_is_empty.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_first_packet_is_empty.restype = gf_bool
-
-_libgpac.gf_filter_pid_get_first_packet_cts.argtypes = _gf_filter_pid, POINTER(c_ulonglong)
-_libgpac.gf_filter_pid_get_first_packet_cts.restype = gf_bool
-
-_libgpac.gf_filter_pid_get_packet_count.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_timescale.argtypes = _gf_filter_pid
-
-_libgpac.gf_filter_pid_set_clock_mode.argtypes = _gf_filter_pid, gf_bool
-_libgpac.gf_filter_pid_set_discard.argtypes = _gf_filter_pid, gf_bool
-
-_libgpac.gf_filter_pid_require_source_id.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_recompute_dts.argtypes = _gf_filter_pid, gf_bool
-
-
-_libgpac.gf_filter_pid_get_min_pck_duration.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_is_playing.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_is_playing.restype = gf_bool
-
-_libgpac.gf_filter_pid_get_filter_name.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_filter_name.restype = c_char_p
-
-_libgpac.gf_filter_pid_get_next_ts.argtypes = _gf_filter_pid
-_libgpac.gf_filter_pid_get_next_ts.restype = c_longlong
-
-
-_libgpac.gf_filter_pid_caps_query.argtypes = _gf_filter_pid, c_uint
-_libgpac.gf_filter_pid_caps_query.restype = POINTER(PropertyValue)
-_libgpac.gf_filter_pid_caps_query_str.argtypes = _gf_filter_pid, c_char_p
-_libgpac.gf_filter_pid_caps_query_str.restype = POINTER(PropertyValue)
-
-_libgpac.gf_filter_pid_negociate_property.argtypes = _gf_filter_pid, c_uint, POINTER(PropertyValue)
-_libgpac.gf_filter_pid_negociate_property_dyn.argtypes = _gf_filter_pid, c_char_p, POINTER(PropertyValue)
-
-_libgpac.gf_filter_pck_new_ref.argtypes = _gf_filter_pid, c_uint, c_uint, _gf_filter_packet
-_libgpac.gf_filter_pck_new_ref.restype = _gf_filter_packet
-
-_libgpac.gf_filter_pck_new_alloc.argtypes = _gf_filter_pid, c_uint, POINTER(c_void_p)
-_libgpac.gf_filter_pck_new_alloc.restype = _gf_filter_packet
-
-_libgpac.gf_filter_pck_new_clone.argtypes = _gf_filter_pid, _gf_filter_packet, POINTER(c_void_p)
-_libgpac.gf_filter_pck_new_clone.restype = _gf_filter_packet
-_libgpac.gf_filter_pck_new_copy.argtypes = _gf_filter_pid, _gf_filter_packet, POINTER(c_void_p)
-_libgpac.gf_filter_pck_new_copy.restype = _gf_filter_packet
-
-## \endcond private
-
-
-## \cond private
-
-#callback for packet destruction
-
-_libgpac.gf_filter_pck_new_shared.argtypes = _gf_filter_pid, POINTER(c_ubyte), c_uint, c_void_p
-_libgpac.gf_filter_pck_new_shared.restype = _gf_filter_packet
-
-@CFUNCTYPE(c_int, _gf_filter, _gf_filter_pid, _gf_filter_packet)
-def filter_cbk_release_packet(_f, _pid, _pck):
- obj = _libgpac.gf_filter_get_rt_udta(_f)
- filter = cast(obj, py_object).value
- pck_obj=None
- obj = _libgpac.gf_filter_pid_get_udta(_pid)
- if obj:
- pid_obj = cast(obj, py_object).value
- else:
- raise Exception('Unknwon PID on packet destruction callback')
-
- for pck in pid_obj.pck_refs:
- if pck._pck==_pck:
- pck_obj = pck
- break
-
- if not pck_obj:
- raise Exception('Unknwon packet on packet destruction callback')
- pid_obj.pck_refs.remove(pck_obj)
- filter.packet_release(pid_obj, pck_obj)
- return 0
-
-## \endcond private
-
-## Object representing a PID of a custom filter
-class FilterPid:
- ## \cond private
- def __init__(self, filter, pid, IsInput):
- self._filter = filter
- self._pid = pid
- self._cur_pck = None
- self._input = IsInput
- ## \endcond
- #hack for doxygen to generate member vars (not support for parsing @property)
- if 0:
- ##name of the PID - see \ref gf_filter_pid_get_name and \ref gf_filter_pid_set_name
- #\hideinitializer
- self.name=0
- ##name of the parent filter, readonly - see \ref gf_filter_pid_get_filter_name
- #\hideinitializer
- self.filter_name=0
- ##end of stream property of PID - see \ref gf_filter_pid_is_eos and \ref gf_filter_pid_set_eos
- #\hideinitializer
- self.eos=0
- ##True if end of stream was seen in the chain but has not yet reached the filter, readonly - see \ref gf_filter_pid_has_seen_eos
- #\hideinitializer
- self.has_seen_eos=0
- ##True if end of stream was seen on the input PID but some packets are still to be processed, readonly - see \ref gf_filter_pid_eos_received
- #\hideinitializer
- self.eos_received=0
- ##True if PID would block, readonly - see \ref gf_filter_pid_would_block
- #\hideinitializer
- self.would_block=0
- ##maximum buffer of PID in microseconds - see \ref gf_filter_pid_get_max_buffer and \ref gf_filter_pid_set_max_buffer
- #\hideinitializer
- self.max_buffer=0
- ##buffer of PID in microseconds, readonly - see \ref gf_filter_pid_query_buffer_duration
- #\hideinitializer
- self.buffer=0
- ##True if buffer is full, readonly - see \ref gf_filter_pid_query_buffer_duration
- #\hideinitializer
- self.buffer_full=0
- ##True if no pending packet, readonly - see \ref gf_filter_pid_first_packet_is_empty
- #\hideinitializer
- self.first_empty=0
- ##value of CTS of first pending packet, None if none, readonly - see \ref gf_filter_pid_get_first_packet_cts
- #\hideinitializer
- self.first_cts=0
- ##number of queued packets for input pid, readonly - see \ref gf_filter_pid_get_packet_count
- #\hideinitializer
- self.nb_pck_queued=0
- ##timescale of pid, readonly - see \ref gf_filter_pid_get_timescale
- #\hideinitializer
- self.timescale=0
- ##minimum packet duration (in timescale) of pid, readonly - see \ref gf_filter_pid_get_min_pck_duration
- #\hideinitializer
- self.min_pck_dur=0
- ##True if PID is playing, readonly - see \ref gf_filter_pid_is_playing
- #\hideinitializer
- self.playing=0
- ##Next estimated timestamp on pid, readonly - see \ref gf_filter_pid_get_next_ts
- #\hideinitializer
- self.next_ts=0
-
-
- ##send an event on the pid - see \ref gf_filter_pid_send_event
- #\param evt FilterEvent to send
- #\return
- def send_event(self, evt):
- evt.base.on_pid = self._pid
- _libgpac.gf_filter_pid_send_event(self._pid, byref(evt))
-
- ##removes this output pid - see \ref gf_filter_pid_remove
- #\return
- def remove(self):
- if self._input:
- raise Exception('Cannot remove input pid')
- return
- _libgpac.gf_filter_pid_remove(self._pid)
-
- ##enumerates property on pid
- #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval(property value)
- #\return
- def enum_props(self, callback_obj):
- self._filter._pid_enum_props_ex(callback_obj, self._pid)
-
- ##get a PID property
- #\param pname property name
- #\return property value or None if not found
- def get_prop(self, pname):
- return self._filter._pid_prop_ex(pname, self._pid, False)
-
- ##get a PID info
- #\param pname property name
- #\return property value or None if not found
- def get_info(self, pname):
- return self._filter._pid_prop_ex(pname, self._pid, True)
-
- ##get first packet of input PID - see gf_filter_pid_get_packet
- #\return FilterPacket or None if no packet available
- def get_packet(self):
- ##\cond private
- if self._cur_pck:
- return self._cur_pck
- pck = _libgpac.gf_filter_pid_get_packet(self._pid)
- if pck:
- self._cur_pck = FilterPacket(pck, True)
- return self._cur_pck
- ##\endcond
-
- ##drops (removes) the first packet of input PID - see \ref gf_filter_pid_drop_packet
- #\return
- def drop_packet(self):
- ##\cond private
- if self._cur_pck:
- self._cur_pck = None
- _libgpac.gf_filter_pid_drop_packet(self._pid)
- ##\endcond
-
- ##copy property of given PID to the current pid - see \ref gf_filter_pid_copy_properties
- #\param ipid FilterPid to copy from
- #\return
- def copy_props(self, ipid):
- if self._input:
- raise Exception('Cannot copy properties on input PID')
- return
- if ipid==None:
- return
- err = _libgpac.gf_filter_pid_copy_properties(self._pid, ipid._pid)
- if err<0:
- raise Exception('Cannot copy properties: ' + e2s(err) )
- 
- ##removes all properties of the current pid - see \ref gf_filter_pid_reset_properties
- #\return
- def reset_props(self):
- if self._input:
- raise Exception('Cannot reset properties on input PID')
- return
- _libgpac.gf_filter_pid_reset_properties(self._pid)
-
- ##forward a packet on the current pid - see \ref gf_filter_pck_forward
- #\param ipck packet to forward
- #\return
- def forward(self, ipck):
- if self._input:
- raise Exception('Cannot copy properties on input PID')
- return
- if ipck==None:
- return
- _libgpac.gf_filter_pck_forward(ipck._pck, self._pid)
-
- ##set a property the current pid - see \ref gf_filter_pid_set_property and \ref gf_filter_pid_set_property_str
- #\param pcode property type
- #\param prop property value to set
- #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
- #\return
- def set_prop(self, pcode, prop, custom_type=0):
- if self._input:
- raise Exception('Cannot set properties on input PID')
- return
- prop_4cc = pcode
- prop_name = None
- if isinstance(pcode, str):
- _pname = pcode.encode('utf-8')
- prop_4cc = _libgpac.gf_props_get_id(_pname)
- if prop_4cc==0:
- prop_name = _pname
-
- if prop==None:
- if prop_4cc:
- _libgpac.gf_filter_pid_set_property(self._pid, prop_4cc, None)
- else:
- _libgpac.gf_filter_pid_set_property_str(self._pid, prop_name, None)
- return
-
- prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
- if prop_4cc:
- _libgpac.gf_filter_pid_set_property(self._pid, prop_4cc, byref(prop_val))
- else:
- _libgpac.gf_filter_pid_set_property_str(self._pid, prop_name, byref(prop_val))
-
- ##set a info property the current pid - see \ref gf_filter_pid_set_info and \ref gf_filter_pid_set_info_str
- #\param pcode property type
- #\param prop property value to set
- #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
- #\return
- def set_info(self, pcode, prop, custom_type=0):
- if self._input:
- raise Exception('Cannot set info on input PID')
- return
- prop_4cc = pcode
- prop_name = None
- if isinstance(pcode, str):
- _pname = pcode.encode('utf-8')
- prop_4cc = _libgpac.gf_props_get_id(_pname)
- if prop_4cc==0:
- prop_name = _pname
-
- if prop==None:
- if prop_4cc:
- _libgpac.gf_filter_pid_set_info(self._pid, prop_4cc, None)
- else:
- _libgpac.gf_filter_pid_set_info_str(self._pid, prop_name, None)
- return
-
- prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
- if prop_4cc:
- _libgpac.gf_filter_pid_set_info(self._pid, prop_4cc, byref(prop_val))
- else:
- _libgpac.gf_filter_pid_set_info_str(self._pid, prop_name, byref(prop_val))
-
- ##clears EOS on the current PID - see \ref gf_filter_pid_clear_eos
- #\param all_pids if True, clears eos on all input pids
- #\return
- def clear_eos(self, all_pids):
- _libgpac.gf_filter_pid_clear_eos(self._pid, all_pids)
-
- ##check PID properties match capability of filter - see \ref gf_filter_pid_check_caps
- #\return
- def check_caps(self):
- return _libgpac.gf_filter_pid_check_caps(self._pid)
-
- ##discard blocking mode on PID - see \ref gf_filter_pid_discard_block
- #\return
- def discard_block(self):
- _libgpac.gf_filter_pid_discard_block(self._pid)
-
- ##allow direct dispatch of output to destinations - see \ref gf_filter_pid_allow_direct_dispatch
- #\return
- def allow_direct_dispatch(self):
- _libgpac.gf_filter_pid_allow_direct_dispatch(self._pid)
-
- ##get current clock type info - see \ref gf_filter_pid_get_clock_info
- #\return clock type (int)
- def get_clock_type(self):
- return _libgpac.gf_filter_pid_get_clock_info(self._pid, None, None)
-
- ##get current clock time stamp - see \ref gf_filter_pid_get_clock_info
- #\return clock timestamp (Fraction64)
- def get_clock_timestamp(self):
- timestamp = c_longlong(0)
- timescale = c_uint(0)
- _libgpac.gf_filter_pid_get_clock_info(self._pid, byref(timestamp), byref(timescale))
- v = Fraction64()
- v.value.num = timestamp.value
- v.value.den = timescale.value
- return v
-
- ##check if a filter is in the parent filter chain of the pid - see \ref gf_filter_pid_is_filter_in_parents
- #\param filter Filter to check
- #\return True or False
- def is_filter_in_parents(self, filter):
- return _libgpac.gf_filter_pid_is_filter_in_parents(self._pid, filter._f)
-
- ##get buffer occupancy - see \ref gf_filter_pid_get_buffer_occupancy
- #\return BufferOccupancy object
- def get_buffer_occupancy(self):
- max_units = c_uint(0)
- nb_pck = c_uint(0)
- max_dur = c_uint(0)
- dur = c_uint(0)
- in_final_flush = _libgpac.gf_filter_pid_get_buffer_occupancy(self._pid, byref(max_units), byref(nb_pck), byref(max_dur), byref(dur) )
- in_final_flush = not in_final_flush
- return BufferOccupancy(max_units, nb_pck, max_dur, dur, not_in_final_flush)
-
- ##sets loose connect mode - see \ref gf_filter_pid_set_loose_connect
- #\return
- def loose_connect(self):
- _libgpac.gf_filter_pid_set_loose_connect(self._pid)
-
- ##sets framing mode - see \ref gf_filter_pid_set_framing_mode
- #\param framed if True, complete frames only will be delivered on the pid
- #\return
- def set_framing(self, framed):
- _libgpac.gf_filter_pid_set_framing_mode(self._pid, framed)
-
- ##sets clock mode - see \ref gf_filter_pid_set_clock_mode
- #\param cmode clock mode operation of filter
- #\return
- def set_clock_mode(self, cmode):
- _libgpac.gf_filter_pid_set_clock_mode(self._pid, cmode)
-
- ##sets discard mode - see \ref gf_filter_pid_set_discard
- #\param do_discard if True, discard is on
- #\return
- def set_discard(self, do_discard):
- _libgpac.gf_filter_pid_set_discard(self._pid, do_discard)
-
- ##enforces sourceID to be present for output pids of this filter - see \ref gf_filter_pid_require_source_id
- #\return
- def require_source_id(self):
- err = _libgpac.gf_filter_pid_require_source_id(self._pid)
- if err<0:
- raise Exception('Failed to require sourceID for pid: ' + e2s(err))
- return
-
- ##sets DTS recomputing mode - see \ref gf_filter_pid_recompute_dts
- #\param do_compute if True, DTS are recomputed
- #\return
- def recompute_dts(self, do_compute):
- _libgpac.gf_filter_pid_recompute_dts(self._pid, do_compute)
-
- ##queries a capability property on output PID - see \ref gf_filter_pid_caps_query and \ref gf_filter_pid_caps_query_str
- #\param pcode property to check
- #\return property value if found, None otherwise
- def query_cap(self, pcode):
- if self._input:
- raise Exception('Cannot query caps on input PID')
- return
- prop_4cc = pcode
- prop_name = None
- if isinstance(pcode, str):
- _pname = pcode.encode('utf-8')
- prop_4cc = _libgpac.gf_props_get_id(_pname)
- if prop_4cc==0:
- prop_name = _pname
-
- if prop_4cc:
- prop_val = _libgpac.gf_filter_pid_caps_query(self._pid, prop_4cc)
- else:
- prop_val = _libgpac.gf_filter_pid_caps_query_str(self._pid, _pname)
-
- if prop_val:
- return _prop_to_python(pname, prop.contents)
- return None
-
- ##negociates a capability property on input PID - see \ref gf_filter_pid_negociate_property and \ref gf_filter_pid_negociate_property_dyn
- #\param pcode property to negotiate
- #\param prop property to negotiate
- #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
- #\return
- def negociate_cap(self, pcode, prop, custom_type=0):
- if not self._input:
- raise Exception('Cannot negociate caps on output PID')
- return
- prop_4cc = pcode
- prop_name = None
- if isinstance(pcode, str):
- _pname = pcode.encode('utf-8')
- prop_4cc = _libgpac.gf_props_get_id(_pname)
- if prop_4cc==0:
- prop_name = _pname
-
- prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
- if prop_4cc:
- _libgpac.gf_filter_pid_negociate_property(self._pid, prop_4cc, byref(prop_val))
- else:
- _libgpac.gf_filter_pid_negociate_property_dyn(self._pid, prop_name, byref(prop_val))
-
- ##resolves a template string - see \ref gf_filter_pid_resolve_file_template
- #\param template the template string
- #\param file_idx the file index
- #\param suffix the file suffix
- #\return the resolved template string
- def resolve_template(self, template, file_idx=0, suffix=None):
- res = create_string_buffer(2000)
- err = _libgpac.gf_filter_pid_resolve_file_template(self._pid, res, template.encode('utf-8'), file_idx, suffix)
- if err<0:
- raise Exception('Cannot resolve file template ' + template + ': ' + e2s(err))
- return res.raw.decode('utf-8')
-
- ##creates a new packet referring to an existing packet - see \ref gf_filter_pck_new_ref
- #\param ipck the input (referenced) packet
- #\param size the data size of the new packet
- #\param offset the offset in the original data
- #\return the new FilterPacket or None if failure
- def new_pck_ref(self, ipck, size=0, offset=0):
- if ipck==None:
- raise Exception('NULL input packet in new_pck_ref !')
- _pck = _libgpac.gf_filter_pck_new_ref(self._pid, offset, size, ipck._pck)
- if _pck:
- return FilterPacket(_pck, False)
- return None
-
- ##creates a new packet of the given size, allocating memory in libgpac - see \ref gf_filter_pck_new_alloc
- #\param size the data size of the new packet
- #\return the new FilterPacket or None if failure
- def new_pck(self, size=0):
- _pck = _libgpac.gf_filter_pck_new_alloc(self._pid, size, None)
- if _pck:
- pck = FilterPacket(_pck, False)
- pck._readonly = False
- return pck
- return None
-
- ##creates a new packet sharing memory of the filter - see \ref gf_filter_pck_new_shared
- #The filter object must have a `packet_release` method with arguments FilterPid, FilterPacket 
- #\param data the data to use. If NumPy is detected, accept a NP Array. Otherwise data is type casted into POINTER(c_ubyte)
- #\return the new FilterPacket or None if failure
- def new_pck_shared(self, data):
- data_p = None
- data_len = 0
- readonly=False
- if not hasattr(self._filter, 'packet_release'):
- raise Exception('Filter ' + self._filter.name + ' has no packet_release callback function defined')
-
- if numpy_support and isinstance(data, np.ndarray):
- data_p = data.ctypes.data_as(POINTER(c_ubyte))
- data_len = data.size * data.itemsize
- readonly = not data.flags.writeable
- else:
- data_p = cast(data, POINTER(c_ubyte) )
- data_len = len(data)
-
- if not data_p:
- raise Exception('Unknown data reference class ' + data.__class__.__name__)
-
- _pck = _libgpac.gf_filter_pck_new_shared(self._pid, data_p, data_len, filter_cbk_release_packet)
- if _pck:
- pck = FilterPacket(_pck, False)
- pck._readonly = readonly
- self.pck_refs.append(pck)
- return pck
- return None
-
- ##creates a new packet copying a source packet - see \ref gf_filter_pck_new_copy
- #\param ipck the FilterPacket to copy
- #\return the new FilterPacket or None if failure
- def new_pck_copy(self, ipck):
- if ipck==None:
- raise Exception('NULL input packet in new_pck_copy !')
- _pck = _libgpac.gf_filter_pck_new_copy(self._pid, ipck._pck, None)
- if _pck:
- pck = FilterPacket(_pck, False)
- pck._readonly = False
- return pck
- return None
-
- ##creates a new packet cloning a source packet - see \ref gf_filter_pck_new_clone
- #\param ipck the FilterPacket to clone
- #\return the new FilterPacket or None if failure
- def new_pck_clone(self, ipck):
- if ipck==None:
- raise Exception('NULL input packet in new_pck_clone !')
- _pck = _libgpac.gf_filter_pck_new_clone(self._pid, ipck._pck, None)
- if _pck:
- pck = FilterPacket(_pck, False)
- pck._readonly = False
- return pck
- return None
-
- ##\cond private: until end, properties
- ##name of the PID - see \ref gf_filter_pid_get_name and \ref gf_filter_pid_set_name
- #\return
- @property
- def name(self):
- return _libgpac.gf_filter_pid_get_name(self._pid).decode('utf-8')
-
- ##\cond private
- @name.setter
- def name(self, val):
- _libgpac.gf_filter_pid_set_name(self._pid, val.encode('utf-8'))
- ##\endcond
-
- ##name of the parent filter - see \ref gf_filter_pid_get_filter_name
- #\return
- @property
- def filter_name(self):
- return _libgpac.gf_filter_pid_get_filter_name(self._pid).decode('utf-8')
-
- ##end of stream property of PID - see \ref gf_filter_pid_is_eos and \ref gf_filter_pid_set_eos
- #\return
- @property
- def eos(self):
- return _libgpac.gf_filter_pid_is_eos(self._pid)
-
- ##\cond private
- @eos.setter
- def eos(self, Value):
- _libgpac.gf_filter_pid_set_eos(self._pid)
- ##\endcond private
-
- ##True if end of stream was seen in the chain but not yet reached by the filter - see \ref gf_filter_pid_has_seen_eos
- #\return
- @property
- def has_seen_eos(self):
- return _libgpac.gf_filter_pid_has_seen_eos(self._pid)
-
- ##True if end of stream was seen on pid but some packets are still pending - see \ref gf_filter_pid_eos_received
- #\return
- @property
- def eos_receievd(self):
- return _libgpac.gf_filter_pid_eos_received(self._pid)
-
- ##True if PID would block - see \ref gf_filter_pid_would_block
- #\return
- @property
- def would_block(self):
- return _libgpac.gf_filter_pid_would_block(self._pid)
-
- ##maximum buffer of PID in microseconds - see \ref gf_filter_pid_get_max_buffer and \ref gf_filter_pid_set_max_buffer
- #\return
- @property
- def max_buffer(self):
- return _libgpac.gf_filter_pid_get_max_buffer(self._pid)
-
- ##\cond private
- @max_buffer.setter
- def max_buffer(self, value):
- return _libgpac.gf_filter_pid_set_max_buffer(self._pid, value)
- ##\endcond
-
- ##buffer of PID in microseconds - see \ref gf_filter_pid_query_buffer_duration
- #\return
- @property
- def buffer(self):
- return _libgpac.gf_filter_pid_query_buffer_duration(self._pid, False)
-
- ##True if buffer is full - see \ref gf_filter_pid_query_buffer_duration
- #\return
- @property
- def buffer_full(self):
- dur = _libgpac.gf_filter_pid_query_buffer_duration(self._pid, True)
- if dur:
- return True
- else:
- return False
-
- ##True if no pending packet - see \ref gf_filter_pid_first_packet_is_empty
- #\return
- @property
- def first_empty(self):
- return _libgpac.gf_filter_pid_first_packet_is_empty(self._pid)
-
- ##value of CTS of first pending packet, None if none - see \ref gf_filter_pid_get_first_packet_cts
- #\return
- @property
- def first_cts(self):
- cts = c_ulonglong(0)
- res = _libgpac.gf_filter_pid_get_first_packet_cts(self._pid, byref(cts))
- if not res:
- return None
- return cts.value
-
- ##number of queued packets for input pid - see \ref gf_filter_pid_get_packet_count
- #\return
- @property
- def nb_pck_queued(self):
- return _libgpac.gf_filter_pid_get_packet_count(self._pid)
-
- ##timescale of pid - see \ref gf_filter_pid_get_timescale
- #\return
- @property
- def timescale(self):
- return _libgpac.gf_filter_pid_get_timescale(self._pid)
-
- ##minimum packet duration (in timescale) of pid - see \ref gf_filter_pid_get_min_pck_duration
- #\return
- @property
- def min_pck_dur(self):
- return _libgpac.gf_filter_pid_get_min_pck_duration(self._pid)
-
- ##True if PID is playing - see \ref gf_filter_pid_is_playing
- #\return
- @property
- def playing(self):
- return _libgpac.gf_filter_pid_is_playing(self._pid)
-
- #\return
- @property
- def next_ts(self):
- return _libgpac.gf_filter_pid_get_next_ts(self._pid)
-
- ##\endcond
-
- #vars:
- #src_name, args, src_args, src_url, dst_url: probably not needed since the entire session is exposed to the custom filter
-
-
-
-
-#
-# filter packet bindings
-#
-
-##\cond private
-
-#getters
-_libgpac.gf_filter_pck_get_dts.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_dts.restype = c_ulonglong
-_libgpac.gf_filter_pck_set_dts.argtypes = _gf_filter_packet, c_ulonglong
-
-_libgpac.gf_filter_pck_get_cts.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_cts.restype = c_ulonglong
-_libgpac.gf_filter_pck_set_cts.argtypes = _gf_filter_packet, c_ulonglong
-
-_libgpac.gf_filter_pck_get_sap.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_sap.restype = c_uint
-_libgpac.gf_filter_pck_set_sap.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_duration.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_duration.restype = c_uint
-_libgpac.gf_filter_pck_set_duration.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_data.argtypes = _gf_filter_packet, POINTER(c_uint)
-_libgpac.gf_filter_pck_get_data.restype = POINTER(c_ubyte)
-
-_libgpac.gf_filter_pck_get_framing.argtypes = _gf_filter_packet, POINTER(gf_bool), POINTER(gf_bool)
-_libgpac.gf_filter_pck_set_framing.argtypes = _gf_filter_packet, gf_bool, gf_bool
-
-_libgpac.gf_filter_pck_get_timescale.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_timescale.restype = c_uint
-
-_libgpac.gf_filter_pck_get_interlaced.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_interlaced.restype = c_uint
-_libgpac.gf_filter_pck_set_interlaced.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_corrupted.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_corrupted.restype = gf_bool
-_libgpac.gf_filter_pck_set_corrupted.argtypes = _gf_filter_packet, gf_bool
-
-_libgpac.gf_filter_pck_get_seek_flag.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_seek_flag.restype = gf_bool
-_libgpac.gf_filter_pck_set_seek_flag.argtypes = _gf_filter_packet, gf_bool
-
-_libgpac.gf_filter_pck_get_byte_offset.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_byte_offset.restype = c_ulonglong
-_libgpac.gf_filter_pck_set_byte_offset.argtypes = _gf_filter_packet, c_ulonglong
-
-_libgpac.gf_filter_pck_get_roll_info.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_roll_info.restype = c_short
-_libgpac.gf_filter_pck_set_roll_info.argtypes = _gf_filter_packet, c_short
-
-_libgpac.gf_filter_pck_get_crypt_flags.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_crypt_flags.restype = c_uint
-_libgpac.gf_filter_pck_set_crypt_flags.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_clock_type.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_clock_type.restype = c_uint
-_libgpac.gf_filter_pck_set_clock_type.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_carousel_version.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_carousel_version.restype = c_uint
-_libgpac.gf_filter_pck_set_carousel_version.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_seq_num.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_seq_num.restype = c_uint
-_libgpac.gf_filter_pck_set_seq_num.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_dependency_flags.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_dependency_flags.restype = c_uint
-_libgpac.gf_filter_pck_set_dependency_flags.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_get_frame_interface.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_get_frame_interface.restype = c_void_p
-
-_libgpac.gf_filter_pck_is_blocking_ref.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_is_blocking_ref.restype = gf_bool
-
-_libgpac.gf_filter_pck_has_properties.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_has_properties.restype = gf_bool
-
-_libgpac.gf_filter_pck_enum_properties.argtypes = _gf_filter_packet, POINTER(c_uint), POINTER(c_uint), POINTER(c_char_p)
-_libgpac.gf_filter_pck_enum_properties.restype = POINTER(PropertyValue)
-
-_libgpac.gf_filter_pck_get_property.argtypes = _gf_filter_packet, c_uint
-_libgpac.gf_filter_pck_get_property.restype = POINTER(PropertyValue)
-_libgpac.gf_filter_pck_get_property_str.argtypes = _gf_filter_packet, c_char_p
-_libgpac.gf_filter_pck_get_property_str.restype = POINTER(PropertyValue)
-
-_libgpac.gf_filter_pck_ref_ex.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_ref_ex.restype = _gf_filter_packet
-_libgpac.gf_filter_pck_unref.argtypes = _gf_filter_packet
-
-_libgpac.gf_filter_pck_discard.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_set_readonly.argtypes = _gf_filter_packet
-_libgpac.gf_filter_pck_send.argtypes = _gf_filter_packet
-
-_libgpac.gf_filter_pck_merge_properties.argtypes = _gf_filter_packet, _gf_filter_packet
-
-_libgpac.gf_filter_pck_set_property.argtypes = _gf_filter_packet, c_uint, POINTER(PropertyValue)
-_libgpac.gf_filter_pck_set_property_str.argtypes = _gf_filter_packet, c_char_p, POINTER(PropertyValue)
-_libgpac.gf_filter_pck_truncate.argtypes = _gf_filter_packet, c_uint
-
-_libgpac.gf_filter_pck_dangling_copy.argtypes = _gf_filter_packet, _gf_filter_packet
-_libgpac.gf_filter_pck_dangling_copy.restype = _gf_filter_packet
-
-##\endcond private
-
-##filter packet object
-class FilterPacket:
- ##\cond private
- def __init__(self, pck, is_src):
- self._pck = pck
- self._is_src = is_src
- self._readonly = True
- ##\endcond private
- #hack for doxygen to generate member vars (not support for parsing @property)
- if 0:
- ##Decode Timestamp - see \ref gf_filter_pck_get_dts and \ref gf_filter_pck_set_dts
- #\hideinitializer
- self.dts=0
- ##Compose Timestamp - see \ref gf_filter_pck_get_cts and \ref gf_filter_pck_set_cts
- #\hideinitializer
- self.cts=0
- ##SAP type - see \ref gf_filter_pck_get_sap and \ref gf_filter_pck_set_sap
- #\hideinitializer
- self.sap=0
- ##Duration - see \ref gf_filter_pck_get_duration and \ref gf_filter_pck_set_duration
- #\hideinitializer
- self.dur=0
- ##Size of packet data, readonly
- #\hideinitializer
- self.size=0
- ##Packet data - see \ref gf_filter_pck_get_data
- #If NumPy is available, the data is returned as a np Array, otherwise it is a POINTER(c_ubyte) object
- #The property is readonly (cannot be set) but content can be modified for non-refs output packets
- #\hideinitializer
- self.data=0
- ##frame start - see \ref gf_filter_pck_get_framing and \ref gf_filter_pck_set_framing
- #\hideinitializer
- self.start=0
- ##frame end - see \ref gf_filter_pck_get_framing and \ref gf_filter_pck_set_framing
- #\hideinitializer
- self.end=0
- ##associated timescale, readonly - see \ref gf_filter_pck_get_timescale
- #\hideinitializer
- self.timescale=0
- ##Interlaced flags - see \ref gf_filter_pck_get_interlaced and \ref gf_filter_pck_set_interlaced
- #\hideinitializer
- self.interlaced=0
- ##Corrupted flag - see \ref gf_filter_pck_get_corrupted and \ref gf_filter_pck_set_corrupted
- #\hideinitializer
- self.corrupted=0
- ##Seek flag - see \ref gf_filter_pck_get_seek_flag and \ref gf_filter_pck_set_seek_flag
- #\hideinitializer
- self.seek=0
- ##Byte offset - see \ref gf_filter_pck_get_byte_offset and \ref gf_filter_pck_set_byte_offset
- #\hideinitializer
- self.byte_offset=0
- ##Roll info - see \ref gf_filter_pck_get_roll_info and \ref gf_filter_pck_set_roll_info
- #\hideinitializer
- self.roll=0
- ##Encryption flags - see \ref gf_filter_pck_get_crypt_flags and \ref gf_filter_pck_set_crypt_flags
- #\hideinitializer
- self.crypt=0
- ##Clock reference flag - see \ref gf_filter_pck_get_clock_type and \ref gf_filter_pck_set_clock_type
- #\hideinitializer
- self.clock=0
- ##Carousel version - see \ref gf_filter_pck_get_carousel_version and \ref gf_filter_pck_set_carousel_version
- #\hideinitializer
- self.carousel=0
- ##Sequence number - see \ref gf_filter_pck_get_seq_num and \ref gf_filter_pck_set_seq_num
- #\hideinitializer
- self.seqnum=0
- ##Dependency flags - see \ref gf_filter_pck_get_dependency_flags and \ref gf_filter_pck_set_dependency_flags
- #\hideinitializer
- self.deps=0
- ##true if packet holds a GF_FrameInterface object and not a data packet, readonly
- #\hideinitializer
- self.frame_ifce=0
- ##Custom properties present, readonly - see \ref gf_filter_pck_has_properties
- #\hideinitializer
- self.has_properties=0
- ##true if packet is a blocking reference, readonly - see \ref gf_filter_pck_is_blocking_ref
- #\hideinitializer
- self.blocking_ref=0
-
- ##enumerate an packet properties
- #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval
- #\return
- def enum_props(self, callback_obj):
- if not hasattr(callback_obj, 'on_prop_enum'):
- return
-
- pidx=c_uint(0)
- while True:
- _p4cc=c_uint(0)
- _pname=c_char_p(0)
- prop = _libgpac.gf_filter_pck_enum_properties(self._pck, byref(pidx), byref(_p4cc), byref(_pname))
- if prop:
- p4cc=_p4cc.value
- pname=None
- if _pname:
- pname=_pname.value.decode('utf-8')
- else:
- pname=_libgpac.gf_props_4cc_get_name(p4cc).decode('utf-8')
- pval = _prop_to_python(pname, prop.contents)
- callback_obj.on_prop_enum(pname, pval)
- else:
- break
-
- ##get a packet property - see \ref gf_filter_pck_get_property and \ref gf_filter_pck_get_property_str
- #\param prop_name name of property to get
- #\return property value, or None if not found
- def get_prop(self, prop_name):
- _name = prop_name.encode('utf-8')
- p4cc = _libgpac.gf_props_get_id(_name)
- if p4cc:
- prop = _libgpac.gf_filter_pck_get_property(self._pck, p4cc)
- else:
- prop = _libgpac.gf_filter_pck_get_property_str(self._pck, _name)
- if prop:
- return _prop_to_python(prop_name, prop.contents)
- return None
-
- ##increase packet reference count - see \ref gf_filter_pck_ref_ex
- #\return
- def ref(self):
- ##\cond private
- self._pck = _libgpac.gf_filter_pck_ref_ex(self._pck)
- ##\endcond private
-
- ##decrease packet reference count - see \ref gf_filter_pck_unref
- #\return
- def unref(self):
- _libgpac.gf_filter_pck_unref(self._pck)
-
-
- ##discard an output packet instead of sending it - see \ref gf_filter_pck_discard
- #\return
- def discard(self):
- ##\cond private
- if self._is_src:
- raise Exception('Cannot discard on source packet')
- _libgpac.gf_filter_pck_discard(self._pck)
- self._pck = None
- ##\endcond private
-
- ##creates a new packet cloning a source packet - see \ref gf_filter_pck_dangling_copy.
- #The resulting packet is read/write mode and may have its own memory allocated.
- #This is typically used by sink filters wishing to access underling GPU data of a packet using frame interface.
- #the resulting packet can be explicitly discarded using \ref discard, otherwise will be garrbage collected.
- #\param cached_pck if set, will be reuse for creation of new packet. This can greatly reduce memory allocations
- #\return the new FilterPacket or None if failure or None if failure ( if grabbing the frame into a local copy failed)
- def clone(self, cached_pck=None):
- if cached_pck:
- _pck = _libgpac.gf_filter_pck_dangling_copy(self._pck, cached_pck._pck)
- else:
- _pck = _libgpac.gf_filter_pck_dangling_copy(self._pck, None)
-
- if _pck:
- pck = FilterPacket(_pck, False)
- pck._readonly = False
- return pck
- return None
-
-
- ##mark an output packet as readonly - see \ref gf_filter_pck_set_readonly
- #\return
- def readonly(self):
- if self._is_src:
- raise Exception('Cannot set readonly on source packet')
- _libgpac.gf_filter_pck_set_readonly(self._pck)
-
- ##send the packet - see \ref gf_filter_pck_send
- #\return
- def send(self):
- if self._is_src:
- raise Exception('Cannot send on source packet')
- _libgpac.gf_filter_pck_send(self._pck)
-
- ##copy properties of source packet in this packet - see \ref gf_filter_pck_merge_properties
- #\param ipck source packet
- #\return
- def copy_props(self, ipck):
- if self._is_src:
- raise Exception('Cannot copy properties on source packet')
- if ipck==None:
- return
- err = _libgpac.gf_filter_pck_merge_properties(ipck._pck, self._pck)
- if err<0:
- raise Exception('Cannot copy properties: ' + e2s(err) )
-
- ##set property in this packet - see \ref gf_filter_pck_set_property and \ref gf_filter_pck_set_property_str
- #\param pcode name of property
- #\param prop property value
- #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
- #\return
- def set_prop(self, pcode, prop, custom_type=0):
- if self._is_src:
- raise Exception('Cannot copy properties on source packet')
- prop_4cc = pcode
- prop_name = None
- if isinstance(pcode, str):
- _pname = pcode.encode('utf-8')
- prop_4cc = _libgpac.gf_props_get_id(_pname)
- if prop_4cc==0:
- prop_name = _pname
-
- if prop==None:
- if prop_4cc:
- _libgpac.gf_filter_pck_set_property(self._pck, prop_4cc, None)
- else:
- _libgpac.gf_filter_pck_set_property_str(self._pck, prop_name, None)
- return
-
- prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
- if prop_4cc:
- _libgpac.gf_filter_pck_set_property(self._pck, prop_4cc, byref(prop_val))
- else:
- _libgpac.gf_filter_pck_set_property_str(self._pck, prop_name, byref(prop_val))
-
- ##truncates an output packet to the given size - see \ref gf_filter_pck_truncate
- #\param size new size of packet
- #\return
- def truncate(self, size):
- if self._is_src:
- raise Exception('Cannot truncate an source packet')
- _libgpac.gf_filter_pck_truncate(self._pck, size)
-
- ##\cond private: until end, all packet properties
- @property
- def blocking_ref(self):
- return _libgpac.gf_filter_pck_is_blocking_ref(self._pck)
-
- @property
- def dts(self):
- return _libgpac.gf_filter_pck_get_dts(self._pck)
-
- @dts.setter
- def dts(self, val):
- if self._is_src:
- raise Exception('Cannot set DTS on source packet')
- _libgpac.gf_filter_pck_set_dts(self._pck, val)
-
- @property
- def cts(self):
- return _libgpac.gf_filter_pck_get_cts(self._pck)
-
- @cts.setter
- def cts(self, val):
- if self._is_src:
- raise Exception('Cannot set CTS on source packet')
- return _libgpac.gf_filter_pck_set_cts(self._pck, val)
-
- @property
- def sap(self):
- return _libgpac.gf_filter_pck_get_sap(self._pck)
-
- @sap.setter
- def sap(self, val):
- if self._is_src:
- raise Exception('Cannot set SAP on source packet')
- return _libgpac.gf_filter_pck_set_sap(self._pck, val)
-
- @property
- def dur(self):
- return _libgpac.gf_filter_pck_get_duration(self._pck)
-
- @dur.setter
- def dur(self, val):
- if self._is_src:
- raise Exception('Cannot set duration on source packet')
- return _libgpac.gf_filter_pck_set_duration(self._pck, val)
-
- @property
- def size(self):
- size = c_uint(0)
- _libgpac.gf_filter_pck_get_data(self._pck, byref(size))
- return size.value
-
- @property
- def data(self):
- size = c_uint(0)
- data = _libgpac.gf_filter_pck_get_data(self._pck, byref(size))
- if not data:
- return None
-
- if numpy_support:
- data = np.ctypeslib.as_array(data, (size.value,))
- if self._readonly:
- data.flags.writeable=False
- return data 
-
- @property
- def start(self):
- start = gf_bool(False)
- end = gf_bool(False)
- _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
- return start.value
-
- @start.setter
- def start(self, value):
- if self._is_src:
- raise Exception('Cannot set framing on source packet')
- start = gf_bool(False)
- end = gf_bool(False)
- _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
- _libgpac.gf_filter_pck_set_framing(self._pck, value, end.value)
-
- @property
- def end(self):
- start = gf_bool(False)
- end = gf_bool(False)
- _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
- return end.value
-
- @end.setter
- def end(self, value):
- if self._is_src:
- raise Exception('Cannot set framing on source packet')
- start = gf_bool(False)
- end = gf_bool(False)
- _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
- _libgpac.gf_filter_pck_set_framing(self._pck, start.value, value)
-
- @property
- def timescale(self):
- return _libgpac.gf_filter_pck_get_timescale(self._pck)
-
- @property
- def interlaced(self):
- return _libgpac.gf_filter_pck_get_interlaced(self._pck)
-
- @interlaced.setter
- def interlaced(self, value):
- if self._is_src:
- raise Exception('Cannot set interlaced on source packet')
- return _libgpac.gf_filter_pck_set_interlaced(self._pck, value)
-
- @property
- def corrupted(self):
- return _libgpac.gf_filter_pck_get_corrupted(self._pck)
-
- @corrupted.setter
- def corrupted(self, value):
- if self._is_src:
- raise Exception('Cannot set corrupted on source packet')
- return _libgpac.gf_filter_pck_set_corrupted(self._pck, value)
-
- @property
- def seek(self):
- return _libgpac.gf_filter_pck_get_seek_flag(self._pck)
-
- @seek.setter
- def seek(self, value):
- if self._is_src:
- raise Exception('Cannot set seek on source packet')
- return _libgpac.gf_filter_pck_set_seek_flag(self._pck, value)
-
- @property
- def byte_offset(self):
- return _libgpac.gf_filter_pck_get_byte_offset(self._pck)
-
- @byte_offset.setter
- def byte_offset(self, value):
- if self._is_src:
- raise Exception('Cannot set byte offset on source packet')
- return _libgpac.gf_filter_pck_set_byte_offset(self._pck, value)
-
- @property
- def roll(self):
- return _libgpac.gf_filter_pck_get_roll_info(self._pck)
-
- @roll.setter
- def roll(self):
- if self._is_src:
- raise Exception('Cannot set roll on source packet')
- return _libgpac.gf_filter_pck_set_roll_info(self._pck, value)
-
- @property
- def crypt(self):
- return _libgpac.gf_filter_pck_get_crypt_flags(self._pck)
-
- @crypt.setter
- def crypt(self, value):
- if self._is_src:
- raise Exception('Cannot set crypt on source packet')
- return _libgpac.gf_filter_pck_set_crypt_flags(self._pck, value)
-
- @property
- def clock(self):
- return _libgpac.gf_filter_pck_get_clock_type(self._pck)
-
- @clock.setter
- def clock(self, value):
- if self._is_src:
- raise Exception('Cannot set clock on source packet')
- return _libgpac.gf_filter_pck_set_clock_type(self._pck, value)
-
- @property
- def carousel(self):
- return _libgpac.gf_filter_pck_get_carousel_version(self._pck)
-
- @carousel.setter
- def carousel(self, value):
- if self._is_src:
- raise Exception('Cannot set carousel on source packet')
- return _libgpac.gf_filter_pck_set_carousel_version(self._pck, value)
-
- @property
- def seqnum(self):
- return _libgpac.gf_filter_pck_get_seq_num(self._pck)
-
- @seqnum.setter
- def seqnum(self):
- if self._is_src:
- raise Exception('Cannot set segnum on source packet')
- return _libgpac.gf_filter_pck_set_seq_num(self._pck, value)
-
- @property
- def deps(self):
- return _libgpac.gf_filter_pck_get_dependency_flags(self._pck)
-
- @deps.setter
- def deps(self, value):
- if self._is_src:
- raise Exception('Cannot set deps on source packet')
- return _libgpac.gf_filter_pck_set_dependency_flags(self._pck, value)
-
- @property
- def has_properties(self):
- if _libgpac.gf_filter_pck_has_properties(self._pck):
- return True
- return False
-
- @property
- def frame_ifce(self):
- p = _libgpac.gf_filter_pck_get_frame_interface(self._pck)
- if p:
- return True
- return False
-
- ##\endcond private
-
- #todo
- #append ?
-
-## @}
-
-
-##\cond private
-_gf_fileio = c_void_p
-_libgpac.gf_fileio_new.argtypes = c_char_p, py_object, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p
-_libgpac.gf_fileio_new.restype = _gf_fileio
-
-_libgpac.gf_fileio_url.argtypes = _gf_fileio
-_libgpac.gf_fileio_url.restype = c_char_p
-
-_libgpac.gf_fileio_resource_url.argtypes = _gf_fileio
-_libgpac.gf_fileio_resource_url.restype = c_char_p
-
-_libgpac.gf_fileio_translate_url.argtypes = c_char_p
-_libgpac.gf_fileio_translate_url.restype = c_char_p
-
-_libgpac.gf_fileio_get_udta.argtypes = _gf_fileio
-_libgpac.gf_fileio_get_udta.restype = c_void_p
-
-_libgpac.gf_fileio_del.argtypes = _gf_fileio
-
-_libgpac.gf_fileio_tag_main_thread.argtypes = _gf_fileio
-
-#wraps gf_url_concatenate to be able to free the value
-#we declare a void * return value
-_libgpac.gf_url_concatenate.argtypes = c_char_p, c_char_p
-_libgpac.gf_url_concatenate.restype = c_void_p
-_libgpac.gf_url_free.argtypes = c_void_p
-
-def url_concatenate(_parent, _url):
-	#this is c_void_p
-	_path = _libgpac.gf_url_concatenate(_parent, _url)
-	if _path==None:
-		raise Exception('Failed to concatenate path, out of memory')
-	#this is a string
-	path = cast(_path, c_char_p).value.decode('utf-8')
-	#we still have the pointer, we can free it
-	_libgpac.gf_url_free(_path)
-	return path
-
-#fio open callback
-@CFUNCTYPE(_gf_fileio, _gf_fileio, c_char_p, c_char_p, POINTER(c_int))
-def fileio_cbk_open(_fio_ref, _url, _mode, error):
- fio_ref = cast(_libgpac.gf_fileio_get_udta(_fio_ref), py_object).value
- mode = _mode.decode('utf-8')
- error.contents.value=GF_OK
- if mode=="url":
- path = url_concatenate(_libgpac.gf_fileio_resource_url(_fio_ref), _url);
- new_gfio = FileIO(path, fio_ref)
- fio_ref.factory.pending_urls.append(new_gfio)
- #prevent garbage collection
- fio_ref.factory.gc_exclude.append(new_gfio)
- fio_ref.factory.all_refs+=1
- return new_gfio._gf_fio
-
- if mode=="ref":
- fio_ref.nb_refs+=1
- fio_ref.factory.all_refs+=1
- return _fio_ref
-
- if mode=="probe":
- if not hasattr(fio_ref.factory.root_obj, 'exists'):
- return None
- if not fio_ref.factory.root_obj.exists(url):
- error.contents.value=GF_URL_ERROR
- return None
-
- do_delete=False
- if mode=="unref":
- fio_ref.nb_refs-=1
- fio_ref.factory.all_refs-=1
- if fio_ref.nb_refs:
- return _fio_ref
- do_delete=True
-
- if mode=="close":
- if fio_ref.py_obj != None:
- fio_ref.py_obj.close()
- fio_ref.factory.all_refs-=1
-
- if fio_ref.nb_refs:
- return None
- do_delete=True
-
- if do_delete:
- #file no longer used, can now be garbage collected
- fio_ref.factory.gc_exclude.remove(fio_ref)
-
- if not fio_ref.factory == fio_ref:
- _libgpac.gf_fileio_del(fio_ref._gf_fio)
- fio_ref._gf_fio = None
-
- if not fio_ref.factory.all_refs and not len(fio_ref.factory.pending_urls) and not len(fio_ref.factory.gc_exclude):
- _libgpac.gf_fileio_del(fio_ref.factory._gf_fio)
- fio_ref.factory._gf_fio = None
- fio_ref.factory.root_obj = None
- return None
-
-
-	#this is an open() call
- fio_url = _url.decode('utf-8')
-
-	#check if associated object exists, if not so we can use this instance
- fio = None
- if fio_ref.py_obj == None:
- fio = fio_ref
- if fio_ref in fio_ref.factory.pending_urls:
- fio_ref.factory.all_refs-=1
- fio_ref.factory.pending_urls.remove(fio_ref)
-
-	#check in pending urls
- if fio == None:
- for afio in fio_ref.factory.pending_urls:
- a_url = _libgpac.gf_fileio_resource_url(afio._gf_fio).decode('utf-8')
- if a_url == fio_url:
- fio_ref.factory.all_refs-=1
- fio_ref.factory.pending_urls.remove(afio)
- fio = afio
- break;
-
-	#we need to create a new FileIO
- created=False
- if fio==None:
- created=True
-
-	#read url, translate
- if fio_url.startswith('gfio://')==True:
- fio_url = _libgpac.gf_fileio_translate_url(_url).decode('utf-8')
-	#if we create a new FileIO, we need to resolve url, against parent URL
- elif created:
- fio_url = url_concatenate(_libgpac.gf_fileio_resource_url(fio_ref._gf_fio), _url)
-
- if fio==None:
- fio = FileIO(fio_url, fio_ref)
-
- #create object, direct copy of the object passed at construction
- fio.py_obj = copy.copy(fio.factory.root_obj)
- res = fio.py_obj.open(fio_url, mode)
-
- if res==True:
- if not fio in fio.factory.gc_exclude:
- fio.factory.gc_exclude.append(fio)
- fio.factory.all_refs+=1
- return fio._gf_fio
-
- #failure to open a new created object, remove FileIO and let the object be garbage collected
- if created:
- _libgpac.gf_fileio_del(fio._gf_fio)
- fio._gf_fio = None
-
- error.contents.value=GF_URL_ERROR
- return None
-
-#fio write callback
-@CFUNCTYPE(c_uint, _gf_fileio, POINTER(c_ubyte), c_uint)
-def fileio_cbk_write(_fio, buf, size):
- fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
- if numpy_support:
- ar_data = np.ctypeslib.as_array(buf, shape=(size,))
- ar_data.flags.writeable=False
- return fio.py_obj.write(ar_data, size)
- return fio.py_obj.write(buf, size)
-
-#fio read callback
-@CFUNCTYPE(c_uint, _gf_fileio, POINTER(c_ubyte), c_uint)
-def fileio_cbk_read(_fio, buf, size):
- fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
- if numpy_support:
- ar_data = np.ctypeslib.as_array(buf, shape=(size,))
- ar_data.flags.writeable=True
- return fio.py_obj.read(ar_data, size)
- return fio.py_obj.read(buf, size)
-
-#fio seek callback
-@CFUNCTYPE(c_uint, _gf_fileio, c_ulonglong, c_int)
-def fileio_cbk_seek(_fio, pos, whence):
- fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
- return fio.py_obj.seek(pos, whence)
-
-#fio tell callback
-@CFUNCTYPE(c_ulonglong, _gf_fileio)
-def fileio_cbk_tell(_fio):
- fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
- return fio.py_obj.tell()
-
-#fio eof callback
-@CFUNCTYPE(gf_bool, _gf_fileio)
-def fileio_cbk_eof(_fio):
- fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
- return fio.py_obj.eof()
-
-
-
-##\endcond private
-
-##
-# \defgroup pyfileio_grp libgpac core tools
-# \ingroup pycore_grp Python APIs
-# \brief FileIO tools for libgpac.
-#
-# @{
-
-
-## FileIO object for file IO callbacks from libgpac
-#
-#
-# The FileIO object is used to create input or output interfaces in which GPAC will read or write.
-# This allows generating content in python without any disk IO, or passing python data as input to GPAC without intermediate file.
-#
-# This object passed to the FileIO constructor must implement the following callbacks:
-#
-# \code boolean open(string URL, string mode)\endcode
-#Opens the file in read or write mode.
-#- URL: string containing file to open
-#- mode: open mode (same as fopen)
-#- return true if success, false otherwise
-#
-#\note There is no guarantee that the URL is checked for existence before calling open
-#\note There is no guarantee that the first call to open is on the URL provided for the constructor (e.g. for DASH generation, this will depend on the DASH profile used which may require to write the manifest after one or more segments)
-#
-# \code void close()\endcode
-#Closes the file
-#
-# \code int write(numpy buffer, unsigned long size)\endcode
-#Writes the file
-#- buffer: numpy array to fill if numpy support, ctypes.c_ubyte otherwise
-#- size: number of bytes to write starting from first byte in buffer
-#- return number of bytes writen, at most the size of the array
-#
-# \code int read(numy buffer, unsigned long size)\endcode
-#Reads the file
-#- buffer: numpy array to read if numpy support, ctypes.c_ubyte otherwise
-#- size: number of bytes to read
-#- return number of bytes read, at most the size of the array
-#
-# \code void seek(unsigned long long pos, int whence)\endcode
-#Seeks current position in file (same as fopen)
-#- pos: position
-#- whence: origin of the position
-#- return 0 if no error, error code otherwise
-#
-# \code unsigned long long tell()\endcode
-#Gets current position in file (same as ftell)
-#- pos: position
-#- return current position
-#
-# \code boolean eof()\endcode
-#Checks if the current position is at the end of the file (same as feof)
-#- return true if file end reached, false otherwise
-#
-# \code boolean exists(string URL)\endcode
-#Checks if the given URL exists. This callback is optional
-#- return true if associated URL exists, false otherwise
-#
-#\warning All these callbacks MUST perform synchronously
-#
-# The URL passed to the constructor indentifies the file name wrapped.
-# Some file types such as HLS or DASH manifest may imply reading or writing several files.
-# To handle these cases, the object passed to the constructor will be cloned for each call to open().
-#
-#\warning This object is a shallow copy of the factory object, not an empty object (difference with NodeJS bindings).
-#
-# All FileIO callbacks will be done in the main thread.
-#
-class FileIO:
-	## constructor for FileIO
-	#\param url url for this fileIO factory
-	#\param obj instance of the class used for IOs. This instance will be cloned (shallow copy) for each new file to open
-	def __init__(self, url, obj):
-		if 0:
-			## the underlying gfio:// URL to be provided to GPAC
-			self.url = 0
-
-##\cond private
-		_libgpac.user_init = True
-		self.nb_refs=0
-		self.py_obj = None
-		#this is internal constructor call from open
-		if obj.__class__.__name__=="FileIO":
-			self.factory = obj.factory
-		#this is regular constructor call
-		else:
-			if hasattr(obj, 'open')==False:
-				raise Exception('No open function on FileIO callback')
-			if hasattr(obj, 'close')==False:
-				raise Exception('No close function on FileIO callback')
-			if hasattr(obj, 'write')==False:
-				raise Exception('No write function on FileIO callback')
-			if hasattr(obj, 'read')==False:
-				raise Exception('No read function on FileIO callback')
-			if hasattr(obj, 'seek')==False:
-				raise Exception('No see function on FileIO callback')
-			if hasattr(obj, 'tell')==False:
-				raise Exception('No tell function on FileIO callback')
-			self.factory = self
-			self.factory.all_refs=0
-			self.factory.pending_urls=
-			#keep all created file IOs still useful here to prevent garbage collection
-			self.factory.gc_exclude=
-			self.factory.root_obj = obj
-
-		self._gf_fio = _libgpac.gf_fileio_new(url.encode('utf-8'), py_object(self), fileio_cbk_open, fileio_cbk_seek, fileio_cbk_read, fileio_cbk_write, fileio_cbk_tell, fileio_cbk_eof, None )
-		if self._gf_fio==None:
-			raise Exception('Failed to create FileIO for ' + url)
-		#ask for all file IOs to happen on main thread
-		_libgpac.gf_fileio_tag_main_thread(self._gf_fio)
-
-	@property
-	def url(self):
-		_url = _libgpac.gf_fileio_url(self._gf_fio)
-		if _url==None:
-			return None
-		return _url.decode('utf-8')
-##\endcond private
-
-## @}
-#

gpac-2.0.0.tar.gz/src/terminal Deleted

gpac-2.0.0.tar.gz/src/terminal/terminal.c Deleted

@@ -1,1743 +0,0 @@
-/*
- *			GPAC - Multimedia Framework C SDK
- *
- *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2022
- *					All rights reserved
- *
- * This file is part of GPAC / Media terminal sub-project
- *
- * GPAC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * GPAC is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. If not, write to
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-
-#include <gpac/internal/compositor_dev.h>
-#include <gpac/internal/scenegraph_dev.h>
-#include <gpac/term_info.h>
-#include <gpac/constants.h>
-#include <gpac/options.h>
-#include <gpac/network.h>
-#include <gpac/xml.h>
-#include <gpac/avparse.h>
-#include <gpac/nodes_svg.h>
-
-#include "../utils/module_wrap.h"
-
-/*textual command processing*/
-#include <gpac/terminal.h>
-#include <gpac/scene_manager.h>
-
-u32 gf_term_sample_clocks(GF_Terminal *term);
-
-
-struct _tag_terminal
-{
-	GF_User *user;
-	GF_Compositor *compositor;
-	GF_FilterSession *fsess;
-	Bool in_destroy;
-	u32 reload_state;
-	char *reload_url;
-};
-
-GF_Compositor *gf_sc_from_filter(GF_Filter *filter);
-
-u32 gf_sc_play_from_time(GF_Compositor *compositor, u64 from_time, u32 pause_at_first_frame);
-
-
-GF_EXPORT
-Bool gf_term_send_event(GF_Terminal *term, GF_Event *evt)
-{
-	return gf_filter_send_gf_event(term->compositor->filter, evt);
-}
-
-
-static GF_Err gf_sc_step_clocks_intern(GF_Compositor *compositor, u32 ms_diff, Bool force_resume_pause)
-{
-	/*only play/pause if connected*/
-	if (!compositor || !compositor->root_scene || !compositor->root_scene->root_od) return GF_BAD_PARAM;
-
-	if (ms_diff) {
-		u32 i, j;
-		GF_SceneNamespace *ns;
-		GF_Clock *ck;
-
-		if (compositor->play_state == GF_STATE_PLAYING) return GF_BAD_PARAM;
-
-		gf_sc_lock(compositor, 1);
-		i = 0;
-		while ((ns = (GF_SceneNamespace*)gf_list_enum(compositor->root_scene->namespaces, &i))) {
-			j = 0;
-			while (ns->clocks && (ck = (GF_Clock *)gf_list_enum(ns->clocks, &j))) {
-				ck->init_timestamp += ms_diff;
-				ck->media_time_at_init += ms_diff;
-				//make sure we don't touch clock while doing resume/pause below
-				if (force_resume_pause)
-					ck->nb_paused++;
-			}
-		}
-		compositor->step_mode = GF_TRUE;
-		compositor->use_step_mode = GF_TRUE;
-		gf_sc_next_frame_state(compositor, GF_SC_DRAW_FRAME);
-
-		//resume/pause to trigger codecs state change
-		if (force_resume_pause) {
-			mediacontrol_resume(compositor->root_scene->root_od, 0);
-			mediacontrol_pause(compositor->root_scene->root_od);
-
-			//release our safety
-			i = 0;
-			while ((ns = (GF_SceneNamespace*)gf_list_enum(compositor->root_scene->namespaces, &i))) {
-				j = 0;
-				while (ns->clocks && (ck = (GF_Clock *)gf_list_enum(ns->clocks, &j))) {
-					ck->nb_paused--;
-				}
-			}
-		}
-
-		gf_sc_lock(compositor, 0);
-
-	}
-	return GF_OK;
-}
-
-static void gf_term_set_play_state(GF_Compositor *compositor, u32 PlayState, Bool reset_audio, Bool pause_clocks)
-{
-	Bool resume_live = 0;
-	u32 prev_state;
-
-	/*only play/pause if connected*/
-	if (!compositor || !compositor->root_scene) return;
-
-	prev_state = compositor->play_state;
-	compositor->use_step_mode = GF_FALSE;
-
-	if (PlayState==GF_STATE_PLAY_LIVE) {
-		PlayState = GF_STATE_PLAYING;
-		resume_live = 1;
-		if (compositor->play_state == GF_STATE_PLAYING) {
-			compositor->play_state = GF_STATE_PAUSED;
-			mediacontrol_pause(compositor->root_scene->root_od);
-		}
-	}
-
-	/*and if not already paused/playing*/
-	if ((compositor->play_state == GF_STATE_PLAYING) && (PlayState == GF_STATE_PLAYING)) return;
-	if ((compositor->play_state != GF_STATE_PLAYING) && (PlayState == GF_STATE_PAUSED)) return;
-
-	/*pause compositor*/
-	if ((PlayState==GF_STATE_PLAYING) && reset_audio)
-		gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, 0xFF);
-	else
-		gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, PlayState);
-
-	/* step mode specific */
-	if (PlayState==GF_STATE_STEP_PAUSE) {
-		if (prev_state==GF_STATE_PLAYING) {
-			mediacontrol_pause(compositor->root_scene->root_od);
-			compositor->play_state = GF_STATE_PAUSED;
-		} else {
-			u32 diff=1;
-			if (compositor->ms_until_next_frame>0) diff = compositor->ms_until_next_frame;
-			gf_sc_step_clocks_intern(compositor, diff, GF_TRUE);
-		}
-		return;
-	}
-
-	/* nothing to change*/
-	if (compositor->play_state == PlayState) return;
-	compositor->play_state = PlayState;
-
-	if (compositor->root_scene->first_frame_pause_type && (PlayState == GF_STATE_PLAYING))
-		compositor->root_scene->first_frame_pause_type = 0;
-
-	if (!pause_clocks) return;
-
-	if (PlayState != GF_STATE_PLAYING) {
-		mediacontrol_pause(compositor->root_scene->root_od);
-	} else {
-		mediacontrol_resume(compositor->root_scene->root_od, resume_live);
-	}
-
-}
-
-
-GF_EXPORT
-void gf_sc_connect_from_time_ex(GF_Compositor *compositor, const char *URL, u64 startTime, u32 pause_at_first_frame, Bool secondary_scene, const char *parent_path)
-{
-	GF_Scene *scene;
-	GF_ObjectManager *odm;
-	if (!URL || !strlen(URL)) return;
-
-	if (compositor->root_scene) {
-		if (compositor->root_scene->root_od && compositor->root_scene->root_od->scene_ns) {
-			const char *main_url = compositor->root_scene->root_od->scene_ns->url;
-			if (main_url && !strcmp(main_url, URL)) {
-				gf_sc_play_from_time(compositor, 0, pause_at_first_frame);
-				return;
-			}
-		}
-		/*disconnect*/
-		gf_sc_disconnect(compositor);
-	}
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal Connecting to %s\n", URL));
-
-	assert(!compositor->root_scene);
-
-	/*create a new scene*/
-	scene = gf_scene_new(compositor, NULL);
-	odm = gf_odm_new();
-	scene->root_od = odm;
-	odm->subscene = scene;
-	//by default all scenes are dynamic, until we get a BIFS attached
-	scene->is_dynamic_scene = GF_TRUE;
-
-	odm->media_start_time = startTime;
-
-	// we are not in compositor:process at this point of time since the terminal thread drives the compositor
-	compositor->root_scene = scene;
-
-	/*render first visual frame and pause*/
-	if (pause_at_first_frame) {
-		gf_term_set_play_state(compositor, GF_STATE_STEP_PAUSE, 0, 0);
-		scene->first_frame_pause_type = pause_at_first_frame;
-	}
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal root scene created\n", URL));
-
-	if (!strnicmp(URL, "views://", 8)) {
-		gf_scene_generate_views(compositor->root_scene, (char *) URL+8, (char*)parent_path);
-		return;
-	}
-	else if (!strnicmp(URL, "mosaic://", 9)) {
-		gf_scene_generate_mosaic(compositor->root_scene, (char *) URL+9, (char*)parent_path);
-		return;
-	}
-
-	gf_scene_ns_connect_object(scene, odm, (char *) URL, (char*)parent_path, NULL);
-}
-
-
-GF_EXPORT
-Bool gf_term_is_type_supported(GF_Terminal *term, const char* mime)
-{
-	return gf_fs_is_supported_mime(term->fsess, mime);
-}
-
-//todo: move this to compositor ?
-static void gf_term_refresh_cache()
-{
-	u32 i, count;
-	count = gf_opts_get_section_count();
-	for (i=0; i<count; i++) {
-		const char *opt;
-		u32 sec, frac, exp;
-		Bool force_delete;
-		const char *file;
-		const char *name = gf_opts_get_section_name(i);
-		if (strncmp(name, "@cache=", 7)) continue;
-
-		file = gf_opts_get_key(name, "cacheFile");
-		opt = gf_opts_get_key(name, "expireAfterNTP");
-		if (!opt) {
-			if (file) gf_file_delete((char*) file);
-			gf_opts_del_section(name);
-			i--;
-			count--;
-			continue;
-		}
-
-		force_delete = 0;
-		if (file && gf_file_exists(file)) {
-			force_delete = 1;
-		}
-		sscanf(opt, "%u", &exp);
-		gf_net_get_ntp(&sec, &frac);
-		if (exp && (exp<sec)) force_delete=1;
-
-		if (force_delete) {
-			if (file) gf_file_delete(file);
-
-			gf_opts_del_section(name);
-			i--;
-			count--;
-			continue;
-		}
-	}
-}
-
-GF_EXPORT
-GF_Terminal *gf_term_new(GF_User *user)
-{
-	GF_Terminal *tmp;
-	GF_Filter *comp_filter;
-	u32 def_w, def_h;
-	GF_Err e;
-	const char *opt;
-	char szArgs200;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal Creating terminal\n"));
-
-	tmp = (GF_Terminal*)gf_malloc(sizeof(GF_Terminal));
-	if (!tmp) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPTIME, ("Terminal Failed to allocate GF_Terminal : OUT OF MEMORY ?\n"));
-		return NULL;
-	}
-	memset(tmp, 0, sizeof(GF_Terminal));
-
-	/*just for safety in case not done before*/
-	gf_sys_init(GF_MemTrackerNone, NULL);
-
-	tmp->user = user;
-
-	//for now we store the init_flags in the global config (used by compositor and AV output modules)
-	//cleaning this would need futher API rework and getting rid of the GF_User strcuture
-	sprintf(szArgs, "%d", user->init_flags);
-	gf_opts_set_key("Temp", "InitFlags", szArgs);
-
-	tmp->fsess = gf_fs_new_defaults(GF_FS_FLAG_NON_BLOCKING);
-	if (!tmp->fsess) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPTIME, ("Terminal Failed to create filter session.\n"));
-		gf_free(tmp);
-		return NULL;
-	}
-
-	gf_fs_set_ui_callback(tmp->fsess, user->EventProc, user->opaque);
-
-	opt = gf_opts_get_key("Temp", "DefaultWidth");
-	def_w = opt ? atoi(opt) : 0;
-	opt = gf_opts_get_key("Temp", "DefaultHeight");
-	def_h = opt ? atoi(opt) : 0;
-
-	if (def_w && def_h) {
-		sprintf(szArgs, "compositor:FID=compose:player=base:osize=%dx%d", def_w, def_h);
-	} else {
-		strcpy(szArgs, "compositor:FID=compose:player=base");
-	}
-
-	comp_filter = gf_fs_load_filter(tmp->fsess, szArgs, &e);
-	tmp->compositor = comp_filter ? gf_sc_from_filter(comp_filter) : NULL;
-	if (!tmp->compositor) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPTIME, ("Terminal Failed to load compositor filter: %s\n", gf_error_to_string(e) ));
-		gf_fs_del(tmp->fsess);
-		gf_free(tmp);
-		return NULL;
-	}
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal compositor loaded\n"));
-
-	gf_term_refresh_cache();
-	gf_fs_run(tmp->fsess);
-
-	return tmp;
-}
-
-GF_EXPORT
-GF_Err gf_term_del(GF_Terminal * term)
-{
-	if (!term) return GF_BAD_PARAM;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal Destroying terminal\n"));
-	/*close main service*/
-	gf_term_disconnect(term);
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal main service disconnected\n"));
-
-	term->in_destroy = GF_TRUE;
-	/*stop the media manager */
-	gf_fs_del(term->fsess);
-
-	gf_sys_close();
-	if (term->reload_url) gf_free(term->reload_url);
-	gf_free(term);
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal Terminal destroyed\n"));
-	return GF_OK;
-}
-
-GF_EXPORT
-void gf_term_connect_from_time(GF_Terminal * term, const char *URL, u64 startTime, u32 pause_at_first_frame)
-{
-	if (!term) return;
-	gf_sc_connect_from_time_ex(term->compositor, URL, startTime, pause_at_first_frame, 0, NULL);
-}
-
-GF_EXPORT
-void gf_term_connect(GF_Terminal * term, const char *URL)
-{
-	if (!term) return;
-	gf_sc_connect_from_time_ex(term->compositor, URL, 0, 0, 0, NULL);
-}
-
-
-GF_EXPORT
-void gf_term_connect_with_path(GF_Terminal * term, const char *URL, const char *parent_path)
-{
-	if (!term) return;
-	gf_sc_connect_from_time_ex(term->compositor, URL, 0, 0, 0, parent_path);
-}
-
-GF_EXPORT
-void gf_sc_disconnect(GF_Compositor *compositor)
-{
-	/*resume*/
-	if (compositor->play_state != GF_STATE_PLAYING) gf_term_set_play_state(compositor, GF_STATE_PLAYING, 1, 1);
-
-	if (compositor->root_scene && compositor->root_scene->root_od) {
-		GF_ObjectManager *root = compositor->root_scene->root_od;
-		gf_sc_lock(compositor, GF_TRUE);
-		compositor->root_scene = NULL;
-		gf_odm_disconnect(root, 2);
-		gf_sc_lock(compositor, GF_FALSE);
-	}
-}
-
-GF_EXPORT
-void gf_term_disconnect(GF_Terminal *term)
-{
-	if (term) gf_sc_disconnect(term->compositor);
-}
-
-GF_EXPORT
-const char *gf_term_get_url(GF_Terminal *term)
-{
-	GF_Compositor *compositor = term ? term->compositor : NULL;
-	if (!compositor || !compositor->root_scene || !compositor->root_scene->root_od || !compositor->root_scene->root_od->scene_ns) return NULL;
-	return compositor->root_scene->root_od->scene_ns->url;
-}
-
-GF_DownloadManager *gf_filter_get_download_manager(GF_Filter *filter);
-
-/*set rendering option*/
-GF_EXPORT
-GF_Err gf_term_set_option(GF_Terminal * term, u32 type, u32 value)
-{
-	if (!term) return GF_BAD_PARAM;
-	switch (type) {
-	case GF_OPT_PLAY_STATE:
-		gf_term_set_play_state(term->compositor, value, 0, 1);
-		return GF_OK;
-	case GF_OPT_HTTP_MAX_RATE:
-	{
-		GF_DownloadManager *dm = gf_filter_get_download_manager(term->compositor->filter);
-		if (!dm) return GF_SERVICE_ERROR;
-		gf_dm_set_data_rate(dm, value);
-		return GF_OK;
-	}
-	default:
-		return gf_sc_set_option(term->compositor, type, value);
-	}
-}
-
-GF_EXPORT
-Double gf_term_get_simulation_frame_rate(GF_Terminal *term, u32 *nb_frames_drawn)
-{
-	Double fps;
-	if (!term) return 0.0;
-	if (nb_frames_drawn) *nb_frames_drawn = term->compositor->frame_number;
-	fps = term->compositor->fps.num;
-	fps /= term->compositor->fps.den;
-	return fps;
-}
-
-
-
-/*get rendering option*/
-static
-u32 gf_sc_term_get_option(GF_Compositor *compositor, u32 type)
-{
-	if (!compositor) return 0;
-	switch (type) {
-	case GF_OPT_HAS_JAVASCRIPT:
-		return gf_sg_has_scripting();
-	case GF_OPT_IS_FINISHED:
-		return gf_sc_check_end_of_scene(compositor, 0);
-	case GF_OPT_IS_OVER:
-		return gf_sc_check_end_of_scene(compositor, 1);
-	case GF_OPT_MAIN_ADDON:
-		return compositor->root_scene ? compositor->root_scene->main_addon_selected : 0;
-
-	case GF_OPT_PLAY_STATE:
-		if (compositor->step_mode) return GF_STATE_STEP_PAUSE;
-		if (compositor->root_scene) {
-			GF_Clock *ck = compositor->root_scene->root_od->ck;
-			if (!ck) return GF_STATE_PAUSED;
-
-//			if (ck->Buffering) return GF_STATE_PLAYING;
-		}
-		if (compositor->play_state != GF_STATE_PLAYING) return GF_STATE_PAUSED;
-		return GF_STATE_PLAYING;
-	case GF_OPT_CAN_SELECT_STREAMS:
-		return (compositor->root_scene && compositor->root_scene->is_dynamic_scene) ? 1 : 0;
-	case GF_OPT_HTTP_MAX_RATE:
-	{
-		GF_DownloadManager *dm = gf_filter_get_download_manager(compositor->filter);
-		if (!dm) return 0;
-		return gf_dm_get_data_rate(dm);
-	}
-	case GF_OPT_VIDEO_BENCH:
-		return compositor->bench_mode ? GF_TRUE : GF_FALSE;
-	case GF_OPT_ORIENTATION_SENSORS_ACTIVE:
-		return compositor->orientation_sensors_active;
-	default:
-		return gf_sc_get_option(compositor, type);
-	}
-}
-
-/*get rendering option*/
-GF_EXPORT
-u32 gf_term_get_option(GF_Terminal * term, u32 type)
-{
-	return term ? gf_sc_term_get_option(term->compositor, type) : 0;
-}
-
-GF_EXPORT
-GF_Err gf_term_set_size(GF_Terminal * term, u32 NewWidth, u32 NewHeight)
-{
-	if (!term) return GF_BAD_PARAM;
-	return gf_sc_set_size(term->compositor, NewWidth, NewHeight);
-}
-
-typedef struct
-{
-	GF_ObjectManager *odm;
-	char *service_url, *parent_url;
-} GF_TermConnectObject;
-
-
-GF_EXPORT
-u32 gf_sc_play_from_time(GF_Compositor *compositor, u64 from_time, u32 pause_at_first_frame)
-{
-	if (!compositor || !compositor->root_scene || !compositor->root_scene->root_od) return 0;
-	if (compositor->root_scene->root_od->flags & GF_ODM_NO_TIME_CTRL) return 1;
-
-	if (pause_at_first_frame==2) {
-		if (gf_sc_term_get_option(compositor, GF_OPT_PLAY_STATE) != GF_STATE_PLAYING)
-			pause_at_first_frame = 1;
-		else
-			pause_at_first_frame = 0;
-	}
-
-	/*for dynamic scene OD resources are static and all object use the same clock, so don't restart the root
-	OD, just act as a mediaControl on all playing streams*/
-	if (compositor->root_scene->is_dynamic_scene) {
-
-		/*exit pause mode*/
-		gf_term_set_play_state(compositor, GF_STATE_PLAYING, 1, 1);
-
-		if (pause_at_first_frame)
-			gf_term_set_play_state(compositor, GF_STATE_STEP_PAUSE, 0, 0);
-
-		gf_sc_lock(compositor, 1);
-		gf_scene_restart_dynamic(compositor->root_scene, from_time, 0, 0);
-		gf_sc_lock(compositor, 0);
-		return 2;
-	}
-
-	/*pause everything*/
-	gf_term_set_play_state(compositor, GF_STATE_PAUSED, 0, 1);
-	/*stop root*/
-	gf_odm_stop(compositor->root_scene->root_od, 1);
-	gf_scene_disconnect(compositor->root_scene, 0);
-
-	compositor->root_scene->root_od->media_start_time = from_time;
-
-	gf_odm_start(compositor->root_scene->root_od);
-	gf_term_set_play_state(compositor, GF_STATE_PLAYING, 0, 1);
-	if (pause_at_first_frame)
-		gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
-	return 2;
-}
-
-GF_EXPORT
-u32 gf_term_play_from_time(GF_Terminal *term, u64 from_time, u32 pause_at_first_frame)
-{
-	return term ? gf_sc_play_from_time(term->compositor, from_time, pause_at_first_frame) : 0;
-}
-
-GF_EXPORT
-Bool gf_term_user_event(GF_Terminal * term, GF_Event *evt)
-{
-	if (term && !term->in_destroy) return gf_sc_user_event(term->compositor, evt);
-	return GF_FALSE;
-}
-
-
-GF_EXPORT
-Double gf_term_get_framerate(GF_Terminal *term, Bool absoluteFPS)
-{
-	if (!term || !term->compositor) return 0;
-	return gf_sc_get_fps(term->compositor, absoluteFPS);
-}
-
-/*get main scene current time in sec*/
-GF_EXPORT
-u32 gf_term_get_time_in_ms(GF_Terminal *term)
-{
-	GF_Clock *ck;
-	GF_Compositor *compositor = term ? term->compositor : NULL;
-	if (!term || !compositor->root_scene) return 0;
-	ck = compositor->root_scene->root_od->ck;
-	if (!ck) return 0;
-	return gf_clock_media_time(ck);
-}
-
-GF_EXPORT
-u32 gf_term_get_elapsed_time_in_ms(GF_Terminal *term)
-{
-	u32 i, count;
-	GF_Compositor *compositor = term ? term->compositor : NULL;
-	if (!term || !compositor->root_scene) return 0;
-
-	count = gf_list_count(compositor->root_scene->namespaces);
-	for (i=0; i<count; i++) {
-		GF_SceneNamespace *sns = gf_list_get(compositor->root_scene->namespaces, i);
-		GF_Clock *ck = gf_list_get(sns->clocks, 0);
-		if (ck) return gf_clock_elapsed_time(ck);
-	}
-	return 0;
-}
-
-GF_EXPORT
-void gf_term_navigate_to(GF_Terminal *term, const char *toURL)
-{
-	GF_Compositor *compositor = term ? term->compositor : NULL;
-	if (!term) return;
-	if (!toURL && !term->compositor->root_scene) return;
-
-	if (term->reload_url) gf_free(term->reload_url);
-	term->reload_url = NULL;
-
-	if (toURL) {
-		if (compositor->root_scene && compositor->root_scene->root_od && compositor->root_scene->root_od->scene_ns)
-			term->reload_url = gf_url_concatenate(compositor->root_scene->root_od->scene_ns->url, toURL);
-		if (!term->reload_url) term->reload_url = gf_strdup(toURL);
-	}
-	term->reload_state = 1;
-}
-
-GF_EXPORT
-GF_Err gf_term_get_viewpoint(GF_Terminal *term, u32 viewpoint_idx, const char **outName, Bool *is_bound)
-{
-	return gf_sc_get_viewpoint(term->compositor, viewpoint_idx, outName, is_bound);
-}
-
-GF_EXPORT
-GF_Err gf_term_set_viewpoint(GF_Terminal *term, u32 viewpoint_idx, const char *viewpoint_name)
-{
-	return gf_sc_set_viewpoint(term->compositor, viewpoint_idx, viewpoint_name);
-}
-
-GF_EXPORT
-GF_Err gf_term_add_object(GF_Terminal *term, const char *url, Bool auto_play)
-{
-	GF_MediaObject *mo=NULL;
-	//this needs refinement
-	SFURL sfurl;
-	MFURL mfurl;
-	if (!url || !term || !term->compositor->root_scene || !term->compositor->root_scene->is_dynamic_scene) return GF_BAD_PARAM;
-
-	sfurl.OD_ID = GF_MEDIA_EXTERNAL_ID;
-	sfurl.url = (char *) url;
-	mfurl.count = 1;
-	mfurl.vals = &sfurl;
-	/*only text tracks are supported for now...*/
-	mo = gf_scene_get_media_object(term->compositor->root_scene, &mfurl, GF_MEDIA_OBJECT_TEXT, 1);
-	if (mo) {
-		/*check if we must deactivate it*/
-		if (mo->odm) {
-			if (mo->num_open && !auto_play) {
-				gf_scene_select_object(term->compositor->root_scene, mo->odm);
-			}
-		} else {
-			gf_list_del_item(term->compositor->root_scene->scene_objects, mo);
-			gf_sg_vrml_mf_reset(&mo->URLs, GF_SG_VRML_MFURL);
-			gf_free(mo);
-			mo = NULL;
-		}
-	}
-	return mo ? GF_OK : GF_NOT_SUPPORTED;
-}
-
-
-GF_EXPORT
-GF_Err gf_term_scene_update(GF_Terminal *term, char *type, char *com)
-{
-#ifndef GPAC_DISABLE_SMGR
-	GF_Compositor *compositor = term ? term->compositor : NULL;
-	GF_Err e;
-	GF_StreamContext *sc;
-	Bool is_xml = 0;
-	Double time = 0;
-	u32 i, tag;
-	GF_SceneLoader load;
-
-	if (!term || !com) return GF_BAD_PARAM;
-
-	if (type && (!stricmp(type, "application/ecmascript") || !stricmp(type, "js")) ) {
-#if defined(GPAC_HAS_QJS) && !defined(GPAC_DISABLE_SVG)
-		u32 tag;
-		GF_Node *root = gf_sg_get_root_node(compositor->root_scene->graph);
-		if (!root) return GF_BAD_PARAM;
-		tag = gf_node_get_tag(root);
-		if (tag >= GF_NODE_RANGE_FIRST_SVG) {
-			if (compositor->root_scene->graph->svg_js) {
-				GF_Err svg_exec_script(struct __tag_svg_script_ctx *svg_js, GF_SceneGraph *sg, const char *com);
-				return svg_exec_script(compositor->root_scene->graph->svg_js, compositor->root_scene->graph, (char *)com);
-			}
-			return GF_NOT_FOUND;
-		}
-		return GF_NOT_SUPPORTED;
-#else
-		return GF_NOT_SUPPORTED;
-#endif
-	}
-
-	if (!type && !strncmp(com, "gpac ", 5)) {
-		com += 5;
-		//new add-on
-		if (compositor->root_scene && !strncmp(com, "add ", 4)) {
-			GF_AssociatedContentLocation addon_info;
-			memset(&addon_info, 0, sizeof(GF_AssociatedContentLocation));
-			addon_info.external_URL = com + 4;
-			addon_info.timeline_id = -100;
-			gf_scene_register_associated_media(compositor->root_scene, &addon_info);
-			return GF_OK;
-		}
-		//new splicing add-on
-		if (compositor->root_scene && !strncmp(com, "splice ", 7)) {
-			char *sep;
-			Double start, end;
-			Bool is_pts = GF_FALSE;
-			GF_AssociatedContentLocation addon_info;
-			memset(&addon_info, 0, sizeof(GF_AssociatedContentLocation));
-			com += 7;
-			if (!strnicmp(com, "pts ", 4)) {
-				is_pts = GF_TRUE;
-				com += 4;
-			}
-			sep = strchr(com, ':');
-			start = 0;
-			end = -1;
-			if (sep) {
-				sep0=0;
-				if (sscanf(com, "%lf-%lf", &start, &end) != 2) {
-					end = -1;
-					sscanf(com, "%lf", &start);
-				}
-				sep0=':';
-				addon_info.external_URL = sep+1;
-			}
-			//splice end, locate first splice with no end set and set it
-			else if (sscanf(com, "%lf", &end)==1) {
-				u32 count = gf_list_count(compositor->root_scene->declared_addons);
-				for (i=0; i<count; i++) {
-					GF_AddonMedia *addon = gf_list_get(compositor->root_scene->declared_addons, i);
-					if (addon->is_splicing && (addon->splice_end<0) ) {
-						addon->splice_end = end;
-						break;
-					}
-				}
-				return GF_OK;
-			} else {
-				//splice now, until end of spliced media
-				addon_info.external_URL = com;
-			}
-			addon_info.is_splicing = GF_TRUE;
-			addon_info.timeline_id = -100;
-			addon_info.splice_start_time = start;
-			addon_info.splice_end_time = end;
-			addon_info.splice_time_pts = is_pts;
-			gf_scene_register_associated_media(compositor->root_scene, &addon_info);
-			return GF_OK;
-		}
-		//select object
-		if (compositor->root_scene && !strncmp(com, "select ", 7)) {
-			u32 idx = atoi(com+7);
-			gf_term_select_object(term, gf_list_get(compositor->root_scene->resources, idx));
-			return GF_OK;
-		}
-		return GF_OK;
-	}
-
-	memset(&load, 0, sizeof(GF_SceneLoader));
-	load.localPath = gf_opts_get_key("core", "cache");
-	load.flags = GF_SM_LOAD_FOR_PLAYBACK | GF_SM_LOAD_CONTEXT_READY;
-	load.type = GF_SM_LOAD_BT;
-
-	if (!compositor->root_scene) {
-
-		/*create a new scene*/
-		compositor->root_scene = gf_scene_new(compositor, NULL);
-		compositor->root_scene->root_od = gf_odm_new();
-		compositor->root_scene->root_od->parentscene = NULL;
-		compositor->root_scene->root_od->subscene = compositor->root_scene;
-
-		load.ctx = gf_sm_new(compositor->root_scene->graph);
-	} else if (compositor->root_scene->root_od) {
-		u32 nb_ch = 0;
-		load.ctx = gf_sm_new(compositor->root_scene->graph);
-
-		if (compositor->root_scene->root_od->pid) nb_ch++;
-		if (compositor->root_scene->root_od->extra_pids) nb_ch += gf_list_count(compositor->root_scene->root_od->extra_pids);
-		for (i=0; i<nb_ch; i++) {
-			u32 stream_type, es_id, oti;
-			const GF_PropertyValue *p;
-			GF_FilterPid *pid = compositor->root_scene->root_od->pid;
-			if (i) {
-				GF_ODMExtraPid *xpid = gf_list_get(compositor->root_scene->root_od->extra_pids, i-1);
-				pid = xpid->pid;
-			}
-			p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
-			if (!p) continue;
-			stream_type = p->value.uint;
-			switch (stream_type) {
-			case GF_STREAM_OD:
-			case GF_STREAM_SCENE:
-			case GF_STREAM_PRIVATE_SCENE:
-				p = gf_filter_pid_get_property(pid, GF_PROP_PID_ESID);
-				if (!p)
-					p = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
-				es_id = p ? p->value.uint : 0;
-				p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
-				oti = p ? p->value.uint : 1;
-
-				sc = gf_sm_stream_new(load.ctx, es_id, stream_type, oti);
-				if (stream_type==GF_STREAM_PRIVATE_SCENE) sc->streamType = GF_STREAM_SCENE;
-				p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
-				sc->timeScale = p ? p->value.uint : 1000;
-				break;
-			}
-		}
-	} else {
-		return GF_BAD_PARAM;
-	}
-	load.ctx->max_node_id = gf_sg_get_max_node_id(compositor->root_scene->graph);
-
-	i=0;
-	while ((comi == ' ') || (comi == '\r') || (comi == '\n') || (comi == '\t')) i++;
-	if (comi=='<') is_xml = 1;
-
-	load.type = is_xml ? GF_SM_LOAD_XMTA : GF_SM_LOAD_BT;
-	time = gf_scene_get_time(compositor->root_scene);
-
-
-	if (type && (!stricmp(type, "application/x-laser+xml") || !stricmp(type, "laser"))) {
-		load.type = GF_SM_LOAD_XSR;
-		time = gf_scene_get_time(compositor->root_scene);
-	}
-	else if (type && (!stricmp(type, "image/svg+xml") || !stricmp(type, "svg")) ) {
-		load.type = GF_SM_LOAD_XSR;
-		time = gf_scene_get_time(compositor->root_scene);
-	}
-	else if (type && (!stricmp(type, "model/x3d+xml") || !stricmp(type, "x3d")) ) load.type = GF_SM_LOAD_X3D;
-	else if (type && (!stricmp(type, "model/x3d+vrml") || !stricmp(type, "x3dv")) ) load.type = GF_SM_LOAD_X3DV;
-	else if (type && (!stricmp(type, "model/vrml") || !stricmp(type, "vrml")) ) load.type = GF_SM_LOAD_VRML;
-	else if (type && (!stricmp(type, "application/x-xmt") || !stricmp(type, "xmt")) ) load.type = GF_SM_LOAD_XMTA;
-	else if (type && (!stricmp(type, "application/x-bt") || !stricmp(type, "bt")) ) load.type = GF_SM_LOAD_BT;
-	else if (gf_sg_get_root_node(compositor->root_scene->graph)) {
-		tag = gf_node_get_tag(gf_sg_get_root_node(compositor->root_scene->graph));
-		if (tag >= GF_NODE_RANGE_FIRST_SVG) {
-			load.type = GF_SM_LOAD_XSR;
-			time = gf_scene_get_time(compositor->root_scene);
-		} else if (tag>=GF_NODE_RANGE_FIRST_X3D) {
-			load.type = is_xml ? GF_SM_LOAD_X3D : GF_SM_LOAD_X3DV;
-		} else {
-			load.type = is_xml ? GF_SM_LOAD_XMTA : GF_SM_LOAD_BT;
-			time = gf_scene_get_time(compositor->root_scene);
-		}
-	}
-
-	e = gf_sm_load_init(&load);
-	if (!e) e = gf_sm_load_string(&load, com, 1);
-	gf_sm_load_done(&load);
-	if (!e) {
-		u32 j, au_count, st_count;
-		st_count = gf_list_count(load.ctx->streams);
-		for (i=0; i<st_count; i++) {
-			sc = (GF_StreamContext*)gf_list_get(load.ctx->streams, i);
-			au_count = gf_list_count(sc->AUs);
-			for (j=0; j<au_count; j++) {
-				GF_AUContext *au = (GF_AUContext *)gf_list_get(sc->AUs, j);
-				e = gf_sg_command_apply_list(compositor->root_scene->graph, au->commands, time);
-				if (e) break;
-			}
-		}
-	}
-	if (!compositor->root_scene->graph_attached) {
-		if (!load.ctx->scene_width || !load.ctx->scene_height) {
-//			load.ctx->scene_width = term->compositor->width;
-//			load.ctx->scene_height = term->compositor->height;
-		}
-		gf_sg_set_scene_size_info(compositor->root_scene->graph, load.ctx->scene_width, load.ctx->scene_height, load.ctx->is_pixel_metrics);
-		gf_scene_attach_to_compositor(compositor->root_scene);
-	}
-	gf_sm_del(load.ctx);
-	return e;
-#else
-	return GF_NOT_SUPPORTED;
-#endif
-}
-
-GF_EXPORT
-GF_Err gf_term_get_screen_buffer(GF_Terminal *term, GF_VideoSurface *framebuffer)
-{
-	if (!term) return GF_BAD_PARAM;
-	return gf_sc_get_screen_buffer(term->compositor, framebuffer, 0);
-}
-
-GF_EXPORT
-GF_Err gf_term_get_offscreen_buffer(GF_Terminal *term, GF_VideoSurface *framebuffer, u32 view_idx, GF_CompositorGrabMode depth_buffer_type)
-{
-	if (!term) return GF_BAD_PARAM;
-	return gf_sc_get_offscreen_buffer(term->compositor, framebuffer, view_idx, depth_buffer_type);
-}
-
-GF_EXPORT
-GF_Err gf_term_release_screen_buffer(GF_Terminal *term, GF_VideoSurface *framebuffer)
-{
-	if (!term) return GF_BAD_PARAM;
-	return gf_sc_release_screen_buffer(term->compositor, framebuffer);
-}
-
-GF_EXPORT
-const char *gf_term_get_text_selection(GF_Terminal *term, Bool probe_only)
-{
-	Bool has_text;
-	if (!term) return NULL;
-	has_text = gf_sc_has_text_selection(term->compositor);
-	if (!has_text) return NULL;
-	if (probe_only) return "";
-	return gf_sc_get_selected_text(term->compositor);
-}
-
-
-GF_EXPORT
-GF_Err gf_term_paste_text(GF_Terminal *term, const char *txt, Bool probe_only)
-{
-	if (!term) return GF_BAD_PARAM;
-	if (probe_only) return gf_sc_paste_text(term->compositor, NULL);
-	return gf_sc_paste_text(term->compositor, txt);
-}
-
-
-GF_EXPORT
-GF_Err gf_term_set_speed(GF_Terminal *term, Fixed speed)
-{
-	GF_Fraction fps;
-	u32 i, j;
-	GF_SceneNamespace *ns;
-	Bool restart = 0;
-	u32 scene_time = gf_term_get_time_in_ms(term);
-
-	if (!term || !speed) return GF_BAD_PARAM;
-
-	if (speed<0) {
-		i=0;
-		while ( (ns = (GF_SceneNamespace*)gf_list_enum(term->compositor->root_scene->namespaces, &i)) ) {
-			u32 k=0;
-			GF_ObjectManager *odm;
-			if (!ns->owner || !ns->owner->subscene) continue;
-
-			while ( (odm = gf_list_enum(ns->owner->subscene->resources, &k))) {
-				const GF_PropertyValue *p = gf_filter_pid_get_property(odm->pid, GF_PROP_PID_PLAYBACK_MODE);
-				if (!p || (p->value.uint!=GF_PLAYBACK_MODE_REWIND))
-					return GF_NOT_SUPPORTED;
-			}
-		}
-	}
-
-	/*adjust all clocks on all services, if possible*/
-	i=0;
-	while ( (ns = (GF_SceneNamespace*)gf_list_enum(term->compositor->root_scene->namespaces, &i)) ) {
-		GF_Clock *ck;
-		ns->set_speed = speed;
-		j=0;
-		while (ns->clocks && (ck = (GF_Clock *)gf_list_enum(ns->clocks, &j)) ) {
-			//we will have to reissue a PLAY command since playback direction changed
-			if ( gf_mulfix(ck->speed,speed) < 0)
-				restart = 1;
-			gf_clock_set_speed(ck, speed);
-
-			if (ns->owner) {
-				gf_odm_set_speed(ns->owner, speed, GF_FALSE);
-				if (ns->owner->subscene) {
-					u32 k=0;
-					GF_ObjectManager *odm;
-					GF_Scene *scene = ns->owner->subscene;
-					while ( (odm = gf_list_enum(scene->resources, &k))) {
-						gf_odm_set_speed(odm, speed, GF_FALSE);
-					}
-				}
-			}
-		}
-	}
-
-	if (restart) {
-		if (term->compositor->root_scene->is_dynamic_scene) {
-			gf_scene_restart_dynamic(term->compositor->root_scene, scene_time, 0, 0);
-		}
-	}
-
-	if (speed<0)
-		speed = -speed;
-
-	fps = term->compositor->fps;
-	if (fps.den<1000) {
-		fps.num = fps.num * (u32) (1000 * FIX2FLT(speed));
-		fps.den *= 1000;
-	} else {
-		fps.num = (u32) (fps.num * FIX2FLT(speed));
-	}
-	gf_media_get_reduced_frame_rate(&fps.num, &fps.den);
-	gf_sc_set_fps(term->compositor, fps);
-	return GF_OK;
-}
-
-#if 0 //no more support for shortcuts in MP4 client, this must be done through GUI
-
-enum
-{
-	GF_ACTION_PLAY,
-	GF_ACTION_STOP,
-	GF_ACTION_STEP,
-	GF_ACTION_EXIT,
-	GF_ACTION_MUTE,
-	GF_ACTION_VOLUP,
-	GF_ACTION_VOLDOWN,
-	GF_ACTION_JUMP_FORWARD,
-	GF_ACTION_JUMP_BACKWARD,
-	GF_ACTION_JUMP_START,
-	GF_ACTION_JUMP_END,
-	GF_ACTION_VERY_FAST_FORWARD,
-	GF_ACTION_FAST_FORWARD,
-	GF_ACTION_SLOW_FORWARD,
-	GF_ACTION_VERY_FAST_REWIND,
-	GF_ACTION_FAST_REWIND,
-	GF_ACTION_SLOW_REWIND,
-	GF_ACTION_NEXT,
-	GF_ACTION_PREVIOUS,
-	GF_ACTION_QUALITY_UP,
-	GF_ACTION_QUALITY_DOWN,
-};
-
-#define	MAX_SHORTCUTS	200
-
-typedef struct
-{
-	u8 code;
-	u8 mods;
-	u8 action;
-} GF_Shortcut;
-
-static void set_clocks_speed(GF_Compositor *compositor, Fixed ratio)
-{
-	u32 i, j;
-	GF_SceneNamespace *ns;
-
-	/*pause all clocks on all services*/
-	i=0;
-	while ( (ns = (GF_SceneNamespace*)gf_list_enum(compositor->root_scene->namespaces, &i)) ) {
-		GF_Clock *ck;
-		j=0;
-		while ( (ck = (GF_Clock *)gf_list_enum(ns->Clocks, &j)) ) {
-			Fixed s = gf_mulfix(ck->speed, ratio);
-			gf_clock_set_speed(ck, s);
-		}
-	}
-}
-
-void gf_term_process_shortcut(GF_Terminal *term, GF_Event *ev)
-{
-	GF_Event evt;
-	if (ev->type==GF_EVENT_KEYDOWN) {
-		u32 i;
-		u8 mod = 0;
-		if (ev->key.flags & GF_KEY_MOD_CTRL) mod |= GF_KEY_MOD_CTRL;
-		if (ev->key.flags & GF_KEY_MOD_ALT) mod |= GF_KEY_MOD_ALT;
-
-		for (i=0; i<MAX_SHORTCUTS; i++) {
-			u32 val;
-			if (!term->shortcutsi.code) break;
-			if (term->shortcutsi.mods!=mod) continue;
-			if (term->shortcutsi.code!=ev->key.key_code) continue;
-
-			switch (term->shortcutsi.action) {
-			case GF_ACTION_PLAY:
-				if (gf_term_get_option(term, GF_OPT_PLAY_STATE) == GF_STATE_PAUSED) {
-					gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PLAYING);
-				} else if (term->speed_ratio != FIX_ONE) {
-					set_clocks_speed(term, gf_divfix(1, term->speed_ratio) );
-					term->speed_ratio = FIX_ONE;
-				} else {
-					gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PAUSED);
-				}
-				break;
-			case GF_ACTION_STOP:
-				gf_term_play_from_time(term, 0, 1);
-				break;
-			case GF_ACTION_NEXT:
-				evt.type = GF_EVENT_KEYDOWN;
-				evt.key.key_code = GF_KEY_MEDIANEXTTRACK;
-				gf_term_send_event(term, &evt);
-				break;
-			case GF_ACTION_PREVIOUS:
-				evt.type = GF_EVENT_KEYDOWN;
-				evt.key.key_code = GF_KEY_MEDIAPREVIOUSTRACK;
-				gf_term_send_event(term, &evt);
-				break;
-
-			case GF_ACTION_STEP:
-				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
-				break;
-			case GF_ACTION_EXIT:
-				memset(&evt, 0, sizeof(GF_Event));
-				evt.type = GF_EVENT_QUIT;
-				gf_term_send_event(term, &evt);
-				break;
-			case GF_ACTION_MUTE:
-				gf_term_set_option(term, GF_OPT_AUDIO_MUTE, gf_term_get_option(term, GF_OPT_AUDIO_MUTE) ? 0 : 1);
-				break;
-			case GF_ACTION_VOLUP:
-				val = gf_term_get_option(term, GF_OPT_AUDIO_VOLUME);
-				if (val<95) val += 5;
-				else val = 100;
-				gf_term_set_option(term, GF_OPT_AUDIO_VOLUME, val);
-				break;
-			case GF_ACTION_VOLDOWN:
-				val = gf_term_get_option(term, GF_OPT_AUDIO_VOLUME);
-				if (val>5) val -= 5;
-				else val = 0;
-				gf_term_set_option(term, GF_OPT_AUDIO_VOLUME, val);
-				break;
-			case GF_ACTION_JUMP_FORWARD:
-			case GF_ACTION_JUMP_BACKWARD:
-			case GF_ACTION_VERY_FAST_REWIND:
-			case GF_ACTION_FAST_REWIND:
-			case GF_ACTION_SLOW_REWIND:
-				if (0 && term->root_scene && !(term->root_scene->root_od->flags & GF_ODM_NO_TIME_CTRL) ) {
-					s32 res;
-					u32 dur = (u32) term->root_scene->duration ;
-					val = gf_term_get_time_in_ms(term);
-					res = val;
-					switch (term->shortcutsi.action) {
-					case GF_ACTION_JUMP_BACKWARD:
-					case GF_ACTION_FAST_REWIND:
-						res -= (s32) (5*dur/100);
-						if (res<0) res = 0;
-						break;
-					case GF_ACTION_VERY_FAST_REWIND:
-						res -= (s32) (10*dur/100);
-						if (res<0) res = 0;
-						break;
-					case GF_ACTION_SLOW_REWIND:
-						res -= (s32) (dur/100);
-						if (res<0) res = 0;
-						break;
-					default:
-						res += (s32) (5*dur/100);
-						if (res > (s32)dur) res = dur;
-						break;
-					}
-					gf_term_play_from_time(term, res, 2);
-				}
-				break;
-			case GF_ACTION_JUMP_START:
-				if (term->root_scene && !(term->root_scene->root_od->flags & GF_ODM_NO_TIME_CTRL) ) {
-					gf_term_play_from_time(term, 0, 2);
-				}
-				break;
-			case GF_ACTION_JUMP_END:
-				if (term->root_scene && !(term->root_scene->root_od->flags & GF_ODM_NO_TIME_CTRL) ) {
-					gf_term_play_from_time(term, term->root_scene->duration, 2);
-				}
-				break;
-			case GF_ACTION_VERY_FAST_FORWARD:
-			case GF_ACTION_FAST_FORWARD:
-			case GF_ACTION_SLOW_FORWARD:
-				if (term->speed_ratio != FIX_ONE) {
-					set_clocks_speed(term, gf_divfix(1, term->speed_ratio) );
-					term->speed_ratio = FIX_ONE;
-				}
-				else {
-					switch (term->shortcutsi.action) {
-					case GF_ACTION_VERY_FAST_FORWARD:
-						term->speed_ratio = INT2FIX(4);
-						break;
-					case GF_ACTION_FAST_FORWARD:
-						term->speed_ratio = INT2FIX(2);
-						break;
-					case GF_ACTION_SLOW_FORWARD:
-						term->speed_ratio = INT2FIX(1)/4;
-						break;
-					}
-					set_clocks_speed(term, term->speed_ratio);
-				}
-				break;
-			case GF_ACTION_QUALITY_UP:
-				gf_term_switch_quality(term, 1);
-				break;
-			case GF_ACTION_QUALITY_DOWN:
-				gf_term_switch_quality(term, 0);
-				break;
-			}
-			break;
-		}
-	}
-}
-
-void gf_term_load_shortcuts(GF_Terminal *term)
-{
-	char szVal51;
-	u32 i, k, count;
-
-	memset(term->shortcuts, 0, sizeof(GF_Shortcut)*MAX_SHORTCUTS);
-	count = gf_opts_get_key_count("Shortcuts");
-	k = 0;
-	for (i=0; i<count; i++) {
-		char *name = (char*)gf_opts_get_key_name("Shortcuts", i);
-		char *val = (char*)gf_opts_get_key("Shortcuts", name);
-		if (!name || !val) continue;
-
-		strncpy(szVal, val, 50);
-		szVal50 = 0;
-		strlwr(szVal);
-		val = szVal;
-
-		while (strchr(val, '+')) {
-			if (!strnicmp(val, "ctrl+", 5)) {
-				val += 5;
-				term->shortcutsk.mods |= GF_KEY_MOD_CTRL;
-			}
-			if (!strnicmp(val, "alt+", 4)) {
-				val += 4;
-				term->shortcutsk.mods |= GF_KEY_MOD_ALT;
-			}
-		}
-#ifndef GPAC_DISABLE_SVG
-		term->shortcutsk.code = gf_dom_get_key_type((char *)val);
-#endif
-		if (!term->shortcutsk.code) continue;
-
-		if (!stricmp(name, "Play") || !stricmp(name, "Pause")) term->shortcutsk.action = GF_ACTION_PLAY;
-		else if (!stricmp(name, "Stop")) term->shortcutsk.action = GF_ACTION_STOP;
-		else if (!stricmp(name, "Step")) term->shortcutsk.action = GF_ACTION_STEP;
-		else if (!stricmp(name, "Exit")) term->shortcutsk.action = GF_ACTION_EXIT;
-		else if (!stricmp(name, "Mute")) term->shortcutsk.action = GF_ACTION_MUTE;
-		else if (!stricmp(name, "VolumeUp")) term->shortcutsk.action = GF_ACTION_VOLUP;
-		else if (!stricmp(name, "VolumeDown")) term->shortcutsk.action = GF_ACTION_VOLDOWN;
-		else if (!stricmp(name, "JumpForward")) term->shortcutsk.action = GF_ACTION_JUMP_FORWARD;
-		else if (!stricmp(name, "JumpBackward")) term->shortcutsk.action = GF_ACTION_JUMP_BACKWARD;
-		else if (!stricmp(name, "JumpStart")) term->shortcutsk.action = GF_ACTION_JUMP_START;
-		else if (!stricmp(name, "JumpEnd")) term->shortcutsk.action = GF_ACTION_JUMP_END;
-		else if (!stricmp(name, "VeryFastForward")) term->shortcutsk.action = GF_ACTION_VERY_FAST_FORWARD;
-		else if (!stricmp(name, "FastForward")) term->shortcutsk.action = GF_ACTION_FAST_FORWARD;
-		else if (!stricmp(name, "SlowForward")) term->shortcutsk.action = GF_ACTION_SLOW_FORWARD;
-		else if (!stricmp(name, "VeryFastRewind")) term->shortcutsk.action = GF_ACTION_VERY_FAST_REWIND;
-		else if (!stricmp(name, "FastRewind")) term->shortcutsk.action = GF_ACTION_FAST_REWIND;
-		else if (!stricmp(name, "SlowRewind")) term->shortcutsk.action = GF_ACTION_SLOW_REWIND;
-		else if (!stricmp(name, "Next")) term->shortcutsk.action = GF_ACTION_NEXT;
-		else if (!stricmp(name, "Previous")) term->shortcutsk.action = GF_ACTION_PREVIOUS;
-		else if (!stricmp(name, "QualityUp")) term->shortcutsk.action = GF_ACTION_QUALITY_UP;
-		else if (!stricmp(name, "QualityDown")) term->shortcutsk.action = GF_ACTION_QUALITY_DOWN;
-		else {
-			term->shortcutsk.mods = 0;
-			term->shortcutsk.code = 0;
-			continue;
-		}
-		k++;
-		if (k==MAX_SHORTCUTS) break;
-	}
-}
-#endif
-
-
-GF_EXPORT
-void gf_term_switch_quality(GF_Terminal *term, Bool up)
-{
-	if (term)
-		gf_scene_switch_quality(term->compositor->root_scene, up);
-}
-
-GF_EXPORT
-GF_Err gf_term_get_visual_output_size(GF_Terminal *term, u32 *width, u32 *height)
-{
-	if (!term) return GF_BAD_PARAM;
-	if (width) *width = term->compositor->display_width;
-	if (height) *height = term->compositor->display_height;
-	return GF_OK;
-}
-
-GF_EXPORT
-Bool gf_term_process_step(GF_Terminal *term)
-{
-
-	term->compositor->frame_was_produced = GF_FALSE;
-	/*need to reload*/
-	if (term->reload_state == 1) {
-		term->reload_state = 0;
-		gf_term_disconnect(term);
-		term->reload_state = 2;
-	}
-	if (term->reload_state == 2) {
-		if (!term->compositor->root_scene) {
-			term->reload_state = 0;
-			if (term->reload_url) {
-				gf_term_connect(term, term->reload_url);
-				gf_free(term->reload_url);
-			}
-			term->reload_url = NULL;
-		}
-	}
-
-	gf_fs_run(term->fsess);
-	return term->compositor->frame_was_produced;
-}
-
-static Bool check_in_scene(GF_Scene *scene, GF_ObjectManager *odm)
-{
-	u32 i;
-	GF_ObjectManager *ptr, *root;
-	if (!scene) return 0;
-	root = scene->root_od;
-	if (odm == root) return 1;
-	scene = root->subscene;
-
-	i=0;
-	while ((ptr = (GF_ObjectManager *)gf_list_enum(scene->resources, &i))) {
-		if (ptr == odm) return 1;
-		if (check_in_scene(ptr->subscene, odm)) return 1;
-	}
-	return 0;
-}
-
-static Bool gf_term_check_odm(GF_Terminal *term, GF_ObjectManager *odm)
-{
-	if (!term->compositor->root_scene) return 0;
-	return check_in_scene(term->compositor->root_scene, odm);
-}
-
-
-/*returns top-level OD of the presentation*/
-GF_EXPORT
-GF_ObjectManager *gf_term_get_root_object(GF_Terminal *term)
-{
-	if (!term) return NULL;
-	if (!term->compositor->root_scene) return NULL;
-	return term->compositor->root_scene->root_od;
-}
-
-/*returns number of sub-ODs in the current root. scene_od must be an inline OD*/
-GF_EXPORT
-u32 gf_term_get_object_count(GF_Terminal *term, GF_ObjectManager *scene_od)
-{
-	if (!term || !scene_od) return 0;
-	if (!gf_term_check_odm(term, scene_od)) return 0;
-	if (!scene_od->subscene) return 0;
-	return gf_list_count(scene_od->subscene->resources);
-}
-
-/*returns indexed (0-based) OD manager in the scene*/
-GF_EXPORT
-GF_ObjectManager *gf_term_get_object(GF_Terminal *term, GF_ObjectManager *scene_od, u32 index)
-{
-	if (!term || !scene_od) return NULL;
-	if (!gf_term_check_odm(term, scene_od)) return NULL;
-	if (!scene_od->subscene) return NULL;
-	return (GF_ObjectManager *) gf_list_get(scene_od->subscene->resources, index);
-}
-
-GF_EXPORT
-u32 gf_term_object_subscene_type(GF_Terminal *term, GF_ObjectManager *odm)
-{
-	if (!term || !odm) return 0;
-	if (!gf_term_check_odm(term, odm)) return 0;
-
-	if (!odm->subscene) return 0;
-#ifndef GPAC_DISABLE_VRML
-	if (odm->parentscene) {
-
-		u32 i=0;
-		GF_ProtoLink *pl;
-		i=0;
-		while ((pl = (GF_ProtoLink*)gf_list_enum(odm->parentscene->extern_protos, &i))) {
-			if (pl->mo->odm == odm) return 3;
-		}
-		return 2;
-	}
-	
-#endif
-	return 1;
-}
-
-/*select given object when stream selection is available*/
-GF_EXPORT
-void gf_term_select_object(GF_Terminal *term, GF_ObjectManager *odm)
-{
-	if (!term || !odm) return;
-	if (!gf_term_check_odm(term, odm)) return;
-
-	gf_scene_select_object(term->compositor->root_scene, odm);
-}
-
-
-/*select given object when stream selection is available*/
-GF_EXPORT
-void gf_term_select_service(GF_Terminal *term, GF_ObjectManager *odm, u32 service_id)
-{
-	if (!term || !odm || !odm->subscene) return;
-	if (!gf_term_check_odm(term, odm)) return;
-
-#ifndef GPAC_DISABLE_VRML
-	gf_scene_set_service_id(odm->subscene, service_id);
-#endif
-}
-
-GF_EXPORT
-Bool gf_term_find_service(GF_Terminal *term, GF_ObjectManager *odm, u32 service_id)
-{
-	u32 i;
-	GF_ObjectManager *anodm;
-	if (!term || !odm || !odm->subscene) return GF_FALSE;
-	if (!gf_term_check_odm(term, odm)) return GF_FALSE;
-
-	i=0;
-	while ((anodm = gf_list_enum(odm->subscene->resources, &i))) {
-		if (anodm->ServiceID==service_id) return GF_TRUE;
-	}
-	return GF_FALSE;
-}
-
-/*select given object when stream selection is available*/
-GF_EXPORT
-void gf_term_toggle_addons(GF_Terminal *term, Bool show_addons)
-{
-	if (!term || !term->compositor->root_scene || !term->compositor->root_scene->is_dynamic_scene) return;
-#ifndef GPAC_DISABLE_VRML
-	gf_scene_toggle_addons(term->compositor->root_scene, show_addons);
-#endif
-}
-
-GF_EXPORT
-u32 gf_term_get_current_service_id(GF_Terminal *term)
-{
-	SFURL *the_url;
-	GF_MediaObject *mo;
-	GF_Compositor *compositor = term ? term->compositor : NULL;
-	if (!term || !term->compositor->root_scene) return 0;
-	if (! term->compositor->root_scene->is_dynamic_scene) return term->compositor->root_scene->root_od->ServiceID;
-
-	if (compositor->root_scene->visual_url.OD_ID || compositor->root_scene->visual_url.url)
-		the_url = &compositor->root_scene->visual_url;
-	else
-		the_url = &compositor->root_scene->audio_url;
-
-	mo = gf_scene_find_object(compositor->root_scene, the_url->OD_ID, the_url->url);
-	if (mo && mo->odm) return mo->odm->ServiceID;
-	return 0;
-}
-
-
-
-
-GF_EXPORT
-GF_Err gf_term_get_object_info(GF_Terminal *term, GF_ObjectManager *odm, GF_MediaInfo *info)
-{
-	if (!term || !odm || !info) return GF_BAD_PARAM;
-	if (!gf_term_check_odm(term, odm)) return GF_BAD_PARAM;
-	return gf_odm_get_object_info(odm, info);
-}
-
-
-GF_EXPORT
-Bool gf_term_get_download_info(GF_Terminal *term, GF_ObjectManager *odm, u32 *d_enum, const char **url, u32 *bytes_done, u32 *total_bytes, u32 *bytes_per_sec)
-{
-	u32 nb_ch;
-	const GF_PropertyValue *p;
-	GF_PropertyEntry *pe=NULL;
-	GF_FilterPid *pid=NULL;
-	if (!term || !odm || !gf_term_check_odm(term, odm)) return GF_FALSE;
-	if (odm->scene_ns->owner != odm)
-		return GF_FALSE;
-
-	nb_ch = odm->pid ? 1 : 0;
-	if (odm->extra_pids)
-	 	nb_ch += gf_list_count(odm->extra_pids);
-
-	if (!nb_ch) {
-		GF_ObjectManager *anodm;
-		if (*d_enum || !odm->subscene) return GF_FALSE;
-		anodm = gf_list_get(odm->subscene->resources, 0);
-		if (anodm) pid = anodm->pid;
-	} else {
-
-		if (*d_enum >= nb_ch) return GF_FALSE;
-		if (! *d_enum) pid = odm->pid;
-		else pid = gf_list_get(odm->extra_pids, *d_enum - 1);
-	}
-	if (!pid) return GF_FALSE;
-
-	(*d_enum) ++;
-
-	p = gf_filter_pid_get_info(pid, GF_PROP_PID_DOWN_RATE, &pe);
-	if (p && bytes_per_sec) {
-		*bytes_per_sec = p->value.uint;
-		*bytes_per_sec /= 8;
-	}
-
-	p = gf_filter_pid_get_info(pid, GF_PROP_PID_DOWN_BYTES, &pe);
-	if (p && bytes_done) *bytes_done = (u32) p->value.longuint;
-
-	p = gf_filter_pid_get_info(pid, GF_PROP_PID_DOWN_SIZE, &pe);
-	if (p && total_bytes) *total_bytes = (u32) p->value.longuint;
-
-	p = gf_filter_pid_get_info(pid, GF_PROP_PID_URL, &pe);
-	if (p && url) *url = p->value.string;
-
-	gf_filter_release_property(pe);
-
-	return GF_TRUE;
-}
-
-GF_EXPORT
-Bool gf_term_get_channel_net_info(GF_Terminal *term, GF_ObjectManager *odm, u32 *d_enum, u32 *chid, GF_TermNetStats *net_stats, GF_Err *ret_code)
-{
-	u32 nb_ch;
-	const GF_PropertyValue *p;
-	GF_PropertyEntry *pe=NULL;
-	GF_FilterPid *pid;
-	if (!term || !odm || !gf_term_check_odm(term, odm)) return GF_FALSE;
-
-	nb_ch = odm->pid ? 1 : 0;
-	if (odm->extra_pids)
-	 	nb_ch += gf_list_count(odm->extra_pids);
-
-	if (*d_enum >= nb_ch) return GF_FALSE;
-	if (! *d_enum) pid = odm->pid;
-	else pid = gf_list_get(odm->extra_pids, *d_enum - 1);
-	if (!pid) return GF_FALSE;
-	(*d_enum) ++;
-
-	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
-	if (p) (*chid) = p->value.uint;
-
-	(*ret_code) = GF_OK;
-
-	memset(net_stats, 0, sizeof(GF_TermNetStats));
-	p = gf_filter_pid_get_info_str(pid, "nets:loss", &pe);
-	if (p) net_stats->pck_loss_percentage = p->value.fnumber;
-
-	p = gf_filter_pid_get_info_str(pid, "nets:interleaved", &pe);
-	if (p) {
-		net_stats->multiplex_port = p->value.uint;
-		p = gf_filter_pid_get_info_str(pid, "nets:rtpid", &pe);
-		if (p) net_stats->port = p->value.uint;
-		p = gf_filter_pid_get_info_str(pid, "nets:rtcpid", &pe);
-		if (p) net_stats->ctrl_port = p->value.uint;
-	} else {
-		p = gf_filter_pid_get_info_str(pid, "nets:rtpp", &pe);
-		if (p) net_stats->port = p->value.uint;
-		p = gf_filter_pid_get_info_str(pid, "nets:rtcpp", &pe);
-		if (p) net_stats->ctrl_port = p->value.uint;
-	}
-
-	p = gf_filter_pid_get_info_str(pid, "nets:bw_down", &pe);
-	if (p) net_stats->bw_down = p->value.uint;
-	p = gf_filter_pid_get_info_str(pid, "nets:bw_up", &pe);
-	if (p) net_stats->bw_up = p->value.uint;
-	p = gf_filter_pid_get_info_str(pid, "nets:ctrl_bw_down", &pe);
-	if (p) net_stats->ctrl_bw_down = p->value.uint;
-	p = gf_filter_pid_get_info_str(pid, "nets:ctrl_bw_up", &pe);
-	if (p) net_stats->ctrl_bw_up = p->value.uint;
-
-	gf_filter_release_property(pe);
-	return GF_TRUE;
-}
-
-GF_EXPORT
-GF_Err gf_term_get_service_info(GF_Terminal *term, GF_ObjectManager *odm, GF_TermURLInfo *urli)
-{
-	const GF_PropertyValue *p;
-	GF_PropertyEntry *pe=NULL;
-	GF_FilterPid *pid;
-	if (urli) memset(urli, 0, sizeof(GF_TermURLInfo));
-	if (!term || !odm || !urli || !gf_term_check_odm(term, odm)) return GF_BAD_PARAM;
-
-	pid = odm->pid;
-	if (!pid && odm->subscene) {
-		GF_ObjectManager *anodm = gf_list_get(odm->subscene->resources, 0);
-		if (!anodm) return GF_OK;
-		pid = anodm->pid;
-	}
-	if (!pid) return GF_OK;
-
-	memset(urli, 0, sizeof(GF_TermURLInfo));
-
-	p = gf_filter_pid_get_info_str(pid, "info:name", &pe);
-	if (p) urli->name = p->value.string;
-
-	p = gf_filter_pid_get_info_str(pid, "info:artist", &pe);
-	if (p) urli->artist = p->value.string;
-
-	p = gf_filter_pid_get_info_str(pid, "info:album", &pe);
-	if (p) urli->album = p->value.string;
-
-	p = gf_filter_pid_get_info_str(pid, "info:comment", &pe);
-	if (p) urli->comment = p->value.string;
-
-	p = gf_filter_pid_get_info_str(pid, "info:composer", &pe);
-	if (p) urli->composer = p->value.string;
-
-	p = gf_filter_pid_get_info_str(pid, "info:writer", &pe);
-	if (p) urli->writer = p->value.string;
-
-	p = gf_filter_pid_get_info_str(pid, "info:track", &pe);
-	if (p) {
-		urli->track_num = p->value.frac.num;
-		urli->track_total = p->value.frac.den;
-	}
-	gf_filter_release_property(pe);
-	return GF_OK;
-}
-
-GF_EXPORT
-const char *gf_term_get_world_info(GF_Terminal *term, GF_ObjectManager *scene_od, GF_List *descriptions)
-{
-	GF_Node *info;
-	if (!term) return NULL;
-	info = NULL;
-	if (!scene_od) {
-		if (!term->compositor->root_scene) return NULL;
-		info = (GF_Node*)term->compositor->root_scene->world_info;
-	} else {
-		if (!gf_term_check_odm(term, scene_od)) return NULL;
-		info = (GF_Node*) (scene_od->subscene ? scene_od->subscene->world_info : scene_od->parentscene->world_info);
-	}
-	if (!info) return NULL;
-
-	if (gf_node_get_tag(info) == TAG_SVG_title) {
-		/*FIXME*/
-		//return ((SVG_titleElement *) info)->textContent;
-		return "TO FIX IN GPAC!!";
-	} else {
-#ifndef GPAC_DISABLE_VRML
-		M_WorldInfo *wi = (M_WorldInfo *) info;
-		if (descriptions) {
-			u32 i;
-			for (i=0; i<wi->info.count; i++) {
-				gf_list_add(descriptions, wi->info.valsi);
-			}
-		}
-		return wi->title.buffer;
-#endif
-	}
-	return "GPAC";
-}
-
-GF_EXPORT
-GF_Err gf_term_dump_scene(GF_Terminal *term, char *rad_name, char **filename, Bool xml_dump, Bool skip_protos, GF_ObjectManager *scene_od)
-{
-#ifndef GPAC_DISABLE_SCENE_DUMP
-	GF_SceneGraph *sg;
-	GF_ObjectManager *odm;
-	GF_SceneDumper *dumper;
-	GF_List *extra_graphs;
-	u32 mode;
-	u32 i;
-	char *ext;
-	GF_Err e;
-
-	if (!term || !term->compositor->root_scene) return GF_BAD_PARAM;
-	if (!scene_od) {
-		if (!term->compositor->root_scene) return GF_BAD_PARAM;
-		odm = term->compositor->root_scene->root_od;
-	} else {
-		odm = scene_od;
-		if (!gf_term_check_odm(term, scene_od))
-			odm = term->compositor->root_scene->root_od;
-	}
-
-	if (odm->subscene) {
-		if (!odm->subscene->graph) return GF_IO_ERR;
-		sg = odm->subscene->graph;
-		extra_graphs = odm->subscene->extra_scenes;
-	} else {
-		if (!odm->parentscene->graph) return GF_IO_ERR;
-		sg = odm->parentscene->graph;
-		extra_graphs = odm->parentscene->extra_scenes;
-	}
-
-	mode = xml_dump ? GF_SM_DUMP_AUTO_XML : GF_SM_DUMP_AUTO_TXT;
-	/*figure out best dump format based on extension*/
-	ext = odm->scene_ns ? gf_file_ext_start(odm->scene_ns->url) : NULL;
-	if (ext) {
-		char szExt20;
-		strcpy(szExt, ext);
-		strlwr(szExt);
-		if (!strcmp(szExt, ".wrl")) mode = xml_dump ? GF_SM_DUMP_X3D_XML : GF_SM_DUMP_VRML;
-		else if(!strncmp(szExt, ".x3d", 4) || !strncmp(szExt, ".x3dv", 5) ) mode = xml_dump ? GF_SM_DUMP_X3D_XML : GF_SM_DUMP_X3D_VRML;
-		else if(!strncmp(szExt, ".bt", 3) || !strncmp(szExt, ".xmt", 4) || !strncmp(szExt, ".mp4", 4) ) mode = xml_dump ? GF_SM_DUMP_XMTA : GF_SM_DUMP_BT;
-	}
-
-	dumper = gf_sm_dumper_new(sg, rad_name, GF_FALSE, ' ', mode);
-
-	if (!dumper) return GF_IO_ERR;
-	e = gf_sm_dump_graph(dumper, skip_protos, 0);
-	for (i = 0; i < gf_list_count(extra_graphs); i++) {
-		GF_SceneGraph *extra = (GF_SceneGraph *)gf_list_get(extra_graphs, i);
-		gf_sm_dumper_set_extra_graph(dumper, extra);
-		e = gf_sm_dump_graph(dumper, skip_protos, 0);
-	}
-#ifdef GPAC_ENABLE_COVERAGE
-	if (gf_sys_is_cov_mode()) {
-		gf_sm_dumper_set_extra_graph(dumper, NULL);
-		gf_sm_dump_get_name(dumper);
-	}
-#endif
-
-	if (filename) *filename = gf_strdup(gf_sm_dump_get_name(dumper));
-	gf_sm_dumper_del(dumper);
-	return e;
-#else
-	return GF_NOT_SUPPORTED;
-#endif
-}
-
-GF_EXPORT
-void gf_term_print_stats(GF_Terminal *term)
-{
-	if (term->fsess)
-		gf_fs_print_stats(term->fsess);
-}
-
-GF_EXPORT
-void gf_term_print_graph(GF_Terminal *term)
-{
-	if (term->fsess)
-		gf_fs_print_connections(term->fsess);
-}
-
-
-
-GF_EXPORT
-Bool gf_term_is_supported_url(GF_Terminal *term, const char *fileName, Bool use_parent_url, Bool no_mime_check)
-{
-	char *parent_url = NULL;
-	if (!term || !term->compositor || !term->compositor->root_scene || !term->compositor->root_scene->root_od || !term->compositor->root_scene->root_od->scene_ns)
-		return GF_FALSE;
-		
-	if (use_parent_url && term->compositor->root_scene)
-		parent_url = term->compositor->root_scene->root_od->scene_ns->url;
-	return gf_filter_is_supported_source(term->compositor->filter, fileName, parent_url);
-}

gpac-2.0.0.tar.gz/Changelog -> gpac-2.2.0.tar.gz/Changelog Changed

@@ -1,4 +1,55 @@
-22/02/2022: GPAC 2.0
+# 19/12/2022: GPAC 2.2
+
+## Media Formats
+- 2-pass encoding for FFmpeg codecs other than libx264
+- Conversion filters for VTT, TXG3 and TTML
+- SubstationAlpha subtitle import (basic)
+- DVB subpictures in M2TS mux and demux
+- FFMPEG (mostly for Matroska) subtitle import and export (SRT/SSA to TX3G, TX3G to SRT, WebVTT and DVB subpictures)
+- EC3+Atmos signaling support
+- ALAC support
+- Improved DolbyVision muxing
+
+## Media player
+- subtitle delay and position adjustment
+- audio delay adjustment
+
+## MP4Box
+- allow numbers and media types as identifiers for track actions
+- dlba option to update atmos+ec3 signaling
+
+## Filters
+- UTC-based range extraction in reframer
+- Thumbnail generator filter
+- Added unframer filter
+- FFMPEG bitstream filters support
+- initseg support in mp4dmx filter
+- Access to GPU textures of decoders in Python and JSF bindings (glpush filter for tests)
+- Chapters editing and original timestamp dispatch in reformer range extraction 
+- dual in-band and out-of-band parameter set support in dasher
+- non-blocking IO for RTSP and HTTP servers/clients
+- RTSP over HTTP in rtsp server
+- Source-Specific multicast for udp and rtp inputs
+- User Authentication for HTTP and RTSP servers
+- TLS support for RTSP client and server
+- Per-filter buffering options
+
+## Encryption
+- ClearKey support in dasher and decryption
+
+## Misc
+- QT metadata tags in MP4Box and qt muxer 
+- support for some packet properties in URL templates 
+
+## DEPRECATED
+- Removed GF_Terminal API
+- Removed MP4Client, merged old behaviour in gpac -mp4c
+- Removed osmo4ios, direct compilation of gpac is now used on iOS
+- Removed Android Osmo4 and MP4Box, replaced by GPAC for Android which can run GUI as well as MP4Box and gpac command lines
+- Removed filemode option from dash demure
+
+
+# 22/02/2022: GPAC 2.0
 
 ## Adaptive Streaming
 - Low Latency HLS (LL-HLS, generation and playback)

gpac-2.0.0.tar.gz/Makefile -> gpac-2.2.0.tar.gz/Makefile Changed

@@ -49,9 +49,6 @@
 mods:
 	$(MAKE) -C modules all
 
-instmoz:
-	$(MAKE) -C applications/osmozilla install
-
 depend:
 	$(MAKE) -C src dep
 	$(MAKE) -C applications dep
@@ -69,6 +66,7 @@
 	rm -f config.mak config.h config.log
 	@find . -type f -name '*.gcno*' -delete
 	@find . -type f -name '*.gcda*' -delete
+	@find . -type f -name '*.dep*' -delete
 	@rm -f coverage.info 2> /dev/null
 	@rm -f bin/gcc/gm_*$(DYN_LIB_SUFFIX) 2> /dev/null
 	@rm -f bin/gcc/gf_*$(DYN_LIB_SUFFIX) 2> /dev/null
@@ -77,7 +75,7 @@
 	@cd $(SRC_PATH)/share/doc && doxygen
 
 man:
-	@cd $(SRC_PATH)/share/doc/man && MP4Box -genman && MP4Client -genman && gpac -genman
+	@cd $(SRC_PATH)/share/doc/man && MP4Box -genman && gpac -genman
 
 test_suite:
 	@cd $(SRC_PATH)/testsuite && ./make_tests.sh -precommit -p=0
@@ -125,13 +123,6 @@
 	$(INSTALL) $(INSTFLAGS) -m 755 bin/gcc/MP4Box$(EXE_SUFFIX) "$(DESTDIR)$(prefix)/bin" ; \
 	fi
 endif
-ifneq ($(STATIC_BINARY),yes)
-ifeq ($(DISABLE_PLAYER),no)
-	if  -f bin/gcc/MP4Client$(EXE_SUFFIX)  ; then \
-	$(INSTALL) $(INSTFLAGS) -m 755 bin/gcc/MP4Client$(EXE_SUFFIX) "$(DESTDIR)$(prefix)/bin" ; \
-	fi
-endif
-endif
 	$(INSTALL) -d "$(DESTDIR)$(prefix)/$(lib_dir)/$(moddir)"
 ifneq ($(STATIC_BINARY),yes)
 	$(INSTALL) bin/gcc/gm_*$(DYN_LIB_SUFFIX) "$(DESTDIR)$(prefix)/$(lib_dir)/$(moddir)" || true
@@ -144,7 +135,6 @@
 	$(INSTALL) -d "$(DESTDIR)$(prefix)/$(man_dir)"
 	$(INSTALL) -d "$(DESTDIR)$(prefix)/$(man_dir)/man1"
 	$(INSTALL) $(INSTFLAGS) -m 644 $(SRC_PATH)/share/doc/man/mp4box.1 $(DESTDIR)$(prefix)/$(man_dir)/man1/
-	$(INSTALL) $(INSTFLAGS) -m 644 $(SRC_PATH)/share/doc/man/mp4client.1 $(DESTDIR)$(prefix)/$(man_dir)/man1/
 	$(INSTALL) $(INSTFLAGS) -m 644 $(SRC_PATH)/share/doc/man/gpac.1 $(DESTDIR)$(prefix)/$(man_dir)/man1/
 	$(INSTALL) $(INSTFLAGS) -m 644 $(SRC_PATH)/share/doc/man/gpac-filters.1 $(DESTDIR)$(prefix)/$(man_dir)/man1/
 	$(INSTALL) -d "$(DESTDIR)$(prefix)/share/gpac"
@@ -197,11 +187,6 @@
 ifeq ($(DISABLE_ISOFF),no)
 	ln -sf $(BUILD_PATH)/bin/gcc/MP4Box$(EXE_SUFFIX) $(DESTDIR)$(prefix)/bin/MP4Box$(EXE_SUFFIX)
 endif
-ifneq ($(STATIC_BINARY),yes)
-ifeq ($(DISABLE_PLAYER),no)
-	ln -sf $(BUILD_PATH)/bin/gcc/MP4Client$(EXE_SUFFIX) $(DESTDIR)$(prefix)/bin/MP4Client$(EXE_SUFFIX)
-endif
-endif
 ifeq ($(CONFIG_DARWIN),yes)
 	ln -s $(BUILD_PATH)/bin/gcc/libgpac$(DYN_LIB_SUFFIX) $(DESTDIR)$(prefix)/$(lib_dir)/libgpac.$(VERSION_SONAME)$(DYN_LIB_SUFFIX)
 	ln -sf $(DESTDIR)$(prefix)/$(lib_dir)/libgpac.$(VERSION_SONAME)$(DYN_LIB_SUFFIX) $(DESTDIR)$(prefix)/$(lib_dir)/libgpac.$(VERSION_MAJOR)$(DYN_LIB_SUFFIX)
@@ -230,10 +215,8 @@
 	$(MAKE) uninstall-lib
 	rm -rf $(DESTDIR)$(prefix)/$(lib_dir)/$(moddir)
 	rm -rf $(DESTDIR)$(prefix)/bin/MP4Box
-	rm -rf $(DESTDIR)$(prefix)/bin/MP4Client
 	rm -rf $(DESTDIR)$(prefix)/bin/gpac
 	rm -rf $(DESTDIR)$(prefix)/$(man_dir)/man1/mp4box.1
-	rm -rf $(DESTDIR)$(prefix)/$(man_dir)/man1/mp4client.1
 	rm -rf $(DESTDIR)$(prefix)/$(man_dir)/man1/gpac.1
 	rm -rf $(DESTDIR)$(prefix)/$(man_dir)/man1/gpac-filters.1
 	rm -rf $(DESTDIR)$(prefix)/share/gpac
@@ -292,11 +275,6 @@
 
 	$(INSTALL) $(INSTFLAGS) -m 644 config.h "$(DESTDIR)$(prefix)/include/gpac/configuration.h" || true
 
-ifeq ($(GPAC_ENST),yes)
-	$(INSTALL) -d "$(DESTDIR)$(prefix)/include/gpac/enst"
-	$(INSTALL) $(INSTFLAGS) -m 644 $(SRC_PATH)/include/gpac/enst/*.h "$(DESTDIR)$(prefix)/include/gpac/enst"
-endif
-
 	$(INSTALL) -d "$(DESTDIR)$(prefix)/$(lib_dir)"
 	$(INSTALL) $(INSTFLAGS) -m 644 "./bin/gcc/libgpac_static.a" "$(DESTDIR)$(prefix)/$(lib_dir)" || true
 
@@ -317,13 +295,6 @@
 
 ifeq ($(CONFIG_DARWIN),yes)
 dmg:
-#	@if  ! -z "$(shell git diff FETCH_HEAD)" ; then \
-#		echo "Local revision and remote revision are not congruent; you may have local commit."; \
-#		echo "Please consider pushing your commit before generating an installer"; \
-#		exit 1; \
-#	fi
-	rm "bin/gcc/MP4Client"
-	$(MAKE) -C applications/mp4client
 	./mkdmg.sh $(arch)
 endif
 
@@ -346,7 +317,6 @@
 	@echo "lib: builds GPAC library only (libgpac.so)"
 	@echo "apps: builds programs only"
 	@echo "modules: builds modules only"
-	@echo "instmoz: build and local install of osmozilla"
 	@echo "sggen: builds scene graph generators"
 	@echo
 	@echo "clean: clean src repository"

gpac-2.0.0.tar.gz/README.md -> gpac-2.2.0.tar.gz/README.md Changed

@@ -24,7 +24,8 @@
 
 
 # GPAC Introduction
-Latest Release: 2.0
+
+Latest Release: 2.2
 
 GPAC is an open-source multimedia framework focused on modularity and standards compliance.
 GPAC provides tools to process, inspect, package, stream, playback and interact with media content. Such content can be any combination of audio, video, subtitles, metadata, scalable graphics, encrypted media, 2D/3D graphics and ECMAScript.
@@ -32,7 +33,7 @@
 
 For more information, visit GPAC website(http://gpac.io)
 
-GPAC is distributed under the LGPL v2.1 or later, and is also available, for most of it, under a commercial license(https://www.gpac-licensing.com).
+GPAC is distributed under the LGPL v2.1 or later, and is also available, for most of it, under a commercial license(https://www.motionspell.com/gpac-licensing).
 
 Please ! _cite_ ! our work in your research:
 - "GPAC Filters" (https://doi.org/10.1145/3339825.3394929) for recent versions (0.9 or above) 
@@ -68,18 +69,9 @@
 
 
 ## gpac 
-GPAC includes a filter engine in charge of stream management and used by most applications in GPAC - read this post(https://wiki.gpac.io/Rearchitecture) for more discussion on how this impacts MP4Box and MP4Client.
+GPAC includes a filter engine in charge of stream management and used by most applications in GPAC - read this post(https://wiki.gpac.io/Rearchitecture) for more discussion on how this impacts MP4Box.
 The gpac application is a direct interface to the filter engine of GPAC, allowing any combinaison of filters not enabled by other applications. See `gpac -h`, `man gpac`, `man gpac-filters` or our wiki(https://wiki.gpac.io/Filters) for more details.
 
-## MP4Client (deprecated)
-MP4Client is a media player built upon libgpac, featuring a rich media interactive composition engine with MPEG-4 BIFS, SVG, VRML/X3D support.
-For GPAC configuration instruction, check `MP4Client -h` ,  `man MP4Client` or our wiki(https://wiki.gpac.io/mp4client).
-
-__Warning__
-MP4Client is deprecated and will be removed in the next release. Start modifying your scripts:
-- replace `MP4Client URL` with `gpac -play URL` (audio/video playback only) or `gpac -mp4c URL` (if compositor is needed)
-- replace `MP4Client -gui URL` with `gpac -gui URL`.
-
 # Getting started
 ## Download
 Stable and nightly builds installers for Windows, Linux, OSX, Android, iOS are available on gpac.io(https://gpac.wp.imt.fr/downloads/).
@@ -120,15 +112,10 @@
 # Roadmap
 Users are encouraged to use the latest tag or the master branch.
 
-The v0.8.X release (the last one using the legacy architecture) is officially deprecated.
-
 ## V2.X
 Targets:
--   drop MP4Client and GF_Terminal API
--   User authentication for HTTP and RTSP servers
--   DASH event support
 -   Web integration (emscripten, Remotery UI)
+-   DASH event support
+-   Better TTML2 / SMPTE ST 2052-1 support
 -   GUI cleanup ?
 
-
-

gpac-2.0.0.tar.gz/SECURITY.md -> gpac-2.2.0.tar.gz/SECURITY.md Changed

gpac-2.0.0.tar.gz/applications/Makefile -> gpac-2.2.0.tar.gz/applications/Makefile Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/.gitignore Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/build.gradle Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/AndroidManifest.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/java Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/java/com Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/java/com/gpac Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/java/com/gpac/mp4box Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/java/com/gpac/mp4box/mp4box.java Added

@@ -0,0 +1,210 @@
+package com.gpac.mp4box;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.gpac.mp4box.R;
+
+import android.app.Activity;
+import android.graphics.Typeface;
+import android.os.Bundle;
+import android.os.Environment;
+import android.text.InputType;
+import android.text.method.ScrollingMovementMethod;
+import android.widget.Button;
+import android.widget.EditText;
+import android.util.Log;
+import android.view.View;
+
+import android.content.pm.PackageManager;
+import android.content.Context;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.widget.TextView;
+
+import java.io.OutputStreamWriter;
+import java.io.IOException;
+
+public class mp4box extends Activity {
+
+	private mp4terminal myTerminal;
+
+
+ private final static String LOG_LIB = "com.gpac.mp4box.loader";
+ private static Map<String, Throwable> errors = null;
+
+ synchronized static Map<String, Throwable> loadAllLibraries() {
+
+ final String toLoad = {"avutil", "swresample", "swscale", "avcodec", "avformat", "avfilter", "avdevice",
+ "faad", "ft2", "png",
+ "jpegdroid", "mad", "openjpeg",
+ "z", "gpac", "mp4box"};
+
+ HashMap<String, Throwable> exceptions = new HashMap<String, Throwable>();
+
+ for (String s : toLoad) {
+ try {
+ Log.i(LOG_LIB, "Loading library " + s + "...");
+ System.loadLibrary(s);
+
+ } catch (UnsatisfiedLinkError e) {
+ exceptions.put(s, e);
+ Log.e(LOG_LIB, "Failed to load library : " + s + " due to link error " + e.getLocalizedMessage(), e);
+ } catch (SecurityException e) {
+ exceptions.put(s, e);
+ Log.e(LOG_LIB, "Failed to load library : " + s + " due to security error " + e.getLocalizedMessage(), e);
+ } catch (Throwable e) {
+ exceptions.put(s, e);
+ Log.e(LOG_LIB, "Failed to load library : " + s + " due to Runtime error " + e.getLocalizedMessage(), e);
+ }
+ }
+
+ errors = Collections.unmodifiableMap(exceptions);
+ return errors;
+ }
+
+
+ public void reloadUIStatus() {
+
+ final EditText cmdlineTxt = (EditText) findViewById(R.id.CommandLineEdit);
+ ArrayList<String> cmdlineFile = readFromFile("mp4box.cmdline.txt");
+ if (cmdlineFile.size()>0) {
+ cmdlineTxt.setText(cmdlineFile.get(0));
+ }
+
+
+ final TextView stdoutTxt = (TextView) findViewById(R.id.stdoutView);
+ ArrayList<String> stdoutFile = readFromFile("mp4box.stderrout.txt");
+ if (stdoutFile.size()>0) {
+ stdoutTxt.setText("");
+ for (String line: stdoutFile) {
+ stdoutTxt.append(line + "\n");
+ }
+ }
+ stdoutTxt.setMovementMethod(new ScrollingMovementMethod());
+
+ }
+
+ /** Called when the activity is first created. */
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ System.out.println( "hello world java" );
+
+ setContentView(R.layout.main);
+
+ reloadUIStatus();
+
+ myTerminal = new mp4terminal();
+ errors = loadAllLibraries();
+
+ final Button button = (Button) findViewById(R.id.OkButton);
+ button.setOnClickListener(new View.OnClickListener() {
+ public void onClick(View v) {
+
+ 	EditText oCommandLine = (EditText) findViewById(R.id.CommandLineEdit );
+ 	CharSequence sCommandLine = oCommandLine.getText();
+ writeToFile(sCommandLine.toString(), "mp4box.cmdline.txt");
+
+ 	myTerminal.run( sCommandLine.toString() );
+
+
+ doRestart(getApplicationContext());
+ }
+ });
+
+ }
+
+ private void writeToFile(String string, String filename) {
+ try {
+
+ File file = new File(Environment.getExternalStorageDirectory(), filename);
+ if (!file.exists())
+ file.createNewFile();
+
+ FileOutputStream fos;
+ byte data = string.getBytes();
+ fos = new FileOutputStream(file);
+ fos.write(data);
+ fos.flush();
+ fos.close();
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ private ArrayList<String> readFromFile(String filename) {
+
+ ArrayList<String> lines = new ArrayList<>();
+
+ try {
+
+ File file = new File(Environment.getExternalStorageDirectory(), filename);
+ BufferedReader br = new BufferedReader(new FileReader(file));
+
+ String line;
+ while ((line = br.readLine()) != null) {
+ lines.add(line);
+ }
+ br.close();
+ }
+
+ catch (Exception e) {
+ Log.d(LOG_LIB, "While opening " + filename + " got: " + e.toString());
+ }
+
+ return lines;
+ }
+
+
+
+ public static void doRestart(Context c) {
+ try {
+ //check if the context is given
+ if (c != null) {
+ //fetch the packagemanager so we can get the default launch activity
+ // (you can replace this intent with any other activity if you want
+ PackageManager pm = c.getPackageManager();
+ //check if we got the PackageManager
+ if (pm != null) {
+ //create the intent with the default start activity for your application
+ Intent mStartActivity = pm.getLaunchIntentForPackage(
+ c.getPackageName()
+ );
+ if (mStartActivity != null) {
+ mStartActivity.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ //create a pending intent so the application is restarted after System.exit(0) was called.
+ // We use an AlarmManager to call this intent in 100ms
+ int mPendingIntentId = 223344;
+ PendingIntent mPendingIntent = PendingIntent
+ .getActivity(c, mPendingIntentId, mStartActivity,
+ PendingIntent.FLAG_CANCEL_CURRENT);
+ AlarmManager mgr = (AlarmManager) c.getSystemService(Context.ALARM_SERVICE);
+ mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 100, mPendingIntent);
+ //kill the application
+ System.exit(0);
+ } else {
+ Log.e(LOG_LIB, "Was not able to restart application, mStartActivity null");
+ }
+ } else {
+ Log.e(LOG_LIB, "Was not able to restart application, PM null");
+ }
+ } else {
+ Log.e(LOG_LIB, "Was not able to restart application, Context null");
+ }
+ } catch (Exception ex) {
+ Log.e(LOG_LIB, "Was not able to restart application");
+ }
+ }
+
+}
\ No newline at end of file

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/java/com/gpac/mp4box/mp4terminal.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/jni Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/jni/wrapper.c Added

@@ -0,0 +1,101 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <android/log.h>
+#include <jni.h>
+#include "stdlib.h"
+#include "stdio.h"
+#include "string.h"
+
+
+#define jniTAG "WRAPPER_JNI"
+
+#define jniLOGV(X...) __android_log_print(ANDROID_LOG_VERBOSE, jniTAG, X)
+#define jniLOGI(X) __android_log_print(ANDROID_LOG_INFO, jniTAG, X)
+#define jniLOGE(X) __android_log_print(ANDROID_LOG_ERROR, jniTAG, X)
+
+/*#define CAST_HANDLE(wr) jclass c = env->GetObjectClass(obj);\
+ if (!c) return;\
+ jfieldID fid = env->GetFieldID(c, "handle", "J");\
+ if (!fid){\
+ __android_log_print(ANDROID_LOG_ERROR, jniTAG, "No Field ID, ERROR");\
+ return;\
+ }\
+ jlong h = env->GetLongField(obj, fid);
+ //CNativeWrapper* wr = (CNativeWrapper*) h;*/
+
+char ** ConvertCommandLine( const char* sCommand, int* iNbArg );
+int mp4boxMain(int argc, char **argv);
+
+JNIEXPORT void JNICALL Java_com_gpac_mp4box_mp4terminal_run(JNIEnv * env, jobject obj, jstring sCommand)
+{
+	//CAST_HANDLE(wr);
+	jniLOGV("mp4terminal::start");
+	/*if (!wr)
+	{
+		jniLOGV("mp4terminal::end : aborted");
+	 return;
+	}*/
+	jboolean isCopy;
+	const char * sOriginalCommand = (*env)->GetStringUTFChars(env, sCommand, &isCopy);
+
+	jniLOGV("mp4terminal::command get back ok");
+	jniLOGV("%s\n", sOriginalCommand);
+
+	int i = 0;
+	char** sConvertedCommandLine;
+	sConvertedCommandLine = ConvertCommandLine( sOriginalCommand, &i );
+	jniLOGV("Convert command line done");
+
+	FILE* ferr = freopen( "/mnt/sdcard/mp4box.stderrout.txt", "w", stderr );
+	FILE* fout = freopen( "/mnt/sdcard/mp4box.stderrout.txt", "w", stdout );
+
+	mp4boxMain(i, sConvertedCommandLine);
+
+	(*env)->ReleaseStringUTFChars(env, sCommand, sOriginalCommand);
+	jniLOGV("mp4terminal::end");
+	fclose(ferr);
+	fclose(fout);
+}
+
+char ** ConvertCommandLine( const char* sCommand, int* iNbArg )
+{
+	int iLength = strlen( sCommand );
+	int iArgNumber = 1;
+	int i = 0;
+	char** pReturn;
+	int iPreviousPos = 0;
+	int k = 1;//begin at character position 1 as the 0 position will be held by the process name , i.e. mp4box
+	int l = 0;
+
+	for ( i = 0; i < iLength ; i++ )
+	{
+		if( sCommandi == ' ' )
+		{
+			iArgNumber++;
+		}
+	}
+	iArgNumber++; // last argument will not be detected as it is not followed by a space character
+	pReturn = (char**)malloc(sizeof(char*)*iArgNumber);
+	pReturn0 = (char*)malloc(sizeof( char) * ( 7 ));
+	strcpy( pReturn0, "MP4Box" );//just a place holder , will never be read.
+	pReturn06 = '\0';
+
+	for ( l = 0; l <= iLength ; l++ )
+	{
+		if( sCommandl == ' ' || l == ( iLength ) )
+		{
+			pReturnk = (char*)malloc(sizeof( char) * ( l - iPreviousPos + 1));
+			strncpy( pReturnk, sCommand + iPreviousPos, l - iPreviousPos );
+			pReturnkl-iPreviousPos = '\0';
+			iPreviousPos = l + 1;
+			k++;
+		}
+	}
+	*iNbArg = iArgNumber;
+	return pReturn;
+}
+#ifdef __cplusplus
+}
+#endif

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/drawable-hdpi Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/drawable-hdpi/icon.png Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/drawable-ldpi Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/drawable-ldpi/icon.png Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/drawable-mdpi Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/drawable-mdpi/icon.png Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/layout Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/layout/main.xml Added

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:tools="http://schemas.android.com/tools"
+ android:orientation="vertical"
+ android:layout_width="fill_parent"
+ android:layout_height="fill_parent"
+ >
+
+ <TextView android:layout_height="wrap_content" android:layout_width="wrap_content" android:id="@+id/textView1" android:text="@string/CommandLineTitle"></TextView>
+
+ <LinearLayout
+ android:orientation="horizontal"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content">
+
+ <EditText android:layout_height="wrap_content" android:text="-version" android:layout_width="292dp" android:id="@+id/CommandLineEdit"
+ android:layout_weight="1"></EditText>
+
+ <Button android:layout_height="wrap_content" android:id="@+id/OkButton" android:layout_width="wrap_content" android:text="@string/OkButton"
+ android:layout_weight="1"></Button>
+
+ </LinearLayout>
+
+ <TextView
+ android:text="output"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:id="@+id/stdoutView"
+ android:scrollbars = "vertical"
+ android:fontFamily="monospace"
+ android:typeface="monospace"
+ android:textSize="8sp" />
+
+</LinearLayout>

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/values Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/app/src/main/res/values/strings.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/build.gradle Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/gradle Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/gradle/wrapper Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/gradle/wrapper/gradle-wrapper.jar Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/gradle/wrapper/gradle-wrapper.properties Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/gradlew Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/gradlew.bat Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4box_android/settings.gradle Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4client Added

gpac-2.2.0.tar.gz/applications/deprecated/mp4client/Makefile Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4client/carbon_events.c Added

@@ -0,0 +1,109 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2005-2012
+ *					All rights reserved
+ *
+ * This file is part of GPAC / command-line client
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#if defined(__DARWIN__) || defined(__APPLE__)
+#include <Carbon/Carbon.h>
+#endif
+
+
+int gf_sys_set_args(int argc, const char **argv);
+void send_open_url(const char *url);
+
+void RunApplicationEventLoop(void);
+void QuitApplicationEventLoop(void);
+
+char *my_argv2;
+
+static int main_evt_loop_run = 1;
+
+static AEEventHandlerUPP	open_app_UPP, open_doc_UPP;
+
+static pascal OSErr ae_open_app (const AppleEvent *ae_event, AppleEvent *ae_reply, long ae_ref_count)
+{
+	if (main_evt_loop_run) {
+		QuitApplicationEventLoop();
+		main_evt_loop_run = 0;
+	}
+	return (noErr);
+}
+
+static pascal OSErr ae_open_doc (const AppleEvent *ae_event, AppleEvent *ae_reply, long ae_ref_count)
+{
+	OSErr err;
+	FSRef	ref;
+	AEDescList	docList;
+	long	count;
+
+	err = AEGetParamDesc(ae_event, keyDirectObject, typeAEList, &docList);
+	if (err) {
+		return (noErr);
+	}
+	err = AECountItems(&docList, &count);
+	if (err == noErr) {
+		err = AEGetNthPtr(&docList, 1, typeFSRef, NULL, NULL, &ref, sizeof(FSRef), NULL);
+		if (err == noErr) {
+			char path4096;
+			FSRefMakePath(&ref, (UInt8 *) path, 4096);
+			if (main_evt_loop_run) {
+				my_argv1 = strdup(path);
+				gf_sys_set_args(2, (const char **) my_argv);
+			} else {
+				send_open_url(path);
+			}
+		}
+	}
+	AEDisposeDesc(&docList);
+
+	if (main_evt_loop_run) {
+		QuitApplicationEventLoop();
+		main_evt_loop_run = 0;
+	}
+	return (noErr);
+}
+
+void carbon_init ()
+{
+	my_argv0 = "GPAC";
+	my_argv1 = NULL;
+
+	open_app_UPP = NewAEEventHandlerUPP(ae_open_app);
+	AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, open_app_UPP, 0L, false);
+	open_doc_UPP = NewAEEventHandlerUPP(ae_open_doc);
+	AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, open_doc_UPP, 0L, false);
+
+	main_evt_loop_run = 1;
+	RunApplicationEventLoop();
+}
+
+void carbon_uninit()
+{
+
+	DisposeAEEventHandlerUPP(open_app_UPP);
+	DisposeAEEventHandlerUPP(open_doc_UPP);
+
+	if (my_argv1) free(my_argv1);
+}
+
+

gpac-2.2.0.tar.gz/applications/deprecated/mp4client/main.c Added

@@ -0,0 +1,2752 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2005-2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / command-line client
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+
+/*includes both terminal and od browser*/
+#include <gpac/terminal.h>
+#include <gpac/term_info.h>
+#include <gpac/constants.h>
+#include <gpac/events.h>
+#include <gpac/media_tools.h>
+#include <gpac/options.h>
+#include <gpac/main.h>
+
+#include <gpac/avparse.h>
+#include <gpac/network.h>
+#include <gpac/utf.h>
+
+/*ISO 639 languages*/
+#include <gpac/iso639.h>
+
+
+#ifndef WIN32
+#include <dlfcn.h>
+#include <pwd.h>
+#include <unistd.h>
+#if defined(__DARWIN__) || defined(__APPLE__)
+#include <sys/types.h>
+#include <sys/stat.h>
+
+void carbon_init();
+void carbon_uninit();
+
+#endif
+
+#else
+#include <windows.h> /*for GetModuleFileName*/
+#endif	//WIN32
+
+/*local prototypes*/
+static void PrintWorldInfo(GF_Terminal *term);
+static void ViewOD(GF_Terminal *term, u32 OD_ID, u32 number, const char *URL);
+static void PrintODList(GF_Terminal *term, GF_ObjectManager *root_odm, u32 num, u32 indent, char *root_name);
+
+static void ViewODs(GF_Terminal *term, Bool show_timing);
+static void MakeScreenshot(Bool for_coverage);
+static void PrintAVInfo(Bool final);
+
+static u32 gui_mode = 0;
+static int ret_val = 0;
+
+static Bool restart = GF_FALSE;
+static Bool reload = GF_FALSE;
+Bool do_coverage = GF_FALSE;
+
+Bool no_prog = 0;
+
+static FILE *helpout = NULL;
+u32 help_flags = 0;
+
+#if defined(__DARWIN__) || defined(__APPLE__)
+#define VK_MOD GF_KEY_MOD_ALT
+#else
+#define VK_MOD GF_KEY_MOD_CTRL
+#endif
+
+static Bool no_audio = GF_FALSE;
+static u32 bench_mode = 0;
+static u32 bench_mode_start = 0;
+static u32 bench_buffer = 0;
+static Bool eos_seen = GF_FALSE;
+static Bool addon_visible = GF_TRUE;
+Bool is_connected = GF_FALSE;
+Bool startup_file = GF_FALSE;
+GF_User user;
+GF_Terminal *term;
+u64 Duration;
+GF_Err last_error = GF_OK;
+static Bool enable_add_ons = GF_TRUE;
+static Fixed playback_speed = FIX_ONE;
+
+static s32 request_next_playlist_item = GF_FALSE;
+FILE *playlist = NULL;
+static Bool readonly_playlist = GF_FALSE;
+
+static u32 display_rti = 0;
+static Bool Run;
+static Bool CanSeek = GF_FALSE;
+static char the_urlGF_MAX_PATH;
+static char pl_pathGF_MAX_PATH;
+static Bool no_mime_check = GF_TRUE;
+static u64 log_rti_time_start = 0;
+static Bool loop_at_end = GF_FALSE;
+static u32 forced_width=0;
+static u32 forced_height=0;
+
+/*windowless options*/
+u32 align_mode = 0;
+u32 init_w = 0;
+u32 init_h = 0;
+u32 last_x, last_y;
+Bool right_down = GF_FALSE;
+
+Float scale = 1;
+
+static Bool shell_visible = GF_TRUE;
+#if defined(WIN32) && !defined(_WIN32_WCE)
+
+static HWND console_hwnd = NULL;
+static Bool owns_wnd = GF_FALSE;
+#include <tlhelp32.h>
+#include <Psapi.h>
+static DWORD getParentPID(DWORD pid)
+{
+	DWORD ppid = 0;
+	HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+	if (h) {
+		PROCESSENTRY32 pe = { 0 };
+		pe.dwSize = sizeof(PROCESSENTRY32);
+		if (Process32First(h, &pe)) {
+			do {
+				if (pe.th32ProcessID == pid) {
+					ppid = pe.th32ParentProcessID;
+					break;
+				}
+			} while (Process32Next(h, &pe));
+		}
+		CloseHandle(h);
+	}
+	return (ppid);
+}
+
+static void getProcessName(DWORD pid, PUCHAR fname, DWORD sz)
+{
+	HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
+	if (h) {
+		GetModuleFileNameEx(h, NULL, fname, sz);
+		CloseHandle(h);
+	}
+}
+static void w32_hide_shell(u32 cmd_type)
+{
+	typedef HWND (WINAPI *GetConsoleWindowT)(void);
+	HMODULE hk32 = GetModuleHandle("kernel32.dll");
+	if (!console_hwnd) {
+		char parentNameGF_MAX_PATH;
+		DWORD dwProcessId = 0;
+		DWORD dwParentProcessId = 0;
+		DWORD dwParentParentProcessId = 0;
+		GetConsoleWindowT GetConsoleWindow = (GetConsoleWindowT)GetProcAddress(hk32, "GetConsoleWindow");
+		console_hwnd = GetConsoleWindow();
+		dwProcessId = GetCurrentProcessId();
+		dwParentProcessId = getParentPID(dwProcessId);
+		if (dwParentProcessId)
+				dwParentParentProcessId = getParentPID(dwParentProcessId);
+		//get parent process name, check for explorer
+		parentName0 = 0;
+		getProcessName(dwParentProcessId, parentName, GF_MAX_PATH);
+		if (strstr(parentName, "explorer")) {
+			owns_wnd = GF_TRUE;
+		}
+		//get parent parent process name, check for devenv (or any other ide name ...)
+		else if (dwParentParentProcessId) {
+			owns_wnd = GF_FALSE;
+			parentName0 = 0;
+			getProcessName(dwParentParentProcessId, parentName, GF_MAX_PATH);
+			if (strstr(parentName, "devenv")) {
+				owns_wnd = GF_TRUE;
+			}
+		} else {
+			owns_wnd = GF_FALSE;
+		}
+	}
+	if (!owns_wnd || !console_hwnd) return;
+
+	if (cmd_type==0) {
+		ShowWindow(console_hwnd, SW_SHOW);
+		shell_visible = GF_TRUE;
+	}
+	else if (cmd_type==1) {
+		ShowWindow(console_hwnd, SW_HIDE);
+		shell_visible = GF_FALSE;
+	}
+	else if (cmd_type == 2) {
+		PostMessage(GetConsoleWindow(), WM_CLOSE, 0, 0);
+	}
+}
+
+#define hide_shell w32_hide_shell
+#else
+
+#define hide_shell(_var)
+
+#endif
+
+
+void send_open_url(const char *url)
+{
+	GF_Event evt;
+	memset(&evt, 0, sizeof(GF_Event));
+	evt.type = GF_EVENT_NAVIGATE;
+	evt.navigate.to_url = url;
+	gf_term_send_event(term, &evt);
+}
+
+GF_GPACArg mp4client_args =
+{
+#ifdef GPAC_MEMORY_TRACKING
+ 	GF_DEF_ARG("mem-track", NULL, "enable memory tracker", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+ 	GF_DEF_ARG("mem-track-stack", NULL, "enable memory tracker with stack dumping", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+#endif
+	 GF_DEF_ARG("rti", NULL, "log run-time info (FPS, CPU, Mem usage) to given file", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+	 GF_DEF_ARG("rtix", NULL, "same as -rti but driven by GPAC logs", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+	 GF_DEF_ARG("size", NULL, "specify visual size WxH. If not set, scene size or video size is used", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+	 GF_DEF_ARG("rti-refresh", NULL, "set refresh time in ms between two runt-time counters queries (default is 200)", NULL, NULL, GF_ARG_INT, 0),
+
+ 	GF_DEF_ARG("no-thread", NULL, "disable thread usage (except for depending on driver audio)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+ 	GF_DEF_ARG("no-audio", NULL, "disable audio", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+
+#ifdef GPAC_CONFIG_WIN32
+ 	GF_DEF_ARG("no-wnd", NULL, "use windowless mode (Win32 only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERIMENTAL),
+ 	GF_DEF_ARG("no-back", NULL, "use transparent background for output window when no background is specified (Win32 only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERIMENTAL),
+ 	GF_DEF_ARG("align", NULL, "specify v and h alignment for windowless mode\n"
+ 	"- tl: top/left\n"
+ 	"- tm: top/horizontal middle\n"
+ 	"- tr: top/right\n"
+ 	"- ml: vertical middle/left\n"
+ 	"- mm: vertical middle/horizontal middle\n"
+ 	"- mr: vertical middle/right\n"
+ 	"- bl: bottom/left\n"
+ 	"- bm: bottom/horizontal middle\n"
+ 	"- br: bottom/right", "tl", "tl|tm|tr|ml|mm|mr|bl|bm|br", GF_ARG_INT, GF_ARG_HINT_EXPERIMENTAL),
+#endif // GPAC_CONFIG_WIN32
+
+ 	GF_DEF_ARG("pause", NULL, "pause at first frame", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("play-from", NULL, "start playback from given time in seconds in media", NULL, NULL, GF_ARG_DOUBLE, 0),
+	GF_DEF_ARG("speed", NULL, "start playback wit given speed", NULL, NULL, GF_ARG_DOUBLE, 0),
+	GF_DEF_ARG("loop", NULL, "loop playback", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("fs", NULL, "start in fullscreen mode", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("exit", NULL, "exit when presentation is over", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("run-for", NULL, "run for indicated time in seconds and exits", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("service", NULL, "auto-tune to given service ID in a multiplex", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("no-save", NULL, "do not save configuration file on exit", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("no-addon", NULL, "disable automatic loading of media addons declared in source URL", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("gui", NULL, "start in GUI mode. The GUI is indicated in the configuration(core_config) file __GeneralStartupFile__", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("p", NULL, "use indicated profile for the global GPAC config. If not found, config file is created. If a file path is indicated, this will load profile from that file. Otherwise, this will create a directory of the specified name and store new config there. Reserved name `0` means a new profile, not stored to disk. Works using -p=NAME or -p NAME", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("stats", NULL, "dump filter session stats after playback", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("graph", NULL, "dump filter session graph after playback", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("nk", NULL, "disable keyboard interaction", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("h", "help", "show this help. Use `-hx` to show expert help", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("hc", NULL, "show libgpac core options", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("hr", NULL, "show runtime options when keyboard interaction is enabled", NULL, NULL, GF_ARG_BOOL, 0),
+	{0}
+};
+
+
+void PrintUsage(Bool show_all)
+{
+	u32 i=0;
+
+	if (help_flags & GF_PRINTARG_MAN) {
+		fprintf(helpout, ".SH \"DESCRIPTION\"\n.LP\nMP4Client is GPAC command-line media player. It supports all GPAC playback features (2D and 3D support, local playback, RTP streaming, HTTP faststart, many audio and video codecs ...).\n.br\nSpecific URLs shortcuts are available, see gpac -h compositor\n.\n.\n.SH OPTIONS\n");
+	} else {
+		gf_sys_format_help(helpout, help_flags, "Usage: MP4Client options filename\n"
+			"# General\n"
+			"The player accepts any URL supported by GPAC.\n"
+			"Specific URLs shortcuts are available, see GPAC Compositor (gpac -h compositor)(compositor)\n"
+			"\n"
+			"Warning: MP4Client is being deprecated, use `gpac -play URL`, `gpac -gui URL` or `gpac -mp4c URL`.\n"
+			"\n"
+			"Version: %s\n"
+			"%s\n"
+			"For more info on GPAC configuration, use `gpac ` -h(GPAC) `bin` \n \n"
+			"# Options \n \n",
+			(help_flags == GF_PRINTARG_MD) ? GPAC_VERSION : gf_gpac_version(),
+			gf_gpac_copyright_cite()
+		);
+	}
+
+	while (mp4client_argsi.name) {
+		GF_GPACArg *arg = &mp4client_argsi;
+		i++;
+		if (!show_all && (arg->flags & (GF_ARG_HINT_EXPERIMENTAL|GF_ARG_HINT_EXPERT) ))
+			continue;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4client");
+	}
+}
+
+typedef enum
+{
+	MP4C_QUIT = 0,
+	MP4C_KILL,
+	MP4C_RELOAD,
+	MP4C_OPEN,
+	MP4C_OPEN_PL,
+	MP4C_PL_NEXT,
+	MP4C_PL_JUMP,
+	MP4C_DISCONNECT,
+	MP4C_SELECT,
+	MP4C_PAUSE_RESUME,
+	MP4C_STEP,
+	MP4C_SEEK,
+	MP4C_SEEK_TIME,
+	MP4C_TIME,
+	MP4C_UPDATE,
+	MP4C_EVALJS,
+	MP4C_SCREENSHOT,
+	MP4C_WORLDINFO,
+	MP4C_ODLIST,
+	MP4C_ODINFO_ID,
+	MP4C_ODINFO_NUM,
+	MP4C_ODTIME,
+	MP4C_ODBUF,
+	MP4C_DUMPSCENE,
+	MP4C_STRESSMODE,
+	MP4C_NAVMODE,
+	MP4C_LASTVP,
+	MP4C_OGL2D,
+	MP4C_AR_4_3,
+	MP4C_AR_16_9,
+	MP4C_AR_NONE,
+	MP4C_AR_ORIG,
+	MP4C_LOGS,
+	MP4C_RELOAD_OPTS,
+	MP4C_DISP_RTI,
+	MP4C_DISP_FPS,
+	MP4C_DISP_STATS,
+	MP4C_DISP_GRAPH,
+	MP4C_HELP,
+	MP4C_DOWNRATE,
+	MP4C_VMEM_CACHE,
+
+} MP4C_Command;
+
+struct _mp4c_key
+{
+ u8 char_code;
+ MP4C_Command cmd_type;
+ const char *cmd_help;
+ u32 flags;
+} MP4C_Keys = {
+	{'q', MP4C_QUIT, "quit", 0},
+	{'X', MP4C_KILL, "kill", 0},
+	{'r', MP4C_KILL, "reload current presentation", 0},
+	{'o', MP4C_OPEN, "connect to the specified URL", 0},
+	{'O', MP4C_OPEN_PL, "connect to the specified playlist", 0},
+	{'N', MP4C_PL_NEXT, "switch to the next URL in the playlist. Also works with `\\n`", 0},
+	{'P', MP4C_PL_JUMP, "jump to a given number ahead in the playlist", 0},
+	{'D', MP4C_DISCONNECT, "disconnect the current presentation", 0},
+	{'G', MP4C_SELECT, "select object or service ID", 0},
+	{'p', MP4C_PAUSE_RESUME, "play/pause the presentation", 0},
+	{'s', MP4C_STEP, "step one frame ahead", 0},
+	{'z', MP4C_SEEK, "seek into presentation by percentage", 0},
+	{'T', MP4C_SEEK_TIME, "seek into presentation by time", 0},
+	{'t', MP4C_TIME, "print current timing", 0},
+	{'u', MP4C_UPDATE, "send a command (BIFS or LASeR) to the main scene", 0},
+	{'e', MP4C_EVALJS, "evaluate JavaScript code in the main scene", 0},
+	{'Z', MP4C_SCREENSHOT, "dump current output frame to PNG", 0},
+	{'w', MP4C_WORLDINFO, "view world info", 0},
+	{ 'v', MP4C_ODLIST, "view list of active media objects in scene", 0},
+	{ 'i', MP4C_ODINFO_ID, "view Object Descriptor info (by ID)", 0},
+	{ 'j', MP4C_ODINFO_NUM, "view Object Descriptor info (by number)", 0},
+	{ 'b', MP4C_ODTIME, "view media objects timing and buffering info", 0},
+	{ 'm', MP4C_ODBUF, "view media objects buffering and memory info", 0},
+	{ 'd', MP4C_DUMPSCENE, "dump scene graph", 0},
+	{ 'k', MP4C_STRESSMODE, "turn stress mode on/off", 0},
+	{ 'n', MP4C_NAVMODE, "change navigation mode", 0},
+	{ 'x', MP4C_LASTVP, "reset to last active viewpoint", 0},
+	{ '3', MP4C_OGL2D, "switch OpenGL on or off for 2D scenes", 0},
+	{ '4', MP4C_AR_4_3, "force 4/3 Aspect Ratio", 0},
+	{ '5', MP4C_AR_16_9, "force 16/9 Aspect Ratio", 0},
+	{ '6', MP4C_AR_NONE, "force no Aspect Ratio (always fill screen)", 0},
+	{ '7', MP4C_AR_ORIG, "force original Aspect Ratio (default)", 0},
+	{ 'H', MP4C_DOWNRATE, "set HTTP max download rate", 0},
+	{ 'E', MP4C_RELOAD_OPTS, "force reload of compositor options", 0},
+
+	{ 'L', MP4C_LOGS, "change to new log tool/level. CF MP4Client usage for possible values", 0},
+	{ 'R', MP4C_DISP_RTI, "toggle run-time info display in window title bar on/off", 0},
+	{ 'F', MP4C_DISP_FPS, "toggle displaying of FPS in stderr on/off", 0},
+	{ 'f', MP4C_DISP_STATS, "print filter session stats", 0},
+	{ 'g', MP4C_DISP_GRAPH, "print filter session graph", 0},
+
+	{ 'h', MP4C_HELP, "print this message", 0},
+	//below this, only experimental features
+	{ 'M', MP4C_VMEM_CACHE, "specify video cache memory for 2D objects", 1},
+	{0}
+};
+
+MP4C_Command get_cmd(u8 char_code)
+{
+	u32 i=0;
+	while (MP4C_Keysi.char_code) {
+		if (MP4C_Keysi.char_code == char_code)
+			return MP4C_Keysi.cmd_type;
+		i++;
+	}
+	return 0;
+}
+
+void PrintHelp()
+{
+	u32 i=0;
+
+	gf_sys_format_help(helpout, help_flags, "# MP4Client runtime commands\n"
+		"## Prompt Interaction\n"
+		"The following keys are used for prompt interaction:\n");
+
+	while (MP4C_Keysi.char_code) {
+		struct _mp4c_key *k = &MP4C_Keysi;
+		i++;
+		gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%c: %s%s\n", k->char_code, k->cmd_help, k->flags ? " **! experimental !**" : "");
+	}
+
+	gf_sys_format_help(helpout, help_flags, "\n"
+		"## Content interaction\n"
+		"It is possible to interact with content (interactive or not) using mouse and keyboard.\n"
+		"The following commands are available:\n"
+		"TODO\n"
+		"\n"
+	);
+}
+
+
+static void PrintTime(u64 time)
+{
+	u32 ms, h, m, s;
+	h = (u32) (time / 1000 / 3600);
+	m = (u32) (time / 1000 / 60 - h*60);
+	s = (u32) (time / 1000 - h*3600 - m*60);
+	ms = (u32) (time - (h*3600 + m*60 + s) * 1000);
+	fprintf(stderr, "%02d:%02d:%02d.%03d", h, m, s, ms);
+}
+
+
+static u32 rti_update_time_ms = 200;
+static FILE *rti_logs = NULL;
+
+static void UpdateRTInfo(const char *legend)
+{
+	GF_SystemRTInfo rti;
+
+	/*refresh every second*/
+	if (!Run) return;
+	if (!display_rti && !rti_logs) return;
+	if (!gf_sys_get_rti(rti_update_time_ms, &rti, 0) && !legend)
+		return;
+
+	if (display_rti) {
+		char szMsg1024;
+
+		if (rti.total_cpu_usage && (bench_mode<2) ) {
+			sprintf(szMsg, "FPS %02.02f CPU %2d (%02d) Mem %d kB",
+			 gf_term_get_framerate(term, 0), rti.total_cpu_usage, rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024));
+		} else {
+			sprintf(szMsg, "FPS %02.02f CPU %02d Mem %d kB",
+			 gf_term_get_framerate(term, 0), rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024) );
+		}
+
+		if (display_rti==2) {
+			if (bench_mode>=2) {
+				PrintAVInfo(GF_FALSE);
+			}
+			fprintf(stderr, "%s\r", szMsg);
+		} else {
+			GF_Event evt;
+			evt.type = GF_EVENT_SET_CAPTION;
+			evt.caption.caption = szMsg;
+			gf_term_user_event(term, &evt);
+		}
+	}
+	if (rti_logs) {
+		fprintf(rti_logs, "% 8d\t% 8d\t% 8d\t% 4d\t% 8d\t%s",
+		 gf_sys_clock(),
+		 gf_term_get_time_in_ms(term),
+		 rti.total_cpu_usage,
+		 (u32) gf_term_get_framerate(term, 0),
+		 (u32) (rti.gpac_memory / 1024),
+		 legend ? legend : ""
+		 );
+		if (!legend) fprintf(rti_logs, "\n");
+	}
+}
+
+#include <gpac/revision.h>
+#define MP4CLIENT_CAPTION	"GPAC MP4Client "GPAC_VERSION "-rev" GPAC_GIT_REVISION
+
+static void ResetCaption()
+{
+	GF_Event event;
+	if (display_rti) return;
+	event.type = GF_EVENT_SET_CAPTION;
+	event.caption.caption = NULL;
+
+	if (is_connected) {
+		char szName1024;
+		GF_TermURLInfo urli;
+
+		/*get any service info*/
+		if (!startup_file && gf_term_get_service_info(term, gf_term_get_root_object(term), &urli) == GF_OK) {
+			strcpy(szName, "");
+			if (urli.track_num) {
+				char szBuf10;
+				sprintf(szBuf, "%02d ", (u32) urli.track_num );
+				strcat(szName, szBuf);
+			}
+			if (urli.artist) {
+				strcat(szName, urli.artist);
+				strcat(szName, " ");
+			}
+			if (urli.name) {
+				strcat(szName, urli.name);
+				strcat(szName, " ");
+			}
+			if (urli.album) {
+				strcat(szName, "(");
+				strcat(szName, urli.album);
+				strcat(szName, ")");
+			}
+			if (urli.provider) {
+				strcat(szName, "(");
+				strcat(szName, urli.provider);
+				strcat(szName, ")");
+			}
+			if (strlen(szName)) event.caption.caption = szName;
+		}
+		if (!event.caption.caption) {
+			char *str = strrchr(the_url, '\\');
+			if (!str) str = strrchr(the_url, '/');
+			event.caption.caption = str ? str+1 : the_url;
+		}
+	} else {
+		event.caption.caption = MP4CLIENT_CAPTION;
+	}
+	gf_term_user_event(term, &event);
+}
+
+#ifdef WIN32
+u32 get_sys_col(int idx)
+{
+	u32 res;
+	DWORD val = GetSysColor(idx);
+	res = (val)&0xFF;
+	res<<=8;
+	res |= (val>>8)&0xFF;
+	res<<=8;
+	res |= (val>>16)&0xFF;
+	return res;
+}
+#endif
+
+void switch_bench(u32 is_on)
+{
+	bench_mode = is_on;
+	display_rti = is_on ? 2 : 0;
+	ResetCaption();
+	gf_term_set_option(term, GF_OPT_VIDEO_BENCH, is_on);
+}
+
+#ifdef GPAC_ENABLE_COVERAGE
+#define gf_getch() 0
+#define gf_read_line_input(_line, _maxSize, _showContent) GF_FALSE
+#endif //!GPAC_ENABLE_COVERAGE
+
+static void do_set_speed(Fixed desired_speed)
+{
+	if (gf_term_set_speed(term, desired_speed) == GF_OK) {
+		playback_speed = desired_speed;
+		fprintf(stderr, "Playing at %g speed\n", FIX2FLT(playback_speed));
+	} else {
+		fprintf(stderr, "Adjusting speed to %g not supported for this content\n", FIX2FLT(desired_speed));
+	}
+}
+
+Bool GPAC_EventProc(void *ptr, GF_Event *evt)
+{
+	if (!term) return 0;
+
+	if (gui_mode==1) {
+		if (evt->type==GF_EVENT_QUIT) {
+			Run = 0;
+			if (evt->message.error>0)
+				ret_val = evt->message.error;
+		} else if (evt->type==GF_EVENT_KEYDOWN) {
+			switch (evt->key.key_code) {
+			case GF_KEY_C:
+				if (evt->key.flags & (GF_KEY_MOD_CTRL|GF_KEY_MOD_ALT)) {
+					hide_shell(shell_visible ? 1 : 0);
+					if (shell_visible) gui_mode=2;
+				}
+				break;
+			default:
+				break;
+			}
+		}
+		return 0;
+	}
+
+	switch (evt->type) {
+	case GF_EVENT_DURATION:
+		Duration = (u64) ( 1000 * (s64) evt->duration.duration);
+		CanSeek = evt->duration.can_seek;
+		break;
+	case GF_EVENT_MESSAGE:
+	{
+		const char *servName;
+		if (!evt->message.service || !strcmp(evt->message.service, the_url)) {
+			servName = "";
+		} else if (!strnicmp(evt->message.service, "data:", 5)) {
+			servName = "(embedded data)";
+		} else {
+			servName = evt->message.service;
+		}
+
+
+		if (!evt->message.message) return 0;
+
+		if (evt->message.error) {
+			if (!is_connected) last_error = evt->message.error;
+			if (evt->message.error==GF_SCRIPT_INFO) {
+				GF_LOG(GF_LOG_INFO, GF_LOG_CONSOLE, ("%s\n", evt->message.message));
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONSOLE, ("%s %s: %s\n", servName, evt->message.message, gf_error_to_string(evt->message.error)));
+			}
+		} else {
+			GF_LOG(GF_LOG_INFO, GF_LOG_CONSOLE, ("%s %s\n", servName, evt->message.message));
+		}
+	}
+	break;
+	case GF_EVENT_PROGRESS:
+	{
+		char *szTitle = "";
+		if (evt->progress.progress_type==0) {
+			szTitle = "Buffer ";
+			if (bench_mode && (bench_mode!=3) ) {
+				if (evt->progress.done >= evt->progress.total) bench_buffer = 0;
+				else bench_buffer = 1 + 100*evt->progress.done / evt->progress.total;
+				break;
+			}
+		}
+		else if (evt->progress.progress_type==1) {
+			if (bench_mode) break;
+			szTitle = "Download ";
+		}
+		else if (evt->progress.progress_type==2) szTitle = "Import ";
+		gf_set_progress(szTitle, evt->progress.done, evt->progress.total);
+	}
+	break;
+
+
+	case GF_EVENT_DBLCLICK:
+		gf_term_set_option(term, GF_OPT_FULLSCREEN, !gf_term_get_option(term, GF_OPT_FULLSCREEN));
+		return 0;
+
+	case GF_EVENT_MOUSEDOWN:
+		if (evt->mouse.button==GF_MOUSE_RIGHT) {
+			right_down = 1;
+			last_x = evt->mouse.x;
+			last_y = evt->mouse.y;
+		}
+		return 0;
+	case GF_EVENT_MOUSEUP:
+		if (evt->mouse.button==GF_MOUSE_RIGHT) {
+			right_down = 0;
+			last_x = evt->mouse.x;
+			last_y = evt->mouse.y;
+		}
+		return 0;
+	case GF_EVENT_MOUSEMOVE:
+		if (right_down && (user.init_flags & GF_VOUT_WINDOWLESS) ) {
+			GF_Event move;
+			move.move.x = evt->mouse.x - last_x;
+			move.move.y = last_y-evt->mouse.y;
+			move.type = GF_EVENT_MOVE;
+			move.move.relative = 1;
+			gf_term_user_event(term, &move);
+		}
+		return 0;
+
+	case GF_EVENT_KEYUP:
+		switch (evt->key.key_code) {
+		case GF_KEY_SPACE:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) switch_bench(!bench_mode);
+			break;
+		}
+		break;
+	case GF_EVENT_KEYDOWN:
+		switch (evt->key.key_code) {
+		case GF_KEY_SPACE:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) {
+				/*ignore key repeat*/
+				if (!bench_mode) switch_bench(!bench_mode);
+			}
+			break;
+		case GF_KEY_PAGEDOWN:
+		case GF_KEY_MEDIANEXTTRACK:
+			request_next_playlist_item = 1;
+			break;
+		case GF_KEY_MEDIAPREVIOUSTRACK:
+			break;
+		case GF_KEY_ESCAPE:
+			gf_term_set_option(term, GF_OPT_FULLSCREEN, !gf_term_get_option(term, GF_OPT_FULLSCREEN));
+			break;
+		case GF_KEY_C:
+			if (evt->key.flags & (GF_KEY_MOD_CTRL|GF_KEY_MOD_ALT)) {
+				hide_shell(shell_visible ? 1 : 0);
+				if (!shell_visible) gui_mode=1;
+			}
+			break;
+		case GF_KEY_F:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) fprintf(stderr, "Rendering rate: %f FPS\n", gf_term_get_framerate(term, 0));
+			break;
+		case GF_KEY_T:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) fprintf(stderr, "Scene Time: %f \n", gf_term_get_time_in_ms(term)/1000.0);
+			break;
+		case GF_KEY_D:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) gf_term_set_option(term, GF_OPT_DRAW_MODE, (gf_term_get_option(term, GF_OPT_DRAW_MODE)==GF_DRAW_MODE_DEFER) ? GF_DRAW_MODE_IMMEDIATE : GF_DRAW_MODE_DEFER );
+			break;
+		case GF_KEY_4:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
+			break;
+		case GF_KEY_5:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
+			break;
+		case GF_KEY_6:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
+			break;
+		case GF_KEY_7:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
+			break;
+		case GF_KEY_O:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				if (gf_term_get_option(term, GF_OPT_MAIN_ADDON)) {
+					fprintf(stderr, "Resuming to main content\n");
+					gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PLAY_LIVE);
+				} else {
+					fprintf(stderr, "Main addon not enabled\n");
+				}
+			}
+			break;
+		case GF_KEY_P:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				u32 pause_state = gf_term_get_option(term, GF_OPT_PLAY_STATE) ;
+				fprintf(stderr, "Status: %s\n", pause_state ? "Playing" : "Paused");
+				if ((pause_state == GF_STATE_PAUSED) && (evt->key.flags & GF_KEY_MOD_SHIFT)) {
+					gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PLAY_LIVE);
+				} else {
+					gf_term_set_option(term, GF_OPT_PLAY_STATE, (pause_state==GF_STATE_PAUSED) ? GF_STATE_PLAYING : GF_STATE_PAUSED);
+				}
+			}
+			break;
+		case GF_KEY_S:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+				fprintf(stderr, "Step time: ");
+				PrintTime(gf_term_get_time_in_ms(term));
+				fprintf(stderr, "\n");
+			}
+			break;
+		case GF_KEY_B:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected)
+				ViewODs(term, 1);
+			break;
+		case GF_KEY_M:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected)
+				ViewODs(term, 0);
+			break;
+		case GF_KEY_H:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				gf_term_switch_quality(term, 1);
+			//	gf_term_set_option(term, GF_OPT_MULTIVIEW_MODE, 0);
+			}
+			break;
+		case GF_KEY_L:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				gf_term_switch_quality(term, 0);
+			//	gf_term_set_option(term, GF_OPT_MULTIVIEW_MODE, 1);
+			}
+			break;
+		case GF_KEY_F5:
+			if (is_connected)
+				reload = 1;
+			break;
+		case GF_KEY_A:
+			addon_visible = !addon_visible;
+			gf_term_toggle_addons(term, addon_visible);
+			break;
+		case GF_KEY_UP:
+			if ((evt->key.flags & VK_MOD) && is_connected) {
+				do_set_speed(playback_speed * 2);
+			}
+			break;
+		case GF_KEY_DOWN:
+			if ((evt->key.flags & VK_MOD) && is_connected) {
+				do_set_speed(playback_speed / 2);
+			}
+			break;
+		case GF_KEY_LEFT:
+			if ((evt->key.flags & VK_MOD) && is_connected) {
+				do_set_speed(-1 * playback_speed );
+			}
+			break;
+
+		}
+		break;
+
+	case GF_EVENT_CONNECT:
+		if (evt->connect.is_connected) {
+			is_connected = 1;
+			fprintf(stderr, "Service Connected\n");
+			eos_seen = GF_FALSE;
+			if (playback_speed != FIX_ONE)
+				gf_term_set_speed(term, playback_speed);
+
+			if (do_coverage) {
+				gf_term_switch_quality(term, 1);
+			}
+
+		} else if (is_connected) {
+			fprintf(stderr, "Service %s\n", is_connected ? "Disconnected" : "Connection Failed");
+			is_connected = 0;
+			Duration = 0;
+		}
+		if (init_w && init_h) {
+			gf_term_set_size(term, init_w, init_h);
+		}
+		ResetCaption();
+		break;
+	case GF_EVENT_EOS:
+		eos_seen = GF_TRUE;
+		if (playlist) {
+			if (Duration>1500)
+				request_next_playlist_item = GF_TRUE;
+		}
+		else if (loop_at_end) {
+			restart = 1;
+		}
+		break;
+	case GF_EVENT_SIZE:
+		if (user.init_flags & GF_VOUT_WINDOWLESS) {
+			GF_Event move;
+			move.type = GF_EVENT_MOVE;
+			move.move.align_x = align_mode & 0xFF;
+			move.move.align_y = (align_mode>>8) & 0xFF;
+			move.move.relative = 2;
+			gf_term_user_event(term, &move);
+		}
+		break;
+	case GF_EVENT_SCENE_SIZE:
+
+		if ((forced_width && forced_height) || scale) {
+			GF_Event size;
+			u32 nw = forced_width ? forced_width : evt->size.width;
+			u32 nh = forced_height ? forced_height : evt->size.height;
+
+			if (scale != 1) {
+				nw = (u32)(nw * scale);
+				nh = (u32)(nh * scale);
+			}
+			if ((nw != evt->size.width) || (nh != evt->size.height)) {
+				size.type = GF_EVENT_SIZE;
+				size.size.width = nw;
+				size.size.height = nh;
+				gf_term_user_event(term, &size);
+			}
+		}
+		break;
+
+	case GF_EVENT_METADATA:
+		ResetCaption();
+		break;
+	case GF_EVENT_DROPFILE:
+	{
+		u32 i, pos;
+		/*todo - force playlist mode*/
+		if (readonly_playlist) {
+			gf_fclose(playlist);
+			playlist = NULL;
+		}
+		readonly_playlist = 0;
+		if (!playlist) {
+			readonly_playlist = 0;
+			playlist = gf_file_temp(NULL);
+		}
+		pos = (u32) gf_ftell(playlist);
+		i=0;
+		while (i<evt->open_file.nb_files) {
+			if (evt->open_file.filesi != NULL) {
+				fprintf(playlist, "%s\n", evt->open_file.filesi);
+			}
+			i++;
+		}
+		gf_fseek(playlist, pos, SEEK_SET);
+		request_next_playlist_item = 1;
+	}
+	return 1;
+
+	case GF_EVENT_QUIT:
+		if (evt->message.error<0) {
+			fprintf(stderr, "A fatal error was encoutered: %s (%s) - exiting ...\n", evt->message.message ? evt->message.message : "no details", gf_error_to_string(evt->message.error) );
+		} else {
+			ret_val = evt->message.error;
+		}
+		Run = 0;
+		break;
+	case GF_EVENT_DISCONNECT:
+		gf_term_disconnect(term);
+		break;
+	case GF_EVENT_MIGRATE:
+	{
+	}
+	break;
+	case GF_EVENT_NAVIGATE_INFO:
+		if (evt->navigate.to_url)
+			fprintf(stderr, "Go to URL: \"%s\"\r", evt->navigate.to_url);
+		break;
+	case GF_EVENT_NAVIGATE:
+		if (gf_term_is_supported_url(term, evt->navigate.to_url, 1, no_mime_check)) {
+			strncpy(the_url, evt->navigate.to_url, sizeof(the_url)-1);
+			the_urlsizeof(the_url) - 1 = 0;
+			fprintf(stderr, "Navigating to URL %s\n", the_url);
+			gf_term_navigate_to(term, evt->navigate.to_url);
+			return 1;
+		} else {
+			fprintf(stderr, "Navigation destination not supported\nGo to URL: %s\n", evt->navigate.to_url);
+		}
+		break;
+	case GF_EVENT_SET_CAPTION:
+		gf_term_user_event(term, evt);
+		break;
+	case GF_EVENT_AUTHORIZATION:
+	{
+		u32 nb_retry = 4;
+		assert( evt->type == GF_EVENT_AUTHORIZATION);
+		assert( evt->auth.user);
+		assert( evt->auth.password);
+		assert( evt->auth.site_url);
+		while ((!strlen(evt->auth.user) || !strlen(evt->auth.password)) && (nb_retry > 0) ) {
+			nb_retry--;
+			fprintf(stderr, "**** Authorization required for site %s ****\n", evt->auth.site_url);
+			fprintf(stderr, "login : ");
+			if (!gf_read_line_input(evt->auth.user, 50, 1))
+				continue;
+			fprintf(stderr, "\npassword: ");
+			if (!gf_read_line_input(evt->auth.password, 50, 0))
+				continue;
+			fprintf(stderr, "*********\n");
+		}
+		if (nb_retry == 0) {
+			fprintf(stderr, "**** No User or password has been filled, aborting ***\n");
+			return 0;
+		}
+		return 1;
+	}
+	case GF_EVENT_ADDON_DETECTED:
+		if (enable_add_ons) {
+			fprintf(stderr, "Media Addon %s detected - enabling it\n", evt->addon_connect.addon_url);
+			addon_visible = 1;
+		}
+		return enable_add_ons;
+	}
+	return 0;
+}
+
+
+void list_modules()
+{
+	u32 i;
+	fprintf(stderr, "\rAvailable modules:\n");
+	for (i=0; i<gf_modules_count(); i++) {
+		char *str = (char *) gf_modules_get_file_name(i);
+		if (str) fprintf(stderr, "\t%s\n", str);
+	}
+	fprintf(stderr, "\n");
+}
+
+void set_navigation()
+{
+	GF_Err e;
+	char nav;
+	u32 type = gf_term_get_option(term, GF_OPT_NAVIGATION_TYPE);
+	e = GF_OK;
+//	fflush(stdin);
+
+	if (!type) {
+		fprintf(stderr, "Content/compositor doesn't allow user-selectable navigation\n");
+	} else if (type==1) {
+		fprintf(stderr, "Select Navigation (\'N\'one, \'E\'xamine, \'S\'lide): ");
+		nav = do_coverage ? 'N' : gf_getch();
+		if (nav=='N') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
+		else if (nav=='E') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
+		else if (nav=='S') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
+		else fprintf(stderr, "Unknown selector \'%c\' - only \'N\',\'E\',\'S\' allowed\n", nav);
+	} else if (type==2) {
+		fprintf(stderr, "Select Navigation (\'N\'one, \'W\'alk, \'F\'ly, \'E\'xamine, \'P\'an, \'S\'lide, \'G\'ame, \'V\'R, \'O\'rbit): ");
+		nav = do_coverage ? 'N' : gf_getch();
+		if (nav=='N') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
+		else if (nav=='W') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_WALK);
+		else if (nav=='F') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_FLY);
+		else if (nav=='E') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
+		else if (nav=='P') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_PAN);
+		else if (nav=='S') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
+		else if (nav=='G') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_GAME);
+		else if (nav=='O') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_ORBIT);
+		else if (nav=='V') e = gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_VR);
+		else fprintf(stderr, "Unknown selector %c - only \'N\',\'W\',\'F\',\'E\',\'P\',\'S\',\'G\', \'V\', \'O\' allowed\n", nav);
+	}
+	if (e) fprintf(stderr, "Error setting mode: %s\n", gf_error_to_string(e));
+}
+
+
+static void on_rti_log(void *cbk, GF_LOG_Level ll, GF_LOG_Tool lm, const char *fmt, va_list list)
+{
+	if (rti_logs && (lm & GF_LOG_RTI)) {
+		char szMsg2048;
+		vsnprintf(szMsg, 2048, fmt, list);
+		UpdateRTInfo(szMsg + 6 /*"RTI "*/);
+	}
+}
+
+static void init_rti_logs(char *rti_file, char *url, Bool use_rtix)
+{
+	if (rti_logs) gf_fclose(rti_logs);
+	rti_logs = gf_fopen(rti_file, "wt");
+	if (rti_logs) {
+		fprintf(rti_logs, "!! GPAC RunTime Info ");
+		if (url) fprintf(rti_logs, "for file %s", url);
+		fprintf(rti_logs, " !!\n");
+		fprintf(rti_logs, "SysTime(ms)\tSceneTime(ms)\tCPU\tFPS\tMemory(kB)\tObservation\n");
+
+		/*turn on RTI loging*/
+		if (use_rtix) {
+			gf_log_set_callback(NULL, on_rti_log);
+			gf_log_set_tool_level(GF_LOG_RTI, GF_LOG_DEBUG);
+
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_RTI, ("RTI System state when enabling log\n"));
+		} else if (log_rti_time_start) {
+			log_rti_time_start = gf_sys_clock_high_res();
+		}
+	}
+}
+
+
+#ifdef WIN32
+#include <wincon.h>
+#endif
+
+int mp4client_main(int argc, char **argv)
+{
+	char c;
+	MP4C_Command cmdtype;
+	const char *str;
+	GF_Err e;
+	u32 i, ll;
+	u32 simulation_time_in_ms = 0;
+	u32 initial_service_id = 0;
+	Bool auto_exit = GF_FALSE;
+	Bool start_fs = GF_FALSE;
+	Bool use_rtix = GF_FALSE;
+	Bool pause_at_first = GF_FALSE;
+	Bool no_cfg_save = GF_FALSE;
+	Bool print_stats = GF_FALSE;
+	Bool print_graph = GF_FALSE;
+	Bool no_keyboard = GF_FALSE;
+	Double play_from = 0;
+#ifdef GPAC_MEMORY_TRACKING
+ GF_MemTrackerType mem_track = GF_MemTrackerNone;
+#endif
+	Bool has_command;
+	char *url_arg, *gpac_profile, *rti_file;
+	FILE *logfile = NULL;
+#ifndef WIN32
+	dlopen(NULL, RTLD_NOW|RTLD_GLOBAL);
+#endif
+
+	helpout = stdout;
+
+	/*by default use current dir*/
+	strcpy(the_url, ".");
+
+	memset(&user, 0, sizeof(GF_User));
+
+	has_command = GF_FALSE;
+	url_arg = gpac_profile = rti_file = NULL;
+
+	/*first identify profile and mem tracking */
+	for (i=1; i<(u32) argc; i++) {
+		char *arg = argvi;
+		if (!strcmp(arg, "-p")) {
+			gpac_profile = argvi+1;
+			i++;
+		} else if (!strncmp(arg, "-p=", 3)) {
+			gpac_profile = argvi+3;
+		} else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
+#ifdef GPAC_MEMORY_TRACKING
+ mem_track = !strcmp(arg, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
+#else
+			fprintf(stderr, "WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", arg);
+#endif
+		} else if (!strcmp(arg, "-gui")) {
+			gui_mode = 1;
+		} else if (!strcmp(arg, "-guid")) {
+			gui_mode = 2;
+		} else if (!strcmp(arg, "-h") || !strcmp(arg, "-help")) {
+			PrintUsage(GF_FALSE);
+			return 0;
+		} else if (!strcmp(arg, "-hx")) {
+			PrintUsage(GF_TRUE);
+			return 0;
+		} else if (!strcmp(arg, "-hr")) {
+			PrintHelp();
+			return 0;
+		} else if (!strcmp(arg, "-hc")) {
+			fprintf(helpout, "libgpac options:\n");
+			gf_sys_print_core_help(helpout, help_flags, GF_ARGMODE_ALL, 0);
+			return 0;
+		}
+	}
+
+#ifdef GPAC_MEMORY_TRACKING
+	gf_sys_init(mem_track, gpac_profile);
+#else
+	gf_sys_init(GF_MemTrackerNone, gpac_profile);
+#endif
+
+	gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_WARNING);
+	//we by default want 2 additional threads:
+	//main thread might get locked on vsync
+	//second thread might be busy decoding audio/video
+	//third thread will then be able to refill all buffers/perform networks tasks
+	gf_opts_set_key("temp", "threads", "2");
+
+	e = gf_sys_set_args(argc, (const char **) argv);
+	if (e) {
+		fprintf(stderr, "Error assigning libgpac arguments: %s\n", gf_error_to_string(e) );
+		gf_sys_close();
+		return 1;
+	}
+
+	if (!gui_mode) {
+		str = gf_opts_get_key("General", "ForceGUI");
+		if (str && !strcmp(str, "yes")) gui_mode = 1;
+	}
+
+	for (i=1; i<(u32) argc; i++) {
+		char *arg = argvi;
+
+		if (!strcmp(arg, "-genmd")) {
+			help_flags = GF_PRINTARG_MD;
+			helpout = gf_fopen("mp4client.md", "w");
+
+	 		fprintf(helpout, "**HOME**(Home) » MP4Client \n");
+	 		fprintf(helpout, "\n");
+			PrintUsage(GF_TRUE);
+			PrintHelp();
+			gf_fclose(helpout);
+			gf_sys_close();
+			return 0;
+		} else if (!strcmp(arg, "-genman")) {
+			help_flags = GF_PRINTARG_MAN;
+			helpout = gf_fopen("mp4client.1", "w");
+
+
+	 		fprintf(helpout, ".TH MP4Client 1 2019 MP4Client GPAC\n");
+			fprintf(helpout, ".\n.SH NAME\n.LP\nMP4Client \\- GPAC command-line media player\n.SH SYNOPSIS\n.LP\n.B MP4Client\n.RI options \\ file\n.br\n.\n");
+
+	 		PrintUsage(GF_TRUE);
+			PrintHelp();
+
+			fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/mp4client\n");
+			fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
+			".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
+			".br\nbuild: %s\n"
+			".br\nCopyright: %s\n.br\n"
+			".SH SEE ALSO\n"
+			".LP\ngpac(1), MP4Box(1)\n", gf_gpac_version(), gf_gpac_copyright());
+
+			gf_fclose(helpout);
+			gf_sys_close();
+			return 0;
+		} else if (!strcmp(arg, "-rti")) {
+			rti_file = argvi+1;
+			i++;
+		} else if (!strcmp(arg, "-rtix")) {
+			rti_file = argvi+1;
+			i++;
+			use_rtix = GF_TRUE;
+		} else if (!strcmp(arg, "-rti-refresh")) {
+			rti_update_time_ms = atoi(argvi+1);
+			i++;
+		} else if (!stricmp(arg, "-size")) {
+			/*usage of %ud breaks sscanf on MSVC*/
+			if (sscanf(argvi+1, "%dx%d", &forced_width, &forced_height) != 2) {
+				forced_width = forced_height = 0;
+			}
+			i++;
+		}
+		//libgpac opts using an argument
+		else if (!strcmp(arg, "-log-file") || !strcmp(arg, "-lf") || !strcmp(arg, "-logs") || !strcmp(arg, "-cfg") || !strcmp(arg, "-ifce") ) {
+			i++;
+		}
+
+		else if (!strcmp(arg, "-no-thread")) {
+			gf_opts_set_key("temp", "threads", "0");
+		}
+		else if (!strcmp(arg, "-no-audio")) {
+			no_audio = GF_TRUE;
+		}
+		else if (!strcmp(arg, "-fs")) start_fs = 1;
+		else if (!stricmp(arg, "-no-save") || !stricmp(arg, "--no-save") /*old versions used --n-save ...*/) {
+			no_cfg_save=1;
+		}
+		else if (!stricmp(arg, "-run-for")) {
+			simulation_time_in_ms = (u32) (atof(argvi+1) * 1000);
+			if (!simulation_time_in_ms)
+				simulation_time_in_ms = 1; /*1ms*/
+			i++;
+		} else if (!stricmp(arg, "-scale")) {
+			sscanf(argvi+1, "%f", &scale);
+			i++;
+		}
+		/* already parsed */
+		else if (!strcmp(arg, "-nk")) {
+			no_keyboard = GF_TRUE;
+		}
+		/* already parsed */
+		else if (!strcmp(arg, "-p")) {
+			i++;
+		}
+		/* already parsed */
+		else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack") || !strcmp(arg, "-gui") || !strcmp(arg, "-guid")
+			 || !strncmp(arg, "-p=", 3)
+		) {
+		}
+
+		/*arguments only used in non-gui mode*/
+		else if (!gui_mode) {
+			if (arg0 != '-') {
+				if (url_arg) {
+					fprintf(stderr, "Several input URLs provided (\"%s\", \"%s\"). Check your command-line.\n", url_arg, arg);
+					return 1;
+				}
+				url_arg = arg;
+			}
+			else if (!strcmp(arg, "-loop")) loop_at_end = 1;
+			else if (!strcmp(arg, "-bench")) bench_mode = 1;
+			else if (!strcmp(arg, "-vbench")) bench_mode = 2;
+			else if (!strcmp(arg, "-sbench")) bench_mode = 3;
+			else if (!strcmp(arg, "-no-addon")) enable_add_ons = GF_FALSE;
+
+			else if (!strcmp(arg, "-pause")) pause_at_first = 1;
+			else if (!strcmp(arg, "-play-from")) {
+				play_from = atof((const char *) argvi+1);
+				i++;
+			}
+			else if (!strcmp(arg, "-speed")) {
+				playback_speed = FLT2FIX( atof((const char *) argvi+1) );
+				if (playback_speed <= 0) playback_speed = FIX_ONE;
+				i++;
+			}
+			else if (!strcmp(arg, "-no-wnd")) user.init_flags |= GF_VOUT_WINDOWLESS;
+			else if (!strcmp(arg, "-no-back")) user.init_flags |= GF_VOUT_WINDOW_NO_DECORATION;
+			else if (!strcmp(arg, "-align")) {
+				if (argvi+10=='m') align_mode = 1;
+				else if (argvi+10=='b') align_mode = 2;
+				align_mode <<= 8;
+				if (argvi+11=='m') align_mode |= 1;
+				else if (argvi+11=='r') align_mode |= 2;
+				i++;
+			}
+			else if (!strcmp(arg, "-exit")) auto_exit = GF_TRUE;
+			else if (!stricmp(arg, "-com")) {
+				has_command = GF_TRUE;
+				i++;
+			}
+			else if (!stricmp(arg, "-service")) {
+				initial_service_id = atoi(argvi+1);
+				i++;
+			} else if (!stricmp(arg, "-stats")) {
+				print_stats=GF_TRUE;
+			} else if (!stricmp(arg, "-graph")) {
+				print_graph=GF_TRUE;
+			} else if (!stricmp(arg, "-cov")) {
+				do_coverage = GF_TRUE;
+				print_stats = GF_TRUE;
+				print_graph = GF_TRUE;
+			} else {
+				u32 res = gf_sys_is_gpac_arg(arg);
+				if (!res) {
+					fprintf(stderr, "Unrecognized option %s\n", arg);
+				} else if (res==2) {
+					i++;
+				}
+			}
+		} else if (gf_sys_is_gpac_arg(arg)==2) {
+			i++;
+		}
+ 	}
+
+	//will run switch helpout to stderr
+	helpout = stderr;
+
+	if (!gui_mode && !url_arg && (gf_opts_get_key("General", "StartupFile") != NULL)) {
+		gui_mode=1;
+	}
+
+#ifdef WIN32
+	if (gui_mode==1) {
+		const char *opt;
+		TCHAR buffer1024;
+		DWORD res = GetCurrentDirectory(1024, buffer);
+		bufferres = 0;
+		opt = gf_opts_get_key("core", "module-dir");
+		if (strstr(opt, buffer)) {
+			gui_mode=1;
+		} else {
+			gui_mode=2;
+		}
+	}
+#endif
+
+	if (gui_mode==1) {
+		hide_shell(1);
+	}
+	if (gui_mode) {
+		gf_sys_set_cfg_option("core:noprog=yes");
+	}
+
+#if defined(__DARWIN__) || defined(__APPLE__)
+	carbon_init();
+#endif
+
+
+	if (rti_file) init_rti_logs(rti_file, url_arg, use_rtix);
+
+	{
+		GF_SystemRTInfo rti;
+		if (gf_sys_get_rti(0, &rti, 0))
+			fprintf(stderr, "System info: %d MB RAM - %d cores\n", (u32) (rti.physical_memory/1024/1024), rti.nb_cores);
+	}
+
+
+	init_w = forced_width;
+	init_h = forced_height;
+
+	user.EventProc = GPAC_EventProc;
+	/*dummy in this case (global vars) but MUST be non-NULL*/
+	user.opaque = &user;
+
+	if (no_audio) gf_opts_set_key("temp", "no-audio", "yes");
+
+	if (bench_mode) {
+		gf_opts_discard_changes();
+		auto_exit = GF_TRUE;
+		if (bench_mode!=2)
+			gf_opts_set_key("temp", "no-video", "yes");
+	}
+
+	if (forced_width && forced_height) {
+		char dim50;
+		sprintf(dim, "%d", forced_width);
+		gf_opts_set_key("Temp", "DefaultWidth", dim);
+		sprintf(dim, "%d", forced_height);
+		gf_opts_set_key("Temp", "DefaultHeight", dim);
+	}
+
+	fprintf(stderr, "Loading GPAC Terminal\n");
+	i = gf_sys_clock();
+
+	term = gf_term_new(&user);
+	if (!term) {
+		fprintf(stderr, "\nInit error - check you have at least one video out and one rasterizer...\nFound modules:\n");
+		list_modules();
+		gf_opts_discard_changes();
+		gf_sys_close();
+		if (logfile) gf_fclose(logfile);
+		return 1;
+	}
+	fprintf(stderr, "Terminal Loaded in %d ms\n", gf_sys_clock()-i);
+
+	if (bench_mode) {
+		display_rti = 2;
+		gf_term_set_option(term, GF_OPT_VIDEO_BENCH, (bench_mode==3) ? 2 : 1);
+		if (bench_mode==1) bench_mode=2;
+	}
+
+	str = gf_opts_get_key("General", "NoMIMETypeFetch");
+	no_mime_check = (str && !stricmp(str, "yes")) ? 1 : 0;
+
+	if (gf_opts_get_bool("core", "proxy-on")) {
+		str = gf_opts_get_key("core", "proxy-name");
+		if (str) fprintf(stderr, "HTTP Proxy %s enabled\n", str);
+	}
+
+	if (rti_file) {
+		UpdateRTInfo("At GPAC load time\n");
+	}
+
+	Run = 1;
+
+	if (url_arg && !strcmp(url_arg, "NOGUI")) {
+		url_arg = NULL;
+	}
+	/*connect if requested*/
+	else if (!gui_mode && url_arg) {
+		char *ext;
+
+		if (strlen(url_arg) >= sizeof(the_url)) {
+			fprintf(stderr, "Input url %s is too long, truncating to %d chars.\n", url_arg, (int)(sizeof(the_url) - 1));
+			strncpy(the_url, url_arg, sizeof(the_url)-1);
+			the_urlsizeof(the_url) - 1 = 0;
+		}
+		else {
+			strcpy(the_url, url_arg);
+		}
+		ext = strrchr(the_url, '.');
+		//only local playlist - maybe we could remove and control through flist ?
+		if (ext && !strncmp("http", the_url, 4) && (!stricmp(ext, ".m3u") || !stricmp(ext, ".pls"))) {
+			e = GF_OK;
+			fprintf(stderr, "Opening Playlist %s\n", the_url);
+
+			strcpy(pl_path, the_url);
+			playlist = e ? NULL : gf_fopen(the_url, "rt");
+			readonly_playlist = 1;
+			if (playlist) {
+				request_next_playlist_item = GF_TRUE;
+			} else {
+				if (e)
+					fprintf(stderr, "Failed to open playlist %s: %s\n", the_url, gf_error_to_string(e) );
+				fprintf(stderr, "Hit 'h' for help\n\n");
+			}
+		} else {
+			fprintf(stderr, "Opening URL %s\n", the_url);
+			if (pause_at_first) fprintf(stderr, "Status: Paused\n");
+			gf_term_connect_from_time(term, the_url, (u64) (play_from*1000), pause_at_first);
+		}
+	} else {
+		fprintf(stderr, "Hit 'h' for help\n\n");
+		str = gf_opts_get_key("General", "StartupFile");
+		if (str) {
+			snprintf(the_url, sizeof(the_url)-1, "MP4Client %s", gf_gpac_version() );
+			the_urlsizeof(the_url) - 1 = 0;
+			gf_term_connect(term, str);
+			startup_file = 1;
+			is_connected = 1;
+		}
+	}
+	if (gui_mode==2) gui_mode=0;
+
+	if (start_fs) gf_term_set_option(term, GF_OPT_FULLSCREEN, 1);
+
+	if (bench_mode) {
+		rti_update_time_ms = 500;
+		bench_mode_start = gf_sys_clock();
+	}
+
+	if (simulation_time_in_ms)
+		simulation_time_in_ms += gf_sys_clock();
+
+
+	while (Run) {
+
+		/*we don't want getchar to block*/
+		if ((gui_mode==1) || (no_keyboard || !gf_prompt_has_input()) ) {
+			if (reload) {
+				reload = 0;
+				gf_term_disconnect(term);
+				gf_term_connect(term, startup_file ? gf_opts_get_key("General", "StartupFile") : the_url);
+			}
+			if (restart && gf_term_get_option(term, GF_OPT_IS_OVER)) {
+				restart = 0;
+				gf_term_play_from_time(term, 0, 0);
+			}
+			if (request_next_playlist_item) {
+				c = '\n';
+				request_next_playlist_item = 0;
+				goto force_input;
+			}
+
+			if (has_command && is_connected) {
+				has_command = GF_FALSE;
+				for (i=0; i<(u32)argc; i++) {
+					if (!strcmp(argvi, "-com")) {
+						gf_term_scene_update(term, NULL, argvi+1);
+						i++;
+					}
+				}
+			}
+			if (initial_service_id && is_connected) {
+				GF_ObjectManager *root_od = gf_term_get_root_object(term);
+				if (root_od) {
+					gf_term_select_service(term, root_od, initial_service_id);
+					initial_service_id = 0;
+				}
+			}
+
+			if (!use_rtix || display_rti) UpdateRTInfo(NULL);
+
+
+			gf_term_process_step(term);
+
+			if (auto_exit && eos_seen && gf_term_get_option(term, GF_OPT_IS_OVER)) {
+				Run = GF_FALSE;
+			}
+
+			/*sim time*/
+			if (simulation_time_in_ms
+			 && ( (gf_term_get_elapsed_time_in_ms(term)>simulation_time_in_ms) || (!url_arg && gf_sys_clock()>simulation_time_in_ms))
+			 ) {
+				Run = GF_FALSE;
+			}
+			continue;
+		}
+
+		c = gf_prompt_get_char();
+
+force_input:
+		if (c=='\n') cmdtype=MP4C_PL_NEXT;
+		else cmdtype = get_cmd(c);
+
+		switch (cmdtype) {
+		case MP4C_QUIT:
+		{
+			GF_Event evt;
+			memset(&evt, 0, sizeof(GF_Event));
+			evt.type = GF_EVENT_QUIT;
+			gf_term_send_event(term, &evt);
+		}
+//			Run = 0;
+		break;
+		case MP4C_KILL:
+			exit(0);
+			break;
+
+		case MP4C_OPEN:
+			startup_file = 0;
+			gf_term_disconnect(term);
+			fprintf(stderr, "Enter the absolute URL\n");
+			if (1 > scanf("%1023s", the_url)) {
+				fprintf(stderr, "Cannot read absolute URL, aborting\n");
+				break;
+			}
+			if (rti_file) init_rti_logs(rti_file, the_url, use_rtix);
+			gf_term_connect(term, the_url);
+			break;
+		case MP4C_OPEN_PL:
+			gf_term_disconnect(term);
+			fprintf(stderr, "Enter the absolute URL to the playlist\n");
+			if (1 > scanf("%1023s", the_url)) {
+				fprintf(stderr, "Cannot read the absolute URL, aborting.\n");
+				break;
+			}
+			playlist = gf_fopen(the_url, "rt");
+			if (playlist) {
+				if (1 >	fscanf(playlist, "%1023s", the_url)) {
+					fprintf(stderr, "Cannot read any URL from playlist, aborting.\n");
+					gf_fclose( playlist);
+					break;
+				}
+				fprintf(stderr, "Opening URL %s\n", the_url);
+				gf_term_connect(term, the_url);
+			}
+			break;
+		case MP4C_PL_NEXT:
+			if (playlist) {
+				int res;
+				gf_term_disconnect(term);
+
+				res = fscanf(playlist, "%1023s", the_url);
+				if ((res == EOF) && loop_at_end) {
+					gf_fseek(playlist, 0, SEEK_SET);
+					res = fscanf(playlist, "%1023s", the_url);
+				}
+				if (res == EOF) {
+					fprintf(stderr, "No more items - exiting\n");
+					Run = 0;
+				} else if (the_url0 == '#') {
+					request_next_playlist_item = GF_TRUE;
+				} else {
+					fprintf(stderr, "Opening URL %s\n", the_url);
+					gf_term_connect_with_path(term, the_url, pl_path);
+				}
+			}
+			break;
+		case MP4C_PL_JUMP:
+			if (playlist) {
+				u32 count;
+				gf_term_disconnect(term);
+				if (1 > scanf("%u", &count)) {
+					fprintf(stderr, "Cannot read number, aborting.\n");
+					break;
+				}
+				while (count) {
+					if (fscanf(playlist, "%1023s", the_url)) {
+						fprintf(stderr, "Failed to read line, aborting\n");
+						break;
+					}
+					count--;
+				}
+				fprintf(stderr, "Opening URL %s\n", the_url);
+				gf_term_connect(term, the_url);
+			}
+			break;
+		case MP4C_RELOAD:
+			if (is_connected)
+				reload = 1;
+			break;
+
+		case MP4C_DISCONNECT:
+			if (is_connected) gf_term_disconnect(term);
+			break;
+
+		case MP4C_PAUSE_RESUME:
+			if (is_connected) {
+				Bool is_pause = gf_term_get_option(term, GF_OPT_PLAY_STATE);
+				fprintf(stderr, "Status: %s\n", is_pause ? "Playing" : "Paused");
+				gf_term_set_option(term, GF_OPT_PLAY_STATE, is_pause ? GF_STATE_PLAYING : GF_STATE_PAUSED);
+			}
+			break;
+		case MP4C_STEP:
+			if (is_connected) {
+				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+				fprintf(stderr, "Step time: ");
+				PrintTime(gf_term_get_time_in_ms(term));
+				fprintf(stderr, "\n");
+			}
+			break;
+
+		case MP4C_SEEK:
+		case MP4C_SEEK_TIME:
+			if (!CanSeek || (Duration<=2000)) {
+				fprintf(stderr, "scene not seekable\n");
+			} else {
+				Double res;
+				s32 seekTo;
+				fprintf(stderr, "Duration: ");
+				PrintTime(Duration);
+				res = gf_term_get_time_in_ms(term);
+				if (cmdtype==MP4C_SEEK) {
+					res *= 100;
+					res /= (s64)Duration;
+					fprintf(stderr, " (current %.2f %%)\nEnter Seek percentage:\n", res);
+					if (scanf("%d", &seekTo) == 1) {
+						if (seekTo > 100) seekTo = 100;
+						res = (Double)(s64)Duration;
+						res /= 100;
+						res *= seekTo;
+						gf_term_play_from_time(term, (u64) (s64) res, 0);
+					}
+				} else {
+					u32 r, h, m, s;
+					fprintf(stderr, " - Current Time: ");
+					PrintTime((u64) res);
+					fprintf(stderr, "\nEnter seek time (Format: s, m:s or h:m:s):\n");
+					h = m = s = 0;
+					r =scanf("%d:%d:%d", &h, &m, &s);
+					if (r==2) {
+						s = m;
+						m = h;
+						h = 0;
+					}
+					else if (r==1) {
+						s = h;
+						m = h = 0;
+					}
+
+					if (r && (r<=3)) {
+						u64 time = h*3600 + m*60 + s;
+						gf_term_play_from_time(term, time*1000, 0);
+					}
+				}
+			}
+			break;
+
+		case MP4C_TIME:
+		{
+			if (is_connected) {
+				fprintf(stderr, "Current Time: ");
+				PrintTime(gf_term_get_time_in_ms(term));
+				fprintf(stderr, " - Duration: ");
+				PrintTime(Duration);
+				fprintf(stderr, "\n");
+			}
+		}
+		break;
+		case MP4C_WORLDINFO:
+			if (is_connected) PrintWorldInfo(term);
+			break;
+		case MP4C_ODLIST:
+			if (is_connected) PrintODList(term, NULL, 0, 0, "Root");
+			break;
+		case MP4C_ODINFO_ID:
+			if (is_connected) {
+				u32 ID;
+				fprintf(stderr, "Enter OD ID (0 for main OD): ");
+				fflush(stderr);
+				if (scanf("%ud", &ID) == 1) {
+					ViewOD(term, ID, (u32)-1, NULL);
+				} else {
+					char str_urlGF_MAX_PATH;
+					if (scanf("%1023s", str_url) == 1)
+						ViewOD(term, 0, (u32)-1, str_url);
+				}
+			}
+			break;
+		case MP4C_ODINFO_NUM:
+			if (is_connected) {
+				u32 num;
+				do {
+					fprintf(stderr, "Enter OD number (0 for main OD): ");
+					fflush(stderr);
+				} while( 1 > scanf("%ud", &num));
+				ViewOD(term, (u32)-1, num, NULL);
+			}
+			break;
+		case MP4C_ODTIME:
+			if (is_connected) ViewODs(term, 1);
+			break;
+
+		case MP4C_ODBUF:
+			if (is_connected) ViewODs(term, 0);
+			break;
+
+		case MP4C_NAVMODE:
+			if (is_connected) set_navigation();
+			break;
+		case MP4C_LASTVP:
+			if (is_connected) gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
+			break;
+
+		case MP4C_DUMPSCENE:
+			if (is_connected) {
+				GF_ObjectManager *odm = NULL;
+				char radnameGF_MAX_PATH, *sExt;
+				u32 count, odid;
+				Bool xml_dump, std_out;
+				radname0 = 0;
+				do {
+					fprintf(stderr, "Enter Inline OD ID if any or 0 : ");
+					fflush(stderr);
+				} while( 1 > scanf("%ud", &odid));
+				if (odid) {
+					GF_ObjectManager *root_odm = gf_term_get_root_object(term);
+					if (!root_odm) break;
+					count = gf_term_get_object_count(term, root_odm);
+					for (i=0; i<count; i++) {
+						GF_MediaInfo info;
+						odm = gf_term_get_object(term, root_odm, i);
+						if (gf_term_get_object_info(term, odm, &info) == GF_OK) {
+							if (info.ODID==odid) break;
+						}
+						odm = NULL;
+					}
+				}
+				do {
+					fprintf(stderr, "Enter file radical name (+\'.x\' for XML dumping) - \"std\" for stderr: ");
+					fflush(stderr);
+				} while( 1 > scanf("%1023s", radname));
+				sExt = strrchr(radname, '.');
+				xml_dump = 0;
+				if (sExt) {
+					if (!stricmp(sExt, ".x")) xml_dump = 1;
+					sExt0 = 0;
+				}
+				std_out = strnicmp(radname, "std", 3) ? 0 : 1;
+				e = gf_term_dump_scene(term, std_out ? NULL : radname, NULL, xml_dump, 0, odm);
+				fprintf(stderr, "Dump done (%s)\n", gf_error_to_string(e));
+			}
+			break;
+
+		case MP4C_OGL2D:
+		{
+			Bool use_3d = !gf_term_get_option(term, GF_OPT_USE_OPENGL);
+			if (gf_term_set_option(term, GF_OPT_USE_OPENGL, use_3d)==GF_OK) {
+				fprintf(stderr, "Using %s for 2D drawing\n", use_3d ? "OpenGL" : "2D rasterizer");
+			}
+		}
+		break;
+		case MP4C_STRESSMODE:
+		{
+			Bool opt = gf_term_get_option(term, GF_OPT_STRESS_MODE);
+			opt = !opt;
+			fprintf(stderr, "Turning stress mode %s\n", opt ? "on" : "off");
+			gf_term_set_option(term, GF_OPT_STRESS_MODE, opt);
+		}
+		break;
+		case MP4C_AR_4_3:
+			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
+			break;
+		case MP4C_AR_16_9:
+			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
+			break;
+		case MP4C_AR_NONE:
+			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
+			break;
+		case MP4C_AR_ORIG:
+			gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
+			break;
+
+		case MP4C_DISP_RTI:
+			display_rti = !display_rti;
+			ResetCaption();
+			break;
+		case MP4C_DISP_FPS:
+			if (display_rti) display_rti = 0;
+			else display_rti = 2;
+			ResetCaption();
+			break;
+		case MP4C_DISP_STATS:
+		case MP4C_DISP_GRAPH:
+			ll = gf_log_get_tool_level(GF_LOG_APP);
+			gf_log_set_tool_level(GF_LOG_APP, GF_LOG_INFO);
+			if (cmdtype==MP4C_DISP_STATS)
+				gf_term_print_stats(term);
+			else
+				gf_term_print_graph(term);
+			gf_log_set_tool_level(GF_LOG_APP, ll);
+			break;
+		case MP4C_UPDATE:
+		{
+			char szCom8192;
+			fprintf(stderr, "Enter command to send:\n");
+//			fflush(stdin);
+			szCom0 = 0;
+			if (1 > scanf("%8191^\t\n", szCom)) {
+				fprintf(stderr, "Cannot read command to send, aborting.\n");
+				break;
+			}
+			e = gf_term_scene_update(term, NULL, szCom);
+			if (e) fprintf(stderr, "Processing command failed: %s\n", gf_error_to_string(e));
+		}
+		break;
+		case MP4C_EVALJS:
+		{
+			char jsCode8192;
+			fprintf(stderr, "Enter JavaScript code to evaluate:\n");
+//			fflush(stdin);
+			jsCode0 = 0;
+			if (1 > scanf("%8191^\t\n", jsCode)) {
+				fprintf(stderr, "Cannot read code to evaluate, aborting.\n");
+				break;
+			}
+			e = gf_term_scene_update(term, "application/ecmascript", jsCode);
+			if (e) fprintf(stderr, "Processing JS code failed: %s\n", gf_error_to_string(e));
+		}
+		break;
+
+		case MP4C_LOGS:
+		{
+			char szLog1024, *cur_logs;
+			cur_logs = gf_log_get_tools_levels();
+			fprintf(stderr, "Enter new log level (current tools %s):\n", cur_logs);
+			gf_free(cur_logs);
+			if (scanf("%1023s", szLog) < 1) {
+				fprintf(stderr, "Cannot read new log level, aborting.\n");
+				break;
+			}
+			gf_log_modify_tools_levels(szLog);
+		}
+		break;
+
+		case MP4C_VMEM_CACHE:
+		{
+			u32 size;
+			do {
+				fprintf(stderr, "Enter new video cache memory in kBytes (current %ud):\n", gf_term_get_option(term, GF_OPT_VIDEO_CACHE_SIZE));
+			} while (1 > scanf("%ud", &size));
+			gf_term_set_option(term, GF_OPT_VIDEO_CACHE_SIZE, size);
+		}
+		break;
+
+		case MP4C_DOWNRATE:
+		{
+			u32 http_bitrate = gf_term_get_option(term, GF_OPT_HTTP_MAX_RATE);
+			do {
+				fprintf(stderr, "Enter new http bitrate in bps (0 for none) - current limit: %d\n", http_bitrate);
+			} while (1 > scanf("%ud", &http_bitrate));
+
+			gf_term_set_option(term, GF_OPT_HTTP_MAX_RATE, http_bitrate);
+		}
+		break;
+
+		case MP4C_RELOAD_OPTS:
+			gf_term_set_option(term, GF_OPT_RELOAD_CONFIG, 1);
+			break;
+
+		/*extract to PNG*/
+		case MP4C_SCREENSHOT:
+			MakeScreenshot(GF_FALSE);
+			break;
+
+		case MP4C_SELECT:
+		{
+			GF_ObjectManager *root_od, *odm;
+			u32 index;
+			char szOpt8192;
+			fprintf(stderr, "Enter 0-based index of object to select or service ID:\n");
+//			fflush(stdin);
+			szOpt0 = 0;
+			if (1 > scanf("%8191^\t\n", szOpt)) {
+				fprintf(stderr, "Cannot read OD ID\n");
+				break;
+			}
+			index = atoi(szOpt);
+			odm = NULL;
+			root_od = gf_term_get_root_object(term);
+			if (root_od) {
+				if ( gf_term_find_service(term, root_od, index)) {
+					gf_term_select_service(term, root_od, index);
+				} else {
+					fprintf(stderr, "Cannot find service %d - trying with object index\n", index);
+					odm = gf_term_get_object(term, root_od, index);
+					if (odm) {
+						gf_term_select_object(term, odm);
+					} else {
+						fprintf(stderr, "Cannot find object at index %d\n", index);
+					}
+				}
+			}
+		}
+		break;
+
+		case MP4C_HELP:
+			PrintHelp();
+			break;
+		default:
+			break;
+		}
+	}
+
+	if (bench_mode) {
+		PrintAVInfo(GF_TRUE);
+	}
+
+	/*FIXME: we have an issue in cleaning up after playing in bench mode and run-for 0 (buildbot tests). We for now disable error checks after run-for is done*/
+	if (simulation_time_in_ms) {
+		gf_log_set_strict_error(0);
+	}
+
+	if (print_graph || print_stats) {
+		ll = gf_log_get_tool_level(GF_LOG_APP);
+		gf_log_set_tool_level(GF_LOG_APP, GF_LOG_INFO);
+		if (print_graph)
+			gf_term_print_graph(term);
+		if (print_stats)
+			gf_term_print_stats(term);
+		gf_log_set_tool_level(GF_LOG_APP, ll);
+	}
+
+#ifdef GPAC_ENABLE_COVERAGE
+	if (do_coverage) {
+		u32 w, h, k, nb_drawn;
+		GF_Event evt;
+		Bool is_bound;
+		const char *outName;
+		GF_ObjectManager *root_odm, *odm;
+		PrintAVInfo(GF_TRUE);
+		PrintODList(term, NULL, 0, 0, "Root");
+		ViewODs(term, GF_TRUE);
+		ViewODs(term, GF_FALSE);
+		ViewOD(term, 0, (u32) -1, NULL);
+		ViewOD(term, 0, 1, NULL);
+		PrintUsage(0);
+		PrintHelp();
+		PrintWorldInfo(term);
+		gf_term_dump_scene(term, NULL, NULL, GF_FALSE, 0, NULL);
+		gf_term_get_current_service_id(term);
+		gf_term_toggle_addons(term, GF_FALSE);
+		set_navigation();
+		get_cmd('v');
+
+		gf_term_play_from_time(term, 0, 0);
+
+		memset(&evt, 0, sizeof(GF_Event));
+		evt.type = GF_EVENT_MOUSEUP;
+		evt.mouse.x = 20;
+		evt.mouse.y = 20;
+		gf_term_send_event(term, &evt);
+
+		gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+		//exercise step clocks
+		gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+		root_odm = gf_term_get_root_object(term);
+		gf_term_find_service(term, root_odm, 0);
+		gf_term_select_service(term, root_odm, 0);
+		odm = gf_term_get_object(term, root_odm, 0);
+		gf_term_select_object(term, odm );
+		gf_term_object_subscene_type(term, odm);
+		gf_term_get_visual_output_size(term, &w, &h);
+
+		gf_term_is_type_supported(term, "video/mp4");
+		gf_term_get_url(term);
+		gf_term_get_simulation_frame_rate(term, &nb_drawn);
+
+		gf_term_get_text_selection(term, GF_TRUE);
+		gf_term_paste_text(term, "test", GF_TRUE);
+
+		gf_term_set_option(term, GF_OPT_AUDIO_MUTE, 1);
+
+
+		MakeScreenshot(GF_TRUE);
+
+		gf_term_scene_update(term, NULL, "REPLACE DYN_TRANS.translation BY 10 10");
+		gf_term_add_object(term, NULL, GF_TRUE);
+
+		gf_term_get_viewpoint(term, 1, &outName, &is_bound);
+		gf_term_set_viewpoint(term, 1, "testvp");
+
+		for (k=GF_NAVIGATE_WALK; k<=GF_NAVIGATE_VR; k++) {
+			gf_term_set_option(term, GF_OPT_NAVIGATION, k);
+			memset(&evt, 0, sizeof(GF_Event));
+			evt.type = GF_EVENT_MOUSEDOWN;
+			evt.mouse.x = 100;
+			evt.mouse.y = 100;
+			gf_term_user_event(term, &evt);
+			evt.type = GF_EVENT_MOUSEMOVE;
+			evt.mouse.x += 10;
+			gf_term_user_event(term, &evt);
+			evt.mouse.y += 10;
+			gf_term_user_event(term, &evt);
+
+			evt.type = GF_EVENT_KEYDOWN;
+			evt.key.key_code = GF_KEY_CONTROL;
+			gf_term_user_event(term, &evt);
+
+			evt.type = GF_EVENT_MOUSEMOVE;
+			evt.mouse.x = 120;
+			evt.mouse.y = 110;
+			gf_term_user_event(term, &evt);
+
+			evt.type = GF_EVENT_KEYUP;
+			evt.key.key_code = GF_KEY_CONTROL;
+			gf_term_user_event(term, &evt);
+
+			evt.type = GF_EVENT_KEYDOWN;
+			evt.key.key_code = GF_KEY_J;
+			gf_term_user_event(term, &evt);
+
+		}
+		gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
+
+		gf_term_connect_with_path(term, "logo.jpg", "./media/auxiliary_files/");
+		gf_term_navigate_to(term, "./media/auxiliary_files/logo.jpg");
+		send_open_url("./media/auxiliary_files/logo.jpg");
+		switch_bench(1);
+		do_set_speed(1.0);
+		hide_shell(0);
+		list_modules();
+	}
+#endif
+
+	i = gf_sys_clock();
+	gf_term_disconnect(term);
+	if (rti_file) UpdateRTInfo("Disconnected\n");
+
+	if (playlist) gf_fclose(playlist);
+
+#if defined(__DARWIN__) || defined(__APPLE__)
+	carbon_uninit();
+#endif
+
+	//special condition for immediate exit without terminal deletion
+	if (ret_val==3) {
+		fprintf(stderr, "Exit forced, no cleanup\n");
+		exit(0);
+	}
+
+	fprintf(stderr, "Deleting terminal... ");
+	gf_term_del(term);
+	fprintf(stderr, "done (in %d ms) - ran for %d ms\n", gf_sys_clock() - i, gf_sys_clock());
+
+	fprintf(stderr, "GPAC cleanup ...\n");
+
+	if (no_cfg_save)
+		gf_opts_discard_changes();
+
+	gf_sys_close();
+
+	if (rti_logs) gf_fclose(rti_logs);
+	if (logfile) gf_fclose(logfile);
+
+	if (gui_mode) {
+		hide_shell(2);
+	}
+
+#ifdef GPAC_MEMORY_TRACKING
+	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
+	 gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
+		gf_memory_print();
+		return 2;
+	}
+#endif
+
+	return ret_val;
+}
+
+GF_MAIN_FUNC(mp4client_main)
+
+
+static void MakeScreenshot(Bool for_coverage)
+{
+	char szFileName100;
+	u32 nb_pass, nb_views, offscreen_view = 0;
+	GF_VideoSurface fb;
+	GF_Err e;
+	nb_pass = 1;
+	nb_views = gf_term_get_option(term, GF_OPT_NUM_STEREO_VIEWS);
+	if (nb_views>1) {
+		fprintf(stderr, "Auto-stereo mode detected - type number of view to dump (0 is main output, 1 to %d offscreen view, %d for all offscreen, %d for all offscreen and main)\n", nb_views, nb_views+1, nb_views+2);
+		if (!for_coverage) {
+			if (scanf("%d", &offscreen_view) != 1) {
+				offscreen_view = 0;
+			}
+		}
+		if (offscreen_view==nb_views+1) {
+			offscreen_view = 1;
+			nb_pass = nb_views;
+		}
+		else if (offscreen_view==nb_views+2) {
+			offscreen_view = 0;
+			nb_pass = nb_views+1;
+		}
+	}
+	if (for_coverage && !offscreen_view) {
+		if (gf_term_get_offscreen_buffer(term, &fb, 0, 0)==GF_OK)
+			gf_term_release_screen_buffer(term, &fb);
+	}
+	while (nb_pass) {
+		nb_pass--;
+		if (offscreen_view) {
+			sprintf(szFileName, "view%d_dump.png", offscreen_view);
+			e = gf_term_get_offscreen_buffer(term, &fb, offscreen_view-1, 0);
+		} else {
+			sprintf(szFileName, "gpac_video_dump_"LLU".png", gf_net_get_utc() );
+			e = gf_term_get_screen_buffer(term, &fb);
+		}
+		offscreen_view++;
+		if (e) {
+			fprintf(stderr, "Error dumping screen buffer %s\n", gf_error_to_string(e) );
+			nb_pass = 0;
+		} else {
+#ifndef GPAC_DISABLE_AV_PARSERS
+			u32 dst_size = fb.width*fb.height*4;
+			char *dst = (char*)gf_malloc(sizeof(char)*dst_size);
+
+			e = gf_img_png_enc(fb.video_buffer, fb.width, fb.height, fb.pitch_y, fb.pixel_format, dst, &dst_size);
+			if (e) {
+				fprintf(stderr, "Error encoding PNG %s\n", gf_error_to_string(e) );
+				nb_pass = 0;
+			} else {
+				FILE *png = gf_fopen(szFileName, "wb");
+				if (!png) {
+					fprintf(stderr, "Error writing file %s\n", szFileName);
+					nb_pass = 0;
+				} else {
+					gf_fwrite(dst, dst_size, png);
+					gf_fclose(png);
+					fprintf(stderr, "Dump to %s\n", szFileName);
+				}
+			}
+			if (dst) gf_free(dst);
+			gf_term_release_screen_buffer(term, &fb);
+
+			if (for_coverage) gf_file_delete(szFileName);
+#endif //GPAC_DISABLE_AV_PARSERS
+		}
+	}
+	fprintf(stderr, "Done: %s\n", szFileName);
+}
+
+static GF_ObjectManager *video_odm = NULL;
+static GF_ObjectManager *audio_odm = NULL;
+static GF_ObjectManager *scene_odm = NULL;
+static u32 last_odm_count = 0;
+
+static void PrintAVInfo(Bool final)
+{
+	GF_MediaInfo a_odi, v_odi, s_odi;
+	Double avg_dec_time;
+	u32 tot_time;
+
+	if (scene_odm) {
+		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
+		u32 count = gf_term_get_object_count(term, root_odm);
+		if (last_odm_count != count) {
+			last_odm_count = count;
+			scene_odm = NULL;
+		}
+	}
+	if (!video_odm && !audio_odm && !scene_odm) {
+		u32 count, i;
+		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
+		if (!root_odm) return;
+
+		if (gf_term_get_object_info(term, root_odm, &v_odi)==GF_OK) {
+			if (!scene_odm && (v_odi.generated_scene== 0)) {
+				scene_odm = root_odm;
+			}
+		}
+
+		count = gf_term_get_object_count(term, root_odm);
+		for (i=0; i<count; i++) {
+			GF_ObjectManager *odm = gf_term_get_object(term, root_odm, i);
+			if (!odm) break;
+			if (gf_term_get_object_info(term, odm, &v_odi) == GF_OK) {
+				if (!video_odm && (v_odi.od_type == GF_STREAM_VISUAL) && (v_odi.raw_media || (v_odi.cb_max_count>1) || v_odi.direct_video_memory || (bench_mode == 3) )) {
+					video_odm = odm;
+				}
+				else if (!audio_odm && (v_odi.od_type == GF_STREAM_AUDIO)) {
+					audio_odm = odm;
+				}
+				else if (!scene_odm && (v_odi.od_type == GF_STREAM_SCENE)) {
+					scene_odm = odm;
+				}
+			}
+		}
+	}
+
+	if (0 && bench_buffer) {
+		fprintf(stderr, "Buffering %d %% ", bench_buffer-1);
+		return;
+	}
+
+	if (video_odm) {
+		if (gf_term_get_object_info(term, video_odm, &v_odi)!= GF_OK) {
+			video_odm = NULL;
+			return;
+		}
+	} else {
+		memset(&v_odi, 0, sizeof(v_odi));
+	}
+	if (audio_odm) {
+		gf_term_get_object_info(term, audio_odm, &a_odi);
+	} else {
+		memset(&a_odi, 0, sizeof(a_odi));
+	}
+	if (!video_odm && scene_odm) {
+		gf_term_get_object_info(term, scene_odm, &s_odi);
+	} else {
+		memset(&s_odi, 0, sizeof(s_odi));
+	}
+
+	if (final) {
+		tot_time = gf_sys_clock() - bench_mode_start;
+		fprintf(stderr, " \r");
+		fprintf(stderr, "************** Bench Mode Done in %d ms ********************\n", tot_time);
+		if (bench_mode==3) fprintf(stderr, "** Systems layer only (no decoding) **\n");
+
+		if (!video_odm) {
+			u32 nb_frames_drawn;
+			Double FPS = gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
+			fprintf(stderr, "Drawn %d frames FPS %.2f (simulation FPS %.2f) - duration %d ms\n", nb_frames_drawn, ((Float)nb_frames_drawn*1000)/tot_time,(Float) FPS, gf_term_get_time_in_ms(term) );
+		}
+	}
+	if (video_odm) {
+		fprintf(stderr, "%s %dx%d sar=%d:%d duration %.2fs\n", v_odi.codec_name, v_odi.width, v_odi.height, v_odi.par ? (v_odi.par>>16)&0xFF : 1, v_odi.par ? (v_odi.par)&0xFF : 1, v_odi.duration);
+		if (final) {
+			u32 dec_run_time = v_odi.last_frame_time - v_odi.first_frame_time;
+			if (!dec_run_time) dec_run_time = 1;
+			if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
+			fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / dec_run_time, v_odi.max_dec_time, (u32) v_odi.avg_bitrate/1000, (u32) v_odi.max_bitrate/1000);
+			if (v_odi.nb_dropped) {
+				fprintf(stderr, " (Error during bench: %d frames drop)", v_odi.nb_dropped);
+			}
+			fprintf(stderr, "\n");
+		}
+	}
+	if (audio_odm) {
+		fprintf(stderr, "%s SR %d num channels %d %s duration %.2fs\n", a_odi.codec_name, a_odi.sample_rate, a_odi.num_channels, gf_audio_fmt_name(a_odi.afmt), a_odi.duration);
+		if (final) {
+			u32 dec_run_time = a_odi.last_frame_time - a_odi.first_frame_time;
+			if (!dec_run_time) dec_run_time = 1;
+			if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
+			fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max) rate avg %d max %d", a_odi.nb_dec_frames, ((Float)dec_run_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0, (u32) a_odi.avg_bitrate/1000, (u32) a_odi.max_bitrate/1000);
+			if (a_odi.nb_dropped) {
+				fprintf(stderr, " (Error during bench: %d frames drop)", a_odi.nb_dropped);
+			}
+			fprintf(stderr, "\n");
+		}
+	}
+	if (scene_odm) {
+		u32 w, h;
+		gf_term_get_visual_output_size(term, &w, &h);
+		fprintf(stderr, "%s scene size %dx%d rastered to %dx%d duration %.2fs\n", s_odi.codec_name ? s_odi.codec_name : "", s_odi.width, s_odi.height, w, h, s_odi.duration);
+		if (final) {
+			if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
+				u32 dec_run_time = s_odi.last_frame_time - s_odi.first_frame_time;
+				if (!dec_run_time) dec_run_time = 1;
+				fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", s_odi.nb_dec_frames, ((Float)s_odi.nb_dec_frames*1000) / dec_run_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000, (u32) s_odi.max_bitrate/1000);
+				fprintf(stderr, "\n");
+			} else {
+				u32 nb_frames_drawn;
+				Double FPS;
+				gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
+				tot_time = gf_sys_clock() - bench_mode_start;
+				FPS = gf_term_get_framerate(term, 0);
+				fprintf(stderr, "%d frames FPS %.2f (abs %.2f)\n", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
+			}
+
+			fprintf(stderr, "**********************************************************\n\n");
+			return;
+		}
+	}
+
+	if (video_odm) {
+		tot_time = v_odi.last_frame_time - v_odi.first_frame_time;
+		if (!tot_time) tot_time=1;
+		if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
+		fprintf(stderr, "%d f FPS %.2f (%.2f ms max) rate %d ", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / tot_time, v_odi.max_dec_time/1000.0, (u32) v_odi.avg_bitrate/1000);
+	}
+	else if (scene_odm) {
+
+		if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
+			avg_dec_time = (Float) 1000000 * s_odi.nb_dec_frames;
+			avg_dec_time /= s_odi.total_dec_time;
+			if (s_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*s_odi.current_time / s_odi.duration ) );
+			fprintf(stderr, "%d f %.2f (%d us max) - rate %d ", s_odi.nb_dec_frames, avg_dec_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000);
+		} else {
+			u32 nb_frames_drawn;
+			Double FPS;
+			gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
+			tot_time = gf_sys_clock() - bench_mode_start;
+			FPS = gf_term_get_framerate(term, 1);
+			fprintf(stderr, "%d f FPS %.2f (abs %.2f) ", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
+		}
+	}
+	else if (audio_odm) {
+		gf_term_get_object_info(term, audio_odm, &a_odi);
+
+		tot_time = a_odi.last_frame_time - a_odi.first_frame_time;
+		if (!tot_time) tot_time=1;
+		if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
+		fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max)", a_odi.nb_dec_frames, ((Float)tot_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0);
+	}
+}
+
+static void PrintWorldInfo(GF_Terminal *term)
+{
+	u32 i;
+	const char *title;
+	GF_List *descs;
+	descs = gf_list_new();
+	title = gf_term_get_world_info(term, NULL, descs);
+	if (!title && !gf_list_count(descs)) {
+		fprintf(stderr, "No World Info available\n");
+	} else {
+		fprintf(stderr, "\t%s\n", title ? title : "No title available");
+		for (i=0; i<gf_list_count(descs); i++) {
+			char *str = gf_list_get(descs, i);
+			fprintf(stderr, "%s\n", str);
+		}
+	}
+	gf_list_del(descs);
+}
+
+static void PrintODList(GF_Terminal *term, GF_ObjectManager *root_odm, u32 num, u32 indent, char *root_name)
+{
+	GF_MediaInfo odi;
+	u32 i, count;
+	char szIndent50;
+
+	if (!root_odm) {
+		fprintf(stderr, "Currently loaded objects:\n");
+		root_odm = gf_term_get_root_object(term);
+	}
+	if (!root_odm) return;
+
+	count = gf_term_get_current_service_id(term);
+	if (count)
+		fprintf(stderr, "Current service ID %d\n", count);
+
+	if (gf_term_get_object_info(term, root_odm, &odi) != GF_OK) return;
+	if (!odi.ODID) {
+		fprintf(stderr, "Service not attached\n");
+		return;
+	}
+
+	for (i=0; i<indent; i++) szIndenti=' ';
+	szIndentindent=0;
+
+	fprintf(stderr, "%s", szIndent);
+	fprintf(stderr, "#%d %s - ", num, root_name);
+	if (odi.ServiceID) fprintf(stderr, "Service ID %d ", odi.ServiceID);
+	if (odi.media_url) {
+		fprintf(stderr, "%s\n", odi.media_url);
+	} else {
+		fprintf(stderr, "OD ID %d\n", odi.ODID);
+	}
+
+	szIndentindent=' ';
+	szIndentindent+1=0;
+	indent++;
+
+	count = gf_term_get_object_count(term, root_odm);
+	for (i=0; i<count; i++) {
+		GF_ObjectManager *odm = gf_term_get_object(term, root_odm, i);
+		if (!odm) break;
+		num++;
+		if (gf_term_get_object_info(term, odm, &odi) == GF_OK) {
+			switch (gf_term_object_subscene_type(term, odm)) {
+			case 1:
+				PrintODList(term, odm, num, indent, "Root");
+				break;
+			case 2:
+				PrintODList(term, odm, num, indent, "Inline Scene");
+				break;
+			case 3:
+				PrintODList(term, odm, num, indent, "EXTERNPROTO Library");
+				break;
+			default:
+				fprintf(stderr, "%s", szIndent);
+				fprintf(stderr, "#%d - ", num);
+				if (odi.media_url) {
+					fprintf(stderr, "%s", odi.media_url);
+				} else if (odi.service_url) {
+					fprintf(stderr, "%s", odi.service_url);
+				} else if (odi.remote_url) {
+					fprintf(stderr, "%s", odi.remote_url);
+				} else {
+					fprintf(stderr, "ID %d", odi.ODID);
+				}
+				fprintf(stderr, " - %s", (odi.od_type==GF_STREAM_VISUAL) ? "Video" : (odi.od_type==GF_STREAM_AUDIO) ? "Audio" : "Systems");
+				if (odi.ServiceID) fprintf(stderr, " - Service ID %d", odi.ServiceID);
+				fprintf(stderr, "\n");
+				break;
+			}
+		}
+	}
+}
+
+static void ViewOD(GF_Terminal *term, u32 OD_ID, u32 number, const char *szURL)
+{
+	GF_MediaInfo odi;
+	u32 i, count, d_enum, id;
+	GF_TermNetStats stats;
+	GF_Err e;
+	GF_ObjectManager *odm, *root_odm = gf_term_get_root_object(term);
+	if (!root_odm) return;
+
+	odm = NULL;
+	if (!szURL && ((!OD_ID && (number == (u32)-1)) || ((OD_ID == (u32)(-1)) && !number))) {
+		odm = root_odm;
+		if ((gf_term_get_object_info(term, odm, &odi) != GF_OK)) odm=NULL;
+	} else {
+		count = gf_term_get_object_count(term, root_odm);
+		for (i=0; i<count; i++) {
+			odm = gf_term_get_object(term, root_odm, i);
+			if (!odm) break;
+			if (gf_term_get_object_info(term, odm, &odi) == GF_OK) {
+				if (szURL && strstr(odi.service_url, szURL)) break;
+				if ((number == (u32)(-1)) && (odi.ODID == OD_ID)) break;
+				else if (i == (u32)(number-1)) break;
+			}
+			odm = NULL;
+		}
+	}
+	if (!odm) {
+		if (szURL) fprintf(stderr, "cannot find OD for URL %s\n", szURL);
+		if (number == (u32)-1) fprintf(stderr, "cannot find OD with ID %d\n", OD_ID);
+		else fprintf(stderr, "cannot find OD with number %d\n", number);
+		return;
+	}
+	if (!odi.ODID) {
+		if (number == (u32)-1) fprintf(stderr, "Object %d not attached yet\n", OD_ID);
+		else fprintf(stderr, "Object #%d not attached yet\n", number);
+		return;
+	}
+
+	fprintf(stderr, "Object Duration: ");
+	if (odi.duration) {
+		PrintTime((u32) (odi.duration*1000));
+	} else {
+		fprintf(stderr, "unknown");
+	}
+	fprintf(stderr, "\n");
+
+	fprintf(stderr, "Service Handler: %s\n", odi.service_handler);
+	fprintf(stderr, "Service URL: %s\n", odi.service_url);
+
+	if (odi.codec_name) {
+		Float avg_dec_time;
+		switch (odi.od_type) {
+		case GF_STREAM_VISUAL:
+			fprintf(stderr, "Video Object: Width %d - Height %d\r\n", odi.width, odi.height);
+			fprintf(stderr, "Media Codec: %s\n", odi.codec_name);
+			if (odi.par) fprintf(stderr, "Pixel Aspect Ratio: %d:%d\n", (odi.par>>16)&0xFF, (odi.par)&0xFF);
+			break;
+		case GF_STREAM_AUDIO:
+			fprintf(stderr, "Audio Object: Sample Rate %d - %d channels\r\n", odi.sample_rate, odi.num_channels);
+			fprintf(stderr, "Media Codec: %s\n", odi.codec_name);
+			break;
+		case GF_STREAM_SCENE:
+		case GF_STREAM_PRIVATE_SCENE:
+			if (odi.width && odi.height) {
+				fprintf(stderr, "Scene Description - Width %d - Height %d\n", odi.width, odi.height);
+			} else {
+				fprintf(stderr, "Scene Description - no size specified\n");
+			}
+			fprintf(stderr, "Scene Codec: %s\n", odi.codec_name);
+			break;
+		case GF_STREAM_TEXT:
+			if (odi.width && odi.height) {
+				fprintf(stderr, "Text Object: Width %d - Height %d\n", odi.width, odi.height);
+			} else {
+				fprintf(stderr, "Text Object: No size specified\n");
+			}
+			fprintf(stderr, "Text Codec %s\n", odi.codec_name);
+			break;
+		}
+
+		avg_dec_time = 0;
+		if (odi.nb_dec_frames) {
+			avg_dec_time = (Float) odi.total_dec_time;
+			avg_dec_time /= odi.nb_dec_frames;
+		}
+		fprintf(stderr, "\tBitrate over last second: %d kbps\n\tMax bitrate over one second: %d kbps\n\tAverage Decoding Time %.2f us %d max)\n\tTotal decoded frames %d\n",
+		 (u32) odi.avg_bitrate/1024, odi.max_bitrate/1024, avg_dec_time, odi.max_dec_time, odi.nb_dec_frames);
+	}
+	if (odi.protection) fprintf(stderr, "Encrypted Media scheme %s\n", gf_4cc_to_str(odi.protection) );
+
+	fprintf(stderr, "\nStream ID %d - %s - Clock ID %d\n", odi.pid_id, gf_stream_type_name(odi.od_type), odi.ocr_id);
+//	if (esd->dependsOnESID) fprintf(stderr, "\tDepends on Stream ID %d for decoding\n", esd->dependsOnESID);
+
+	if (odi.lang_code)
+		fprintf(stderr, "\tStream Language: %s\n", odi.lang_code);
+
+	fprintf(stderr, "\n");
+
+	switch (odi.status) {
+	case 0:
+		fprintf(stderr, "Stopped - ");
+		break;
+	case 1:
+		fprintf(stderr, "Playing - ");
+		break;
+	case 2:
+		fprintf(stderr, "Paused - ");
+		break;
+	case 3:
+		fprintf(stderr, "Not setup yet\n");
+		return;
+	default:
+		fprintf(stderr, "Setup Failed\n");
+		return;
+	}
+	if (odi.buffer>=0) fprintf(stderr, "Buffer: %d ms - ", odi.buffer);
+	else fprintf(stderr, "Not buffering - ");
+	fprintf(stderr, "Clock drift: %d ms\n", odi.clock_drift);
+	if (odi.db_unit_count) fprintf(stderr, "%d AU in DB\n", odi.db_unit_count);
+	if (odi.cb_max_count) fprintf(stderr, "Composition Buffer: %d CU (%d max)\n", odi.cb_unit_count, odi.cb_max_count);
+	fprintf(stderr, "\n");
+
+	if (odi.owns_service) {
+		const char *url;
+		u32 done, total, bps;
+		d_enum = 0;
+		while (gf_term_get_download_info(term, odm, &d_enum, &url, &done, &total, &bps)) {
+			if (d_enum==1) fprintf(stderr, "Current Downloads in service:\n");
+			if (done && total) {
+				fprintf(stderr, "%s: %d / %d bytes (%.2f %%) - %.2f kBps\n", url, done, total, (100.0f*done)/total, ((Float)bps)/1024.0f);
+			} else {
+				fprintf(stderr, "%s: %.2f kbps\n", url, ((Float)8*bps)/1024.0f);
+			}
+		}
+		if (!d_enum) fprintf(stderr, "No Downloads in service\n");
+		fprintf(stderr, "\n");
+	}
+
+	d_enum = 0;
+	while (gf_term_get_channel_net_info(term, odm, &d_enum, &id, &stats, &e)) {
+		if (e) continue;
+		if (!stats.bw_down && !stats.bw_up) continue;
+
+		fprintf(stderr, "Stream ID %d statistics:\n", id);
+		if (stats.multiplex_port) {
+			fprintf(stderr, "\tMultiplex Port %d - multiplex ID %d\n", stats.multiplex_port, stats.port);
+		} else {
+			fprintf(stderr, "\tPort %d\n", stats.port);
+		}
+		fprintf(stderr, "\tPacket Loss Percentage: %.4f\n", stats.pck_loss_percentage);
+		fprintf(stderr, "\tDown Bandwidth: %d bps\n", stats.bw_down);
+		if (stats.bw_up) fprintf(stderr, "\tUp Bandwidth: %d bps\n", stats.bw_up);
+		if (stats.ctrl_port) {
+			if (stats.multiplex_port) {
+				fprintf(stderr, "\tControl Multiplex Port: %d - Control Multiplex ID %d\n", stats.multiplex_port, stats.ctrl_port);
+			} else {
+				fprintf(stderr, "\tControl Port: %d\n", stats.ctrl_port);
+			}
+			fprintf(stderr, "\tDown Bandwidth: %d bps\n", stats.ctrl_bw_down);
+			fprintf(stderr, "\tUp Bandwidth: %d bps\n", stats.ctrl_bw_up);
+		}
+		fprintf(stderr, "\n");
+	}
+}
+
+static void PrintODTiming(GF_Terminal *term, GF_ObjectManager *odm, u32 indent)
+{
+	GF_MediaInfo odi;
+	u32 ind = indent;
+	u32 i, count;
+	if (!odm) return;
+
+	if (gf_term_get_object_info(term, odm, &odi) != GF_OK) return;
+	if (!odi.ODID) {
+		fprintf(stderr, "Service not attached\n");
+		return;
+	}
+	while (ind) {
+		fprintf(stderr, " ");
+		ind--;
+	}
+
+	if (! odi.generated_scene) {
+
+		fprintf(stderr, "- OD %d: ", odi.ODID);
+		switch (odi.status) {
+		case 1:
+			fprintf(stderr, "Playing - ");
+			break;
+		case 2:
+			fprintf(stderr, "Paused - ");
+			break;
+		default:
+			fprintf(stderr, "Stopped - ");
+			break;
+		}
+		if (odi.buffer>=0) fprintf(stderr, "Buffer: %d ms - ", odi.buffer);
+		else fprintf(stderr, "Not buffering - ");
+		fprintf(stderr, "Clock drift: %d ms", odi.clock_drift);
+		fprintf(stderr, " - time: ");
+		PrintTime((u32) (odi.current_time*1000));
+		fprintf(stderr, "\n");
+
+	} else {
+		fprintf(stderr, "+ Service %s:\n", odi.service_url);
+	}
+
+	count = gf_term_get_object_count(term, odm);
+	for (i=0; i<count; i++) {
+		GF_ObjectManager *an_odm = gf_term_get_object(term, odm, i);
+		PrintODTiming(term, an_odm, indent+1);
+	}
+	return;
+
+}
+
+static void PrintODBuffer(GF_Terminal *term, GF_ObjectManager *odm, u32 indent)
+{
+	Float avg_dec_time;
+	GF_MediaInfo odi;
+	u32 ind, i, count;
+	if (!odm) return;
+
+	if (gf_term_get_object_info(term, odm, &odi) != GF_OK) return;
+	if (!odi.ODID) {
+		fprintf(stderr, "Service not attached\n");
+		return;
+	}
+
+	ind = indent;
+	while (ind) {
+		fprintf(stderr, " ");
+		ind--;
+	}
+
+	if (odi.generated_scene) {
+		fprintf(stderr, "+ Service %s:\n", odi.service_url);
+	} else {
+		fprintf(stderr, "- OD %d: ", odi.ODID);
+		switch (odi.status) {
+		case 1:
+			fprintf(stderr, "Playing");
+			break;
+		case 2:
+			fprintf(stderr, "Paused");
+			break;
+		default:
+			fprintf(stderr, "Stopped");
+			break;
+		}
+		if (odi.buffer>=0) fprintf(stderr, " - Buffer: %d ms", odi.buffer);
+		if (odi.db_unit_count) fprintf(stderr, " - DB: %d AU", odi.db_unit_count);
+		if (odi.cb_max_count) fprintf(stderr, " - CB: %d/%d CUs", odi.cb_unit_count, odi.cb_max_count);
+
+		fprintf(stderr, "\n");
+		ind = indent;
+		while (ind) {
+			fprintf(stderr, " ");
+			ind--;
+		}
+
+		fprintf(stderr, " %d decoded frames - %d dropped frames\n", odi.nb_dec_frames, odi.nb_dropped);
+
+		ind = indent;
+		while (ind) {
+			fprintf(stderr, " ");
+			ind--;
+		}
+
+		avg_dec_time = 0;
+		if (odi.nb_dec_frames) {
+			avg_dec_time = (Float) odi.total_dec_time;
+			avg_dec_time /= odi.nb_dec_frames;
+		}
+		fprintf(stderr, " Avg Bitrate %d kbps (%d max) - Avg Decoding Time %.2f us (%d max)\n",
+		 (u32) odi.avg_bitrate/1024, odi.max_bitrate/1024, avg_dec_time, odi.max_dec_time);
+	}
+
+	count = gf_term_get_object_count(term, odm);
+	for (i=0; i<count; i++) {
+		GF_ObjectManager *an_odm = gf_term_get_object(term, odm, i);
+		PrintODBuffer(term, an_odm, indent+1);
+	}
+
+}
+
+static void ViewODs(GF_Terminal *term, Bool show_timing)
+{
+	GF_ObjectManager *root_odm = gf_term_get_root_object(term);
+	if (!root_odm) return;
+
+	if (show_timing) {
+		PrintODTiming(term, root_odm, 0);
+	} else {
+		PrintODBuffer(term, root_odm, 0);
+	}
+	fprintf(stderr, "\n");
+}

gpac-2.2.0.tar.gz/applications/deprecated/mp4client/mp4client.rc Changed

gpac-2.2.0.tar.gz/applications/deprecated/mp4client/resource.h Changed

gpac-2.0.0.tar.gz/applications/deprecated/old_arch/mp42avi/main.c -> gpac-2.2.0.tar.gz/applications/deprecated/old_arch/mp42avi/main.c Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/.gitignore Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/Readme.md Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/build.gradle Added

@@ -0,0 +1,36 @@
+apply plugin: 'com.android.application'
+import org.apache.tools.ant.taskdefs.condition.Os
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "25.0.2"
+
+    defaultConfig {
+        applicationId "com.gpac.Osmo4"
+        minSdkVersion 16
+        targetSdkVersion 22
+    }
+
+    sourceSets.main {
+        jni.srcDirs =  // This prevents the auto generation of Android.mk
+        jniLibs.srcDir 'src/main/libs' // This is not necessary unless you have precompiled libraries in your project.
+    }
+
+
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+    }
+}
+
+dependencies {
+    compile files('libs/real3d.jar')
+    compile 'com.android.support:recyclerview-v7:23.1.1'
+    compile 'com.android.support:cardview-v7:23.1.1'
+    compile 'com.android.support:appcompat-v7:23.1.1'
+    compile 'com.android.support:design:23.1.1'
+
+}

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/AndroidManifest.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/assets Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/assets/configuration.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4 Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/BitmapView.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/GPACInstance.java Added

@@ -0,0 +1,424 @@
+/**
+ * $URL$
+ *
+ * $LastChangedBy$ - $LastChangedDate$
+ */
+package com.gpac.Osmo4;
+
+import java.io.File;
+import java.io.PrintStream;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+
+/**
+ * @version $Revision$
+ *
+ */
+public class GPACInstance implements GPACInstanceInterface {
+
+ private final static String LOG_LIB = "LibrariesLoader"; //$NON-NLS-1$
+
+ private final Thread uniqueThread;
+
+ /**
+ *
+ * a recursive method to get the directory hierarchy under root.
+ *
+ * @param sb StringBuilder object which will return the final hierarchy
+ * @param root root of the hierarchy
+ * @param inc initial number of spaces.
+ */
+ private static void listing(StringBuilder sb, File root, int inc) {
+ StringBuilder increment = new StringBuilder();
+ for (int i = 0; i < inc; i++)
+ increment.append(' ');
+ String incr = increment.toString();
+ for (File f : root.listFiles()) {
+ sb.append(incr).append(f.getName());
+ if (f.isDirectory()) {
+ sb.append(" Directory\n"); //$NON-NLS-1$
+ listing(sb, f, inc + 2);
+ } else {
+ sb.append(" ").append(f.length() + " bytes\n"); //$NON-NLS-1$//$NON-NLS-2$
+ }
+ }
+ }
+
+ /**
+ * Loads all libraries
+ *
+ * @param config
+ *
+ * @return a map of exceptions containing the library as key and the exception as value. If map is empty, no error
+ *
+ */
+
+
+ synchronized static Map<String, Throwable> loadAllLibraries(GpacConfig config) {
+ if (errors != null)
+ return errors;
+ StringBuilder sb = new StringBuilder();
+ final String toLoad = { "GLESv2", "log",
+ "jpegdroid", "javaenv",
+ "mad", "ft2", "faad",
+ "openjpeg", "png", "z",
+ "avutil", "swscale", "swresample", "avcodec", "avformat", "avfilter", "avdevice",
+ "gpacWrapper", "gpac",
+ "gm_droid_mpegv" };
+ HashMap<String, Throwable> exceptions = new HashMap<String, Throwable>();
+ for (String s : toLoad) {
+ try {
+ String msg = "Loading library " + s + "...";//$NON-NLS-1$//$NON-NLS-2$
+ sb.append(msg);
+ Log.i(LOG_LIB, msg);
+ System.loadLibrary(s);
+ } catch (UnsatisfiedLinkError e) {
+ sb.append("Failed to load " + s + ", error=" + e.getLocalizedMessage() + " :: " //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
+ + e.getClass().getSimpleName() + "\n"); //$NON-NLS-1$
+ exceptions.put(s, e);
+ Log.e(LOG_LIB, "Failed to load library : " + s + " due to link error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
+ } catch (SecurityException e) {
+ exceptions.put(s, e);
+ Log.e(LOG_LIB, "Failed to load library : " + s + " due to security error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
+ } catch (Throwable e) {
+ exceptions.put(s, e);
+ Log.e(LOG_LIB, "Failed to load library : " + s + " due to Runtime error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ }
+
+ if (!exceptions.isEmpty()) {
+ try {
+ PrintStream out = new PrintStream(config.getGpacLogDirectory() + "debug_libs.txt", "UTF-8"); //$NON-NLS-1$//$NON-NLS-2$
+ out.println("$Revision$"); //$NON-NLS-1$
+ out.println(new Date());
+ out.println("\n*** Configuration\n"); //$NON-NLS-1$
+ out.println(config.getConfigAsText());
+ sb.append("*** Libs listing: "); //$NON-NLS-1$
+ sb.append(config.getGpacLibsDirectory());
+ sb.append('\n');
+ listing(sb, new File(config.getGpacLibsDirectory()), 2);
+ sb.append("*** Modules listing: "); //$NON-NLS-1$
+ sb.append(config.getGpacModulesDirectory());
+ sb.append('\n');
+ listing(sb, new File(config.getGpacModulesDirectory()), 2);
+ sb.append("*** Fonts listing: \n"); //$NON-NLS-1$
+ sb.append(config.getGpacFontDirectory());
+ sb.append('\n');
+ listing(sb, new File(config.getGpacFontDirectory()), 2);
+ sb.append("*** Exceptions:\n"); //$NON-NLS-1$
+ for (Map.Entry<String, Throwable> ex : exceptions.entrySet()) {
+ sb.append(ex.getKey()).append(": ") //$NON-NLS-1$
+ .append(ex.getValue().getLocalizedMessage())
+ .append('(')
+ .append(ex.getValue().getClass())
+ .append(")\n"); //$NON-NLS-1$
+ }
+ out.println(sb.toString());
+ out.flush();
+ out.close();
+ } catch (Exception e) {
+ Log.e(LOG_LIB, "Failed to output debug info to debug file", e); //$NON-NLS-1$
+ }
+ }
+ errors = Collections.unmodifiableMap(exceptions);
+ return errors;
+ }
+
+ private static Map<String, Throwable> errors = null;
+
+ private boolean hasToBeFreed = true;
+
+ /**
+ * Constructor
+ *
+ * @param callback
+ * @param width
+ * @param height
+ * @param config The configuration to use for GPAC
+ * @param urlToOpen
+ * @throws GpacInstanceException
+ */
+ public GPACInstance(GpacCallback callback, int width, int height, GpacConfig config, String urlToOpen)
+ throws GpacInstanceException {
+ StringBuilder sb = new StringBuilder();
+ Map<String, Throwable> errors = loadAllLibraries(config);
+ if (!errors.isEmpty()) {
+ sb.append("Exceptions while loading libraries:"); //$NON-NLS-1$
+ for (Map.Entry<String, Throwable> x : errors.entrySet()) {
+ sb.append('\n')
+ .append(x.getKey())
+ .append('')
+ .append(x.getValue().getClass().getSimpleName())
+ .append(": ") //$NON-NLS-1$
+ .append(x.getValue().getLocalizedMessage());
+ }
+ Log.e(LOG_LIB, sb.toString());
+ }
+ try {
+ handle = createInstance(callback,
+ width,
+ height,
+ config.getGpacConfigDirectory(),
+ config.getGpacModulesDirectory(),
+ config.getGpacCacheDirectory(),
+ config.getGpacFontDirectory(),
+ config.getGpacGuiDirectory(),
+ urlToOpen);
+ } catch (Throwable e) {
+ throw new GpacInstanceException("Error while creating instance\n" + sb.toString()); //$NON-NLS-1$
+ }
+ if (handle == 0) {
+ throw new GpacInstanceException("Error while creating instance, no handle created!\n" + sb.toString()); //$NON-NLS-1$
+ }
+ synchronized (this) {
+ hasToBeFreed = true;
+ }
+ uniqueThread = Thread.currentThread();
+ }
+
+ /**
+ * This one handles the pointer to the real C object
+ */
+ private final long handle;
+
+ /**
+ * @return the handle
+ */
+ public synchronized long getHandle() {
+ return handle;
+ }
+
+ private void checkCurrentThread() throws RuntimeException {
+ if (Thread.currentThread() != uniqueThread)
+ throw new RuntimeException("Method called outside allowed Thread scope !"); //$NON-NLS-1$
+ }
+
+ @Override
+ public void disconnect() {
+ checkCurrentThread();
+ gpacrender();
+ gpacdisconnect();
+ }
+
+ @Override
+ public void connect(String url) {
+ Log.i(LOG_LIB, "connect(" + url + ")"); //$NON-NLS-1$ //$NON-NLS-2$
+ checkCurrentThread();
+ gpacrender();
+ gpacconnect(url);
+ }
+
+ /**
+ * Call this method when a key has been pressed
+ *
+ * @param keyCode
+ * @param event
+ * @param pressed true if key is pressed, false if key is released
+ * @param unicode
+ */
+ public void eventKey(int keyCode, KeyEvent event, boolean pressed, int unicode) {
+ checkCurrentThread();
+ gpaceventkeypress(keyCode, event.getScanCode(), pressed ? 1 : 0, event.getFlags(), unicode);
+ }
+
+ /**
+ * Renders the current frame
+ */
+ public void render() {
+ checkCurrentThread();
+ gpacrender();
+ }
+
+ /**
+ * Resizes the object to new dimensions
+ *
+ * @param width
+ * @param height
+ */
+ public void resize(int width, int height) {
+ Log.i(LOG_LIB, "Resizing to " + width + "x" + height); //$NON-NLS-1$ //$NON-NLS-2$
+ gpacresize(width, height);
+ }
+
+ private boolean touched = false;
+
+ /**
+ * Call this when a motion event occurs
+ *
+ * @param event
+ */
+ public void motionEvent(MotionEvent event) {
+ checkCurrentThread();
+ final float x = event.getX();
+ final float y = event.getY();
+ switch (event.getAction()) {
+ // not in 1.6 case MotionEvent.ACTION_POINTER_1_DOWN:
+ case MotionEvent.ACTION_DOWN:
+ gpaceventmousemove(x, y);
+ gpaceventmousedown(x, y);
+ touched = true;
+ break;
+ // not in 1.6 case MotionEvent.ACTION_POINTER_1_UP:
+ case MotionEvent.ACTION_UP:
+ 	if ( !touched )
+ 		break;
+ 	gpaceventmouseup(x, y);
+ touched = false;
+ break;
+ case MotionEvent.ACTION_MOVE:
+ 	gpaceventmousemove(x, y);
+ 	if ( !touched ) {
+ 		touched = true;
+ 		//Log.i("Osmo4", "Mouse down: " + x +"," + y);
+ 		gpaceventmousedown(x, y);
+ 	}
+ 	break;
+ case MotionEvent.ACTION_CANCEL:
+ 	if ( !touched )
+ 		break;
+ 	//Log.i("Osmo4", "Mouse up: " + x +"," + y);
+ gpaceventmouseup(x, y);
+ touched = false;
+ break;
+ }
+ }
+
+ @Override
+ public void finalize() throws Throwable {
+ // Not sure how to do this..., destroy is supposed to be called already
+ // destroy();
+ super.finalize();
+ }
+
+ /**
+ * All Native functions, those functions are binded using the handle
+ */
+
+ /**
+ * Opens an URL
+ *
+ * @param url The URL to open
+ */
+ private native void gpacconnect(String url);
+
+ /**
+ * Used to create the GPAC instance
+ *
+ * @param callback
+ * @param width
+ * @param height
+ * @param cfg_dir
+ * @param modules_dir
+ * @param cache_dir
+ * @param font_dir
+ * @param gui_dir
+ * @return
+ */
+ private native long createInstance(GpacCallback callback, int width, int height, String cfg_dir,
+ String modules_dir, String cache_dir, String font_dir, String gui_dir, String url_to_open);
+
+ /**
+ * Disconnects the currently loaded URL
+ */
+ private native void gpacdisconnect();
+
+ /**
+ * Renders
+ *
+ * @param handle
+ */
+ private native void gpacrender();
+
+ /**
+ * Resizes the current view
+ *
+ * @param width The new width to set
+ * @param height The new height to set
+ */
+ private native void gpacresize(int width, int height);
+
+ /**
+ * Free all GPAC resources
+ */
+ private native void gpacfree();
+
+ /**
+ * To call when a key has been pressed
+ *
+ * @param keycode
+ * @param rawkeycode
+ * @param up
+ * @param flag
+ */
+ private native void gpaceventkeypress(int keycode, int rawkeycode, int up, int flag, int unicode);
+
+ /**
+ * To call when a mouse is down
+ *
+ * @param x Position in pixels
+ * @param y Position in pixels
+ */
+ private native void gpaceventmousedown(float x, float y);
+
+ /**
+ * To call when a mouse is up (released)
+ *
+ * @param x Position in pixels
+ * @param y Position in pixels
+ */
+ private native void gpaceventmouseup(float x, float y);
+
+ /**
+ * To call when a mouse is moving
+ *
+ * @param x Position in pixels
+ * @param y Position in pixels
+ */
+ private native void gpaceventmousemove(float x, float y);
+
+ /**
+ * To call when a change in orientation is returned from the sensors
+ * All angles are in RADIANS and positive in the COUNTER-CLOCKWISE direction
+ *
+ * @param x yaw (rotation around the -Z axis) range: -PI, PI
+ * @param y pitch (rotation around the -X axis) range: -PI/2, PI/2
+ * @param z roll (rotation around the Y axis) range: -PI, PI
+ */
+ private native void gpaceventorientationchange(float x, float y, float z);
+
+ public void onOrientationChange(float yaw, float pitch, float roll){
+ gpaceventorientationchange(yaw, pitch, roll);
+ }
+
+ @Override
+ public void destroy() {
+ boolean freeIt;
+ synchronized (this) {
+ freeIt = hasToBeFreed;
+ hasToBeFreed = false;
+ }
+ if (freeIt) {
+ disconnect();
+ gpacfree();
+ }
+ }
+
+ /**
+ * @see com.gpac.Osmo4.GPACInstanceInterface#setGpacPreference(String, String, String)
+ */
+ @Override
+ public native void setGpacPreference(String category, String name, String value);
+
+
+
+ /**
+ * @see com.gpac.Osmo4.GPACInstanceInterface#setGpacLogs(String)
+ */
+ @Override
+ public native void setGpacLogs(String tools_at_levels);
+}

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/GPACInstanceInterface.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/GpacCallback.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/GpacConfig.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/MPEGVSensor.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/Osmo4.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/Osmo4GLSurfaceView.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/Osmo4Renderer.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/Preview.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/SensorServices.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/ConfigFileEditor.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/ConfigFileEditorActivity.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/FileArrayAdapter.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/FileChooserActivity.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/FileChooserFragment.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/FileManager.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/PrefsActivity.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/extra/XMLTagHandler.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/logs Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/java/com/gpac/Osmo4/logs/GpacLogger.java Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/jni Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/jni/README.txt Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/jni/wrapper.cpp Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/jni/wrapper.h Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/jni/wrapper_jni.cpp Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/jni/wrapper_jni.hpp Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout/about_dialog.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout/activity_config_file_editor.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout/activity_file_chooser.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout/auth_requested.xml Added

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="fill_parent"
+ android:layout_height="fill_parent">
+
+ <LinearLayout
+ android:id="@+id/verticalLayout"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:orientation="vertical">
+
+ <TableLayout
+ android:id="@+id/url_auth_layout"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content">
+
+ <TableRow
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:baselineAligned="true">
+
+ <TextView
+ android:layout_width="wrap_content"
+ android:layout_height="fill_parent"
+ android:layout_gravity="right"
+ android:text="@string/usernameLabel" />
+
+ <EditText
+ android:id="@+id/userName"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_weight="2"
+ android:gravity="fill_horizontal|right"
+ android:hint="@string/usernameHint"
+ android:inputType="textUri"
+ android:text="" />
+ </TableRow>
+
+ <TableRow
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:gravity="fill_horizontal">
+
+ <TextView
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="right"
+ android:layout_weight="0"
+ android:baselineAligned="true"
+ android:text="@string/passwordLabel" />
+
+ <EditText
+ android:id="@+id/passwordPrompt"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:layout_weight="2"
+ android:gravity="fill_horizontal|right"
+ android:hint="@string/passwordHint"
+ android:inputType="textPassword"
+ android:text="" />
+ </TableRow>
+ </TableLayout>
+
+ <LinearLayout
+ android:id="@+id/linearLayout1"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content">
+
+ <Button
+ android:id="@+id/button1"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="Button" />
+
+ <Button
+ android:id="@+id/button2"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="Button" />
+
+
+ </LinearLayout>
+ </LinearLayout>
+
+
+</FrameLayout>

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout/fragment_file_chooser.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout/list_item_file_chooser.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/layout/main.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/menu Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/menu/main_menu.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/values Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/values/arrays.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/values/strings.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/xml Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/app/src/main/res/xml/preference.xml Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/build.gradle Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/import-summary.txt Changed

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_android_studio/settings.gradle Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_ios Added

gpac-2.2.0.tar.gz/applications/deprecated/osmo4_ios/main.c Added

@@ -0,0 +1,841 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre, Romain Bouqueau
+ *			Copyright (c) Telecom ParisTech 2000-2012
+ *					All rights reserved
+ *
+ * This file is part of GPAC / command-line client
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+/*includes both terminal and od browser*/
+#include <gpac/terminal.h>
+#include <gpac/term_info.h>
+#include <gpac/constants.h>
+#include <gpac/options.h>
+#include <gpac/events.h>
+
+#include <pwd.h>
+#include <unistd.h>
+
+#include "sensors_def.h"
+
+void PrintAVInfo(Bool final);
+
+static Bool restart = 0;
+static Bool not_threaded = 1;
+
+static Bool no_audio = 0;
+Bool is_connected = 0;
+Bool startup_file = 0;
+GF_User user;
+GF_Terminal *term;
+u64 Duration;
+GF_Err last_error = GF_OK;
+
+static u32 display_rti = 0;
+static Bool Run;
+static Bool CanSeek = 0;
+static char the_urlGF_MAX_PATH;
+static Bool no_mime_check = 1;
+static Bool be_quiet = 0;
+static u32 log_time_start = 0;
+
+static u32 forced_width=0;
+static u32 forced_height=0;
+static u32 bench_mode = 0;
+static u32 bench_mode_start = 0;
+static u32 paused_by_bench = 0;
+
+/*windowless options*/
+u32 align_mode = 0;
+u32 init_w = 0;
+u32 init_h = 0;
+u32 last_x, last_y;
+Bool right_down = 0;
+
+static u32 rti_update_time_ms = 200;
+static FILE *rti_logs = NULL;
+static u64 memory_at_gpac_startup = 0;
+
+static void UpdateRTInfo(const char *legend)
+{
+	GF_SystemRTInfo rti;
+	if (paused_by_bench==1) return;
+
+	/*refresh every second*/
+	if (!display_rti && !rti_logs) return;
+	if (!gf_sys_get_rti(rti_update_time_ms, &rti, 0) && !legend)
+		return;
+
+	if (display_rti) {
+		if (display_rti==2) {
+			char szMsg1024;
+
+			if (rti.total_cpu_usage && (bench_mode<2) ) {
+				sprintf(szMsg, "FPS %02.02f CPU %2d (%02d) Mem %d kB",
+			 gf_term_get_framerate(term, 0), rti.total_cpu_usage, rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024));
+			} else {
+				sprintf(szMsg, "FPS %02.02f CPU %02d Mem %d kB",
+			 gf_term_get_framerate(term, 0), rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024) );
+			}
+
+			PrintAVInfo(GF_FALSE);
+
+
+			fprintf(stderr, "%s\r", szMsg);
+		} else {
+			if (!rti.process_memory) rti.process_memory = (u32) (memory_at_gpac_startup-rti.physical_memory_avail);
+
+			if (!rti.gpac_memory) rti.gpac_memory = (u32) (memory_at_gpac_startup-rti.physical_memory_avail);
+		}
+
+	}
+	if (rti_logs) {
+		fprintf(rti_logs, "% 8d\t% 8d\t% 8d\t% 4d\t% 8d\t%s",
+		 gf_sys_clock(),
+		 gf_term_get_time_in_ms(term),
+		 rti.total_cpu_usage,
+		 (u32) gf_term_get_framerate(term, 0),
+		 (u32) (rti.gpac_memory / 1024),
+		 legend ? legend : ""
+		 );
+		if (!legend) fprintf(rti_logs, "\n");
+	}
+}
+
+static void ResetCaption()
+{
+	GF_Event event;
+	if (display_rti) return;
+	memset(&event, 0, sizeof(GF_Event));
+
+	event.type = GF_EVENT_SET_CAPTION;
+	if (is_connected) {
+#ifdef FILTER_FIXME
+		char szName1024;
+		NetInfoCommand com;
+
+		event.caption.caption = NULL;
+		/*get any service info*/
+		if (!startup_file && gf_term_get_service_info(term, gf_term_get_root_object(term), &com) == GF_OK) {
+			strcpy(szName, "");
+			if (com.track_info) {
+				char szBuf10;
+				sprintf(szBuf, "%02d ", (u32) (com.track_info>>16) );
+				strcat(szName, szBuf);
+			}
+			if (com.artist) {
+				strcat(szName, com.artist);
+				strcat(szName, " ");
+			}
+			if (com.name) {
+				strcat(szName, com.name);
+				strcat(szName, " ");
+			}
+			if (com.album) {
+				strcat(szName, "(");
+				strcat(szName, com.album);
+				strcat(szName, ")");
+			}
+
+			if (strlen(szName)) event.caption.caption = szName;
+		}
+		if (!event.caption.caption) {
+			char *str = strrchr(the_url, '\\');
+			if (!str) str = strrchr(the_url, '/');
+			event.caption.caption = str ? str+1 : the_url;
+		}
+#endif
+
+	} else {
+		event.caption.caption = "GPAC MP4Client " GPAC_VERSION;
+	}
+	gf_term_user_event(term, &event);
+}
+
+#ifdef WIN32
+u32 get_sys_col(int idx)
+{
+	u32 res;
+	DWORD val = GetSysColor(idx);
+	res = (val)&0xFF;
+	res<<=8;
+	res |= (val>>8)&0xFF;
+	res<<=8;
+	res |= (val>>16)&0xFF;
+	return res;
+}
+#endif
+
+
+void *gyro_dev = NULL;
+
+void ios_sensor_callback(int sensorType, float x, float y, float z, float w)
+{
+	GF_Event evt;
+	memset(&evt, 0, sizeof(GF_Event));
+
+	switch (sensorType) {
+	case SENSOR_ORIENTATION:
+		evt.type = GF_EVENT_SENSOR_ORIENTATION;
+		evt.sensor.x = x;
+		evt.sensor.y = y;
+		evt.sensor.z = z;
+		evt.sensor.w = w;
+		gf_term_user_event(term, &evt);
+		return;
+	default:
+		return;
+	}
+}
+
+static s32 request_next_playlist_item = GF_FALSE;
+FILE *playlist = NULL;
+
+Bool GPAC_EventProc(void *ptr, GF_Event *evt)
+{
+	if (!term) return 0;
+
+	switch (evt->type) {
+	case GF_EVENT_DURATION:
+		Duration = 1000;
+		Duration = (u64) (((s64) Duration) * evt->duration.duration);
+		CanSeek = evt->duration.can_seek;
+		break;
+	case GF_EVENT_MESSAGE:
+	{
+		const char *servName;
+		if (!evt->message.service || !strcmp(evt->message.service, the_url)) {
+			servName = "main service";
+		} else if (!strnicmp(evt->message.service, "data:", 5)) {
+			servName = "";
+		} else {
+			servName = evt->message.service;
+		}
+		if (!evt->message.message) return 0;
+		if (evt->message.error) {
+			if (!is_connected) last_error = evt->message.error;
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s (%s): %s\n", evt->message.message, servName, gf_error_to_string(evt->message.error) ));
+		} else if (!be_quiet) {
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("(%s) %s\r", servName, evt->message.message ));
+		}
+	}
+	break;
+	case GF_EVENT_PROGRESS:
+		if (bench_mode && (evt->progress.progress_type==1) ) {
+
+			fprintf(stderr, "Bench mode paused - downloading %02d %%\r", (u32) (evt->progress.done*100.0/evt->progress.total) );
+			if (!paused_by_bench) {
+				gf_term_set_option(term, GF_OPT_VIDEO_BENCH, 0);
+				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PAUSED);
+				paused_by_bench=1;
+			} else if (evt->progress.done == evt->progress.total) {
+				gf_term_set_option(term, GF_OPT_PLAY_STATE, GF_STATE_PLAYING);
+				gf_term_set_option(term, GF_OPT_VIDEO_BENCH, (bench_mode==3) ? 2 : 1);
+				bench_mode_start = gf_sys_clock();
+				paused_by_bench=2;
+			}
+		}
+		break;
+
+	case GF_EVENT_CONNECT:
+		if (evt->connect.is_connected) {
+			is_connected = 1;
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Service Connected\n"));
+		} else if (is_connected) {
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Service %s\n", is_connected ? "Disconnected" : "Connection Failed"));
+			is_connected = 0;
+			Duration = 0;
+		}
+		if (init_w && init_h) {
+			gf_term_set_size(term, init_w, init_h);
+		}
+		ResetCaption();
+		break;
+
+	case GF_EVENT_QUIT:
+		Run = 0;
+		break;
+	case GF_EVENT_DISCONNECT:
+		gf_term_disconnect(term);
+		break;
+
+	case GF_EVENT_NAVIGATE:
+		if (gf_term_is_supported_url(term, evt->navigate.to_url, 1, no_mime_check)) {
+			strcpy(the_url, evt->navigate.to_url);
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Navigating to URL %s\n", the_url));
+			gf_term_navigate_to(term, evt->navigate.to_url);
+			return 1;
+		} else {
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Navigation destination not supported\nGo to URL: %s\n", evt->navigate.to_url ));
+		}
+		break;
+	case GF_EVENT_DBLCLICK:
+		if (playlist) {
+			request_next_playlist_item=GF_TRUE;
+		}
+		break;
+	case GF_EVENT_SENSOR_REQUEST:
+		if (evt->activate_sensor.sensor_type==GF_EVENT_SENSOR_ORIENTATION) {
+			if (!gyro_dev) {
+				gyro_dev = sensor_create(SENSOR_ORIENTATION, ios_sensor_callback);
+				if (!gyro_dev)
+					return GF_FALSE;
+			}
+			if (evt->activate_sensor.activate) {
+				/*start sensors*/
+				sensor_start(gyro_dev);
+			} else if (gyro_dev) {
+				sensor_stop(gyro_dev);
+			}
+			return GF_TRUE;
+		}
+		return GF_FALSE;
+	}
+	return 0;
+}
+
+
+static void on_gpac_log(void *cbk, GF_LOG_Level ll, GF_LOG_Tool lm, const char *fmt, va_list list)
+{
+	FILE *logs = cbk;
+
+	if (rti_logs && (lm & GF_LOG_RTI)) {
+		char szMsg2048;
+		vsnprintf(szMsg, 2048, fmt, list);
+		UpdateRTInfo(szMsg + 6 /*"RTI "*/);
+	} else {
+		if (log_time_start) fprintf(logs, "At %d", gf_sys_clock() - log_time_start);
+		vfprintf(logs, fmt, list);
+		fflush(logs);
+	}
+}
+
+void set_cfg_option(char *opt_string)
+{
+	char *sep, *sep2, szSec1024, szKey1024, szVal1024;
+	sep = strchr(opt_string, ':');
+	if (!sep) {
+		fprintf(stderr, "Badly formatted option %s - expected Section:Name=Value\n", opt_string);
+		return;
+	}
+	{
+		const size_t sepIdx = sep - opt_string;
+		strncpy(szSec, opt_string, sepIdx);
+		szSecsepIdx = 0;
+	}
+	sep ++;
+	sep2 = strchr(sep, '=');
+	if (!sep2) {
+		fprintf(stderr, "Badly formatted option %s - expected Section:Name=Value\n", opt_string);
+		return;
+	}
+	{
+		const size_t sepIdx = sep2 - sep;
+		strncpy(szKey, sep, sepIdx);
+		szKeysepIdx = 0;
+		strcpy(szVal, sep2+1);
+	}
+
+	if (!stricmp(szKey, "*")) {
+		if (stricmp(szVal, "null")) {
+			fprintf(stderr, "Badly formatted option %s - expected Section:*=null\n", opt_string);
+			return;
+		}
+		gf_opts_del_section(szSec);
+		return;
+	}
+
+	if (!stricmp(szVal, "null")) {
+		szVal0=0;
+	}
+	gf_opts_set_key(szSec, szKey, szVal0 ? szVal : NULL);
+}
+
+
+static void on_progress_null(const void *_ptr, const char *_title, u64 done, u64 total)
+{
+}
+#ifdef GPAC_CONFIG_IOS
+int SDL_main (int argc, char *argv)
+#else
+int main (int argc, char *argv)
+#endif
+{
+	const char *str;
+	char *ext;
+	u32 i;
+	u32 url_idx_plus_1 = 0;
+	u32 simulation_time = 0;
+	Bool auto_exit = 0;
+	Bool use_gui = 0;
+ GF_MemTrackerType mem_track = GF_MemTrackerNone;
+	Bool logs_set = GF_FALSE;
+	char *url_arg, *the_cfg;
+	const char *logs_settings = NULL;
+	GF_SystemRTInfo rti;
+	FILE *logfile = NULL;
+	/*by default use current dir*/
+	strcpy(the_url, ".");
+
+	memset(&user, 0, sizeof(GF_User));
+
+	url_arg = the_cfg = NULL;
+
+#ifdef GPAC_MEMORY_TRACKING
+	for (i=1; i<argc; i++) {
+		char *arg = argvi;
+		if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
+ mem_track = !strcmp(arg, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
+		}
+	}
+#endif
+
+	gf_sys_init(mem_track, NULL);
+	gf_set_progress_callback(NULL, on_progress_null);
+ 
+	for (i=1; i<argc; i++) {
+		char *arg = argvi;
+		if (arg0 != '-') {
+			url_arg = arg;
+			url_idx_plus_1 = i+1;
+		}
+		else if (!strcmp(arg, "-logs")) {
+			logs_settings = argvi+1;
+			i++;
+		}
+		else if (!strcmp(arg, "-lf")) {
+			logfile = gf_fopen(argvi+1, "wt");
+			gf_log_set_callback(logfile, on_gpac_log);
+			i++;
+		}
+#ifndef GPAC_MEMORY_TRACKING
+		else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
+			fprintf(stderr, "WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", arg);
+		}
+#endif
+		else if (!strcmp(arg, "-no-audio")) no_audio = GF_TRUE;
+		else if (!strcmp(arg, "-bench")) bench_mode = 1;
+		else if (!strcmp(arg, "-vbench")) bench_mode = 2;
+		else if (!strcmp(arg, "-sbench")) bench_mode = 3;
+		else if (!strcmp(arg, "-gui") || !strcmp(arg, "-guid")) use_gui = 1;
+		else if (!strcmp(arg, "-opt")) {
+			set_cfg_option(argvi+1);
+			i++;
+		}
+		else if (!strcmp(arg, "-run-for")) {
+			simulation_time = atoi(argvi+1);
+			i++;
+		}
+ 	}
+
+	if (logs_settings) {
+		if (gf_log_set_tools_levels(logs_settings, GF_TRUE) != GF_OK) {
+			return 1;
+		}
+		logs_set = GF_TRUE;
+	}
+
+	if (!logs_set)
+		gf_log_set_tools_levels( gf_opts_get_key("core", "logs"), GF_TRUE);
+
+	gf_opts_set_key("filter@compositor", "ogl", "hybrid");
+
+	if (!logfile) {
+		const char *opt = gf_opts_get_key("core", "log-file");
+		if (opt) {
+			logfile = gf_fopen(opt, "wt");
+			if (logfile)
+				gf_log_set_callback(logfile, on_gpac_log);
+		}
+	}
+
+	gf_sys_get_rti(500, &rti, GF_RTI_SYSTEM_MEMORY_ONLY);
+	memory_at_gpac_startup = rti.physical_memory_avail;
+
+	init_w = forced_width;
+	init_h = forced_height;
+/*
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Loading modules\n" ));
+	str = gf_opts_get_key("core", "mod-dirs");
+
+	user.modules = gf_modules_new((const char *) str, cfg_file);
+	if (user.modules) i = gf_modules_get_count(user.modules);
+	if (!i || !user.modules) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Error: no modules found in %s - exiting\n", str));
+		if (user.modules) gf_modules_del(user.modules);
+		gf_cfg_del(cfg_file);
+		gf_sys_close();
+		if (logfile) gf_fclose(logfile);
+		return 1;
+	}
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Modules Loaded (%d found in %s)\n", i, str));
+*/
+//	url_arg="$IOS_DOCS/NBA_score_table_2_hd.mp4#LIVE360TV";
+
+	if (url_arg && !strncmp(url_arg, "$IOS_DOCS", 9)) {
+		char *path = (char *) gf_opts_get_key("General", "iOSDocumentsDir");
+		if (path) {
+			strcpy(the_url, path);
+			path = strchr(url_arg, '/');
+			if (path) {
+				strcat(the_url, path+1);
+				url_arg = the_url;
+				argvurl_idx_plus_1 - 1 = url_arg;
+			}
+		}
+	}
+	gf_sys_set_args(argc, (const char **) argv);
+
+	user.EventProc = GPAC_EventProc;
+	/*dummy in this case (global vars) but MUST be non-NULL*/
+	//user.opaque = user.modules;
+	if (no_audio) gf_opts_set_key("temp", "no-audio", "yes");
+
+	if (bench_mode) {
+		//gf_cfg_discard_changes(user.config);
+		auto_exit = GF_TRUE;
+		if (bench_mode!=2) {
+			gf_opts_set_key("filter@compositor", "ogl", "off");
+		} else {
+			gf_opts_set_key("core", "disable-vsync", "yes");
+		}
+	}
+
+
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Loading GPAC Terminal\n"));
+	term = gf_term_new(&user);
+	if (!term) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("\nInit error - check you have at least one video out and one rasterizer...\nFound modules:\n"));
+		//gf_modules_del(user.modules);
+		//gf_cfg_del(cfg_file);
+		gf_sys_close();
+		if (logfile) gf_fclose(logfile);
+		return 1;
+	}
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Terminal Loaded\n"));
+
+	if (bench_mode) {
+		display_rti = 2;
+		gf_term_set_option(term, GF_OPT_VIDEO_BENCH, (bench_mode==3) ? 2 : 1);
+		if (bench_mode==1) bench_mode=2;
+	}
+
+	/*check audio output*/
+	str = gf_opts_get_key("core", "audio-output");
+	if (!str || !strcmp(str, "No Audio Output Available")) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("WARNING: no audio output availble - make sure no other program is locking the sound card\n"));
+	}
+	str = gf_opts_get_key("General", "NoMIMETypeFetch");
+	no_mime_check = (str && !stricmp(str, "yes")) ? 1 : 0;
+
+	str = gf_opts_get_key("core", "proxy-on");
+	if (str && !strcmp(str, "yes")) {
+		str = gf_opts_get_key("core", "proxy-name");
+		if (str) GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("HTTP Proxy %s enabled\n", str));
+	}
+
+	Run = 1;
+
+	ext = url_arg ? strrchr(url_arg, '.') : NULL;
+	if (ext && (!stricmp(ext, ".m3u") || !stricmp(ext, ".pls"))) {
+		char pl_pathGF_MAX_PATH;
+		GF_Err e = GF_OK;
+		fprintf(stderr, "Opening Playlist %s\n", url_arg);
+
+		strcpy(pl_path, url_arg);
+		/*this is not clean, we need to have a plugin handle playlist for ourselves*/
+		if (!strncmp("http:", url_arg, 5)) {
+#ifdef FILTER_FIXME
+			GF_DownloadSession *sess = gf_dm_sess_new(term->downloader, url_arg, GF_NETIO_SESSION_NOT_THREADED, NULL, NULL, &e);
+			if (sess) {
+				e = gf_dm_sess_process(sess);
+				if (!e) strcpy(pl_path, gf_dm_sess_get_cache_name(sess));
+				gf_dm_sess_del(sess);
+			}
+#endif
+
+		}
+
+		playlist = e ? NULL : gf_fopen(pl_path, "rt");
+		if (playlist) {
+			request_next_playlist_item = GF_TRUE;
+		} else {
+			if (e)
+				fprintf(stderr, "Failed to open playlist %s: %s\n", url_arg, gf_error_to_string(e) );
+
+			fprintf(stderr, "Hit 'h' for help\n\n");
+		}
+	} else if (!use_gui && url_arg) {
+		gf_term_connect(term, url_arg);
+	} else {
+		str = gf_opts_get_key("General", "StartupFile");
+		if (str) {
+			if (!url_arg) {
+				sprintf(the_url, "MP4Client %s", gf_gpac_version() );
+			}
+			gf_term_connect(term, str);
+			startup_file = 1;
+		}
+	}
+
+	/*force fullscreen*/
+	gf_term_set_option(term, GF_OPT_FULLSCREEN, 1);
+
+	if (bench_mode) {
+		rti_update_time_ms = 500;
+		bench_mode_start = gf_sys_clock();
+	}
+
+	while (Run) {
+		if (restart) {
+			restart = 0;
+			gf_term_play_from_time(term, 0, 0);
+		}
+
+		if (request_next_playlist_item) {
+			char szPathGF_MAX_PATH;
+
+			request_next_playlist_item=0;
+			gf_term_disconnect(term);
+
+			if (fscanf(playlist, "%1023s", szPath) == EOF) {
+				fprintf(stderr, "No more items - exiting\n");
+				Run = 0;
+			} else if (szPath0 == '#') {
+				request_next_playlist_item = GF_TRUE;
+			} else {
+				fprintf(stderr, "Opening URL %s\n", szPath);
+				gf_term_connect_with_path(term, szPath, url_arg);
+			}
+		}
+
+		if (display_rti) UpdateRTInfo(NULL);
+		if (not_threaded) {
+			//printf("gf_term_process_step from run loop\n");
+			gf_term_process_step(term);
+			if (auto_exit && gf_term_get_option(term, GF_OPT_IS_OVER)) {
+				Run = 0;
+			}
+		} else {
+			gf_sleep(rti_update_time_ms);
+		}
+		/*sim time*/
+		if (simulation_time && (gf_term_get_time_in_ms(term)>simulation_time)) {
+			Run = 0;
+		}
+	}
+
+	if (bench_mode) {
+		PrintAVInfo(GF_TRUE);
+	}
+
+	gf_term_disconnect(term);
+
+	if (gyro_dev) {
+		sensor_stop(gyro_dev);
+	}
+
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Deleting terminal... "));
+	gf_term_del(term);
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("OK\n"));
+
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("GPAC cleanup ...\n"));
+	//gf_modules_del(user.modules);
+	//gf_cfg_del(cfg_file);
+
+	if (gyro_dev) {
+		sensor_destroy(&gyro_dev);
+	}
+
+#ifdef GPAC_MEMORY_TRACKING
+	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
+		gf_memory_print();
+	}
+#endif
+
+	gf_sys_close();
+	if (rti_logs) gf_fclose(rti_logs);
+	if (logfile) gf_fclose(logfile);
+	if (playlist) gf_fclose(playlist);
+
+	exit(0);
+	return 0;
+}
+
+static GF_ObjectManager *video_odm = NULL;
+static GF_ObjectManager *audio_odm = NULL;
+static GF_ObjectManager *scene_odm = NULL;
+static u32 last_odm_count = 0;
+void PrintAVInfo(Bool final)
+{
+	GF_MediaInfo a_odi, v_odi, s_odi;
+	u32 tot_time;
+
+	if (scene_odm) {
+		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
+		u32 count = gf_term_get_object_count(term, root_odm);
+		if (last_odm_count != count) {
+			last_odm_count = count;
+			scene_odm = NULL;
+		}
+	}
+	if (!video_odm && !audio_odm && !scene_odm) {
+		u32 count, i;
+		GF_ObjectManager *root_odm = gf_term_get_root_object(term);
+		if (!root_odm) return;
+
+		if (gf_term_get_object_info(term, root_odm, &v_odi)==GF_OK) {
+			if (!scene_odm && (v_odi.generated_scene== 0)) {
+				scene_odm = root_odm;
+			}
+		}
+
+		count = gf_term_get_object_count(term, root_odm);
+		for (i=0; i<count; i++) {
+			GF_ObjectManager *odm = gf_term_get_object(term, root_odm, i);
+			if (!odm) break;
+			if (gf_term_get_object_info(term, odm, &v_odi) == GF_OK) {
+				if (!video_odm && (v_odi.od_type == GF_STREAM_VISUAL) && (v_odi.raw_media || (v_odi.cb_max_count>1) || v_odi.direct_video_memory) ) {
+					video_odm = odm;
+				}
+				else if (!audio_odm && (v_odi.od_type == GF_STREAM_AUDIO)) {
+					audio_odm = odm;
+				}
+				else if (!scene_odm && (v_odi.od_type == GF_STREAM_SCENE)) {
+					scene_odm = odm;
+				}
+			}
+		}
+	}
+
+	if (video_odm) {
+		if (gf_term_get_object_info(term, video_odm, &v_odi)!= GF_OK) {
+			video_odm = NULL;
+			return;
+		}
+	} else {
+		memset(&v_odi, 0, sizeof(v_odi));
+	}
+	if (audio_odm) {
+		gf_term_get_object_info(term, audio_odm, &a_odi);
+	} else {
+		memset(&a_odi, 0, sizeof(a_odi));
+	}
+	if (!video_odm && scene_odm) {
+		gf_term_get_object_info(term, scene_odm, &s_odi);
+	} else {
+		memset(&s_odi, 0, sizeof(s_odi));
+	}
+
+	if (final) {
+		tot_time = gf_sys_clock() - bench_mode_start;
+		fprintf(stderr, " \r");
+		fprintf(stderr, "************** Bench Mode Done in %d ms ********************\n", tot_time);
+		if (bench_mode==3) fprintf(stderr, "** Systems layer only (no decoding) **\n");
+
+		if (!video_odm) {
+			u32 nb_frames_drawn;
+			Double FPS = gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
+			fprintf(stderr, "Drawn %d frames FPS %.2f (simulation FPS %.2f) - duration %d ms\n", nb_frames_drawn, ((Float)nb_frames_drawn*1000)/tot_time,(Float) FPS, gf_term_get_time_in_ms(term) );
+		}
+	}
+	if (video_odm) {
+		fprintf(stderr, "%s %dx%d sar=%d:%d duration %.2fs\n", v_odi.codec_name, v_odi.width, v_odi.height, v_odi.par ? (v_odi.par>>16)&0xFF : 1, v_odi.par ? (v_odi.par)&0xFF : 1, v_odi.duration);
+		if (final) {
+			u32 dec_run_time = v_odi.last_frame_time - v_odi.first_frame_time;
+			if (!dec_run_time) dec_run_time = 1;
+			if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
+			fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / dec_run_time, v_odi.max_dec_time, (u32) v_odi.avg_bitrate/1000, (u32) v_odi.max_bitrate/1000);
+			if (v_odi.nb_dropped) {
+				fprintf(stderr, " (Error during bench: %d frames drop)", v_odi.nb_dropped);
+			}
+			fprintf(stderr, "\n");
+		}
+	}
+	if (audio_odm) {
+		fprintf(stderr, "%s SR %d num channels %d fmt %s duration %.2fs\n", a_odi.codec_name, a_odi.sample_rate, a_odi.num_channels, gf_audio_fmt_name(a_odi.afmt), a_odi.duration);
+		if (final) {
+			u32 dec_run_time = a_odi.last_frame_time - a_odi.first_frame_time;
+			if (!dec_run_time) dec_run_time = 1;
+			if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
+			fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max) rate avg %d max %d", a_odi.nb_dec_frames, ((Float)dec_run_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0, (u32) a_odi.avg_bitrate/1000, (u32) a_odi.max_bitrate/1000);
+			if (a_odi.nb_dropped) {
+				fprintf(stderr, " (Error during bench: %d frames drop)", a_odi.nb_dropped);
+			}
+			fprintf(stderr, "\n");
+		}
+	}
+	if (scene_odm) {
+		u32 w, h;
+		gf_term_get_visual_output_size(term, &w, &h);
+		fprintf(stderr, "%s scene size %dx%d rastered to %dx%d duration %.2fs\n", s_odi.codec_name ? s_odi.codec_name : "", s_odi.width, s_odi.height, w, h, s_odi.duration);
+		if (final) {
+			if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
+				u32 dec_run_time = s_odi.last_frame_time - s_odi.first_frame_time;
+				if (!dec_run_time) dec_run_time = 1;
+				fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", s_odi.nb_dec_frames, ((Float)s_odi.nb_dec_frames*1000) / dec_run_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000, (u32) s_odi.max_bitrate/1000);
+				fprintf(stderr, "\n");
+			} else {
+				u32 nb_frames_drawn;
+				Double FPS;
+				gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
+				tot_time = gf_sys_clock() - bench_mode_start;
+				FPS = gf_term_get_framerate(term, 0);
+				fprintf(stderr, "%d frames FPS %.2f (abs %.2f)\n", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
+			}
+		}
+	}
+	if (final) {
+		fprintf(stderr, "**********************************************************\n\n");
+		return;
+	}
+
+	if (video_odm) {
+		u32 dec_run_time = v_odi.last_frame_time - v_odi.first_frame_time;
+		if (!dec_run_time) dec_run_time = 1;
+		tot_time = v_odi.last_frame_time - v_odi.first_frame_time;
+		if (!tot_time) tot_time=1;
+		if (v_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*v_odi.current_time / v_odi.duration ) );
+		fprintf(stderr, "%d f FPS %.2f (max %d us/f) rate avg %d max %d", v_odi.nb_dec_frames, ((Float)v_odi.nb_dec_frames*1000) / dec_run_time, v_odi.max_dec_time, (u32) v_odi.avg_bitrate/1000, (u32) v_odi.max_bitrate/1000);
+	}
+	else if (scene_odm) {
+		if (s_odi.nb_dec_frames>2 && s_odi.total_dec_time) {
+			u32 dec_run_time = s_odi.last_frame_time - s_odi.first_frame_time;
+			if (!dec_run_time) dec_run_time = 1;
+			fprintf(stderr, "%d frames FPS %.2f (max %d us/f) rate avg %d max %d", s_odi.nb_dec_frames, ((Float)s_odi.nb_dec_frames*1000) / dec_run_time, s_odi.max_dec_time, (u32) s_odi.avg_bitrate/1000, (u32) s_odi.max_bitrate/1000);
+			fprintf(stderr, "\n");
+		} else {
+			u32 nb_frames_drawn;
+			Double FPS;
+			gf_term_get_simulation_frame_rate(term, &nb_frames_drawn);
+			tot_time = gf_sys_clock() - bench_mode_start;
+			FPS = gf_term_get_framerate(term, 0);
+			fprintf(stderr, "%d frames FPS %.2f (abs %.2f)\n", nb_frames_drawn, (1000.0*nb_frames_drawn / tot_time), FPS);
+		}
+	}
+	else if (audio_odm) {
+		gf_term_get_object_info(term, audio_odm, &a_odi);
+		tot_time = a_odi.last_frame_time - a_odi.first_frame_time;
+		if (!tot_time) tot_time=1;
+		if (a_odi.duration) fprintf(stderr, "%d%% ", (u32) (100*a_odi.current_time / a_odi.duration ) );
+		fprintf(stderr, "%d frames (ms/f %.2f avg %.2f max)", a_odi.nb_dec_frames, ((Float)tot_time)/a_odi.nb_dec_frames, a_odi.max_dec_time/1000.0);
+	}
+}
+

gpac-2.2.0.tar.gz/applications/deprecated/player_api Added

gpac-2.2.0.tar.gz/applications/deprecated/player_api/main.c Changed

gpac-2.0.0.tar.gz/applications/gpac/Makefile -> gpac-2.2.0.tar.gz/applications/gpac/Makefile Changed

gpac-2.2.0.tar.gz/applications/gpac/carbon_hook.c Added

@@ -0,0 +1,88 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / gpac application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#if defined(__DARWIN__) || defined(__APPLE__)
+#include <Carbon/Carbon.h>
+#endif
+
+#include <gpac/setup.h>
+
+#ifndef GPAC_DISABLE_PLAYER
+
+//declare prototype, don't include gpac.h due to conflict in Fixed type between gpac and OSX
+void carbon_remove_hook(void);
+void carbon_set_hook(void);
+void gpac_open_urls(const char *urls);
+
+int gf_dynstrcat(char **str, const char *to_append, const char *sep);
+
+static AEEventHandlerUPP open_doc_UPP;
+
+void carbon_remove_hook()
+{
+	AERemoveEventHandler(kCoreEventClass, kAEOpenDocuments, open_doc_UPP, false);
+	DisposeAEEventHandlerUPP(open_doc_UPP);
+}
+
+static pascal OSErr sdl_ae_open_doc(const AppleEvent *ae_event, AppleEvent *ae_reply, long ae_ref_count)
+{
+	char path4096;
+	OSErr err;
+	AEDescList docList;
+	long i, count;
+	char *urls = NULL;
+
+	err = AEGetParamDesc(ae_event, keyDirectObject, typeAEList, &docList);
+	if (err) goto exit;
+
+	err = AECountItems(&docList, &count);
+	if (err) goto exit;
+	for (i=0; i<count; i++) {
+		FSRef ref;
+		err = AEGetNthPtr(&docList, i+1, typeFSRef, NULL, NULL, &ref, sizeof(FSRef), NULL);
+		if (err) continue;
+		FSRefMakePath(&ref, (UInt8 *) path, 4096);
+		path4095=0;
+		gf_dynstrcat(&urls, path, ",");
+	}
+	if (urls) {
+		gpac_open_urls(urls);
+		gf_free(urls);
+	}
+
+	AEDisposeDesc(&docList);
+
+exit:
+	return (noErr);
+}
+
+void carbon_set_hook()
+{
+	open_doc_UPP = NewAEEventHandlerUPP(sdl_ae_open_doc);
+	AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, open_doc_UPP, 0L, false);
+}
+
+
+#endif // GPAC_DISABLE_PLAYER

gpac-2.2.0.tar.gz/applications/gpac/compositor_tools.c Added

@@ -0,0 +1,1642 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / gpac application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include "gpac.h"
+
+#ifndef GPAC_DISABLE_PLAYER
+
+#include <gpac/main.h>
+#include <gpac/events.h>
+#include <gpac/filters.h>
+#include <gpac/compositor.h>
+//for window flags
+#include <gpac/modules/video_out.h>
+#include <gpac/avparse.h>
+
+#ifndef WIN32
+#include <dlfcn.h>
+#include <pwd.h>
+#include <unistd.h>
+
+#else //WIN32
+
+#include <windows.h> /*for GetModuleFileName*/
+
+#endif	//WIN32
+
+extern u32 compositor_mode;
+
+#if !defined(GPAC_CONFIG_IOS)
+#define DESKTOP_GUI
+#endif
+
+
+#ifdef DESKTOP_GUI
+static void mp4c_take_screenshot(Bool for_coverage);
+#endif
+
+
+static Bool reload = GF_FALSE;
+static u32 window_flags=0;
+static Bool do_coverage = GF_FALSE;
+
+extern FILE *helpout;
+extern u32 gen_doc;
+extern u32 help_flags;
+
+#ifdef WIN32
+#include <wincon.h>
+#endif
+
+#if defined(__DARWIN__) || defined(__APPLE__)
+#define VK_MOD GF_KEY_MOD_ALT
+#else
+#define VK_MOD GF_KEY_MOD_CTRL
+#endif
+
+static u32 bench_mode = 0;
+static u32 bench_mode_start = 0;
+static u32 bench_buffer = 0;
+static Bool eos_seen = GF_FALSE;
+static Bool addon_visible = GF_TRUE;
+static Bool is_connected = GF_FALSE;
+static u64 duration_ms=0;
+static GF_Err last_error = GF_OK;
+static Bool enable_add_ons = GF_TRUE;
+static Fixed playback_speed = FIX_ONE;
+
+static u32 display_rti = 0;
+static Bool can_seek = GF_FALSE;
+static u64 log_rti_time_start = 0;
+
+static Bool loop_at_end = GF_FALSE;
+static const char *update_str = NULL;
+static const char *update_type = "js";
+#ifdef DESKTOP_GUI
+static u32 forced_width=0;
+static u32 forced_height=0;
+
+
+/*windowless options*/
+static u32 align_mode = 0;
+static u32 init_w = 0;
+static u32 init_h = 0;
+static u32 last_x, last_y;
+static Bool right_down = GF_FALSE;
+
+#endif
+
+
+static GF_Filter *comp_filter = NULL;
+static GF_Compositor *compositor = NULL;
+
+
+GF_GPACArg mp4c_args =
+{
+#ifdef DESKTOP_GUI
+	GF_DEF_ARG("size", NULL, "specify visual size WxH. If not set, scene size or video size is used", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("fs", NULL, "start in fullscreen mode", NULL, NULL, GF_ARG_BOOL, 0),
+#endif
+
+ 	GF_DEF_ARG("bm", NULL, "benchmark compositor without video out", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+ 	GF_DEF_ARG("vbm", NULL, "benchmark compositor with video out", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+ 	GF_DEF_ARG("sbm", NULL, "benchmark compositor systems aspect (no decode, no video)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("loop", NULL, "loop playback", NULL, NULL, GF_ARG_BOOL, 0),
+
+	GF_DEF_ARG("rti", NULL, "log run-time info (FPS, CPU, Mem usage) to given file", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("rtix", NULL, "same as -rti but driven by GPAC logs", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("rti-refresh", NULL, "set refresh time in ms between two runt-time counters queries (default is 200)", NULL, NULL, GF_ARG_INT, 0),
+ 	GF_DEF_ARG("pause", NULL, "pause at first frame", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("start", NULL, "play from given time in seconds", NULL, NULL, GF_ARG_DOUBLE, 0),
+	GF_DEF_ARG("speed", NULL, "set playback speed", NULL, NULL, GF_ARG_DOUBLE, 0),
+	GF_DEF_ARG("exit", NULL, "exit when presentation is over", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("service", NULL, "auto-tune to given service ID in a multiplex", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("update", NULL, "scene update to execute once connected", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("update-type", NULL, "type of scene update to execute", "js", NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+
+#ifdef GPAC_CONFIG_WIN32
+ 	GF_DEF_ARG("no-wnd", NULL, "use windowless mode (Win32 only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERIMENTAL),
+ 	GF_DEF_ARG("no-back", NULL, "use transparent background for output window when no background is specified (Win32 only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERIMENTAL),
+ 	GF_DEF_ARG("align", NULL, "specify v and h alignment for windowless mode\n"
+ 	"- tl: top/left\n"
+ 	"- tm: top/horizontal middle\n"
+ 	"- tr: top/right\n"
+ 	"- ml: vertical middle/left\n"
+ 	"- mm: vertical middle/horizontal middle\n"
+ 	"- mr: vertical middle/right\n"
+ 	"- bl: bottom/left\n"
+ 	"- bm: bottom/horizontal middle\n"
+ 	"- br: bottom/right", "tl", "tl|tm|tr|ml|mm|mr|bl|bm|br", GF_ARG_INT, GF_ARG_HINT_EXPERIMENTAL),
+#endif // GPAC_CONFIG_WIN32
+
+	GF_DEF_ARG("no-addon", NULL, "disable automatic loading of media addons declared in source URL", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("nk", NULL, "disable keyboard interaction", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	{0}
+};
+
+typedef enum
+{
+	MP4C_RELOAD=0,
+	MP4C_OPEN,
+	MP4C_DISCONNECT,
+	MP4C_PAUSE_RESUME,
+	MP4C_STEP,
+	MP4C_SEEK,
+	MP4C_SEEK_TIME,
+	MP4C_TIME,
+	MP4C_UPDATE,
+	MP4C_EVALJS,
+#ifdef DESKTOP_GUI
+	MP4C_SCREENSHOT,
+#endif
+	MP4C_DUMPSCENE,
+	MP4C_STRESSMODE,
+	MP4C_NAVMODE,
+	MP4C_LASTVP,
+	MP4C_OGL2D,
+	MP4C_AR_4_3,
+	MP4C_AR_16_9,
+	MP4C_AR_NONE,
+	MP4C_AR_ORIG,
+	MP4C_LOGS,
+	MP4C_RELOAD_OPTS,
+	MP4C_DISP_RTI,
+	MP4C_DISP_FPS,
+	MP4C_HELP,
+	MP4C_DOWNRATE,
+	MP4C_VMEM_CACHE,
+
+} MP4C_Command;
+
+struct _mp4c_key
+{
+ u8 char_code;
+ MP4C_Command cmd_type;
+ const char *cmd_help;
+ u32 flags;
+} MP4C_Keys = {
+	{'R', MP4C_RELOAD, "reload presentation", 0},
+	{'o', MP4C_OPEN, "connect to the specified URL", 0},
+	{'D', MP4C_DISCONNECT, "disconnect the current presentation", 0},
+	{'p', MP4C_PAUSE_RESUME, "play/pause the presentation", 0},
+	{'f', MP4C_STEP, "step one frame ahead", 0},
+	{'z', MP4C_SEEK, "seek into presentation by percentage", 0},
+	{'T', MP4C_SEEK_TIME, "seek into presentation by time", 0},
+	{'t', MP4C_TIME, "print current timing", 0},
+	{'a', MP4C_UPDATE, "send a command (BIFS or LASeR) to the main scene", 0},
+	{'e', MP4C_EVALJS, "evaluate JavaScript code in the main scene", 0},
+#ifdef DESKTOP_GUI
+	{'Z', MP4C_SCREENSHOT, "dump current output frame to PNG", 0},
+#endif
+	{ 'd', MP4C_DUMPSCENE, "dump scene graph", 0},
+	{ 'k', MP4C_STRESSMODE, "turn stress mode on/off", 0},
+	{ 'n', MP4C_NAVMODE, "change navigation mode", 0},
+	{ 'v', MP4C_LASTVP, "reset to last active viewpoint", 0},
+	{ '3', MP4C_OGL2D, "switch OpenGL on or off for 2D scenes", 0},
+	{ '4', MP4C_AR_4_3, "force 4/3 Aspect Ratio", 0},
+	{ '5', MP4C_AR_16_9, "force 16/9 Aspect Ratio", 0},
+	{ '6', MP4C_AR_NONE, "force no Aspect Ratio (always fill screen)", 0},
+	{ '7', MP4C_AR_ORIG, "force original Aspect Ratio (default)", 0},
+	{ 'H', MP4C_DOWNRATE, "set HTTP max download rate", 0},
+	{ 'E', MP4C_RELOAD_OPTS, "force reload of compositor options", 0},
+
+	{ 'L', MP4C_LOGS, "change log tool/level", 0},
+	{ 'R', MP4C_DISP_RTI, "toggle run-time info display in window title bar on/off", 0},
+	{ 'F', MP4C_DISP_FPS, "toggle displaying of FPS in stderr on/off", 0},
+
+	{ 'h', MP4C_HELP, "print this message", 0},
+	//below this, only experimental features
+	{ 'M', MP4C_VMEM_CACHE, "specify video cache memory for 2D objects", 1},
+	{0}
+};
+
+void mp4c_help(u32 argmode)
+{
+	u32 i=0;
+
+	if (help_flags & (GF_PRINTARG_MAN|GF_PRINTARG_MD)) {
+		return;
+	}
+
+	gf_sys_format_help(helpout, help_flags, "Usage: gpac -mp4c URL options\n"
+		"# General\n"
+		"The `-mp4c` option launches the GPAC compositor as a standalone player without GUI.\n"
+		"Specific URLs shortcuts are available, see GPAC Compositor (gpac -h compositor)(compositor)\n"
+		"\n"
+		"# Options \n"
+	);
+
+	while (mp4c_argsi.name) {
+		GF_GPACArg *arg = &mp4c_argsi;
+		i++;
+		if ((argmode<GF_ARGMODE_EXPERT) && (arg->flags & (GF_ARG_HINT_EXPERIMENTAL|GF_ARG_HINT_EXPERT) ))
+			continue;
+		gf_sys_print_arg(helpout, help_flags, arg, "gpac");
+	}
+
+	if (argmode<GF_ARGMODE_EXPERT) return;
+	gf_sys_format_help(helpout, help_flags, "Usage: gpac -mp4c URL options\n"
+		"# Run-time keyboard options \n"
+	);
+
+	i=0;
+	while (MP4C_Keysi.char_code) {
+		gf_sys_format_help(helpout, help_flags, "`%c`: %s\n", MP4C_Keysi.char_code, MP4C_Keysi.cmd_help);
+		i++;
+	}
+	gf_sys_format_help(helpout, help_flags, " \n");
+}
+
+static MP4C_Command get_gui_cmd(u8 char_code)
+{
+	u32 i=0;
+	while (MP4C_Keysi.char_code) {
+		if (MP4C_Keysi.char_code == char_code)
+			return MP4C_Keysi.cmd_type;
+		i++;
+	}
+	return 0;
+}
+
+void gpac_open_urls(const char *urls)
+{
+	GF_Event evt;
+	memset(&evt, 0, sizeof(GF_Event));
+	evt.type = GF_EVENT_NAVIGATE;
+	evt.navigate.to_url = urls;
+	gf_sc_user_event(compositor, &evt);
+}
+
+
+static void mp4c_print_help()
+{
+	u32 i=0;
+
+	gf_sys_format_help(helpout, help_flags, "# Runtime commands\n"
+		"## Prompt Interaction\n"
+		"The following keys are used for prompt interaction:\n");
+
+	while (MP4C_Keysi.char_code) {
+		struct _mp4c_key *k = &MP4C_Keysi;
+		i++;
+		gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%c: %s%s\n", k->char_code, k->cmd_help, k->flags ? " **! experimental !**" : "");
+	}
+
+	gf_sys_format_help(helpout, help_flags, "\n"
+		"## Content interaction\n"
+		"It is possible to interact with content (interactive or not) using mouse and keyboard.\n"
+		"The following commands are available:\n"
+		"TODO\n"
+		"\n"
+	);
+}
+
+static void print_time(u64 time)
+{
+	u32 ms, h, m, s;
+	h = (u32) (time / 1000 / 3600);
+	m = (u32) (time / 1000 / 60 - h*60);
+	s = (u32) (time / 1000 - h*3600 - m*60);
+	ms = (u32) (time - (h*3600 + m*60 + s) * 1000);
+	fprintf(stderr, "%02d:%02d:%02d.%03d", h, m, s, ms);
+}
+
+static u32 rti_update_time_ms = 200;
+static FILE *rti_logs = NULL;
+
+static void update_rti(const char *legend)
+{
+	GF_SystemRTInfo rti;
+
+	/*refresh every second*/
+	if (!display_rti && !rti_logs) return;
+	if (!gf_sys_get_rti(rti_update_time_ms, &rti, 0) && !legend)
+		return;
+
+	if (display_rti) {
+		char szMsg1024;
+		if (rti.total_cpu_usage && (bench_mode<2) ) {
+			sprintf(szMsg, "FPS %02.02f CPU %2d (%02d) Mem %d kB",
+			 gf_sc_get_fps(compositor, 0), rti.total_cpu_usage, rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024));
+		} else {
+			sprintf(szMsg, "FPS %02.02f CPU %02d Mem %d kB",
+			 gf_sc_get_fps(compositor, 0), rti.process_cpu_usage, (u32) (rti.gpac_memory / 1024) );
+		}
+
+		if (display_rti==2) {
+			fprintf(stderr, "%s\r", szMsg);
+		} else {
+			GF_Event evt;
+			evt.type = GF_EVENT_SET_CAPTION;
+			evt.caption.caption = szMsg;
+			gf_sc_user_event(compositor, &evt);
+		}
+	}
+	if (rti_logs) {
+		fprintf(rti_logs, "% 8d\t% 8d\t% 8d\t% 4d\t% 8d\t%s",
+		 gf_sys_clock(),
+		 gf_sc_get_time_in_ms(compositor),
+		 rti.total_cpu_usage,
+		 (u32) gf_sc_get_fps(compositor, 0),
+		 (u32) (rti.gpac_memory / 1024),
+		 legend ? legend : ""
+		 );
+		if (!legend) fprintf(rti_logs, "\n");
+	}
+}
+
+#ifdef DESKTOP_GUI
+
+#include <gpac/revision.h>
+
+char *caption = NULL;
+
+static void set_window_caption()
+{
+	GF_Event event;
+	if (display_rti) return;
+	event.type = GF_EVENT_SET_CAPTION;
+	event.caption.caption = NULL;
+
+	if (is_connected && (compositor_mode==LOAD_MP4C)) {
+		const GF_PropertyValue *p;
+		GF_PropertyEntry *pe=NULL;
+		GF_FilterPid *pid = (GF_FilterPid *) gf_sc_get_main_pid(compositor);
+
+		if (caption) gf_free(caption);
+		caption = NULL;
+		/*get any service info*/
+		if (pid) {
+			p = gf_filter_pid_get_info_str(pid, "info:track", &pe);
+			if (p) {
+				char szBuf10;
+				sprintf(szBuf, "%02d", p->value.frac.num);
+				gf_dynstrcat(&caption, szBuf, " ");
+			}
+			p = gf_filter_pid_get_info_str(pid, "info:artist", &pe);
+			if (p && p->value.string)
+				gf_dynstrcat(&caption, p->value.string, " ");
+
+			p = gf_filter_pid_get_info_str(pid, "info:name", &pe);
+			if (p && p->value.string)
+				gf_dynstrcat(&caption, p->value.string, " ");
+
+			p = gf_filter_pid_get_info_str(pid, "info:album", &pe);
+			if (p && p->value.string) {
+				gf_dynstrcat(&caption, "(", " ");
+				gf_dynstrcat(&caption, p->value.string, NULL);
+				gf_dynstrcat(&caption, ")", NULL);
+			}
+			if (caption) event.caption.caption = caption;
+
+			if (!event.caption.caption) {
+				p = gf_filter_pid_get_property(pid, GF_PROP_PID_URL);
+				if (!p) p = gf_filter_pid_get_property(pid, GF_PROP_PID_FILEPATH);
+				if (p && p->value.string) caption = gf_strdup(gf_file_basename(p->value.string));
+				event.caption.caption = caption;
+			}
+		}
+	} else {
+		event.caption.caption = "GPAC "GPAC_VERSION "-rev" GPAC_GIT_REVISION;
+	}
+	gf_sc_user_event(compositor, &event);
+}
+#else
+
+#define set_window_caption(_ARG)
+
+#endif
+
+#ifdef WIN32
+u32 get_sys_col(int idx)
+{
+	u32 res;
+	DWORD val = GetSysColor(idx);
+	res = (val)&0xFF;
+	res<<=8;
+	res |= (val>>8)&0xFF;
+	res<<=8;
+	res |= (val>>16)&0xFF;
+	return res;
+}
+#endif
+
+static void switch_bench(u32 is_on)
+{
+	bench_mode = is_on;
+	display_rti = is_on ? 2 : 0;
+	set_window_caption();
+	gf_sc_set_option(compositor, GF_OPT_VIDEO_BENCH, is_on);
+}
+
+#ifdef GPAC_ENABLE_COVERAGE
+#define gf_getch() 0
+#define gf_read_line_input(_line, _maxSize, _showContent) GF_FALSE
+#endif
+
+static void do_set_speed(Fixed desired_speed)
+{
+	if (gf_sc_set_speed(compositor, desired_speed) == GF_OK) {
+		playback_speed = desired_speed;
+		fprintf(stderr, "Playing at %g speed\n", FIX2FLT(playback_speed));
+	} else {
+		fprintf(stderr, "Adjusting speed to %g not supported for this content\n", FIX2FLT(desired_speed));
+	}
+}
+
+#ifdef GPAC_CONFIG_IOS
+#include "sensors_def.h"
+static void *gyro_dev = NULL;
+
+void ios_sensor_callback(int sensorType, float x, float y, float z, float w)
+{
+	GF_Event evt;
+	memset(&evt, 0, sizeof(GF_Event));
+
+	switch (sensorType) {
+	case SENSOR_ORIENTATION:
+		evt.type = GF_EVENT_SENSOR_ORIENTATION;
+		evt.sensor.x = x;
+		evt.sensor.y = y;
+		evt.sensor.z = z;
+		evt.sensor.w = w;
+		gf_sc_user_event(compositor, &evt);
+		return;
+	default:
+		return;
+	}
+}
+#endif
+
+
+Bool mp4c_event_proc(void *ptr, GF_Event *evt)
+{
+	if (compositor_mode==LOAD_GUI_CBK) {
+#ifdef GPAC_CONFIG_IOS
+		if (evt->type == GF_EVENT_SENSOR_REQUEST) {
+			if (evt->activate_sensor.sensor_type==GF_EVENT_SENSOR_ORIENTATION) {
+				if (!gyro_dev) {
+					gyro_dev = sensor_create(SENSOR_ORIENTATION, ios_sensor_callback);
+					if (!gyro_dev)
+						return GF_FALSE;
+				}
+				if (evt->activate_sensor.activate) {
+					/*start sensors*/
+					sensor_start(gyro_dev);
+				} else if (gyro_dev) {
+					sensor_stop(gyro_dev);
+				}
+				return GF_TRUE;
+			}
+			return GF_FALSE;
+		}
+#endif
+		return GF_FALSE;
+	}
+
+	switch (evt->type) {
+	case GF_EVENT_DURATION:
+		duration_ms = (u64) ( 1000 * (s64) evt->duration.duration);
+		can_seek = evt->duration.can_seek;
+		break;
+	case GF_EVENT_MESSAGE:
+	{
+		if (!evt->message.message) return 0;
+		if (evt->message.error) {
+			if (!is_connected) last_error = evt->message.error;
+			if (evt->message.error==GF_SCRIPT_INFO) {
+				GF_LOG(GF_LOG_INFO, GF_LOG_CONSOLE, ("%s\n", evt->message.message));
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONSOLE, ("%s: %s\n", evt->message.message, gf_error_to_string(evt->message.error)));
+			}
+		} else {
+			GF_LOG(GF_LOG_INFO, GF_LOG_CONSOLE, ("%s\n", evt->message.message));
+		}
+	}
+	break;
+	case GF_EVENT_PROGRESS:
+	{
+		char *szTitle = "";
+		if (evt->progress.progress_type==0) {
+			szTitle = "Buffer ";
+			if (bench_mode && (bench_mode!=3) ) {
+				if (evt->progress.done >= evt->progress.total) bench_buffer = 0;
+				else bench_buffer = 1 + 100*evt->progress.done / evt->progress.total;
+				break;
+			}
+		}
+		else if (evt->progress.progress_type==1) {
+			if (bench_mode) break;
+			szTitle = "Download ";
+		}
+		else if (evt->progress.progress_type==2) szTitle = "Import ";
+		gf_set_progress(szTitle, evt->progress.done, evt->progress.total);
+	}
+	break;
+
+
+	case GF_EVENT_DBLCLICK:
+		gf_sc_set_option(compositor, GF_OPT_FULLSCREEN, !gf_sc_get_option(compositor, GF_OPT_FULLSCREEN));
+		return 0;
+
+#ifdef DESKTOP_GUI
+	case GF_EVENT_MOUSEDOWN:
+		if (evt->mouse.button==GF_MOUSE_RIGHT) {
+			right_down = 1;
+			last_x = evt->mouse.x;
+			last_y = evt->mouse.y;
+		}
+		return 0;
+	case GF_EVENT_MOUSEUP:
+		if (evt->mouse.button==GF_MOUSE_RIGHT) {
+			right_down = 0;
+			last_x = evt->mouse.x;
+			last_y = evt->mouse.y;
+		}
+		return 0;
+	case GF_EVENT_MOUSEMOVE:
+		if (right_down && (window_flags & GF_VOUT_WINDOWLESS) ) {
+			GF_Event move;
+			move.move.x = evt->mouse.x - last_x;
+			move.move.y = last_y-evt->mouse.y;
+			move.type = GF_EVENT_MOVE;
+			move.move.relative = 1;
+			gf_sc_user_event(compositor, &move);
+		}
+		return 0;
+#endif
+
+	case GF_EVENT_KEYUP:
+		switch (evt->key.key_code) {
+		case GF_KEY_SPACE:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) switch_bench(!bench_mode);
+			break;
+		}
+		break;
+	case GF_EVENT_KEYDOWN:
+		switch (evt->key.key_code) {
+		case GF_KEY_SPACE:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) {
+				/*ignore key repeat*/
+				if (!bench_mode) switch_bench(!bench_mode);
+			}
+			break;
+		case GF_KEY_PAGEDOWN:
+		case GF_KEY_MEDIANEXTTRACK:
+			break;
+		case GF_KEY_MEDIAPREVIOUSTRACK:
+			break;
+		case GF_KEY_ESCAPE:
+			gf_sc_set_option(compositor, GF_OPT_FULLSCREEN, !gf_sc_get_option(compositor, GF_OPT_FULLSCREEN));
+			break;
+		case GF_KEY_F:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) fprintf(stderr, "Rendering rate: %f FPS\n", gf_sc_get_fps(compositor, 0));
+			break;
+		case GF_KEY_T:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) fprintf(stderr, "Scene Time: %f \n", gf_sc_get_time_in_ms(compositor)/1000.0);
+			break;
+		case GF_KEY_D:
+			if (evt->key.flags & GF_KEY_MOD_CTRL) gf_sc_set_option(compositor, GF_OPT_DRAW_MODE, (gf_sc_get_option(compositor, GF_OPT_DRAW_MODE)==GF_DRAW_MODE_DEFER) ? GF_DRAW_MODE_IMMEDIATE : GF_DRAW_MODE_DEFER );
+			break;
+		case GF_KEY_4:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
+			break;
+		case GF_KEY_5:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
+			break;
+		case GF_KEY_6:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
+			break;
+		case GF_KEY_7:
+			if (evt->key.flags & GF_KEY_MOD_CTRL)
+				gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
+			break;
+		case GF_KEY_O:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				if (gf_sc_get_option(compositor, GF_OPT_MAIN_ADDON)) {
+					fprintf(stderr, "Resuming to main content\n");
+					gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_PLAY_LIVE);
+				} else {
+					fprintf(stderr, "Main addon not enabled\n");
+				}
+			}
+			break;
+		case GF_KEY_P:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				u32 pause_state = gf_sc_get_option(compositor, GF_OPT_PLAY_STATE) ;
+				fprintf(stderr, "Status: %s\n", pause_state ? "Playing" : "Paused");
+				if ((pause_state == GF_STATE_PAUSED) && (evt->key.flags & GF_KEY_MOD_SHIFT)) {
+					gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_PLAY_LIVE);
+				} else {
+					gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, (pause_state==GF_STATE_PAUSED) ? GF_STATE_PLAYING : GF_STATE_PAUSED);
+				}
+			}
+			break;
+		case GF_KEY_S:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+				fprintf(stderr, "Step time: ");
+				print_time(gf_sc_get_time_in_ms(compositor));
+				fprintf(stderr, "\n");
+			}
+			break;
+		case GF_KEY_B:
+			break;
+		case GF_KEY_M:
+			break;
+		case GF_KEY_H:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				gf_sc_switch_quality(compositor, GF_TRUE);
+			//	gf_sc_set_option(term, GF_OPT_MULTIVIEW_MODE, 0);
+			}
+			break;
+		case GF_KEY_L:
+			if ((evt->key.flags & GF_KEY_MOD_CTRL) && is_connected) {
+				gf_sc_switch_quality(compositor, GF_FALSE);
+			//	gf_sc_set_option(compositor, GF_OPT_MULTIVIEW_MODE, 1);
+			}
+			break;
+		case GF_KEY_F5:
+			if (is_connected)
+				reload = 1;
+			break;
+		case GF_KEY_A:
+			addon_visible = !addon_visible;
+			gf_sc_toggle_addons(compositor, addon_visible);
+			break;
+		case GF_KEY_UP:
+			if ((evt->key.flags & VK_MOD) && is_connected) {
+				do_set_speed(playback_speed * 2);
+			}
+			break;
+		case GF_KEY_DOWN:
+			if ((evt->key.flags & VK_MOD) && is_connected) {
+				do_set_speed(playback_speed / 2);
+			}
+			break;
+		case GF_KEY_LEFT:
+			if ((evt->key.flags & VK_MOD) && is_connected) {
+				do_set_speed(-1 * playback_speed );
+			}
+			break;
+
+		}
+		break;
+
+	case GF_EVENT_CONNECT:
+		if (evt->connect.is_connected) {
+			is_connected = 1;
+			fprintf(stderr, "Service Connected\n");
+			eos_seen = GF_FALSE;
+			if (playback_speed != FIX_ONE)
+				gf_sc_set_speed(compositor, playback_speed);
+		} else if (is_connected) {
+			fprintf(stderr, "Service %s\n", is_connected ? "Disconnected" : "Connection Failed");
+			is_connected = 0;
+			duration_ms = 0;
+		}
+
+#ifdef DESKTOP_GUI
+		if (init_w && init_h) {
+			gf_sc_set_size(compositor, init_w, init_h);
+		}
+		set_window_caption();
+#endif
+		break;
+	case GF_EVENT_EOS:
+		eos_seen = GF_TRUE;
+		break;
+	case GF_EVENT_SIZE:
+#ifdef DESKTOP_GUI
+		if (window_flags & GF_VOUT_WINDOWLESS) {
+			GF_Event move;
+			move.type = GF_EVENT_MOVE;
+			move.move.align_x = align_mode & 0xFF;
+			move.move.align_y = (align_mode>>8) & 0xFF;
+			move.move.relative = 2;
+			gf_sc_user_event(compositor, &move);
+		}
+#endif
+		break;
+	case GF_EVENT_SCENE_SIZE:
+
+		if (evt->size.window_id && update_str) {
+			gf_sc_scene_update(compositor, (char*)update_type, (char*)update_str);
+		}
+
+#ifdef DESKTOP_GUI
+		if (forced_width && forced_height) {
+			GF_Event size;
+			u32 nw = forced_width ? forced_width : evt->size.width;
+			u32 nh = forced_height ? forced_height : evt->size.height;
+
+			if ((nw != evt->size.width) || (nh != evt->size.height)) {
+				size.type = GF_EVENT_SIZE;
+				size.size.width = nw;
+				size.size.height = nh;
+				gf_sc_user_event(compositor, &size);
+			}
+		}
+#endif
+		break;
+
+	case GF_EVENT_METADATA:
+		set_window_caption();
+		break;
+	case GF_EVENT_DROPFILE:
+		if (evt->open_file.nb_files) {
+			gf_sc_navigate_to(compositor, evt->open_file.files0);
+		}
+		return 1;
+	case GF_EVENT_NAVIGATE_INFO:
+		if (evt->navigate.to_url)
+			fprintf(stderr, "Go to URL: \"%s\"\r", evt->navigate.to_url);
+		break;
+	case GF_EVENT_NAVIGATE:
+		if (gf_sc_is_supported_url(compositor, evt->navigate.to_url, GF_TRUE)) {
+			fprintf(stderr, "Navigating to URL %s\n", evt->navigate.to_url);
+			gf_sc_navigate_to(compositor, evt->navigate.to_url);
+			return 1;
+		} else {
+			fprintf(stderr, "Navigation destination not supported\nGo to URL: %s\n", evt->navigate.to_url);
+		}
+		break;
+	case GF_EVENT_SET_CAPTION:
+		gf_sc_user_event(compositor, evt);
+		break;
+	case GF_EVENT_AUTHORIZATION:
+	{
+		u32 nb_retry = 4;
+		assert( evt->type == GF_EVENT_AUTHORIZATION);
+		assert( evt->auth.user);
+		assert( evt->auth.password);
+		assert( evt->auth.site_url);
+		while ((!strlen(evt->auth.user) || !strlen(evt->auth.password)) && (nb_retry > 0) ) {
+			nb_retry--;
+			fprintf(stderr, "**** Authorization required for site %s ****\n", evt->auth.site_url);
+			fprintf(stderr, "login : ");
+			if (!gf_read_line_input(evt->auth.user, 50, 1))
+				continue;
+			fprintf(stderr, "\npassword: ");
+			if (!gf_read_line_input(evt->auth.password, 50, 0))
+				continue;
+			fprintf(stderr, "*********\n");
+		}
+		if (nb_retry == 0) {
+			fprintf(stderr, "**** No User or password has been filled, aborting ***\n");
+			return 0;
+		}
+		return 1;
+	}
+	case GF_EVENT_ADDON_DETECTED:
+		if (enable_add_ons) {
+			fprintf(stderr, "Media Addon %s detected - enabling it\n", evt->addon_connect.addon_url);
+			addon_visible = 1;
+		}
+		return enable_add_ons;
+	}
+	return 0;
+}
+
+
+static void set_navigation()
+{
+	GF_Err e;
+	char nav;
+	u32 type = gf_sc_get_option(compositor, GF_OPT_NAVIGATION_TYPE);
+	e = GF_OK;
+//	fflush(stdin);
+
+	if (!type) {
+		fprintf(stderr, "Content/compositor doesn't allow user-selectable navigation\n");
+	} else if (type==1) {
+		fprintf(stderr, "Select Navigation (\'N\'one, \'E\'xamine, \'S\'lide): ");
+		nav = do_coverage ? 'N' : gf_getch();
+		if (nav=='N') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
+		else if (nav=='E') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
+		else if (nav=='S') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
+		else fprintf(stderr, "Unknown selector \'%c\' - only \'N\',\'E\',\'S\' allowed\n", nav);
+	} else if (type==2) {
+		fprintf(stderr, "Select Navigation (\'N\'one, \'W\'alk, \'F\'ly, \'E\'xamine, \'P\'an, \'S\'lide, \'G\'ame, \'V\'R, \'O\'rbit): ");
+		nav = do_coverage ? 'N' : gf_getch();
+		if (nav=='N') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
+		else if (nav=='W') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_WALK);
+		else if (nav=='F') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_FLY);
+		else if (nav=='E') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
+		else if (nav=='P') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_PAN);
+		else if (nav=='S') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
+		else if (nav=='G') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_GAME);
+		else if (nav=='O') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_ORBIT);
+		else if (nav=='V') e = gf_sc_set_option(compositor, GF_OPT_NAVIGATION, GF_NAVIGATE_VR);
+		else fprintf(stderr, "Unknown selector %c - only \'N\',\'W\',\'F\',\'E\',\'P\',\'S\',\'G\', \'V\', \'O\' allowed\n", nav);
+	}
+	if (e) fprintf(stderr, "Error setting mode: %s\n", gf_error_to_string(e));
+}
+
+
+static void on_rti_log(void *cbk, GF_LOG_Level ll, GF_LOG_Tool lm, const char *fmt, va_list list)
+{
+	if (rti_logs && (lm & GF_LOG_RTI)) {
+		char szMsg2048;
+		vsnprintf(szMsg, 2048, fmt, list);
+		update_rti(szMsg + 6 /*"RTI "*/);
+	}
+}
+
+static void init_rti_logs(char *rti_file, Bool use_rtix)
+{
+	if (rti_logs) gf_fclose(rti_logs);
+	rti_logs = gf_fopen(rti_file, "wt");
+	if (rti_logs) {
+		fprintf(rti_logs, "!! GPAC RunTime Info ");
+		fprintf(rti_logs, " !!\n");
+		fprintf(rti_logs, "SysTime(ms)\tSceneTime(ms)\tCPU\tFPS\tMemory(kB)\tObservation\n");
+
+		/*turn on RTI loging*/
+		if (use_rtix) {
+			gf_log_set_callback(NULL, on_rti_log);
+			gf_log_set_tool_level(GF_LOG_RTI, GF_LOG_DEBUG);
+
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_RTI, ("RTI System state when enabling log\n"));
+		} else if (log_rti_time_start) {
+			log_rti_time_start = gf_sys_clock_high_res();
+		}
+	}
+}
+
+
+static char *rti_file=NULL;
+Bool use_rtix = GF_FALSE;
+char *send_command = NULL;
+u32 initial_service_id = 0;
+Bool auto_exit = GF_FALSE;
+Bool pause_at_first = GF_FALSE;
+Bool no_keyboard = GF_FALSE;
+Double play_from = 0;
+
+static Bool has_args=GF_FALSE;
+
+#ifdef DESKTOP_GUI
+Bool start_fs = GF_FALSE;
+#else
+Bool start_fs = GF_TRUE;
+#endif
+
+Bool mp4c_parse_arg(char *arg, char *arg_val)
+{
+	if (!strcmp(arg, "-rti")) {
+		rti_file = arg_val;
+	} else if (!strcmp(arg, "-rtix")) {
+		rti_file = arg_val;
+		use_rtix = GF_TRUE;
+	} else if (!strcmp(arg, "-rti-refresh")) {
+		rti_update_time_ms = arg_val ? get_s32(arg_val, "rti-refresh") : 0;
+	} else if (!strcmp(arg, "-cov")) {
+		do_coverage = GF_TRUE;
+	}
+#ifdef DESKTOP_GUI
+	else if (!stricmp(arg, "-size")) {
+		/*usage of %ud breaks sscanf on MSVC*/
+		if (arg_val && (sscanf(arg_val, "%dx%d", &forced_width, &forced_height) != 2)) {
+			forced_width = forced_height = 0;
+		}
+	}
+	else if (!strcmp(arg, "-fs")) start_fs = 1;
+#endif
+	else if (!strcmp(arg, "-nk")) no_keyboard = GF_TRUE;
+	/*arguments only used in non-gui mode*/
+	else if (compositor_mode==LOAD_MP4C) {
+		if (arg0 != '-') {
+		}
+		else if (!strcmp(arg, "-bm")) bench_mode = 1;
+		else if (!strcmp(arg, "-vbm")) bench_mode = 2;
+		else if (!strcmp(arg, "-sbm")) bench_mode = 3;
+		else if (!strcmp(arg, "-loop")) loop_at_end = GF_TRUE;
+		else if (!strcmp(arg, "-no-addon")) enable_add_ons = GF_FALSE;
+		else if (!strcmp(arg, "-pause")) pause_at_first = 1;
+		else if (!strcmp(arg, "-start")) {
+			play_from = arg_val ? atof(arg_val) : 0;
+		}
+		else if (!strcmp(arg, "-speed")) {
+			if (arg_val) playback_speed = FLT2FIX( atof(arg_val) );
+			if (playback_speed == 0) { playback_speed = FIX_ONE; pause_at_first = 1; }
+			else if (playback_speed < 0) playback_speed = FIX_ONE;
+		}
+		else if (!strcmp(arg, "-update")) {
+			update_str = arg_val;
+		}
+		else if (!strcmp(arg, "-update-type")) {
+			update_type = arg_val;
+		}
+#ifdef DESKTOP_GUI
+		else if (!strcmp(arg, "-no-wnd")) window_flags |= GF_VOUT_WINDOWLESS;
+		else if (!strcmp(arg, "-no-back")) window_flags |= GF_VOUT_WINDOW_NO_DECORATION;
+		else if (!strcmp(arg, "-align")) {
+			if (!arg_val) {}
+			else if (arg_val0=='m') align_mode = 1;
+			else if (arg_val0=='b') align_mode = 2;
+			align_mode <<= 8;
+			if (!arg_val) {}
+			else if (arg_val1=='m') align_mode |= 1;
+			else if (arg_val1=='r') align_mode |= 2;
+		}
+#endif
+		else if (!strcmp(arg, "-exit")) auto_exit = GF_TRUE;
+		else if (!stricmp(arg, "-com")) send_command = arg_val;
+		else if (!stricmp(arg, "-service")) initial_service_id = arg_val ? get_u32(arg_val, "service") : 0;
+		else {
+			return GF_FALSE;
+		}
+	} else {
+		return GF_FALSE;
+	}
+	has_args = GF_TRUE;
+	return GF_TRUE;
+}
+
+
+
+void load_compositor(GF_Filter *);
+
+void load_compositor(GF_Filter *filter)
+{
+	const char *str;
+
+	char szArgs20;
+	sprintf(szArgs, "%d", window_flags);
+	gf_opts_set_key("temp", "window-flags", szArgs);
+
+
+	comp_filter = filter;
+	compositor = gf_filter_get_udta(comp_filter);
+	if (start_fs) gf_sc_set_option(compositor, GF_OPT_FULLSCREEN, 1);
+	if (play_from || pause_at_first)
+		gf_sc_connect_from_time(compositor, NULL, (u64) (play_from*1000), pause_at_first, GF_FALSE, NULL);
+
+#if (defined(__DARWIN__) || defined(__APPLE__)) && !defined(GPAC_CONFIG_IOS)
+	/*the output window is init, inject carbon event watcher on open doc, only in GUI mode (when launched by Finder)
+	keep the hook active for the entire app so we can get send back "open with" commands to gpac
+	*/
+	if (compositor_mode==LOAD_GUI_ENV)
+		carbon_set_hook();
+#endif
+
+
+	if (compositor_mode!=LOAD_MP4C) return;
+
+	if (rti_file) init_rti_logs(rti_file, use_rtix);
+
+	GF_SystemRTInfo rti;
+	if (gf_sys_get_rti(0, &rti, 0) && (compositor_mode==LOAD_MP4C))
+		fprintf(stderr, "System info: %d MB RAM - %d cores\n", (u32) (rti.physical_memory/1024/1024), rti.nb_cores);
+
+	if (bench_mode) {
+		gf_opts_discard_changes();
+		auto_exit = GF_TRUE;
+		if (bench_mode!=2)
+			gf_opts_set_key("temp", "no-video", "yes");
+	}
+
+#ifdef DESKTOP_GUI
+	init_w = forced_width;
+	init_h = forced_height;
+
+	if (forced_width && forced_height) {
+/*		char dim50;
+		sprintf(dim, "%d", forced_width);
+		gf_opts_set_key("Temp", "DefaultWidth", dim);
+		sprintf(dim, "%d", forced_height);
+		gf_opts_set_key("Temp", "DefaultHeight", dim);
+*/
+	}
+#endif
+
+	if (gf_opts_get_bool("core", "proxy-on")) {
+		str = gf_opts_get_key("core", "proxy-name");
+		if (str) fprintf(stderr, "HTTP Proxy %s enabled\n", str);
+	}
+
+	if (rti_file) {
+		update_rti("At GPAC load time\n");
+	}
+
+	if (bench_mode) {
+		display_rti = 2;
+		gf_sc_set_option(compositor, GF_OPT_VIDEO_BENCH, (bench_mode==3) ? 2 : 1);
+		if (bench_mode==1) bench_mode=2;
+	}
+
+	if (bench_mode) {
+		rti_update_time_ms = 500;
+		bench_mode_start = gf_sys_clock();
+	}
+}
+
+
+#ifdef GPAC_ENABLE_COVERAGE
+static void mp4c_coverage()
+{
+	u32 k, nb_drawn;
+	GF_Event evt;
+	Bool is_bound;
+	const char *outName;
+
+	mp4c_handle_prompt('h');
+	mp4c_handle_prompt('t');
+	GF_List *descs = gf_list_new();
+	gf_sc_get_world_info(compositor, descs);
+	gf_list_del(descs);
+
+
+	gf_sc_dump_scene(compositor, NULL, NULL, GF_FALSE, 0);
+	gf_sc_get_current_service_id(compositor);
+	gf_sc_toggle_addons(compositor, GF_FALSE);
+	set_navigation();
+
+	get_gui_cmd('v');
+
+	memset(&evt, 0, sizeof(GF_Event));
+	evt.type = GF_EVENT_MOUSEUP;
+	evt.mouse.x = 20;
+	evt.mouse.y = 20;
+	gf_sc_user_event(compositor, &evt);
+
+	gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+	//exercise step clocks
+	gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+
+	gf_sc_get_url(compositor);
+	gf_sc_get_simulation_frame_rate(compositor, &nb_drawn);
+
+	gf_sc_has_text_selection(compositor);
+	gf_sc_get_selected_text(compositor);
+	gf_sc_paste_text(compositor, "test");
+
+	gf_sc_set_option(compositor, GF_OPT_AUDIO_MUTE, 1);
+
+	mp4c_take_screenshot(GF_TRUE);
+
+	gf_sc_scene_update(compositor, NULL, "REPLACE DYN_TRANS.translation BY 10 10");
+	gf_sc_add_object(compositor, NULL, GF_TRUE);
+
+	gf_sc_get_viewpoint(compositor, 1, &outName, &is_bound);
+	gf_sc_set_viewpoint(compositor, 1, "testvp");
+
+	for (k=GF_NAVIGATE_WALK; k<=GF_NAVIGATE_VR; k++) {
+		gf_sc_set_option(compositor, GF_OPT_NAVIGATION, k);
+		memset(&evt, 0, sizeof(GF_Event));
+		evt.type = GF_EVENT_MOUSEDOWN;
+		evt.mouse.x = 100;
+		evt.mouse.y = 100;
+		gf_sc_user_event(compositor, &evt);
+		evt.type = GF_EVENT_MOUSEMOVE;
+		evt.mouse.x += 10;
+		gf_sc_user_event(compositor, &evt);
+		evt.mouse.y += 10;
+		gf_sc_user_event(compositor, &evt);
+
+		evt.type = GF_EVENT_KEYDOWN;
+		evt.key.key_code = GF_KEY_CONTROL;
+		gf_sc_user_event(compositor, &evt);
+
+		evt.type = GF_EVENT_MOUSEMOVE;
+		evt.mouse.x = 120;
+		evt.mouse.y = 110;
+		gf_sc_user_event(compositor, &evt);
+
+		evt.type = GF_EVENT_KEYUP;
+		evt.key.key_code = GF_KEY_CONTROL;
+		gf_sc_user_event(compositor, &evt);
+
+		evt.type = GF_EVENT_KEYDOWN;
+		evt.key.key_code = GF_KEY_J;
+		gf_sc_user_event(compositor, &evt);
+	}
+	gf_sc_set_option(compositor, GF_OPT_NAVIGATION_TYPE, 0);
+
+	gf_sc_connect_from_time(compositor, "logo.jpg", 0, 0, GF_FALSE, "./media/auxiliary_files/");
+	gf_sc_navigate_to(compositor, "./media/auxiliary_files/logo.jpg");
+	gpac_open_urls("./media/auxiliary_files/logo.jpg");
+	switch_bench(1);
+	do_set_speed(1.0);
+}
+#endif
+
+#if defined(WIN32) && !defined(_WIN32_WCE)
+static void close_console();
+#endif
+
+void unload_compositor()
+{
+	if (rti_file) update_rti("Disconnected\n");
+
+	if (rti_logs) gf_fclose(rti_logs);
+
+#ifdef GPAC_ENABLE_COVERAGE
+	if (do_coverage) {
+		mp4c_coverage();
+	}
+#endif
+
+#if defined(WIN32) && !defined(_WIN32_WCE)
+	close_console();
+#endif
+
+
+#ifdef DESKTOP_GUI
+	if (caption) gf_free(caption);
+	caption = NULL;
+#endif
+
+	comp_filter = NULL;
+	compositor = NULL;
+#if (defined(__DARWIN__) || defined(__APPLE__)) && !defined(GPAC_CONFIG_IOS)
+	if (compositor_mode==LOAD_GUI_ENV)
+		carbon_remove_hook();
+#endif
+
+
+#ifdef GPAC_CONFIG_IOS
+	if (gyro_dev) {
+		sensor_stop(gyro_dev);
+	}
+#endif
+
+}
+
+Bool mp4c_task()
+{
+	if (eos_seen && gf_sc_get_option(compositor, GF_OPT_IS_OVER)) {
+		if (!auto_exit) return GF_FALSE;
+		if (!loop_at_end) {
+			gf_sc_disconnect(compositor);
+			return GF_TRUE;
+		}
+		eos_seen = GF_FALSE;
+		gf_sc_play_from_time(compositor, 0, 0);
+		return GF_FALSE;
+	}
+
+	if (reload) {
+		char *url = (char *) gf_sc_get_url(compositor);
+		if (url) {
+			url = gf_strdup(url);
+			gf_sc_disconnect(compositor);
+			gf_sc_connect_from_time(compositor, url, 0, 0, GF_FALSE, NULL);
+			gf_free(url);
+		}
+		reload = 0;
+	}
+
+	if (send_command && is_connected) {
+		gf_sc_scene_update(compositor, NULL, send_command);
+		send_command = NULL;
+	}
+	if (initial_service_id && is_connected) {
+		gf_sc_select_service(compositor, initial_service_id);
+		initial_service_id = 0;
+	}
+
+	if (!use_rtix || display_rti)
+		update_rti(NULL);
+
+	return GF_FALSE;
+}
+
+Bool mp4c_handle_prompt(u8 char_val)
+{
+	MP4C_Command cmdtype = get_gui_cmd(char_val);
+	switch (cmdtype) {
+	case MP4C_OPEN:
+	{
+		char szURL2000;
+		gf_sc_disconnect(compositor);
+		fprintf(stderr, "Enter the absolute URL\n");
+		if (1 > scanf("%1999s", szURL)) {
+			fprintf(stderr, "Cannot read absolute URL, aborting\n");
+			break;
+		}
+		if (rti_file) init_rti_logs(rti_file, use_rtix);
+		gf_sc_connect_from_time(compositor, szURL, 0, 0, 0, NULL);
+	}
+		break;
+	case MP4C_RELOAD:
+		if (is_connected)
+			reload = 1;
+		break;
+
+	case MP4C_DISCONNECT:
+		if (is_connected) gf_sc_disconnect(compositor);
+		break;
+
+	case MP4C_PAUSE_RESUME:
+		if (is_connected) {
+			Bool is_pause = gf_sc_get_option(compositor, GF_OPT_PLAY_STATE);
+			fprintf(stderr, "Status: %s\n", is_pause ? "Playing" : "Paused");
+			gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, is_pause ? GF_STATE_PLAYING : GF_STATE_PAUSED);
+		}
+		break;
+	case MP4C_STEP:
+		if (is_connected) {
+			gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+			fprintf(stderr, "Step time: ");
+			print_time(gf_sc_get_time_in_ms(compositor));
+			fprintf(stderr, "\n");
+		}
+		break;
+
+	case MP4C_SEEK:
+	case MP4C_SEEK_TIME:
+		if (!can_seek || (duration_ms<=2000)) {
+			fprintf(stderr, "scene not seekable\n");
+		} else {
+			Double res;
+			s32 seekTo;
+			fprintf(stderr, "Duration: ");
+			print_time(duration_ms);
+			res = gf_sc_get_time_in_ms(compositor);
+			if (cmdtype==MP4C_SEEK) {
+				res *= 100;
+				res /= (s64)duration_ms;
+				fprintf(stderr, " (current %.2f %%)\nEnter Seek percentage:\n", res);
+				if (scanf("%d", &seekTo) == 1) {
+					if (seekTo > 100) seekTo = 100;
+					res = (Double)(s64)duration_ms;
+					res /= 100;
+					res *= seekTo;
+					gf_sc_play_from_time(compositor, (u64) (s64) res, 0);
+				}
+			} else {
+				u32 r, h, m, s;
+				fprintf(stderr, " - Current Time: ");
+				print_time((u64) res);
+				fprintf(stderr, "\nEnter seek time (Format: s, m:s or h:m:s):\n");
+				h = m = s = 0;
+				r =scanf("%d:%d:%d", &h, &m, &s);
+				if (r==2) {
+					s = m;
+					m = h;
+					h = 0;
+				}
+				else if (r==1) {
+					s = h;
+					m = h = 0;
+				}
+
+				if (r && (r<=3)) {
+					u64 time = h*3600 + m*60 + s;
+					gf_sc_play_from_time(compositor, time*1000, 0);
+				}
+			}
+		}
+		break;
+
+	case MP4C_TIME:
+	{
+		if (is_connected) {
+			fprintf(stderr, "Current Time: ");
+			print_time(gf_sc_get_time_in_ms(compositor));
+			fprintf(stderr, " - Duration: ");
+			print_time(duration_ms);
+			fprintf(stderr, "\n");
+		}
+	}
+	break;
+	case MP4C_NAVMODE:
+		if (is_connected) set_navigation();
+		break;
+	case MP4C_LASTVP:
+		if (is_connected) gf_sc_set_option(compositor, GF_OPT_NAVIGATION_TYPE, 0);
+		break;
+
+	case MP4C_DUMPSCENE:
+		if (is_connected) {
+			char radnameGF_MAX_PATH, *sExt;
+			Bool xml_dump, std_out;
+			radname0 = 0;
+			do {
+				fprintf(stderr, "Enter file radical name (+\'.x\' for XML dumping) - \"std\" for stderr: ");
+				fflush(stderr);
+			} while( 1 > scanf("%1023s", radname));
+			sExt = strrchr(radname, '.');
+			xml_dump = 0;
+			if (sExt) {
+				if (!stricmp(sExt, ".x")) xml_dump = 1;
+				sExt0 = 0;
+			}
+			std_out = strnicmp(radname, "std", 3) ? 0 : 1;
+			GF_Err e = gf_sc_dump_scene(compositor, std_out ? NULL : radname, NULL, xml_dump, 0);
+			if (e<0)
+				fprintf(stderr, "Dump failed: %s\n", gf_error_to_string(e));
+			else
+				fprintf(stderr, "Dump done\n");
+		}
+		break;
+
+	case MP4C_OGL2D:
+	{
+		Bool use_3d = !gf_sc_get_option(compositor, GF_OPT_USE_OPENGL);
+		if (gf_sc_set_option(compositor, GF_OPT_USE_OPENGL, use_3d)==GF_OK) {
+			fprintf(stderr, "Using %s for 2D drawing\n", use_3d ? "OpenGL" : "2D rasterizer");
+		}
+	}
+	break;
+	case MP4C_STRESSMODE:
+	{
+		Bool opt = gf_sc_get_option(compositor, GF_OPT_STRESS_MODE);
+		opt = !opt;
+		fprintf(stderr, "Turning stress mode %s\n", opt ? "on" : "off");
+		gf_sc_set_option(compositor, GF_OPT_STRESS_MODE, opt);
+	}
+	break;
+	case MP4C_AR_4_3:
+		gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
+		break;
+	case MP4C_AR_16_9:
+		gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
+		break;
+	case MP4C_AR_NONE:
+		gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
+		break;
+	case MP4C_AR_ORIG:
+		gf_sc_set_option(compositor, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
+		break;
+
+	case MP4C_DISP_RTI:
+		display_rti = !display_rti;
+		set_window_caption();
+		break;
+	case MP4C_DISP_FPS:
+		if (display_rti) display_rti = 0;
+		else display_rti = 2;
+		set_window_caption();
+		break;
+	case MP4C_UPDATE:
+	{
+		char szCom8192;
+		fprintf(stderr, "Enter command to send:\n");
+		szCom0 = 0;
+		if (1 > scanf("%8191^\t\n", szCom)) {
+			fprintf(stderr, "Cannot read command to send, aborting.\n");
+			break;
+		}
+		GF_Err e = gf_sc_scene_update(compositor, NULL, szCom);
+		if (e) fprintf(stderr, "Processing command failed: %s\n", gf_error_to_string(e));
+	}
+	break;
+	case MP4C_EVALJS:
+	{
+		char jsCode8192;
+		fprintf(stderr, "Enter JavaScript code to evaluate:\n");
+		jsCode0 = 0;
+		if (1 > scanf("%8191^\t\n", jsCode)) {
+			fprintf(stderr, "Cannot read code to evaluate, aborting.\n");
+			break;
+		}
+		GF_Err e = gf_sc_scene_update(compositor, "application/ecmascript", jsCode);
+		if (e) fprintf(stderr, "Processing JS code failed: %s\n", gf_error_to_string(e));
+	}
+	break;
+
+	case MP4C_LOGS:
+	{
+		char szLog1024, *cur_logs;
+		cur_logs = gf_log_get_tools_levels();
+		fprintf(stderr, "Enter new log level (current tools %s):\n", cur_logs);
+		gf_free(cur_logs);
+		if (scanf("%1023s", szLog) < 1) {
+			fprintf(stderr, "Cannot read new log level, aborting.\n");
+			break;
+		}
+		gf_log_modify_tools_levels(szLog);
+	}
+	break;
+
+	case MP4C_VMEM_CACHE:
+	{
+		u32 size;
+		do {
+			fprintf(stderr, "Enter new video cache memory in kBytes (current %ud):\n", gf_sc_get_option(compositor, GF_OPT_VIDEO_CACHE_SIZE));
+		} while (1 > scanf("%ud", &size));
+		gf_sc_set_option(compositor, GF_OPT_VIDEO_CACHE_SIZE, size);
+	}
+	break;
+
+	case MP4C_DOWNRATE:
+	{
+		u32 http_bitrate = gf_sc_get_option(compositor, GF_OPT_HTTP_MAX_RATE);
+		do {
+			fprintf(stderr, "Enter new http bitrate in bps (0 for none) - current limit: %d\n", http_bitrate);
+		} while (1 > scanf("%ud", &http_bitrate));
+
+		gf_sc_set_option(compositor, GF_OPT_HTTP_MAX_RATE, http_bitrate);
+	}
+	break;
+
+	case MP4C_RELOAD_OPTS:
+		gf_sc_set_option(compositor, GF_OPT_RELOAD_CONFIG, 1);
+		break;
+
+#ifdef DESKTOP_GUI
+	/*extract to PNG*/
+	case MP4C_SCREENSHOT:
+		mp4c_take_screenshot(GF_FALSE);
+		break;
+#endif
+
+	case MP4C_HELP:
+		mp4c_print_help();
+		break;
+	default:
+		return GF_FALSE;
+	}
+	return GF_TRUE;
+}
+
+
+#ifdef DESKTOP_GUI
+static void mp4c_take_screenshot(Bool for_coverage)
+{
+	char szFileName100;
+	u32 nb_pass, nb_views, offscreen_view = 0;
+	GF_VideoSurface fb;
+	GF_Err e;
+	nb_pass = 1;
+	nb_views = gf_sc_get_option(compositor, GF_OPT_NUM_STEREO_VIEWS);
+	if (nb_views>1) {
+		fprintf(stderr, "Auto-stereo mode detected - type number of view to dump (0 is main output, 1 to %d offscreen view, %d for all offscreen, %d for all offscreen and main)\n", nb_views, nb_views+1, nb_views+2);
+		if (!for_coverage) {
+			if (scanf("%d", &offscreen_view) != 1) {
+				offscreen_view = 0;
+			}
+		}
+		if (offscreen_view==nb_views+1) {
+			offscreen_view = 1;
+			nb_pass = nb_views;
+		}
+		else if (offscreen_view==nb_views+2) {
+			offscreen_view = 0;
+			nb_pass = nb_views+1;
+		}
+	}
+	if (for_coverage && !offscreen_view) {
+		if (gf_sc_get_offscreen_buffer(compositor, &fb, 0, 0)==GF_OK)
+			gf_sc_release_screen_buffer(compositor, &fb);
+	}
+	while (nb_pass) {
+		nb_pass--;
+		if (offscreen_view) {
+			sprintf(szFileName, "view%d_dump.png", offscreen_view);
+			e = gf_sc_get_offscreen_buffer(compositor, &fb, offscreen_view-1, 0);
+		} else {
+			sprintf(szFileName, "gpac_video_dump_"LLU".png", gf_net_get_utc() );
+			e = gf_sc_get_screen_buffer(compositor, &fb, 0);
+		}
+		offscreen_view++;
+		if (e) {
+			fprintf(stderr, "Error dumping screen buffer %s\n", gf_error_to_string(e) );
+			nb_pass = 0;
+		} else {
+#ifndef GPAC_DISABLE_AV_PARSERS
+			u32 dst_size = fb.width*fb.height*4;
+			u8 *dst = (u8*)gf_malloc(sizeof(u8)*dst_size);
+
+			e = gf_img_png_enc(fb.video_buffer, fb.width, fb.height, fb.pitch_y, fb.pixel_format, dst, &dst_size);
+			if (e) {
+				fprintf(stderr, "Error encoding PNG %s\n", gf_error_to_string(e) );
+				nb_pass = 0;
+			} else {
+				FILE *png = gf_fopen(szFileName, "wb");
+				if (!png) {
+					fprintf(stderr, "Error writing file %s\n", szFileName);
+					nb_pass = 0;
+				} else {
+					if (gf_fwrite(dst, dst_size, png) != dst_size) {
+						fprintf(stderr, "Error dumping screen buffer %s\n", gf_error_to_string(GF_IO_ERR) );
+					}
+					gf_fclose(png);
+					fprintf(stderr, "Dump to %s\n", szFileName);
+				}
+			}
+			if (dst) gf_free(dst);
+			gf_sc_release_screen_buffer(compositor, &fb);
+
+			if (for_coverage) gf_file_delete(szFileName);
+#endif //GPAC_DISABLE_AV_PARSERS
+		}
+	}
+	fprintf(stderr, "Done: %s\n", szFileName);
+}
+#endif
+
+
+#if defined(WIN32) && !defined(_WIN32_WCE)
+
+#include <tlhelp32.h>
+#include <psapi.h>
+
+static DWORD getParentPID(DWORD pid)
+{
+	DWORD ppid = 0;
+	HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+	if (h) {
+		PROCESSENTRY32 pe = { 0 };
+		pe.dwSize = sizeof(PROCESSENTRY32);
+		if (Process32First(h, &pe)) {
+			do {
+				if (pe.th32ProcessID == pid) {
+					ppid = pe.th32ParentProcessID;
+					break;
+				}
+			} while (Process32Next(h, &pe));
+		}
+		CloseHandle(h);
+	}
+	return (ppid);
+}
+
+static void getProcessName(DWORD pid, PUCHAR fname, DWORD sz)
+{
+	HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
+	if (h) {
+		GetModuleFileNameEx(h, NULL, fname, sz);
+		CloseHandle(h);
+	}
+}
+
+static Bool owns_wnd = GF_FALSE;
+HWND console_hwnd = NULL;
+Bool gpac_is_global_launch()
+{
+	typedef HWND(WINAPI *GetConsoleWindowT)(void);
+	HMODULE hk32 = GetModuleHandle("kernel32.dll");
+	char parentNameGF_MAX_PATH;
+	DWORD dwProcessId = 0;
+	DWORD dwParentProcessId = 0;
+	GetConsoleWindowT GetConsoleWindow = (GetConsoleWindowT)GetProcAddress(hk32, "GetConsoleWindow");
+	console_hwnd = GetConsoleWindow();
+	dwProcessId = GetCurrentProcessId();
+	dwParentProcessId = getParentPID(dwProcessId);
+	//get parent process name, check for explorer
+	parentName0 = 0;
+#ifndef GPAC_BUILD_FOR_WINXP
+	getProcessName(dwParentProcessId, parentName, GF_MAX_PATH);
+	if (strstr(parentName, "explorer")) {
+		owns_wnd = GF_TRUE;
+	}
+#if 0
+	DWORD dwParentParentProcessId = 0;
+	if (dwParentProcessId)
+		dwParentParentProcessId = getParentPID(dwParentProcessId);
+	//get parent parent process name, check for devenv (or any other ide name ...)
+	else if (dwParentParentProcessId) {
+		owns_wnd = GF_FALSE;
+		parentName0 = 0;
+		getProcessName(dwParentParentProcessId, parentName, GF_MAX_PATH);
+		if (strstr(parentName, "devenv")) {
+			owns_wnd = GF_TRUE;
+		}
+	}
+#endif
+	else {
+		owns_wnd = GF_FALSE;
+	}
+	if (!owns_wnd) return GF_FALSE;
+#endif //GPAC_BUILD_FOR_WINXP
+	ShowWindow(console_hwnd, SW_HIDE);
+	return GF_TRUE;
+}
+static void close_console()
+{
+	if (owns_wnd && console_hwnd)
+		PostMessage(console_hwnd, WM_CLOSE, 0, 0);
+}
+
+#endif
+
+#endif //#ifndef GPAC_DISABLE_PLAYER

gpac-2.2.0.tar.gz/applications/gpac/gpac.c Added

@@ -0,0 +1,2935 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2017-2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / gpac application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <gpac/main.h>
+#include <gpac/filters.h>
+#include <gpac/thread.h>
+#include "gpac.h"
+
+/*
+	exported for gpac_help.c
+*/
+GF_FilterSession *session=NULL;
+u32 list_filters = 0;
+u32 print_filter_info = 0;
+int alias_argc = 0;
+char **alias_argv = NULL;
+GF_List *args_used = NULL;
+GF_List *args_alloc = NULL;
+u32 gen_doc = 0;
+u32 help_flags = 0;
+FILE *sidebar_md=NULL;
+FILE *helpout = NULL;
+const char *auto_gen_md_warning = "\n";
+
+#ifndef GPAC_CONFIG_ANDROID
+u32 compositor_mode = 0;
+#endif
+
+//the default set of separators
+char separator_set7 = GF_FS_DEFAULT_SEPS;
+
+/*
+	exported by gpac_help.c
+*/
+#ifndef GPAC_DISABLE_DOC
+extern const char *gpac_doc;
+#endif
+
+/*
+	static vars
+*/
+static GF_SystemRTInfo rti;
+static Bool dump_stats = GF_FALSE;
+static Bool dump_graph = GF_FALSE;
+static Bool print_meta_filters = GF_FALSE;
+static Bool load_test_filters = GF_FALSE;
+static s32 nb_loops = 0;
+static s32 runfor = 0;
+static Bool runfor_exit = GF_FALSE;
+static Bool runfor_fast = GF_FALSE;
+static u32 exit_mode = 0;
+static Bool enable_prompt = GF_FALSE;
+static u32 enable_reports = 0;
+static char *report_filter = NULL;
+static Bool do_unit_tests = GF_FALSE;
+static Bool use_step_mode = GF_FALSE;
+static u32 loops_done = 0;
+static GF_Err evt_ret_val = GF_OK;
+static Bool in_sig_handler = GF_FALSE;
+static Bool custom_event_proc=GF_FALSE;
+static u64 run_start_time = 0;
+
+#ifdef GPAC_CONFIG_ANDROID
+static void reset_static_vars()
+{
+	list_filters = print_filter_info = gen_doc = help_flags = 0;
+	strcpy(separator_set, GF_FS_DEFAULT_SEPS);
+
+	//bools
+	dump_stats = dump_graph = print_meta_filters = load_test_filters = GF_FALSE;
+	runfor_exit = runfor_fast = enable_prompt = use_step_mode = in_sig_handler = custom_event_proc = GF_FALSE;
+	//s32
+	nb_loops = runfor = 0;
+	//u32
+	exit_mode = enable_reports = loops_done = 0;
+	//u64
+	run_start_time = 0;
+	report_filter = NULL;
+	evt_ret_val = GF_OK;
+}
+#endif
+
+
+//forward defs - c.f. end of file
+static void gpac_print_report(GF_FilterSession *fsess, Bool is_init, Bool is_final);
+static void cleanup_logs(void);
+static Bool gpac_handle_prompt(GF_FilterSession *fsess, char char_code);
+static void gpac_fsess_task_help(void);
+static const char *make_fileio(const char *inargs, const char **out_arg, Bool is_input, GF_Err *e);
+static void cleanup_file_io(void);
+static GF_Filter *load_custom_filter(GF_FilterSession *sess, char *opts, GF_Err *e);
+static u32 gpac_unit_tests(GF_MemTrackerType mem_track);
+static Bool revert_cache_file(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info);
+#ifdef WIN32
+#include <windows.h>
+static BOOL WINAPI gpac_sig_handler(DWORD sig);
+#else
+#include <signal.h>
+static void gpac_sig_handler(int sig);
+#endif
+static int gpac_do_creds(char *creds_args);
+
+static Bool gpac_event_proc(void *opaque, GF_Event *event)
+{
+	GF_FilterSession *fsess = (GF_FilterSession *)opaque;
+	if ((event->type==GF_EVENT_PROGRESS) && (event->progress.progress_type==3)) {
+		gpac_print_report(fsess, GF_FALSE, GF_FALSE);
+	}
+	else if (event->type==GF_EVENT_QUIT) {
+		if (event->message.error>0)
+			evt_ret_val = event->message.error;
+		gf_fs_abort(fsess, GF_FS_FLUSH_ALL);
+	}
+#if !defined(GPAC_CONFIG_ANDROID) && !defined(GPAC_DISABLE_PLAYER)
+	else if (custom_event_proc) {
+		return mp4c_event_proc(opaque, event);
+	}
+#endif
+	return GF_FALSE;
+}
+
+
+static Bool gpac_fsess_task(GF_FilterSession *fsess, void *callback, u32 *reschedule_ms)
+{
+	if (enable_prompt && gf_prompt_has_input()) {
+#if !defined(GPAC_CONFIG_ANDROID) && !defined(GPAC_DISABLE_PLAYER)
+		if ((compositor_mode==LOAD_MP4C) && mp4c_handle_prompt(gf_prompt_get_char())) {
+
+		} else
+#endif
+		if (!gpac_handle_prompt(fsess, gf_prompt_get_char()))
+			return GF_FALSE;
+	}
+
+#if !defined(GPAC_CONFIG_ANDROID) && !defined(GPAC_DISABLE_PLAYER)
+	if ((compositor_mode==LOAD_MP4C) && mp4c_task()) {
+		gf_fs_abort(fsess, GF_FS_FLUSH_NONE);
+	}
+#endif
+
+	if (runfor>0) {
+		u64 now = gf_sys_clock_high_res();
+		if (!run_start_time) {
+			run_start_time = now;
+		} else if (now - run_start_time > runfor) {
+			//segfault requested
+			if (exit_mode==1) {
+				exit(127);
+			}
+			//deadlock requested
+			else if (exit_mode==2) {
+				while(1) {
+					gf_sleep(1);
+				}
+			}
+			if (nb_loops || loops_done) {
+				gf_fs_abort(fsess, runfor_exit ? GF_FS_FLUSH_NONE : (runfor_fast ? GF_FS_FLUSH_FAST : GF_FS_FLUSH_ALL));
+				run_start_time = 0;
+			} else {
+				if (runfor_exit)
+					exit(0);
+				gf_fs_abort(fsess, runfor_fast ? GF_FS_FLUSH_FAST : GF_FS_FLUSH_ALL);
+			}
+			return GF_FALSE;
+		}
+	}
+
+	if (gf_fs_is_last_task(fsess))
+		return GF_FALSE;
+	//check every 50 ms
+	*reschedule_ms = 50;
+	return GF_TRUE;
+}
+
+static int gpac_exit_fun(int code)
+{
+	u32 i;
+	if (code>=0) {
+		for (i=1; i<gf_sys_get_argc(); i++) {
+			if (!gf_sys_is_arg_used(i)) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Warning: argument %s set but not used\n", gf_sys_get_arg(i) ));
+			}
+		}
+	} else {
+		//negative code is unrecognized option, don't print unused arguments
+		code = 1;
+	}
+
+	if (alias_argv) {
+		while (gf_list_count(args_alloc)) {
+			gf_free(gf_list_pop_back(args_alloc));
+		}
+		gf_list_del(args_alloc);
+		args_alloc = NULL;
+		gf_list_del(args_used);
+		args_used = NULL;
+		gf_free(alias_argv);
+		alias_argv = NULL;
+		alias_argc = 0;
+	}
+	if ((helpout != stdout) && (helpout != stderr)) {
+		if (gen_doc==2) {
+			fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/Filters\n");
+			fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
+			".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
+			".br\nbuild: %s\n"
+			".br\nCopyright: %s\n.br\n"
+			".SH SEE ALSO\n"
+			".LP\ngpac(1), MP4Box(1)\n", gf_gpac_version(), gf_gpac_copyright());
+		}
+		gf_fclose(helpout);
+	}
+
+	if (sidebar_md) {
+		gf_fclose(sidebar_md);
+		sidebar_md = NULL;
+	}
+
+	cleanup_logs();
+
+	gf_sys_close();
+
+#ifdef GPAC_CONFIG_ANDROID
+	reset_static_vars();
+#endif
+
+	if (code) return code;
+
+#ifdef GPAC_MEMORY_TRACKING
+	if (gf_memory_size() || gf_file_handles_count() ) {
+		gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
+		gf_memory_print();
+		return 2;
+	}
+#endif
+	return 0;
+}
+
+u32 get_u32(char *val, char *log_name)
+{
+	u32 res;
+	if (sscanf(val, "%u", &res)==1) return res;
+	GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("%s must be an unsigned integer (got %s), using 0\n", log_name, val));
+	return 0;
+}
+s32 get_s32(char *val, char *log_name)
+{
+	s32 res;
+	if (sscanf(val, "%d", &res)==1) return res;
+	GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("%s must be a signed integer (got %s), using 0\n", log_name, val));
+	return 0;
+}
+
+
+#define gpac_exit(_code) \
+	return gpac_exit_fun(_code)
+
+
+#if defined(GPAC_CONFIG_DARWIN) && !defined(GPAC_CONFIG_IOS)
+#include <syslog.h>
+
+static void gpac_syslog(void *cbck, GF_LOG_Level log_level, GF_LOG_Tool log_tool, const char* fmt, va_list vlist)
+{
+	int prio;
+	char szMsg4000;
+	vsprintf(szMsg, fmt, vlist);
+	if (log_level==GF_LOG_DEBUG) prio = LOG_DEBUG;
+	else if (log_level==GF_LOG_INFO) prio = LOG_INFO;
+	else if (log_level==GF_LOG_WARNING) prio = LOG_WARNING;
+	else prio = LOG_ERR;
+	syslog(prio, "%s", szMsg);
+}
+#endif
+
+#ifndef GPAC_CONFIG_ANDROID
+static
+#endif
+int gpac_main(int argc, char **argv)
+{
+	GF_Err e=GF_OK;
+	int i;
+	const char *profile=NULL;
+	const char *session_js=NULL;
+	u32 sflags=0;
+	Bool override_seps=GF_FALSE;
+	Bool write_profile=GF_FALSE;
+	Bool write_core_opts=GF_FALSE;
+	Bool write_extensions=GF_FALSE;
+	GF_List *links_directive=NULL;
+	GF_List *loaded_filters=NULL;
+	GF_SysArgMode argmode = GF_ARGMODE_BASE;
+	u32 nb_filters = 0;
+	Bool nothing_to_do = GF_TRUE;
+	GF_MemTrackerType mem_track=GF_MemTrackerNone;
+	char *view_conn_for_filter = NULL;
+	Bool view_filter_conn = GF_FALSE;
+	Bool dump_codecs = GF_FALSE;
+	Bool dump_formats = GF_FALSE;
+	Bool dump_proto_schemes = GF_FALSE;
+	Bool has_alias = GF_FALSE;
+	Bool alias_set = GF_FALSE;
+	GF_FilterSession *tmp_sess;
+	Bool alias_is_play = GF_FALSE;
+	Bool prev_filter_is_sink;
+	Bool prev_filter_is_not_source;
+	u32 current_subsession_id;
+	u32 current_source_id;
+	Bool do_creds = GF_FALSE;
+	char *creds_args=NULL;
+	Bool has_xopt = GF_FALSE;
+
+	helpout = stdout;
+	
+#ifdef WIN32
+	Bool gpac_is_global_launch();
+	char *argv_w2;
+	if ((argc == 1) && gpac_is_global_launch()) {
+		argc = 2;
+		argv_w0 = argv0;
+		argv_w1 = "-gui";
+		argv = argv_w;
+	}
+#endif
+
+	//look for mem track and profile, and check for link directives
+	for (i=1; i<argc; i++) {
+		char *arg = argvi;
+		if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
+#ifdef GPAC_MEMORY_TRACKING
+ mem_track = !strcmp(arg, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
+#else
+			fprintf(stderr, "WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", arg);
+#endif
+		} else if (!strncmp(arg, "-p=", 3)) {
+			profile = arg+3;
+		} else if (!strncmp(arg, "-creds", 6)) {
+			do_creds = GF_TRUE;
+			if (!strncmp(arg, "-creds=", 7)) creds_args = arg+7;
+		} else if (!strncmp(arg, "-mkl=", 5)) {
+			return gpac_make_lang(arg+5);
+		}
+	}
+
+	gf_sys_init(mem_track, profile);
+
+
+#ifdef GPAC_CONFIG_ANDROID
+	//prevent destruction of JSRT until we unload the JNI gpac wrapper (see applications/gpac_android/src/main/jni/gpac_jni.cpp)
+	gf_opts_set_key("temp", "static-jsrt", "true");
+#endif
+
+	if (do_creds) {
+		return gpac_do_creds(creds_args);
+	}
+
+//	gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_WARNING);
+	gf_log_set_tool_level(GF_LOG_APP, GF_LOG_INFO);
+
+	if (gf_opts_get_key_count("gpac.alias")) {
+		for (i=1; i<argc; i++) {
+			char *arg = argvi;
+			if (gf_opts_get_key("gpac.alias", arg) != NULL) {
+				has_alias = GF_TRUE;
+				if (!strcmp(arg, "-play"))
+					alias_is_play = GF_TRUE;
+				break;
+			}
+		}
+		if (has_alias) {
+			if (! gpac_expand_alias(argc, argv) ) {
+				gpac_exit(1);
+			}
+			argc = alias_argc;
+			argv = alias_argv;
+		}
+	}
+
+#ifndef GPAC_CONFIG_ANDROID
+	if (compositor_mode) {
+		//we by default want 2 additional threads in gui:
+		//main thread might get locked on vsync
+		//second thread might be busy decoding audio/video
+		//third thread will then be able to refill all buffers/perform networks tasks
+		gf_opts_set_key("temp", "threads", "2");
+		//the number of threads will be overridden if set at command line
+
+		if (compositor_mode==LOAD_MP4C)
+			enable_prompt = GF_TRUE;
+	}
+#endif
+
+
+	//this will parse default args
+	e = gf_sys_set_args(argc, (const char **) argv);
+	if (e) {
+		fprintf(stderr, "Error assigning libgpac arguments: %s\n", gf_error_to_string(e) );
+		gpac_exit(1);
+	}
+
+	if (!profile || strcmp(profile, "0") )
+		gpac_load_suggested_filter_args();
+
+#ifndef GPAC_DISABLE_LOG
+	if (gf_log_tool_level_on(GF_LOG_APP, GF_LOG_DEBUG)) {
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_APP, ("GPAC args: "));
+		for (i=1; i<argc; i++) {
+			char *arg = argvi;
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_APP, ("%s ", arg));
+		}
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_APP, ("\n"));
+	}
+#endif
+
+	for (i=1; i<argc; i++) {
+		char szArgName1024;
+		char *arg = argvi;
+		char *arg_val = strchr(arg, '=');
+		if (arg_val) {
+			u32 len = (u32) (arg_val - arg);
+			if (len>1023) len=1023;
+			strncpy(szArgName, arg, len);
+			szArgNamelen=0;
+			arg = szArgName;
+			arg_val++;
+		}
+
+		gf_sys_mark_arg_used(i, GF_TRUE);
+
+		if ((!has_xopt && !strcmp(arg, "-h")) || !strcmp(arg, "-help") || !strcmp(arg, "-ha") || !strcmp(arg, "-hx") || !strcmp(arg, "-hh")) {
+			if (!strcmp(arg, "-ha")) argmode = GF_ARGMODE_ADVANCED;
+			else if (!strcmp(arg, "-hx")) argmode = GF_ARGMODE_EXPERT;
+			else if (!strcmp(arg, "-hh")) argmode = GF_ARGMODE_ALL;
+
+			gf_opts_set_key("temp", "gpac-help", arg+1);
+
+			if (i+1<argc)
+				gf_sys_mark_arg_used(i+1, GF_TRUE);
+			if ((i+1==argc) || (argvi+10=='-')) {
+				gpac_usage(argmode);
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "log")) {
+				gpac_core_help(GF_ARGMODE_ALL, GF_TRUE);
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "core")) {
+				gpac_core_help(argmode, GF_FALSE);
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "modules")) {
+				gpac_modules_help();
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "doc")) {
+				gpac_filter_help();
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "alias")) {
+				gpac_alias_help(argmode);
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "props")) {
+				if (i+2<argc) {
+					gf_sys_mark_arg_used(i+2, GF_TRUE);
+					dump_all_props(argvi+2);
+				} else {
+					dump_all_props(NULL);
+				}
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "colors")) {
+				dump_all_colors();
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "layouts")) {
+				dump_all_audio_cicp();
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "cfg")) {
+				gpac_config_help();
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "prompt")) {
+				gpac_fsess_task_help();
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "mp4c")) {
+#if defined(GPAC_CONFIG_ANDROID) || defined(GPAC_DISABLE_PLAYER)
+				gf_sys_format_help(helpout, help_flags, "-mp4c unavailable for android\n");
+#else
+				mp4c_help(argmode);
+#endif
+				gpac_exit(0);
+
+			}
+			//old syntax -gui -h us still valid, but also allow -h gui to be consistent with other help options
+			else if (!strcmp(argvi+1, "gui")) {
+				gf_opts_set_key("temp", "gpac-help", "yes");
+				session = gf_fs_new_defaults(0);
+				gf_set_progress_callback(session, NULL);
+				gf_fs_load_filter(session, "compositor:player=gui", NULL);
+				gf_fs_run(session);
+				gf_fs_del(session);
+				session = NULL;
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "codecs")) {
+				dump_codecs = GF_TRUE;
+				sflags |= GF_FS_FLAG_LOAD_META | GF_FS_FLAG_NO_GRAPH_CACHE;
+				i++;
+			} else if (!strcmp(argvi+1, "formats") || !strcmp(argvi+1, "exts")) {
+				dump_formats = GF_TRUE;
+				sflags |= GF_FS_FLAG_LOAD_META | GF_FS_FLAG_NO_GRAPH_CACHE;
+				i++;
+			} else if (!strcmp(argvi+1, "protocols")) {
+				dump_proto_schemes = GF_TRUE;
+				sflags |= GF_FS_FLAG_LOAD_META | GF_FS_FLAG_NO_GRAPH_CACHE;
+				i++;
+			} else if (!strcmp(argvi+1, "links")) {
+				view_filter_conn = GF_TRUE;
+				if ((i+2<argc)	&& (argvi+20 != '-')) {
+					view_conn_for_filter = argvi+2;
+					gf_sys_mark_arg_used(i+2, GF_TRUE);
+					i++;
+				}
+
+				i++;
+			} else if (!strcmp(argvi+1, "creds")) {
+				gpac_credentials_help(argmode);
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "bin")) {
+				gf_sys_format_help(helpout, help_flags, "GPAC binary information:\n"
+					"Version: %s\n"
+					"Compilation configuration: " GPAC_CONFIGURATION "\n"
+					"Enabled features: %s\n"
+	 		"Disabled features: %s\n", gf_gpac_version(), gf_sys_features(GF_FALSE), gf_sys_features(GF_TRUE)
+				);
+				gpac_exit(0);
+			} else if (!strcmp(argvi+1, "filters")) {
+				list_filters = 1;
+				sflags |= GF_FS_FLAG_NO_GRAPH_CACHE;
+				i++;
+			} else if (!strcmp(argvi+1, "filters:*") || !strcmp(argvi+1, "filters:@")) {
+				list_filters = 2;
+				sflags |= GF_FS_FLAG_NO_GRAPH_CACHE;
+				i++;
+			} else {
+				print_filter_info = 1;
+				if (!strcmp(argvi+1, "*:*") || !strcmp(argvi+1, "@:@"))
+					print_filter_info = 2;
+				sflags |= GF_FS_FLAG_NO_GRAPH_CACHE;
+			}
+		}
+		else if (has_xopt && !strcmp(arg, "-h")) {
+			gf_opts_set_key("temp", "gpac-help", "yes");
+		}
+		else if (!strcmp(arg, "-genmd") || !strcmp(arg, "-genman")) {
+			argmode = GF_ARGMODE_ALL;
+			if (!strcmp(arg, "-genmd")) {
+				gf_opts_set_key("temp", "gendoc", "yes");
+				gen_doc = 1;
+				help_flags = GF_PRINTARG_MD;
+				helpout = gf_fopen("gpac_general.md", "w");
+				fprintf(helpout, "%s", auto_gen_md_warning);
+				fprintf(helpout, "# General Usage of gpac\n");
+			} else {
+				gf_opts_set_key("temp", "gendoc", "yes");
+				gen_doc = 2;
+				help_flags = GF_PRINTARG_MAN;
+				helpout = gf_fopen("gpac.1", "w");
+	 			fprintf(helpout, ".TH gpac 1 2019 gpac GPAC\n");
+				fprintf(helpout, ".\n.SH NAME\n.LP\ngpac \\- GPAC command-line filter session manager\n"
+				".SH SYNOPSIS\n.LP\n.B gpac\n"
+				".RI options FILTER LINK FILTER ...\n.br\n.\n");
+			}
+			gpac_usage(GF_ARGMODE_ALL);
+
+			if (gen_doc==1) {
+				fprintf(helpout, "# Using Aliases\n");
+			} else {
+				fprintf(helpout, ".SH Using Aliases\n.PL\n");
+			}
+			gpac_alias_help(GF_ARGMODE_EXPERT);
+
+
+			gpac_credentials_help(GF_ARGMODE_EXPERT);
+
+			if (gen_doc==1) {
+				gf_fclose(helpout);
+				helpout = gf_fopen("core_config.md", "w");
+				fprintf(helpout, "%s", auto_gen_md_warning);
+			}
+			gpac_config_help();
+
+			if (gen_doc==1) {
+				gf_fclose(helpout);
+				helpout = gf_fopen("core_options.md", "w");
+				fprintf(helpout, "%s", auto_gen_md_warning);
+				fprintf(helpout, "# GPAC Core Options\n");
+			}
+			gpac_core_help(argmode, GF_FALSE);
+
+			if (gen_doc==1) {
+				gf_fclose(helpout);
+				helpout = gf_fopen("core_logs.md", "w");
+				fprintf(helpout, "%s", auto_gen_md_warning);
+				fprintf(helpout, "# GPAC Log System\n");
+			}
+			gpac_core_help(argmode, GF_TRUE);
+
+			if (gen_doc==1) {
+				gf_fclose(helpout);
+				helpout = gf_fopen("filters_general.md", "w");
+				fprintf(helpout, "%s", auto_gen_md_warning);
+			}
+#ifndef GPAC_DISABLE_DOC
+			gf_sys_format_help(helpout, help_flags, "%s", gpac_doc);
+#endif
+
+			if (gen_doc==1) {
+				gf_fclose(helpout);
+				helpout = gf_fopen("filters_properties.md", "w");
+				fprintf(helpout, "%s", auto_gen_md_warning);
+			}
+			gf_sys_format_help(helpout, help_flags, "# GPAC Built-in properties\n");
+			dump_all_props(NULL);
+//			dump_codecs = GF_TRUE;
+
+			if (gen_doc==2) {
+				fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/Filters\n");
+				fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
+				".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
+				".br\nbuild: %s\n"
+				".br\nCopyright: %s\n.br\n"
+				".SH SEE ALSO\n"
+				".LP\ngpac-filters(1),MP4Box(1)\n", gf_gpac_version(), gf_gpac_copyright());
+				gf_fclose(helpout);
+
+				helpout = gf_fopen("gpac-filters.1", "w");
+	 			fprintf(helpout, ".TH gpac 1 2019 gpac GPAC\n");
+				fprintf(helpout, ".\n.SH NAME\n.LP\ngpac \\- GPAC command-line filter session manager\n"
+				".SH SYNOPSIS\n.LP\n.B gpac\n"
+				".RI options FILTER LINK FILTER ...\n.br\n.\n"
+				".SH DESCRIPTION\n.LP"
+				"\nThis page describes all filters usually present in GPAC\n"
+				"\nTo check for help on a filter not listed here, use gpac -h myfilter\n"
+				"\n"
+				);
+			}
+
+			list_filters = 1;
+		}
+		else if (!strcmp(arg, "-ltf")) {
+			load_test_filters = GF_TRUE;
+		} else if (!strncmp(arg, "-lcf", 4)) {
+		} else if (!strcmp(arg, "-stats")) {
+			dump_stats = GF_TRUE;
+		} else if (!strcmp(arg, "-graph")) {
+			dump_graph = GF_TRUE;
+		} else if (strstr(arg, ":*") || strstr(arg, ":@")) {
+			if (list_filters)
+				list_filters = 3;
+			else
+				print_meta_filters = GF_TRUE;
+		} else if (!strcmp(arg, "-wc")) {
+			write_core_opts = GF_TRUE;
+		} else if (!strcmp(arg, "-we")) {
+			write_extensions = GF_TRUE;
+		} else if (!strcmp(arg, "-wf")) {
+			write_profile = GF_TRUE;
+		} else if (!strcmp(arg, "-wfx")) {
+			write_profile = GF_TRUE;
+			sflags |= GF_FS_FLAG_LOAD_META;
+		} else if (!strcmp(arg, "-sloop")) {
+			nb_loops = -1;
+			if (arg_val) nb_loops = get_s32(arg_val, "sloop");
+		} else if (!strcmp(arg, "-runfor")) {
+			if (arg_val) runfor = 1000*get_u32(arg_val, "runfor");
+		} else if (!strcmp(arg, "-runforf")) {
+			if (arg_val) runfor = 1000*get_u32(arg_val, "runfor");
+			runfor_fast = GF_TRUE;
+		} else if (!strcmp(arg, "-runforx")) {
+			if (arg_val) runfor = 1000*get_u32(arg_val, "runforx");
+			runfor_exit = GF_TRUE;
+		} else if (!strcmp(arg, "-runfors")) {
+			if (arg_val) runfor = 1000*get_u32(arg_val, "runfors");
+			exit_mode = 1;
+		} else if (!strcmp(arg, "-runforl")) {
+			if (arg_val) runfor = 1000*get_u32(arg_val, "runforl");
+			exit_mode = 2;
+		} else if (!strcmp(arg, "-uncache")) {
+			const char *cache_dir = gf_opts_get_key("core", "cache");
+			gf_enum_directory(cache_dir, GF_FALSE, revert_cache_file, NULL, ".txt");
+			fprintf(stderr, "GPAC Cache dir %s flattened\n", cache_dir);
+			gpac_exit(0);
+		} else if (!strcmp(arg, "-cfg")) {
+			nothing_to_do = GF_FALSE;
+		}
+
+		else if (!strcmp(arg, "-alias") || !strcmp(arg, "-aliasdoc")) {
+			char *alias_val;
+			Bool exists;
+			if (!arg_val) {
+				fprintf(stderr, "-alias does not have any argument, check usage \"gpac -h\"\n");
+				gpac_exit(1);
+			}
+			alias_val = arg_val ? strchr(arg_val, ' ') : NULL;
+			if (alias_val) alias_val0 = 0;
+
+			session = gf_fs_new_defaults(sflags);
+			exists = gf_fs_filter_exists(session, arg_val);
+			gf_fs_del(session);
+			if (exists) {
+				fprintf(stderr, "alias %s has the same name as an existing filter, not allowed\n", arg_val);
+				if (alias_val) alias_val0 = ' ';
+				gpac_exit(1);
+			}
+
+			gf_opts_set_key(!strcmp(arg, "-alias") ? "gpac.alias" : "gpac.aliasdoc", arg_val, alias_val ? alias_val+1 : NULL);
+			fprintf(stderr, "Set %s for %s to %s\n", arg, arg_val, alias_val ? alias_val+1 : "NULL");
+			if (alias_val) alias_val0 = ' ';
+			alias_set = GF_TRUE;
+		}
+		else if (!strncmp(arg, "-seps", 5)) {
+			parse_sep_set(arg_val, &override_seps);
+		} else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
+
+		} else if (!strcmp(arg, "-k")) {
+			if (arg_val && (!strcmp(arg_val, "0") || !strcmp(arg_val, "no") || !strcmp(arg_val, "false")))
+				enable_prompt = GF_FALSE;
+			else
+				enable_prompt = GF_TRUE;
+		} else if (!strcmp(arg, "-js")) {
+			session_js = arg_val;
+		} else if (!strcmp(arg, "-r")) {
+			enable_reports = 2;
+			if (arg_val && !strlen(arg_val)) {
+				enable_reports = 1;
+			} else {
+				report_filter = arg_val;
+			}
+		} else if (!strcmp(arg, "-unit-tests")) {
+			do_unit_tests = GF_TRUE;
+		} else if (!strcmp(arg, "-cl")) {
+			sflags |= GF_FS_FLAG_NO_IMPLICIT;
+		} else if (!strcmp(arg, "-step")) {
+			use_step_mode = GF_TRUE;
+			sflags |= GF_FS_FLAG_NON_BLOCKING;
+		} else if (!strcmp(arg, "-xopt")) {
+			has_xopt = GF_TRUE;
+#ifdef GPAC_CONFIG_IOS
+		} else if (!strcmp(arg, "-req-gl")) {
+#endif
+		} else if (arg0=='-') {
+			if (!strcmp(arg, "-i") || !strcmp(arg, "-src")
+				|| !strcmp(arg, "-o") || !strcmp(arg, "-dst")
+				|| !strcmp(arg, "-ib") || !strcmp(arg, "-ob")
+			) {
+				//skip next arg: input or output, could start with '-'
+				i++;
+				gf_sys_mark_arg_used(i, GF_TRUE);
+			}
+			//profile already processed, and global options (--) handled by libgpac, not this app
+			else if (!strcmp(arg, "-p") || !strcmp(arg, "-")
+			) {
+			}
+			else if (gf_sys_is_gpac_arg(arg) ) {
+			}
+#if !defined(GPAC_CONFIG_ANDROID) && !defined(GPAC_DISABLE_PLAYER)
+			else if ((compositor_mode==LOAD_MP4C) && mp4c_parse_arg(arg, arg_val)) {
+			}
+#endif
+			else {
+				if (!has_xopt) {
+					gpac_suggest_arg(arg);
+					gpac_exit(-1);
+				} else {
+					gf_sys_mark_arg_used(i, GF_FALSE);
+				}
+			}
+		}
+	}
+
+	if (do_unit_tests) {
+		gpac_exit( gpac_unit_tests(mem_track) );
+	}
+
+	if (alias_set) {
+		gpac_exit(0);
+	}
+
+	if (dump_stats && gf_sys_get_rti(0, &rti, 0) ) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("System info: %d MB RAM - %d cores - main thread ID %d\n", (u32) (rti.physical_memory/1024/1024), rti.nb_cores, gf_th_id() ));
+	}
+	if ((list_filters>=2) || print_meta_filters || dump_codecs || dump_formats || print_filter_info) sflags |= GF_FS_FLAG_LOAD_META;
+
+	if (view_filter_conn || list_filters || (print_filter_info && (argmode == GF_ARGMODE_ALL)) )
+		gf_opts_set_key("temp", "gendoc", "yes");
+
+	if (list_filters || print_filter_info)
+		gf_opts_set_key("temp", "helponly", "yes");
+
+	if (dump_proto_schemes || (gen_doc==1))
+		gf_opts_set_key("temp", "get_proto_schemes", "yes");
+
+
+#if defined(GPAC_CONFIG_DARWIN) && !defined(GPAC_CONFIG_IOS)
+	if (compositor_mode==LOAD_GUI_ENV) {
+		const char *sys_logs = getenv("GPAC_SYSLOG");
+		if (sys_logs && !stricmp(sys_logs, "yes")) {
+			gf_log_set_callback(NULL, gpac_syslog);
+		}
+	}
+#endif
+
+restart:
+	prev_filter_is_sink = 0;
+	current_subsession_id = 0;
+	prev_filter_is_not_source = 0;
+	current_source_id = 0;
+
+	if (view_conn_for_filter && argmode>=GF_ARGMODE_EXPERT)
+		sflags |= GF_FS_FLAG_PRINT_CONNECTIONS;
+
+	session = gf_fs_new_defaults(sflags);
+
+	if (!session) {
+		gpac_exit(1);
+	}
+	if (override_seps) gf_fs_set_separators(session, separator_set);
+	if (load_test_filters) gf_fs_register_test_filters(session);
+
+	if (gf_fs_get_max_resolution_chain_length(session) <= 1 ) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("\nDynamic resolution of filter connections disabled\n\n"));
+	}
+
+	if (list_filters || print_filter_info) {
+
+		if (gen_doc==1) {
+			dump_all_formats(argmode);
+			dump_all_proto_schemes(argmode);
+			list_filters = 1;
+		}
+
+		if (print_filters(argc, argv, argmode)==GF_FALSE)
+			e = GF_FILTER_NOT_FOUND;
+		goto exit;
+	}
+	if (view_filter_conn) {
+		gf_fs_print_all_connections(session, view_conn_for_filter, gf_sys_format_help);
+		goto exit;
+	}
+	if (dump_codecs) {
+		dump_all_codecs(argmode);
+		goto exit;
+	}
+	if (dump_formats) {
+		dump_all_formats(argmode);
+		goto exit;
+	}
+	if (dump_proto_schemes) {
+		dump_all_proto_schemes(argmode);
+		goto exit;
+	}
+	if (write_profile || write_extensions || write_core_opts) {
+		if (write_core_opts)
+			write_core_options();
+		if (write_extensions)
+			write_file_extensions();
+		if (write_profile)
+			write_filters_options();
+		goto exit;
+	}
+
+	if (session_js) {
+		e = gf_fs_load_script(session, session_js);
+		if (e) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Failed to load JS for session: %s\n", gf_error_to_string(e) ));
+			goto exit;
+		}
+	}
+
+	//all good to go, load filters
+	has_xopt = GF_FALSE;
+	links_directive = gf_list_new();
+	loaded_filters = gf_list_new();
+	for (i=1; i<argc; i++) {
+		GF_Filter *filter=NULL;
+		Bool is_simple=GF_FALSE;
+		Bool f_loaded = GF_FALSE;
+		char *arg = argvi;
+
+		if (!strcmp(arg, "-src") || !strcmp(arg, "-i") || !strcmp(arg, "-ib") ) {
+			if (!strcmp(arg, "-ib")) {
+				const char *fargs=NULL;
+				const char *fio_url = make_fileio(argvi+1, &fargs, GF_TRUE, &e);
+				if (fio_url)
+					filter = gf_fs_load_source(session, fio_url, fargs, NULL, &e);
+			} else {
+				filter = gf_fs_load_source(session, argvi+1, NULL, NULL, &e);
+			}
+			arg = argvi+1;
+			i++;
+			f_loaded = GF_TRUE;
+		} else if (!strcmp(arg, "-dst") || !strcmp(arg, "-o") || !strcmp(arg, "-ob") ) {
+			if (!strcmp(arg, "-ob")) {
+				const char *fargs=NULL;
+				const char *fio_url = make_fileio(argvi+1, &fargs, GF_FALSE, &e);
+				if (fio_url)
+					filter = gf_fs_load_destination(session, fio_url, fargs, NULL, &e);
+			} else {
+				filter = gf_fs_load_destination(session, argvi+1, NULL, NULL, &e);
+			}
+			arg = argvi+1;
+			i++;
+			f_loaded = GF_TRUE;
+		}
+		else if (!strncmp(arg, "-lcf", 4)) {
+			f_loaded = GF_TRUE;
+			filter = load_custom_filter(session, arg+4, &e);
+		}
+		//appart from the above src/dst, other args starting with - are not filters
+		else if (arg0=='-') {
+			if (!strcmp(arg, "-xopt")) has_xopt = GF_TRUE;
+			continue;
+		}
+		if (!f_loaded && !has_xopt) {
+			if (arg0== separator_setSEP_LINK ) {
+				gf_list_add(links_directive, arg);
+				continue;
+			}
+
+			if (!strncmp(arg, "src=", 4) ) {
+				filter = gf_fs_load_source(session, arg+4, NULL, NULL, &e);
+			} else if (!strncmp(arg, "dst=", 4) ) {
+				filter = gf_fs_load_destination(session, arg+4, NULL, NULL, &e);
+			} else {
+				e = GF_EOS;
+				char *need_gfio = strstr(arg, "@gfi://");
+				if (!need_gfio) need_gfio = strstr(arg, "@gfo://");
+				if (need_gfio) {
+					const char *fargs=NULL;
+					const char *fio_url;
+					char *updated_args;
+					u32 len = (u32) (need_gfio - arg);
+					updated_args = gf_malloc(sizeof(char)*(len+1));
+					strncpy(updated_args, arg, len);
+					updated_argslen=0;
+
+					fio_url = make_fileio(need_gfio+7, &fargs, need_gfio3=='i' ? GF_TRUE : GF_FALSE, &e);
+					if (fio_url) {
+						gf_dynstrcat(&updated_args, fio_url, NULL);
+						if (fargs)
+							gf_dynstrcat(&updated_args, fargs, NULL);
+
+						filter = gf_fs_load_filter(session, updated_args, &e);
+					}
+					gf_free(updated_args);
+				} else {
+					filter = gf_fs_load_filter(session, arg, &e);
+#if !defined(GPAC_CONFIG_ANDROID) && !defined(GPAC_DISABLE_PLAYER)
+					if (filter && compositor_mode && !strncmp(arg, "compositor", 10)) {
+						load_compositor(filter);
+					}
+#endif
+				}
+				is_simple=GF_TRUE;
+				if (!filter && has_xopt)
+					continue;
+			}
+		}
+
+		if (!filter) {
+			if (has_xopt)
+				continue;
+			if (!e) e = GF_FILTER_NOT_FOUND;
+
+			if (e!=GF_FILTER_NOT_FOUND) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Failed to load filter%s \"%s\": %s\n", is_simple ? "" : " for", arg, gf_error_to_string(e) ));
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Failed to find filter%s \"%s\"\n", is_simple ? "" : " for", arg));
+
+				gpac_suggest_filter(arg, GF_FALSE, GF_TRUE);
+				nb_filters=0;
+			}
+			goto exit;
+		}
+		nb_filters++;
+
+		if (!(sflags & GF_FS_FLAG_NO_IMPLICIT))
+			gf_filter_tag_subsession(filter, current_subsession_id, current_source_id);
+
+		while (gf_list_count(links_directive)) {
+			char *link_prev_filter_ext = NULL;
+			GF_Filter *link_from;
+			Bool reverse_order = GF_FALSE;
+			s32 link_filter_idx = -1;
+			char *link = gf_list_pop_front(links_directive);
+			char *ext = strchr(link, separator_setSEP_FRAG);
+			if (ext) {
+				ext0 = 0;
+				link_prev_filter_ext = ext+1;
+			}
+			if (strlen(link)>1) {
+				if (link1 == separator_setSEP_LINK ) {
+					reverse_order = GF_TRUE;
+					link++;
+				}
+				link_filter_idx = 0;
+				if (strlen(link)>1) {
+					link_filter_idx = get_u32(link+1, "Link filter index");
+					if (link_filter_idx < 0) {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Wrong filter index %d, must be positive\n", link_filter_idx));
+						e = GF_BAD_PARAM;
+						goto exit;
+					}
+				}
+			} else {
+				link_filter_idx = 0;
+			}
+			if (ext) ext0 = separator_setSEP_FRAG;
+
+			if (reverse_order)
+				link_from = gf_list_get(loaded_filters, link_filter_idx);
+			else
+				link_from = gf_list_get(loaded_filters, gf_list_count(loaded_filters)-1-link_filter_idx);
+
+			if (!link_from) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Wrong filter index @%d\n", link_filter_idx));
+				e = GF_BAD_PARAM;
+				goto exit;
+			}
+			gf_filter_set_source(filter, link_from, link_prev_filter_ext);
+		}
+
+		gf_list_add(loaded_filters, filter);
+
+		//implicit mode, check changes of source and sinks
+		if (!(sflags & GF_FS_FLAG_NO_IMPLICIT)) {
+			if (gf_filter_is_source(filter)) {
+				if (prev_filter_is_not_source) {
+					current_source_id++;
+					gf_filter_tag_subsession(filter, current_subsession_id, current_source_id);
+				}
+				prev_filter_is_not_source = 0;
+			} else {
+				prev_filter_is_not_source = 1;
+			}
+
+			if (gf_filter_is_sink(filter)) {
+				prev_filter_is_sink = GF_TRUE;
+			}
+			else if (prev_filter_is_sink && gf_filter_is_source(filter)) {
+				prev_filter_is_sink = GF_FALSE;
+				current_subsession_id++;
+				current_source_id=0;
+				prev_filter_is_not_source = 0;
+				gf_filter_tag_subsession(filter, current_subsession_id, current_source_id);
+			}
+		}
+	}
+	if (!gf_list_count(loaded_filters) && !session_js) {
+		if (nothing_to_do && !gen_doc) {
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Nothing to do, check usage \"gpac -h\"\ngpac - GPAC command line filter engine - version %s\n%s\n", gf_gpac_version(), gf_gpac_copyright_cite()));
+			e = GF_BAD_PARAM;
+		} else {
+			e = GF_EOS;
+		}
+		goto exit;
+	}
+	if (enable_reports) {
+		if (enable_reports==2)
+			gf_fs_set_ui_callback(session, gpac_event_proc, session);
+
+		gf_fs_enable_reporting(session, GF_TRUE);
+	}
+#ifndef GPAC_CONFIG_ANDROID
+	if ((compositor_mode==LOAD_MP4C) || (compositor_mode==LOAD_GUI_CBK)) {
+		custom_event_proc = GF_TRUE;
+		gf_fs_set_ui_callback(session, gpac_event_proc, session);
+	}
+#endif
+
+	if (gf_list_count(links_directive)) {
+		GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Link separators specified but no following filter, ignoring links "));
+		while (gf_list_count(links_directive)) {
+			const char *ld = gf_list_pop_front(links_directive);
+			GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\"%s\"", ld));
+		}
+		GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\n"));
+	}
+
+	if (enable_prompt || (runfor>0)) {
+		if (enable_prompt && !loops_done) {
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Running session, press 'h' for help\n"));
+		}
+#ifndef GPAC_CONFIG_ANDROID
+		if (compositor_mode==LOAD_MP4C)
+			gf_fs_post_user_task_main(session, gpac_fsess_task, NULL, "gpac_fsess_task");
+		else
+#endif
+			gf_fs_post_user_task(session, gpac_fsess_task, NULL, "gpac_fsess_task");
+	}
+	if (!enable_prompt) {
+#ifdef WIN32
+		SetConsoleCtrlHandler((PHANDLER_ROUTINE)gpac_sig_handler, TRUE);
+#else
+		signal(SIGINT, gpac_sig_handler);
+		signal(SIGTERM, gpac_sig_handler);
+		signal(SIGPIPE, gpac_sig_handler);
+#endif
+	}
+
+	if (enable_reports) {
+		gpac_print_report(session, GF_TRUE, GF_FALSE);
+	}
+
+	if (use_step_mode) {
+		do {
+			gf_fs_run(session);
+		} while (!gf_fs_is_last_task(session));
+
+	} else {
+		e = gf_fs_run(session);
+		if (e>0) e = GF_OK;
+	}
+
+	if (e) {
+		fprintf(stderr, "session error %s\n", gf_error_to_string(e) );
+	} else {
+		e = gf_fs_get_last_connect_error(session);
+		if (e<0) fprintf(stderr, "session last connect error %s\n", gf_error_to_string(e) );
+
+		if (!e) {
+			e = gf_fs_get_last_process_error(session);
+			if (e<0) fprintf(stderr, "session last process error %s\n", gf_error_to_string(e) );
+
+			if (evt_ret_val<0) {
+				e = evt_ret_val;
+				fprintf(stderr, "UI last error %s\n", gf_error_to_string(e) );
+			}
+		}
+		gpac_check_session_args();
+	}
+
+	if (enable_reports) {
+		if (enable_reports==2) {
+			gf_sys_set_console_code(stderr, GF_CONSOLE_RESTORE);
+		}
+		gpac_print_report(session, GF_FALSE, GF_TRUE);
+	}
+	if (!dump_graph)
+		gf_fs_print_non_connected_ex(session, alias_is_play);
+
+exit:
+	if (enable_reports==2) {
+		gf_log_set_callback(session, NULL);
+	}
+
+	if (e && nb_filters) {
+		gf_fs_run(session);
+	}
+	if (dump_stats)
+		gf_fs_print_stats(session);
+	if (dump_graph)
+		gf_fs_print_connections(session);
+
+#if !defined(GPAC_CONFIG_ANDROID) && !defined(GPAC_DISABLE_PLAYER)
+	if (compositor_mode)
+		unload_compositor();
+#endif
+
+	tmp_sess = session;
+	session = NULL;
+	gf_fs_del(tmp_sess);
+	if (loaded_filters) gf_list_del(loaded_filters);
+	if (links_directive) gf_list_del(links_directive);
+
+	cleanup_file_io();
+
+	if (!e && nb_loops) {
+		if (nb_loops>0) nb_loops--;
+		loops_done++;
+		fprintf(stderr, "session done, restarting (loop %d)\n", loops_done);
+
+#ifndef GPAC_CONFIG_ANDROID
+		fflush(stderr);
+#endif
+		gf_log_reset_file();
+		goto restart;
+	}
+
+	gpac_exit(e<0 ? 1 : 0);
+}
+
+#if defined(GPAC_CONFIG_DARWIN) && !defined(GPAC_CONFIG_IOS)
+int main(int argc, char **argv)
+{
+ const char *is_gui = (argc==1) ? getenv("GPAC_GUI") : NULL;
+ if (is_gui && !stricmp(is_gui, "yes")) {
+ char *_argv2;
+ _argv0 = "gpac";
+ _argv1 = "-gui";
+ compositor_mode = LOAD_GUI_ENV;
+ return gpac_main(2, _argv);
+ }
+ return gpac_main(argc, argv);
+}
+#elif defined(GPAC_CONFIG_IOS)
+/*
+	Note - this requires a patched libSDL2.0.10 or higher where the "main" symbol in SDL_uikit_main is commented out or renamed
+	To build with a vanilla libSDL, remove ios_main.m from project
+
+	The goal is to launch gpac indepentently from SDL for command-line usage
+*/
+int SDL_main(int argc, char **argv)
+{
+ if (argc<=1) {
+ char *_argv3;
+ _argv0 = "gpac";
+ _argv1 = "-noprog";
+ _argv2 = "compositor:player=gui";
+ compositor_mode = LOAD_GUI_CBK;
+ return gpac_main(3, _argv);
+ }
+ return gpac_main(argc, argv);
+}
+
+#elif !defined(GPAC_CONFIG_ANDROID)
+
+GF_MAIN_FUNC(gpac_main)
+
+#endif
+
+#ifdef GPAC_CONFIG_ANDROID
+void gpac_abort(void)
+{
+	if (session) {
+		gf_fs_abort(session, GF_FS_FLUSH_NONE);
+		nb_loops = 0;
+	}
+}
+#endif
+
+
+/*
+	prompt interaction
+*/
+
+typedef enum
+{
+	GPAC_COM_UNDEF = 0,
+	GPAC_QUIT,
+	GPAC_EXIT,
+	GPAC_PRINT_STATS,
+	GPAC_PRINT_GRAPH,
+	GPAC_SEND_UPDATE,
+	GPAC_LIST_FILTERS,
+	GPAC_INSERT_FILTER,
+	GPAC_REMOVE_FILTER,
+	GPAC_PRINT_HELP
+} GPAC_Command;
+
+static struct _gpac_key
+{
+	u8 char_code;
+	GPAC_Command cmd_type;
+	const char *cmd_help;
+	u32 flags;
+} GPAC_Keys = {
+	{'q', GPAC_QUIT, "flush all streams and exit", 0},
+	{'x', GPAC_EXIT, "exit with no flush (may break output files)", 0},
+	{'s', GPAC_PRINT_STATS, "print statistics", 0},
+	{'g', GPAC_PRINT_GRAPH, "print filter graph", 0},
+	{'l', GPAC_LIST_FILTERS, "list filters", 0},
+	{'u', GPAC_SEND_UPDATE, "update argument of filter", 0},
+	{'i', GPAC_INSERT_FILTER, "insert a filter in the chain", 0},
+	{'r', GPAC_REMOVE_FILTER, "remove a filter from the chain", 0},
+	{'h', GPAC_PRINT_HELP, "print this help", 0},
+	{0}
+};
+
+static GPAC_Command get_cmd(u8 char_code)
+{
+	u32 i=0;
+	while (GPAC_Keysi.char_code) {
+		if (GPAC_Keysi.char_code == char_code)
+			return GPAC_Keysi.cmd_type;
+		i++;
+	}
+	return GPAC_COM_UNDEF;
+}
+
+static void gpac_fsess_task_help()
+{
+	gf_sys_format_help(helpout, help_flags, "Available runtime options/keys:\n");
+
+	u32 i=0;
+	while (GPAC_Keysi.char_code) {
+		gf_sys_format_help(helpout, help_flags, "- %c: %s\n", GPAC_Keysi.char_code, GPAC_Keysi.cmd_help);
+		i++;
+	}
+}
+
+
+static char szFilter100;
+static char szCom2048;
+static Bool gpac_handle_prompt(GF_FilterSession *fsess, char char_code)
+{
+	u32 i, count;
+	GF_Filter *filter;
+	const GF_Filter *link_from=NULL;
+	GF_Err e;
+	char *link_args = NULL;
+
+	GPAC_Command c = get_cmd(char_code);
+	switch (c) {
+	case GPAC_QUIT:
+		gf_fs_abort(fsess, GF_FS_FLUSH_ALL);
+		nb_loops = 0;
+		return GF_FALSE;
+	case GPAC_EXIT:
+		gf_fs_abort(fsess, GF_FS_FLUSH_NONE);
+		nb_loops = 0;
+		return GF_FALSE;
+	case GPAC_PRINT_STATS:
+		gf_fs_print_stats(fsess);
+		break;
+	case GPAC_PRINT_GRAPH:
+		gf_fs_print_connections(fsess);
+		break;
+	case GPAC_PRINT_HELP:
+		gpac_fsess_task_help();
+		break;
+	case GPAC_SEND_UPDATE:
+		fprintf(stderr, "Sending filter update - enter the target filter ID, name, registry name or #N with N the 0-based index in loaded filter list:\n");
+
+		if (1 > scanf("%99s", szFilter)) {
+			fprintf(stderr, "Cannot read the filter ID, aborting.\n");
+			break;
+		}
+		e = GF_OK;
+		if (szFilter0=='#') {
+			GF_FilterStats stats;
+			u32 idx = atoi(szFilter+1);
+			gf_fs_lock_filters(fsess, GF_TRUE);
+			e = gf_fs_get_filter_stats(fsess, idx, &stats);
+			gf_fs_lock_filters(fsess, GF_FALSE);
+			if (e==GF_OK)
+				strncpy(szFilter, stats.filter_id ? stats.filter_id : stats.name, 99);
+		}
+		if (e) {
+			fprintf(stderr, "Cannot get filter for ID %s, aborting.\n", szFilter);
+			break;
+		}
+		fprintf(stderr, "Enter the command to send\n");
+		if (1 > scanf("%2047s", szCom)) {
+			fprintf(stderr, "Cannot read the command, aborting.\n");
+			break;
+		}
+		gf_fs_send_update(fsess, szFilter, NULL, szCom, NULL, 0);
+		break;
+	case GPAC_LIST_FILTERS:
+		gf_fs_lock_filters(fsess, GF_TRUE);
+		count = gf_fs_get_filters_count(fsess);
+		fprintf(stderr, "Loaded filters:\n");
+		for (i=0; i<count; i++) {
+			GF_FilterStats stats;
+			gf_fs_get_filter_stats(fsess, i, &stats);
+			if (stats.filter_id)
+				fprintf(stderr, "%s (%s) ID %s\n", stats.name, stats.reg_name, stats.filter_id);
+			else
+				fprintf(stderr, "%s (%s)\n", stats.name, stats.reg_name);
+		}
+		gf_fs_lock_filters(fsess, GF_FALSE);
+		break;
+	case GPAC_INSERT_FILTER:
+	case GPAC_REMOVE_FILTER:
+		fprintf(stderr, "%s filter ID, name, registry name or #N with N the 0-based index in loaded filter list:\n",
+				(c==GPAC_INSERT_FILTER) ? "Inserting filter - enter the source" : "Removing filter - enter the");
+
+		if (1 > scanf("%99s", szFilter)) {
+			fprintf(stderr, "Cannot read the filter ID or index, aborting.\n");
+			break;
+		}
+		link_args = strchr(szFilter, separator_setSEP_LINK);
+		if (link_args) {
+			link_args0 = 0;
+			link_args++;
+		}
+		if (szFilter0=='#') {
+			GF_FilterStats stats;
+			u32 idx = atoi(szFilter+1);
+			gf_fs_lock_filters(fsess, GF_TRUE);
+			gf_fs_get_filter_stats(fsess, idx, &stats);
+			gf_fs_lock_filters(fsess, GF_FALSE);
+			link_from = stats.filter;
+		} else {
+			const GF_Filter *link_from_by_reg=NULL;
+			gf_fs_lock_filters(fsess, GF_TRUE);
+			count = gf_fs_get_filters_count(fsess);
+			for (i=0; i<count; i++) {
+				GF_FilterStats stats;
+				gf_fs_get_filter_stats(fsess, i, &stats);
+				if (!strcmp(stats.name, szFilter)) {
+					link_from = stats.filter;
+					break;
+				}
+				if (!link_from_by_reg && !strcmp(stats.reg_name, szFilter)) {
+					link_from_by_reg = stats.filter;
+				}
+			}
+			gf_fs_lock_filters(fsess, GF_FALSE);
+			if (!link_from)
+				link_from = link_from_by_reg;
+		}
+		if (!link_from) {
+			fprintf(stderr, "Failed to get filter %s, not found\n", szFilter);
+			break;
+		}
+
+		if (c==GPAC_REMOVE_FILTER) {
+			gf_filter_remove((GF_Filter *) link_from);
+			break;
+		}
+
+		fprintf(stderr, "Enter the filter to insert\n");
+		if (1 > scanf("%2047s", szCom)) {
+			fprintf(stderr, "Cannot read the filter to insert, aborting.\n");
+			break;
+		}
+
+		if (!strncmp(szCom, "src=", 4)) {
+			filter = gf_fs_load_source(fsess, szCom+4, NULL, NULL, &e);
+		} else if (!strncmp(szCom, "dst=", 4)) {
+			filter = gf_fs_load_destination(fsess, szCom+4, NULL, NULL, &e);
+		} else {
+			filter = gf_fs_load_filter(fsess, szCom, &e);
+		}
+
+		if (!filter) {
+			fprintf(stderr, "Cannot load filter %s: %s\n", szCom, gf_error_to_string(e));
+			break;
+		}
+		gf_filter_set_source(filter, (GF_Filter *) link_from, link_args);
+		//reconnect outputs of source
+		gf_filter_reconnect_output((GF_Filter *) link_from, NULL);
+		break;
+	default:
+		break;
+	}
+	return GF_TRUE;
+}
+
+/*
+	run-time reporting vars
+*/
+
+static Bool logs_to_file=GF_FALSE;
+
+#define DEF_LOG_ENTRIES	10
+
+struct _logentry
+{
+	u32 tool, level;
+	u32 nb_repeat;
+	u64 clock;
+	char *szMsg;
+} *static_logs;
+static u32 nb_log_entries = DEF_LOG_ENTRIES;
+
+static u32 log_write=0;
+
+static char *log_buf = NULL;
+static u32 log_buf_size=0;
+
+
+static void cleanup_logs()
+{
+	if (static_logs) {
+		u32 i;
+		for (i=0; i<nb_log_entries; i++) {
+			if (static_logsi.szMsg)
+				gf_free(static_logsi.szMsg);
+		}
+		gf_free(static_logs);
+	}
+	if (log_buf) gf_free(log_buf);
+	log_buf = NULL;
+	log_buf_size = 0;
+	log_write = 0;
+}
+
+static void gpac_on_logs(void *cbck, GF_LOG_Level log_level, GF_LOG_Tool log_tool, const char* fmt, va_list vlist)
+{
+	va_list vlist_tmp;
+	va_copy(vlist_tmp, vlist);
+	u32 len = vsnprintf(NULL, 0, fmt, vlist_tmp);
+	va_end(vlist_tmp);
+	if (log_buf_size < len+2) {
+		log_buf_size = len+2;
+		log_buf = gf_realloc(log_buf, log_buf_size);
+	}
+	vsprintf(log_buf, fmt, vlist);
+
+	if (log_write && static_logslog_write-1.szMsg) {
+		if (!strcmp(static_logslog_write-1.szMsg, log_buf)) {
+			static_logslog_write-1.nb_repeat++;
+			return;
+		}
+	}
+
+	static_logslog_write.level = log_level;
+	static_logslog_write.tool = log_tool;
+	if (static_logslog_write.szMsg) gf_free(static_logslog_write.szMsg);
+	static_logslog_write.szMsg = gf_strdup(log_buf);
+	static_logslog_write.clock = gf_net_get_utc();
+
+	log_write++;
+	if (log_write==nb_log_entries) {
+		log_write = nb_log_entries - 1;
+		gf_free(static_logs0.szMsg);
+		memmove(&static_logs0, &static_logs1, sizeof (struct _logentry) * (nb_log_entries-1) );
+		memset(&static_logslog_write, 0, sizeof(struct _logentry));
+	}
+}
+
+static u64 last_report_clock_us = 0;
+static void print_date_ex(u64 time, Bool full_print)
+{
+	time_t gtime;
+	struct tm *t;
+	u32 sec;
+	u32 ms;
+	gtime = time / 1000;
+	sec = (u32)(time / 1000);
+	ms = (u32)(time - ((u64)sec) * 1000);
+	t = gf_gmtime(&gtime);
+	if (full_print) {
+		fprintf(stdout, "%d-%02d-%02dT%02d:%02d:%02d.%03dZ\n", 1900 + t->tm_year, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, ms);
+	} else {
+		fprintf(stderr, "%02d:%02d:%02d.%03dZ ", t->tm_hour, t->tm_min, t->tm_sec, ms);
+	}
+}
+
+static void print_date(u64 time)
+{
+	print_date_ex(time, GF_FALSE);
+
+}
+static void gpac_print_report(GF_FilterSession *fsess, Bool is_init, Bool is_final)
+{
+	u32 i, count, nb_active;
+	u64 now;
+
+	if (in_sig_handler) return;
+
+	if (is_init) {
+		if (enable_reports==2)
+			gf_sys_set_console_code(stderr, GF_CONSOLE_SAVE);
+
+		logs_to_file = gf_log_use_file();
+		if (!logs_to_file && (enable_reports==2) ) {
+			if (!nb_log_entries) nb_log_entries = 1;
+			static_logs = gf_malloc(sizeof(struct _logentry) * nb_log_entries);
+			memset(static_logs, 0, sizeof(struct _logentry) * nb_log_entries);
+			gf_log_set_callback(fsess, gpac_on_logs);
+		}
+		last_report_clock_us = gf_sys_clock_high_res();
+		return;
+	}
+
+	now = gf_sys_clock_high_res();
+	if ( (now - last_report_clock_us < 200000) && !is_final)
+		return;
+
+	last_report_clock_us = now;
+	if (!is_final)
+		gf_sys_set_console_code(stderr, GF_CONSOLE_CLEAR);
+
+	gf_sys_get_rti(100, &rti, 0);
+	gf_sys_set_console_code(stderr, GF_CONSOLE_CYAN);
+	print_date(gf_net_get_utc());
+	fprintf(stderr, "GPAC Session Status: ");
+	gf_sys_set_console_code(stderr, GF_CONSOLE_RESET);
+	fprintf(stderr, "mem % 10"LLD_SUF" kb CPU % 2d", rti.gpac_memory/1000, rti.process_cpu_time);
+	fprintf(stderr, "\n");
+
+	gf_fs_lock_filters(fsess, GF_TRUE);
+	nb_active = count = gf_fs_get_filters_count(fsess);
+	for (i=0; i<count; i++) {
+		GF_FilterStats stats;
+		gf_fs_get_filter_stats(fsess, i, &stats);
+		if (stats.done || stats.filter_alias) {
+			nb_active--;
+			continue;
+		}
+		if (report_filter && (!strstr(report_filter, stats.reg_name)))
+			continue;
+
+		gf_sys_set_console_code(stderr, GF_CONSOLE_GREEN);
+		fprintf(stderr, "%s", stats.name ? stats.name : stats.reg_name);
+		gf_sys_set_console_code(stderr, GF_CONSOLE_RESET);
+		if (stats.name && strcmp(stats.name, stats.reg_name))
+			fprintf(stderr, " (%s)", stats.reg_name);
+		fprintf(stderr, ": ");
+
+		if (stats.status) {
+			fprintf(stderr, "%s\n", stats.status);
+		} else {
+			if (stats.stream_type)
+				fprintf(stderr, "%s ", gf_stream_type_name(stats.stream_type));
+			if (stats.codecid)
+			 	fprintf(stderr, "(%s) ", gf_codecid_name(stats.codecid) );
+
+			if ((stats.nb_pid_in == stats.nb_pid_out) && (stats.nb_pid_in==1)) {
+				Double pck_per_sec = (Double) (stats.nb_hw_pck_sent ? stats.nb_hw_pck_sent : stats.nb_pck_sent);
+				pck_per_sec *= 1000000;
+				pck_per_sec /= (stats.time_process+1);
+
+				fprintf(stderr, "% 10"LLD_SUF" pck %02.02f FPS ", (s64) stats.nb_out_pck, pck_per_sec);
+			} else {
+				if (stats.nb_pid_in)
+					fprintf(stderr, "%d input PIDs % 10"LLD_SUF" pck ", stats.nb_pid_in, (s64)stats.nb_in_pck);
+				if (stats.nb_pid_out)
+					fprintf(stderr, "%d output PIDs % 10"LLD_SUF" pck ", stats.nb_pid_out, (s64) stats.nb_out_pck);
+			}
+			if (stats.in_eos)
+				fprintf(stderr, "- EOS");
+			fprintf(stderr, "\n");
+		}
+	}
+	fprintf(stderr, "Active filters: %d\n", nb_active);
+
+	if (static_logs) {
+		if (is_final && (!log_write || !static_logslog_write-1.szMsg))
+			return;
+
+		fprintf(stderr, "\nLogs:\n");
+		for (i=0; i<log_write; i++) {
+			if (static_logsi.level==GF_LOG_ERROR) gf_sys_set_console_code(stderr, GF_CONSOLE_RED);
+			else if (static_logsi.level==GF_LOG_WARNING) gf_sys_set_console_code(stderr, GF_CONSOLE_YELLOW);
+			else if (static_logsi.level==GF_LOG_INFO) gf_sys_set_console_code(stderr, GF_CONSOLE_GREEN);
+			else gf_sys_set_console_code(stderr, GF_CONSOLE_CYAN);
+
+			print_date(static_logsi.clock);
+
+			if (static_logsi.nb_repeat)
+				fprintf(stderr, "repeated %d ", static_logsi.nb_repeat);
+
+			fprintf(stderr, "%s", static_logsi.szMsg);
+			gf_sys_set_console_code(stderr, GF_CONSOLE_RESET);
+		}
+		fprintf(stderr, "\n");
+	}
+	gf_fs_lock_filters(fsess, GF_FALSE);
+	fflush(stderr);
+}
+
+static Bool revert_cache_file(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
+{
+	const char *url;
+	GF_Config *cached;
+	if (strncmp(item_name, "gpac_cache_", 11)) return GF_FALSE;
+	cached = gf_cfg_new(NULL, item_path);
+	url = gf_cfg_get_key(cached, "cache", "url");
+	if (url) url = strstr(url, "://");
+	if (url) {
+		u32 i, len, dir_len=0, k=0;
+		char *dst_name;
+		char *sep;
+
+		sep = strstr(item_path, "gpac_cache_");
+		if (sep) {
+			sep0 = 0;
+			dir_len = (u32) strlen(item_path);
+			sep0 = 'g';
+		}
+		url+=3;
+		len = (u32) strlen(url);
+		dst_name = gf_malloc(len+dir_len+1);
+		memset(dst_name, 0, len+dir_len+1);
+
+		strncpy(dst_name, item_path, dir_len);
+		k=dir_len;
+		for (i=0; i<len; i++) {
+			dst_namek = urli;
+			if (dst_namek==':') dst_namek='_';
+			else if (dst_namek=='/') {
+				if (!gf_dir_exists(dst_name))
+					gf_mkdir(dst_name);
+			}
+			k++;
+		}
+		sep = strrchr(item_path, '.');
+		if (sep) {
+			sep0=0;
+			if (gf_file_exists(item_path)) {
+				gf_file_move(item_path, dst_name);
+			}
+			sep0='.';
+		}
+		gf_free(dst_name);
+	}
+	gf_cfg_del(cached);
+	gf_file_delete(item_path);
+	return GF_FALSE;
+}
+
+
+typedef struct
+{
+	FILE *filep;
+	char *path;
+	Bool write;
+	u32 nb_refs;
+} FileIOCtx;
+
+static GF_List *all_gfio_defined = NULL;
+
+static GF_FileIO *fio_open(GF_FileIO *fileio_ref, const char *url, const char *mode, GF_Err *out_err);
+
+static GF_Err fio_seek(GF_FileIO *fileio, u64 offset, s32 whence)
+{
+	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
+	if (!ioctx || !ioctx->filep) return GF_BAD_PARAM;
+	gf_fseek(ioctx->filep, offset, whence);
+	return GF_OK;
+}
+static u32 fio_read(GF_FileIO *fileio, u8 *buffer, u32 bytes)
+{
+	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
+	if (!ioctx || !ioctx->filep) return 0;
+	return (u32) gf_fread(buffer, bytes, ioctx->filep);
+}
+static u32 fio_write(GF_FileIO *fileio, u8 *buffer, u32 bytes)
+{
+	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
+	if (!ioctx || !ioctx->filep) return 0;
+	if (!bytes) {
+		fflush(ioctx->filep);
+		return 0;
+	}
+	return (u32) gf_fwrite(buffer, bytes, ioctx->filep);
+}
+static s64 fio_tell(GF_FileIO *fileio)
+{
+	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
+	if (!ioctx || !ioctx->filep) return -1;
+	return gf_ftell(ioctx->filep);
+}
+static Bool fio_eof(GF_FileIO *fileio)
+{
+	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
+	if (!ioctx || !ioctx->filep) return GF_TRUE;
+	return feof(ioctx->filep);
+}
+static int fio_printf(GF_FileIO *fileio, const char *format, va_list args)
+{
+	FileIOCtx *ioctx = gf_fileio_get_udta(fileio);
+	if (!ioctx || !ioctx->filep) return -1;
+	return vfprintf(ioctx->filep, format, args);
+}
+
+#include <gpac/network.h>
+
+static GF_FileIO *fio_open(GF_FileIO *fileio_ref, const char *url, const char *mode, GF_Err *out_err)
+{
+	GF_FileIO *gfio;
+	FileIOCtx *ioctx;
+	u32 i, count;
+	u64 file_size;
+	Bool no_concatenate = GF_FALSE;
+	FileIOCtx *ioctx_ref = gf_fileio_get_udta(fileio_ref);
+
+	*out_err = GF_OK;
+
+	if (!strcmp(mode, "ref")) {
+		ioctx_ref->nb_refs++;
+		return fileio_ref;
+	}
+	if (!strcmp(mode, "unref")) {
+		if (!ioctx_ref->nb_refs) return NULL;
+		ioctx_ref->nb_refs--;
+		if (ioctx_ref->nb_refs)
+			return fileio_ref;
+
+		url = NULL;
+	}
+
+	if (!strcmp(mode, "url")) {
+		if (!url) return NULL;
+		GF_SAFEALLOC(ioctx, FileIOCtx);
+		if (!ioctx) return NULL;
+		ioctx->path = gf_url_concatenate(ioctx_ref->path, url);
+		gfio = gf_fileio_new(ioctx->path, ioctx, fio_open, fio_seek, fio_read, fio_write, fio_tell, fio_eof, fio_printf);
+		if (!gfio) {
+			if (ioctx->path) gf_free(ioctx->path);
+			gf_free(ioctx);
+			return NULL;
+		}
+		//remember it but no need to keep a ref on it
+		gf_list_add(all_gfio_defined, gfio);
+		return gfio;
+	}
+	if (!strcmp(mode, "probe")) {
+		if (!gf_file_exists(url)) *out_err = GF_URL_ERROR;
+		return NULL;
+	}
+
+	if (!url) {
+		if (ioctx_ref->filep) gf_fclose(ioctx_ref->filep);
+		ioctx_ref->filep = NULL;
+
+		if (!ioctx_ref->nb_refs) {
+			gf_list_del_item(all_gfio_defined, fileio_ref);
+			gf_fileio_del(fileio_ref);
+			if (ioctx_ref->path) gf_free(ioctx_ref->path);
+			gf_free(ioctx_ref);
+		}
+		return NULL;
+	}
+
+	//file handle not opened, we can use the current gfio
+	if (!ioctx_ref->filep && (!strnicmp(url, "gfio://", 7) || !strcmp(url, ioctx_ref->path)) ) {
+		ioctx_ref->filep = gf_fopen(ioctx_ref->path, mode);
+		if (!ioctx_ref->filep) {
+			*out_err = GF_IO_ERR;
+			return NULL;
+		}
+		file_size = gf_fsize(ioctx_ref->filep);
+		//in test mode we want to use our ftell and fseek wrappers
+		if (strchr(mode, 'r')) {
+			gf_fileio_set_stats(fileio_ref, file_size, file_size, GF_TRUE, 0);
+		}
+		return fileio_ref;
+	}
+
+	//file handle already open (file is being opened twice), create a new gfio or check if we have already created one
+	gfio = NULL;
+	ioctx = NULL;
+	count = gf_list_count(all_gfio_defined);
+	for (i=0; i<count; i++) {
+		GF_FileIO *a_gfio = gf_list_get(all_gfio_defined, i);
+		ioctx = gf_fileio_get_udta(a_gfio);
+		if (ioctx && !strcmp(ioctx->path, url)) {
+			if (ioctx->filep) {
+				no_concatenate = GF_TRUE;
+				ioctx = NULL;
+			}
+			gfio = a_gfio;
+			break;
+		}
+		ioctx = NULL;
+	}
+	if (!ioctx) {
+		GF_SAFEALLOC(ioctx, FileIOCtx);
+		if (!ioctx) {
+			*out_err = GF_OUT_OF_MEM;
+			return NULL;
+		}
+		if (strnicmp(url, "gfio://", 7)) {
+			if (no_concatenate)
+				ioctx->path = gf_strdup(url);
+			else
+				ioctx->path = gf_url_concatenate(ioctx_ref->path, url);
+		} else {
+			ioctx->path = gf_strdup(ioctx_ref->path);
+		}
+		gfio = gf_fileio_new(ioctx->path, ioctx, fio_open, fio_seek, fio_read, fio_write, fio_tell, fio_eof, fio_printf);
+		if (!gfio) {
+			if (ioctx->path) gf_free(ioctx->path);
+			gf_free(ioctx);
+			*out_err = GF_OUT_OF_MEM;
+		}
+	}
+
+	if (strnicmp(url, "gfio://", 7)) {
+		ioctx->filep = gf_fopen(ioctx->path, mode);
+	} else {
+		ioctx->filep = gf_fopen(ioctx_ref->path, mode);
+	}
+
+	if (!ioctx->filep) {
+		*out_err = GF_IO_ERR;
+		gf_list_del_item(all_gfio_defined, gfio);
+		gf_fileio_del(gfio);
+		if (ioctx->path) gf_free(ioctx->path);
+		gf_free(ioctx);
+		return NULL;
+	}
+
+	file_size = gf_fsize(ioctx->filep);
+	if (strchr(mode, 'r'))
+		gf_fileio_set_stats(gfio, file_size,file_size, GF_TRUE, 0);
+	return gfio;
+}
+
+
+static const char *make_fileio(const char *inargs, const char **out_arg, Bool is_input, GF_Err *e)
+{
+	FileIOCtx *ioctx;
+	GF_FileIO *fio;
+	char *sep = (char *) gf_url_colon_suffix(inargs, separator_set1);
+	*out_arg = NULL;
+	if (sep) sep0 = 0;
+
+	GF_SAFEALLOC(ioctx, FileIOCtx);
+	if (!ioctx) return NULL;
+	ioctx->path = gf_strdup(inargs);
+	if (!ioctx->path) {
+		gf_free(ioctx);
+		return NULL;
+	}
+	if (sep) {
+		sep0 = ':';
+		*out_arg = sep+1;
+	}
+	fio = gf_fileio_new(ioctx->path, ioctx, fio_open, fio_seek, fio_read, fio_write, fio_tell, fio_eof, fio_printf);
+	if (!fio) {
+		gf_free(ioctx->path);
+		gf_free(ioctx);
+		*e = GF_OUT_OF_MEM;
+		return NULL;
+	}
+	if (!all_gfio_defined) {
+		all_gfio_defined = gf_list_new();
+		if (!all_gfio_defined) return NULL;
+	}
+	gf_list_add(all_gfio_defined, fio);
+	//keep alive until end
+	ioctx->nb_refs = 1;
+	return gf_fileio_url(fio);
+}
+
+static void cleanup_file_io()
+{
+	if (!all_gfio_defined) return;
+	while (gf_list_count(all_gfio_defined)) {
+		GF_FileIO *gfio = gf_list_pop_back(all_gfio_defined);
+		FileIOCtx *ioctx = gf_fileio_get_udta(gfio);
+		gf_fileio_del(gfio);
+
+		if (ioctx->filep) {
+			fprintf(stderr, "Warning: file IO for %s still opened!\n", ioctx->path);
+			gf_fclose(ioctx->filep);
+		}
+		if (ioctx->path) gf_free(ioctx->path);
+		gf_free(ioctx);
+	}
+	gf_list_del(all_gfio_defined);
+	all_gfio_defined = NULL;
+}
+
+static GF_Err cust_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
+{
+	GF_FilterEvent evt;
+	if (is_remove) return GF_OK;
+
+	GF_FEVT_INIT(evt, GF_FEVT_PLAY, pid);
+	gf_filter_pid_send_event(pid, &evt);
+	gf_filter_pid_set_framing_mode(pid, GF_TRUE);
+	return GF_OK;
+}
+static GF_Err cust_process(GF_Filter *filter)
+{
+	u32 i;
+	for (i=0; i<gf_filter_get_ipid_count(filter); i++) {
+		GF_FilterPid *pid = gf_filter_get_ipid(filter, i);
+		const char *name = gf_filter_pid_get_name(pid);
+		while (1) {
+			GF_FilterPacket *pck = gf_filter_pid_get_packet(pid);
+			if (!pck) break;
+			fprintf(stderr, "PID %s Got packet CTS "LLU"\n", name, gf_filter_pck_get_cts(pck));
+			gf_filter_pid_drop_packet(pid);
+		}
+	}
+	return GF_OK;
+}
+
+static GF_Filter *load_custom_filter(GF_FilterSession *sess, char *opts, GF_Err *e)
+{
+	GF_Filter *f = gf_fs_new_filter(sess, "custom", 0, e);
+	if (!f) return NULL;
+
+	*e = gf_filter_push_caps(f, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_VISUAL), NULL, GF_CAPS_INPUT, 0);
+	if (*e) return NULL;
+	*e = gf_filter_set_configure_ckb(f, cust_configure_pid);
+	if (*e) return NULL;
+	*e = gf_filter_set_process_ckb(f, cust_process);
+	if (*e) return NULL;
+	*e = gf_filter_set_process_event_ckb(f, NULL);
+	if (*e) return NULL;
+	*e = gf_filter_set_reconfigure_output_ckb(f, NULL);
+	if (*e) return NULL;
+	*e = gf_filter_set_probe_data_cbk(f, NULL);
+	if (*e) return NULL;
+
+	return f;
+}
+
+
+/*
+	sig handler - keep this one last since it uses macros for function prototypes which breaks xcode function browsing
+*/
+static Bool prev_was_cmd=GF_FALSE;
+static Bool signal_catched=GF_FALSE;
+static Bool signal_processed=GF_FALSE;
+#ifdef WIN32
+#include <windows.h>
+static BOOL WINAPI gpac_sig_handler(DWORD sig)
+{
+	if (sig == CTRL_C_EVENT) {
+		Bool is_inter = GF_TRUE;
+#else
+#include <signal.h>
+static void gpac_sig_handler(int sig)
+{
+	if ((sig == SIGINT) || (sig == SIGTERM) || (sig == SIGABRT)) {
+		Bool is_inter = (sig == SIGINT) ? GF_TRUE : GF_FALSE;
+#endif
+		nb_loops = 0;
+		if (session) {
+			if (signal_catched) {
+				if (signal_processed) {
+					fprintf(stderr, "catched SIGINT|SIGTERM twice and session not responding, forcing exit.\n");
+				}
+				exit(1);
+			}
+
+			signal_catched = GF_TRUE;
+			if (is_inter) {
+				char input;
+				in_sig_handler = GF_TRUE;
+				fprintf(stderr, "\nToggle reports (r), or exit with fast (Y), full (f) or no (n) session flush ? \n");
+rescan:
+				input = gf_getch();
+				if (!input || input == 0x0A || input == 0x0D) input = 'Y'; // user pressed "return"
+				switch (input) {
+				case 'Y':
+				case 'y':
+					signal_processed = GF_TRUE;
+					gf_fs_abort(session, GF_FS_FLUSH_FAST);
+					break;
+				case 'F':
+				case 'f':
+					signal_processed = GF_TRUE;
+					gf_fs_abort(session, GF_FS_FLUSH_ALL);
+					break;
+				case 0:
+					break;
+				case 'x':
+					exit(0);
+					break;
+				case '\n':
+					//prev was a command, flush \n
+					if (prev_was_cmd) {
+						prev_was_cmd = GF_FALSE;
+						goto rescan;
+					}
+					break;
+
+				case 'R':
+				case 'r':
+					prev_was_cmd = GF_TRUE;
+					if (!enable_reports) {
+						enable_reports = 2;
+						report_filter = NULL;
+						gf_fs_set_ui_callback(session, gpac_event_proc, session);
+						gf_fs_enable_reporting(session, GF_TRUE);
+						in_sig_handler = GF_FALSE;
+						gpac_print_report(session, GF_TRUE, GF_FALSE);
+					} else {
+						enable_reports = 0;
+						gf_fs_enable_reporting(session, GF_FALSE);
+						gf_sys_set_console_code(stderr, GF_CONSOLE_CLEAR);
+						gf_sys_set_console_code(stderr, GF_CONSOLE_RESTORE);
+					}
+					signal_catched = GF_FALSE;
+					signal_processed = GF_FALSE;
+					break;
+				default:
+					signal_processed = GF_TRUE;
+					gf_fs_abort(session, GF_FS_FLUSH_NONE);
+					break;
+				}
+				in_sig_handler = GF_FALSE;
+			} else {
+				signal_processed = GF_TRUE;
+				gf_fs_abort(session, GF_FS_FLUSH_NONE);
+			}
+		}
+	}
+#ifdef WIN32
+	return TRUE;
+#endif
+}
+
+/*
+	Coverage
+*/
+#ifdef GPAC_ENABLE_COVERAGE
+#include <gpac/utf.h>
+#include <gpac/base_coding.h>
+#include <gpac/network.h>
+#include <gpac/iso639.h>
+#include <gpac/token.h>
+#include <gpac/xml.h>
+#include <gpac/thread.h>
+#include <gpac/avparse.h>
+#include <gpac/mpegts.h>
+#include <gpac/scenegraph_vrml.h>
+#include <gpac/rtp_streamer.h>
+#include <gpac/internal/odf_dev.h>
+#include <gpac/internal/media_dev.h>
+#include <gpac/internal/isomedia_dev.h>
+#include <gpac/path2d.h>
+#include <gpac/module.h>
+#include <gpac/crypt.h>
+#endif
+static u32 gpac_unit_tests(GF_MemTrackerType mem_track)
+{
+#ifdef GPAC_ENABLE_COVERAGE
+	u32 ucs4_buf4;
+	u32 i;
+	u8 utf8_buf7;
+
+	void *mem = gf_calloc(4, sizeof(u32));
+	gf_free(mem);
+
+	if (mem_track == GF_MemTrackerNone) return 0;
+
+	gpac_handle_prompt(NULL, 0);
+
+	gpac_fsess_task_help(); //for coverage
+	gf_dm_sess_last_error(NULL);
+	gf_log_use_color();
+	gf_4cc_parse("abcd");
+	gf_gpac_abi_micro();
+	gf_audio_fmt_get_layout_from_name("3/2.1");
+	gf_audio_fmt_get_dolby_chanmap(4);
+	gf_itags_get_id3tag(1);
+	i=0;
+	gf_itags_enum_tags(&i, NULL, NULL, NULL);
+	//functions exported for gpac_napi but we don't yet have tests for napi in testsuite
+	gf_fs_in_final_flush(NULL);
+	gf_fs_get_rt_udta(NULL);
+	gf_fs_set_external_gl_provider(NULL, NULL, NULL);
+	gf_filter_print_all_connections(NULL, NULL);
+
+	GF_LOG(GF_LOG_INFO, GF_LOG_CORE, ("CoreUnitTests performing tests\n"));
+
+	utf8_buf0 = 'a';
+	utf8_buf1 = 0;
+	if (! utf8_to_ucs4 (ucs4_buf, 1, (unsigned char *) utf8_buf)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for single char\n"));
+		return 1;
+	}
+	utf8_buf0 = 0xc2;
+	utf8_buf1 = 0xa3;
+	utf8_buf2 = 'a';
+	utf8_buf3 = 0;
+	if (! utf8_to_ucs4 (ucs4_buf, 3, (unsigned char *) utf8_buf)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 2-byte + 1-byte char\n"));
+		return 1;
+	}
+	utf8_buf0 = 0xe0;
+	utf8_buf1 = 0xa4;
+	utf8_buf2 = 0xb9;
+	utf8_buf3 = 0;
+	if (! utf8_to_ucs4 (ucs4_buf, 3, (unsigned char *) utf8_buf)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 3-byte char\n"));
+		return 1;
+	}
+	utf8_buf0 = 0xf0;
+	utf8_buf1 = 0x90;
+	utf8_buf2 = 0x8d;
+	utf8_buf3 = 0x88;
+	utf8_buf4 = 0;
+	if (! utf8_to_ucs4 (ucs4_buf, 4, (unsigned char *) utf8_buf)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 4-byte char\n"));
+		return 1;
+	}
+
+	utf8_buf0 = 0xf8;
+	utf8_buf1 = 0x80;
+	utf8_buf2 = 0x80;
+	utf8_buf3 = 0x80;
+	utf8_buf4 = 0xaf;
+	utf8_buf5 = 0;
+	if (! utf8_to_ucs4 (ucs4_buf, 5, (unsigned char *) utf8_buf)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 5-byte char\n"));
+		return 1;
+	}
+	utf8_buf0 = 0xfc;
+	utf8_buf1 = 0x80;
+	utf8_buf2 = 0x80;
+	utf8_buf3 = 0x80;
+	utf8_buf4 = 0x80;
+	utf8_buf5 = 0xaf;
+	utf8_buf6 = 0;
+	if (! utf8_to_ucs4 (ucs4_buf, 6, (unsigned char *) utf8_buf)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests UCS-4 translation failed for 6-byte char\n"));
+		return 1;
+	}
+	//test error case
+	utf8_buf0 = 0xf8;
+	utf8_to_ucs4 (ucs4_buf, 6, (unsigned char *) utf8_buf);
+
+	u8 buf5, obuf3;
+	obuf0 = 1;
+	obuf1 = 2;
+	u32 res = gf_base16_encode(obuf, 2, buf, 5);
+	if (res != 4) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests base16 encode fail\n"));
+		return 1;
+	}
+	u32 res2 = gf_base16_decode(buf, res, obuf, 3);
+	if (res2 != 2) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests base16 decode fail\n"));
+		return 1;
+	}
+
+	u8 *zbuf;
+	u32 osize;
+	GF_Err e;
+	u8 *ozbuf;
+
+#ifndef GPAC_DISABLE_ZLIB
+	zbuf = (u8 *) gf_strdup("123451234512345123451234512345");
+	osize=0;
+	e = gf_gz_compress_payload(&zbuf, 1 + (u32) strlen((char*)zbuf), &osize);
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests zlib compress fail\n"));
+		gf_free(zbuf);
+		return 1;
+	}
+	ozbuf=NULL;
+	res=0;
+	e = gf_gz_decompress_payload(zbuf, osize, &ozbuf, &res);
+	gf_free(zbuf);
+	if (ozbuf) gf_free(ozbuf);
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests zlib decompress fail\n"));
+		return 1;
+	}
+#endif
+
+	zbuf = (u8 *)gf_strdup("123451234512345123451234512345");
+	osize=0;
+	e = gf_lz_compress_payload(&zbuf, 1+(u32) strlen((char*)zbuf), &osize);
+	if (e && (e!= GF_NOT_SUPPORTED)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests lzma compress fail\n"));
+		gf_free(zbuf);
+		return 1;
+	}
+	ozbuf=NULL;
+	res=0;
+	e = gf_lz_decompress_payload(zbuf, osize, &ozbuf, &res);
+	gf_free(zbuf);
+	if (ozbuf) gf_free(ozbuf);
+	if (e && (e!= GF_NOT_SUPPORTED)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests lzma decompress fail\n"));
+		return 1;
+	}
+
+	gf_htonl(0xAABBCCDD);
+	gf_ntohl(0xAABBCCDD);
+	gf_htons(0xAABB);
+	gf_ntohs(0xAABB);
+	gf_errno_str(-1);
+
+	gf_prompt_set_echo_off(GF_FALSE);
+	gf_getch();
+	gf_prompt_get_char();
+	gf_read_line_input(utf8_buf, 7, 1);
+
+	gf_net_set_ntp_shift(-1000);
+	gf_net_get_ntp_diff_ms(gf_net_get_ntp_ts() );
+	gf_net_get_timezone();
+	gf_net_get_utc_ts(70, 1, 0, 0, 0, 0);
+	gf_net_ntp_diff_ms(1000000, 1000000);
+	gf_lang_get_count();
+	gf_lang_get_2cc(2);
+	GF_Blob b;
+	memset(&b, 0, sizeof(GF_Blob));
+	b.data = (u8 *) "test";
+	b.size = 5;
+	char url100, *burl;
+	u8 *data;
+	u32 size;
+
+	burl = gf_blob_register(&b);
+	gf_sys_profiler_set_callback(NULL, NULL);
+
+	gf_blob_get(burl, &data, &size, NULL);
+	gf_blob_unregister(&b);
+	gf_free(burl);
+
+	if (!data || strcmp((char *)data, "test")) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CoreUnitTests blob url parsing fail\n"));
+		return 1;
+	}
+	gf_sys_get_battery_state(NULL, NULL, NULL, NULL, NULL);
+	gf_sys_get_process_id();
+	data = (u8 *) gf_log_get_tools_levels();
+	if (data) gf_free(data);
+
+	gf_sys_is_quiet();
+	gf_sys_get_argv();
+	gf_mx_get_num_locks(NULL);
+	signal_catched = GF_TRUE;
+
+	gf_url_is_relative("./");
+
+	//test ECB (no test using ECB decrypt)
+	bin128 master_key;
+	memset(master_key, 0, sizeof(bin128));
+	GF_Crypt *crypto = gf_crypt_open(GF_AES_128, GF_ECB);
+	gf_crypt_init(crypto, master_key, master_key);
+	gf_crypt_encrypt(crypto, master_key, 16);
+	gf_crypt_decrypt(crypto, master_key, 16);
+	gf_crypt_set_IV(crypto, master_key, 16);
+	u32 ivsize=16;
+	gf_crypt_get_IV(crypto, master_key, &ivsize);
+	gf_crypt_close(crypto);
+
+
+#ifdef WIN32
+	gpac_sig_handler(CTRL_C_EVENT);
+#else
+	gpac_sig_handler(SIGINT);
+	gpac_sig_handler(SIGTERM);
+#endif
+
+	gf_mkdir("testdir");
+	gf_mkdir("testdir/somedir");
+	strcpy(url, "testdir/somedir/test.bin");
+	FILE *f=gf_fopen(url, "wb");
+	fprintf(f, "some test\n");
+#ifdef GPAC_MEMORY_TRACKING
+	gf_memory_print();
+#endif
+	gf_fclose(f);
+	gf_file_modification_time(url);
+	gf_m2ts_probe_file(url);
+
+	gf_dir_cleanup("testdir");
+	gf_rmdir("testdir");
+
+	//math.c not covered yet by our sample files
+	GF_Matrix2D mx;
+	gf_mx2d_init(mx);
+	gf_mx2d_add_skew(&mx, FIX_ONE, FIX_ONE);
+	gf_mx2d_add_skew_x(&mx, GF_PI/4);
+	gf_mx2d_add_skew_y(&mx, GF_PI/4);
+	GF_Point2D scale, translate;
+	Fixed rotate;
+	gf_mx2d_decompose(&mx, &scale, &rotate, &translate);
+	GF_Rect rc1, rc2;
+	memset(&rc1, 0, sizeof(GF_Rect));
+	memset(&rc2, 0, sizeof(GF_Rect));
+	gf_rect_equal(&rc1, &rc2);
+
+	GF_Matrix mat;
+	gf_mx_init(mat);
+	Fixed yaw, pitch, roll;
+	gf_mx_get_yaw_pitch_roll(&mat, &yaw, &pitch, &roll);
+	gf_mx_ortho_reverse_z(&mat, -20, 20, -20, 20, 0.1, 100.0);
+	gf_mx_perspective_reverse_z(&mat, 0.76, 1.0, 0.1, 100.0);
+
+	GF_Ray ray;
+	GF_Vec center, outPoint;
+	memset(&ray, 0, sizeof(GF_Ray));
+	ray.dir.z = FIX_ONE;
+	memset(&center, 0, sizeof(GF_Vec));
+	gf_ray_hit_sphere(&ray, &center, FIX_ONE, &outPoint);
+
+	gf_closest_point_to_line(center, ray.dir, center);
+
+	GF_Plane plane;
+	plane.d = FIX_ONE;
+	plane.normal = center;
+	gf_plane_intersect_line(&plane, &center, &ray.dir, &outPoint);
+
+	GF_Vec4 rot, quat;
+	rot.x = rot.y = 0;
+	rot.z = FIX_ONE;
+	rot.q = GF_PI/4;
+	quat = gf_quat_from_rotation(rot);
+	gf_quat_get_inv(&quat);
+	gf_quat_rotate(&quat, &ray.dir);
+	gf_quat_slerp(quat, quat, FIX_ONE/2);
+	GF_BBox bbox;
+	memset(&bbox, 0, sizeof(GF_BBox));
+	gf_bbox_equal(&bbox, &bbox);
+
+	bbox.min_edge.x=-1;
+	bbox.max_edge.x=1;
+	gf_bbox_refresh(&bbox);
+	gf_mx_apply_bbox_4x4(&mat, &bbox);
+
+
+	GF_Vec v;
+	v.x = v.y = v.z = 0;
+	gf_vec_scale_p(&v, 2*FIX_ONE);
+
+	//token.c
+	char container1024;
+	gf_token_get_strip("12 34{ 56 : }", 0, "{:", " ", container, 1024);
+
+	//netwok.c
+	char nameGF_MAX_IP_NAME_LEN;
+	gf_sk_get_host_name(name);
+	gf_sk_set_usec_wait(NULL, 1000);
+	u32 fam;
+	u16 port;
+	//to remove once we have rtsp server back
+	gf_sk_get_local_info(NULL, &port, &fam);
+
+	//path2D
+	GF_Path *path = gf_path_new();
+	gf_path_add_move_to(path, 0, 0);
+	gf_path_add_quadratic_to(path, 5, 5, 10, 0);
+	gf_path_point_over(path, 4, 0);
+	gf_path_del(path);
+
+	//xml dom - to update once we find a way to integrate atsc demux in tests
+	GF_DOMParser *dom = gf_xml_dom_new();
+	gf_xml_dom_parse_string(dom, "<Dummy>test</Dummy>");
+	gf_xml_dom_get_error(dom);
+	gf_xml_dom_get_line(dom);
+	gf_xml_dom_get_root_nodes_count(dom);
+	gf_xml_dom_del(dom);
+
+	//downloader - to update once we find a way to integrate atsc demux in tests
+	GF_DownloadManager *dm = gf_dm_new(NULL);
+	gf_dm_set_auth_callback(dm, NULL, NULL);
+
+	gf_dm_set_data_rate(dm, 0);
+	gf_dm_get_data_rate(dm);
+	gf_dm_set_localcache_provider(dm, NULL, NULL);
+	gf_dm_sess_abort(NULL);
+	gf_dm_del(dm);
+
+	//constants
+	gf_stream_type_afx_name(GPAC_AFX_3DMC);
+	//thread
+	gf_th_stop(NULL);
+	gf_list_swap(NULL, NULL);
+	//bitstream
+	GF_BitStream *bs = gf_bs_new((u8 *)"test", 4, GF_BITSTREAM_READ);
+	gf_bs_bits_available(bs);
+	gf_bs_get_bit_offset(bs);
+	gf_bs_read_vluimsbf5(bs);
+	gf_bs_del(bs);
+	//module
+	gf_module_load_static(NULL);
+
+	gf_mp3_version_name(0);
+	u8 tsbuf188;
+	u8 is_pesGF_M2TS_MAX_STREAMS;
+	memset(is_pes, 1, sizeof(u8)*GF_M2TS_MAX_STREAMS);
+	memset(tsbuf, 0, 188);
+	tsbuf0 = 0x47;
+	tsbuf1 = 0x40;
+	tsbuf4=0x00;
+	tsbuf5=0x00;
+	tsbuf6=0x01;
+	tsbuf10 = 0x80;
+	tsbuf11 = 0xc0;
+	tsbuf13 = 0x2 << 4;
+	gf_m2ts_restamp(tsbuf, 188, 1000, is_pes);
+
+
+	gf_filter_post_task(NULL,NULL,NULL,NULL);
+	gf_filter_get_arg_str(NULL, NULL, NULL);
+	gf_filter_all_sinks_done(NULL);
+
+	gf_opts_discard_changes();
+
+	gf_rtp_reset_ssrc(NULL);
+	gf_rtp_enable_nat_keepalive(NULL, 0);
+	gf_rtp_stop(NULL);
+	gf_rtp_streamer_get_payload_type(NULL);
+	gf_rtsp_unregister_interleave(NULL, 0);
+	gf_rtsp_reset_aggregation(NULL);
+
+	get_cmd('h');
+	gpac_suggest_arg("blcksize");
+	gpac_suggest_filter("outf", GF_FALSE, GF_FALSE);
+	//todo: build tests for these two
+	gf_filter_pid_negociate_property_str(NULL, NULL, NULL);
+	gf_filter_pid_negociate_property_dyn(NULL, NULL, NULL);
+
+	gf_props_parse_type("uint");
+	//this one is just a wrapper around an internal function
+	gf_filter_pck_new_copy(NULL, NULL, NULL);
+	gf_filter_get_max_extra_input_pids(NULL);
+	gf_filter_remove(NULL);
+	gf_filter_reconnect_output(NULL, NULL);
+	gf_filter_pid_get_udta_flags(NULL);
+
+	gf_audio_fmt_get_cicp_layout(4, 1, 1);
+	gf_audio_fmt_get_layout_from_cicp(3);
+	gf_audio_fmt_get_layout_name_from_cicp(3);
+	gf_audio_fmt_get_cicp_from_layout(GF_AUDIO_CH_FRONT_LEFT|GF_AUDIO_CH_FRONT_RIGHT);
+
+	//old bifs parsing stuff
+	gf_odf_desc_del(gf_odf_desc_new(GF_ODF_ELEM_MASK_TAG));
+	GF_TextConfig *txtc = (GF_TextConfig *)gf_odf_desc_new(GF_ODF_TEXT_CFG_TAG);
+	gf_odf_get_text_config(NULL, 0, 0, txtc);
+	gf_odf_dump_txtcfg(txtc, NULL, 0, GF_FALSE);
+	gf_odf_desc_del((GF_Descriptor *) txtc);
+
+	//stuff only used by vtbdec
+	gf_hevc_read_pps_bs(NULL, NULL);
+	gf_hevc_read_sps_bs(NULL, NULL);
+	gf_hevc_read_vps_bs(NULL, NULL);
+	gf_mpegv12_get_config(NULL, 0, NULL);
+
+	//hinting stuff
+	GF_HintPacket *hpck = gf_isom_hint_pck_new(GF_ISOM_BOX_TYPE_RTCP_STSD);
+	gf_isom_hint_pck_length(hpck);
+	gf_isom_hint_pck_size(hpck);
+	GF_BitStream *hbs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+	gf_isom_hint_pck_write(hpck, hbs);
+	u8 *hbuf;
+	u32 hsize;
+	gf_bs_get_content(hbs, &hbuf, &hsize);
+	gf_bs_del(hbs);
+	hbs = gf_bs_new(hbuf, hsize, GF_BITSTREAM_READ);
+	gf_isom_hint_pck_read(hpck, hbs);
+	gf_bs_del(hbs);
+	gf_free(hbuf);
+	gf_isom_hint_pck_del(hpck);
+
+	gf_isom_last_error(NULL);
+	gf_isom_get_media_time(NULL, 0, 0, NULL);
+	gf_isom_get_sample_description_index(NULL, 0, 0);
+
+	gf_sg_has_scripting();
+	gf_node_get_proto_root(NULL);
+	gf_node_proto_is_grouping(NULL);
+	gf_sg_proto_get_id(NULL);
+	gf_sg_proto_instance_set_ised(NULL, 0, NULL, 0);
+
+	gf_audio_fmt_to_isobmf(0);
+	gf_pixel_fmt_probe(0, NULL);
+	gf_net_ntp_to_utc(0);
+	gf_sys_profiler_sampling_enabled();
+
+
+#endif
+	return 0;
+}
+
+#include <gpac/token.h>
+
+static void to_hex(u8 *data, u32 len, char *out)
+{
+	u32 i;
+	out0 = 0;
+	for (i=0; i<len; i++) {
+		sprintf(out + 2*i, "%02x", datai);
+	}
+	out2*i=0;
+}
+
+#ifndef GPAC_64_BITS
+#define PTR_INT (u64) (u32)
+#else
+#define PTR_INT (u64)
+#endif
+
+static u64 creds_set_pass(GF_Config *creds, const char *user, const char *passwd)
+{
+	u8 *pass;
+	char szVAL100;
+	u8 hashGF_SHA256_DIGEST_SIZE;
+	u8 saltGF_SHA256_DIGEST_SIZE;
+	u64 v1, v2, v3, v4;
+	v1 = gf_rand(); v1<<=32; v1 |= gf_rand();
+	v1 |= gf_sys_clock_high_res();
+	v2 = gf_rand(); v2<<=32; v2 |= gf_rand();
+	v2 |= PTR_INT creds;
+	v3 = gf_rand(); v3<<=32; v3 |= gf_rand();
+	v3 |= PTR_INT creds_set_pass;
+	v4 = gf_rand(); v4<<=32; v4 |= gf_rand();
+	v4 |= PTR_INT to_hex;
+
+	* ((u64*) &salt0) = v1;
+	* ((u64*) &salt8) = v2;
+	* ((u64*) &salt16) = v3;
+	* ((u64*) &salt24) = v4;
+
+	u32 len = (u32) strlen(passwd);
+	pass = gf_malloc(len+GF_SHA256_DIGEST_SIZE+1);
+	memcpy(pass, passwd, len);
+	passlen = '@';
+	memcpy(pass + len + 1, salt, GF_SHA256_DIGEST_SIZE);
+	len += GF_SHA256_DIGEST_SIZE+1;
+	gf_sha256_csum(pass, len, hash);
+	to_hex(hash, GF_SHA256_DIGEST_SIZE, szVAL);
+	gf_cfg_set_key(creds, user, "password", szVAL);
+	to_hex(salt, GF_SHA256_DIGEST_SIZE, szVAL);
+	gf_cfg_set_key(creds, user, "salt", szVAL);
+
+	u64 now = gf_sys_clock_high_res();
+	sprintf(szVAL, LLU, now);
+	gf_cfg_set_key(creds, user, "pass_date", szVAL);
+	return now;
+}
+
+static void rem_user_from_group(GF_Config *creds, const char *group, const char *user)
+{
+	char *g = (char *) gf_cfg_get_key(creds, "groups", group);
+	char *grp=NULL;
+	while (g) {
+		char *sep = strchr(g, ',');
+		if (sep) sep0 = 0;
+		if (strcmp(user, g))
+			gf_dynstrcat(&grp, g, ",");
+		if (!sep) break;
+		sep0 = ',';
+		g = sep+1;
+	}
+	if (grp) {
+		gf_cfg_set_key(creds, "groups", group, grp);
+		gf_free(grp);
+	} else {
+		gf_cfg_set_key(creds, "groups", group, "");
+	}
+}
+static int gpac_do_creds(char *creds_args)
+{
+	GF_Config *creds = NULL;
+
+	const char *cred_file = gf_opts_get_key("core", "users");
+	if (!cred_file) {
+		char credFilePathGF_MAX_PATH;
+		const char *p = gf_opts_get_filename();
+		if (!p) {
+			fprintf(stderr, "Failed to locate profile directory\n");
+			goto err_exit;
+		}
+
+		strcpy(credFilePath, p);
+		char *sep = strrchr(credFilePath, '/');
+		if (!sep) sep = strrchr(credFilePath, '\\');
+		if (sep) sep0 = 0;
+		strcat(credFilePath, "/users.cfg");
+		gf_opts_set_key("core", "users", credFilePath);
+		gf_opts_save();
+		cred_file = gf_opts_get_key("core", "users");
+		if (!cred_file) {
+			fprintf(stderr, "Failed to create credential file %s\n", credFilePath);
+			goto err_exit;
+		}
+	}
+
+	if (!creds_args || !strcmp(creds_args, "show")) {
+		if (gf_file_exists(cred_file)) {
+			u8 *cdata=NULL;
+			u32 clen;
+			gf_file_load_data(cred_file, &cdata, &clen);
+			fwrite(cdata, clen, 1, stdout);
+			gf_free(cdata);
+		} else {
+			fprintf(stdout, "Empty creds file %s\n", cred_file);
+		}
+		goto exit;
+	}
+	if (!strcmp(creds_args, "reset")) {
+		fprintf(stdout, "Deleting creds file %s\n", cred_file);
+		goto exit;
+	}
+
+	creds = gf_cfg_force_new(NULL, cred_file);
+	if (!creds) {
+		fprintf(stderr, "Failed to open creds file %s\n", cred_file);
+		goto err_exit;
+	}
+	Bool is_group=GF_FALSE;
+	u32 is_add=0;
+	Bool is_rem=GF_FALSE;
+	if (creds_args0 == '@') { is_group = GF_TRUE; creds_args++; }
+	if (creds_args0 == '+') { is_add = 1; creds_args++;}
+	if (creds_args0 == '_') { is_add = 2; creds_args++; }
+	if (creds_args0 == '-') { is_rem = GF_TRUE; creds_args++;}
+
+	char *param = strchr(creds_args, ':');
+	if (param) {
+		param0 = 0;
+	}
+
+	if (is_group) {
+		if (is_rem) {
+			if (!strcmp(creds_args, "users")) {
+				fprintf(stderr, "Cannot remove group users\n");
+				goto err_exit;
+			}
+			char *g = (char *) gf_cfg_get_key(creds, "groups", creds_args);
+			if (g == NULL) {
+				fprintf(stderr, "No such group %s\n", creds_args);
+				goto err_exit;
+			}
+			if (param) {
+				param++;
+				char *user = (char *) gf_token_find_word(g, param, ",");
+				if (!user) {
+					fprintf(stdout, "user %s not member of group %s\n", param, creds_args);
+					goto err_exit;
+				}
+				rem_user_from_group(creds, creds_args, param);
+			} else {
+				fprintf(stdout, "Deleting group %s\n", creds_args);
+				gf_cfg_set_key(creds, "groups", creds_args, NULL);
+			}
+		}
+		else if (is_add) {
+			char *grp = NULL;
+			if (param) {
+				param++;
+				while (param) {
+					char *sep = strchr(param, ',');
+					if (sep) sep0 = 0;
+					const char *u = gf_cfg_get_key(creds, param, "password");
+					if (!u) {
+						fprintf(stderr, "No user %s defined, not adding to group\n", param);
+					} else {
+						gf_dynstrcat(&grp, param, ",");
+					}
+					if (!sep) break;
+					param = sep+1;
+				}
+			}
+			if (grp) {
+				gf_cfg_set_key(creds, "groups", creds_args, grp);
+				gf_free(grp);
+			} else {
+				gf_cfg_set_key(creds, "groups", creds_args, "");
+			}
+		} else {
+			const char *g = gf_cfg_get_key(creds, "groups", creds_args);
+			if (g) {
+				fprintf(stdout, "Users in group: %s\n", g);
+			} else {
+				fprintf(stdout, "No such group %s\n", creds_args);
+				goto err_exit;
+			}
+		}
+		goto exit;
+	}
+
+	u32 keys = gf_cfg_get_key_count(creds, creds_args);
+	if (!keys && !is_add) {
+		fprintf(stderr, "No such user %s\n", creds_args);
+		goto err_exit;
+	}
+
+	//user add
+	if ((is_add==1) || ((is_add==2) && !param)) {
+		char szP1117;
+		char szP2117;
+		u64 now = gf_net_get_utc();
+
+		const char *pass = gf_cfg_get_key(creds, creds_args, "password");
+		if (!pass || (is_add==2)) {
+
+			if (pass) {
+				fprintf(stderr, "Enter old password for %s\n", creds_args);
+				if (!gf_read_line_input(szP2, 100, 0))
+					goto err_exit;
+				fprintf(stderr, "*********\n");
+
+				if (gf_creds_check_password(creds_args, szP2)!=GF_OK) {
+					fprintf(stderr, "Wrong password\n");
+					goto err_exit;
+				}
+			}
+
+			fprintf(stderr, "Enter new password for %s\n", creds_args);
+			if (!gf_read_line_input(szP1, 100, 0))
+				goto err_exit;
+			fprintf(stderr, "*********\n");
+			if (strlen(szP1)<8) {
+				fprintf(stderr, "passwords must be at least 8 characters\n");
+				goto err_exit;
+			}
+			fprintf(stderr, "Re-enter new password for %s\n", creds_args);
+			if (!gf_read_line_input(szP2, 100, 0))
+				goto err_exit;
+			fprintf(stderr, "*********\n");
+			if (strcmp(szP1, szP2)) {
+				fprintf(stderr, "passwords do not match\n");
+				goto err_exit;
+			}
+
+			now = creds_set_pass(creds, creds_args, szP2);
+		} else {
+			fprintf(stderr, "Updating user \"%s\" information\n", creds_args);
+		}
+
+		const char *val;
+#define UPDATE_FIELD(_prompt, _key) \
+		val = gf_cfg_get_key(creds, creds_args, _key);\
+		if (!val) val="";\
+		fprintf(stderr, "\nEnter %s (%s): \n", _prompt, val);\
+		if (gf_read_line_input(szP1, 50, 1) && szP10) \
+			gf_cfg_set_key(creds, creds_args, _key, szP1); \
+
+
+		UPDATE_FIELD("first name", "first_name")
+		UPDATE_FIELD("last name", "last_name")
+		UPDATE_FIELD("email", "email")
+		UPDATE_FIELD("company", "company")
+
+		if (!pass) {
+			sprintf(szP1, LLU, now);
+			gf_cfg_set_key(creds, creds_args, "created", szP1);
+		}
+
+		gf_opts_save();
+
+		const char *g = gf_cfg_get_key(creds, "groups", "users");
+		if (!gf_token_find_word(g, creds_args, ",")) {
+			char *newg = NULL;
+			if (g) gf_dynstrcat(&newg, g, NULL);
+			gf_dynstrcat(&newg, creds_args, ",");
+			gf_cfg_set_key(creds, "groups", "users", newg);
+			gf_free(newg);
+		}
+	} else if (is_rem) {
+		fprintf(stdout, "Deleting user \"%s\"\n", creds_args);
+		gf_cfg_del_section(creds, creds_args);
+		u32 i, count = gf_cfg_get_key_count(creds, "groups");
+		for (i=0; i<count; i++) {
+			const char *group = gf_cfg_get_key_name(creds, "groups", i);
+			rem_user_from_group(creds, group, creds_args);
+		}
+	} else if (!param) {
+		fprintf(stdout, "User \"%s\" information:\n", creds_args);
+		u32 i, count = gf_cfg_get_key_count(creds, creds_args);
+		for (i=0; i<count; i++) {
+			const char *k = gf_cfg_get_key_name(creds, creds_args, i);
+			if (!strcmp(k, "password")) continue;
+			if (!strcmp(k, "salt")) continue;
+			u32 klen = (u32) strlen(k) + 1;
+
+			fprintf(stdout, "%s: ", k);
+			while (klen<15) {
+				fprintf(stdout, " ");
+				klen++;
+			}
+
+			if (!strcmp(k, "created") || !strcmp(k, "pass_date") || !strcmp(k, "last_auth")) {
+				u64 val;
+				const char *sval = gf_cfg_get_key(creds, creds_args, k);
+				if (!sval) continue;
+				sscanf(sval, LLU, &val);
+				print_date_ex(val, GF_TRUE);
+				continue;
+			}
+			fprintf(stdout, "%s\n", gf_cfg_get_key(creds, creds_args, k));
+		}
+		Bool first=GF_TRUE;
+		count = gf_cfg_get_key_count(creds, "groups");
+		for (i=0; i<count; i++) {
+			const char *gname = gf_cfg_get_key_name(creds, "groups", i);
+			const char *g = gf_cfg_get_key(creds, "groups", gname);
+			if (!gf_token_find_word(g, creds_args, ",")) continue;
+			if (first) {
+				fprintf(stdout, "In groups: ");
+				first = GF_FALSE;
+			}
+			fprintf(stdout, " %s", gname);
+		}
+		if (!first) fprintf(stdout, "\n");
+	}
+
+	if (!is_rem && param) {
+		param++;
+		while (param) {
+			char *sep = strchr(param, ':');
+			if (sep) sep0 = 0;
+			char *sep2 = strchr(param, '=');
+			if (sep2) {
+				sep20 = 0;
+				if (!strcmp(param, "salt")
+					|| !strcmp(param, "created")
+					|| !strcmp(param, "pass_date")
+					|| !strcmp(param, "last_auth")
+				) {
+					fprintf(stderr, "Cannot modify %s (reserved value)\n", param);
+					sep20 = '=';
+					if (sep) sep0 = ':';
+					goto err_exit;
+				}
+				else if (!strcmp(param, "password")) {
+					creds_set_pass(creds, creds_args, sep2+1);
+				} else {
+					gf_cfg_set_key(creds, creds_args, param, sep2+1);
+				}
+				sep20 = '=';
+			}
+			if (!sep) break;
+			sep0 = ':';
+			param = sep+1;
+		}
+	}
+
+
+exit:
+	if (creds) {
+		gf_cfg_save(creds);
+		gf_cfg_del(creds);
+	}
+	return 0;
+
+
+err_exit:
+	if (creds) gf_cfg_del(creds);
+	return 1;
+}

gpac-2.2.0.tar.gz/applications/gpac/gpac.h Added

@@ -0,0 +1,96 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / gpac application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <gpac/filters.h>
+#include <gpac/events.h>
+
+#ifndef GPAC_CONFIG_ANDROID
+
+//gpac is loaded using sink compositor in base player mode (-mp4c) with a custum event proc
+#define LOAD_MP4C		1
+//gpac is loaded with gui
+#define LOAD_GUI		2
+//gpac is loaded with gui from env var GPAC_GUI (OSX only for now)
+#define LOAD_GUI_ENV	3
+//gpac is loaded with gui but uses event proc (ios only for now)
+#define LOAD_GUI_CBK	4
+
+u32 get_u32(char *val, char *log_name);
+s32 get_s32(char *val, char *log_name);
+
+
+void load_compositor(GF_Filter *f);
+void unload_compositor(void);
+Bool mp4c_event_proc(void *ptr, GF_Event *evt);
+Bool mp4c_parse_arg(char *arg, char *arg_val);
+Bool mp4c_handle_prompt(u8 char_val);
+Bool mp4c_task(void );
+void mp4c_help(u32 argmode);
+
+#endif
+
+
+//if uncommented, check argument description matches our conventions - see filter.h
+#define CHECK_DOC
+
+#define SEP_LINK	5
+#define SEP_FRAG	2
+#define SEP_LIST	3
+
+#include <gpac/main.h>
+
+void gpac_filter_help(void);
+void gpac_modules_help(void);
+void gpac_alias_help(GF_SysArgMode argmode);
+void gpac_credentials_help(GF_SysArgMode argmode);
+void gpac_core_help(GF_SysArgMode mode, Bool for_logs);
+void gpac_usage(GF_SysArgMode argmode);
+void gpac_config_help(void);
+void gpac_suggest_arg(char *aname);
+void gpac_suggest_filter(char *fname, Bool is_help, Bool filter_only);
+void gpac_check_session_args(void);
+int gpac_make_lang(char *filename);
+Bool gpac_expand_alias(int o_argc, char **o_argv);
+void gpac_load_suggested_filter_args(void);
+void dump_all_props(char *pname);
+void dump_all_colors(void);
+void dump_all_audio_cicp(void);
+void dump_all_codecs(GF_SysArgMode argmode);
+void dump_all_formats(GF_SysArgMode argmode);
+void dump_all_proto_schemes(GF_SysArgMode argmode);
+
+void write_core_options(void );
+void write_file_extensions(void );
+void write_filters_options(void);
+Bool print_filters(int argc, char **argv, GF_SysArgMode argmode);
+void parse_sep_set(const char *arg, Bool *override_seps);
+
+
+#if defined(GPAC_CONFIG_DARWIN) && !defined(GPAC_CONFIG_IOS)
+void carbon_remove_hook(void);
+void carbon_set_hook(void);
+#endif
+
+void gpac_open_urls(const char *urls);

gpac-2.2.0.tar.gz/applications/gpac/gpac.rc Added

@@ -0,0 +1,72 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "windows.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// Français (France) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
+#ifdef _WIN32
+LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""windows.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ICON3               ICON                    "..\\..\\share\\doc\\gpac.ico"
+#endif    // Français (France) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

gpac-2.2.0.tar.gz/applications/gpac/gpac_help.c Added

@@ -0,0 +1,3389 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2017-2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / gpac application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+
+#include <gpac/filters.h>
+#include "gpac.h"
+
+extern FILE *sidebar_md;
+extern FILE *helpout;
+extern u32 gen_doc;
+extern u32 help_flags;
+extern u32 list_filters;
+extern GF_FilterSession *session;
+extern char separator_set7;
+extern const char *auto_gen_md_warning;
+extern u32 print_filter_info;
+extern int alias_argc;
+extern char **alias_argv;
+extern GF_List *args_used;
+extern GF_List *args_alloc;
+extern u32 compositor_mode;
+#define SEP_LIST	3
+
+
+#ifndef GPAC_DISABLE_DOC
+const char *gpac_doc =
+"# Overview\n"
+"Filters are configurable processing units consuming and producing data packets. These packets are carried "
+"between filters through a data channel called __PID__. A PID is in charge of allocating/tracking data packets, "
+"and passing the packets to the destination filter(s). A filter output PID may be connected to zero or more filters. "
+"This fan-out is handled internally by GPAC (no such thing as a tee filter in GPAC).\n"
+"Note: When a PID cannot be connected to any filter, a warning is thrown and all packets dispatched on "
+"this PID will be destroyed. The session may however still run, unless -full-link(CORE) is set.\n"
+" \nEach output PID carries a set of properties describing the data it delivers (e.g. __width__, __height__, __codec__, ...). Properties "
+"can be built-in (see gpac -h props(filters_properties) ), or user-defined. Each PID tracks "
+"its properties changes and triggers filter reconfiguration during packet processing. This allows the filter chain to be "
+"reconfigured at run time, potentially reloading part of the chain (e.g. unload a video decoder when switching from compressed "
+"to uncompressed sources).\n"
+" \nEach filter exposes a set of argument to configure itself, using property types and values described as strings formatted with "
+"separators. This help is given with default separator sets `:=#,@` to specify filters, properties and options. Use -seps(GPAC) to change them.\n"
+"# Property and filter option format\n"
+"- boolean: formatted as `yes`,`true`,`1` or `no`,`false`,`0`\n"
+"- enumeration (for filter arguments only): must use the syntax given in the argument description, otherwise value `0` (first in enum) is assumed.\n"
+"- 1-dimension (numbers, floats, ints...): formatted as `valueunit`, where `unit` can be `k`,`K` (x 1000) or `m`,`M` (x 1000000) or `g`,`G` (x 1000000000) or `sec` (x 1000) or `min` (x 60000). `+I` means max float/int/uint value, `-I` min float/int/uint value.\n"
+"- fraction: formatted as `num/den` or `num-den` or `num`, in which case the denominator is 1 if `num` is an integer, or 1000000 if `num` is a floating-point value.\n"
+"- unsigned 32 bit integer: formatted as number or hexadecimal using the format `0xAABBCCDD`.\n"
+"- N-dimension (vectors): formatted as `DIM1xDIM2xDIM3xDIM4` values, without unit multiplier.\n"
+" - For 2D integer vectors, the following resolution names can be used: `360`, `480`, `576`, `720`, `1080`, `hd`, `2k`, `2160`, `4k`, `4320`, `8k`\n"
+"- string: formatted as:\n"
+" - `value`: copies value to string.\n"
+" - `file@FILE`: load string from local `FILE` (opened in binary mode).\n"
+" - `bxml@FILE`: binarize XML from local `FILE` and set property type to data - see https://wiki.gpac.io/NHML-Format.\n"
+"- data: formatted as:\n"
+" - `size@address`: constant data block, not internally copied; `size` gives the size of the block, `address` the data pointer.\n"
+" - `0xBYTESTRING`: data block specified in hexadecimal, internally copied.\n"
+" - `file@FILE`: load data from local `FILE` (opened in binary mode).\n"
+" - `bxml@FILE`: binarize XML from local `FILE` - see https://wiki.gpac.io/NHML-Format.\n"
+" - `b64@DATA`: load data from base-64 encoded `DATA`.\n"
+"- pointer: pointer address as formatted by `%p` in C.\n"
+"- string lists: formatted as `val1,val2,...`. Each value can also use `file@FILE` syntax.\n"
+"- integer lists: formatted as `val1,val2,...`\n"
+"Note: The special characters in property formats (0x,/,-,+I,-I,x) cannot be configured.\n"
+"# Filter declaration __FILTER__\n"
+"## Generic declaration\n"
+"Each filter is declared by its name, with optional filter arguments appended as a list of colon-separated `name=value` pairs. Additional syntax is provided for:\n"
+"- boolean: `value` can be omitted, defaulting to `true` (e.g. `:noedit`). Using `!` before the name negates the result (e.g. `:!moof_first`)\n"
+"- enumerations: name can be omitted, e.g. `:disp=pbo` is equivalent to `:pbo`.\n"
+"\n \n"
+"When string parameters are used (e.g. URLs), it is recommended to escape the string using the keyword `gpac`. \n"
+"EX filter:ARG=http://foo/bar?yes:gpac:opt=VAL\n"
+"This will properly extract the URL.\n"
+"EX filter:ARG=http://foo/bar?yes:opt=VAL\n"
+"This will fail to extract it and keep `:opt=VAL` as part of the URL.\n"
+"The escape mechanism is not needed for local source, for which file existence is probed during argument parsing. "
+"It is also not needed for builtin protocol handlers (`avin://`, `video://`, `audio://`, `pipe://`)\n"
+"For `tcp://` and `udp://` protocols, the escape is not needed if a trailing `/` is appended after the port number.\n"
+"EX -i tcp://127.0.0.1:1234:OPT\n"
+"This will fail to extract the URL and options.\n"
+"EX -i tcp://127.0.0.1:1234/:OPT\n"
+"This will extract the URL and options.\n"
+"Note: one trick to avoid the escape sequence is to declare the URLs option at the end, e.g. `f1:opt1=foo:url=http://bar`, provided you have only one URL parameter to specify on the filter.\n"
+"\n"
+"It is possible to disable option parsing (for string options) by duplicating the separator.\n"
+"EX filter::opt1=UDP://IP:PORT/:someopt=VAL::opt2=VAL2\n"
+"This will pass `UDP://IP:PORT/:someopt=VAL` to `opt1` without inspecting it, and `VAL2` to `opt2`.\n"
+" \n"
+"## Source and Sink filters\n"
+"Source and sink filters do not need to be addressed by the filter name, specifying `src=` or `dst=` instead is enough. "
+"You can also use the syntax `-src URL` or `-i URL` for sources and `-dst URL` or `-o URL` for destination, this allows prompt completion in shells.\n"
+"EX \"src=file.mp4\" or \"-src file.mp4\" or \"-i file.mp4\"\n"
+"This will find a filter (for example `fin`) able to load `file.mp4`. The same result can be achieved by using `fin:src=file.mp4`.\n"
+"EX \"dst=dump.yuv\" or \"-dst dump.yuv\" or \"-o dump.yuv\"\n"
+"This will dump the video content in `dump.yuv`. The same result can be achieved by using `fout:dst=dump.yuv`.\n"
+"\n"
+"Specific source or sink filters may also be specified using `filterName:src=URL` or `filterName:dst=URL`.\n"
+"\n"
+"The `src=` and `dst=` syntaxes can also be used in alias for dynamic argument cloning (see `gpac -hx alias`).\n"
+"\n"
+"## Forcing specific filters\n"
+"There is a special option called `gfreg` which allows specifying preferred filters to use when handling URLs.\n"
+"EX src=file.mp4:gfreg=ffdmx,ffdec\n"
+"This will use __ffdmx__ to read `file.mp4` and __ffdec__ to decode it.\n"
+"This can be used to test a specific filter when alternate filter chains are possible.\n"
+"## Specifying encoders and decoders\n"
+"By default filters chain will be resolved without any decoding/encoding if the destination accepts the desired format. "
+"Otherwise, decoders/encoders will be dynamically loaded to perform the conversion, unless dynamic resolution is disabled. "
+"There is a special shortcut filter name for encoders `enc` allowing to match a filter providing the desired encoding. "
+"The parameters for `enc` are:\n"
+"- c=NAME: identifies the desired codec. `NAME` can be the GPAC codec name or the encoder instance for ffmpeg/others\n"
+"- b=UINT, rate=UINT, bitrate=UINT: indicates the bitrate in bits per second\n"
+"- g=UINT, gop=UINT: indicates the GOP size in frames\n"
+"- pfmt=NAME: indicates the target pixel format name (see properties (-h props)(filters_properties) ) of the source, if supported by codec\n"
+"- all_intra=BOOL: indicates all frames should be intra frames, if supported by codec\n"
+"\n"
+"Other options will be passed to the filter if it accepts generic argument parsing (as is the case for ffmpeg).\n"
+"The shortcut syntax `c=TYPE` (e.g. `c=aac:opts`) is also supported.\n"
+"\n"
+"EX gpac -i dump.yuv:size=320x240:fps=25 enc:c=avc:b=150000:g=50:cgop=true:fast=true -o raw.264\n"
+"This creates a 25 fps AVC at 175kbps with a gop duration of 2 seconds, using closed gop and fast encoding settings for ffmpeg.\n"
+"\n"
+"The inverse operation (forcing a decode to happen) is possible using the __reframer__ filter.\n"
+"EX gpac -i file.mp4 reframer:raw=av -o null\n"
+"This will force decoding media from `file.mp4` and trash (send to `null`) the result (doing a decoder benchmark for example).\n"
+"\n"
+"## Escaping option separators\n"
+"When a filter uses an option defined as a string using the same separator character as gpac, you can either "
+"modify the set of separators, or escape the separator by duplicating it. The options enclosed by duplicated "
+"separator are not parsed. This is mostly used for meta filters, such as ffmpeg, to pass options to sub-filters "
+"such as libx264 (cf `x264opts` parameter).\n"
+"EX f:a=foo:b=bar\n"
+"This will set option `a` to `foo` and option `b` to `bar` on the filter.\n"
+"EX f::a=foo:b=bar\n"
+"This will set option `a` to `foo:b=bar` on the filter.\n"
+"EX f:a=foo::b=bar:c::d=fun\n"
+"This will set option `a` to `foo`, `b` to `bar:c` and the option `d` to `fun` on the filter.\n"
+"\n"
+"# Filter linking __LINK__\n"
+"\n"
+"Each filter exposes one or more sets of capabilities, called __capability bundle__, which are property type and values "
+"that must be matched or excluded by connecting PIDs.\n"
+"To check the possible sources and destination for a filter `FNAME`, use `gpac -h links FNAME`\n"
+"\n"
+"The filter graph resolver uses this information together with the PID properties to link the different filters.\n"
+"\n"
+"Link directives, when provided, specify which source a filter can accept connections from.\n"
+"__They do not specify which destination a filter can connect to.__\n"
+"\n"
+"## Default filter linking\n"
+"When no link instructions are given (see below), the default linking strategy used is either __implicit mode__ (default in `gpac`) or __complete mode__ (if -cl(GPAC) is set).\n"
+"Each PID is checked for possible connection to all defined filters, in their declaration order.\n"
+"For each filter `DST` accepting a connection from the PID, directly or with intermediate filters:\n"
+"- if `DST` filter has link directives, use them to allow or reject PID connection.\n"
+"- otherwise, if __complete mode__ is enabled, allow connection..\n"
+"- otherwise (__implicit mode__):\n"
+" - if `DST` is not a sink and is the first matching filter with no link directive, allow connection.\n"
+" - otherwise, if `DST` is not a sink and is not the first matching filter with no link directive, reject connection.\n"
+" - otherwise (`DST` is a sink) and no previous connections to a non-sink filter, allow connection.\n"
+"\n"
+"In all linking modes, a filter can prevent being linked to a filter with no link directives by setting `RSID` option on the filter.\n"
+"This is typically needed when dynamically inserting/removing filters in an existing session where some filters have no ID defined and are not desired for the inserted chain.\n"
+"\n"
+"EX gpac -i file.mp4 c=avc -o output\n"
+"With this setup in __implicit mode__:\n"
+"- if the file has a video PID, it will connect to `enc` but not to `output`. The output PID of `enc` will connect to `output`.\n"
+"- if the file has other PIDs than video, they will connect to `output`, since this `enc` filter accepts only video.\n"
+"\n"
+"EX gpac -cl -i file.mp4 c=avc -o output\n"
+"With this setup in __complete mode__:\n"
+"- if the file has a video PID, it will connect both to `enc` and to `output`, and the output PID of `enc` will connect to `output`.\n"
+"- if the file has other PIDs than video, they will connect to `output`.\n"
+"\n"
+"Furthermore in __implicit mode__, filter connections are restricted to filters defined between the last source and the sink(s).\n"
+"EX gpac -i video1 reframer:saps=1 -i video2 ffsws:osize=128x72 -o output\n"
+"This will connect:\n"
+"- `video1` to `reframer` then `reframer` to `output` but will prevent `reframer` to `ffsws` connection.\n"
+"- `video2` to `ffsws` then `ffsws` to `output` but will prevent `video2` to `reframer` connection.\n"
+"\n"
+"EX gpac -i video1 -i video2 reframer:saps=1 ffsws:osize=128x72 -o output\n"
+"This will connect `video1` AND `video2` to `reframer->ffsws->output`\n"
+"\n"
+"The __implicit mode__ allows specifying linear processing chains (no PID fan-out except for final output(s)) without link directives, simplifying command lines for common cases.\n"
+"Warning: Argument order really matters in implicit mode!\n"
+"\n"
+"EX gpac -i file.mp4 c=avc c=aac -o output\n"
+"If the file has a video PID, it will connect to `c=avc` but not to `output`. The output PID of `c=avc` will connect to `output`.\n"
+"If the file has an audio PID, it will connect to `c=aac` but not to `output`. The output PID of `c=aac` will connect to `output`.\n"
+"If the file has other PIDs than audio or video, they will connect to `output`.\n"
+"\n"
+"EX gpac -i file.mp4 ffswf=osize:128x72 c=avc resample=osr=48k c=aac -o output\n"
+"This will force:\n"
+"- `SRC(video)->ffsws->enc(video)->output` and prevent `SRC(video)->output`, `SRC(video)->enc(video)` and `ffsws->output` connections which would happen in __complete mode__.\n"
+"- `SRC(audio)->resample->enc(audio)->output` and prevent `SRC(audio)->output`, `SRC(audio)->enc(audio)` and `resample->output` connections which would happen in __complete mode__.\n"
+"\n"
+"## Quick links\n"
+"Link between filters may be manually specified. The syntax is an `@` character optionally followed by an integer (0 if omitted).\n"
+"This indicates that the following filter specified at prompt should be linked only to a previous listed filter.\n"
+"The optional integer is a 0-based index to the previous filter declarations, 0 indicating the previous filter declaration, 1 the one before the previous declaration, ...).\n"
+"If `@@` is used instead of `@`, the optional integer gives the filter index starting from the first filter (index 0) specified in command line.\n"
+"Several link directives can be given for a filter.\n"
+"EX fA fB @1 fC\n"
+"This indicates that `fC` only accepts inputs from `fA`.\n"
+"EX fA fB fC @1 @0 fD\n"
+"This indicates that `fD` only accepts inputs from `fB` and `fC`.\n"
+"EX fA fB fC ... @@1 fZ\n"
+"This indicates that `fZ` only accepts inputs from `fB`.\n"
+"\n"
+"## Complex links\n"
+"The `@` link directive is just a quick shortcut to set the following filter arguments:\n"
+"- FID=name: assigns an identifier to the filter\n"
+"- SID=name1,name2...: sets a list of filter identifiers, or __sourceIDs__, restricting the list of possible inputs for a filter.\n"
+"\n"
+"EX fA fB @1 fC\n"
+"This is equivalent to `fA:FID=1 fB fC:SID=1`.\n"
+"EX fA:FID=1 fB fC:SID=1\n"
+"This indicates that `fC` only accepts input from `fA`, but `fB` might accept inputs from `fA`.\n"
+"EX fA:FID=1 fB:FID=2 fC:SID=1 fD:SID=1,2\n"
+"This indicates that `fD` only accepts input from `fA` and `fB` and `fC` only from `fA`\n"
+"Note: A filter with sourceID set cannot get input from filters with no IDs.\n"
+"\n"
+"A sourceID name can be further extended using fragment identifier (`#` by default):\n"
+"- name#PIDNAME: accepts only PID(s) with name `PIDNAME`\n"
+"- name#TYPE: accepts only PIDs of matching media type. TYPE can be `audio`, `video`, `scene`, `text`, `font`, `meta`\n"
+"- name#TYPEN: accepts only `N` (1-based index) PID of matching type from source (e.g. `video2` to only accept second video PID)\n"
+"- name#TAG=VAL: accepts the PID if its parent filter has no tag or a tag matching `VAL`\n"
+"- name#P4CC=VAL: accepts only PIDs with builtin property of type `P4CC` and value `VAL`.\n"
+"- name#PName=VAL: same as above, using the builtin name corresponding to the property.\n"
+"- name#AnyName=VAL: same as above, using the name of a non built-in property.\n"
+"- name#Name=OtherPropName: compares the value with the value of another property of the PID. The matching will fail if the value to compare to is not present or different from the value to check. The property to compare with shall be a built-in property.\n"
+"If the property is not defined on the PID, the property is matched. Otherwise, its value is checked against the given value.\n"
+"\n"
+"The following modifiers for comparisons are allowed (for any fragment format using `=`):\n"
+"- name#P4CC=!VAL: accepts only PIDs with property NOT matching `VAL`.\n"
+"- name#P4CC-VAL: accepts only PIDs with property strictly less than `VAL` (only for 1-dimension number properties).\n"
+"- name#P4CC+VAL: accepts only PIDs with property strictly greater than `VAL` (only for 1-dimension number properties).\n"
+"\n"
+"A sourceID name can also use wildcard or be empty to match a property regardless of the source filter.\n"
+"EX fA fB:SID=*#ServiceID=2\n"
+"EX fA fB:SID=#ServiceID=2\n"
+"This indicates to match connection between `fA` and `fB` only for PIDs with a `ServiceID` property of `2`.\n"
+"These extensions also work with the __LINK__ `@` shortcut.\n"
+"EX fA fB @1#video fC\n"
+"This indicates that `fC` only accepts inputs from `fA`, and of type video.\n"
+"EX gpac -i img.heif @#ItemID=200 vout\n"
+"This indicates to connect to `vout` only PIDs with `ItemID` property equal to `200`.\n"
+"EX gpac -i vid.mp4 @#PID=1 vout\n"
+"This indicates to connect to `vout` only PIDs with `ID` property equal to `1`.\n"
+"EX gpac -i vid.mp4 @#Width=640 vout\n"
+"This indicates to connect to `vout` only PIDs with `Width` property equal to `640`.\n"
+"EX gpac -i vid.mp4 @#Width-640 vout\n"
+"This indicates to connect to `vout` only PIDs with `Width` property less than `640`\n"
+"EX gpac -i vid.mp4 @#ID=ItemID#ItemNumber=1 vout\n"
+"This will connect to `vout` only PID with an ID property equal to ItemID property (keep items, discard tracks) and an Item number of 1 (first item).\n"
+"\n"
+"Multiple fragment can be specified to check for multiple PID properties.\n"
+"EX gpac -i vid.mp4 @#Width=640#Height+380 vout\n"
+"This indicates to connect to `vout` only PIDs with `Width` property equal to `640` and `Height` greater than `380`.\n"
+"\n"
+"Warning: If a PID directly connects to one or more explicitly loaded filters, no further dynamic link resolution will "
+"be done to connect it to other filters with no sourceID set. Link directives should be carefully setup.\n"
+"EX fA @ reframer fB\n"
+"If `fB` accepts inputs provided by `fA` but `reframer` does not, this will link `fA` PID to `fB` filter since `fB` has no sourceID.\n"
+"Since the PID is connected, the filter engine will not try to solve a link between `fA` and `reframer`.\n"
+"\n"
+"An exception is made for local files: by default, a local file destination will force a remultiplex of input PIDs from a local file.\n"
+"EX gpac -i file.mp4 -o dump.mp4\n"
+"This will prevent direct connection of PID of type `file` to dst `file.mp4`, remultiplexing the file.\n"
+"\n"
+"The special option `nomux` is used to allow direct connections (ignored for non-sink filters).\n"
+"EX gpac -i file.mp4 -o dump.mp4:nomux\n"
+"This will result in a direct file copy.\n"
+"\n"
+"This only applies to local files destination. For pipes, sockets or other file outputs (HTTP, ROUTE):\n"
+"- direct copy is enabled by default\n"
+"- `nomux=0` can be used to force remultiplex\n"
+"\n"
+"## Sub-session tagging\n"
+"Filters may be assigned to a sub-session using `:FS=N`, with `N` a positive integer.\n"
+"Filters belonging to different sub-sessions may only link to each-other:\n"
+"- if explicitly allowed through sourceID directives (`@` or `SID`)\n"
+"- or if they have the same sub-session identifier\n"
+"\n"
+"This is mostly used for __implicit mode__ in `gpac`: each first source filter specified after a sink filter will trigger a new sub-session.\n"
+"EX gpac -i in1.mp4 -i in2.mp4 -o out1.mp4 -o out2.mp4\n"
+"This will result in both inputs multiplexed in both outputs.\n"
+"EX gpac -i in1.mp4 -o out1.mp4 -i in2.mp4 -o out2.mp4\n"
+"This will result in in1 mixed to out1 and in2 mixed to out2, these last two filters belonging to a different sub-session.\n"
+"\n"
+"# Arguments inheriting\n"
+"Unless explicitly disabled (see -max-chain(CORE)), the filter engine will resolve implicit or explicit (__LINK__) connections "
+"between filters and will allocate any filter chain required to connect the filters. "
+"In doing so, it loads new filters with arguments inherited from both the source and the destination.\n"
+"EX gpac -i file.mp4:OPT -o file.aac -o file.264\n"
+"This will pass the `:OPT` to all filters loaded between the source and the two destinations.\n"
+"EX gpac -i file.mp4 -o file.aac:OPT -o file.264\n"
+"This will pass the `:OPT` to all filters loaded between the source and the file.aac destination.\n"
+"Note: the destination arguments inherited are the arguments placed **AFTER** the `dst=` option.\n"
+"EX gpac -i file.mp4 fout:OPTFOO:dst=file.aac:OPTBAR\n"
+"This will pass the `:OPTBAR` to all filters loaded between `file.mp4` source and `file.aac` destination, but not `OPTFOO`.\n"
+"Arguments inheriting can be stopped by using the keyword `gfloc`: arguments after the keyword will not be inherited.\n"
+"EX gpac -i file.mp4 -o file.aac:OPTFOO:gfloc:OPTBAR -o file.264\n"
+"This will pass `:OPTFOO` to all filters loaded between `file.mp4` source and `file.aac` destination, but not `OPTBAR`\n"
+"Arguments are by default tracked to check if they were used by the filter chain, and a warning is thrown if this is not the case.\n"
+"It may be useful to specify arguments which may not be consumed depending on the graph resolution; the specific keyword `gfopt` indicates that arguments after the keyword will not be tracked.\n"
+"EX gpac -i file.mp4 -o file.aac:OPTFOO:gfopt:OPTBAR -o file.264\n"
+"This will warn if `OPTFOO` is not consumed, but will not track `OPTBAR`.\n"
+" \n"
+"A filter may be assigned a name (for inspection purposes, not inherited) using `:N=name` option. This name is not used in link resolution and may be changed at runtime by the filter instance.\n"
+" \n"
+"A filter may be assigned a tag (any string) using `:TAG=name` option. This tag does not need to be unique, and can be used to exclude filter in link resolution. Tags are not inherited, therefore dynamically loaded filters never have a tag.\n"
+" \n"
+"# URL templating\n"
+"Destination URLs can be dynamically constructed using templates. Pattern `$KEYWORD$` is replaced in the template with the "
+"resolved value and `$KEYWORD%%0Nd$` is replaced in the template with the resolved integer, padded with up to N zeros if needed.\n"
+"`KEYWORD` is **case sensitive**, and may be present multiple times in the string. Supported `KEYWORD`:\n"
+"- num: replaced by file number if defined, 0 otherwise\n"
+"- PID: ID of the source PID\n"
+"- URL: URL of source file\n"
+"- File: path on disk for source file; if not found, use URL if set, or PID name otherwise\n"
+"- Type: name of stream type of PID (`video`, `audio` ...)\n"
+"- p4cc=ABCD: uses PID property with 4CC value `ABCD`\n"
+"- pname=VAL: uses PID property with name `VAL`\n"
+"- cts, dts, dur, sap: uses properties of first packet in PID at template resolution time\n"
+"- OTHER: locates property 4CC for the given name, or property name if no 4CC matches.\n"
+" \n"
+"`$$` is an escape for $\n"
+"\n"
+"Templating can be useful when encoding several qualities in one pass.\n"
+"EX gpac -i dump.yuv:size=640x360 vcrop:wnd=0x0x320x180 c=avc:b=1M @2 c=avc:b=750k -o dump_$CropOrigin$x$Width$x$Height$.264:clone\n"
+"This will create a cropped version of the source, encoded in AVC at 1M, and a full version of the content in AVC at 750k. "
+"Outputs will be `dump_0x0x320x180.264` for the cropped version and `dump_0x0x640x360.264` for the non-cropped one.\n"
+"# Cloning filters\n"
+"When a filter accepts a single connection and has a connected input, it is no longer available for dynamic resolution. "
+"There may be cases where this behavior is undesired. Take a HEIF file with N items and do:\n"
+"EX gpac -i img.heif -o dump_$ItemID$.jpg\n"
+"In this case, only one item (likely the first declared in the file) will connect to the destination.\n"
+"Other items will not be connected since the destination only accepts one input PID.\n"
+"There is a special option `clone` allowing filters to be cloned with the same arguments. The cloned filters have the same ID as the original one.\n"
+"EX gpac -i img.heif -o dump_$ItemID$.jpg:clone\n"
+"In this case, the destination will be cloned for each item, and all will be exported to different JPEGs thanks to URL templating.\n"
+"EX gpac -i vid.mpd c=avc:FID=1:clone -o transcode.mpd:SID=1\n"
+"In this case, the encoder will be cloned for each video PIDs in the source, and the destination will only use PIDs coming from the encoders.\n"
+"\n"
+"When implicit linking is enabled, all filters are by default clonable. This allows duplicating the processing for each PIDs of the same type.\n"
+"EX gpac -i dual_audio resample:osr=48k c=aac -o dst\n"
+"The `resampler` filter will be cloned for each audio PID, and the encoder will be cloned for each resampler output.\n"
+"You can explicitly deactivate the cloning instructions:\n"
+"EX gpac -i dual_audio resample:osr=48k:clone=0 c=aac -o dst\n"
+"The first audio will connect to the `resample` filter, the second to the `enc` filter and the `resample` output will connect to a clone of the `enc` filter.\n"
+"\n"
+"# Templating filter chains\n"
+"There can be cases where the number of desired outputs depends on the source content, for example dumping a multiplex of N services into N files. When the destination involves multiplexing the input PIDs, the `:clone` option is not enough since the multiplexer will always accept the input PIDs.\n"
+"To handle this, it is possible to use a PID property name in the sourceID of a filter with the value `*` or an empty value. In this case, whenever a new PID with a new value for the property is found, the filter with such sourceID will be dynamically cloned.\n"
+"Warning: This feature should only be called with a single property set to `*` (or empty) per source ID, results are undefined otherwise.\n"
+"EX gpac -i source.ts -o file_$ServiceID$.mp4:SID=*#ServiceID=*\n"
+"EX gpac -i source.ts -o file_$ServiceID$.mp4:SID=#ServiceID=\n"
+"In this case, each new `ServiceID` value found when connecting PIDs to the destination will create a new destination file.\n"
+"\n"
+"Cloning in implicit linking mode applies to output as well:\n"
+"EX gpac -i dual_audio -o dst_$PID$.aac\n"
+"Each audio track will be dumped to aac (potentially reencoding if needed).\n"
+"\n"
+"# Assigning PID properties\n"
+"It is possible to define properties on output PIDs that will be declared by a filter. This allows tagging parts of the "
+"graph with different properties than other parts (for example `ServiceID`). "
+"The syntax is the same as filter option, and uses the fragment separator to identify properties, e.g. `#Name=Value`.\n"
+"This sets output PIDs property (4cc, built-in name or any name) to the given value. Value can be omitted for boolean "
+"(defaults to true, e.g. `:#Alpha`).\n"
+"Non built-in properties are parsed as follows:\n"
+"- `file@FOO` will be declared as string with a value set to the content of `FOO`.\n"
+"- `bxml@FOO` will be declared as data with a value set to the binarized content of `FOO`.\n"
+"- `FOO` will be declared as string with a value set to `FOO`.\n"
+"- `TYPE@FOO` will be parsed according to `TYPE`. If the type is not recognized, the entire value is copied as string. See `gpac -h props` for defined types.\n"
+"\n"
+"User-assigned PID properties on filter `fA` will be inherited by all filters dynamically loaded to solve `fA -> fB` connection.\n"
+"If `fB` also has user-assigned PID properties, these only apply starting from `fB` in the chain and are not inherited by filters between `fA` and `fB`.\n"
+"\n"
+"Warning: Properties are not filtered and override the properties of the filter's output PIDs, be careful not to break "
+"the session by overriding core properties such as width/height/samplerate/... !\n"
+"EX gpac -i v1.mp4:#ServiceID=4 -i v2.mp4:#ServiceID=2 -o dump.ts\n"
+"This will multiplex the streams in `dump.ts`, using `ServiceID` 4 for PIDs from `v1.mp4` and `ServiceID` 2 for PIDs from `v2.mp4`.\n"
+"\n"
+"PID properties may be conditionally assigned by checking other PID properties. The syntax uses parenthesis (not configurable) after the property assignment sign:\n"
+"`#Prop=(CP=CV)VAL`\n"
+"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV`.\n"
+"`#Prop=(CP=CV)VAL,(CP2=CV2)VAL2`\n"
+"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV`, and to `VAL2` for PIDs with property `CP2` equal to `CV2`.\n"
+"`#Prop=(CP=CV)(CP2=CV2)VAL`\n"
+"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV` and property `CP2` equal to `CV2`.\n"
+"`#Prop=(CP=CV)VAL,()DEFAULT`\n"
+"This will assign PID property `Prop` to `VAL` for PIDs with property `CP` equal to `CV`, or to `DEFAULT` for other PIDs.\n"
+"The condition syntax is the same as source ID fragment syntax.\n"
+"Note: When set, the default value (empty condition) always matches the PID, therefore it should be placed last in the list of conditions.\n"
+"EX gpac -i source.mp4:#MyProp=(audio)\"Super Audio\",(video)\"Super Video\"\n"
+"This will assign property `MyProp` to `Super Audio` for audio PIDs and to `Super Video` for video PIDs.\n"
+"EX gpac -i source.mp4:#MyProp=(audio1)\"Super Audio\"\n"
+"This will assign property `MyProp` to `Super Audio` for first audio PID declared.\n"
+"EX gpac -i source.mp4:#MyProp=(Width+1280)HD\n"
+"This will assign property `MyProp` to `HD` for PIDs with property `Width` greater than 1280.\n"
+"# Using option files\n"
+"It is possible to use a file to define options of a filter, by specifying the target file name as an option without value, i.e. `:myopts.txt`.\n"
+"Warning: Only local files are allowed.\n"
+"An option file is a simple text file containing one or more options or PID properties on one or more lines.\n"
+"- A line beginning with \"//\" is a comment and is ignored (not configurable).\n"
+"- A line beginning with \":\" indicates an escaped option (the entire line is parsed as a single option).\n"
+"Options in an option file may point to other option files, with a maximum redirection level of 5.\n"
+"An option file declaration (`filter:myopts.txt`) follows the same inheritance rules as regular options.\n"
+"EX gpac -i source.mp4:myopts.txt:foo=bar -o dst\n"
+"Any filter loaded between `source.mp4` and `dst` will inherit both `myopts.txt` and `foo` options and will resolve options and PID properties given in `myopts.txt`.\n"
+"# Specific filter options\n"
+"Some specific keywords are replaced when processing filter options.\n"
+"Warning: These keywords do not apply to PID properties. Multiple keywords cannot be defined for a single option.\n"
+"Defined keywords:\n"
+"- $GSHARE: replaced by system path to GPAC shared directory (e.g. /usr/share/gpac)\n"
+"- $GJS: replaced by the first path from global share directory and paths set through -js-dirs(CORE) that contains the file name following the macro, e.g. $GJS/source.js\n"
+"- $GDOCS: replaced by system path to:\n"
+" - application document directory for iOS\n"
+" - `EXTERNAL_STORAGE` environment variable if present or `/sdcard` otherwise for Android\n"
+" - user home directory for other platforms\n"
+"- $GLANG: replaced by the global config language option -lang(CORE)\n"
+"- $GUA: replaced by the global config user agent option -user-agent(CORE)\n"
+"- $GINC(init_val,inc): replaced by `init_val` and increment `init_val` by `inc` (positive or negative number, 1 if not specified) each time a new filter using this string is created.\n"
+"\n"
+"The `$GINC` construct can be used to dynamically assign numbers in filter chains:\n"
+"EX gpac -i source.ts tssplit @#ServiceID= -o dump_$GINC(10,2).ts\n"
+"This will dump first service in dump_10.ts, second service in dump_12.ts, etc...\n"
+"\n"
+"As seen previously, the following options may be set on any filter, but are not visible in individual filter help:\n"
+"- FID: filter identifier\n"
+"- SID: filter source(s) (string value)\n"
+"- N=NAME: filter name (string value)\n"
+"- FS: sub-session identifier (unsigned int value)\n"
+"- RSID: require sourceID to be present on target filters (no value)\n"
+"- TAG: filter tag (string value)\n"
+"- FBT: buffer time in microseconds (unsigned int value)\n"
+"- FBU: buffer units (unsigned int value)\n"
+"- FBD: decode buffer time in microseconds (unsigned int value)\n"
+"- clone: filter cloning flag (no value)\n"
+"- nomux: enable/disable direct file copy (no value)\n"
+"- gfreg: preferred filter registry names for link solving (string value)\n"
+"- gfloc: following options are local to filter declaration, not inherited (no value)\n"
+"- gfopt: following options are not tracked (no value)\n"
+"- gpac: argument separator for URLs (no value)\n"
+"\n"
+"The buffer control options are used to change the default buffering of PIDs of a filter:\n"
+"- `FBT` controls the maximum buffer time of output PIDs of a filter\n"
+"- `FBU` controls the maximum number of packets in buffer of output PIDs of a filter when timing is not available\n"
+"- `FBD` controls the maximum buffer time of input PIDs of a decoder filter, ignored for other filters\n"
+"\n"
+"If another filter sends a buffer requirement messages, the maximum value of `FBT` (resp. `FBD`) and the user requested buffer time will be used for output buffer time (resp. decoding buffer time).\n"
+"\n"
+"These options can be set:\n"
+"- per filter instance: `fA reframer:FBU=2`\n"
+"- per filter class for the run: `--reframer@FBU=2`\n"
+"- in the GPAC config file in a per-filter section: `filter@reframerFBU=2`\n"
+"\n"
+"The default values are defined by the session default parameters `-buffer-gen`, `buffer-units` and `-buffer-dec`.\n"
+"\n"
+"# External filters\n"
+"GPAC comes with a set of built-in filters in libgpac. It may also load external filters in dynamic libraries, located in "
+"default module folder or folders listed in -mod-dirs(CORE) option. The files shall be named `gf_*` and shall export"
+" a single function `RegisterFilter` returning a filter register - see libgpac documentation(https://doxygen.gpac.io/) for more details.\n"
+"\n";
+#endif
+
+void gpac_filter_help(void)
+{
+	gf_sys_format_help(helpout, help_flags,
+"Usage: gpac options FILTER LINK FILTER ... \n"
+#ifndef GPAC_DISABLE_DOC
+	"%s", gf_sys_localized("gpac", "doc", gpac_doc)
+#else
+	"GPAC compiled without built-in doc.\n"
+#endif
+	);
+
+}
+
+#include <gpac/modules/video_out.h>
+#include <gpac/modules/audio_out.h>
+#include <gpac/modules/compositor_ext.h>
+#include <gpac/modules/hardcoded_proto.h>
+#include <gpac/modules/font.h>
+
+void gpac_modules_help(void)
+{
+	u32 i;
+	gf_sys_format_help(helpout, help_flags, "Available modules:\n");
+	for (i=0; i<gf_modules_count(); i++) {
+		char *str = (char *) gf_modules_get_file_name(i);
+		if (!str) continue;
+		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s: implements ", str);
+		if (!strncmp(str, "gm_", 3) || !strncmp(str, "gsm_", 4)) {
+			GF_BaseInterface *ifce = gf_modules_load_by_name(str, GF_VIDEO_OUTPUT_INTERFACE);
+			if (ifce) {
+				gf_sys_format_help(helpout, help_flags, "VideoOutput ");
+				gf_modules_close_interface(ifce);
+			}
+			ifce = gf_modules_load_by_name(str, GF_AUDIO_OUTPUT_INTERFACE);
+			if (ifce) {
+				gf_sys_format_help(helpout, help_flags, "AudioOutput ");
+				gf_modules_close_interface(ifce);
+			}
+			ifce = gf_modules_load_by_name(str, GF_FONT_READER_INTERFACE);
+			if (ifce) {
+				gf_sys_format_help(helpout, help_flags, "FontReader ");
+				gf_modules_close_interface(ifce);
+			}
+			ifce = gf_modules_load_by_name(str, GF_COMPOSITOR_EXT_INTERFACE);
+			if (ifce) {
+				gf_sys_format_help(helpout, help_flags, "CompositorExtension ");
+				gf_modules_close_interface(ifce);
+			}
+			ifce = gf_modules_load_by_name(str, GF_HARDCODED_PROTO_INTERFACE);
+			if (ifce) {
+				gf_sys_format_help(helpout, help_flags, "HardcodedProto ");
+				gf_modules_close_interface(ifce);
+			}
+		} else {
+			gf_sys_format_help(helpout, help_flags, "Filter ");
+		}
+		gf_sys_format_help(helpout, help_flags, "\n");
+	}
+	gf_sys_format_help(helpout, help_flags, "\n");
+}
+
+#ifndef GPAC_DISABLE_DOC
+const char *gpac_alias =
+"The gpac command line can become quite complex when many sources or filters are used. In order to simplify this, an alias system is provided.\n"
+"\n"
+"To assign an alias, use the syntax `gpac -alias=\"NAME VALUE\"`.\n"
+"- `NAME`: shall be a single string, with no space.\n"
+"- `VALUE`: the list of argument this alias replaces. If not set, the alias is destroyed\n"
+"\n"
+"When parsing arguments, the alias will be replace by its value.\n"
+"EX gpac -alias=\"output aout vout\"\n"
+"This allows later audio and video playback using `gpac -i src.mp4 output`\n"
+"\n"
+"Aliases can use arguments from the command line. The allowed syntaxes are:\n"
+"- `@{a}`: replaced by the value of the argument with index `a` after the alias\n"
+"- `@{a,b}`: replaced by the value of the arguments with index `a` and `b`\n"
+"- `@{a:b}`: replaced by the value of the arguments between index `a` and `b`\n"
+"- `@{-a,b}`: replaced by the value of the arguments with index `a` and `b`, inserting a list separator (comma by default) between them\n"
+"- `@{-a:b}`: replaced by the value of the arguments between index `a` and `b`, inserting a list separator (comma by default) between them\n"
+"- `@{+a,b}`: clones the parent word in the alias for `a` and `b`, replacing this pattern in each clone by the corresponding argument\n"
+"- `@{+a:b}`: clones the parent word in the alias for each argument between index `a` and `b`, replacing this pattern in each clone by the corresponding argument\n"
+"\n"
+"The specified index can be:\n"
+"- forward index: a strictly positive integer, 1 being the first argument after the alias\n"
+"- backward index: the value 'n' (or 'N') to indicate the last argument on the command line. This can be followed by `-x` to rewind arguments (e.g. `@{n-1}` is the before last argument)\n"
+"\n"
+"Before solving aliases, all option arguments are moved at the beginning of the command line. This implies that alias arguments cannot be options.\n"
+"Arguments not used by any aliases are kept on the command line, other ones are removed\n"
+"\n"
+"EX -alias=\"foo src=@{N} dst=test.mp4\"\n"
+"The command `gpac foo f1 f2` expands to `gpac src=f2 dst=test.mp4 f1`\n"
+"EX -alias=\"list: inspect src=@{+:N}\"\n"
+"The command `gpac list f1 f2 f3` expands to `gpac inspect src=f1 src=f2 src=f3`\n"
+"EX -alias=\"list inspect src=@{+2:N}\"\n"
+"The command `gpac list f1 f2 f3` expands to `gpac inspect src=f2 src=f3 f1`\n"
+"EX -alias=\"plist aout vout flist:srcs=@{-,N}\"\n"
+"The command `gpac plist f1 f2 f3` expands to `gpac aout vout flist:srcs=\"f1,f2,f3\"` \n"
+"\n"
+"Alias documentation can be set using `gpac -aliasdoc=\"NAME VALUE\"`, with `NAME` the alias name and `VALUE` the documentation.\n"
+"Alias documentation will then appear in gpac help.\n"
+"\n";
+#endif
+
+void gpac_alias_help(GF_SysArgMode argmode)
+{
+	u32 i, count;
+
+	if (argmode >= GF_ARGMODE_EXPERT) {
+
+#ifndef GPAC_DISABLE_DOC
+		gf_sys_format_help(helpout, help_flags, "%s", gf_sys_localized("gpac", "alias", gpac_alias) );
+#else
+		gf_sys_format_help(helpout, help_flags, "%s", "GPAC compiled without built-in doc.\n");
+#endif
+		if (argmode == GF_ARGMODE_EXPERT) {
+			return;
+		}
+	}
+
+	count = gf_opts_get_key_count("gpac.alias");
+	if (count) {
+		if (argmode < GF_ARGMODE_EXPERT) {
+			gf_sys_format_help(helpout, help_flags, "Available aliases (use 'gpac -hx alias' for more info on aliases):\n");
+		} else {
+			gf_sys_format_help(helpout, help_flags, "Available aliases:\n");
+		}
+		for (i=0; i<count; i++) {
+			const char *alias = gf_opts_get_key_name("gpac.alias", i);
+			const char *alias_doc = gf_opts_get_key("gpac.aliasdoc", alias);
+			const char *alias_value = gf_opts_get_key("gpac.alias", alias);
+
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s", alias);
+			if (argmode>=GF_ARGMODE_ADVANCED)
+				gf_sys_format_help(helpout, help_flags, " (%s)", alias_value);
+
+			if (alias_doc)
+				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_OPT_DESC, ": %s", gf_sys_localized("gpac", "aliasdoc", alias_doc));
+			else if (argmode<GF_ARGMODE_ADVANCED) {
+				gf_sys_format_help(helpout, help_flags, " (%s)", alias_value);
+			}
+
+			gf_sys_format_help(helpout, help_flags, "\n");
+		}
+	} else {
+		gf_sys_format_help(helpout, help_flags, "No aliases defined - use 'gpac -hx alias' for more info on aliases\n");
+	}
+}
+
+
+void gpac_core_help(GF_SysArgMode mode, Bool for_logs)
+{
+	u32 mask;
+	gf_sys_format_help(helpout, help_flags, "# libgpac %s options:\n", for_logs ? "logs" : "core");
+	if (for_logs) {
+		mask = GF_ARG_SUBSYS_LOG;
+	} else {
+		mask = 0xFFFFFFFF;
+		mask &= ~GF_ARG_SUBSYS_LOG;
+		mask &= ~GF_ARG_SUBSYS_FILTERS;
+	}
+	gf_sys_print_core_help(helpout, help_flags, mode, mask);
+}
+
+static GF_GPACArg gpac_args =
+{
+#ifdef GPAC_MEMORY_TRACKING
+ 	GF_DEF_ARG("mem-track", NULL, "enable memory tracker", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+ 	GF_DEF_ARG("mem-track-stack", NULL, "enable memory tracker with stack dumping", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+#endif
+	GF_DEF_ARG("ltf", NULL, "load test-unit filters (used for for unit tests only)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("sloop", NULL, "loop execution of session, creating a session at each loop, mainly used for testing. If no value is given, loops forever", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("runfor", NULL, "run for the given amount of milliseconds, exit with full session flush", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("runforf", NULL, "run for the given amount of milliseconds, exit with fast session flush", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("runforx", NULL, "run for the given amount of milliseconds and exit with no cleanup", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("runfors", NULL, "run for the given amount of milliseconds and exit with segfault (tests)", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("runforl", NULL, "run for the given amount of milliseconds and wait forever at end (tests)", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT),
+
+	GF_DEF_ARG("stats", NULL, "print stats after execution", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("graph", NULL, "print graph after execution", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("k", NULL, "enable keyboard interaction from command line", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("r", NULL, "enable reporting\n"
+			"- r: runtime reporting\n"
+			"- r=FA,FB: runtime reporting but only print given filters, e.g. `r=mp4mx` for ISOBMFF multiplexer only\n"
+			"- r=: only print final report"
+			, NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("seps", NULL, "set the default character sets used to separate various arguments\n"
+		"- the first char is used to separate argument names\n"
+		"- the second char, if present, is used to separate names and values\n"
+		"- the third char, if present, is used to separate fragments for PID sources\n"
+		"- the fourth char, if present, is used for list separators (__sourceIDs__, __gfreg__, ...)\n"
+		"- the fifth char, if present, is used for boolean negation\n"
+		"- the sixth char, if present, is used for LINK directives (see filters help (-h doc)(filters_general))", GF_FS_DEFAULT_SEPS, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+
+	GF_DEF_ARG("i", "src", "specify an input file - see filters help (-h doc)(filters_general)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("o", "dst", "specify an output file - see filters help (-h doc)(filters_general)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("ib", NULL, "specify an input file to wrap as GF_FileIO object (testing of GF_FileIO)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("ob", NULL, "specify an output file to wrap as GF_FileIO object (testing of GF_FileIO)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("cl", NULL, "force complete mode when no link directive are set - see filters help (-h doc)(filters_general)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("step", NULL, "test step mode in non-blocking session", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("h", "help,-ha,-hx,-hh", "print help. Use `-help` or `-h` for basic options, `-ha` for advanced options, `-hx` for expert options and `-hh` for all. \nNote: The `@` character can be used in place of the `*` character. String parameter can be:\n"
+			"- empty: print command line options help\n"
+			"- doc: print the general filter info\n"
+			"- alias: print the gpac alias syntax\n"
+			"- log: print the log system help\n"
+			"- core: print the supported libgpac core options. Use -ha/-hx/-hh for advanced/expert options\n"
+			"- cfg: print the GPAC configuration help\n"
+			"- prompt: print the GPAC prompt help when running in interactive mode (see -k(GPAC) )\n"
+			"- modules: print available modules\n"
+			"- creds: print credential help\n"
+			"- filters: print name of all available filters\n"
+			"- filters:*: print name of all available filters, including meta filters\n"
+			"- codecs: print the supported builtin codecs - use `-hx` to include unmapped codecs (ffmpeg, ...)\n"
+			"- formats: print the supported formats (`-ha`: print filter names, `-hx`: include meta filters (ffmpeg,...), `-hh`: print mime types)\n"
+			"- protocols: print the supported protocol schemes (`-ha`: print filter names, `-hx`: include meta filters (ffmpeg,...), `-hh`: print all)\n"
+			"- props: print the supported builtin PID and packet properties\n"
+			"- props PNAME: print the supported builtin PID and packet properties mentioning `PNAME`\n"
+			"- colors: print the builtin color names and their values\n"
+			"- layouts: print the builtin CICP audio channel layout names and their values\n"
+			"- links: print possible connections between each supported filters (use -hx to view src->dst cap bundle detail)\n"
+			"- links FNAME: print sources and sinks for filter `FNAME` (either builtin or JS filter)\n"
+			"- FNAME: print filter `FNAME` info (multiple FNAME can be given)\n"
+			" - For meta-filters, use `FNAME:INST`, e.g. `ffavin:avfoundation`\n"
+			" - Use `*` to print info on all filters (__big output!__), `*:*` to print info on all filters including meta filter instances (__really big output!__)\n"
+			" - By default only basic filter options and description are shown. Use `-ha` to show advanced options capabilities, `-hx` for expert options, `-hh` for all options and filter capabilities including on filters disabled in this build\n"
+			"- FNAME.OPT: print option `OPT` in filter `FNAME`\n"
+			"- OPT: look in filter names and options for `OPT` and suggest possible matches if none found. Use `-hx` to look for keyword in all option descriptions\n"
+		, NULL, NULL, GF_ARG_STRING, 0),
+
+ 	GF_DEF_ARG("p", NULL, "use indicated profile for the global GPAC config. If not found, config file is created. If a file path is indicated, this will load profile from that file. Otherwise, this will create a directory of the specified name and store new config there. Reserved name `0` means a new profile, not stored to disk. Appending `:reload` to the profile name will force recreating a new configuration file", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+ 	GF_DEF_ARG("alias", NULL, "assign a new alias or remove an alias. Can be specified several times. See alias usage (-h alias)(#using-aliases)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+ 	GF_DEF_ARG("aliasdoc", NULL, "assign documentation for a given alias (optional). Can be specified several times", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED),
+
+ 	GF_DEF_ARG("uncache", NULL, "revert all items in GPAC cache directory to their original name and server path", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED),
+	GF_DEF_ARG("js", NULL, "specify javascript file to use as controller of filter session", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+
+	GF_DEF_ARG("wc", NULL, "write all core options in the config file unless already set", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("we", NULL, "write all file extensions in the config file unless already set (useful to change some default file extensions)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("wf", NULL, "write all filter options in the config file unless already set", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("wfx", NULL, "write all filter options and all meta filter arguments in the config file unless already set (__large config file !__)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("unit-tests", NULL, "enable unit tests of some functions otherwise not covered by gpac test suite", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_HIDE),
+	GF_DEF_ARG("genmd", NULL, "generate markdown doc", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_HIDE),
+	GF_DEF_ARG("xopt", NULL, "unrecognized options and filters declaration following this option are ignored - used to pass arguments to GUI", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+	GF_DEF_ARG("creds", NULL, "setup credentials as used by servers", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT),
+
+#ifdef GPAC_CONFIG_IOS
+	GF_DEF_ARG("req-gl", NULL, "forces loading SDL - iOS only", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT),
+#endif
+	{0}
+};
+
+
+void gpac_usage(GF_SysArgMode argmode)
+{
+	u32 i=0;
+	if ((argmode != GF_ARGMODE_ADVANCED) && (argmode != GF_ARGMODE_EXPERT) ) {
+		if (gen_doc!=2)
+			gf_sys_format_help(helpout, help_flags, "Usage: gpac options FILTER LINK FILTER ... \n");
+
+		gf_sys_format_help(helpout, help_flags, "gpac is GPAC's command line tool for setting up and running filter chains.\n\n"
+		"__FILTER__: a single filter declaration (e.g., `-i file`, `-o dump`, `inspect`, ...), see %s.\n"
+		"__LINK__: a link instruction (e.g., `@`, `@2`, `@2#StreamType=Visual`, ...), see %s.\n"
+		"__options__: one or more option strings, each starting with a `-` character.\n"
+		" - an option using a single `-` indicates an option of gpac (see %s) or of libgpac (see %s)\n"
+		" - an option using `--` indicates a global filter or meta-filter (e.g. FFMPEG) option, e.g. `--block_size=1000` or `--profile=Baseline` (see %s)\n"
+		" \n"
+		"Filter declaration order may impact the link resolver which will try linking in declaration order. Most of the time for simple graphs, this has no impact. However, for complex graphs with no link declarations, this can lead to different results. \n"
+		"Options do not require any specific order, and may be present anywhere, including between link statements or filter declarations. \n"
+		"Boolean values do not need any value specified. Other types shall be formatted as `opt=val`, except -i(), `-src`, -o(), `-dst` and -h() options.\n\n"
+		"\n"
+		"The session can be interrupted at any time using `ctrl+c`, which can also be used to toggle global reporting.\n"
+		"\n"
+		"The possible options for gpac are:\n\n",
+			(gen_doc==1) ? "gpac -h doc(filters_general#filter-declaration-filter)" : "`gpac -h doc`",
+			(gen_doc==1) ? "gpac -h doc(filters_general#explicit-links-between-filters-link)" : "`gpac -h doc`",
+			(gen_doc==1) ? "gpac -hx(gpac_general#h)" : "`gpac -hx`",
+			(gen_doc==1) ? "gpac -hx core(core_options)" : "`gpac -hx core`",
+			(gen_doc==1) ? "gpac -h doc(core_config#global-filter-options)" : "`gpac -h doc`",
+			(gen_doc==1) ? "gpac -h doc(core_config#global-filter-options)" : "`gpac -h doc`"
+		);
+	}
+
+	while (gpac_argsi.name) {
+		GF_GPACArg *arg = &gpac_argsi;
+		i++;
+
+		if (argmode!=GF_ARGMODE_ALL) {
+			if ((argmode==GF_ARGMODE_EXPERT) && !(arg->flags & GF_ARG_HINT_EXPERT)) continue;
+			if ((argmode==GF_ARGMODE_ADVANCED) && !(arg->flags & GF_ARG_HINT_ADVANCED)) continue;
+			else if ((argmode==GF_ARGMODE_BASE) && (arg->flags & (GF_ARG_HINT_ADVANCED| GF_ARG_HINT_EXPERT)) ) continue;
+		}
+
+		gf_sys_print_arg(helpout, help_flags, arg, "gpac");
+	}
+
+	if (argmode>=GF_ARGMODE_ADVANCED) {
+		gf_sys_format_help(helpout, help_flags, "\n \nThe following libgpac core options allow customizing the filter session:\n \n" );
+		gf_sys_print_core_help(helpout, help_flags, argmode, GF_ARG_SUBSYS_FILTERS);
+	}
+
+	if (argmode==GF_ARGMODE_BASE) {
+		if ( gf_opts_get_key_count("gpac.aliasdoc")) {
+			gf_sys_format_help(helpout, help_flags, "\n");
+			gpac_alias_help(GF_ARGMODE_BASE);
+		}
+
+		gf_sys_format_help(helpout, help_flags, "\ngpac - GPAC command line filter engine - version %s\n%s\n", gf_gpac_version(), gf_gpac_copyright_cite() );
+	}
+}
+
+#ifndef GPAC_DISABLE_DOC
+static const char *gpac_config =
+{
+"# Configuration file\n"
+"GPAC uses a configuration file to modify default options of libgpac and filters. This file is called `GPAC.cfg` and is located:\n"
+"- on Windows platforms, in `C:\\Users\\FOO\\AppData\\Roaming\\GPAC` or in `C:\\Program Files\\GPAC`.\n"
+"- on iOS platforms, in a .gpac folder in the app storage directory.\n"
+"- on Android platforms, in `/sdcard/GPAC/` if this directory exists, otherwise in `/data/data/io.gpac.gpac/GPAC`.\n"
+"- on other platforms, in a `$HOME/.gpac/`.\n"
+"\n"
+"Applications in GPAC can also specify a different configuration file through the -p(GPAC) profile option. "
+"EX gpac -p=foo \n"
+"This will load configuration from $HOME/.gpac/foo/GPAC.cfg, creating it if needed.\n"
+"The reserved name `0` is used to disable configuration file writing.\n"
+"\n"
+"The configuration file is structured in sections, each made of one or more keys:\n"
+"- section `foo` is declared as `foo\\n`\n"
+"- key `bar` with value `N` is declared as `bar=N\\n`. The key value `N` is not interpreted and always handled as ASCII text.\n"
+"\n"
+"By default the configuration file only holds a few system specific options and directories. It is possible to serialize "
+"the entire set of options to the configuration file, using -wc(GPAC) -wf(GPAC).\n"
+"This should be avoided as the resulting configuration file size will be quite large, hence larger memory usage for the applications.\n"
+"The options specified in the configuration file may be overridden by the values in __restrict.cfg__ file located in GPAC share system directory (e.g. `/usr/share/gpac` or `C:\\Program Files\\GPAC`), "
+"if present; this allows enforcing system-wide configuration values.\n"
+"Note: The methods describe in this section apply to any application in GPAC transferring their arguments "
+"to libgpac. This is the case for __gpac__ and __MP4Box__.\n"
+"\n"
+"# Core options\n"
+"The options from libgpac core can also be assigned though the config file from section __core__ using "
+"option name **without initial dash** as key name.\n"
+"EX core\n"
+"EX threads=2\n"
+"Setting this in the config file is equivalent to using `-threads=2`.\n"
+"The options specified at prompt overrides the value of the config file.\n"
+"# Filter options in configuration\n"
+"It is possible to alter the default value of a filter option by modifying the configuration file. Filter __foo__ options are stored in section "
+"`filter@foo`, using option name and value as key-value pair. Options specified through the configuration file do not take precedence over "
+"options specified at prompt or through alias.\n"
+"EX filter@rtpin\n"
+"EX interleave=yes\n"
+"This will force the rtp input filter to always request RTP over RTSP by default.\n"
+"To generate a configuration file with all filters options serialized, use -wf(GPAC).\n"
+"# Global filter options\n"
+"It is possible to specify options global to multiple filters using `--OPTNAME=VAL`. Global options do not override filter options but "
+"take precedence over options loaded from configuration file.\n"
+"This will set option `OPTNAME`, when present, to `VAL` in any loaded filter.\n"
+"EX --buffer=100 -i file vout aout\n"
+"This is equivalent to specifying `vout:buffer=100 aout:buffer=100`.\n"
+"EX --buffer=100 -i file vout aout:buffer=10\n"
+"This is equivalent to specifying `vout:buffer=100 aout:buffer=10`.\n"
+"Warning: This syntax only applies to regular filter options. It cannot be used with builtin shortcuts (gfreg, enc, ...).\n"
+"Meta-filter options can be set in the same way using the syntax `--OPT_NAME=VAL`.\n"
+"EX --profile=Baseline -i file.cmp -o dump.264\n"
+"This is equivalent to specifying `-o dump.264:profile=Baseline`.\n"
+" \n"
+"For both syntaxes, it is possible to specify the filter registry name of the option, using `--FNAME:OPTNAME=VAL` or `--FNAME@OPTNAME=VAL`.\n"
+"In this case the option will only be set for filters which are instances of registry FNAME. This is used when several registries use same option names.\n"
+"EX --flist@timescale=100 -i plist1 -i plist2 -o live.mpd\n"
+"This will set the timescale option on the playlists filters but not on the dasher filter.\n"
+};
+#endif
+
+
+
+void gpac_config_help()
+{
+#ifndef GPAC_DISABLE_DOC
+		gf_sys_format_help(helpout, help_flags, "%s", gf_sys_localized("gpac", "config", gpac_config) );
+#else
+		gf_sys_format_help(helpout, help_flags, "%s", "GPAC compiled without built-in doc.\n");
+#endif
+
+	if (gen_doc) return;
+	gf_sys_format_help(helpout, help_flags, "\nCurrent configuration file is `%s`\n\n", gf_opts_get_filename());
+}
+
+#ifndef GPAC_DISABLE_DOC
+static const char *gpac_credentials =
+{
+"# User Credentials\n"
+"Some servers in GPAC can use user-based and group-based authentication.\n"
+"The information is stored by default in the file `users.cfg` located in the GPAC profile directory.\n"
+"The file can be overwritten using the -users(CORE) option.\n"
+"\n"
+"By default, this file does not exist until at least one user has been configured.\n"
+"\n"
+"The -creds() option allows inspecting or modifying the users and groups information. The syntax for the option value is:\n"
+"- `show` or no value: prints the `users.cfg` file\n"
+"- `reset`: deletes the `users.cfg` file (i.e. deletes all users and groups)\n"
+"- `NAME`: show information of user `NAME`\n"
+"- `+NAME`: adds user `NAME`\n"
+"- `+NAME:I1=V1,I2=V2`: sets info `I1` with value `V1` to user `NAME`. the info name `password` resets password without prompt.\n"
+"- `-NAME`: removes user `NAME`\n"
+"- `_NAME`: force password change of user `NAME`\n"
+"- `@NAME`: show information of group `NAME`\n"
+"- `@+NAME:u1,u2`: adds group `NAME` if not existing and adds specified users to group\n"
+"- `@-NAME:u1,u2`: removes specified users from group `NAME`\n"
+"- `@-NAME`: removes group `NAME`\n"
+"\n"
+"By default all added users are members of the group `users`.\n"
+"Passwords are not stored, only a SHA256 hash is stored.\n"
+"\n"
+"Servers using authentication rules can use a configuration file instead of a directory name.\n"
+"This configuration file is organized in sections, each section name descibing a directory.\n"
+"EX somedir\n"
+"EX ru=foo\n"
+"EX rg=bar\n"
+"\n"
+"The following keys are defined per directory, but may be ignored by the server depending on its operation mode:\n"
+"- ru: comma-separated list of user names with read access to the directory\n"
+"- rg: comma-separated list of group names with read access to the directory\n"
+"- wu: comma-separated list of user names with write access to the directory\n"
+"- wg: comma-separated list of group names with write access to the directory\n"
+"- mcast: comma-separated list of user names with multicast creation rights (RTSP server only)\n"
+"- filters: comma-separated list of filter names for which the directory is valid. If not found or `all`, applies to all filters\n"
+"\n"
+"Rights can be configured on sub-directories by adding sections for the desired directories.\n"
+"EX d1\n"
+"EX rg=bar\n"
+"EX d1/d2\n"
+"EX ru=foo\n"
+"With this configuration:\n"
+"- the directory `d1` will be readable by all members of group `bar`\n"
+"- the directory `d1/d2` will be readable by user `foo` only\n"
+"\n"
+"Servers in GPAC currently only support the `Basic` HTTP authentication scheme, and should preferably be run over TLS.\n"
+};
+#endif
+
+void gpac_credentials_help(GF_SysArgMode argmode)
+{
+#ifndef GPAC_DISABLE_DOC
+		gf_sys_format_help(helpout, help_flags, "%s", gf_sys_localized("gpac", "credentials", gpac_credentials) );
+#else
+		gf_sys_format_help(helpout, help_flags, "%s", "GPAC compiled without built-in doc.\n");
+#endif
+}
+
+#include <gpac/network.h>
+void gpac_load_suggested_filter_args()
+{
+	u32 i, count, k;
+	GF_Config *opts = NULL;
+	GF_FilterSession *fsess;
+	const char *version, *cfg_path;
+	char *all_opts;
+
+	if (gf_opts_get_bool("core", "no-argchk"))
+		return;
+
+	cfg_path = gf_opts_get_filename();
+	all_opts = gf_url_concatenate(cfg_path, "all_opts.txt");
+
+	opts = gf_cfg_force_new("probe", all_opts);
+	gf_free(all_opts);
+
+	version = gf_cfg_get_key(opts, "version", "version");
+	if (version && !strcmp(version, gf_gpac_version()) ) {
+		gf_cfg_del(opts);
+		return;
+	}
+	gf_cfg_del_section(opts, "allopts");
+	gf_cfg_set_key(opts, "version", "version", gf_gpac_version());
+
+	gf_sys_format_help(stderr, 0, "__Refreshing all options registry, this may take some time ... ");
+
+	fsess = gf_fs_new(0, GF_FS_SCHEDULER_LOCK_FREE, GF_FS_FLAG_LOAD_META, NULL);
+	if (!fsess) {
+		gf_sys_format_help(stderr, 0, "\nWarning: Error creating session\n");
+		gf_cfg_del(opts);
+		return;
+	}
+
+	count = gf_fs_filters_registers_count(fsess);
+	for (i=0; i<count; i++) {
+		const GF_FilterRegister *freg = gf_fs_get_filter_register(fsess, i);
+
+		k=0;
+		while (freg->args) {
+			const char *old_val;
+			char *argn=NULL;
+			const GF_FilterArgs *arg = &freg->argsk;
+			if (!arg || !arg->arg_name) {
+				break;
+			}
+			k++;
+			if (arg->flags & GF_FS_ARG_HINT_HIDE) continue;
+
+			if (arg->flags & GF_FS_ARG_META) {
+				gf_dynstrcat(&argn, "-+", NULL);
+			} else {
+				gf_dynstrcat(&argn, "--", NULL);
+			}
+			gf_dynstrcat(&argn, arg->arg_name, NULL);
+			if ((arg->arg_type==GF_PROP_UINT) && arg->min_max_enum && strchr(arg->min_max_enum, '|')) {
+				gf_dynstrcat(&argn, arg->min_max_enum, "@");
+			}
+
+			old_val = gf_cfg_get_key(opts, "allopts", argn);
+			if (old_val) {
+				char *newval = gf_strdup(freg->name);
+				gf_dynstrcat(&newval, old_val, " ");
+				gf_cfg_set_key(opts, "allopts", argn, newval);
+				gf_free(newval);
+			} else {
+				gf_cfg_set_key(opts, "allopts", argn, freg->name);
+			}
+			gf_free(argn);
+		}
+	}
+	gf_fs_del(fsess);
+	gf_cfg_del(opts);
+	gf_sys_format_help(stderr, 0, "done\n");
+}
+
+
+void gpac_suggest_arg(char *aname)
+{
+	u32 k;
+	const GF_GPACArg *args;
+	if (!aname) return;
+	Bool found=GF_FALSE;
+	for (k=0; k<2; k++) {
+		u32 i=0;
+		if (k==0) args = gpac_args;
+		else args = gf_sys_get_options();
+
+		while (argsi.name) {
+			const GF_GPACArg *arg = &argsi;
+			i++;
+			if (gf_sys_word_match(aname, arg->name)) {
+				if (!found) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unrecognized option \"%s\", did you mean:\n", aname));
+					found = GF_TRUE;
+				}
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("\t-%s (see gpac -hx%s)\n", arg->name, k ? " core" : ""));
+			}
+		}
+	}
+	//look in alias
+	u32 nb_alias = gf_opts_get_key_count("gpac.alias");
+	for (k=0; k<nb_alias; k++) {
+		const char *key = gf_opts_get_key_name("gpac.alias", k);
+		if (gf_sys_word_match(aname, key)) {
+			if (!found) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unrecognized option \"%s\", did you mean:\n", aname));
+				found = GF_TRUE;
+			}
+			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("\t%s (see gpac -h)\n", key));
+		}
+	}
+
+	if (!found) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unrecognized option \"%s\", check usage \"gpac -h\"\n", aname));
+	}
+}
+
+void gpac_suggest_filter(char *fname, Bool is_help, Bool filter_only)
+{
+	Bool found = GF_FALSE;
+	Bool first = GF_FALSE;
+	u32 i, count, pass_exact = GF_TRUE;
+	if (!fname) return;
+
+	if (filter_only || !is_help) pass_exact = GF_FALSE;
+
+redo_pass:
+
+	count = gf_fs_filters_registers_count(session);
+	if (!pass_exact) {
+		for (i=0; i<count; i++) {
+			const GF_FilterRegister *freg = gf_fs_get_filter_register(session, i);
+
+			if (gf_sys_word_match(fname, freg->name)) {
+				if (!first) {
+					first = GF_TRUE;
+					if (!found) {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
+						found = GF_TRUE;
+					}
+					GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest filter names: \n"));
+				}
+				GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("- %s\n", freg->name));
+			}
+		}
+	}
+
+	if (is_help) {
+		if (!pass_exact) {
+			const char *doc_helps = {
+				"log", "core", "modules", "doc", "alias", "props", "colors", "layouts", "cfg", "prompt", "codecs", "formats", "exts", "protocols", "links", "bin", "filters", "filters:*", "filters:@", "mp4c", NULL
+			};
+			first = GF_FALSE;
+			i=0;
+			while (doc_helpsi) {
+				if (gf_sys_word_match(fname, doc_helpsi)) {
+					if (!first) {
+						first = GF_TRUE;
+						if (!found) {
+							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
+							found = GF_TRUE;
+						}
+						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest help commands: \n"));
+					}
+					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("-h %s\n", doc_helpsi));
+				}
+				i++;
+			}
+		}
+
+		if (!filter_only) {
+			u32 nb_alias = gf_opts_get_key_count("gpac.alias");
+			first = GF_FALSE;
+			for (i=0; i<nb_alias; i++) {
+				const char *alias = gf_opts_get_key_name("gpac.alias", i);
+
+				if (pass_exact) {
+					if (!strcmp(fname, alias+1)) {
+						const char *doc = gf_opts_get_key("gpac.aliasdoc", alias);
+						if (!doc) doc = "Not documented";
+						GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s: %s\n", alias, doc));
+						found = GF_TRUE;
+					}
+				}
+				else if (gf_sys_word_match(fname, alias)) {
+					if (!first) {
+						first = GF_TRUE;
+						if (!found) {
+							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
+							found = GF_TRUE;
+						}
+						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Closest alias: \n"));
+					}
+					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s\n", alias));
+				}
+			}
+			//check in libgpac core opts
+			first = GF_FALSE;
+			i=0;
+			const GF_GPACArg *core_opts = gf_sys_get_options();
+			while (core_opts && core_optsi.name) {
+				const GF_GPACArg *arg = &core_optsi;
+				i++;
+
+				if (gf_sys_word_match(fname, arg->name)) {
+					if (!first) {
+						first = GF_TRUE;
+						if (!found) {
+							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
+							found = GF_TRUE;
+						}
+						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\nClosest core option: \n"));
+					}
+					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("-%s: %s\n", arg->name, arg->description));
+				}
+			}
+
+			//check filters
+			first = GF_FALSE;
+			for (i=0; i<count; i++) {
+				u32 j=0;
+				const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+
+				while (reg->args) {
+					const GF_FilterArgs *arg = &reg->argsj;
+					if (!arg || !arg->arg_name) break;
+					j++;
+
+					if (pass_exact) {
+						if (!strcmp(fname, arg->arg_name)) {
+							gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s %s\n", reg->name, arg->arg_name, arg->arg_desc);
+							found = GF_TRUE;
+						}
+						continue;
+					}
+					if (!gf_sys_word_match(fname, arg->arg_name)) continue;
+
+					if (!first) {
+						first = GF_TRUE;
+						if (!found) {
+							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
+							found = GF_TRUE;
+						}
+						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\nClosest matching filter options:\n", fname));
+					}
+					gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s \n", reg->name, arg->arg_name);
+				}
+			}
+
+
+			first = GF_FALSE;
+			i=0;
+			const GF_BuiltInProperty *prop_info;
+			while ((prop_info = gf_props_get_description(i))) {
+				i++;
+				if (!prop_info->name || !prop_info->description) continue;
+				
+				if (gf_sys_word_match(fname, prop_info->name)) {
+					if (!first) {
+						first = GF_TRUE;
+						if (!found) {
+							GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No such filter %s\n", fname));
+							found = GF_TRUE;
+						}
+						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\nClosest property name: \n"));
+					}
+					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s: %s\n", prop_info->name, prop_info->description));
+				}
+			}
+
+		}
+	}
+	if (!found) {
+		if (pass_exact) {
+			pass_exact = GF_FALSE;
+			goto redo_pass;
+		}
+
+		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("No filter%swith similar name found, see gpac -h filters%s\n",
+			is_help ? ", option or help command " : " ",
+			is_help ? ", gpac -h or search all help using gpac -hx" : ""
+		));
+	}
+}
+
+static void gpac_suggest_filter_arg(GF_Config *opts, const char *argname, u32 atype)
+{
+	char *keyname;
+	const char *keyval;
+	u32 i, count, len, nb_filters, j;
+	Bool f_found = GF_FALSE;
+	char szSep2;
+
+	if (gf_opts_get_bool("core", "no-argchk"))
+		return;
+
+	szSep0 = separator_set0;
+	szSep1 = 0;
+
+	len = (u32) strlen(argname);
+	keyname = gf_malloc(sizeof(char)*(len+3));
+	sprintf(keyname, "-%c%s", (atype==2) ? '+' : '-', argname);
+	keyval = gf_cfg_get_key(opts, "allopts", keyname);
+	gf_free(keyname);
+	if (keyval) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Argument \"%s%s\" was set but not used by any filter\n",
+		(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
+		return;
+	}
+
+	nb_filters = gf_fs_get_filters_count(session);
+	count = gf_cfg_get_key_count(opts, "allopts");
+	for (i=0; i<count; i++) {
+		Bool ffound = GF_FALSE;
+		char *enum_vals=NULL;
+		const char *arg = gf_cfg_get_key_name(opts, "allopts", i);
+		const char *aval = gf_cfg_get_key(opts, "allopts", arg);
+		if ((arg1=='+') && (atype!=2)) continue;
+		if ((arg1=='-') && (atype==2)) continue;
+
+		arg += 2;
+		char *sep = strchr(arg, '@');
+		if (sep) {
+			sep0 = 0;
+
+			if (!strcmp(arg, argname)) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Argument \"%s%s\" was set but not used by any filter\n",
+				(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
+				sep0 = '@';
+				return;
+			}
+
+			enum_vals = strstr(sep+1, argname);
+			if (enum_vals) {
+				if (!f_found) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unknown argument \"%s%s\" set but not used by any filter - possible matches\n",
+						(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
+					f_found = GF_TRUE;
+				}
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("- %s (%s) in filters %s\n", arg, sep+1, aval));
+				sep0 = '@';
+				continue;
+			}
+		}
+		u32 alen = (u32) strlen(arg);
+		if (alen>2*len) {
+			if (sep) sep0 = '@';
+			continue;
+		}
+
+		for (j=0; j<nb_filters; j++) {
+			GF_FilterStats stats;
+			stats.reg_name = NULL;
+			gf_fs_get_filter_stats(session, j, &stats);
+
+			if (stats.reg_name && strstr(aval, stats.reg_name)) {
+				ffound = GF_TRUE;
+				break;
+			}
+		}
+		if (!ffound) {
+			if (sep) sep0 = '@';
+			continue;
+		}
+		if (gf_sys_word_match(argname, arg)) {
+			if (!f_found) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unknown argument \"%s%s\" set but not used by any filter - possible matches\n",
+					(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
+				f_found = GF_TRUE;
+			}
+			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("- %s in filters %s\n", arg, aval));
+		}
+		if (sep) sep0 = '@';
+	}
+	if (!f_found) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Unknown argument \"%s%s\" set but not used by any filter - no matching argument found\n",
+			(atype==2) ? "-+" : (atype ? "--" : szSep), argname));
+	}
+}
+
+void gpac_check_session_args()
+{
+	GF_Config *opts = NULL;
+	u32 idx = 0;
+	const char *argname, *meta_name, *meta_opt;
+	u32 argtype;
+
+	while (1) {
+		if (gf_fs_enum_unmapped_options(session, &idx, &argname, &argtype, &meta_name, &meta_opt)==GF_FALSE)
+			break;
+
+		if (meta_name) {
+			if (meta_opt) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Filter %s:%s value \"%s\" set but not used\n", meta_name, meta_opt, argname));
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Filter %s:%s option set but not used\n", meta_name, argname));
+			}
+			continue;
+		}
+
+		if (!opts) {
+			const char *cfg_path = gf_opts_get_filename();
+			char *all_opts = gf_url_concatenate(cfg_path, "all_opts.txt");
+			opts = gf_cfg_new(NULL, all_opts);
+			gf_free(all_opts);
+		}
+		if (!opts) {
+			break;
+		}
+		gpac_suggest_filter_arg(opts, argname, argtype);
+	}
+	if (opts) gf_cfg_del(opts);
+}
+
+
+
+/*********************************************************
+		Filter and property info/dump functions
+*********************************************************/
+
+static void dump_caps(u32 nb_caps, const GF_FilterCapability *caps)
+{
+	u32 i;
+	for (i=0;i<nb_caps; i++) {
+		const char *szName;
+		const char *szVal;
+		char szDumpGF_PROP_DUMP_ARG_SIZE;
+		const GF_FilterCapability *cap = &capsi;
+		if (!(cap->flags & GF_CAPFLAG_IN_BUNDLE) && i+1==nb_caps) break;
+		if (!i) gf_sys_format_help(helpout, help_flags, "Capabilities Bundle:\n");
+		else if (!(cap->flags & GF_CAPFLAG_IN_BUNDLE) ) {
+			gf_sys_format_help(helpout, help_flags, "Capabilities Bundle:\n");
+			continue;
+		}
+
+		szName = cap->name ? cap->name : gf_props_4cc_get_name(cap->code);
+		if (!szName) szName = gf_4cc_to_str(cap->code);
+		gf_sys_format_help(helpout, help_flags, "\t Flags:");
+		if (cap->flags & GF_CAPFLAG_INPUT) gf_sys_format_help(helpout, help_flags, " Input");
+		if (cap->flags & GF_CAPFLAG_OUTPUT) gf_sys_format_help(helpout, help_flags, " Output");
+		if (cap->flags & GF_CAPFLAG_EXCLUDED) gf_sys_format_help(helpout, help_flags, " Exclude");
+		if (cap->flags & GF_CAPFLAG_LOADED_FILTER) gf_sys_format_help(helpout, help_flags, " LoadedFilterOnly");
+
+		//dump some interesting predefined ones which are not mapped to types
+		if (cap->code==GF_PROP_PID_STREAM_TYPE) szVal = gf_stream_type_name(cap->val.value.uint);
+		else if (cap->code==GF_PROP_PID_CODECID) szVal = (const char *) gf_codecid_name(cap->val.value.uint);
+		else szVal = gf_props_dump_val(&cap->val, szDump, GF_PROP_DUMP_DATA_NONE, NULL);
+
+		gf_sys_format_help(helpout, help_flags, " %s=\"%s\"", szName, szVal);
+		if (cap->priority) gf_sys_format_help(helpout, help_flags, ", priority=%d", cap->priority);
+		gf_sys_format_help(helpout, help_flags, "\n");
+	}
+}
+
+static void print_filter_arg(const GF_FilterArgs *a, u32 gen_doc)
+{
+	Bool is_enum = GF_FALSE;
+
+	if ((a->arg_type==GF_PROP_UINT) && a->min_max_enum && strchr(a->min_max_enum, '|')) {
+		is_enum = GF_TRUE;
+	}
+
+	if (gen_doc==1) {
+		gf_sys_format_help(helpout, help_flags, "<a id=\"%s\">", a->arg_name);
+		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s", a->arg_name);
+		gf_sys_format_help(helpout, help_flags, "</a> (%s", is_enum ? "enum" : gf_props_get_type_name(a->arg_type));
+	} else {
+		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s (%s", a->arg_name, is_enum ? "enum" : gf_props_get_type_name(a->arg_type));
+	}
+	if (a->arg_default_val) {
+		if (!strcmp(a->arg_default_val, "2147483647"))
+			gf_sys_format_help(helpout, help_flags, ", default: __+I__");
+		else if (!strcmp(a->arg_default_val, "-2147483648"))
+			gf_sys_format_help(helpout, help_flags, ", default: __-I__");
+		else
+			gf_sys_format_help(helpout, help_flags, ", default: __%s__", a->arg_default_val);
+	} else {
+//		gf_sys_format_help(helpout, help_flags, ", no default");
+	}
+	if (a->min_max_enum && !is_enum) {
+		if (!strcmp(a->min_max_enum, "-2147483648-I"))
+			gf_sys_format_help(helpout, help_flags, ", %s: -I-I", /*strchr(a->min_max_enum, '|') ? "Enum" : */"minmax");
+		else
+			gf_sys_format_help(helpout, help_flags, ", %s: %s", /*strchr(a->min_max_enum, '|') ? "Enum" : */"minmax", a->min_max_enum);
+	}
+	if (a->flags & GF_FS_ARG_UPDATE) gf_sys_format_help(helpout, help_flags, ", updatable");
+//		if (a->flags & GF_FS_ARG_META) gf_sys_format_help(helpout, help_flags, ", meta");
+
+	if (is_enum && a->arg_desc && !strchr(a->arg_desc, '\n')) {
+		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_OPT_DESC, "): %s (%s)\n", a->arg_desc, a->min_max_enum);
+	} else {
+		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_OPT_DESC, "): %s\n", a->arg_desc);
+	}
+
+	//check syntax
+	if (gen_doc) {
+		GF_GPACArg _a;
+		memset(&_a, 0, sizeof(GF_GPACArg));
+		_a.name = a->arg_name;
+		_a.description = a->arg_desc;
+		_a.flags = GF_ARG_HINT_HIDE;
+		gf_sys_print_arg(NULL, 0, &_a, "");
+	}
+
+	if (a->min_max_enum && strchr(a->min_max_enum, '|'))
+		gf_sys_format_help(helpout, help_flags, "\n");
+	else if (!a->min_max_enum && a->arg_desc && strstr(a->arg_desc, "\n- "))
+		gf_sys_format_help(helpout, help_flags, "\n");
+}
+
+static void print_filter_single_opt(const GF_FilterRegister *reg, char *optname, GF_Filter *filter_inst)
+{
+	u32 idx=0;
+	Bool found = GF_FALSE;
+	const GF_FilterArgs *args = NULL;
+	if (filter_inst)
+		args = gf_filter_get_args(filter_inst);
+	else if (reg)
+		args = reg->args;
+
+	if (!args) return;
+
+	while (1) {
+		const GF_FilterArgs *a = & argsidx;
+		if (!a || !a->arg_name) break;
+		idx++;
+		if (strcmp(a->arg_name, optname)) continue;
+
+		print_filter_arg(a, 0);
+		found = GF_TRUE;
+		break;
+	}
+	if (found) return;
+
+	idx = 0;
+	while (1) {
+		const GF_FilterArgs *a = & argsidx;
+		if (!a || !a->arg_name) break;
+		idx++;
+		if (gf_sys_word_match(optname, a->arg_name)
+			|| (a->arg_desc && strstr(a->arg_desc, optname))
+		) {
+			if (!found) {
+				found = GF_TRUE;
+				fprintf(stderr, "No such option %s for filter %s - did you mean:\n", optname, filter_inst ? gf_filter_get_name(filter_inst) : reg->name);
+			}
+			fprintf(stderr, " - %s: %s\n", a->arg_name, a->arg_desc);
+		}
+	}
+	if (found) return;
+
+	fprintf(stderr, "No such option %s for filter %s\n", optname, filter_inst ? gf_filter_get_name(filter_inst) : reg->name);
+}
+
+static void print_filter(const GF_FilterRegister *reg, GF_SysArgMode argmode, GF_Filter *filter_inst, char *inst_name)
+{
+	u32 idx=0;
+	const GF_FilterArgs *args = NULL;
+	const char *reg_name, *reg_desc=NULL;
+#ifndef GPAC_DISABLE_DOC
+	const char *reg_help;
+#endif
+	Bool jsmod_help = (argmode>GF_ARGMODE_ALL) ? GF_TRUE : GF_FALSE;
+
+	if (filter_inst) {
+		reg_name = inst_name;
+		reg_desc = gf_filter_get_description(filter_inst);
+#ifndef GPAC_DISABLE_DOC
+		reg_help = gf_filter_get_help(filter_inst);
+#endif
+	} else if (reg) {
+		reg_name = reg->name;
+#ifndef GPAC_DISABLE_DOC
+		reg_desc = reg->description;
+		reg_help = reg->help;
+#endif
+	} else {
+		return;
+	}
+
+	//happens on some meta filter or JS filters
+	if (!reg_desc) {
+		reg_desc = "No description available";
+	}
+
+	if (gen_doc==1) {
+		char szName1024;
+		sprintf(szName, "%s.md", reg_name);
+
+		gf_fclose(helpout);
+		helpout = gf_fopen(szName, "w");
+		fprintf(helpout, "%s", auto_gen_md_warning);
+
+		if (!sidebar_md) {
+			char *sbbuf = NULL;
+			if (gf_file_exists("_Sidebar.md")) {
+				char szLine1024;
+				u32 end_pos=0;
+				sidebar_md = gf_fopen("_Sidebar.md", "r");
+				gf_fseek(sidebar_md, 0, SEEK_SET);
+				while (!feof(sidebar_md)) {
+					char *read = gf_fgets(szLine, 1024, sidebar_md);
+					if (!read) break;
+					if (!strncmp(szLine, "**Filters Help**", 16)) {
+						end_pos = (u32) gf_ftell(sidebar_md);
+						break;
+					}
+				}
+				if (!end_pos) end_pos = (u32) gf_ftell(sidebar_md);
+				if (end_pos) {
+					sbbuf = gf_malloc(end_pos+1);
+					gf_fseek(sidebar_md, 0, SEEK_SET);
+					end_pos = (u32) gf_fread(sbbuf, end_pos, sidebar_md);
+					sbbufend_pos=0;
+					gf_fclose(sidebar_md);
+				}
+			}
+			sidebar_md = gf_fopen("_Sidebar.md", "w");
+			if (sbbuf) {
+				fprintf(sidebar_md, "%s\n \n", sbbuf);
+				gf_free(sbbuf);
+			}
+		}
+		fprintf(sidebar_md, "%s (%s)|%s \n", reg_desc, reg_name, reg_name);
+#ifndef GPAC_DISABLE_DOC
+
+		if (!reg_help) {
+			fprintf(stderr, "filter %s without help, forbidden\n", reg_name);
+			exit(1);
+		}
+#endif
+
+#ifndef GPAC_DISABLE_DOC
+		gf_sys_format_help(helpout, help_flags, "# %s\n", reg_desc);
+#endif
+		gf_sys_format_help(helpout, help_flags, "Register name used to load filter: **%s**\n", reg_name);
+		if (filter_inst) {
+			gf_sys_format_help(helpout, help_flags, "This is a JavaScript filter, not checked during graph resolution and needs explicit loading.\n");
+		} else {
+			if (reg->flags & GF_FS_REG_EXPLICIT_ONLY) {
+				gf_sys_format_help(helpout, help_flags, "This filter is not checked during graph resolution and needs explicit loading.\n");
+			} else {
+				gf_sys_format_help(helpout, help_flags, "This filter may be automatically loaded during graph resolution.\n");
+			}
+			if (reg->flags & GF_FS_REG_REQUIRES_RESOLVER) {
+				gf_sys_format_help(helpout, help_flags, "This filter requires the graph resolver to be activated.\n");
+			}
+			if (reg->flags & GF_FS_REG_ALLOW_CYCLIC) {
+				gf_sys_format_help(helpout, help_flags, "Filters of this class can connect to each-other.\n");
+			}
+		}
+	} else if (!jsmod_help) {
+		gf_sys_format_help(helpout, help_flags, "# %s\n", reg_name);
+		gf_sys_format_help(helpout, help_flags, "Description: %s\n", reg_desc );
+
+		if (filter_inst) {
+			const char *version = gf_filter_get_version(filter_inst);
+			if (version)
+				gf_sys_format_help(helpout, help_flags, "Version: %s\n", version );
+		} else {
+			if (reg->version) {
+				if (!strncmp(reg->version, "! ", 2)) {
+					if (!gen_doc)
+						gf_sys_format_help(helpout, help_flags, "%s\n", reg->version+2);
+				} else {
+					gf_sys_format_help(helpout, help_flags, "Version: %s\n", reg->version);
+				}
+			}
+		}
+	}
+
+	if (filter_inst) {
+		const char *str;
+		if (!jsmod_help) {
+			str = gf_filter_get_author(filter_inst);
+			if (str)
+				gf_sys_format_help(helpout, help_flags, "%s: %s\n", (str0=='-') ? "Configuration" : "Author", str );
+		}
+		str = gf_filter_get_help(filter_inst);
+		if (str)
+			gf_sys_format_help(helpout, help_flags, "\n%s\n\n", str);
+	} else if (reg) {
+#ifndef GPAC_DISABLE_DOC
+		if (reg->author) {
+			if (reg->author0=='-') {
+				if (! (help_flags & (GF_PRINTARG_MD|GF_PRINTARG_MAN))) {
+					gf_sys_format_help(helpout, help_flags, "Configuration: %s\n", reg->author);
+				}
+			} else {
+				gf_sys_format_help(helpout, help_flags, "Author: %s\n", reg->author);
+			}
+		}
+		if (reg->help) {
+			u32 hf = help_flags;
+			if (gen_doc==1) hf |= GF_PRINTARG_ESCAPE_XML;
+			gf_sys_format_help(helpout, hf, "\n%s\n\n", reg->help);
+		}
+#else
+		gf_sys_format_help(helpout, help_flags, "GPAC compiled without built-in doc\n");
+#endif
+	}
+
+	if (reg && (argmode==GF_ARGMODE_EXPERT)) {
+		if (reg->max_extra_pids==(u32) -1) gf_sys_format_help(helpout, help_flags, "Max Input PIDs: any\n");
+		else gf_sys_format_help(helpout, help_flags, "Max Input PIDs: %d\n", 1 + reg->max_extra_pids);
+
+		gf_sys_format_help(helpout, help_flags, "Flags:");
+		if (reg->flags & GF_FS_REG_EXPLICIT_ONLY) gf_sys_format_help(helpout, help_flags, " ExplicitOnly");
+		if (reg->flags & GF_FS_REG_MAIN_THREAD) gf_sys_format_help(helpout, help_flags, " MainThread");
+		if (reg->flags & GF_FS_REG_CONFIGURE_MAIN_THREAD) gf_sys_format_help(helpout, help_flags, " ConfigureMainThread");
+		if (reg->flags & GF_FS_REG_HIDE_WEIGHT) gf_sys_format_help(helpout, help_flags, " HideWeight");
+		if (reg->flags & GF_FS_REG_REQUIRES_RESOLVER) gf_sys_format_help(helpout, help_flags, " RequireResolver");
+		if (reg->flags & GF_FS_REG_ALLOW_CYCLIC) gf_sys_format_help(helpout, help_flags, " CyclicAllowed");
+		if (reg->probe_url) gf_sys_format_help(helpout, help_flags, " URLMimeProber");
+		if (reg->probe_data) gf_sys_format_help(helpout, help_flags, " DataProber");
+		if (reg->reconfigure_output) gf_sys_format_help(helpout, help_flags, " ReconfigurableOutput");
+
+		gf_sys_format_help(helpout, help_flags, "\nPriority %d", reg->priority);
+
+		gf_sys_format_help(helpout, help_flags, "\n");
+	}
+
+	if (filter_inst) args = gf_filter_get_args(filter_inst);
+	else args = reg->args;
+
+	u32 nb_opts=0;
+	idx=0;
+	while (args) {
+		const GF_FilterArgs *a = & argsidx;
+		if (!a || !a->arg_name) break;
+		idx++;
+		if (a->flags & GF_FS_ARG_HINT_HIDE) continue;
+		nb_opts++;
+	}
+	if (!nb_opts)
+		args = NULL;
+
+	if (args && !jsmod_help) {
+		idx=0;
+		if (gen_doc==1) {
+			gf_sys_format_help(helpout, help_flags, "# Options \n");
+		} else {
+			switch (argmode) {
+			case GF_ARGMODE_ALL:
+			case GF_ARGMODE_EXPERT:
+				gf_sys_format_help(helpout, help_flags, "# Options (expert):\n");
+				break;
+			case GF_ARGMODE_ADVANCED:
+				gf_sys_format_help(helpout, help_flags, "# Options (advanced):\n");
+				break;
+			case GF_ARGMODE_BASE:
+				gf_sys_format_help(helpout, help_flags, "# Options (basic):\n");
+				break;
+			}
+		}
+
+		while (1) {
+			const GF_FilterArgs *a = & argsidx;
+			if (!a || !a->arg_name) break;
+			idx++;
+
+			if (a->flags & GF_FS_ARG_HINT_HIDE) continue;
+
+			switch (argmode) {
+			case GF_ARGMODE_ALL:
+			case GF_ARGMODE_EXPERT:
+			 	break;
+			case GF_ARGMODE_ADVANCED:
+			 	if (a->flags & GF_FS_ARG_HINT_EXPERT) continue;
+			 	break;
+			case GF_ARGMODE_BASE:
+			 	if (a->flags & (GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_HINT_ADVANCED)) continue;
+			 	break;
+			}
+
+			print_filter_arg(a, gen_doc);
+
+			if (!gen_doc) continue;
+
+#ifdef CHECK_DOC
+			if (a->flags & GF_FS_ARG_META) continue;
+
+			u8 achar;
+			char szArg100;
+			sprintf(szArg, " %s ", a->arg_name);
+#ifndef GPAC_DISABLE_DOC
+			u32 j=0;
+			char *quoted = reg_help ? strstr(reg_help, szArg) : NULL;
+			if (quoted) {
+				fprintf(stderr, "\nWARNING: filter %s bad help, uses arg %s without link: \"... %s\"\n", reg_name, a->arg_name, quoted);
+				exit(1);
+			}
+			while (1) {
+				const GF_FilterArgs *anarg = & argsj;
+				if (!anarg || !anarg->arg_name) break;
+				j++;
+				if (a == anarg) continue;
+				if (reg_help && strstr(reg_help, szArg)) {
+					fprintf(stderr, "\nWARNING: filter %s bad description for argument %s, uses arg %s without link\n", reg_name, anarg->arg_name, a->arg_name);
+					exit(1);
+				}
+			}
+#endif
+
+			if (a->min_max_enum) {
+				//check format
+ if ((a->arg_type!=GF_PROP_UINT_LIST) && !(a->flags&GF_FS_ARG_META) && strchr(a->min_max_enum, '|') && (!a->arg_default_val || strcmp(a->arg_default_val, "-1")) ) {
+					const char *a_val = a->min_max_enum;
+					while (a_val0 == '|') a_val++;
+					if (strstr(a->arg_desc, "see filter "))
+						a_val = NULL;
+					while (a_val) {
+						char szName100;
+						const char *a_sep = strchr(a_val, '|');
+						u32 len = a_sep ? (u32)(a_sep - a_val) : (u32)strlen(a_val);
+						strcpy(szName, "- ");
+						strncat(szName, a_val, MIN(sizeof(szName)-3,len));
+						szName2+len=0;
+						strcat(szName, ": ");
+
+						if (!strstr(a->arg_desc, szName)) {
+							fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, missing list bullet \"%s\"\n", reg_name, a->arg_name, szName);
+							exit(1);
+						}
+						if (!a_sep) break;
+						a_val = a_sep+1;
+					}
+					if (a_val && !strstr(a->arg_desc, "- ")) {
+ 	fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, missing list bullet \"- \"\n", reg_name, a->arg_name);
+ 	exit(1);
+					}
+					if (a_val && strstr(a->arg_desc, ":\n")) {
+ 	fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should not use \":\\n\"\n", reg_name, a->arg_name);
+ 	exit(1);
+					}
+ } else if (!(a->flags&GF_FS_ARG_META) && strchr(a->arg_desc, '\n')) {
+					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should not contain \"\\n\"\n", reg_name, a->arg_name);
+					exit(1);
+				}
+			}
+ if (!(a->flags&GF_FS_ARG_META)) {
+				char *sep;
+
+				achar = a->arg_descstrlen(a->arg_desc)-1;
+				if (achar == '\n') {
+					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should not end with \"\\n\"\n", reg_name, a->arg_name);
+					exit(1);
+				}
+
+				achar = a->arg_desc0;
+				if ((achar >= 'A') && (achar <= 'Z')) {
+					achar = a->arg_desc1;
+					if ((achar < 'A') || (achar > 'Z')) {
+						fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, should start with lowercase\n", reg_name, a->arg_name);
+						exit(1);
+					}
+				}
+				if (a->arg_desc0 == ' ') {
+					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, first character should not be space\n", reg_name, a->arg_name);
+					exit(1);
+				}
+				sep = strchr(a->arg_desc+1, ' ');
+				if (sep) sep--;
+				if (sep && (sep0 == 's') && (sep-1 != 's')) {
+					fprintf(stderr, "\nWARNING: filter %s bad description format for arg %s, first word should be infinitive\n", reg_name, a->arg_name);
+					exit(1);
+				}
+			}
+#endif
+		}
+	} else if (!args) {
+		gf_sys_format_help(helpout, help_flags, "No options\n");
+	}
+
+	if (!gen_doc && (argmode==GF_ARGMODE_ALL)) {
+		if (filter_inst) {
+			u32 nb_caps = 0;
+			const GF_FilterCapability *caps = gf_filter_get_caps(filter_inst, &nb_caps);
+			dump_caps(nb_caps, caps);
+		} else if (reg->nb_caps) {
+			dump_caps(reg->nb_caps, reg->caps);
+		}
+	}
+	gf_sys_format_help(helpout, help_flags, "\n");
+}
+
+static Bool strstr_nocase(const char *text, const char *subtext, u32 subtext_len)
+{
+	if (!*text || !subtext || !subtext_len)
+		return GF_FALSE;
+
+	while (*text) {
+		if (tolower(*text) == *subtext) {
+			if (!strnicmp(text, subtext, subtext_len))
+				return GF_TRUE;
+
+		}
+		text++;
+	}
+	return GF_FALSE;
+}
+
+
+struct __jsenum_info
+{
+	GF_FilterSession *session;
+	GF_SysArgMode argmode;
+	Bool print_filter_info;
+	const char *path;
+	char *js_dir;
+};
+
+static Bool jsinfo_enum(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
+{
+	struct __jsenum_info *jsi = (struct __jsenum_info *)cbck;
+	GF_Filter *f;
+	if (jsi->js_dir && strcmp(item_name, "init.js")) {
+		return GF_FALSE;
+	}
+
+	f = gf_fs_load_filter(jsi->session, item_path, NULL);
+	if (f) {
+		char szPathGF_MAX_PATH;
+		char *ext;
+		if (jsi->js_dir) {
+			strcpy(szPath, jsi->js_dir);
+		} else {
+			strcpy(szPath, item_name);
+		}
+		ext = gf_file_ext_start(szPath);
+		if (ext) ext0 = 0;
+
+		if (jsi->print_filter_info || gen_doc)
+			print_filter(NULL, jsi->argmode, f, szPath);
+		else
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s: %s\n", szPath, gf_filter_get_description(f));
+	}
+	return GF_FALSE;
+}
+static Bool jsinfo_dir_enum(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
+{
+	char szPathGF_MAX_PATH;
+	struct __jsenum_info *jsi = (struct __jsenum_info *)cbck;
+	jsi->js_dir = item_name;
+
+	strcpy(szPath, jsi->path);
+	strcat(szPath, item_name);
+	strcat(szPath, "/");
+	gf_enum_directory(szPath, GF_FALSE, jsinfo_enum, jsi, ".js");
+	jsi->js_dir = NULL;
+	return GF_FALSE;
+}
+
+
+Bool print_filters(int argc, char **argv, GF_SysArgMode argmode)
+{
+	Bool found = GF_FALSE;
+	Bool print_all = GF_FALSE;
+	char *fname = NULL;
+	char *l_fname = NULL;
+	u32 lf_len = 0;
+	u32 i, count = gf_fs_filters_registers_count(session);
+
+	if (!gen_doc && list_filters) gf_sys_format_help(helpout, help_flags, "Listing %d supported filters%s:\n", count, (list_filters==2) ? " including meta-filters" : "");
+
+	if (print_filter_info != 1) {
+		for (i=0; i<count; i++) {
+			const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+			if (gen_doc) {
+				print_filter(reg, argmode, NULL, NULL);
+			} else if (print_filter_info) {
+				print_filter(reg, argmode, NULL, NULL);
+			} else {
+#ifndef GPAC_DISABLE_DOC
+				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s: %s\n", reg->name, reg->description);
+#else
+				gf_sys_format_help(helpout, help_flags, "%s (compiled without built-in doc)\n", reg->name);
+#endif
+			}
+		}
+		found = GF_TRUE;
+	}
+	//print a specific filter info, browse args
+	else {
+		u32 k;
+		//all good to go, load filters
+		for (k=1; k<(u32) argc; k++) {
+			char *arg = argvk;
+			char *sepe;
+			Bool found_freg = GF_FALSE;
+			char *optname = NULL;
+			if (arg0=='-') continue;
+
+			sepe = gf_file_basename(arg);
+			if (sepe) sepe = strchr(sepe, '.');
+			if (sepe) {
+				if (!strncmp(sepe, ".js.", 4)) sepe = strchr(sepe+1, '.');
+				else if (!strcmp(sepe, ".js")) sepe = NULL;
+				if (sepe) {
+					sepe0 = 0;
+					optname = sepe+1;
+				}
+			}
+			fname = arg;
+			for (i=0; i<count; i++) {
+				const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+				//exact match
+				if (!strcmp(arg, reg->name) ) {
+					if (optname)
+						print_filter_single_opt(reg, optname, NULL);
+					else
+						print_filter(reg, argmode, NULL, NULL);
+					found_freg = GF_TRUE;
+				}
+				//search for name:*, also accept *:*
+				else {
+					char *sepo = strchr(arg, ':');
+
+					if (!strcmp(arg, "*:*") || !strcmp(arg, "@:@")
+						|| (!sepo && (!strcmp(arg, "*") || !strcmp(arg, "@")) )
+						|| (sepo && (!strcmp(sepo, ":*") || !strcmp(sepo, ":@")) && !strncmp(reg->name, arg, 1+sepo - arg) )
+					) {
+						if (optname)
+							print_filter_single_opt(reg, optname, NULL);
+						else
+							print_filter(reg, argmode, NULL, NULL);
+						found_freg = GF_TRUE;
+						if (!strcmp(arg, "*")) print_all = GF_TRUE;
+					}
+				}
+			}
+			if (found_freg) {
+				found = GF_TRUE;
+			} else /*if (!strchr(arg, ':')) */ {
+				GF_SysArgMode _argmode = argmode;
+				char *js_opt = strchr(arg, ':');
+				if (js_opt) {
+					js_opt0 = 0;
+					gf_opts_set_key("temp", "gpac-js-help", js_opt+1);
+					_argmode = GF_ARGMODE_ALL+1;
+				}
+				//try to load the filter (JS)
+				GF_Filter *f = gf_fs_load_filter(session, arg, NULL);
+				const GF_FilterRegister *reg = f ? gf_filter_get_register(f) : NULL;
+				if (!reg || !(reg->flags & GF_FS_REG_SCRIPT))
+					f = NULL;
+
+				if (f) {
+					char *ext;
+					char szPathGF_MAX_PATH;
+					strcpy(szPath, gf_file_basename(arg) );
+					ext = gf_file_ext_start(szPath);
+					if (ext) ext0 = 0;
+					if (optname) {
+						print_filter_single_opt(NULL, optname, f);
+					} else {
+						print_filter(NULL, _argmode, f, szPath);
+					}
+					found = GF_TRUE;
+				}
+				if (js_opt) {
+					js_opt0 = ':';
+					gf_opts_set_key("temp", "gpac-js-help", NULL);
+				}
+			}
+			if (sepe) sepe0 = '.';
+		}
+	}
+
+	if (print_all || !print_filter_info || gen_doc) {
+		const char *js_dirs = gf_opts_get_key("core", "js-dirs");
+		char szPathGF_MAX_PATH;
+		struct __jsenum_info jsi;
+		memset(&jsi, 0, sizeof(struct __jsenum_info));
+		jsi.argmode = argmode;
+		jsi.session = session;
+		jsi.print_filter_info = print_filter_info;
+
+		gf_log_set_tools_levels("console@error", GF_FALSE);
+
+		if (gf_opts_default_shared_directory(szPath)) {
+			strcat(szPath, "/scripts/jsf/");
+			jsi.path = szPath;
+			gf_enum_directory(szPath, GF_FALSE, jsinfo_enum, &jsi, ".js");
+			gf_enum_directory(szPath, GF_TRUE, jsinfo_dir_enum, &jsi, NULL);
+		}
+		while (js_dirs && js_dirs0) {
+			char *sep = strchr(js_dirs, ',');
+			if (sep) {
+				u32 cplen = (u32) (sep-js_dirs);
+				if (cplen>=GF_MAX_PATH) cplen = GF_MAX_PATH-1;
+				strncpy(szPath, js_dirs, cplen);
+				szPathcplen=0;
+				js_dirs = sep+1;
+			} else {
+				strcpy(szPath, js_dirs);
+			}
+			//pre 1.1, $GJS was inserted by default
+			if (strcmp(szPath, "$GJS")) {
+				u32 len = (u32) strlen(szPath);
+				if (len && (szPathlen-1!='/') && (szPathlen-1!='\\'))
+					strcat(szPath, "/");
+				gf_enum_directory(szPath, GF_FALSE, jsinfo_enum, &jsi, ".js");
+			}
+			if (!sep) break;
+		}
+		return GF_TRUE;
+	}
+
+
+	if (found) return GF_TRUE;
+	if (!fname) return GF_FALSE;
+	if (!print_filter_info) return GF_FALSE;
+	if (gen_doc) return GF_FALSE;
+
+	if (argmode==GF_ARGMODE_EXPERT) {
+		l_fname = gf_strdup(fname);
+		strlwr(l_fname);
+		lf_len = (u32) strlen(l_fname);
+	}
+
+	for (i=0; i<count; i++) {
+		u32 j=0;
+		const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+
+		while (reg->args) {
+			const GF_FilterArgs *arg = &reg->argsj;
+			if (!arg || !arg->arg_name) break;
+			j++;
+			if (argmode==GF_ARGMODE_EXPERT) {
+				if (!arg->arg_desc || !strstr_nocase(arg->arg_desc, l_fname, lf_len)) continue;
+				if (!found) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("\"%s\" is mentioned in the following filters options:\n", fname));
+					found = GF_TRUE;
+				}
+				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s \n", reg->name, arg->arg_name);
+#if 0
+
+			} else {
+				if (strcmp(arg->arg_name, fname)) continue;
+				if (!found) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("No such filter \"%s\" but found filters with matching options:\n", fname));
+					found = GF_TRUE;
+				}
+				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s.%s: %s\n", reg->name, arg->arg_name, arg->arg_desc);
+#endif
+			}
+		}
+	}
+	if (l_fname) gf_free(l_fname);
+
+
+	if (found) return GF_TRUE;
+
+	gpac_suggest_filter(fname, GF_TRUE, GF_FALSE);
+	return GF_FALSE;
+}
+
+void dump_all_props(char *pname)
+{
+	u32 i=0, pname_len = pname ? (u32) strlen(pname) : 0;
+	const GF_BuiltInProperty *prop_info;
+
+	if (gen_doc==1) {
+		gf_sys_format_help(helpout, help_flags, "## Built-in property types\n"
+		" \n");
+
+		gf_sys_format_help(helpout, help_flags, "Name | Description \n");
+		gf_sys_format_help(helpout, help_flags, "--- | --- \n");
+		for (i=GF_PROP_FORBIDEN+1; i<GF_PROP_LAST_DEFINED; i++) {
+			if (i==GF_PROP_STRING_NO_COPY) continue;
+			if (i==GF_PROP_DATA_NO_COPY) continue;
+			if (i==GF_PROP_STRING_LIST_COPY) continue;
+			if ((i>=GF_PROP_LAST_NON_ENUM) && (i<GF_PROP_FIRST_ENUM)) continue;
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s \n", gf_props_get_type_name(i), gf_props_get_type_desc(i) );
+		}
+
+		gf_sys_format_help(helpout, help_flags, "## Built-in properties for PIDs and packets, pixel formats and audio formats\n"
+		" \n"
+		"Flags can be:\n"
+		"- D: droppable property, see GSF multiplexer(gsfmx) filter help for more info\n"
+		"- P: property applying to packet\n"
+		" \n");
+		gf_sys_format_help(helpout, help_flags, "Name | type | Flags | Description | 4CC \n");
+		gf_sys_format_help(helpout, help_flags, "--- | --- | --- | --- | --- \n");
+	} else if (pname) {
+		gf_sys_format_help(helpout, help_flags, "Built-in properties matching `%s` for PIDs and packets listed as `Name (4CC type FLAGS): description`\n`FLAGS` can be D (droppable - see GSF multiplexer filter help), P (packet property)\n", pname);
+	} else {
+		gf_sys_format_help(helpout, help_flags, "Built-in property types\n");
+		for (i=GF_PROP_FORBIDEN+1; i<GF_PROP_LAST_DEFINED; i++) {
+			if (i==GF_PROP_STRING_NO_COPY) continue;
+			if (i==GF_PROP_DATA_NO_COPY) continue;
+			if (i==GF_PROP_STRING_LIST_COPY) continue;
+			if ((i>=GF_PROP_LAST_NON_ENUM) && (i<GF_PROP_FIRST_ENUM)) continue;
+
+			if (gen_doc==2) {
+				gf_sys_format_help(helpout, help_flags, ".TP\n.B %s\n%s\n", gf_props_get_type_name(i), gf_props_get_type_desc(i));
+			} else {
+				gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s : %s\n", gf_props_get_type_name(i), gf_props_get_type_desc(i) );
+			}
+		}
+		gf_sys_format_help(helpout, help_flags, "\n\n");
+
+		gf_sys_format_help(helpout, help_flags, "Built-in properties for PIDs and packets listed as `Name (4CC type FLAGS): description`\n`FLAGS` can be D (droppable - see GSF multiplexer filter help), P (packet property)\n");
+	}
+	i=0;
+	while ((prop_info = gf_props_get_description(i))) {
+		i++;
+		char szFlags10;
+		if (! prop_info->name) continue;
+
+		if (gen_doc==1) {
+			strcpy(szFlags, "");
+			if (prop_info->flags & GF_PROP_FLAG_GSF_REM) strcat(szFlags, "D");
+			if (prop_info->flags & GF_PROP_FLAG_PCK) strcat(szFlags, "P");
+
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s | %s | %s | %s \n", prop_info->name, gf_props_get_type_name(prop_info->data_type),
+				szFlags,
+			 	prop_info->description,
+			 	gf_4cc_to_str(prop_info->type)
+			);
+		} else if (gen_doc==2) {
+			gf_sys_format_help(helpout, help_flags, ".TP\n.B %s (%s,%s,%s%s)\n%s\n", prop_info->name, gf_4cc_to_str(prop_info->type), gf_props_get_type_name(prop_info->data_type),
+			 	(prop_info->flags & GF_PROP_FLAG_GSF_REM) ? "D" : " ",
+			 	(prop_info->flags & GF_PROP_FLAG_PCK) ? "P" : " ",
+				prop_info->description);
+		} else {
+			u32 len;
+			const char *ptype;
+
+			if (pname) {
+				if (gf_sys_word_match(prop_info->name, pname)) {}
+				else if (gf_strnistr(prop_info->description, pname, pname_len)) {}
+				else continue;
+			}
+			szFlags0=0;
+			if (prop_info->flags & GF_PROP_FLAG_GSF_REM) strcat(szFlags, "D");
+			if (prop_info->flags & GF_PROP_FLAG_PCK) strcat(szFlags, "P");
+
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s", prop_info->name);
+			len = (u32) strlen(prop_info->name);
+			while (len<16) {
+				gf_sys_format_help(helpout, help_flags, " ");
+				len++;
+			}
+			ptype = gf_props_get_type_name(prop_info->data_type);
+			gf_sys_format_help(helpout, help_flags, " (%s %s %s):", gf_4cc_to_str(prop_info->type), ptype, szFlags);
+			len += (u32) strlen(ptype) + (u32) strlen(szFlags);
+			while (len<24) {
+				gf_sys_format_help(helpout, help_flags, " ");
+				len++;
+			}
+
+			gf_sys_format_help(helpout, help_flags, "%s", prop_info->description);
+
+			if (prop_info->data_type==GF_PROP_PIXFMT) {
+				gf_sys_format_help(helpout, help_flags, "\n\tNames: %s\n\tFile extensions: %s", gf_pixel_fmt_all_names(), gf_pixel_fmt_all_shortnames() );
+			} else if (prop_info->data_type==GF_PROP_PCMFMT) {
+				gf_sys_format_help(helpout, help_flags, "\n\tNames: %s\n\tFile extensions: %s", gf_audio_fmt_all_names(), gf_audio_fmt_all_shortnames() );
+			} else if (gf_props_type_is_enum(prop_info->data_type)) {
+				gf_sys_format_help(helpout, help_flags, "\n\tNames: %s\n\t", gf_props_enum_all_names(prop_info->data_type) );
+			}
+			gf_sys_format_help(helpout, help_flags, "\n");
+		}
+	}
+	if (gen_doc==1) {
+		u32 idx=0;
+		u32 cicp;
+		u64 layout;
+		GF_PixelFormat pfmt;
+		const char *name, *fileext, *desc;
+		gf_sys_format_help(helpout, help_flags, "# Pixel formats\n");
+		gf_sys_format_help(helpout, help_flags, "Name | File extensions | QT 4CC | Description \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- | --- | --- \n");
+		while ( (pfmt = gf_pixel_fmt_enum(&idx, &name, &fileext, &desc) )) {
+			const char *qtname = "";
+			u32 qt_code = gf_pixel_fmt_to_qt_type(pfmt);
+			if (qt_code) qtname = gf_4cc_to_str(qt_code);
+
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s | %s | %s \n", name, fileext, qtname, desc);
+		}
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Audio formats\n");
+		gf_sys_format_help(helpout, help_flags, " Name | File extensions | Description \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- | --- \n");
+		while ( gf_audio_fmt_enum(&idx, &name, &fileext, &desc)) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s | %s \n", name, fileext, desc);
+		}
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Stream types\n");
+		gf_sys_format_help(helpout, help_flags, " Name | Description \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- \n");
+		while ( gf_stream_types_enum(&idx, &name, &desc)) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %s \n", name, desc);
+		}
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Codecs\n");
+		gf_sys_format_help(helpout, help_flags, "The codec name identifies a codec within GPAC. There can be several names for a given codec. The first name is used as a default file extension when dumping a raw media stream. \n\n"
+			"_NOTE: This table does not include meta filters (ffmpeg, ...). Use `gpac -hx codecs` to list them._ \n"
+			" \n");
+
+		gf_sys_format_help(helpout, help_flags, " Name | Description \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- \n");
+		while ( gf_codecid_enum(idx, &name, &desc)) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR | GF_PRINTARG_ESCAPE_PIPE, "%s | %s \n", name, desc);
+			idx++;
+		}
+
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Audio channel layout code points (ISO/IEC 23091-3)\n");
+		gf_sys_format_help(helpout, help_flags, " Name | Integer value | ChannelMask \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- | --- \n");
+		while ( (cicp = gf_audio_fmt_cicp_enum(idx, &name, &layout)) ) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | %d | 0x%016"LLX_SUF" \n", name, cicp, layout);
+			idx++;
+		}
+
+		gf_sys_format_help(helpout, help_flags, "# Color Primaries code points (ISO/IEC 23091-2)\n");
+		gf_sys_format_help(helpout, help_flags, " Name | Integer value \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- \n");
+		for (i=0; i<GF_CICP_PRIM_LAST; i++) {
+			name = gf_cicp_color_primaries_name(i);
+			if (!name || !strcmp(name, "unknown")) continue;
+			gf_sys_format_help(helpout, help_flags, " %s | %d \n", name, i);
+		}
+		gf_sys_format_help(helpout, help_flags, "# Transfer Characteristics code points (ISO/IEC 23091-2)\n");
+		gf_sys_format_help(helpout, help_flags, " Name | Integer value \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- \n");
+		for (i=0; i<GF_CICP_TRANSFER_LAST; i++) {
+			name = gf_cicp_color_transfer_name(i);
+			if (!name) continue;
+			gf_sys_format_help(helpout, help_flags, " %s | %d \n", name, i);
+		}
+		gf_sys_format_help(helpout, help_flags, "# Matrix Coefficients code points (ISO/IEC 23091-2)\n");
+		gf_sys_format_help(helpout, help_flags, " Name | Integer value \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- \n");
+		for (i=0; i<GF_CICP_MX_LAST; i++) {
+			name = gf_cicp_color_matrix_name(i);
+			if (!name) continue;
+			gf_sys_format_help(helpout, help_flags, " %s | %d \n", name, i);
+		}
+	} else if (gen_doc==2) {
+		u32 idx=0, cicp;
+		u64 layout;
+		const char *name, *fileext, *desc;
+		gf_sys_format_help(helpout, help_flags, "# Pixel formats\n");
+		while ( gf_pixel_fmt_enum(&idx, &name, &fileext, &desc)) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s (ext *.%s)\n%s\n", name, fileext, desc);
+		}
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Audio formats\n");
+		while ( gf_audio_fmt_enum(&idx, &name, &fileext, &desc)) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s (ext *.%s)\n%s\n", name, fileext, desc);
+		}
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Stream types\n");
+		while ( gf_stream_types_enum(&idx, &name, &desc)) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s\n%s\n", name, desc);
+		}
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Codecs\n");
+		while ( gf_codecid_enum(idx, &name, &desc)) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s\n%s\n", name, desc);
+			idx++;
+		}
+
+		idx=0;
+		gf_sys_format_help(helpout, help_flags, "# Stream types\n");
+		while ( (cicp = gf_audio_fmt_cicp_enum(idx, &name, &layout)) ) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, ".TP\n.B %s (int %d)\nLayout 0x%016"LLX_SUF"\n", name, cicp, layout);
+			idx++;
+		}
+	}
+}
+#include <gpac/color.h>
+void dump_all_colors(void)
+{
+	u32 i=0;
+	GF_Color color;
+	const char *name;
+	while (gf_color_enum(&i, &color, &name)) {
+		gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%s: 0x%08X\n", name, color);
+	}
+}
+
+void dump_all_audio_cicp(void)
+{
+	u32 i=0, cicp;
+	const char *name;
+	u64 layout;
+
+	while ((cicp = gf_audio_fmt_cicp_enum(i, &name, &layout)) ) {
+		gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%s (%d): 0x%016"LLX_SUF"\n", name, cicp, layout);
+		i++;
+	}
+}
+
+void dump_all_codecs(GF_SysArgMode argmode)
+{
+#define PAD_LEN	30
+	GF_PropertyValue rawp, filep, stp;
+	GF_PropertyValue cp, acp;
+	GF_List *meta_codecs = (argmode>GF_ARGMODE_BASE) ? gf_list_new() : NULL;
+	char szFlags10, szCap2;
+	u32 i;
+	u32 cidx=0;
+	u32 count = gf_fs_filters_registers_count(session);
+
+	gf_sys_format_help(helpout, help_flags, "Codec support in filters, listed as `built_in_name|variant FLAGS: full_name (mime)` with possible FLAGS values:\n");
+	gf_sys_format_help(helpout, help_flags, " - I: Raw format input (elementary stream parser) support\n");
+	gf_sys_format_help(helpout, help_flags, " - O: Raw format output (elementary stream writer) support\n");
+	gf_sys_format_help(helpout, help_flags, " - D: Decoder support\n");
+	gf_sys_format_help(helpout, help_flags, " - E: Encoder support\n");
+	gf_sys_format_help(helpout, help_flags, "\nNote: Raw output may still be possible even when no output serializer is given\n\n");
+
+	rawp.type = cp.type = GF_PROP_UINT;
+	rawp.value.uint = GF_CODECID_RAW;
+	filep.type = cp.type = GF_PROP_UINT;
+	filep.value.uint = GF_STREAM_FILE;
+	stp.type = GF_PROP_UINT;
+	cp.type = GF_PROP_UINT;
+	acp.type = GF_PROP_UINT;
+	szCap1 = 0;
+
+	if (meta_codecs) {
+		for (i=0; i<count; i++) {
+			u32 j;
+			const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+			if (! (reg->flags & GF_FS_REG_META)) continue;
+			for (j=0; j<reg->nb_caps; j++) {
+				if (!(reg->capsj.flags & GF_CAPFLAG_IN_BUNDLE)) continue;
+				if (reg->capsj.code != GF_PROP_PID_CODECID) continue;
+				if (reg->capsj.val.type != GF_PROP_NAME) continue;
+				if (gf_list_find(meta_codecs, (void *)reg)<0)
+					gf_list_add(meta_codecs, (void *)reg);
+			}
+		}
+	}
+
+	while (1) {
+		const char *lname;
+		const char *sname;
+		const char *mime;
+		u32 rfc4cc;
+		Bool enc_found = GF_FALSE;
+		Bool dec_found = GF_FALSE;
+		Bool dmx_found = GF_FALSE;
+		Bool mx_found = GF_FALSE;
+		cp.value.uint = gf_codecid_enum(cidx, &sname, &lname);
+		cidx++;
+		if (cp.value.uint == GF_CODECID_NONE) break;
+//		if (cp.value.uint == GF_CODECID_RAW) continue;
+		if (!sname) break;
+
+		stp.value.uint = gf_codecid_type(cp.value.uint);
+		acp.value.uint = gf_codecid_alt(cp.value.uint);
+
+		for (i=0; i<count; i++) {
+			const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+
+			if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &stp, GF_PROP_PID_STREAM_TYPE, &stp, GF_TRUE)) {
+				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &rawp, GF_PROP_PID_CODECID, &cp, GF_TRUE)) {
+					enc_found = GF_TRUE;
+					if (gf_list_find(meta_codecs, (void *)reg)>=0)
+						gf_list_del_item(meta_codecs, (void *)reg);
+				} else if (acp.value.uint && gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &rawp, GF_PROP_PID_CODECID, &acp, GF_TRUE)) {
+					enc_found = GF_TRUE;
+					if (gf_list_find(meta_codecs, (void *)reg)>=0)
+						gf_list_del_item(meta_codecs, (void *)reg);
+				}
+				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &cp, GF_PROP_PID_CODECID, &rawp, GF_TRUE)) {
+					dec_found = GF_TRUE;
+				} else if (acp.value.uint && gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &acp, GF_PROP_PID_CODECID, &rawp, GF_TRUE)) {
+					dec_found = GF_TRUE;
+				}
+			}
+
+			if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &filep, GF_PROP_PID_STREAM_TYPE, &stp, GF_TRUE)) {
+				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &filep, GF_PROP_PID_CODECID, &cp, GF_TRUE))
+					dmx_found = GF_TRUE;
+			}
+			if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_STREAM_TYPE, &stp, GF_PROP_PID_STREAM_TYPE, &filep, GF_TRUE)) {
+				if ( gf_fs_check_filter_register_cap(reg, GF_PROP_PID_CODECID, &cp, GF_PROP_PID_STREAM_TYPE, &filep, GF_TRUE))
+					mx_found = GF_TRUE;
+			}
+		}
+
+		szFlags0 = 0;
+		if (enc_found || dec_found || dmx_found || mx_found) {
+			strcpy(szFlags, " ");
+			if (dmx_found) { szCap0 = 'I'; strcat(szFlags, szCap); }
+			if (mx_found) { szCap0 = 'O'; strcat(szFlags, szCap); }
+			if (dec_found) { szCap0 = 'D'; strcat(szFlags, szCap); }
+			if (enc_found) { szCap0 = 'E'; strcat(szFlags, szCap); }
+			strcat(szFlags, "");
+		}
+
+		mime = gf_codecid_mime(cp.value.uint);
+		rfc4cc = gf_codecid_4cc_type(cp.value.uint);
+		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s%s: ", sname, szFlags);
+
+		u32 len = (u32) (2 + strlen(sname) + strlen(szFlags));
+		while (len<PAD_LEN) {
+			len++;
+			gf_sys_format_help(helpout, help_flags, " ");
+		}
+		gf_sys_format_help(helpout, help_flags, "%s", lname);
+		if (rfc4cc || mime) {
+			gf_sys_format_help(helpout, help_flags, " (");
+			if (rfc4cc) gf_sys_format_help(helpout, help_flags, "%s", gf_4cc_to_str(rfc4cc) );
+			if (rfc4cc&&mime) gf_sys_format_help(helpout, help_flags, ", ");
+			if (mime) gf_sys_format_help(helpout, help_flags, "%s", mime);
+			gf_sys_format_help(helpout, help_flags, ")");
+		}
+		gf_sys_format_help(helpout, help_flags, "\n");
+	}
+
+	if (meta_codecs) {
+		gf_sys_format_help(helpout, help_flags, "# Meta-filters codec support (not mapped to GPAC codec IDs)\n");
+		gf_sys_format_help(helpout, help_flags, "Only encoding and decoding support is listed.\n\n");
+		count = gf_list_count(meta_codecs);
+		for (i=0; i<count; i++) {
+			u32 j, k;
+			Bool has_dec = GF_FALSE, has_enc = GF_FALSE;
+			const char *codec_desc = "Unknown";
+			const GF_FilterRegister *reg = gf_list_get(meta_codecs, i);
+			const char *name = strchr(reg->name, ':');
+			if (name) name++;
+			else name = reg->name;
+			for (j=0; j<reg->nb_caps; j++) {
+				if (reg->capsj.code != GF_PROP_PID_CODECID) continue;
+				if (reg->capsj.val.type != GF_PROP_NAME) continue;
+				codec_desc = reg->capsj.val.value.string;
+				if (reg->capsj.flags & GF_CAPFLAG_INPUT) has_dec = GF_TRUE;
+				else if (reg->capsj.flags & GF_CAPFLAG_OUTPUT) has_enc = GF_TRUE;
+				break;
+			}
+			for (k=0; k<count; k++) {
+				if (k==i) continue;;
+				reg = gf_list_get(meta_codecs, k);
+				const char *rname = strchr(reg->name, ':');
+				if (rname) rname++;
+				else rname = reg->name;
+				if (strcmp(rname, name)) continue;
+
+				for (j=0; j<reg->nb_caps; j++) {
+					if (reg->capsj.code != GF_PROP_PID_CODECID) continue;
+					if (reg->capsj.val.type != GF_PROP_NAME) continue;
+					if (reg->capsj.flags & GF_CAPFLAG_INPUT) has_dec = GF_TRUE;
+					else if (reg->capsj.flags & GF_CAPFLAG_OUTPUT) has_enc = GF_TRUE;
+					gf_list_rem(meta_codecs, k);
+					count--;
+				}
+			}
+			strcpy(szFlags, " ");
+			if (has_dec) strcat(szFlags, "D");
+			if (has_enc) strcat(szFlags, "E");
+			strcat(szFlags, "");
+
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST, "%s%s: ", name, szFlags);
+			u32 len = (u32) (2 + strlen(name) + strlen(szFlags));
+			while (len<PAD_LEN) {
+				len++;
+				gf_sys_format_help(helpout, help_flags, " ");
+			}
+			gf_sys_format_help(helpout, help_flags, "%s\n", codec_desc);
+			gf_list_rem(meta_codecs, i);
+			i--;
+			count--;
+		}
+		gf_list_del(meta_codecs);
+	}
+
+	gf_sys_format_help(helpout, help_flags, "\n");
+}
+
+typedef struct
+{
+	char *ext;
+	char *mime;
+	GF_List *demuxers, *muxers;
+	Bool meta_only;
+} FMTHandler;
+
+//quick hack for a few of our filters to avoid crazy long lists of mimes
+static const char *get_best_mime(char *ext)
+{
+	if (!strcmp(ext, "mp4") || !strcmp(ext, "iso") || !strcmp(ext, "ismv")) return "video/mp4|audio/mp4|application/mp4";
+	if (!strcmp(ext, "mpg4")) return "application/mp4";
+	if (!strcmp(ext, "m4a")) return "audio/mp4";
+	if (!strcmp(ext, "m4i")) return "application/mp4";
+	if (!strcmp(ext, "3gp") || !strcmp(ext, "3gpp")) return "video/3gpp|audio/3gpp";
+	if (!strcmp(ext, "3g2") || !strcmp(ext, "3gp2")) return "video/3gp2|audio/3gp2";
+	if (!strcmp(ext, "m4s")) return "video/iso.segment|audio/iso.segment";
+	if (!strcmp(ext, "iff") || !strcmp(ext, "heif")) return "image/heif";
+	if (!strcmp(ext, "heic")) return "image/heic";
+	if (!strcmp(ext, "avci") || !strcmp(ext, "avif")) return "image/avci";
+	if (!strcmp(ext, "mj2")) return "video/jp2";
+	if (!strcmp(ext, "mov") || !strcmp(ext, "qt")) return "video/quicktime";
+	if (!strcmp(ext, "bt") || !strcmp(ext, "btz") || !strcmp(ext, "bt.gz")) return "application/x-bt";
+	if (!strcmp(ext, "xmt") || !strcmp(ext, "xmtz") || !strcmp(ext, "xmt.gz")) return "application/x-xmt";
+	if (!strcmp(ext, "wrl") || !strcmp(ext, "wrl.gz")) return "model/vrml";
+	if (!strcmp(ext, "x3dv") || !strcmp(ext, "x3dvz") || !strcmp(ext, "x3dv.gz")) return "model/x3d+vrml";
+	if (!strcmp(ext, "x3d") || !strcmp(ext, "x3dz") || !strcmp(ext, "x3d.gz")) return "model/x3d+xml";
+	if (!strcmp(ext, "swf")) return "application/x-shockwave-flash";
+	if (!strcmp(ext, "xsr")) return "application/x-LASeR+xml";
+	if (!strcmp(ext, "svg") || !strcmp(ext, "svgz") || !strcmp(ext, "svg.gz")) return "image/svg+xml";
+	if (!strcmp(ext, "jpg") || !strcmp(ext, "jpeg")) return "image/jpg";
+	if (!strcmp(ext, "jp2") || !strcmp(ext, "j2k")) return "image/jp2";
+	if (!strcmp(ext, "bmp")) return "image/bmp";
+	if (!strcmp(ext, "png")) return "image/png";
+	if (!strcmp(ext, "aac") || !strcmp(ext, "adts")) return "audio/aac";
+	if (!strcmp(ext, "latm")) return "audio/aac+latm";
+	if (!strcmp(ext, "usac") || !strcmp(ext, "xheaac")) return "audio/xheaac+latm";
+	if (!strcmp(ext, "amr") || !strcmp(ext, "awb")) return "audio/amr";
+	if (!strcmp(ext, "evc")) return "audio/x-evc";
+	if (!strcmp(ext, "smv")) return "audio/x-smv";
+	if (!strcmp(ext, "oga") || !strcmp(ext, "spx") || !strcmp(ext, "opus")) return "audio/ogg";
+	if (!strcmp(ext, "ogg") || !strcmp(ext, "ogv")) return "video/ogg";
+	if (!strcmp(ext, "oggm")) return "application/ogg";
+	if (!strcmp(ext, "ts") || !strcmp(ext, "m2t") || !strcmp(ext, "mts") || !strcmp(ext, "dmb") || !strcmp(ext, "trp")) return "video/mp2t";
+	if (!strcmp(ext, "ac3")) return "audio/ac3";
+	if (!strcmp(ext, "eac3")) return "audio/eac3";
+	if (!strcmp(ext, "mpd")) return "application/dash+xml";
+	if (!strcmp(ext, "m3u8")) return "application/vnd.apple.mpegurl";
+	if (!strcmp(ext, "ism")) return "application/vnd.ms-sstr+xml";
+	if (!strcmp(ext, "3gm")) return "application/vnd.3gpp.mpd";
+	if (!strcmp(ext, "264") || !strcmp(ext, "avc") || !strcmp(ext, "h264") || !strcmp(ext, "26l") || !strcmp(ext, "h26l")) return "video/h264";
+	if (!strcmp(ext, "svc")) return "video/svc";
+	if (!strcmp(ext, "mvc")) return "video/mvc";
+	if (!strcmp(ext, "265") || !strcmp(ext, "hvc") || !strcmp(ext, "h265") || !strcmp(ext, "hevc")) return "video/hevc";
+	if (!strcmp(ext, "shvc")) return "video/shvc";
+	if (!strcmp(ext, "mhvc")) return "video/mhvc";
+	if (!strcmp(ext, "lvc") || !strcmp(ext, "lhvc")) return "video/lhvc";
+	if (!strcmp(ext, "266") || !strcmp(ext, "vvc") || !strcmp(ext, "h266") || !strcmp(ext, "lvvc")) return "video/vvc";
+	if (!strcmp(ext, "srt")) return "subtitle/srt";
+	if (!strcmp(ext, "ttxt")) return "subtitle/x-ttxt";
+	if (!strcmp(ext, "vtt")) return "subtitle/vtt";
+	if (!strcmp(ext, "sub")) return "subtitle/sub";
+	if (!strcmp(ext, "txml")) return "x-quicktime/text";
+	if (!strcmp(ext, "ttml")) return "subtitle/ttml";
+	if (!strcmp(ext, "ass") || !strcmp(ext, "ssa")) return "subtitle/ssa";
+	if (!strcmp(ext, "mkv") || !strcmp(ext, "mks")) return "video/x-matroska";
+	if (!strcmp(ext, "mka")) return "audio/x-matroska";
+	if (!strcmp(ext, "webm")) return "video/webm";
+	return NULL;
+}
+static void push_ext_mime(GF_List *all_fmts, const char *exts, Bool is_output, const GF_FilterRegister *reg, const char *mime)
+{
+	FMTHandler *hdl;
+	if (!exts) return;
+	if (!strcmp(exts, "*")) return;
+
+	char *names = gf_strdup(exts);
+	char *name = names;
+	while (name) {
+		Bool found = GF_FALSE;
+		char *sep = strchr(name, '|');
+		char *sep2 = strchr(name, ',');
+		if (sep2 && sep && (sep2<sep)) sep = sep2;
+		else if (sep2 && !sep) sep=sep2;
+
+		if (sep) sep0 = 0;
+		hdl = NULL;
+		u32 i, count = gf_list_count(all_fmts);
+		for (i=0; i<count; i++) {
+			hdl = gf_list_get(all_fmts, i);
+			if (!strcmp(hdl->ext, name)) {
+				found=GF_TRUE;
+				break;
+			}
+		}
+		if (!found || !hdl) {
+			GF_SAFEALLOC(hdl, FMTHandler);
+			while (name0==' ')
+				name = name+1;
+			hdl->ext = gf_strdup(name);
+			hdl->demuxers = gf_list_new();
+			hdl->muxers = gf_list_new();
+			if (reg->flags & GF_FS_REG_META)
+				hdl->meta_only = GF_TRUE;
+			gf_list_add(all_fmts, hdl);
+		}
+		if (mime && !hdl->mime) {
+			const char *small_mime = get_best_mime(hdl->ext);
+			if (small_mime)
+				hdl->mime = gf_strdup(small_mime);
+			else {
+				hdl->mime = gf_strdup(mime);
+			}
+		}
+		if (!(reg->flags & GF_FS_REG_META))
+			hdl->meta_only = GF_TRUE;
+
+		if (is_output) {
+			if (gf_list_find(hdl->muxers, (void*) reg)<0) {
+				gf_list_add(hdl->muxers, (void*) reg);
+			}
+		} else {
+			if (gf_list_find(hdl->demuxers, (void*) reg)<0) {
+				gf_list_add(hdl->demuxers, (void*)reg);
+			}
+		}
+		if (!sep) break;
+		name = sep+1;
+	}
+	gf_free(names);
+}
+
+void dump_all_formats(GF_SysArgMode argmode)
+{
+	u32 i, count = gf_fs_filters_registers_count(session);
+	GF_List *all_fmts = gf_list_new();
+	GF_List *all_inputs = gf_list_new();
+
+	for (i=0; i<count; i++) {
+		u32 j, nb_in=0;
+		const char *in_ext=NULL;
+		const char *out_ext=NULL;
+		const char *in_mime=NULL;
+		const char *out_mime=NULL;
+		Bool ext_static = GF_FALSE;
+		Bool st_static = GF_FALSE;
+		u32 in_st_type = GF_STREAM_UNKNOWN;
+		u32 out_st_type = GF_STREAM_UNKNOWN;
+		const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+		if ((argmode<GF_ARGMODE_EXPERT) && (reg->flags&GF_FS_REG_META)) continue;
+
+		for (j=0; j<reg->nb_caps; j++) {
+			if (!(reg->capsj.flags & GF_CAPFLAG_IN_BUNDLE)) {
+				//special case for meta filters, declaring only input ext (demux) or output ext (mux)
+				if (reg->flags & GF_FS_REG_META) {
+					if (in_ext && (out_st_type==GF_STREAM_UNKNOWN)) out_st_type = GF_STREAM_VISUAL;
+					if (out_ext && (in_st_type==GF_STREAM_UNKNOWN)) in_st_type = GF_STREAM_VISUAL;
+				}
+
+				if (in_ext && (in_st_type==GF_STREAM_FILE) && !out_ext && (out_st_type!=GF_STREAM_UNKNOWN))
+					push_ext_mime(all_fmts, in_ext, GF_FALSE, reg, in_mime);
+				if (out_ext && (out_st_type==GF_STREAM_FILE) && !in_ext && (in_st_type!=GF_STREAM_UNKNOWN))
+					push_ext_mime(all_fmts, out_ext, GF_TRUE, reg, out_mime);
+
+				if (!ext_static) {
+					in_ext=NULL;
+					out_ext=NULL;
+				}
+				if (!st_static) {
+					in_st_type = GF_STREAM_UNKNOWN;
+					out_st_type = GF_STREAM_UNKNOWN;
+				}
+				continue;
+			}
+			if (reg->capsj.flags & GF_CAPFLAG_INPUT) nb_in++;
+
+			if (reg->capsj.code == GF_PROP_PID_FILE_EXT) {
+				if ((reg->capsj.val.type != GF_PROP_NAME)
+					&& (reg->capsj.val.type != GF_PROP_STRING)
+					&& (reg->capsj.val.type != GF_PROP_STRING_NO_COPY)
+				) continue;
+				char *ext = reg->capsj.val.value.string;
+				if (!ext || !ext0) continue;
+
+				if (reg->capsj.flags & GF_CAPFLAG_STATIC) ext_static = GF_TRUE;
+				if (reg->capsj.flags & GF_CAPFLAG_INPUT) {
+					in_ext = ext;
+					in_st_type = GF_STREAM_FILE;
+				}
+				if (reg->capsj.flags & GF_CAPFLAG_OUTPUT) {
+					out_ext = ext;
+					out_st_type = GF_STREAM_FILE;
+				}
+			} else if (reg->capsj.code == GF_PROP_PID_MIME) {
+				if ((reg->capsj.val.type != GF_PROP_NAME)
+					&& (reg->capsj.val.type != GF_PROP_STRING)
+					&& (reg->capsj.val.type != GF_PROP_STRING_NO_COPY)
+				) continue;
+				char *m = reg->capsj.val.value.string;
+				if (!m || !m0) continue;
+				if (reg->capsj.flags & GF_CAPFLAG_INPUT) in_mime = m;
+				if (reg->capsj.flags & GF_CAPFLAG_OUTPUT) out_mime = m;
+			} else if (reg->capsj.code == GF_PROP_PID_STREAM_TYPE) {
+				if (reg->capsj.flags & GF_CAPFLAG_STATIC) st_static = GF_TRUE;
+				u32 st = reg->capsj.val.value.uint;
+				//special case for filters advertising any stream, consider not file
+				if ((st==GF_STREAM_UNKNOWN) && (reg->capsj.flags&GF_CAPFLAG_EXCLUDED))
+					st = GF_STREAM_VISUAL;
+				if (reg->capsj.flags & GF_CAPFLAG_INPUT) in_st_type = st;
+				if (reg->capsj.flags & GF_CAPFLAG_OUTPUT) out_st_type = st;
+			}
+		}
+
+		if (reg->flags & GF_FS_REG_META) {
+			if (in_ext && (out_st_type==GF_STREAM_UNKNOWN)) out_st_type = GF_STREAM_VISUAL;
+			if (out_ext && (in_st_type==GF_STREAM_UNKNOWN)) in_st_type = GF_STREAM_VISUAL;
+		}
+		if (in_ext && (in_st_type==GF_STREAM_FILE) && !out_ext && (out_st_type!=GF_STREAM_UNKNOWN))
+			push_ext_mime(all_fmts, in_ext, GF_FALSE, reg, in_mime);
+		if (out_ext && (out_st_type==GF_STREAM_FILE) && !in_ext && (in_st_type!=GF_STREAM_UNKNOWN))
+			push_ext_mime(all_fmts, out_ext, GF_TRUE, reg, out_mime);
+
+
+		if (reg->nb_caps && !nb_in && reg->probe_url && !strchr(reg->name, ':')) {
+			gf_list_add(all_inputs, (void*)reg);
+		}
+	}
+
+	if (gen_doc==1) {
+		gf_sys_format_help(helpout, help_flags, "# Extensions and mime types\n");
+		gf_sys_format_help(helpout, help_flags, "Extension name can be used to force output formats using `ext=` option of sink filters. \nBy default, GPAC does not rely on file extension for source processing unless `-no-probe` option is set, in which case `ext=` option may be set on source filter. \n");
+		gf_sys_format_help(helpout, help_flags, "_NOTE: This table does not include meta filters (ffmpeg, ...), use `gpac -hx formats` to list them._\n\n");
+		gf_sys_format_help(helpout, help_flags, " Extension | Input Filter(s) | Output Filter(s) | Mime(s) \n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- | --- | --- \n");
+	} else {
+		gf_sys_format_help(helpout, help_flags, "Format support in filters, by file extension\n");
+		gf_sys_format_help(helpout, help_flags, "\nNote: Some demuxers may only rely on data probing and not declare file extensions used for formats, resulting in formats not listed as supported for inputs\n\n");
+	}
+
+	count = gf_list_count(all_fmts);
+	for (i=0; i<count; i++) {
+		u32 j, c2;
+		FMTHandler *hdl = gf_list_get(all_fmts, i);
+		if (gen_doc==1) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "%s | ", hdl->ext);
+		} else {
+			gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%s:", hdl->ext);
+
+		}
+		c2 = gf_list_count(hdl->demuxers);
+		if (!c2 && hdl->meta_only) {
+			char szFileName100;
+			sprintf(szFileName, "test.%s", hdl->ext);
+			c2 = gf_list_count(all_inputs);
+			for (j=0; j<c2; j++) {
+				const GF_FilterRegister *reg = gf_list_get(all_inputs, j);
+				GF_FilterProbeScore score = reg->probe_url(szFileName, NULL);
+				if (score>=GF_FPROBE_MAYBE_SUPPORTED) {
+					gf_list_add(hdl->demuxers, (void*)reg);
+					break;
+				}
+			}
+			c2 = gf_list_count(hdl->demuxers);
+		}
+		if (c2 && (gen_doc!=1)) {
+			gf_sys_format_help(helpout, help_flags, " Demux");
+		}
+
+		if (c2) {
+			if ((gen_doc==1) || (argmode>=GF_ARGMODE_ADVANCED)) {
+				if (gen_doc!=1)
+					gf_sys_format_help(helpout, help_flags, " (");
+				for (j=0; j<c2; j++) {
+					const GF_FilterRegister *reg = gf_list_get(hdl->demuxers, j);
+					if (j) gf_sys_format_help(helpout, help_flags, " ");
+					gf_sys_format_help(helpout, help_flags, "%s", reg->name);
+				}
+				if (gen_doc!=1)
+					gf_sys_format_help(helpout, help_flags, ")");
+			}
+		} else if (gen_doc==1) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "n/a");
+		}
+
+		if (gen_doc==1)
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, " | ");
+
+		c2 = gf_list_count(hdl->muxers);
+		if (c2) {
+			if (gen_doc!=1)
+				gf_sys_format_help(helpout, help_flags, " Mux");
+			if ((gen_doc==1) || (argmode>=GF_ARGMODE_ADVANCED)) {
+				if (gen_doc!=1)
+					gf_sys_format_help(helpout, help_flags, " (");
+				for (j=0; j<c2; j++) {
+					const GF_FilterRegister *reg = gf_list_get(hdl->muxers, j);
+					if (j) gf_sys_format_help(helpout, help_flags, " ");
+					gf_sys_format_help(helpout, help_flags, "%s", reg->name);
+				}
+				if (gen_doc!=1)
+					gf_sys_format_help(helpout, help_flags, ")");
+			}
+		} else if (gen_doc==1) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, "n/a");
+		}
+
+		if (gen_doc==1) {
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR, " | ");
+			gf_sys_format_help(helpout, help_flags | GF_PRINTARG_NL_TO_BR | GF_PRINTARG_ESCAPE_PIPE, "%s \n", hdl->mime ? hdl->mime : "n/a");
+		} else {
+			if (hdl->mime && (argmode>GF_ARGMODE_EXPERT)) {
+				gf_sys_format_help(helpout, help_flags, " MIME %s", hdl->mime);
+			}
+			gf_sys_format_help(helpout, help_flags, "\n");
+		}
+	}
+
+	while (gf_list_count(all_fmts)) {
+		FMTHandler *hdl = gf_list_pop_back(all_fmts);
+		gf_free(hdl->ext);
+		if (hdl->mime) gf_free(hdl->mime);
+		gf_list_del(hdl->demuxers);
+		gf_list_del(hdl->muxers);
+		gf_free(hdl);
+	}
+	gf_list_del(all_fmts);
+	gf_list_del(all_inputs);
+}
+
+typedef struct
+{
+	char *proto;
+	GF_List *in, *out;
+} PROTOHandler;
+
+void dump_all_proto_schemes(GF_SysArgMode argmode)
+{
+	GF_List *all_protos = gf_list_new();
+	u32 k, i, count;
+	for (k=0; k<2; k++) {
+		const char *sname = k ? "temp_out_proto" : "temp_in_proto";
+		count = gf_opts_get_key_count(sname);
+		for (i=0; i<count; i++) {
+			const char *f = gf_opts_get_key_name(sname, i);
+			if (!f) continue;
+			if ((argmode<GF_ARGMODE_EXPERT) && strchr(f, ':')) continue;
+
+			char *proto = (char*)gf_opts_get_key(sname, f);
+			if (!proto) continue;
+
+			while (proto) {
+				PROTOHandler *pe=NULL;
+				char *sep = strchr(proto, ',');
+				if (sep) sep0 = 0;
+				u32 j=0;
+				while ((pe = gf_list_enum(all_protos, &j) )) {
+					if (!strcmp(pe->proto, proto)) {
+						break;
+					}
+				}
+				if (!pe) {
+					GF_SAFEALLOC(pe, PROTOHandler);
+					pe->proto = gf_strdup(proto);
+					pe->in = gf_list_new();
+					pe->out = gf_list_new();
+					gf_list_add(all_protos, pe);
+				}
+				if (k)
+					gf_list_add(pe->out, (void *)f);
+				else
+					gf_list_add(pe->in, (void *)f);
+
+				if (!sep) break;
+				proto = sep+1;
+			}
+		}
+	}
+
+	if (gen_doc==1) {
+		gf_sys_format_help(helpout, help_flags, "# Protocol Schemes\n");
+		gf_sys_format_help(helpout, help_flags, "_NOTE: This table does not include meta filters (ffmpeg, ...), use `gpac -hx protocols` to list them._\n\n");
+		gf_sys_format_help(helpout, help_flags, " Scheme | Input Filter(s) | Output Filter(s)\n");
+		gf_sys_format_help(helpout, help_flags, " --- | --- | --- \n");
+	} else {
+		gf_sys_format_help(helpout, help_flags, "\nSupported protocols schemes (listed as `scheme: in (filters) out (filters)`):\n");
+	}
+	count = gf_list_count(all_protos);
+	for (i=0; i<count; i++) {
+		u32 j, c2;
+		PROTOHandler *pe = gf_list_get(all_protos, i);
+
+		if (gen_doc==1) {
+			gf_sys_format_help(helpout, help_flags|GF_PRINTARG_NL_TO_BR, "%s | ", pe->proto);
+		} else {
+			gf_sys_format_help(helpout, help_flags|GF_PRINTARG_HIGHLIGHT_FIRST, "%s:", pe->proto);
+		}
+		for (k=0; k<2; k++) {
+			GF_List *list = k ? pe->out : pe->in;
+			const char *lab = k ? "in" : "out";
+			c2 = gf_list_count(list);
+			if (c2) {
+				if (gen_doc!=1)
+					gf_sys_format_help(helpout, help_flags, " %s", lab);
+
+				if ((gen_doc==1) || (argmode==GF_ARGMODE_ADVANCED) || (argmode==GF_ARGMODE_ALL)) {
+					if (gen_doc!=1)
+						gf_sys_format_help(helpout, help_flags, " (");
+					for (j=0;j<c2; j++) {
+						char *f = gf_list_get(list, j);
+						if (j) gf_sys_format_help(helpout, help_flags, " ");
+						gf_sys_format_help(helpout, help_flags, "%s", f);
+					}
+					if (gen_doc!=1)
+						gf_sys_format_help(helpout, help_flags, ")");
+				}
+			} else if (gen_doc==1) {
+				gf_sys_format_help(helpout, help_flags, " n/a");
+			}
+			if ((gen_doc==1) && !k)
+				gf_sys_format_help(helpout, help_flags, " | ");
+		}
+		gf_sys_format_help(helpout, help_flags, "\n");
+		gf_free(pe->proto);
+		gf_list_del(pe->in);
+		gf_list_del(pe->out);
+		gf_free(pe);
+	}
+	gf_list_del(all_protos);
+}
+
+
+/*********************************************************
+			Config file writing functions
+*********************************************************/
+
+void write_core_options()
+{
+	//print libgpac core help
+	const GF_GPACArg *args = gf_sys_get_options();
+	u32 i = 0;
+
+	while (argsi.name) {
+		if (! gf_opts_get_key("core", argsi.name) && argsi.val) {
+			gf_opts_set_key("core", argsi.name, argsi.val);
+		}
+		i++;
+	}
+}
+
+void write_file_extensions()
+{
+	u32 i = 0;
+
+	while (1) {
+		const char *short_name, *long_name, *mime ;
+		u32 cid = gf_codecid_enum(i, &short_name, &long_name);
+		if (cid==GF_CODECID_NONE) break;
+		mime = gf_codecid_mime(cid);
+		if (mime && ! gf_opts_get_key("file_extensions", mime) ) {
+			gf_opts_set_key("file_extensions", mime, short_name);
+		}
+		i++;
+	}
+}
+
+void write_filters_options()
+{
+	u32 i, count;
+	count = gf_fs_filters_registers_count(session);
+	for (i=0; i<count; i++) {
+		char *meta_sep;
+		u32 j=0;
+		char szSecName200;
+
+		const GF_FilterRegister *freg = gf_fs_get_filter_register(session, i);
+		sprintf(szSecName, "filter@%s", freg->name);
+		meta_sep = strchr(szSecName + 7, ':');
+		if (meta_sep) meta_sep0 = 0;
+
+		while (freg->args) {
+			const GF_FilterArgs *arg = &freg->argsj;
+			if (!arg || !arg->arg_name) break;
+			j++;
+
+			if (arg->arg_default_val && !gf_opts_get_key(szSecName, arg->arg_name)) {
+				gf_opts_set_key(szSecName, arg->arg_name, arg->arg_default_val);
+			}
+		}
+	}
+}
+
+/*********************************************************
+		Language file creation / update functions
+*********************************************************/
+
+static Bool lang_updated = GF_FALSE;
+static void gpac_lang_set_key(GF_Config *cfg, const char *sec_name, const char *key_name, const char *key_val)
+{
+	char szKeyCRC1024;
+	const char *opt = gf_cfg_get_key(cfg, sec_name, key_name);
+	u32 crc_key = 0;
+	if (opt) {
+		sprintf(szKeyCRC, "%s_crc", key_name);
+		const char *crc_opt = gf_cfg_get_key(cfg, sec_name, szKeyCRC);
+		if (crc_opt) {
+			u32 old_crc = atoi(crc_opt);
+			crc_key = gf_crc_32((u8*)key_val, (u32) strlen(key_val));
+			if (old_crc != crc_key) {
+				gf_sys_format_help(helpout, help_flags, "Warning: description has changed for %s:%s (crc %d - crc in file %d) - please check translation\n", sec_name, key_name, crc_key, old_crc);
+			}
+			return;
+		}
+	}
+	if (!opt) {
+		char szKeyCRCVal100;
+		if (!crc_key) {
+			sprintf(szKeyCRC, "%s_crc", key_name);
+			crc_key = gf_crc_32((u8*)key_val, (u32) strlen(key_val));
+		}
+		sprintf(szKeyCRCVal, "%u", crc_key);
+		gf_cfg_set_key(cfg, sec_name, key_name, key_val);
+		gf_cfg_set_key(cfg, sec_name, szKeyCRC, szKeyCRCVal);
+		lang_updated = GF_TRUE;
+	}
+}
+
+int gpac_make_lang(char *filename)
+{
+	GF_Config *cfg;
+	u32 i;
+	gf_sys_init(GF_MemTrackerNone, NULL);
+
+	session = gf_fs_new_defaults(0);
+	if (!session) {
+		gf_sys_format_help(helpout, help_flags, "failed to load session, cannot create language file\n");
+		return 1;
+	}
+	if (!gf_file_exists(filename)) {
+		FILE *f = gf_fopen(filename, "wt");
+		if (!f) {
+			gf_sys_format_help(helpout, help_flags, "failed to open %s in write mode\n", filename);
+			gf_fs_del(session);
+			return 1;
+		}
+		gf_fclose(f);
+	}
+
+	cfg = gf_cfg_new(NULL, filename);
+
+	//print gpac help
+	i = 0;
+	while (gpac_argsi.name) {
+		gpac_lang_set_key(cfg, "gpac", gpac_argsi.name, gpac_argsi.description);
+		i++;
+	}
+
+#ifndef GPAC_DISABLE_DOC
+	//print gpac doc
+	gpac_lang_set_key(cfg, "gpac", "doc", gpac_doc);
+
+	//print gpac alias doc
+	gpac_lang_set_key(cfg, "gpac", "alias", gpac_alias);
+#endif
+
+	//print libgpac core help
+	const GF_GPACArg *args = gf_sys_get_options();
+	i = 0;
+
+	while (argsi.name) {
+		gpac_lang_set_key(cfg, "core", argsi.name, argsi.description);
+		i++;
+	}
+
+	//print properties
+	i=0;
+	const GF_BuiltInProperty *prop_info;
+	while ((prop_info = gf_props_get_description(i))) {
+		i++;
+		if (! prop_info->name || !prop_info->description) continue;
+		gpac_lang_set_key(cfg, "properties", prop_info->name, prop_info->description);
+	}
+
+	//print filters
+	u32 count = gf_fs_filters_registers_count(session);
+	for (i=0; i<count; i++) {
+		u32 j=0;
+		const GF_FilterRegister *reg = gf_fs_get_filter_register(session, i);
+
+#ifndef GPAC_DISABLE_DOC
+		if (reg->description) {
+			gpac_lang_set_key(cfg, reg->name, "desc", reg->description);
+		}
+		if (reg->help) {
+			gpac_lang_set_key(cfg, reg->name, "help", reg->help);
+		}
+#endif
+		while (reg->args && reg->argsj.arg_name) {
+			gpac_lang_set_key(cfg, reg->name, reg->argsj.arg_name, reg->argsj.arg_desc);
+			j++;
+		}
+	}
+
+	if (!lang_updated) {
+		gf_cfg_discard_changes(cfg);
+		fprintf(stderr, "lang file %s has not been modified\n", filename);
+	} else {
+		fprintf(stderr, "lang file generated in %s\n", filename);
+	}
+	gf_cfg_del(cfg);
+
+	gf_fs_del(session);
+	gf_sys_close();
+	return 0;
+}
+
+
+/*********************************************************
+			Alias functions
+*********************************************************/
+
+static GFINLINE void push_arg(char *_arg, Bool _dup)
+{
+	alias_argv = gf_realloc(alias_argv, sizeof(char**) * (alias_argc+1));\
+	alias_argvalias_argc = _dup ? gf_strdup(_arg) : _arg; \
+	if (_dup) {
+		if (!args_alloc) args_alloc = gf_list_new();
+		gf_list_add(args_alloc, alias_argvalias_argc);
+	}
+	alias_argc++;
+}
+
+static Bool gpac_expand_alias_arg(char *param, char *prefix, char *suffix, int arg_idx, int argc, char **argv, char *alias_name);
+
+static Bool check_param_extension(char *szArg, int arg_idx, int argc, char **argv, char *alias_name)
+{
+	char *par_start = strstr(szArg, "@{");
+	if (par_start) {
+		char szPar100;
+		Bool ok;
+		char *par_end = strchr(par_start, '}');
+		if (!par_end) {
+			fprintf(stderr, "Bad format %s for alias parameter, expecting @{N}\n", szArg);
+			return GF_FALSE;
+		}
+		par_end0 = 0;
+		strcpy(szPar, par_start+2);
+		par_start0 = 0;
+
+	 	ok = gpac_expand_alias_arg(szPar, szArg, par_end+1, arg_idx, argc, argv, alias_name);
+	 	if (!ok) return GF_FALSE;
+		par_start0 = '@';
+		par_end0 = '}';
+		return GF_TRUE;
+	}
+	//done, push arg
+	push_arg(szArg, 1);
+	return GF_TRUE;
+}
+
+static Bool gpac_expand_alias_arg(char *param, char *prefix, char *suffix, int arg_idx, int argc, char **argv, char *alias_name)
+{
+	char *alias_arg=NULL;
+	char szSepList2;
+	char *oparam = param;
+	szSepList0 = separator_setSEP_LIST;
+	szSepList1 = 0;
+
+	Bool is_list = param0=='-';
+	Bool is_expand = param0=='+';
+
+	if (is_list || is_expand) param++;
+
+	gf_dynstrcat(&alias_arg, prefix, NULL);
+	while (param) {
+		u32 idx=0;
+		u32 last_idx=0;
+		char *sep = strchr(param, ',');
+		if (sep) sep0=0;
+
+		if ((param0=='n') || (param0=='N')) {
+			idx = argc - arg_idx - 1;
+			if (param1=='-') {
+				u32 diff = atoi(param+2);
+				if (diff>=idx) {
+					if (sep) sep0=',';
+					fprintf(stderr, "Bad usage for alias %s parameter %s: not enough parameters\n", alias_name, oparam);
+					gf_free(alias_arg);
+					return GF_FALSE;
+				}
+				idx -= diff;
+			}
+		} else {
+			char *lsep = strchr(param, ':');
+			if (lsep) {
+				lsep0 = 0;
+				if (strlen(param))
+					idx = atoi(param);
+				else
+					idx=1;
+
+				lsep0 = ':';
+				if ((lsep1=='n') || (lsep1=='N')) {
+
+					last_idx = argc - arg_idx - 1;
+					if (lsep2=='-') {
+						u32 diff = atoi(lsep+3);
+						if (diff>=last_idx) {
+							fprintf(stderr, "Bad usage for alias %s parameter %s: not enough parameters\n", alias_name, oparam);
+							gf_free(alias_arg);
+							return GF_FALSE;
+						}
+						last_idx -= diff;
+					}
+				} else {
+					last_idx = atoi(lsep+1);
+				}
+			} else {
+				idx = atoi(param);
+			}
+		}
+		if (!idx) {
+			if (sep) sep0=',';
+			fprintf(stderr, "Bad format for alias %s parameter %s: cannot extract argument index\n", alias_name, oparam);
+			gf_free(alias_arg);
+			return GF_FALSE;
+		}
+		if ((int) idx + arg_idx >= argc) {
+			if (sep) sep0=',';
+			fprintf(stderr, "Bad format for %s alias parameter %s: argument out of bounds (not enough paramteters?)\n", alias_name, oparam);
+			gf_free(alias_arg);
+			return GF_FALSE;
+		}
+
+		if (!last_idx) last_idx=idx;
+		for (; idx<=last_idx;idx++) {
+			char *an_arg = argvidx+arg_idx;
+
+			if (!args_used) args_used = gf_list_new();
+			gf_list_add(args_used, an_arg);
+
+			if (is_expand) {
+				gf_free(alias_arg);
+				alias_arg = NULL;
+				gf_dynstrcat(&alias_arg, prefix, NULL);
+				gf_dynstrcat(&alias_arg, an_arg, NULL);
+				gf_dynstrcat(&alias_arg, suffix, NULL);
+
+				Bool ok = check_param_extension(alias_arg, arg_idx, argc, argv, alias_name);
+				if (!ok) {
+					if (sep) sep0=',';
+					gf_free(alias_arg);
+					return GF_FALSE;
+				}
+			} else {
+				gf_dynstrcat(&alias_arg, an_arg, NULL);
+				if (is_list && (idx<last_idx)) {
+					gf_dynstrcat(&alias_arg, szSepList, NULL);
+				}
+			}
+		}
+
+		if (!sep) break;
+		sep0=',';
+		param = sep+1;
+		if (is_list) {
+			gf_dynstrcat(&alias_arg, szSepList, NULL);
+		}
+	}
+
+	if (is_expand) {
+		gf_free(alias_arg);
+		return GF_TRUE;
+	}
+
+	gf_dynstrcat(&alias_arg, suffix, NULL);
+
+	Bool res = check_param_extension(alias_arg, arg_idx, argc, argv, alias_name);
+	gf_free(alias_arg);
+	return res;
+}
+
+Bool gpac_expand_alias(int o_argc, char **o_argv)
+{
+	u32 i, a_idx;
+	Bool has_xopt=GF_FALSE;
+	int argc = o_argc;
+
+	//move all options at the beginning, except anything specified after xopt
+	char **argv = gf_malloc(sizeof(char*) * argc);
+	if (!argv) return GF_FALSE;
+
+	a_idx = 1;
+	argv0 = o_argv0;
+	for (i=1; i< (u32) argc; i++) {
+		//alias, do not push
+		const char *alias = gf_opts_get_key("gpac.alias", o_argvi);
+		if (alias != NULL) {
+			if (strstr(alias, "xopt")) break;
+			continue;
+		}
+		//not an option, do not push
+		if (o_argvi0 != '-') continue;
+		argva_idx = o_argvi;
+		a_idx++;
+	}
+	for (i=1; i< (u32) argc; i++) {
+		//option and not an alias, do not push
+		if (o_argvi0 == '-') {
+			if (!has_xopt) {
+				const char *alias = gf_opts_get_key("gpac.alias", o_argvi);
+				if (alias == NULL)
+					continue;
+				if (strstr(alias, "xopt")) has_xopt = GF_TRUE;
+			}
+		}
+		argva_idx = o_argvi;
+		a_idx++;
+	}
+	assert(argc==a_idx);
+
+	for (i=0; i< (u32) argc; i++) {
+		char *arg = argvi;
+		char *alias = (char *) gf_opts_get_key("gpac.alias", arg);
+		if (alias == NULL) {
+			if (gf_list_find(args_used, arg)<0) {
+				push_arg(arg, 0);
+			}
+			continue;
+		}
+		char *sep;
+
+#ifndef GPAC_CONFIG_ANDROID
+		if (!compositor_mode) {
+			if (!strcmp(arg, "-mp4c")) compositor_mode = LOAD_MP4C;
+			//on OSX we only activate this mode when launched from finder
+			else if (!strcmp(arg, "-gui")) compositor_mode = LOAD_GUI;
+		}
+#endif
+
+		while (alias) {
+			sep = strchr(alias, ' ');
+			if (sep) sep0 = 0;
+			Bool ok = check_param_extension(alias, i, argc, argv, arg);
+			if (sep) sep0 = ' ';
+			if (!ok) {
+				gf_free(argv);
+				return GF_FALSE;
+			}
+			if (!sep) break;
+			alias = sep+1;
+		}
+	}
+	gf_free(argv);
+	return GF_TRUE;
+}
+
+
+void parse_sep_set(const char *arg, Bool *override_seps)
+{
+	if (!arg) return;
+	u32 len = (u32) strlen(arg);
+	if (!len) return;
+	*override_seps = GF_TRUE;
+	if (len>=1) separator_set0 = arg0;
+	if (len>=2) separator_set1 = arg1;
+	if (len>=3) separator_set2 = arg2;
+	if (len>=4) separator_set3 = arg3;
+	if (len>=5) separator_set4 = arg4;
+	if (len>=6) separator_set5 = arg5;
+}

gpac-2.2.0.tar.gz/applications/gpac/ios-Info.plist Added

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleDisplayName</key>
+	<string>GPAC</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFiles</key>
+	<array>
+		<string>icon.png</string>
+		<string>icon_retina.png</string>
+		<string>icon_ipad.png</string>
+		<string>icon_ipad_retina.png</string>
+	</array>
+	<key>CFBundleIcons</key>
+	<dict>
+		<key>CFBundlePrimaryIcon</key>
+		<dict>
+			<key>CFBundleIconFiles</key>
+			<array>
+				<string>icon.png</string>
+				<string>icon_retina.png</string>
+				<string>icon_ipad.png</string>
+				<string>icon_ipad_retina.png</string>
+			</array>
+		</dict>
+	</dict>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>GPAC</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>2.2</string>
+	<key>CFBundleSignature</key>
+	<string>gpac</string>
+	<key>CFBundleVersion</key>
+	<string>12.10.0</string>
+	<key>NSCameraUsageDescription</key>
+	<string>GPAC needs camera access to handle this URL</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>GPAC needs microphone access to handle this URL</string>
+	<key>UIFileSharingEnabled</key>
+	<true/>
+	<key>UIRequiresFullScreen</key>
+	<true/>
+	<key>UIStatusBarHidden</key>
+	<true/>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>

gpac-2.2.0.tar.gz/applications/gpac/ios_main.m Added

@@ -0,0 +1,64 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / gpac ios application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifdef main
+#undef main
+#endif
+
+#import <UIKit/UIKit.h>
+//requires SDL 2.0.10 - if not available, remove ios_main.m from project
+typedef int (*SDL_main_func)(int argc, char *argv);
+extern int SDL_UIKitRunApp(int argc, char *argv, SDL_main_func mainFunction);
+
+int SDL_main(int argc, char **argv);
+
+int main(int argc, char **argv)
+{
+	int i, needs_uikit=0;
+
+	if (argc<=1) {
+		needs_uikit=1;
+	} else {
+		for (i=1; i<argc; i++) {
+			if (strstr(argvi, "-mp4c")
+				|| strstr(argvi, "-gui")
+				|| strstr(argvi, "-req-gl")
+				|| strstr(argvi, "vout")
+				|| strstr(argvi, "player=base")
+				|| strstr(argvi, "player=gui")
+			) {
+				needs_uikit = 1;
+				break;
+			}
+		}
+	}
+
+	if (needs_uikit) {
+		return SDL_UIKitRunApp(argc, argv, SDL_main);
+	}
+
+	return SDL_main(argc, argv);
+}
+

gpac-2.2.0.tar.gz/applications/gpac/ios_res Added

gpac-2.2.0.tar.gz/applications/gpac/ios_res/Default-568h@2x.png Changed

gpac-2.2.0.tar.gz/applications/gpac/ios_res/gpac.icns Changed

gpac-2.2.0.tar.gz/applications/gpac/ios_res/iTunesArtwork Changed

gpac-2.2.0.tar.gz/applications/gpac/ios_res/icon.png Changed

gpac-2.2.0.tar.gz/applications/gpac/ios_res/icon_ipad.png Changed

gpac-2.2.0.tar.gz/applications/gpac/ios_res/icon_ipad_retina.png Changed

gpac-2.2.0.tar.gz/applications/gpac/ios_res/icon_retina.png Changed

gpac-2.2.0.tar.gz/applications/gpac/ios_sensors Added

gpac-2.2.0.tar.gz/applications/gpac/ios_sensors/sensors.h Added

@@ -0,0 +1,51 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / gpac ios application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+ 
+#import <Foundation/Foundation.h>
+#import <CoreMotion/CoreMotion.h>
+#import <CoreLocation/CoreLocation.h>
+
+#include "sensors_def.h"
+
+@interface SensorAccess : NSObject <CLLocationManagerDelegate>
+{
+	SensorDataCallback* sensorCallbak;
+	int sensorType;
+	int gpsActive;
+	int sensorActive;
+}
+
+@property (nonatomic, retain) CMMotionManager *motionManager;
+@property (nonatomic, retain) NSOperationQueue *queue;
+@property (nonatomic, retain) CLLocationManager *locMngr;
+
+- (int) setSensorType :(int) type;
+- (int) getSensorType;
+- (int) setSensorCallback:(SensorDataCallback*)callback ;
+- (int) startSensor;
+- (int) stopSensor;
+- (int) isSensorStarted;
+
+@end

gpac-2.2.0.tar.gz/applications/gpac/ios_sensors/sensors.m Added

@@ -0,0 +1,217 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ *  This file is part of GPAC / gpac ios application
+ *
+ *  GPAC is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  GPAC is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#import "sensors.h"
+
+@implementation SensorAccess
+
+- (id)init {
+	if ((self = super init)) {
+        @autoreleasepool {
+            self.motionManager = CMMotionManager alloc init autorelease;
+			self.motionManager.deviceMotionUpdateInterval = 0.1f;
+            self.queue = NSOperationQueue alloc init autorelease;
+            
+            self.locMngr = CLLocationManager alloc init autorelease;
+            self.locMngr.delegate = self;
+            self.locMngr.desiredAccuracy = kCLLocationAccuracyBest;
+            self.locMngr.distanceFilter = 2;
+            
+            sensorCallbak = NULL;
+            sensorType = -1;
+            gpsActive = 0;
+        }
+	}
+	return self;
+}
+
+- (void)dealloc{
+    self.locMngr.delegate = NULL;
+    super dealloc;
+}
+
+- (int) setSensorType :(int) type
+{
+    sensorType = type;
+    return 0;
+}
+
+- (int) getSensorType
+{
+    return sensorType;
+}
+
+- (int) setSensorCallback:(SensorDataCallback*)callback
+{
+    sensorCallbak = callback;
+    return 0;
+}
+
+- (int) startSensor
+{
+	sensorActive=1;
+    switch (sensorType) {
+        case SENSOR_ACCELEROMETER:
+            if ( !self motionManager isAccelerometerAvailable )
+                return 1;
+            self motionManager startAccelerometerUpdatesToQueue:self queue withHandler:^(CMAccelerometerData* data, NSError* error) {
+                    if ( sensorCallbak && sensorActive) {
+                        sensorCallbak(sensorType, data.acceleration.x, data.acceleration.y, data.acceleration.z, 0);
+                    }
+                }
+             ;
+            return 0;
+
+        case SENSOR_GYROSCOPE:
+            if ( !self motionManager isGyroAvailable )
+                return 1;
+            self motionManager startGyroUpdatesToQueue:self queue withHandler:^(CMGyroData* data, NSError* error) {
+                if ( sensorCallbak  && sensorActive) {
+                    sensorCallbak(sensorType, data.rotationRate.x, data.rotationRate.y, data.rotationRate.z, 0);
+                }
+            }
+             ;
+            return 0;
+
+		case SENSOR_ORIENTATION:
+            if ( !self motionManager isGyroAvailable )
+                return 1;
+            self motionManager startDeviceMotionUpdatesToQueue:self queue withHandler:^(CMDeviceMotion* data, NSError* error) {
+                if ( sensorCallbak  && sensorActive) {
+                    sensorCallbak(sensorType, data.attitude.quaternion.x, data.attitude.quaternion.y, data.attitude.quaternion.z, data.attitude.quaternion.w);
+                }
+            }
+             ;
+            return 0;
+
+        case SENSOR_MAGNETOMETER:
+            if ( !self motionManager isMagnetometerAvailable )
+                return 1;
+            self motionManager startMagnetometerUpdatesToQueue:self queue withHandler:^(CMMagnetometerData* data, NSError* error) {
+                if ( sensorCallbak  && sensorActive) {
+                    sensorCallbak(sensorType, data.magneticField.x, data.magneticField.y, data.magneticField.z, 0);
+                }
+            }
+             ;
+            return 0;
+
+        case SENSOR_GPS:
+            self.locMngr startUpdatingLocation;
+            gpsActive = 1;
+            return 0;
+
+    }
+
+    return 1;
+}
+
+- (int) stopSensor
+{
+	sensorActive=0;
+    switch (sensorType) {
+        case SENSOR_ACCELEROMETER:
+            self motionManager stopAccelerometerUpdates;
+            return 0;
+            break;
+        case SENSOR_GYROSCOPE:
+            self motionManager stopGyroUpdates;
+            return 0;
+            break;
+        case SENSOR_MAGNETOMETER:
+            self motionManager stopMagnetometerUpdates;
+            return 0;
+        case SENSOR_GPS:
+            self.locMngr stopUpdatingLocation;
+            gpsActive = 0;
+            return 0;
+            break;
+    }
+    return 1;
+}
+
+- (int) isSensorStarted
+{
+    switch (sensorType) {
+        case SENSOR_ACCELEROMETER:
+            return self motionManager isAccelerometerActive;
+            break;
+        case SENSOR_GYROSCOPE:
+            return self motionManager isGyroActive;
+            break;
+        case SENSOR_MAGNETOMETER:
+            return self motionManager isMagnetometerActive;
+        case SENSOR_GPS:
+            return gpsActive;
+            break;
+    }
+    return 0;
+}
+
+- (void)locationManager:(CLLocationManager *)manager didUpdateToLocation:(CLLocation *)location fromLocation:(CLLocation *)oldLocation {
+    if ( sensorCallbak ) {
+		sensorCallbak(sensorType, (float)location.coordinate.latitude, (float)location.coordinate.longitude, (float)location.altitude, (float)location.horizontalAccuracy);
+	}
+}
+
+@end
+
+
+int sensor_get_type(void* inst);
+int sensor_start(void* inst);
+int sensor_stop(void* inst);
+int sensor_is_running(void* inst);
+
+void *sensor_create(int type, SensorDataCallback *callback) {
+    void* obj = SensorAccess alloc init;
+	if (!obj) return NULL;
+    (id)obj setSensorType:type;
+    (id)obj setSensorCallback:callback ;
+    return obj;
+}
+
+int sensor_destroy(void** inst) {
+    (id)*inst dealloc;
+    *inst = NULL;
+    return 0;
+}
+
+int sensor_get_type(void* inst) {
+    if ( !inst ) return 1;
+    return (id)inst getSensorType;
+}
+
+int sensor_start(void* inst) {
+    if ( !inst ) return 1;
+    return (id)inst startSensor;
+}
+
+int sensor_stop(void* inst) {
+    if ( !inst ) return 1;
+    return (id)inst stopSensor;
+}
+
+int sensor_is_running(void* inst) {
+    if ( !inst ) return 1;
+    return (id)inst isSensorStarted;
+}

gpac-2.2.0.tar.gz/applications/gpac/ios_sensors/sensors_def.h Added

@@ -0,0 +1,57 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ *  This file is part of GPAC / gpac ios application
+ *
+ *  GPAC is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  GPAC is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+ 
+#ifndef _SENSORS_DEF_H_
+#define _SENSORS_DEF_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//accelerometer
+#define SENSOR_ACCELEROMETER    0
+//gyro
+#define SENSOR_GYROSCOPE        1
+//yaw-pitch-roll
+#define SENSOR_ORIENTATION       2
+//magnetometer
+#define SENSOR_MAGNETOMETER     3
+//GPS
+#define SENSOR_GPS              4
+
+typedef void (SensorDataCallback)(int sensor_type, float x, float y, float z, float w);
+
+void *sensor_create(int type, SensorDataCallback *callback);
+int sensor_destroy(void** inst);
+int sensor_get_type(void* inst);
+int sensor_start(void* inst);
+int sensor_stop(void* inst);
+int sensor_is_running(void* inst);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_SENSORS_DEF_H_

gpac-2.2.0.tar.gz/applications/gpac/resource.h Added

gpac-2.2.0.tar.gz/applications/gpac_android Added

gpac-2.2.0.tar.gz/applications/gpac_android/.gitignore Added

gpac-2.2.0.tar.gz/applications/gpac_android/build.gradle Added

@@ -0,0 +1,48 @@
+apply plugin: 'com.android.application'
+import org.apache.tools.ant.taskdefs.condition.Os
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:2.1.2'
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}
+
+android {
+    compileSdkVersion 28
+    buildToolsVersion "25.0.2"
+
+    defaultConfig {
+        applicationId "io.gpac.gpac"
+        minSdkVersion 16
+        targetSdkVersion 22
+    }
+
+    sourceSets.main {
+        jni.srcDirs =  // This prevents the auto generation of Android.mk
+        jniLibs.srcDir 'src/main/libs' // our JNI libs
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+    }
+}
+
+dependencies {
+    compile files('libs/real3d.jar')
+    compile 'com.android.support:recyclerview-v7:23.1.1'
+    compile 'com.android.support:cardview-v7:23.1.1'
+    compile 'com.android.support:appcompat-v7:23.1.1'
+    compile 'com.android.support:design:23.1.1'
+}

gpac-2.2.0.tar.gz/applications/gpac_android/gradle Added

gpac-2.2.0.tar.gz/applications/gpac_android/gradle/wrapper Added

gpac-2.2.0.tar.gz/applications/gpac_android/gradle/wrapper/gradle-wrapper.jar Added

gpac-2.2.0.tar.gz/applications/gpac_android/gradle/wrapper/gradle-wrapper.properties Added

gpac-2.2.0.tar.gz/applications/gpac_android/gradlew Added

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while  -h "$PRG"  ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> $.*$$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if  -n "$JAVA_HOME"  ; then
+    if  -x "$JAVA_HOME/jre/sh/java"  ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if  ! -x "$JAVACMD"  ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if  "$cygwin" = "false" -a "$darwin" = "false"  ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if  $? -eq 0  ; then
+        if  "$MAX_FD" = "maximum" -o "$MAX_FD" = "max"  ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if  $? -ne 0  ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if  "$GRADLE_CYGPATTERN" != ""  ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if  $CHECK -ne 0  &&  $CHECK2 -eq 0  ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS${#JVM_OPTS*}="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS@}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gpac-2.2.0.tar.gz/applications/gpac_android/gradlew.bat Added

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval2+2" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

gpac-2.2.0.tar.gz/applications/gpac_android/libs Added

gpac-2.2.0.tar.gz/applications/gpac_android/libs/real3d.jar Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/AndroidManifest.xml Added

@@ -0,0 +1,155 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="io.gpac.gpac"
+ android:versionCode="1"
+ android:versionName="1.0">
+
+ <uses-permission android:name="android.permission.WAKE_LOCK" />
+ <uses-permission android:name="android.permission.INTERNET" />
+ <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+ <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+ <uses-permission android:name="android.permission.CAMERA" />
+ <uses-permission android:name="android.permission.RECORD_AUDIO" />
+ <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+ <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+
+ <uses-feature
+ android:name="lge.hardware.real3d.barrier.landscape"
+ android:required="false" />
+
+ <uses-feature
+ android:name="android.hardware.camera"
+ android:required="false" />
+ <uses-feature
+ android:name="android.hardware.camera.autofocus"
+ android:required="false" />
+ <uses-feature
+ android:name="android.hardware.sensor.gyroscope"
+ android:required="false" />
+ <uses-feature
+ android:name="android.hardware.sensor.accelerometer"
+ android:required="false" />
+ <uses-feature
+ android:glEsVersion="0x00020000"
+ android:required="true" />
+
+ <application
+ android:icon="@drawable/icon"
+ android:label="@string/app_name">
+ <uses-library
+ android:name="com.lge.real3d"
+ android:required="false" />
+
+ <activity
+ android:name=".GPAC"
+ android:noHistory="true"
+ android:configChanges="orientation|screenSize"
+ android:label="@string/app_name">
+
+ android:theme="@android:style/Theme.AppCompat">
+ <intent-filter>
+
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+
+ </intent-filter>
+ <intent-filter android:label="Open with GPAC">
+ <action android:name="android.intent.action.VIEW" />
+
+ <category android:name="android.intent.category.DEFAULT" />
+
+ <data
+ android:mimeType="audio/*"
+ android:scheme="http" />
+
+ <data android:mimeType="audio/*" />
+
+ <data
+ android:mimeType="video/*"
+ android:scheme="http" />
+
+ <data android:mimeType="video/*" />
+
+ <data
+ android:mimeType="x-subtitle/*"
+ android:scheme="http" />
+
+ <data android:mimeType="x-subtitle/*" />
+
+ <data
+ android:mimeType="application/x-mpegurl"
+ android:scheme="http" />
+
+ <data android:mimeType="application/x-mpegurl" />
+
+ <data android:scheme="udp" />
+
+ <data android:scheme="rtsp" />
+
+ <data
+ android:mimeType="application/vnd.apple.mpegurl"
+ android:scheme="http" />
+
+ <data android:mimeType="application/vnd.apple.mpegurl" />
+
+ <data
+ android:mimeType="application/x-isomedia"
+ android:scheme="http" />
+
+ <data android:mimeType="application/x-isomedia" />
+
+ <data
+ android:mimeType="application/mp4"
+ android:scheme="http" />
+
+ <data android:mimeType="application/mp4" />
+
+ <data
+ android:mimeType="application/sdp"
+ android:scheme="http" />
+
+ <data android:mimeType="application/sdp" />
+
+ <data
+ android:mimeType="application/x-bt"
+ android:scheme="http" />
+
+ <data android:mimeType="application/x-bt" />
+
+ <data
+ android:mimeType="application/x-xmt"
+ android:scheme="http" />
+
+ <data
+ android:mimeType="application/dash+xml"
+ android:scheme="http" />
+
+ <data android:mimeType="application/x-xmt" />
+
+ <data
+ android:pathPattern="*.mp4"
+ android:scheme="file"
+ />
+ </intent-filter>
+ </activity>
+ <activity
+ android:name=".extra.FileChooserActivity"
+ android:configChanges="orientation|screenSize"
+ android:label="@string/app_name"
+ android:permission="android.permission.WRITE_EXTERNAL_STORAGE">
+ <intent-filter android:priority="1">
+
+ <action android:name="org.openintents.action.PICK_FILE" />
+ <category android:name="android.intent.category.DEFAULT" />
+ <data android:scheme="file" />
+
+ </intent-filter>
+ </activity>
+ <activity android:name=".extra.URLAuthenticate"
+ android:label="@string/authName"
+ android:theme="@android:style/Theme.Dialog"
+ android:excludeFromRecents="true"/>
+
+ </application>
+
+</manifest>

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/GPAC.java Added

@@ -0,0 +1,1485 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre, NGO Van Luyen, Ivica Arsov
+ *			Copyright (c) Telecom Paris 2010-2022
+ *			All rights reserved
+ *
+ * This file is part of GPAC / JavaScript libgpac Core bindings
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+package io.gpac.gpac;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.Map;
+import java.util.Date;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.res.Configuration;
+import android.hardware.SensorManager;
+import android.location.LocationManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.os.PowerManager.WakeLock;
+import android.os.Vibrator;
+import android.text.InputType;
+import android.util.Log;
+import android.view.View;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.WindowManager;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.ArrayAdapter;
+import android.widget.AutoCompleteTextView;
+import android.widget.LinearLayout;
+import android.widget.Toast;
+import android.content.res.AssetManager;
+import android.os.Environment;
+import android.Manifest;
+import android.support.v4.app.ActivityCompat;
+import android.os.Build;
+import android.content.pm.PackageManager;
+
+import android.os.Handler;
+import android.os.Message;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+
+import io.gpac.gpac.GPACGLSurfaceView;
+import io.gpac.gpac.R;
+import io.gpac.gpac.extra.FileChooserActivity;
+import io.gpac.gpac.extra.URLAuthenticate;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import android.content.pm.PackageManager.NameNotFoundException;
+
+import com.lge.real3d.Real3D;
+import com.lge.real3d.Real3DInfo;
+
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+import android.text.method.ScrollingMovementMethod;
+import android.view.Gravity;
+
+
+
+/**
+ * The main GPAC activity, used to launch everything
+ *
+ * @version $Revision$
+ *
+ */
+public class GPAC extends Activity {
+ private final static String LOG_TAG = "GPAC";
+ private final static int DEFAULT_BUFFER_SIZE = 8192;
+
+ // Activity request ID for picking a file from local file system
+ public final static int PICK_FILE_REQUEST = 1;
+ public final static int AUTH_REQUEST = 2;
+
+ public final static int SERVICE_TYPE_URL = 0;
+ public final static int SERVICE_TYPE_GPAC = 1;
+ public final static int SERVICE_TYPE_MP4BOX = 2;
+
+ // List of all extensions recognized by GPAC - we should fetch this from libgpac
+ public final static String REGISTERED_FILE_EXTENSIONS = "*.mp4,*.bt,*.xmt,*.xml,*.ts,*.svg,*.mp3,*.m3u8,*.mpg,*.aac,*.m4a,*.jpg,*.png,*.wrl,*.mpd,*.m3u8,*.mkv,*.mov,*.ac3,*.pls,*.m3u";
+
+ //underlying C object
+ private long gpac_jni_handle;
+
+	//orientation and location sensors
+ private SensorServices sensors;
+
+	//Real3D rendering
+ private Real3D real3d_dev;
+
+ private static boolean keyboard_visible = false;
+ private static boolean ui_visible;
+
+ private Thread gpac_render_thread;
+
+ private String gpac_data_dir;
+ private String external_storage_dir;
+ private String gpac_install_logs;
+
+ private String init_url = null;
+ private PowerManager.WakeLock wl = null;
+
+ private GPACGLSurfaceView gpac_gl_view;
+
+ private ProgressDialog startupProgress;
+ private String currentURL;
+
+ private int last_orientation = 0;
+	private boolean has_display_cutout = false;
+
+ private String last_displayed_message;
+ //logs view for command line
+	private TextView gpac_log_view;
+	private boolean is_gui_mode = true;
+	private boolean in_session = false;
+	private boolean session_aborted = false;
+
+	private static final int WRITE_PERM_REQUEST = 112;
+
+ // ---------------------------------------
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+		//fetch init URL
+		init_url = null;
+ if (Intent.ACTION_VIEW.equals(getIntent().getAction())) {
+ Uri uri = getIntent().getData();
+ if (uri != null) {
+ synchronized (this) {
+ init_url = uri.toString();
+ }
+ }
+		}
+ if (startupProgress == null) {
+ startupProgress = new ProgressDialog(this);
+ startupProgress.setCancelable(false);
+			startupProgress.setMessage(getResources().getText(R.string.gpacLoading));
+			startupProgress.setTitle(R.string.gpacLoading);
+ }
+ startupProgress.show();
+
+		//reopen of activity ("open with GPAC" called), post open and return
+ if (gpac_gl_view != null) {
+ setContentView(R.layout.main);
+ if (init_url != null)
+ openURLasync(init_url);
+
+ return;
+ }
+
+		if (Build.VERSION.SDK_INT >= 28) {
+			getWindow().getAttributes().layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
+		}
+
+		//locate data dirs and external storage
+		Context context = getApplicationContext();
+ try {
+ if (context == null || context.getPackageManager() == null) {
+ gpac_data_dir = Environment.getDataDirectory() + "/data/io.gpac.gpac";
+ Log.e("GPAC", "Cannot get context or PackageManager, using default directory=" + gpac_data_dir);
+ } else
+ gpac_data_dir = context.getPackageManager().getApplicationInfo(context.getPackageName(), 0).dataDir;
+ } catch (NameNotFoundException e) {
+ Log.e("GPAC", "This is bad, we cannot find ourself : " + context.getPackageName(), e); //$NON-NLS-1$
+ throw new RuntimeException("Cannot find package " + context.getPackageName(), e); //$NON-NLS-1$
+ }
+
+ external_storage_dir = Environment.getExternalStorageDirectory().getAbsolutePath();
+ gpac_install_logs = external_storage_dir + "/gpac_android_launch_logs.txt";
+
+		//extract assets
+		checkAssetsCopy();
+
+		//create layout + GLSurface
+ setContentView(R.layout.main);
+
+
+		if (Build.VERSION.SDK_INT >= 23) {
+		 String PERMISSIONS = {android.Manifest.permission.WRITE_EXTERNAL_STORAGE};
+		 if (!hasPermissions(context, PERMISSIONS)) {
+		 ActivityCompat.requestPermissions((Activity) context, PERMISSIONS, WRITE_PERM_REQUEST );
+		 }
+		}
+
+		final View contentView = (LinearLayout)findViewById(R.id.surface_gl);
+		View decor_view = getWindow().getDecorView();
+		decor_view.setOnSystemUiVisibilityChangeListener(
+			new View.OnSystemUiVisibilityChangeListener() {
+				@Override
+				public void onSystemUiVisibilityChange(int visibility) {
+					if ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0) {
+						ui_visible = true;
+					} else {
+						ui_visible = false;
+					}
+				}
+			}
+		);
+
+		contentView.setClickable(true);
+ final GestureDetector clickDetector = new GestureDetector(this,
+			new GestureDetector.SimpleOnGestureListener() {
+				@Override
+				public boolean onSingleTapUp(MotionEvent e) {
+					if (ui_visible) {
+						if (GPAC.this.keyboard_visible)
+							((InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(gpac_gl_view.getWindowToken(), 0);
+						hideSystemUI();
+					}
+					return true;
+				}
+			}
+		);
+ contentView.setOnTouchListener(new View.OnTouchListener() {
+ @Override
+ public boolean onTouch(View view, MotionEvent motionEvent) {
+ return clickDetector.onTouchEvent(motionEvent);
+ }
+ });
+
+		showSystemUI();
+
+ gpac_log_view = new TextView(this);
+ gpac_log_view.setTextSize(16);
+		gpac_log_view.setGravity(Gravity.BOTTOM);
+ gpac_log_view.setMovementMethod(new ScrollingMovementMethod());
+ gpac_log_view.setTextIsSelectable(true);
+
+		gpac_gl_view = new GPACGLSurfaceView(this);
+
+		final LinearLayout view_layout = (LinearLayout)findViewById(R.id.surface_gl);
+
+		//init sensor manager
+ sensors = new SensorServices(this);
+
+		//real3D renderering
+		boolean real3d_lib_loaded = false;
+ try {
+			Class c = Class.forName("com.lge.real3d.Real3D");
+			final String LGE_3D_DISPLAY = "lge.hardware.real3d.barrier.landscape";
+			if (this.getPackageManager().hasSystemFeature(LGE_3D_DISPLAY)) {
+				real3d_dev = new Real3D(gpac_gl_view.getHolder());
+				real3d_dev.setReal3DInfo(new Real3DInfo(true, Real3D.REAL3D_TYPE_SS, Real3D.REAL3D_ORDER_LR));
+			}
+ } catch (ClassNotFoundException e) { }
+
+ service.submit(new Runnable() {
+ @Override
+ public void run() {
+ // loadAllModules();
+ runOnUiThread(new Runnable() {
+
+ @Override
+ public void run() {
+ startupProgress.setIndeterminate(true);
+ startupProgress.setMessage(getResources().getText(R.string.gpacLoading));
+ PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+ WakeLock wl = pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK, LOG_TAG);
+ if (wl != null)
+ wl.acquire();
+ synchronized (GPAC.this) {
+ GPAC.this.wl = wl;
+ }
+
+						//we need a renderer to catch resize and draw
+ GPACRenderer renderer = new GPACRenderer(GPAC.this);
+ gpac_gl_view.setRenderer(renderer);
+
+ view_layout.addView(gpac_gl_view);
+ }
+ });
+ }
+ });
+		//done
+	}
+
+	private static boolean hasPermissions(Context context, String permissions) {
+	 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && context != null && permissions != null) {
+	 for (String permission : permissions) {
+	 if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
+	 return false;
+	 }
+	 }
+	 }
+	 return true;
+	}
+
+	@Override
+	public void onRequestPermissionsResult(int requestCode, String permissions, int grantResults) {
+	 super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+	 switch (requestCode) {
+	 case WRITE_PERM_REQUEST: {
+	 if (grantResults.length > 0 && grantResults0 == PackageManager.PERMISSION_GRANTED) {
+	 } else {
+	 displayPopup("The app was not allowed to write in your storage", "Error Requesting file write permissions");
+	 }
+	 }
+	 }
+	}
+ /*
+ * Copy /share elements
+ *
+ * Reference: http://stackoverflow.com/questions/4447477/android-how-to-copy-files-from-assets-folder-to-sdcard
+ */
+ private final static String ROOT_ASSET_DIR = "share";
+
+ private void checkAssetsCopy() {
+ //copy APK/assets in APP_DATA/share - we could optimize by using asset manager in NDK
+ File share_dir = new File( gpac_data_dir + "/" + ROOT_ASSET_DIR);
+ //already copied
+ if (share_dir.isDirectory())
+			return;
+
+		// there was a file which have the same name with GUI dir, delete it
+		if (share_dir.exists()) {
+			if (!share_dir.delete())
+				Log.e(LOG_TAG, "Failed to delete " + share_dir);
+		}
+		if (!share_dir.mkdirs())
+			Log.e(LOG_TAG, "Failed to create directory " + share_dir);
+
+		StringBuilder sb = new StringBuilder();
+		HashMap<String, Throwable> exceptions = new HashMap<String, Throwable>();
+		AssetManager assetManager = getAssets();
+		String list = null;
+		Log.d(LOG_TAG, "Copy assets of " + ROOT_ASSET_DIR);
+		try {
+			list = assetManager.list(ROOT_ASSET_DIR);
+		} catch (IOException e) {
+			Log.e(LOG_TAG, "Failed to get asset file list.", e);
+			exceptions.put("Failed to get asset file list", e);
+		}
+		for(String path : list) {
+			try {
+			 copyFileOrDir(ROOT_ASSET_DIR, path);
+			} catch(IOException e) {
+				Log.e(LOG_TAG, "Failed to copy: " + path, e);
+				exceptions.put("Failed to copy " + path, e);
+			}
+		}
+
+		if (!exceptions.isEmpty()) {
+			try {
+				PrintStream out = new PrintStream(gpac_install_logs, "UTF-8");
+				sb.append("*** Exceptions:\n");
+				for (Map.Entry<String, Throwable> ex : exceptions.entrySet()) {
+					sb.append(ex.getKey()).append(": ")
+						.append(ex.getValue().getLocalizedMessage())
+						.append('(')
+						.append(ex.getValue().getClass())
+						.append(")\n");
+				}
+				out.println(sb.toString());
+				out.flush();
+				out.close();
+			} catch (Exception e) {
+				Log.e(LOG_TAG, "Failed to output debug info to debug file", e); //$NON-NLS-1$
+			}
+		}
+	}
+
+	private void copyFileOrDir(String root, String path) throws IOException {
+		AssetManager assetManager = getAssets();
+		String assets = null;
+		assets = assetManager.list(root + "/" + path);
+		if (assets.length == 0) {
+		 copyFile(root, path);
+		} else {
+			String fullPath = null;
+			fullPath = gpac_data_dir + "/" + ROOT_ASSET_DIR + "/" + path;
+
+			File dir = new File(fullPath);
+			if (!dir.exists())
+				dir.mkdir();
+			for (int i = 0; i < assets.length; ++i) {
+				copyFileOrDir(root, path + "/" + assetsi);
+			}
+		}
+	}
+
+	private void copyFile(String root, String filename) throws IOException {
+		if (root.equals(ROOT_ASSET_DIR)){
+			if ((new File(gpac_data_dir + "/" + ROOT_ASSET_DIR + "/" + filename).exists()))
+				return;
+		}
+
+		AssetManager assetManager = getAssets();
+		InputStream in = null;
+		OutputStream out = null;
+		in = assetManager.open(root + "/" + filename);
+
+		String newFileName = null;
+		newFileName = gpac_data_dir + "/" + ROOT_ASSET_DIR + "/" + filename;
+		out = new FileOutputStream(newFileName);
+
+		byte buffer = new byte1024;
+		int read;
+		while ((read = in.read(buffer)) != -1) {
+			out.write(buffer, 0, read);
+		}
+		in.close();
+		in = null;
+		out.flush();
+		out.close();
+		out = null;
+	}
+
+	//if system UI or keyboard is shown, don't forward to GPAC
+ public static boolean noEventForward() {
+//		return (ui_visible || keyboard_visible);
+		return false;
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ MenuInflater inflater = getMenuInflater();
+ inflater.inflate(R.menu.main_menu, menu);
+ return true;
+ }
+
+ @Override
+	public boolean onPrepareOptionsMenu(Menu menu) {
+		MenuItem item = menu.findItem(R.id.runGPAC);
+		item.setTitle(in_session ? R.string.abortSession : R.string.runGPAC);
+
+		item = menu.findItem(R.id.reloadLast);
+		item.setEnabled((currentURL==null) ? false : true);
+		if ((currentURL!=null) && (currentURL.startsWith("gpac ") || currentURL.startsWith("MP4Box "))) {
+			item.setTitle(R.string.reloadSession);
+		} else {
+			item.setTitle(R.string.reloadLast);
+		}
+		return true;
+	}
+
+ private String getRecentURLsFile(int service_type) {
+		String fname = "/GPAC/history_";
+		if (service_type==SERVICE_TYPE_MP4BOX) fname += "mp4box";
+		else if (service_type==SERVICE_TYPE_GPAC) fname += "gpac";
+		else fname += "urls";
+		//if we have a /GPAC profile folder, use it for recent URLs, otherwise use global one (avoids creating a GPAC profile folder)
+ File prof_dir = new File(external_storage_dir + "/GPAC");
+		if (prof_dir.exists()) {
+			return external_storage_dir + fname;
+		}
+		return gpac_data_dir + fname;
+ }
+
+ private boolean openURL(final int service_type) {
+ Future<String> res = service.submit(new Callable<String>() {
+
+ @Override
+ public String call() throws Exception {
+ BufferedReader reader = null;
+ try {
+ reader = new BufferedReader(new InputStreamReader(new FileInputStream(getRecentURLsFile(service_type)),
+ DEFAULT_ENCODING), DEFAULT_BUFFER_SIZE);
+
+ String s = null;
+ Set<String> results = new HashSet<String>();
+ while (null != (s = reader.readLine())) {
+ results.add(s);
+ }
+ addAllRecentURLs(results);
+ return results.toArray(new String0);
+ } finally {
+ if (reader != null)
+ reader.close();
+ }
+ }
+ });
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ final AutoCompleteTextView textView = new AutoCompleteTextView(this);
+ textView.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI);
+ builder.setMessage( (service_type==SERVICE_TYPE_MP4BOX) ? R.string.selectMP4Box : ((service_type==SERVICE_TYPE_GPAC) ? R.string.selectGPAC : R.string.selectURL) )
+ .setCancelable(true)
+ .setPositiveButton((service_type!=SERVICE_TYPE_URL) ? R.string.open_url_ok : R.string.open_cmd_ok, new DialogInterface.OnClickListener() {
+
+				@Override
+				public void onClick(DialogInterface dialog, int id) {
+					dialog.cancel();
+					String the_url = textView.getText().toString();
+					if ((service_type==SERVICE_TYPE_MP4BOX) && !the_url.toLowerCase().startsWith("mp4box ")) {
+						the_url = "MP4Box " + the_url;
+					}
+					else if ((service_type==SERVICE_TYPE_GPAC) && !the_url.toLowerCase().startsWith("gpac ")) {
+						the_url = "gpac " + the_url;
+					}
+					final String newURL = the_url;
+					openURLasync(newURL);
+					service.execute(new Runnable() {
+
+ @Override
+ public void run() {
+ addAllRecentURLs(Collections.singleton(newURL));
+ File tmp = new File(getRecentURLsFile(service_type) + ".tmp"); //$NON-NLS-1$
+ BufferedWriter w = null;
+ try {
+ w = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(tmp),
+ DEFAULT_ENCODING), DEFAULT_BUFFER_SIZE);
+ Collection<String> toWrite = getAllRecentURLs();
+ for (String s : toWrite) {
+ w.write(s);
+ w.write("\n"); //$NON-NLS-1$
+ }
+ w.close();
+ w = null;
+ if (tmp.renameTo(new File(getRecentURLsFile(service_type))))
+ Log.e(LOG_TAG, "Failed to rename " + tmp + " to " + getRecentURLsFile(service_type)); //$NON-NLS-1$//$NON-NLS-2$
+
+ } catch (IOException e) {
+ Log.e(LOG_TAG, "Failed to write recent URLs to " + tmp, e); //$NON-NLS-1$
+ try {
+ if (w != null)
+ w.close();
+ } catch (IOException ex) {
+ Log.e(LOG_TAG, "Failed to close stream " + tmp, ex); //$NON-NLS-1$
+ }
+ }
+
+ }
+ });
+ }
+ })
+ .setNegativeButton(R.string.cancel, null);
+
+ builder.setView(textView);
+
+ builder.show();
+ ArrayAdapter<String> adapter;
+ try {
+ adapter = new ArrayAdapter<String>(this,
+ android.R.layout.simple_dropdown_item_1line,
+ res.get(1, TimeUnit.SECONDS));
+ textView.setAdapter(adapter);
+ } catch (ExecutionException e) {
+ // Ignored
+ Log.e(LOG_TAG, "Error while parsing recent URLs", e); //$NON-NLS-1$
+ } catch (TimeoutException e) {
+ Log.e(LOG_TAG, "It took too long to parse recent URLs", e); //$NON-NLS-1$
+ } catch (InterruptedException e) {
+ Log.e(LOG_TAG, "Interrupted while parsing recent URLs", e); //$NON-NLS-1$
+ }
+
+ return true;
+ }
+
+ private final ExecutorService service = Executors.newSingleThreadExecutor();
+
+ private final Set<String> allRecentURLs = new HashSet<String>();
+
+ private synchronized void addAllRecentURLs(Collection<String> urlsToAdd) {
+ allRecentURLs.addAll(urlsToAdd);
+ }
+
+ private synchronized Collection<String> getAllRecentURLs() {
+ return new ArrayList<String>(allRecentURLs);
+ }
+
+ private final static Charset DEFAULT_ENCODING = Charset.forName("UTF-8"); //$NON-NLS-1$
+
+ /**
+ * Opens a new activity to select a file
+ *
+ * @return true if activity has been selected
+ */
+ private boolean openFileDialog() {
+ String title = getResources().getString(R.string.selectFile);
+ Uri uriDefaultDir = Uri.fromFile(new File( gpac_data_dir ));
+ Intent intent = new Intent();
+ intent.setAction(Intent.ACTION_PICK);
+ // Files and directories
+ intent.setDataAndType(uriDefaultDir, "vnd.android.cursor.dir/lysesoft.andexplorer.file"); //$NON-NLS-1$
+ // Optional filtering on file extension.
+ intent.putExtra("browser_filter_extension_whitelist", REGISTERED_FILE_EXTENSIONS); //$NON-NLS-1$
+ // Title
+ intent.putExtra("explorer_title", title); //$NON-NLS-1$
+
+ try {
+ startActivityForResult(intent, PICK_FILE_REQUEST);
+ return true;
+ } catch (ActivityNotFoundException e) {
+ // OK, lets try with another one... (it includes out bundled one)
+ intent = new Intent("org.openintents.action.PICK_FILE"); //$NON-NLS-1$
+ intent.setData(uriDefaultDir);
+ intent.putExtra(FileChooserActivity.TITLE_PARAMETER, title);
+ intent.putExtra("browser_filter_extension_whitelist", REGISTERED_FILE_EXTENSIONS); //$NON-NLS-1$
+ try {
+ startActivityForResult(intent, PICK_FILE_REQUEST);
+ return true;
+ } catch (ActivityNotFoundException ex) {
+ // Not found neither... We build our own dialog to display error
+ // Note that this should happen only if we did not embed out own intent
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setMessage("Impossible to find an Intent to choose a file... Cannot open file !") //$NON-NLS-1$
+ .setCancelable(true)
+ .setPositiveButton(R.string.cancel, null);
+ AlertDialog alert = builder.create();
+ alert.show();
+ return false;
+ }
+ }
+ }
+
+ // ---------------------------------------
+ @Override
+ protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
+ if (requestCode == PICK_FILE_REQUEST) {
+ if (resultCode == RESULT_OK) {
+ Uri uri = intent.getData();
+ if (uri != null) {
+ String url = uri.toString();
+ String file = "file://"; //$NON-NLS-1$
+ if (url.startsWith(file)) {
+ url = uri.getPath();
+ }
+ Log.i(LOG_TAG, "Requesting opening local file " + url); //$NON-NLS-1$
+ openURLasync(url);
+ }
+ }
+ return;
+ }
+ if (requestCode == AUTH_REQUEST) {
+ if (resultCode == RESULT_OK) {
+				String user = intent.getStringExtra("USER");
+				String passwd = intent.getStringExtra("PASSWD");
+				displayPopup("User " + user + " Pass " + passwd, "Success");
+ }
+ return;
+		}
+ }
+
+	private void openURLasync(final String url) {
+		if (url==null) return;
+
+		if (url.startsWith("gpac ") || url.startsWith("MP4Box ")) {
+			if (is_gui_mode) {
+				is_gui_mode = false;
+				replaceView(gpac_gl_view, gpac_log_view);
+			}
+			gpac_log_view.setText(null);
+			gpac_log_view.append("Executing \"" + url + "\"\n\n");
+		} else {
+			if (!is_gui_mode) {
+				//switching log view to GLSurfaceView must be done on UI thread otherwsie we crash
+ runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+						is_gui_mode = true;
+						gpac_render_thread = null;
+						replaceView(gpac_log_view, gpac_gl_view);
+ }
+ });
+			}
+		}
+
+ service.execute(new Runnable() {
+
+ @Override
+ public void run() {
+				final int ex_code;
+				if (is_gui_mode) {
+					gpac_gl_view.connect(url);
+					ex_code = 0;
+				} else {
+					session_aborted = false;
+					in_session = true;
+					ex_code = load_service(url);
+					in_session = false;
+				}
+				currentURL = url;
+
+ runOnUiThread(new Runnable() {
+
+ @Override
+ public void run() {
+						if (!is_gui_mode) {
+							setTitle(getResources().getString(R.string.app_name));
+							gpac_log_view.append("\n" + (session_aborted ? "Aborted - " : "") + "exit code: " + ex_code + "\n");
+						} else {
+							setTitle(getResources().getString(R.string.app_name));
+						}
+ }
+ });
+ }
+ });
+ }
+
+ // ---------------------------------------
+
+ @Override
+ public void onConfigurationChanged(Configuration newConfig) {
+ super.onConfigurationChanged(newConfig);
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ // Handle item selection
+ switch (item.getItemId()) {
+ case R.id.open_url:
+ return openURL(SERVICE_TYPE_URL);
+ case R.id.open_file:
+ return openFileDialog();
+ case R.id.reloadLast:
+				if (in_session) {
+					session_aborted=true;
+					abort_session();
+				}
+ openURLasync(currentURL);
+ return true;
+ case R.id.runGPAC:
+				if (in_session) {
+					session_aborted=true;
+					abort_session();
+					return true;
+ }
+ return openURL(SERVICE_TYPE_GPAC);
+ case R.id.runMP4Box:
+				if (in_session) {
+					session_aborted=true;
+					abort_session();
+					return true;
+ }
+ return openURL(SERVICE_TYPE_MP4BOX);
+ case R.id.quit:
+ this.finish();
+ return true;
+ case R.id.resetConfig:
+				if (in_session) {
+					session_aborted=true;
+					abort_session();
+				}
+				reset_config();
+		 runOnUiThread(new Runnable() {
+
+		 @Override
+		 public void run() {
+		 Toast toast = Toast.makeText(GPAC.this, "GPAC Configuration file reset", Toast.LENGTH_SHORT);
+		 toast.show();
+		 }
+		 });
+		 
+ openURLasync("gpac -cfg");
+ return true;
+ 
+/*			case R.id.testAuth:
+ Intent intent = new Intent(GPAC.this, URLAuthenticate.class);
+				intent.putExtra("URL", "http://bar.foo/test");
+				startActivityForResult(intent, AUTH_REQUEST);
+ return true;
+*/
+ default:
+ return super.onOptionsItemSelected(item);
+ }
+ }
+
+
+ @Override
+ protected void onDestroy() {
+ service.shutdown();
+ synchronized (this) {
+ if (wl != null)
+ wl.release();
+ }
+ Log.d(LOG_TAG, "Destroying GPAC instance..."); //$NON-NLS-1$
+ if (isLoaded() ) {
+ uninit();
+ gpac_jni_handle = 0;
+ load_errors = null;
+ }
+ super.onDestroy();
+ //we use JNI and cleaned up GPAC, kill parent process otherwise we will get relaunched with old libgpac loaded ...
+ android.os.Process.killProcess(android.os.Process.myPid());
+ }
+
+ @Override
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ // Handle the back button
+ if (keyCode == KeyEvent.KEYCODE_BACK) {
+ // Ask the user if they want to quit
+ new AlertDialog.Builder(this).setIcon(android.R.drawable.ic_dialog_alert)
+ .setTitle(R.string.quit)
+ .setMessage(R.string.really_quit)
+ .setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+											 GPAC.this.finish();
+ }
+
+ })
+ .setNegativeButton(R.string.no, null)
+ .show();
+
+ return true;
+ } else {
+ return super.onKeyDown(keyCode, event);
+ }
+
+ }
+
+
+ private void displayPopup(final CharSequence message, final CharSequence title) {
+ final String fullMsg = getResources().getString(R.string.displayPopupFormat, title, message);
+ synchronized (this) {
+			// In case of an error message, always popup it
+ if (fullMsg.equals(last_displayed_message) && !title.equals("Error"))
+ return;
+ last_displayed_message = fullMsg;
+ }
+ runOnUiThread(new Runnable() {
+
+ @Override
+ public void run() {
+ Toast toast = Toast.makeText(GPAC.this, fullMsg, Toast.LENGTH_SHORT);
+ toast.show();
+ }
+ });
+
+ }
+
+ /**
+ * Display a message
+ *
+ * @param message
+ * @param title
+ * @param errorCode
+ */
+ public void messageDialog(final String message, final String title, final int status) {
+ if (status == 0) {//GF_OK
+			if (is_gui_mode) {
+				Log.d(LOG_TAG, message);
+			} else {
+				runOnUiThread(new Runnable() {
+					@Override
+					public void run() {
+						gpac_log_view.append(message);
+/*						if (!gpac_log_view.hasSelection()) {
+							final int scrollAmount = gpac_log_view.getLayout().getLineTop(gpac_log_view.getLineCount()) - gpac_log_view.getHeight();
+							gpac_log_view.scrollTo(0, (scrollAmount > 0) ? scrollAmount : 0);
+						}
+*/
+
+					}
+				});
+			}
+			return;
+ }
+ //show a message box
+		runOnUiThread(new Runnable() {
+
+			@Override
+			public void run() {
+				StringBuilder sb = new StringBuilder();
+				sb.append(error_to_string(status) );
+				sb.append(' ');
+				sb.append(title);
+				AlertDialog.Builder builder = new AlertDialog.Builder(GPAC.this);
+				builder.setTitle(sb.toString());
+				sb.append('\n');
+				sb.append(message);
+				builder.setMessage(sb.toString());
+				builder.setCancelable(true);
+				builder.setPositiveButton(R.string.ok, new OnClickListener() {
+
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						dialog.cancel();
+					}
+				});
+				try {
+					builder.create().show();
+				} catch (WindowManager.BadTokenException e) {
+					// May happen when we close the window and there are still somes messages
+					Log.e(LOG_TAG, "Failed to display Message " + sb.toString(), e); //$NON-NLS-1$
+				}
+			}
+		});
+ }
+
+ /**
+ * Called when progress is set, only in player mode with no GUI
+ *
+ * @param msg
+ * @param done
+ * @param total
+ */
+ public void onProgress(final String msg, final int done, final int total) {
+ if (Log.isLoggable(LOG_TAG, Log.DEBUG))
+ Log.d(LOG_TAG, "Setting progress to " + done + "/" + total + ", message=" + msg); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ runOnUiThread(new Runnable() {
+
+ @Override
+ public void run() {
+ // GPAC sometimes return total = 0
+ if (total < 1) {
+ setProgressBarIndeterminate(true);
+ } else {
+ int progress = done * 10000 / (total < 1 ? 1 : total);
+ if (progress > 9900)
+ progress = 10000;
+ setProgressBarIndeterminate(false);
+ setProgress(progress);
+ }
+ }
+ });
+ }
+
+ private static Map<String, Throwable> load_errors = null;
+ /**
+ * Loads all libraries
+ * @return a map of exceptions containing the library as key and the exception as value. If map is empty, no error
+ */
+ synchronized void loadAllLibraries() {
+ if (load_errors != null)
+ return;
+ StringBuilder sb = new StringBuilder();
+ final String toLoad = { "GLESv2", "log",
+ "jpegdroid", "javaenv",
+ "mad", "ft2", "faad",
+ "openjpeg", "png", "z",
+ "avutil", "swscale", "swresample", "avcodec", "avformat", "avfilter", "avdevice",
+ "gpacWrapper", "gpac"};
+ HashMap<String, Throwable> exceptions = new HashMap<String, Throwable>();
+ for (String s : toLoad) {
+ try {
+ String msg = "Loading library " + s + "...";//$NON-NLS-1$//$NON-NLS-2$
+ sb.append(msg);
+ Log.i(LOG_TAG, msg);
+ System.loadLibrary(s);
+ } catch (UnsatisfiedLinkError e) {
+ sb.append("Failed to load " + s + ", error=" + e.getLocalizedMessage() + " :: " //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
+ + e.getClass().getSimpleName() + "\n"); //$NON-NLS-1$
+ exceptions.put(s, e);
+ Log.e(LOG_TAG, "Failed to load library : " + s + " due to link error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
+ } catch (SecurityException e) {
+ exceptions.put(s, e);
+ Log.e(LOG_TAG, "Failed to load library : " + s + " due to security error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
+ } catch (Throwable e) {
+ exceptions.put(s, e);
+ Log.e(LOG_TAG, "Failed to load library : " + s + " due to Runtime error " + e.getLocalizedMessage(), e); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ }
+
+ if (!exceptions.isEmpty()) {
+ try {
+ PrintStream out = new PrintStream(gpac_install_logs, "UTF-8"); //$NON-NLS-1$//$NON-NLS-2$
+ out.println("$Revision$"); //$NON-NLS-1$
+ out.println(new Date());
+ out.println("\n*** Configuration\n"); //$NON-NLS-1$
+ out.println("Data dir ");
+ out.println(gpac_data_dir);
+ out.println("\nExternal data dir: ");
+ out.println(external_storage_dir);
+ sb.append("\n*** Exceptions:\n"); //$NON-NLS-1$
+ for (Map.Entry<String, Throwable> ex : exceptions.entrySet()) {
+ sb.append(ex.getKey()).append(": ") //$NON-NLS-1$
+ .append(ex.getValue().getLocalizedMessage())
+ .append('(')
+ .append(ex.getValue().getClass())
+ .append(")\n"); //$NON-NLS-1$
+ }
+ out.println(sb.toString());
+ out.flush();
+ out.close();
+ } catch (Exception e) {
+ Log.e(LOG_TAG, "Failed to output debug info to debug file", e); //$NON-NLS-1$
+ }
+ }
+ load_errors = Collections.unmodifiableMap(exceptions);
+ }
+
+	public boolean isLoaded() {
+		return (gpac_jni_handle!=0) ? true : false;
+	}
+ public void initGPAC() throws Exception {
+		if (isLoaded())
+			return;
+
+ StringBuilder sb = new StringBuilder();
+ loadAllLibraries();
+ if (!load_errors.isEmpty()) {
+ sb.append("Exceptions while loading libraries:"); //$NON-NLS-1$
+ for (Map.Entry<String, Throwable> x : load_errors.entrySet()) {
+ sb.append('\n')
+ .append(x.getKey())
+ .append('')
+ .append(x.getValue().getClass().getSimpleName())
+ .append(": ") //$NON-NLS-1$
+ .append(x.getValue().getLocalizedMessage());
+ }
+ Log.e(LOG_TAG, sb.toString());
+ }
+
+ try {
+			int width = gpac_gl_view.getWidth();
+			int height = gpac_gl_view.getHeight();
+			if (Build.VERSION.SDK_INT >= 28) {
+				if ( getWindow().getDecorView().getRootWindowInsets().getDisplayCutout() != null)
+					has_display_cutout = true;
+		 }
+ gpac_jni_handle = init(this, width, height, has_display_cutout, init_url, external_storage_dir, gpac_data_dir );
+			if (gpac_jni_handle == 0) {
+				throw new Exception("Error while creating instance, no handle created!\n" + sb.toString()); //$NON-NLS-1$
+			}
+ } catch (Throwable e) {
+			onGPACError(e);
+ throw new Exception("Error while creating instance\n" + sb.toString()); //$NON-NLS-1$
+ }
+ gpac_render_thread = Thread.currentThread();
+
+ startupProgress.dismiss();
+ Log.i(LOG_TAG, "GPAC is ready"); //$NON-NLS-1$
+ }
+
+
+ /**
+ * Called when GPAC initialization fails
+ *
+ * @param e
+ */
+ public void onGPACError(final Throwable e) {
+ startupProgress.dismiss();
+ Log.e(LOG_TAG, "GPAC Error", e); //$NON-NLS-1$
+ runOnUiThread(new Runnable() {
+
+ @Override
+ public void run() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("Failed to init GPAC due to ");
+ sb.append(e.getClass().getSimpleName());
+ AlertDialog.Builder builder = new AlertDialog.Builder(GPAC.this);
+ builder.setTitle(sb.toString());
+ sb.append("\nDescription: ");
+ sb.append(e.getLocalizedMessage());
+ sb.append("\nRevision: $Revision$"); //$NON-NLS-1$
+ sb.append("\nConfiguration information :");
+ sb.append("\nData dir:");
+ sb.append(gpac_data_dir);
+ sb.append("\nExternal Data dir:");
+ sb.append(external_storage_dir);
+
+ builder.setMessage(sb.toString());
+ builder.setCancelable(true);
+ builder.setPositiveButton(R.string.ok, new OnClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ dialog.cancel();
+ }
+ });
+ builder.create().show();
+ }
+ });
+ }
+
+ @Override
+ protected void onPause() {
+ super.onPause();
+ if (gpac_gl_view != null)
+ gpac_gl_view.onPause();
+ }
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+ if (gpac_gl_view != null)
+ gpac_gl_view.onResume();
+ }
+
+ /**
+ * @see android.app.Activity#onStop()
+ */
+ @Override
+ protected void onStop() {
+ Log.i(LOG_TAG, "onStop called on activity"); //$NON-NLS-1$
+ super.onStop();
+ }
+
+ /**
+ * Show the virtual keyboard
+ *
+ * @param showKeyboard
+ */
+ public void showKeyboard(boolean showKeyboard) {
+ if (this.keyboard_visible == showKeyboard) return;
+ this.keyboard_visible = showKeyboard;
+
+ runOnUiThread(new Runnable() {
+
+ @Override
+ public void run() {
+ InputMethodManager mgr = ((InputMethodManager) getSystemService(INPUT_METHOD_SERVICE));
+ if (GPAC.this.keyboard_visible) {
+ 	mgr.showSoftInput(gpac_gl_view, 0);
+					getActionBar().hide();
+					getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
+					getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
+				} else {
+ 	mgr.hideSoftInputFromWindow(gpac_gl_view.getWindowToken(), 0);
+					getActionBar().show();
+					getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
+					getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
+					hideSystemUI();
+				}
+ //mgr.toggleSoftInputFromWindow(gpac_gl_view.getWindowToken(), 0, 0);
+				gpac_gl_view.requestFocus();
+ }
+ });
+ }
+	@Override
+ public void onWindowFocusChanged(boolean hasFocus) {
+ super.onWindowFocusChanged(hasFocus);
+
+ // When the window loses focus (e.g. the action overflow is shown),
+ // cancel any pending hide action. When the window gains focus,
+ // hide the system UI.
+ if (hasFocus) {
+ delayedHide(100);
+ } else {
+ mHideHandler.removeMessages(0);
+ }
+ }
+
+ private void hideSystemUI() {
+		View decor_view = getWindow().getDecorView();
+ decor_view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+										 | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+										 | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+										 | View.SYSTEM_UI_FLAG_FULLSCREEN
+										 | View.SYSTEM_UI_FLAG_LOW_PROFILE
+										 | View.SYSTEM_UI_FLAG_IMMERSIVE);
+ }
+
+ private void showSystemUI() {
+		View decor_view = getWindow().getDecorView();
+ decor_view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+										 | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+										 | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
+ }
+
+ private final Handler mHideHandler = new Handler() {
+ @Override
+ public void handleMessage(Message msg) {
+ hideSystemUI();
+ }
+ };
+
+ private void delayedHide(int delayMillis) {
+ mHideHandler.removeMessages(0);
+ mHideHandler.sendEmptyMessageDelayed(0, delayMillis);
+ }
+
+ private void replaceView(View oldV, View newV){
+ ViewGroup par = (ViewGroup)oldV.getParent();
+ if(par == null) return;
+
+ int idx = par.indexOfChild(oldV);
+ par.removeViewAt(idx);
+ par.addView(newV, idx);
+ }
+
+ /**
+ * Toggle Sensors on/off
+ *
+ * @param active sensor (true/false)
+ */
+ public void sensorSwitch(final int type, final boolean active) {
+		Log.i(LOG_TAG, "Received " + (active ? "Un-" : "") + "Register Sensors call for type " + type);
+ if (active) {
+			switch (type) {
+			case 0:
+				sensors.registerSensors();
+				break;
+			case 1:
+				sensors.registerLocation();
+				break;
+			}
+ } else {
+			switch (type) {
+			case 0:
+				sensors.unregisterSensors();
+				break;
+			case 1:
+				sensors.unregisterLocation();
+				break;
+			}
+ }
+ }
+ public void setOrientation(final int type) {
+
+		if (type > 0) {
+			last_orientation = this.getRequestedOrientation();
+			if ((type == 1) || (type == 4))
+				this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+			else
+				this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+		} else {
+			this.setRequestedOrientation(last_orientation);
+		}
+	}
+
+ private boolean checkCurrentThread() throws RuntimeException {
+		if (!is_gui_mode) return false;
+ if (Thread.currentThread() != gpac_render_thread)
+ throw new RuntimeException("Method called outside allowed Thread scope !"); //$NON-NLS-1$
+		return true;
+ }
+
+ public void connect(String url) {
+ if (gpac_render_thread == null)
+			gpac_render_thread = Thread.currentThread();
+ else if (!checkCurrentThread())
+			return;
+
+		Log.i(LOG_TAG, "connect(" + url + ")"); //$NON-NLS-1$ //$NON-NLS-2$
+		load_service(url);
+ }
+
+ /**
+ * Call this method when a key has been pressed
+ *
+ * @param keyCode
+ * @param event
+ * @param pressed true if key is pressed, false if key is released
+ * @param unicode
+ */
+ public void eventKey(int keyCode, KeyEvent event, boolean pressed, int unicode) {
+ if (!checkCurrentThread()) return;
+ eventkeypress(keyCode, event.getScanCode(), pressed ? 1 : 0, event.getFlags(), unicode);
+ }
+
+ /**
+ * Renders the current frame
+ */
+ public void render() {
+ if (!checkCurrentThread()) return;
+ render_frame();
+ }
+
+ /**
+ * Resizes the object to new dimensions
+ *
+ * @param width
+ * @param height
+ */
+ public void resize(int width, int height) {
+ if (!checkCurrentThread()) return;
+ Log.i(LOG_TAG, "Resizing to " + width + "x" + height); //$NON-NLS-1$ //$NON-NLS-2$
+
+		int orientation = getResources().getConfiguration().orientation;
+		int rotation = getWindowManager().getDefaultDisplay().getRotation();
+		int actual_orientation = -1;
+		if ((orientation == Configuration.ORIENTATION_LANDSCAPE)
+			&& ((rotation == android.view.Surface.ROTATION_0) || (rotation == android.view.Surface.ROTATION_90))
+		) {
+			orientation = 2; //GF_DISPLAY_MODE_LANDSCAPE
+		} else if ((orientation == Configuration.ORIENTATION_PORTRAIT)
+			&& ((rotation == android.view.Surface.ROTATION_0) || (rotation == android.view.Surface.ROTATION_90))
+		) {
+			orientation = 1; //GF_DISPLAY_MODE_PORTRAIT
+		} else if ((orientation == Configuration.ORIENTATION_LANDSCAPE)
+			&& ((rotation == android.view.Surface.ROTATION_180) || (rotation == android.view.Surface.ROTATION_270))
+		) {
+			orientation = 3; //GF_DISPLAY_MODE_LANDSCAPE_INV
+		} else if ((orientation == Configuration.ORIENTATION_PORTRAIT)
+			&& ((rotation == android.view.Surface.ROTATION_180) || (rotation == android.view.Surface.ROTATION_270))
+		) {
+			orientation = 4; //GF_DISPLAY_MODE_PORTRAIT_INV
+		} else {
+			orientation = 0; //GF_DISPLAY_MODE_UNKNOWN
+		}
+ set_size(width, height, orientation);
+ }
+
+ private boolean touched = false;
+
+ /**
+ * Call this when a motion event occurs
+ *
+ * @param event
+ */
+ public void motionEvent(MotionEvent event) {
+ if (!checkCurrentThread()) return;
+ final float x = event.getX();
+ final float y = event.getY();
+ switch (event.getAction()) {
+ // not in 1.6 case MotionEvent.ACTION_POINTER_1_DOWN:
+ case MotionEvent.ACTION_DOWN:
+ eventmousemove(x, y);
+ eventmousedown(x, y);
+ touched = true;
+ break;
+ // not in 1.6 case MotionEvent.ACTION_POINTER_1_UP:
+ case MotionEvent.ACTION_UP:
+ if ( !touched ) break;
+ eventmouseup(x, y);
+ eventmousemove(0, 0);
+ touched = false;
+ break;
+ case MotionEvent.ACTION_MOVE:
+ 	eventmousemove(x, y);
+ 	if ( !touched ) {
+ 		touched = true;
+ 		eventmousedown(x, y);
+ 	}
+ 	break;
+ case MotionEvent.ACTION_CANCEL:
+ 	if ( !touched )
+ 		break;
+ eventmouseup(x, y);
+ touched = false;
+ break;
+ }
+ }
+
+ public void onOrientationChange(float yaw, float pitch, float roll){
+ eventorientationchange(yaw, pitch, roll);
+ }
+
+ public void onLocationChange(double longitude, double latitude, double altitude, float bearing, float accuracy) {
+ eventlocationchange(longitude, latitude, altitude, bearing, accuracy);
+ }
+
+ /**
+ * All Native functions, those functions are binded using the handle
+ */
+
+ /**
+ * Used to create the GPAC instance
+ *
+ * @param main_act
+ * @param width
+ * @param height
+ * @param cfg_dir
+ * @param modules_dir
+ * @param cache_dir
+ * @param font_dir
+ * @param gui_dir
+ * @return
+ */
+ private native long init(GPAC main_act, int width, int height, boolean has_display_cutout, String url_to_open, String profile, String data_dir);
+
+ /**
+ * Opens an URL
+ *
+ * @param url The URL to open
+ */
+ private native int load_service(String url);
+
+
+ /**
+ * Renders
+ *
+ * @param handle
+ */
+ private native void render_frame();
+
+ /**
+ * Resizes the current view
+ *
+ * @param width The new width to set
+ * @param height The new height to set
+ */
+ private native void set_size(int width, int height, int orientation);
+
+ /**
+ * Free all GPAC resources
+ */
+ private native void uninit();
+
+ /**
+ * To call when a key has been pressed
+ *
+ * @param keycode
+ * @param rawkeycode
+ * @param up
+ * @param flag
+ */
+ private native void eventkeypress(int keycode, int rawkeycode, int up, int flag, int unicode);
+
+ /**
+ * To call when a mouse is down
+ *
+ * @param x Position in pixels
+ * @param y Position in pixels
+ */
+ private native void eventmousedown(float x, float y);
+
+ /**
+ * To call when a mouse is up (released)
+ *
+ * @param x Position in pixels
+ * @param y Position in pixels
+ */
+ private native void eventmouseup(float x, float y);
+
+ /**
+ * To call when a mouse is moving
+ *
+ * @param x Position in pixels
+ * @param y Position in pixels
+ */
+ private native void eventmousemove(float x, float y);
+
+ /**
+ * To call when a change in orientation is returned from the sensors
+ * All angles are in RADIANS and positive in the COUNTER-CLOCKWISE direction
+ *
+ * @param x yaw (rotation around the -Z axis) range: -PI, PI
+ * @param y pitch (rotation around the -X axis) range: -PI/2, PI/2
+ * @param z roll (rotation around the Y axis) range: -PI, PI
+ */
+ private native void eventorientationchange(float x, float y, float z);
+
+ private native void eventlocationchange(double longitude, double latitude, double altitude, float bearing, float accuracy);
+
+ public native String error_to_string(int err_code);
+
+	public native void abort_session();
+ private native void reset_config();
+
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/GPACGLSurfaceView.java Added

@@ -0,0 +1,131 @@
+package io.gpac.gpac;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.widget.Toast;
+
+/**
+ * The view represented the blitted contents by libgpac
+ * 
+ * @version $Revision$
+ * 
+ */
+public class GPACGLSurfaceView extends GLSurfaceView {
+
+    private final static String LOG_GL_SURFACE = "GPACGLSurfaceView";
+
+    private GPAC main_act;
+
+    public GPACGLSurfaceView(GPAC gpac_act) {
+        super(gpac_act);
+        setEGLContextClientVersion(2);
+        setPreserveEGLContextOnPause(true);
+        //setDebugFlags(DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS);
+        setFocusable(true);
+        setFocusableInTouchMode(true);
+        main_act = gpac_act;
+    }
+
+    /* Set the renderer */
+    public void setRenderer(GPACRenderer renderer) {
+        super.setRenderer(renderer);
+        setRenderMode(RENDERMODE_CONTINUOUSLY);
+    }
+
+    @Override
+    public boolean onTouchEvent(final MotionEvent event) {
+		if (GPAC.noEventForward() )
+			return false;
+
+		queueEvent(new Runnable() {
+		    @Override
+		    public void run() {
+		        main_act.motionEvent(event);
+		    }
+		});
+		return true;
+	}
+
+    private static final long TIME_INTERVAL = 500;
+    private static long mBackPressed;
+    /* Should we handle this key in GPAC ?
+     @param keyCode
+     @param event
+     @return true if event is to be handled by GPAC
+	*/
+    private static boolean handleInGPAC(int keyCode, KeyEvent event) {
+        if (event.isSystem() && keyCode!=KeyEvent.KEYCODE_BACK)
+            return false;
+        switch (keyCode) {
+		case KeyEvent.KEYCODE_MEDIA_STOP:
+		case KeyEvent.KEYCODE_MENU:
+			return false;
+		case KeyEvent.KEYCODE_BACK:
+			if (mBackPressed + TIME_INTERVAL > System.currentTimeMillis()){
+				return false;
+			}
+			return true;
+		default:
+			return true;
+        }
+    }
+
+    @Override
+    public boolean onKeyDown(final int keyCode, final KeyEvent event) {
+	if (keyCode == KeyEvent.KEYCODE_BACK) Toast.makeText(main_act, "Press back button twice to exit", Toast.LENGTH_SHORT).show();
+        if (handleInGPAC(keyCode, event)) {
+            Log.d(LOG_GL_SURFACE, "onKeyDown = " + keyCode); //$NON-NLS-1$
+            queueEvent(new Runnable() {
+
+                @Override
+                public void run() {
+                    main_act.eventKey(keyCode, event, true, event.getUnicodeChar());
+                }
+            });
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onKeyUp(final int keyCode, final KeyEvent event) {
+        if (handleInGPAC(keyCode, event)) {
+            Log.d(LOG_GL_SURFACE, "onKeyUp =" + keyCode); //$NON-NLS-1$
+	    if (keyCode == KeyEvent.KEYCODE_BACK) mBackPressed = System.currentTimeMillis();
+            queueEvent(new Runnable() {
+
+                @Override
+                public void run() {
+                    main_act.eventKey(keyCode, event, false, event.getUnicodeChar());
+                }
+            });
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onResume() {
+        if ( main_act.isLoaded() )
+            super.onResume();
+    }
+
+    @Override
+    public void onPause() {
+        if ( main_act.isLoaded() )
+            super.onPause();
+    }
+
+    public void connect(final String url) {
+        queueEvent(new Runnable() {
+
+            @Override
+            public void run() {
+                main_act.connect(url);
+            }
+        });
+    }
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/GPACRenderer.java Added

@@ -0,0 +1,50 @@
+package io.gpac.gpac;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+import android.opengl.GLES20;
+import android.opengl.GLSurfaceView;
+import android.util.Log;
+
+/**
+ * The renderer
+ * 
+ * @version $Revision$
+ * 
+ */
+public class GPACRenderer implements GLSurfaceView.Renderer {
+
+    private final static String LOG_RENDERER = GPACRenderer.class.getSimpleName();
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+		try {
+			main_act.initGPAC();
+		} catch (Exception e) {
+			return;
+		}
+    }
+
+    /**
+     * Constructor
+     * 
+     * @param main_act main GPAC activity
+     * @param urlToLoad The URL to load at startup, can be null
+     */
+    public GPACRenderer(GPAC main_act) {
+        this.main_act = main_act;
+    }
+
+    private final GPAC main_act;
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int w, int h) {
+        Log.i(LOG_RENDERER, "Surface changed from thread " + Thread.currentThread()); //$NON-NLS-1$
+        main_act.resize(w, h);
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        main_act.render();
+    }
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/SensorServices.java Added

@@ -0,0 +1,434 @@
+package io.gpac.gpac;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.Display;
+import android.view.WindowManager;
+
+
+import java.util.TimerTask;
+import java.util.Timer;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Bundle;
+
+/**
+ * Class for 360video sensors management
+ *
+ * @author Emmanouil Potetsianakis <emmanouil.potetsianakis@telecom-paristech.fr>, Jean Le Feuvre
+ * @version $Revision$
+ */
+public class SensorServices implements SensorEventListener, LocationListener {
+
+ //automatically set to true, if TYPE_ROTATION_VECTOR sensor is detected
+ //NOTE: this is a composite sensor; does not work with fusion
+ private boolean useRotationVector;
+
+//Startof Options
+ private static final int SENSOR_DELAY = SensorManager.SENSOR_DELAY_FASTEST; // 0: SENSOR_DELAY_FASTEST, 1: SENSOR_DELAY_GAME, 2: SENSOR_DELAY_UI, 3: SENSOR_DELAY_NORMAL
+
+ private static final boolean USE_ORIENTATION_FILTER = true; //if true smoothSensorMeasurement is applied to getOrientation result
+ private static final boolean USE_ORIENTATION_THRESHOLD = true; //if true keepOrientation() discards results within the error margin
+
+ //the lower the value, the more smoothing is applied (lower response) - set to 1.0 for no filter
+ private static final float ORIENTATION_FILTER_LVL = 0.04f;
+ //threshold to discard orientation x, y, z
+ private static final float ORIENTATION_THRESHOLD = {0.2f, 0.02f, 0.02f};
+//Endof Options
+
+
+ private static SensorManager sensorManager;
+ private static LocationManager locationManager;
+
+ private static Sensor accelerometer; //base sensor
+ private static Sensor magnetometer; //base sensor
+ private static Sensor rotationSensor; //composite sensor
+
+ private GPAC main_act;
+ private Display displayDev;
+
+ private boolean newOrientation = false; //auto-set to true when new Rotation arrives (from acc), auto-set to false when rotation is sent to player
+
+ private Timer fuseTimer = new Timer();
+
+ private float acceleration = {0.0f, 0.0f, 0.0f}; //holds acceleration values (g)
+ private float magnetic = {0.0f, 0.0f, 0.0f}; //holds magnetic field values (μT)
+ private float rotationValues = {0.0f, 0.0f, 0.0f};//holds rotation vector
+ private float orientation = {0.0f, 0.0f, 0.0f}; //from acc+magn
+ private float lastOrient = {0.0f, 0.0f, 0.0f}, prevOrient;
+
+ private float rotationMx = new float9;
+ private float rotationMxRaw = new float9;
+
+ private static final String LOG_TAG = "GPAC SensorServices";
+ private static final float _PI_ = (float) Math.PI;
+
+
+ /**
+ * Constructor (initialize sensors)
+ *
+ * @param gpac_act The parent activity
+ * @return SensorServices object
+ */
+ public SensorServices(GPAC gpac_act) {
+ //init sensors
+ sensorManager = (SensorManager) gpac_act.getSystemService(Context.SENSOR_SERVICE);
+ magnetometer = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
+ accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+ rotationSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
+
+ //init the rest
+ WindowManager wm = (WindowManager) gpac_act.getSystemService(Context.WINDOW_SERVICE);
+ displayDev = wm.getDefaultDisplay();
+
+ main_act = gpac_act;
+
+ //check sensor availability and select
+ if(rotationSensor!=null){
+ useRotationVector = true;
+ return;
+ }else{
+ Log.w(LOG_TAG, "No Rotation Vector composit sensor found - Switching to Acc+Magn sensors");
+ }
+
+ if (magnetometer == null || accelerometer == null){
+ Log.e(LOG_TAG, "No Accelerometer and/or Magnetic Field sensors found"); //TODOk handle this - rollback to manual navigation
+ }
+
+		locationManager = (LocationManager) gpac_act.getSystemService(Context.LOCATION_SERVICE);
+
+ }
+
+ /**
+ * Register sensors to start receiving data
+ */
+ public void registerSensors() {
+
+ if (rotationSensor!=null){
+ sensorManager.registerListener(this, rotationSensor, SENSOR_DELAY);
+ Log.i(LOG_TAG, "Using Rotation Vector sensor for 360navigation");
+ return;
+ }
+
+ if (magnetometer != null && accelerometer != null){
+ sensorManager.registerListener(this, magnetometer, SENSOR_DELAY);
+ sensorManager.registerListener(this, accelerometer, SENSOR_DELAY);
+ Log.i(LOG_TAG, "Using Acceleration & Magnetic Field sensors for 360navigation");
+ }
+ }
+
+ //TODOk we do not handle this yet - there is an issue with onResume (not working) and onPause (working)
+ public void unregisterSensors() {
+ sensorManager.unregisterListener(this);
+ }
+
+ public void registerLocation() {
+		if (locationManager != null) {
+			locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
+		}
+	}
+
+ public void unregisterLocation() {
+		if (locationManager != null) {
+			locationManager.removeUpdates(this);
+		}
+	}
+
+ /**
+ * We calculate rotation/orientation on new acc measurements
+ **/
+ @Override
+ public void onSensorChanged(SensorEvent event) {
+
+ boolean newevent = false;
+
+ switch (event.sensor.getType()) {
+ case Sensor.TYPE_ROTATION_VECTOR:
+ rotationValues = event.values.clone();
+ newOrientation = calculateRotationMx();
+ if (newOrientation){
+ float tmpOrient = new float3;
+ SensorManager.getOrientation(rotationMx, tmpOrient);
+ main_act.onOrientationChange(-tmpOrient0, tmpOrient1, -tmpOrient2);
+ }
+ return;
+ case Sensor.TYPE_ACCELEROMETER:
+ newevent=true;
+ acceleration = event.values.clone();
+ break;
+ case Sensor.TYPE_MAGNETIC_FIELD:
+ newevent=true;
+ magnetic = event.values.clone();
+ break;
+
+			case Sensor.TYPE_LIGHT:
+			{
+//				String res = "";
+//				res += event.values0 + ";";
+//				sendData(InternalPtr, res);
+				return;
+			}
+			case Sensor.TYPE_PRESSURE:
+			{
+//				String res = "";
+//				res += event.values0+";";
+//				sendData(InternalPtr, res);
+				break;
+			}
+			case Sensor.TYPE_ORIENTATION:
+//				azzimuth = event.values0;
+//				pitch = event.values1;
+//				roll = event.values2;
+				return;
+			case Sensor.TYPE_GYROSCOPE:
+//				for (int i=0 ; i<3 ; i++)
+//	 	mGDatai = event.valuesi;
+				return;
+
+ default:
+ return;
+ }
+ if(newevent){
+ newOrientation = calculateRotationMx();
+ if (!newOrientation) return;
+ calculateOrientation();
+ updateOrientation();
+ }
+ }
+
+ /**
+ * Calculate orientation X,Y,Z from Acc and Magn
+ * Orientation is stored in prevOrient
+ * Rotation matrix is stored in rotationMx
+ *
+ * @return true if rotationMatrix was updated
+ */
+ private boolean calculateRotationMx() {
+ boolean gotRotation = false;
+
+
+ if(useRotationVector){
+ try {
+ SensorManager.getRotationMatrixFromVector(rotationMxRaw, rotationValues);
+ gotRotation = true;
+ } catch (Exception e) {
+ gotRotation = false;
+ Log.e(LOG_TAG, "Error getting rotation matrix" + e.getMessage());
+ }
+ }else{
+ try {
+ gotRotation = SensorManager.getRotationMatrix(rotationMxRaw, null, acceleration, magnetic);
+ } catch (Exception e) {
+ gotRotation = false;
+ Log.e(LOG_TAG, "Error getting rotation matrix" + e.getMessage());
+ }
+ } 
+
+ if (gotRotation) {
+ //NOTE: the rotation considered is according to device natural orientation
+ //and it might NOT be the same as the screen orientation
+ switch (displayDev.getRotation()) {
+ case 1: //Surface.ROTATION_90
+ rotationMx = rotationMxRaw.clone();
+ break;
+ case 2: //Surface.ROTATION_180
+ SensorManager.remapCoordinateSystem(rotationMxRaw, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, rotationMx);
+ break;
+ case 3: //Surface.ROTATION_270
+ SensorManager.remapCoordinateSystem(rotationMxRaw, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_MINUS_Y, rotationMx);
+ break;
+ case 0: //no rotation (= Surface.ROTATION_0)
+ SensorManager.remapCoordinateSystem(rotationMxRaw, SensorManager.AXIS_MINUS_Y, SensorManager.AXIS_X, rotationMx);
+ break;
+ }
+ }
+
+ return gotRotation;
+ }
+
+ private void calculateOrientation() {
+ float tmpOrient = new float3;
+ SensorManager.getOrientation(rotationMx, tmpOrient);
+ orientation = tmpOrient.clone();
+ }
+
+ private void updateOrientation() {
+ lastOrient = orientation.clone();
+ boolean refreshOrientation = true;
+ if (USE_ORIENTATION_THRESHOLD) {
+ refreshOrientation = keepOrientation(lastOrient, prevOrient);
+ }
+
+ if (refreshOrientation) {
+ if (USE_ORIENTATION_FILTER) {
+ prevOrient = smoothSensorMeasurement(lastOrient, prevOrient);
+ } else {
+ prevOrient = lastOrient;
+ }
+ }
+
+ //NOTE: we invert yaw and roll (for 360 navigation)
+ main_act.onOrientationChange(-prevOrient0, prevOrient1, -prevOrient2);
+ newOrientation = false;
+ }
+
+ private float getRotationMxFromOrientation(float o) {
+ float xM = new float9;
+ float yM = new float9;
+ float zM = new float9;
+
+ float sinX = (float) Math.sin(o1);
+ float cosX = (float) Math.cos(o1);
+ float sinY = (float) Math.sin(o2);
+ float cosY = (float) Math.cos(o2);
+ float sinZ = (float) Math.sin(o0);
+ float cosZ = (float) Math.cos(o0);
+
+ // rotation about x-axis (pitch)
+ xM0 = 1.0f;
+ xM1 = 0.0f;
+ xM2 = 0.0f;
+ xM3 = 0.0f;
+ xM4 = cosX;
+ xM5 = sinX;
+ xM6 = 0.0f;
+ xM7 = -sinX;
+ xM8 = cosX;
+
+ // rotation about y-axis (roll)
+ yM0 = cosY;
+ yM1 = 0.0f;
+ yM2 = sinY;
+ yM3 = 0.0f;
+ yM4 = 1.0f;
+ yM5 = 0.0f;
+ yM6 = -sinY;
+ yM7 = 0.0f;
+ yM8 = cosY;
+
+ // rotation about z-axis (azimuth)
+ zM0 = cosZ;
+ zM1 = sinZ;
+ zM2 = 0.0f;
+ zM3 = -sinZ;
+ zM4 = cosZ;
+ zM5 = 0.0f;
+ zM6 = 0.0f;
+ zM7 = 0.0f;
+ zM8 = 1.0f;
+
+ // rotation order is y, x, z (roll, pitch, azimuth)
+ float resultMatrix = multiplyMx(xM, yM);
+ resultMatrix = multiplyMx(zM, resultMatrix);
+ return resultMatrix;
+ }
+
+ private float multiplyMx(float A, float B) {
+ float result = new float9;
+
+ result0 = A0 * B0 + A1 * B3 + A2 * B6;
+ result1 = A0 * B1 + A1 * B4 + A2 * B7;
+ result2 = A0 * B2 + A1 * B5 + A2 * B8;
+
+ result3 = A3 * B0 + A4 * B3 + A5 * B6;
+ result4 = A3 * B1 + A4 * B4 + A5 * B7;
+ result5 = A3 * B2 + A4 * B5 + A5 * B8;
+
+ result6 = A6 * B0 + A7 * B3 + A8 * B6;
+ result7 = A6 * B1 + A7 * B4 + A8 * B7;
+ result8 = A6 * B2 + A7 * B5 + A8 * B8;
+
+ return result;
+ }
+
+ private static boolean keepOrientation(float in, float out) {
+
+ if (out == null) return true;
+
+ for (int i = 0; i < in.length; i++) {
+ if (Math.abs(ini - outi) > ORIENTATION_THRESHOLDi) return true;
+ }
+
+ return false;
+ }
+
+
+ private static float smoothSensorMeasurement(float in, float out) {
+
+ if (out == null) return in;
+
+ float output = {0.0f, 0.0f, 0.0f};
+ float diff = 0.0f;
+
+
+ for (int i = 0; i < in.length; i++) {
+
+ diff = (ini - outi);
+
+ if (Math.abs(diff) > Math.PI) {
+ float diff_f = 0.0f;
+ if (diff > Math.PI) {
+ diff = 2 * _PI_ - diff;
+ diff_f = outi - ORIENTATION_FILTER_LVL * diff;
+ if (diff_f < -Math.PI) {
+ outputi = (2 * _PI_ + diff_f);
+ } else {
+ outputi = diff_f;
+ }
+ } else if (diff < -Math.PI) {
+ diff = 2 * _PI_ + diff;
+ diff_f = outi + ORIENTATION_FILTER_LVL * diff;
+ if (diff_f > Math.PI) {
+ outputi = -2 * _PI_ + diff_f;
+ } else {
+ outputi = diff_f;
+ }
+
+ }
+
+ } else {
+ outputi = outi + ORIENTATION_FILTER_LVL * diff;
+ }
+ }
+
+ return output;
+ }
+
+
+ @Override
+ public void onAccuracyChanged(Sensor sensor, int accuracy) {
+ //required - but not used
+ }
+
+
+	//GPS
+	@Override
+	public void onLocationChanged(Location loc) {
+ main_act.onLocationChange(loc.getLongitude(), loc.getLatitude(), loc.getAltitude(), loc.getBearing(), loc.getAccuracy());
+	}
+
+	@Override
+	public void onProviderDisabled(String arg0) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void onProviderEnabled(String arg0) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/extra Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/extra/FileArrayAdapter.java Added

@@ -0,0 +1,144 @@
+package io.gpac.gpac.extra;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.support.v4.content.ContextCompat;
+import android.support.v4.graphics.drawable.DrawableCompat;
+import android.support.v7.widget.CardView;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import io.gpac.gpac.R;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Date;
+
+
+public class FileArrayAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
+
+ public interface OnItemClickListener {
+ void onItemClick(View view, int position);
+ }
+
+ private ArrayList<File> files;
+ private OnItemClickListener onItemClickListener;
+ private Context context;
+
+ public FileArrayAdapter(ArrayList<File> files, OnItemClickListener onItemClickListener, Context context) {
+ this.files = files;
+ this.onItemClickListener = onItemClickListener;
+ this.context = context;
+ }
+
+ @Override
+ public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+ return new ListItemViewHolder(
+ LayoutInflater
+ .from(parent.getContext())
+ .inflate(R.layout.list_item_file_chooser, parent, false));
+ }
+
+ @Override
+ public void onBindViewHolder(final RecyclerView.ViewHolder viewHolder, final int position) {
+
+ ListItemViewHolder holder = (ListItemViewHolder) viewHolder;
+ File file = getItem(position);
+ holder.title.setText(file.getName());
+ holder.lastModified.setText(new Date(file.lastModified()).toString());
+ setIcon(file, holder);
+ holder.cardView.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ onItemClickListener.onItemClick(v, position);
+ }
+ });
+ }
+
+ public void setIcon(File file, ListItemViewHolder holder) {
+
+ String extension;
+ Drawable drawable = null;
+
+ try {
+ extension = FileManager.getExtension(file.getAbsolutePath());
+
+ if (file.isFile()) {
+ switch (extension) {
+
+ case ".c": case ".cpp": case ".doc": case ".docx": case ".exe":
+ case ".h": case ".html": case ".java": case ".log": case ".txt":
+ case ".pdf": case ".ppt": case ".xls":
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_file);
+ break;
+
+ case ".3ga": case ".aac": case ".mp3": case ".m4a": case ".ogg":
+ case ".wav": case ".wma":
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_audio);
+ break;
+
+ case ".3gp": case ".avi": case ".mpg": case ".mpeg": case ".mp4":
+ case ".mkv": case ".webm": case ".wmv": case ".vob":
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_video);
+ break;
+
+ case ".ai": case ".bmp": case ".exif": case ".gif": case ".jpg":
+ case ".jpeg": case ".png": case ".svg":
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_image);
+ break;
+
+ case ".rar": case ".zip": case ".ZIP":
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_compressed);
+ break;
+
+ default:
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_error);
+ break;
+ }
+ } else if (file.isDirectory()) {
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_folder);
+ } else drawable = ContextCompat.getDrawable(context, R.drawable.ic_error);
+
+ } catch (Exception e) {
+ drawable = ContextCompat.getDrawable(context, R.drawable.ic_error);
+ }
+ drawable = DrawableCompat.wrap(drawable);
+ holder.icon.setImageDrawable(drawable);
+ }
+
+ @Override
+ public int getItemCount() {
+ return files.size();
+ }
+
+ public File getItem(int position) {
+ return files.get(position);
+ }
+
+ static class ListItemViewHolder extends RecyclerView.ViewHolder {
+
+ CardView cardView;
+ TextView title;
+ TextView lastModified;
+ ImageView icon;
+ LinearLayout linearLayout;
+
+ public ListItemViewHolder(View itemView) {
+ super(itemView);
+ cardView = (CardView) itemView.findViewById(R.id.cardView);
+ title = (TextView) itemView.findViewById(R.id.title);
+ icon = (ImageView) itemView.findViewById(R.id.icon);
+ linearLayout = (LinearLayout) itemView.findViewById(R.id.linearLayout);
+ lastModified = (TextView) itemView.findViewById(R.id.lastModified);
+ }
+ }
+
+ public ArrayList<File> getFiles() {
+ return files;
+ }
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/extra/FileChooserActivity.java Added

@@ -0,0 +1,97 @@
+/**
+ * $URL$
+ * 
+ * $LastChangedBy$ - $LastChangedDate$
+ */
+package io.gpac.gpac.extra;
+
+import android.Manifest;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.FragmentManager;
+import android.content.DialogInterface;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.content.ContextCompat;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import io.gpac.gpac.R;
+
+
+public class FileChooserActivity extends Activity {
+
+ final String FILE_CHOOSER_FRAGMENT = "fileChooserFragment";
+ public final static String TITLE_PARAMETER = "org.openintents.extra.TITLE";
+
+ private FragmentManager fm;
+ private FileChooserFragment fileChooserFragment;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_file_chooser);
+
+ requestForPermission();
+ fm = getFragmentManager();
+
+ if (fm.findFragmentById(R.id.fileChooserLayout) == null) {
+ fileChooserFragment = new FileChooserFragment();
+ fm.beginTransaction()
+ .add(R.id.fileChooserLayout, fileChooserFragment, FILE_CHOOSER_FRAGMENT)
+ .addToBackStack(FILE_CHOOSER_FRAGMENT)
+ .commit();
+ }
+ }
+
+ private void requestForPermission() {
+
+ if (ContextCompat.checkSelfPermission(FileChooserActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ != PackageManager.PERMISSION_GRANTED) {
+
+ if (ActivityCompat.shouldShowRequestPermissionRationale(FileChooserActivity.this,
+ Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
+
+ promptForPermissionsDialog(getString(R.string.requestPermissionStorage), new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ ActivityCompat.requestPermissions(FileChooserActivity.this,
+ new String{Manifest.permission.WRITE_EXTERNAL_STORAGE},
+ 100);
+ }
+ });
+ } else {
+ ActivityCompat.requestPermissions(FileChooserActivity.this,
+ new String{Manifest.permission.WRITE_EXTERNAL_STORAGE},
+ 100);
+ }
+ }
+ }
+
+ private void promptForPermissionsDialog(String message, DialogInterface.OnClickListener onClickListener) {
+ new AlertDialog.Builder(FileChooserActivity.this)
+ .setMessage(message)
+ .setPositiveButton(getString(R.string.yes), onClickListener)
+ .setNegativeButton(getString(R.string.no), null)
+ .create()
+ .show();
+ }
+
+ @Override
+ public void onBackPressed() {
+ fileChooserFragment.backPressed();
+ }
+
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ return true;
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ return super.onOptionsItemSelected(item);
+ }
+
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/extra/FileChooserFragment.java Added

@@ -0,0 +1,160 @@
+package io.gpac.gpac.extra;
+
+import android.Manifest;
+import android.app.ActionBar;
+import android.app.Activity;
+import android.app.Fragment;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.Environment;
+import android.preference.PreferenceManager;
+import android.support.annotation.Nullable;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.widget.GridLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Toast;
+
+import io.gpac.gpac.R;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class FileChooserFragment extends Fragment {
+
+ private final String PREF_SHOW_HIDDEN_FILES = "SHOW_HIDDEN_FILES";
+ private final String PREF_SORT_ORDER = "SORT_ORDER";
+ private final String PREF_SORT_BY = "SORT_BY";
+ private final String PREF_FOLDERS_FIRST = "FOLDERS_FIRST";
+
+ private File currDir;
+ private ArrayList<File> files;
+ private FileArrayAdapter adapter;
+ private SharedPreferences prefs;
+ private ActionBar actionBar;
+
+ private boolean showHiddenFiles;
+ private String sortOrder;
+ private String sortBy;
+ private boolean foldersFirst;
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ != PackageManager.PERMISSION_GRANTED)
+ currDir = new File("/");
+
+ else currDir = Environment.getExternalStorageDirectory();
+ }
+
+ @Nullable
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+ View view = inflater.inflate(R.layout.fragment_file_chooser, container, false);
+ setRetainInstance(true);
+
+ RecyclerView recyclerView = (RecyclerView) view.findViewById(R.id.recyclerView);
+ GridLayoutManager gridLayoutManager = new GridLayoutManager(getActivity(), 2);
+ gridLayoutManager.setOrientation(GridLayoutManager.VERTICAL);
+ files = new ArrayList<>();
+ actionBar = getActivity().getActionBar();
+ adapter = new FileArrayAdapter(files, onItemClickListenerCallback, getActivity());
+ prefs = PreferenceManager.getDefaultSharedPreferences(getActivity());
+ setPreferences();
+ recyclerView.setLayoutManager(gridLayoutManager);
+ populateList(currDir);
+ recyclerView.setAdapter(adapter);
+ return view;
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+ setPreferences();
+ }
+
+ private void setPreferences() {
+ showHiddenFiles = prefs.getBoolean(PREF_SHOW_HIDDEN_FILES, true);
+ sortOrder = prefs.getString(PREF_SORT_ORDER, FileManager.SORT_ORDER_ASC);
+ sortBy = prefs.getString(PREF_SORT_BY, FileManager.SORT_BY_NAME);
+ foldersFirst = prefs.getBoolean(PREF_FOLDERS_FIRST, true);
+ }
+
+ public void backPressed() {
+ if (currDir.getAbsolutePath().equals("/") || !currDir.getParentFile().canRead())
+ getActivity().finish();
+ else populateList(currDir.getParentFile());
+ }
+
+ private FileArrayAdapter.OnItemClickListener onItemClickListenerCallback = new FileArrayAdapter.OnItemClickListener() {
+ @Override
+ public void onItemClick(View view, int position) {
+ File f = adapter.getItem(position);
+ if (f.isDirectory())
+ onDirectoryClick(f);
+ else if (f.isFile())
+ onFileClick(f);
+ }
+ };
+
+ private void onFileClick(File f) {
+ Intent data = new Intent();
+ data.setData(Uri.fromFile(f));
+ getActivity().setResult(Activity.RESULT_OK, data);
+ getActivity().finish();
+ }
+
+ private void onDirectoryClick(File f) {
+ if (f.canRead())
+ populateList(f);
+ else Toast.makeText(getActivity(), "Cannot read " + f, Toast.LENGTH_LONG).show();
+ }
+
+ public void populateList(File file) {
+ new BackgroundWork(file).execute();
+ }
+
+ class BackgroundWork extends AsyncTask<File, String, Boolean> {
+
+ private File file;
+ public BackgroundWork(File file) {
+ this.file = file;
+ }
+
+ @Override
+ protected Boolean doInBackground(File... params) {
+
+ if (!file.canRead()) {
+ Toast.makeText(getActivity(), "Directory cannot be read", Toast.LENGTH_LONG).show();
+ return false;
+ }
+ files.clear();
+ ArrayList<File> list = new ArrayList<>(Arrays.asList(file.listFiles()));
+
+ files.addAll(
+ FileManager.sort(
+ showHiddenFiles? list : FileManager.removeHiddenFiles(list),
+ sortOrder,
+ sortBy,
+ foldersFirst
+ ));
+ currDir = file;
+ return true;
+ }
+
+ @Override
+ protected void onPostExecute(Boolean aVoid) {
+ actionBar.setTitle(file.getAbsolutePath());
+ adapter.notifyDataSetChanged();
+ }
+ }
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/extra/FileManager.java Added

@@ -0,0 +1,189 @@
+package io.gpac.gpac.extra;
+
+import android.os.Build;
+import android.support.annotation.Nullable;
+import android.util.Log;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+
+
+public class FileManager {
+
+ public static final String SORT_ORDER_ASC = "ASC";
+ public static final String SORT_ORDER_DESC = "DESC";
+
+ public static final String SORT_BY_NAME = "NAME";
+ public static final String SORT_BY_SIZE = "SIZE";
+ public static final String SORT_BY_LAST_MODIFIED = "LAST_MODIFIED";
+
+ public static String getExtension(String url) {
+
+ if (url.contains("?")) {
+ url = url.substring(0, url.indexOf("?"));
+ }
+ if (url.lastIndexOf(".") == -1) {
+ return null;
+ } else {
+ String ext = url.substring(url.lastIndexOf("."));
+ if (ext.contains("%")) {
+ ext = ext.substring(0, ext.indexOf("%"));
+ }
+ if (ext.contains("/")) {
+ ext = ext.substring(0, ext.indexOf("/"));
+ }
+ return ext.toLowerCase();
+ }
+ }
+
+ public static ArrayList<File> sort(ArrayList<File> files, String sortOrder, String sortBy, boolean folderFirst) {
+
+ switch (sortOrder) {
+
+ case SORT_ORDER_ASC:
+ switch (sortBy) {
+ case SORT_BY_SIZE:
+ return sortBySize(files, SORT_ORDER_ASC, folderFirst);
+
+ case SORT_BY_LAST_MODIFIED:
+ return sortByLastModified(files, SORT_ORDER_ASC, folderFirst);
+
+ case SORT_BY_NAME:
+ default:
+ return sortByName(files, SORT_ORDER_ASC, folderFirst);
+ }
+
+ case SORT_ORDER_DESC:
+ switch (sortBy) {
+ case SORT_BY_NAME:
+ return sortByName(files, SORT_ORDER_DESC, folderFirst);
+
+ case SORT_BY_LAST_MODIFIED:
+ return sortByLastModified(files, SORT_ORDER_DESC, folderFirst);
+
+ case SORT_BY_SIZE:
+ default:
+ return sortBySize(files, SORT_ORDER_DESC, folderFirst);
+ }
+
+ default:
+ return sortByName(files, SORT_ORDER_ASC, folderFirst);
+ }
+
+ }
+
+ private static ArrayList<File> sortByName(final ArrayList<File> files, final String sortOrder, final boolean folderFirst) {
+
+ Collections.sort(files, new Comparator<File>() {
+ @Override
+ public int compare(File lhs, File rhs) {
+ if(folderFirst) {
+ if (lhs.isDirectory() && !rhs.isDirectory()) return -1;
+ if (!lhs.isDirectory() && rhs.isDirectory()) return 1;
+ }
+ switch (sortOrder) {
+ case SORT_ORDER_DESC:
+ return rhs.getName().compareToIgnoreCase(lhs.getName());
+
+ case SORT_ORDER_ASC:
+ default:
+ return lhs.getName().compareToIgnoreCase(rhs.getName());
+ }
+ }
+ });
+ return files;
+ }
+
+ private static ArrayList<File> sortBySize(ArrayList<File> files, final String sortOrder, final boolean folderFirst) {
+
+ Collections.sort(files, new Comparator<File>() {
+ @Override
+ public int compare(File lhs, File rhs) {
+
+ if(folderFirst) {
+ if (lhs.isDirectory() && !rhs.isDirectory()) return -1;
+ if (!lhs.isDirectory() && rhs.isDirectory()) return 1;
+ }
+
+ long lhsLength = 0, rhsLength = 0, diff;
+
+ if(lhs.isDirectory()) lhsLength = getFolderSize(lhs);
+ if(lhs.isFile()) lhsLength = lhs.length();
+ if(rhs.isDirectory()) rhsLength = getFolderSize(rhs);
+ if(rhs.isFile()) rhsLength = rhs.length();
+
+ switch (sortOrder) {
+ case SORT_ORDER_DESC:
+ diff = rhsLength - lhsLength;
+ break;
+ case SORT_ORDER_ASC:
+ default:
+ diff = lhsLength - rhsLength;
+ break;
+ }
+
+ if (diff < 0) return -1;
+ else if (diff > 0) return 1;
+ else return 0;
+ }
+ });
+ return files;
+ }
+
+ private static ArrayList<File> sortByLastModified(ArrayList<File> files, final String sortOrder, final boolean foldersFirst) {
+
+ Collections.sort(files, new Comparator<File>() {
+ @Override
+ public int compare(File lhs, File rhs) {
+
+ if (foldersFirst){
+ if(lhs.isDirectory() && !rhs.isDirectory()) return -1;
+ if(!lhs.isDirectory() && rhs.isDirectory()) return 1;
+ }
+
+ long diff;
+ switch (sortOrder) {
+ case SORT_ORDER_DESC:
+ diff = rhs.lastModified() - lhs.lastModified();
+ break;
+
+ case SORT_ORDER_ASC:
+ default:
+ diff = lhs.lastModified() - rhs.lastModified();
+ break;
+ }
+
+ if (diff < 0) return -1;
+ else if (diff > 0) return 1;
+ else return 0;
+ }
+ });
+ return files;
+ }
+
+ public static long getFolderSize(File file) {
+
+ long size = 0;
+ for (File f : file.listFiles()) {
+ if (f.isFile()) size += f.length();
+ else size += getFolderSize(f);
+ }
+ return size;
+ }
+
+ public static boolean isHiddenFile(File file) {
+ return file.getName().startsWith(".");
+ }
+
+ public static ArrayList<File> removeHiddenFiles(ArrayList<File> files) {
+ ArrayList<File> list = new ArrayList<>();
+
+ for (File file : files) {
+ if (!isHiddenFile(file))
+ list.add(file);
+ }
+ return list;
+ }
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/java/io/gpac/gpac/extra/URLAuthenticate.java Added

@@ -0,0 +1,65 @@
+package io.gpac.gpac.extra;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.text.Html;
+import android.text.method.ScrollingMovementMethod;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.AutoCompleteTextView;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.TextView;
+import android.widget.Toast;
+import android.view.ViewGroup;
+import android.content.Intent;
+
+import io.gpac.gpac.R;
+
+
+public class URLAuthenticate extends Activity {
+
+    private String TAG = "URLAuthenticate";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_url_authenticate);
+        getWindow().setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+        this.setFinishOnTouchOutside(false);
+
+		TextView txt_url = (TextView) findViewById(R.id.authURL);
+
+		Intent intent = getIntent();
+		txt_url.setText("URL " + intent.getStringExtra("URL"));
+
+		Button b_ok = (Button) findViewById(R.id.ok);
+		b_ok.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				Intent intent=new Intent();
+
+				EditText ed_txt = (EditText) findViewById(R.id.userName);
+				intent.putExtra("USER", ed_txt.getText().toString() );
+
+				ed_txt = (EditText) findViewById(R.id.password);
+				intent.putExtra("PASSWD", ed_txt.getText().toString() );
+
+				setResult(RESULT_OK, intent);
+				finish();
+			}
+		});
+
+		Button b_cancel = (Button) findViewById(R.id.cancel);
+		b_cancel.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				setResult(RESULT_CANCELED);
+				finish();
+			}
+		});
+    }
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/jni Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/jni/gpac_jni.cpp Added

@@ -0,0 +1,1103 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre, Ivica Arsov
+ *			Copyright (c) Telecom Paris 2010-2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / android JNI wrapper for player
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <jni.h>
+#include <android/log.h>
+#include <math.h>
+#include <pthread.h>
+#include <stdio.h>
+
+#include <gpac/thread.h>
+#include <gpac/network.h>
+#include <gpac/tools.h>
+#include <gpac/filters.h>
+#include <gpac/compositor.h>
+
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, "GPAC", __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, "GPAC", __VA_ARGS__)
+
+
+#define GET_GPAC_JNI(_e)	 jclass c = env->GetObjectClass(obj);\
+ if (!c) return _e;\
+ jfieldID fid = env->GetFieldID(c, "gpac_jni_handle", "J");\
+ if (!fid) {\
+ LOGE("No Field ID, ERROR");\
+ return _e;\
+ }\
+ jlong h = env->GetLongField(obj, fid);\
+ GPAC_JNI *gpac = (GPAC_JNI *)h;\
+ if (!gpac) return _e;
+
+
+typedef struct _JavaEnvTh {
+	JNIEnv * env;
+	u32 javaThreadId;
+	//callbacks into GPAC
+	jobject cbk_obj;
+	jmethodID cbk_messageDialog;
+	jmethodID cbk_onProgress;
+	jmethodID cbk_showKeyboard;
+	jmethodID cbk_sensorSwitch;
+	jmethodID cbk_setOrientation;
+} JavaEnvTh;
+
+static JavaVM* javaVM = NULL;
+static pthread_key_t jni_thread_env_key = 0;
+
+typedef struct
+{
+	//GPAC class instance for callbacks
+	jobject gpac_cbk_obj;
+
+	GF_FilterSession *fsess;
+	GF_Compositor *compositor;
+
+	u32 last_width, last_height;
+
+	Bool has_display_cutout;
+	int	no_gui;
+	int	do_log;
+	FILE *log_file;
+
+	char *log_buf;
+	u32 log_buf_size;
+
+	char out_stdGF_MAX_PATH;
+} GPAC_JNI;
+
+static Bool gpac_jni_event_proc(void *cbk, GF_Event *evt);
+static void gpac_jni_on_log(void *cbk, GF_LOG_Level ll, GF_LOG_Tool lm, const char *fmt, va_list list);
+static void translate_key_to_gpac(int android_keycode, GF_EventKey *evt);
+static void on_progress_cbk(const void *usr, const char *title, u64 done, u64 total);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int gpac_main(int argc, char **argv);
+int mp4box_main(int argc, char **argv);
+void gpac_abort(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+void gpac_jni_set_java_env(JavaEnvTh * envToSet, JNIEnv *env, jobject callback)
+{
+	assert( envToSet );
+	jclass localRef = env->GetObjectClass(callback);
+	envToSet->env = env;
+	envToSet->javaThreadId = gf_th_id();
+	envToSet->cbk_obj = callback;
+	envToSet->cbk_messageDialog = env->GetMethodID(localRef, "messageDialog", "(Ljava/lang/String;Ljava/lang/String;I)V");
+	envToSet->cbk_onProgress = env->GetMethodID(localRef, "onProgress", "(Ljava/lang/String;II)V");
+	envToSet->cbk_showKeyboard = env->GetMethodID(localRef, "showKeyboard", "(Z)V");
+	envToSet->cbk_sensorSwitch = env->GetMethodID(localRef, "sensorSwitch", "(IZ)V");
+	envToSet->cbk_setOrientation = env->GetMethodID(localRef, "setOrientation", "(I)V");
+	env->DeleteLocalRef(localRef);
+}
+
+JavaEnvTh * gpac_jni_get_env(GPAC_JNI *gpac_jni)
+{
+	JNIEnv *env;
+	JavaEnvTh * javaEnv;
+	if (!javaVM) {
+		LOGE("No JVM Found");
+		return NULL;
+	}
+	javaEnv = (JavaEnvTh*) pthread_getspecific( jni_thread_env_key );
+	if (javaEnv) return javaEnv;
+	javaEnv = (JavaEnvTh *) malloc(sizeof(JavaEnvTh));
+	if (!javaEnv) return NULL;
+
+	memset(javaEnv, 0, sizeof(JavaEnvTh));
+	javaVM->AttachCurrentThread(&env, NULL);
+	if (!env) {
+		LOGE("Attaching to thread did failed for thread id=%d", gf_th_id());
+		free(javaEnv);
+		return NULL;
+	}
+
+	gpac_jni_set_java_env(javaEnv, env, gpac_jni->gpac_cbk_obj);
+	if (pthread_setspecific(jni_thread_env_key, javaEnv)) {
+		LOGE("Failed to set specific thread data to jni_thread_env_key for thread=%d. No ENV available !", gf_th_id());
+		free(javaEnv);
+		return NULL;
+	}
+	return javaEnv;
+}
+
+
+int show_message(GPAC_JNI *gpac, const char* msg, const char* title, GF_Err status)
+{
+	JavaEnvTh * env = gpac_jni_get_env(gpac);
+	if (!env || !env->cbk_messageDialog) return 0;
+
+	env->env->PushLocalFrame(2);
+	jstring _title = title ? env->env->NewStringUTF(title) : NULL;
+	jstring _msg = msg ? env->env->NewStringUTF(msg) : NULL;
+	env->env->CallVoidMethod(env->cbk_obj, env->cbk_messageDialog, _msg, _title, status);
+	env->env->PopLocalFrame(NULL);
+	return 1;
+}
+
+static GF_Err gpac_init_gui(GPAC_JNI *gpac)
+{
+	GF_Filter *comp_filter=NULL;
+	const char *opt=NULL;
+	GF_Err e = GF_OK;
+
+	gf_sys_init(GF_MemTrackerNone, NULL);
+
+	if (!gf_opts_get_key("core", "threads"))
+		gf_opts_set_key("temp", "threads", "2");
+
+	opt = gf_opts_get_key("core", "log-file");
+	if (opt && strcmp(opt, "system") ) {
+		gpac->log_file = gf_fopen(opt, "wt");
+		if (!gpac->log_file) opt = "system";
+	}
+	if (opt) {
+		gf_log_set_tools_levels( gf_opts_get_key("core", "logs"), GF_TRUE );
+		gf_log_set_callback(gpac, gpac_jni_on_log);
+		gpac->do_log = 1;
+	}
+	gf_opts_set_key("temp", "display-cutout", gpac->has_display_cutout ? "yes" : "no");
+
+	opt = gf_opts_get_key("core", "startup-file");
+	GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("GUI path is %s\n", opt ? opt : "NOT SET!") );
+	gpac->no_gui = 0;
+	if (!opt || !gf_file_exists(opt)) {
+		gpac->no_gui = 1;
+		//if no GUI, redirect progress events
+		gf_set_progress_callback(gpac, on_progress_cbk);
+	}
+
+	//run in non blocking mode
+	gpac->fsess = gf_fs_new_defaults(GF_FS_FLAG_NON_BLOCKING);
+	if (!gpac->fsess) return GF_OUT_OF_MEM;
+
+	comp_filter = gf_fs_load_filter(gpac->fsess, "compositor:player=gui", &e);
+	if (!comp_filter) return e ? e : GF_OUT_OF_MEM;
+
+	gpac->compositor = (GF_Compositor *) gf_filter_get_udta(comp_filter);
+	if (!gpac->compositor) return GF_OUT_OF_MEM;
+
+	/*force fullscreen*/
+	gf_sc_set_option(gpac->compositor, GF_OPT_FULLSCREEN, 1);
+	gf_sc_set_size(gpac->compositor, gpac->last_width, gpac->last_height);
+	gf_fs_set_ui_callback(gpac->fsess, gpac_jni_event_proc, gpac);
+
+	//prevent destruction of JSRT until we unload gpac
+	gf_opts_set_key("temp", "static-jsrt", "true");
+
+	return GF_OK;
+}
+
+JNIEXPORT jlong JNICALL gpac_jni_init(JNIEnv * env, jclass obj, jobject gpac_class_obj, jint width, jint height, jboolean has_display_cutout, jstring _url_to_open, jstring _ext_storage, jstring _app_data_dir)
+{
+	GF_Err e = GF_OK;
+	int success = 1;
+	jboolean isCopy;
+	const char *ext_storage = NULL, *app_data_dir=NULL, *url_to_open=NULL;
+
+	if (!javaVM) {
+		LOGE("NO JAVA VM FOUND !\n");
+		return (jlong) NULL;
+	}
+
+	if (_ext_storage)
+		ext_storage = env->GetStringUTFChars(_ext_storage, &isCopy);
+
+	if (_app_data_dir)
+		app_data_dir = env->GetStringUTFChars(_app_data_dir, &isCopy);
+
+	if (_url_to_open)
+		url_to_open = env->GetStringUTFChars(_url_to_open, &isCopy);
+
+
+	GPAC_JNI *gpac = (GPAC_JNI *) malloc(sizeof(GPAC_JNI));
+	if (!gpac) { success = 0; goto exit; }
+	memset(gpac, 0, sizeof(GPAC_JNI));
+
+	//keep a global ref to the java class instance
+	gpac->gpac_cbk_obj = env->NewGlobalRef(gpac_class_obj);
+
+	gpac->last_width = width;
+	gpac->last_height = height;
+	gpac->has_display_cutout = has_display_cutout ? GF_TRUE : GF_FALSE;
+	gf_sys_set_android_paths(app_data_dir, ext_storage);
+
+	e = gpac_init_gui(gpac);
+	if (e) { success = 0; goto exit; }
+
+	if (url_to_open) {
+		if (gpac->no_gui) {
+			GF_Event evt;
+			memset(&evt, 0, sizeof(GF_Event));
+			evt.type = GF_EVENT_NAVIGATE;
+			evt.navigate.to_url = url_to_open;
+			gf_sc_user_event(gpac->compositor, &evt);
+		} else {
+			gf_opts_set_key("temp", "gui_load_urls", url_to_open);
+		}
+	}
+
+	gpac->out_std0 = 0;
+	if (ext_storage) {
+		strcpy(gpac->out_std, ext_storage);
+		strcat(gpac->out_std, "/GPAC/");
+		if (!gf_dir_exists(gpac->out_std)) {
+			gpac->out_std0 = 0;
+		} else {
+			strcat(gpac->out_std, "/stderr_stdout.txt");
+		}
+	}
+
+exit:
+
+	if (app_data_dir)
+		env->ReleaseStringUTFChars(_app_data_dir, app_data_dir);
+	if (ext_storage)
+		env->ReleaseStringUTFChars(_ext_storage, ext_storage);
+	if (url_to_open)
+		env->ReleaseStringUTFChars(_url_to_open, url_to_open);
+
+	if (!success) {
+		if (!e) e = GF_OUT_OF_MEM;
+		if (gpac) {
+			show_message(gpac, "Cannot load GPAC", "Fatal Error", e);
+			if (gpac->fsess) gf_fs_del(gpac->fsess);
+			free(gpac);
+			gpac = NULL;
+		}
+		LOGE("Cannot load GPAC filter session");
+	}
+	return (jlong) gpac;
+}
+
+static void gpac_uninit(GPAC_JNI *gpac)
+{
+	if (!gpac->fsess)
+		return;
+
+	GF_FilterSession *fs = gpac->fsess;
+	gpac->fsess = NULL;
+	gf_fs_abort(fs, GF_FS_FLUSH_FAST);
+	gf_fs_del(fs);
+	gpac->compositor = NULL;
+
+	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("GPAC shutdown\n"));
+	if (gpac->log_file) gf_fclose(gpac->log_file);
+	gpac->log_file = NULL;
+	gf_log_set_callback(NULL, NULL);
+
+	gf_sys_close();
+}
+
+JNIEXPORT void JNICALL gpac_jni_uninit(JNIEnv * env, jobject obj)
+{
+	GET_GPAC_JNI( )
+
+	//final destruction, unload JSRT if any
+	gf_opts_set_key("temp", "static-jsrt", "false");
+
+	gpac_uninit(gpac);
+
+	//shutdown JNI
+	JavaEnvTh *th_env = gpac_jni_get_env(gpac);
+	if (th_env)
+		th_env->env->DeleteGlobalRef(gpac->gpac_cbk_obj);
+
+	if (gpac->log_buf) free(gpac->log_buf);
+	free(gpac);
+}
+
+
+static int start_logger(GPAC_JNI *gpac);
+static void stop_logger(GPAC_JNI *gpac);
+
+
+JNIEXPORT jint JNICALL gpac_jni_load_service(JNIEnv * env, jobject obj, jstring fileName)
+{
+	int ret_val = 0;
+	GET_GPAC_JNI(-1)
+
+	jboolean isCopy;
+	const char *service_url = env->GetStringUTFChars(fileName, &isCopy);
+
+	//url starting with "gpac " , run gpac command line
+	if (service_url
+		&& (!strnicmp(service_url, "gpac ", 5) || !strnicmp(service_url, "mp4box ", 7) )
+	) {
+		gpac_uninit(gpac);
+
+		u32 in_quote_s = 0;
+		u32 in_quote_d = 0;
+		u32 argc = 0;
+		u32 alen;
+		char *arg;
+		char **argv = NULL;
+		u32 start_pos = 0;
+		u32 i, len = (u32) strlen(service_url);
+		for (i=0; i<len; i++) {
+			char a_c = service_urli;
+			if (a_c != ' ') {
+				if (a_c=='\'') in_quote_s = in_quote_s ? 0 : 1;
+				if (a_c=='"') in_quote_d = in_quote_d ? 0 : 1;
+				if (!start_pos) {
+					start_pos = i+1;
+				}
+				continue;
+			}
+			if (in_quote_d || in_quote_d) continue;
+			if (!start_pos) continue;
+
+			alen = (u32) (i - (start_pos-1));
+			argv = (char **) realloc(argv, sizeof(char *)*(argc + 1));
+			arg = (char *) malloc(sizeof(char)*(alen + 1));
+			memcpy(arg, service_url+start_pos-1, alen);
+			argalen = 0;
+			argvargc = arg;
+			argc++;
+			start_pos=0;
+		}
+		if (start_pos) {
+			alen = (u32) (len - (start_pos-1));
+			argv = (char **) realloc(argv, sizeof(char *)*(argc + 1));
+			arg = (char *) malloc(sizeof(char)*(alen + 1));
+			memcpy(arg, service_url+start_pos-1, alen);
+			argalen = 0;
+			argvargc = arg;
+			argc++;
+		}
+
+		//always set log callback when running a filter chain
+		gf_log_set_callback(gpac, gpac_jni_on_log);
+
+		start_logger(gpac);
+
+		if (!strnicmp(service_url, "mp4box ", 7)) {
+			ret_val = mp4box_main(argc, argv);
+		} else {
+			ret_val = gpac_main(argc, argv);
+		}
+		stop_logger(gpac);
+
+		for (i=0; i<argc; i++) {
+			free(argvi);
+		}
+		free(argv);
+	} else {
+		Bool send_nav_event = GF_FALSE;
+		//not running in GUI mode, set it
+		if (!gpac->compositor) {
+			gpac_uninit(gpac);
+
+			gpac_init_gui(gpac);
+			if (gpac->no_gui) {
+				send_nav_event = GF_TRUE;
+			} else {
+				gf_opts_set_key("temp", "gui_load_urls", service_url);
+			}
+		}
+		//otherwise, already running in GUI mode, send navigate event
+		else {
+			send_nav_event = GF_TRUE;
+		}
+
+		if (send_nav_event && service_url) {
+			GF_Event evt;
+			memset(&evt, 0, sizeof(GF_Event));
+			evt.type = GF_EVENT_NAVIGATE;
+			evt.navigate.to_url = service_url;
+			gf_sc_user_event(gpac->compositor, &evt);
+		}
+	}
+
+	if (service_url)
+		env->ReleaseStringUTFChars(fileName, service_url);
+
+	return ret_val;
+}
+
+JNIEXPORT void JNICALL gpac_jni_render_frame(JNIEnv * env, jobject obj)
+{
+	GET_GPAC_JNI( )
+
+	//force frame draw type
+	gf_sc_invalidate_next_frame(gpac->compositor);
+	while (1) {
+		gf_fs_run(gpac->fsess);
+		if (gf_sc_frame_was_produced(gpac->compositor)) break;
+	}
+}
+
+JNIEXPORT void JNICALL gpac_jni_set_size(JNIEnv * env, jobject obj, jint width, jint height, jint orientation)
+{
+	GET_GPAC_JNI( )
+
+	gpac->last_width = (u32) width;
+	gpac->last_height = (u32) height;
+
+	GF_Event evt;
+	memset(&evt, 0, sizeof(GF_Event));
+	evt.size.type = GF_EVENT_SIZE;
+	evt.size.width = (u32) width;
+	evt.size.height = (u32) height;
+	evt.size.orientation = (GF_DisplayOrientationType) orientation;
+	gf_sc_user_event(gpac->compositor, &evt);
+}
+
+JNIEXPORT void JNICALL gpac_jni_eventmousedown(JNIEnv * env, jobject obj, jfloat x, jfloat y)
+{
+	GET_GPAC_JNI( )
+
+	GF_Event evt;
+	evt.type = GF_EVENT_MOUSEDOWN;
+	evt.mouse.button = GF_MOUSE_LEFT;
+	evt.mouse.x = x;
+	evt.mouse.y = y;
+
+	gf_sc_user_event(gpac->compositor, &evt);
+}
+
+JNIEXPORT void JNICALL gpac_jni_eventmouseup(JNIEnv * env, jobject obj, jfloat x, jfloat y)
+{
+	GET_GPAC_JNI( )
+
+	GF_Event evt;
+	evt.type = GF_EVENT_MOUSEUP;
+	evt.mouse.button = GF_MOUSE_LEFT;
+	evt.mouse.x = x;
+	evt.mouse.y = y;
+
+	gf_sc_user_event(gpac->compositor, &evt);
+}
+
+JNIEXPORT void JNICALL gpac_jni_eventmousemove(JNIEnv * env, jobject obj, jfloat x, jfloat y)
+{
+	GET_GPAC_JNI( )
+
+	GF_Event evt;
+	evt.type = GF_EVENT_MOUSEMOVE;
+	evt.mouse.button = GF_MOUSE_LEFT;
+	evt.mouse.x = x;
+	evt.mouse.y = y;
+
+	gf_sc_user_event(gpac->compositor, &evt);
+}
+
+JNIEXPORT void JNICALL gpac_jni_eventkeypress(JNIEnv * env, jobject obj, jint keycode, jint rawkeycode, jint up, jint flag, jint unicode)
+{
+	GET_GPAC_JNI( )
+
+	GF_Event evt;
+	memset(&evt, 0, sizeof(GF_Event));
+	if (up == 0) evt.type = GF_EVENT_KEYUP;
+	else evt.type = GF_EVENT_KEYDOWN;
+
+	evt.key.flags = 0;
+	evt.key.hw_code = rawkeycode;
+
+	translate_key_to_gpac(keycode, &evt.key);
+	gf_sc_user_event(gpac->compositor, &evt);
+
+	if (evt.type == GF_EVENT_KEYUP && unicode) {
+		memset(&evt, 0, sizeof(GF_Event));
+		evt.type = GF_EVENT_TEXTINPUT;
+		evt.character.unicode_char = unicode;
+		gf_sc_user_event(gpac->compositor, &evt);
+	}
+}
+
+JNIEXPORT void JNICALL gpac_jni_eventorientationchange(JNIEnv * env, jobject obj, jfloat x, jfloat y, jfloat z)
+{
+	GET_GPAC_JNI( )
+
+	GF_Event evt;
+	evt.type = GF_EVENT_SENSOR_ORIENTATION;
+	evt.sensor.x = x;
+	evt.sensor.y = y;
+	evt.sensor.z = z;
+	evt.sensor.w = 0;
+
+	gf_sc_user_event(gpac->compositor, &evt);
+}
+
+
+JNIEXPORT void JNICALL gpac_jni_eventlocationchange(JNIEnv * env, jobject obj, jdouble longitude, jdouble latitude, jdouble altitude, jfloat bearing, jfloat accuracy)
+{
+	GET_GPAC_JNI( )
+
+	GF_Event evt;
+	evt.type = GF_EVENT_SENSOR_GPS;
+	evt.gps.longitude = longitude;
+	evt.gps.latitude = latitude;
+	evt.gps.altitude = altitude;
+	evt.gps.bearing = bearing;
+	evt.gps.accuracy = accuracy;
+	gf_sc_user_event(gpac->compositor, &evt);
+}
+
+JNIEXPORT jstring JNICALL gpac_jni_error_to_string(JNIEnv * env, jobject obj, jint code)
+{
+	const char *str = gf_error_to_string((GF_Err) (s32) code);
+
+	jstring result = env->NewStringUTF(str);
+ return result;
+}
+
+JNIEXPORT void JNICALL gpac_jni_abort_session(JNIEnv * env, jobject obj)
+{
+	gpac_abort();
+}
+
+JNIEXPORT void JNICALL gpac_jni_reset_config(JNIEnv * env, jobject obj)
+{
+	gf_opts_set_key("core", "reset", "yes");
+}
+
+//from https://codelab.wordpress.com/2014/11/03/how-to-use-standard-output-streams-for-logging-in-android-apps/
+#include <unistd.h>
+static int pipe_fd2;
+static int run_logger = 0;
+static FILE *f_std_err_out=NULL;
+
+static void *logger_thread(void*_param)
+{
+	GPAC_JNI *gpac = (GPAC_JNI *)_param;
+ ssize_t read_size;
+ char buf1025;
+ while ((read_size = read(pipe_fd0, buf, 1023)) > 0) {
+		if (!run_logger) break;
+
+ bufread_size = 0;
+		show_message(gpac, buf, NULL, GF_OK);
+		if (f_std_err_out)
+			fwrite(buf, 1, read_size, f_std_err_out);
+ }
+ run_logger = 0;
+ return 0;
+}
+
+static pthread_t thr;
+
+static int start_logger(GPAC_JNI *gpac)
+{
+	char szPathGF_MAX_PATH;
+	//reopen stderr and stdout
+	if (gpac->out_std0) {
+		f_std_err_out = fopen(gpac->out_std, "w");
+	}
+
+ /* make stdout and stderr line-buffered*/
+ setvbuf(stdout, 0, _IOLBF, 0);
+ setvbuf(stderr, 0, _IOLBF, 0);
+
+ /* create the pipe and redirect stdout and stderr */
+ pipe(pipe_fd);
+ dup2(pipe_fd1, 1);
+ dup2(pipe_fd1, 2);
+
+	run_logger = 1;
+ if (pthread_create(&thr, 0, logger_thread, gpac) == -1) {
+		run_logger = 0;
+ return -1;
+	}
+ pthread_detach(thr);
+ return 0;
+}
+static void stop_logger(GPAC_JNI *gpac)
+{
+	fflush(stderr);
+	fflush(stdout);
+	//give logger 100ms to flush everything
+	gf_sleep(100);
+	close(pipe_fd0);
+	close(pipe_fd1);
+
+	//wait for 1s for logger thread to exit
+	u32 nb_retry = 9;
+	while (run_logger && nb_retry) {
+		gf_sleep(100);
+		nb_retry--;
+	}
+	run_logger = 0;
+	if (f_std_err_out) {
+		fclose(f_std_err_out);
+		f_std_err_out = NULL;
+	}
+}
+
+static void gpac_jni_on_log(void *cbk, GF_LOG_Level ll, GF_LOG_Tool lm, const char *fmt, va_list list)
+{
+	GPAC_JNI *gpac = (GPAC_JNI *) cbk;
+
+	if (!gpac || (gpac->do_log && !gpac->log_file)) {
+		char szTag50;
+		int level;
+		if (ll == GF_LOG_ERROR) level = ANDROID_LOG_ERROR;
+		else if (ll == GF_LOG_WARNING) level = ANDROID_LOG_WARN;
+		else if (ll == GF_LOG_INFO) level = ANDROID_LOG_INFO;
+		else level = ANDROID_LOG_DEBUG;
+
+		sprintf(szTag, "GPAC@%s", gf_log_tool_name(lm) );
+		__android_log_vprint(level, szTag, fmt, list);
+		return;
+	}
+
+	if (!gpac->compositor) {
+		va_list vlist_tmp;
+
+		va_copy(vlist_tmp, list);
+		u32 len = (u32) vsnprintf(NULL, 0, fmt, vlist_tmp);
+		va_end(vlist_tmp);
+		if (gpac->log_buf_size < len+2) {
+			gpac->log_buf_size = len+2;
+			gpac->log_buf = (char *) realloc(gpac->log_buf, gpac->log_buf_size);
+		}
+
+		va_copy(vlist_tmp, list);
+		vsprintf(gpac->log_buf, fmt, vlist_tmp);
+		va_end(vlist_tmp);
+		show_message(gpac, gpac->log_buf, NULL, GF_OK);
+	}
+	if (!gpac->do_log) return;
+
+
+	vfprintf(gpac->log_file, fmt, list);
+	fflush(gpac->log_file);
+}
+
+static void on_progress_cbk(const void *usr, const char *title, u64 done, u64 total)
+{
+	if (!usr) return;
+	JavaEnvTh *env = gpac_jni_get_env( (GPAC_JNI *) usr );
+	if (!env || !env->cbk_onProgress) return;
+
+	env->env->PushLocalFrame(1);
+	jstring js = env->env->NewStringUTF(title);
+	env->env->CallVoidMethod(env->cbk_obj, env->cbk_onProgress, js, done, total);
+	env->env->PopLocalFrame(NULL);
+}
+
+static Bool gpac_jni_event_proc(void *cbk, GF_Event *evt)
+{
+	if (!cbk) return GF_FALSE;
+	GPAC_JNI *gpac = (GPAC_JNI *) cbk;
+
+	switch (evt->type) {
+	case GF_EVENT_MESSAGE:
+		GF_LOG(evt->message.error ? GF_LOG_ERROR : GF_LOG_INFO, GF_LOG_APP, ("%s: %s",
+				evt->message.message ? evt->message.message : "Error",
+				gf_error_to_string(evt->message.error)
+		));
+		break;
+	case GF_EVENT_CONNECT:
+		if (evt->connect.is_connected)
+			show_message(gpac, "Connected", "Connected to scene", GF_OK);
+		else
+			show_message(gpac, "Disconnected", "Disconnected from scene.", GF_OK);
+		break;
+	case GF_EVENT_PROGRESS:
+		if (evt->progress.progress_type==0)
+			on_progress_cbk(gpac, "Buffering", evt->progress.done, evt->progress.total);
+		else if (evt->progress.progress_type==1)
+			on_progress_cbk(gpac, "Downloading", evt->progress.done, evt->progress.total);
+		else if (evt->progress.progress_type==2)
+			on_progress_cbk(gpac, "Import", evt->progress.done, evt->progress.total);
+		break;
+	case GF_EVENT_TEXT_EDITING_START:
+	case GF_EVENT_TEXT_EDITING_END:
+	{
+		JavaEnvTh * env = gpac_jni_get_env(gpac);
+		if (!env || !env->cbk_showKeyboard) return GF_FALSE;
+		env->env->CallVoidMethod(env->cbk_obj, env->cbk_showKeyboard, GF_EVENT_TEXT_EDITING_START == evt->type);
+	}
+		break;
+	case GF_EVENT_EOS:
+		break;
+	case GF_EVENT_NAVIGATE:
+		if (gf_sc_is_supported_url(gpac->compositor, evt->navigate.to_url, GF_TRUE)) {
+			gf_sc_navigate_to(gpac->compositor, evt->navigate.to_url);
+		}
+		break;
+	case GF_EVENT_SENSOR_REQUEST:
+		if ((evt->activate_sensor.sensor_type == GF_EVENT_SENSOR_ORIENTATION)
+			|| (evt->activate_sensor.sensor_type == GF_EVENT_SENSOR_GPS)
+		) {
+			JavaEnvTh * env = gpac_jni_get_env(gpac);
+			if (!env || !env->cbk_sensorSwitch) return GF_FALSE;
+
+			env->env->CallVoidMethod(env->cbk_obj, env->cbk_sensorSwitch, (evt->activate_sensor.sensor_type == GF_EVENT_SENSOR_GPS) ? 1 : 0, evt->activate_sensor.activate);
+			return GF_TRUE;
+		}
+		break;
+	case GF_EVENT_SET_ORIENTATION:
+		{
+			JavaEnvTh * env = gpac_jni_get_env(gpac);
+			if (!env || !env->cbk_sensorSwitch) return GF_FALSE;
+
+			env->env->CallVoidMethod(env->cbk_obj, env->cbk_setOrientation, evt->size.orientation);
+			return GF_TRUE;
+		}
+		break;
+	//ignore all the rest
+	default:
+		break;
+	}
+	return GF_FALSE;
+}
+
+
+/**
+ * This method is called when a pthread is destroyed, so we can delete the JNI env
+ */
+static void jni_destroy_env_func(void * env)
+{
+	JavaEnvTh * jniEnv = (JavaEnvTh *) env;
+	if (jniEnv) {
+		memset(jniEnv, 0, sizeof(JavaEnvTh));
+		gf_free(jniEnv);
+	}
+	pthread_setspecific(jni_thread_env_key, NULL);
+	if (javaVM)
+		javaVM->DetachCurrentThread();
+}
+
+static int jniRegisterNativeMethods(JNIEnv* env, const char* className, const JNINativeMethod* gMethods, int numMethods)
+{
+	int res;
+	jclass clazz;
+	clazz = env->FindClass(className);
+	if (clazz == NULL) {
+		LOGE("Native registration unable to find class '%s'\n", className);
+		return -1;
+	}
+	res = env->RegisterNatives(clazz, gMethods, numMethods);
+	if (res < 0) {
+		LOGE("RegisterNatives failed for '%s'\n", className);
+		return res;
+	}
+	return 0;
+}
+
+/* name, signature, funcPtr */
+static JNINativeMethod sMethods = {
+	{	"init", "(Lio/gpac/gpac/GPAC;IIZLjava/lang/String;Ljava/lang/String;Ljava/lang/String;)J", (void*)&gpac_jni_init},
+	{	"uninit", "()V", (void*)gpac_jni_uninit},
+	{	"render_frame", "()V", (void*)gpac_jni_render_frame},
+	{	"set_size", "(III)V", (void*)gpac_jni_set_size},
+	{	"eventkeypress", "(IIIII)V", (void*)gpac_jni_eventkeypress},
+	{	"eventmousedown", "(FF)V", (void*)gpac_jni_eventmousedown},
+	{	"eventmouseup", "(FF)V", (void*)gpac_jni_eventmouseup},
+	{	"eventmousemove", "(FF)V", (void*)gpac_jni_eventmousemove},
+	{	"eventorientationchange", "(FFF)V", (void*)gpac_jni_eventorientationchange},
+	{	"eventlocationchange", "(DDDFF)V", (void*)gpac_jni_eventlocationchange},
+	{	"load_service", "(Ljava/lang/String;)I", (void*)gpac_jni_load_service},
+	{	"error_to_string", "(I)Ljava/lang/String;", (void*)gpac_jni_error_to_string},
+	{	"abort_session", "()V", (void*)gpac_jni_abort_session},
+	{	"reset_config", "()V", (void*)gpac_jni_reset_config},
+	NULL
+};
+
+
+jint JNI_OnUnLoad(JavaVM* vm, void* reserved)
+{
+	if (pthread_key_delete(jni_thread_env_key)) {
+		LOGW("Failed to delete key jni_thread_env_key jni_thread_env_key=%d\n", jni_thread_env_key);
+	}
+	javaVM = NULL;
+	jni_thread_env_key = (int) NULL;
+	return 0;
+}
+
+#define NUM_JNI_VERSIONS 4
+
+jint JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+	int res;
+	int jniV;
+	int allowedVersionsNUM_JNI_VERSIONS;
+	const char * className = "io/gpac/gpac/GPAC";
+	allowedVersions0 = JNI_VERSION_1_6;
+	allowedVersions1 = JNI_VERSION_1_4;
+	allowedVersions2 = JNI_VERSION_1_2;
+	allowedVersions3 = JNI_VERSION_1_1;
+	JNIEnv * env = NULL;
+	if (!vm)
+		return -1;
+	for (int i = 0 ; i < NUM_JNI_VERSIONS; i++) {
+		jniV = allowedVersionsi;
+		if (vm->GetEnv((void**)(&env), jniV) == JNI_OK) {
+			break;
+		} else {
+			if (i == NUM_JNI_VERSIONS - 1) {
+				LOGW("Failed to find any supported JNI VERSION of the %d proposed.", NUM_JNI_VERSIONS);
+				return -1;
+			}
+		}
+
+	}
+	if (! env) {
+		LOGW("Failed to find any supported JNI VERSION");
+		return -1;
+	}
+	javaVM = vm;
+
+	res = jniRegisterNativeMethods(env, className, sMethods, (sizeof(sMethods) - 1)/sizeof(JNINativeMethod));
+	if (res < 0) {
+		LOGE("Failed to register native methods, result was = %d, try to continue anyway...\n", res);
+		/*return -1;*/
+	}
+
+	int ret = pthread_key_create(&jni_thread_env_key, &jni_destroy_env_func);
+	if (ret) {
+		LOGE("Failed to register jni_thread_env_key jni_thread_env_key=%d\n", jni_thread_env_key);
+	}
+	return jniV;
+}
+
+//these two are used by modumles - define them when using static module build
+#ifdef GPAC_STATIC_MODULES
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JavaVM* GetJavaVM()
+{
+	return javaVM;
+}
+
+JNIEnv* GetEnv()
+{
+	JNIEnv* env = 0;
+	if (javaVM) javaVM->GetEnv((void**)(&env), JNI_VERSION_1_2);
+	return env;
+}
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+// keyboard code
+#define ANDROID_KEYCODE_0	7
+#define ANDROID_KEYCODE_1	8
+#define ANDROID_KEYCODE_2	9
+#define ANDROID_KEYCODE_3	10
+#define ANDROID_KEYCODE_4	11
+#define ANDROID_KEYCODE_5	12
+#define ANDROID_KEYCODE_6	13
+#define ANDROID_KEYCODE_7	14
+#define ANDROID_KEYCODE_8	15
+#define ANDROID_KEYCODE_9	16
+#define ANDROID_KEYCODE_A	29
+#define ANDROID_KEYCODE_B	30
+#define ANDROID_KEYCODE_C	31
+#define ANDROID_KEYCODE_D	32
+#define ANDROID_KEYCODE_E	33
+#define ANDROID_KEYCODE_F	34
+#define ANDROID_KEYCODE_G	35
+#define ANDROID_KEYCODE_H	36
+#define ANDROID_KEYCODE_I	37
+#define ANDROID_KEYCODE_J	38
+#define ANDROID_KEYCODE_K	39
+#define ANDROID_KEYCODE_L	40
+#define ANDROID_KEYCODE_M	41
+#define ANDROID_KEYCODE_N	42
+#define ANDROID_KEYCODE_O	43
+#define ANDROID_KEYCODE_P	44
+#define ANDROID_KEYCODE_Q	45
+#define ANDROID_KEYCODE_R	46
+#define ANDROID_KEYCODE_S	47
+#define ANDROID_KEYCODE_T	48
+#define ANDROID_KEYCODE_U	49
+#define ANDROID_KEYCODE_V	50
+#define ANDROID_KEYCODE_W	51
+#define ANDROID_KEYCODE_X	52
+#define ANDROID_KEYCODE_Y	53
+#define ANDROID_KEYCODE_Z	54
+#define ANDROID_KEYCODE_ALT_LEFT	57
+#define ANDROID_KEYCODE_ALT_RIGHT	58
+#define ANDROID_KEYCODE_AT		77
+#define ANDROID_KEYCODE_BACK		4
+#define ANDROID_KEYCODE_BACKSLASH	73
+#define ANDROID_KEYCODE_CALL		5
+#define ANDROID_KEYCODE_CAMERA		27
+#define ANDROID_KEYCODE_CLEAR		28
+#define ANDROID_KEYCODE_COMMA		55
+#define ANDROID_KEYCODE_DEL		67
+#define ANDROID_KEYCODE_DPAD_CENTER	23
+#define ANDROID_KEYCODE_DPAD_DOWN	20
+#define ANDROID_KEYCODE_DPAD_LEFT	21
+#define ANDROID_KEYCODE_DPAD_RIGHT	22
+#define ANDROID_KEYCODE_DPAD_UP		19
+#define ANDROID_KEYCODE_ENDCALL		6
+#define ANDROID_KEYCODE_ENTER		66
+#define ANDROID_KEYCODE_ENVELOPE	65
+#define ANDROID_KEYCODE_EQUALS		70
+#define ANDROID_KEYCODE_EXPLORER	64
+#define ANDROID_KEYCODE_FOCUS		80
+#define ANDROID_KEYCODE_GRAVE		68
+#define ANDROID_KEYCODE_HEADSETHOOK	79
+#define ANDROID_KEYCODE_HOME		3
+#define ANDROID_KEYCODE_LEFT_BRACKET	71
+#define ANDROID_KEYCODE_MEDIA_FAST_FORWARD	90
+#define ANDROID_KEYCODE_MEDIA_NEXT	87
+#define ANDROID_KEYCODE_MEDIA_PLAY_PAUSE	85
+#define ANDROID_KEYCODE_MEDIA_PREVIOUS	88
+#define ANDROID_KEYCODE_MEDIA_REWIND	89
+#define ANDROID_KEYCODE_MEDIA_STOP	86
+#define ANDROID_KEYCODE_MENU		82
+#define ANDROID_KEYCODE_MINUS		69
+#define ANDROID_KEYCODE_MUTE		91
+#define ANDROID_KEYCODE_NUM		78
+#define ANDROID_KEYCODE_PLUS		81
+#define ANDROID_KEYCODE_POWER		26
+#define ANDROID_KEYCODE_RIGHT_BRACKET	72
+#define ANDROID_KEYCODE_SEARCH		84
+#define ANDROID_KEYCODE_SEMICOLON	74
+#define ANDROID_KEYCODE_SHIFT_LEFT	59
+#define ANDROID_KEYCODE_SHIFT_RIGHT	60
+#define ANDROID_KEYCODE_SLASH		76
+#define ANDROID_KEYCODE_SOFT_LEFT	1
+#define ANDROID_KEYCODE_SOFT_RIGHT	2
+#define ANDROID_KEYCODE_SPACE		62
+#define ANDROID_KEYCODE_STAR		17
+#define ANDROID_KEYCODE_SYM		63
+#define ANDROID_KEYCODE_TAB		61
+
+
+static void translate_key_to_gpac(int keycode, GF_EventKey *evt)
+{
+	evt->flags = 0;
+	switch (keycode) {
+	case ANDROID_KEYCODE_BACK:
+		evt->key_code = GF_KEY_BACKSPACE;
+		evt->hw_code = 8;
+		break;
+	case ANDROID_KEYCODE_TAB:
+		evt->key_code = GF_KEY_TAB;
+		evt->hw_code = 9;
+		break;
+	case ANDROID_KEYCODE_CLEAR:
+		evt->key_code = GF_KEY_CLEAR;
+		break;
+	case ANDROID_KEYCODE_DPAD_CENTER:
+	case ANDROID_KEYCODE_ENTER:
+		evt->key_code = GF_KEY_ENTER;
+		evt->hw_code = 13;
+		break;
+	case ANDROID_KEYCODE_SHIFT_LEFT:
+		evt->key_code = GF_KEY_SHIFT;
+		break;
+	case ANDROID_KEYCODE_SHIFT_RIGHT:
+		evt->key_code = GF_KEY_SHIFT;
+		break;
+	case ANDROID_KEYCODE_ALT_LEFT:
+		evt->key_code = GF_KEY_ALT;
+		break;
+	case ANDROID_KEYCODE_ALT_RIGHT:
+		evt->key_code = GF_KEY_ALT;
+		break;
+	case ANDROID_KEYCODE_SPACE:
+		evt->key_code = GF_KEY_SPACE;
+		evt->hw_code = 32;
+		break;
+	case ANDROID_KEYCODE_HOME:
+		evt->key_code = GF_KEY_HOME;
+		break;
+	case ANDROID_KEYCODE_DPAD_LEFT:
+		evt->key_code = GF_KEY_LEFT;
+		break;
+	case ANDROID_KEYCODE_DPAD_UP:
+		evt->key_code = GF_KEY_UP;
+		break;
+	case ANDROID_KEYCODE_DPAD_RIGHT:
+		evt->key_code = GF_KEY_RIGHT;
+		break;
+	case ANDROID_KEYCODE_DPAD_DOWN:
+		evt->key_code = GF_KEY_DOWN;
+		break;
+	case ANDROID_KEYCODE_DEL:
+		evt->key_code = GF_KEY_BACKSPACE;
+		evt->hw_code = 8;
+		break;
+	case ANDROID_KEYCODE_0:
+		evt->key_code = GF_KEY_0;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_1:
+		evt->key_code = GF_KEY_1;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_2:
+		evt->key_code = GF_KEY_2;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_3:
+		evt->key_code = GF_KEY_3;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_4:
+		evt->key_code = GF_KEY_4;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_5:
+		evt->key_code = GF_KEY_5;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_6:
+		evt->key_code = GF_KEY_6;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_7:
+		evt->key_code = GF_KEY_7;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_8:
+		evt->key_code = GF_KEY_8;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	case ANDROID_KEYCODE_9:
+		evt->key_code = GF_KEY_9;
+		evt->flags = GF_KEY_EXT_NUMPAD;
+		break;
+	/*thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
+	/* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
+	default:
+		if ((keycode>=ANDROID_KEYCODE_A) && (keycode<=ANDROID_KEYCODE_Z)) {
+			evt->key_code = GF_KEY_A + keycode - ANDROID_KEYCODE_A;
+		} else {
+			evt->key_code = GF_KEY_UNIDENTIFIED;
+		}
+		break;
+	}
+}

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-hdpi Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-hdpi/icon.png Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-ldpi Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-ldpi/icon.png Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/ic_audio.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/ic_compressed.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/ic_error.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/ic_file.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/ic_folder.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/ic_image.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/ic_video.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable-mdpi/icon.png Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/drawable/ic_back.xml Changed

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/layout Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/layout/activity_file_chooser.xml Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/layout/activity_url_authenticate.xml Added

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+
+ <LinearLayout
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:orientation="vertical">
+
+ <TableLayout
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content">
+
+ <TableRow
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:baselineAligned="true">
+
+ <TextView
+ android:id="@+id/authURL"
+ android:layout_width="wrap_content"
+ android:layout_height="fill_parent"
+ android:layout_gravity="right"
+ android:text="URL" />
+ </TableRow>
+
+ <TableRow
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:baselineAligned="true">
+
+ <TextView
+ android:layout_width="wrap_content"
+ android:layout_height="fill_parent"
+ android:layout_gravity="right"
+ android:text="@string/usernameLabel" />
+
+ <EditText
+ android:id="@+id/userName"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_weight="2"
+ android:gravity="fill_horizontal|right"
+ android:hint="@string/usernameHint"
+ android:inputType="textUri"
+ android:text="" />
+ </TableRow>
+
+ <TableRow
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:gravity="fill_horizontal">
+
+ <TextView
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="right"
+ android:layout_weight="0"
+ android:baselineAligned="true"
+ android:text="@string/passwordLabel" />
+
+ <EditText
+ android:id="@+id/password"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:layout_weight="2"
+ android:gravity="fill_horizontal|right"
+ android:hint="@string/passwordHint"
+ android:inputType="textPassword"
+ android:text="" />
+ </TableRow>
+
+ <TableRow
+ android:id="@+id/tableRow2"
+ android:layout_height="wrap_content"
+ android:layout_gravity="fill_horizontal"
+ android:gravity="fill_horizontal">
+
+				<Button
+					android:id="@+id/cancel"
+					android:layout_width="wrap_content"
+					android:layout_height="wrap_content"
+					android:text="Cancel" />
+
+				<Button
+					android:id="@+id/ok"
+					android:layout_width="wrap_content"
+					android:layout_height="wrap_content"
+					android:text="OK" />
+
+ </TableRow>
+ </TableLayout>
+
+ </LinearLayout>
+
+
+</FrameLayout>

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/layout/fragment_file_chooser.xml Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/layout/list_item_file_chooser.xml Added

@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:app="http://schemas.android.com/apk/res-auto"
+ android:id="@+id/linearLayout"
+ android:orientation="vertical"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:weightSum="1"
+ android:focusable="true"
+ android:clickable="true"
+ >
+
+ <android.support.v7.widget.CardView
+ android:id="@+id/cardView"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:padding="5dp"
+ android:layout_margin="3dp"
+ app:cardBackgroundColor="#777777"
+ >
+
+ <LinearLayout
+ android:orientation="horizontal"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:padding="2dp"
+ >
+
+ <ImageView
+ android:id="@+id/icon"
+ android:layout_width="66dp"
+ android:layout_height="66dp"
+ />
+
+ <LinearLayout
+ android:orientation="vertical"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:weightSum="1">
+
+ <LinearLayout
+ android:orientation="vertical"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:weightSum="1">
+
+ <TextView
+ android:layout_width="match_parent"
+ android:layout_height="30dp"
+ android:textAppearance="?android:attr/textAppearanceLarge"
+ android:text="title"
+ android:id="@+id/title"
+ android:layout_marginLeft="10dp"
+ android:textSize="15dp"
+ android:textStyle="bold"
+ android:maxLines="2"
+ android:layout_weight="0.79"
+ android:gravity="center_vertical" />
+
+ <LinearLayout
+ android:orientation="horizontal"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:weightSum="1"
+ android:layout_marginLeft="10dp">
+
+ <TextView
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:textAppearance="?android:attr/textAppearanceSmall"
+ android:text="lastModified"
+ android:id="@+id/lastModified"
+ android:textSize="10dp"
+ android:layout_weight="0.23"
+ android:maxLines="1" />
+
+ </LinearLayout>
+ </LinearLayout>
+ </LinearLayout>
+
+ </LinearLayout>
+
+ </android.support.v7.widget.CardView>
+
+</LinearLayout>
\ No newline at end of file

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/layout/main.xml Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/menu Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/menu/main_menu.xml Added

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+
+ <item
+ android:id="@+id/open_file"
+ android:checkable="false"
+ android:enabled="true"
+ android:title="@string/open_file"
+ android:visible="true" />
+
+ <item
+ android:id="@+id/open_url"
+ android:checkable="false"
+ android:enabled="true"
+ android:title="@string/open_url"
+ android:visible="true" />
+
+	<item
+		android:id="@+id/runGPAC"
+		android:checkable="false"
+		android:enabled="true"
+		android:title="@string/runGPAC"
+		android:visible="true" />
+
+	<item
+		android:id="@+id/reloadLast"
+		android:checkable="false"
+		android:enabled="true"
+		android:title="@string/reloadLast"
+		android:visible="true" />
+
+	<item
+		android:id="@+id/runMP4Box"
+		android:checkable="false"
+		android:enabled="true"
+		android:title="@string/runMP4Box"
+		android:visible="true" />
+
+	<item
+		android:id="@+id/resetConfig"
+		android:checkable="false"
+		android:enabled="true"
+		android:title="@string/resetConfig"
+		android:visible="true" />
+
+	
+
+
+	<item
+		android:id="@+id/quit"
+		android:checkable="false"
+		android:enabled="true"
+		android:title="@string/quit"
+		android:visible="true" />
+</menu>

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/values Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/values/arrays.xml Added

gpac-2.2.0.tar.gz/applications/gpac_android/src/main/res/values/strings.xml Added

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+ <string name="ok">OK</string>
+ <string name="cancel">Cancel</string>
+ <string name="open_file">Open file</string>
+ <string name="open_url">Open URL</string>
+ <string name="open_url_ok">Load</string>
+ <string name="open_cmd_ok">Run</string>
+ <string name="quit">Exit</string>
+ <string name="really_quit">Are you sure that you want to quit ?</string>
+ <string name="yes">Yes</string>
+ <string name="no">No</string>
+ <string name="app_name">GPAC</string>
+ <string name="copying_native_libs">Copying module %1$s to %2$s…</string>
+ <string name="displayPopupFormat">%1$s\n%2$s</string>
+ <string name="reloadLast">Reload last URL</string>
+ <string name="reloadSession">Reload last command</string>
+ <string name="runGPAC">Run gpac</string>
+ <string name="abortSession">Abort Session</string>
+ <string name="runMP4Box">Run MP4Box</string>
+ <string name="selectURL">Enter URL</string>
+ <string name="selectGPAC">Type gpac command line</string>
+ <string name="selectMP4Box">Type MP4Box command line</string>
+ <string name="selectFile">Select a file to open</string>
+ <string name="usernameLabel">Username: </string>
+ <string name="usernameHint">username</string>
+ <string name="passwordLabel">Password: </string>
+ <string name="passwordHint">password</string>
+ <string name="directory">Directory</string>
+ <string name="gpacLoading">GPAC is loading…</string>
+ <string name="requestPermissionStorage">You need to give permission to access External Storage</string>
+ 
+ <string name="authName">Authentication Required</string>
+ <string name="resetConfig">Reset GPAC config</string>
+
+
+</resources>

gpac-2.0.0.tar.gz/applications/mp4box/Makefile -> gpac-2.2.0.tar.gz/applications/mp4box/Makefile Changed

@@ -21,11 +21,17 @@
 LINKFLAGS+= -Wl,-rpath,'$$ORIGIN' -Wl,-rpath-link,../../bin/gcc
 endif
 
-ifeq ($(STATICBUILD),yes)
+ifeq ($(STATIC_BUILD),yes)
 ##include static modules and other deps for libgpac
 include ../../static.mak
-LINKFLAGS+=$(shell pkg-config ../../gpac.pc --libs --static | sed 's/-lgpac //'  )
+ifneq ($(PKG_CONFIG), no)
+LINKFLAGS+=$(shell $(PKG_CONFIG) ../../gpac.pc --libs --static | sed 's/-lgpac //'  )
+else
+LINKFLAGS+= -lgpac_static
+endif
 LINKFLAGS+= $(GPAC_SH_FLAGS)
+LINKFLAGS+=$(zlib_ldflags) $(opensvc_ldflags) $(ssl_ldflags) $(jpeg_ldflags) $(openjpeg_ldflags) $(png_ldflags) $(mad_ldflags) $(a52_ldflags) $(xvid_ldflags) $(faad_ldflags)
+LINKFLAGS+=$(ffmpeg_ldflags) $(ogg_ldflags) $(vorbis_ldflags) $(theora_ldflags) $(nghttp2_ldflags) $(vtb_ldflags)
 LINKFLAGS+=$(EXTRALIBS)
 else
 LINKFLAGS+=-lgpac
@@ -53,7 +59,7 @@
 endif
 
 #common obj
-OBJS=main.o filedump.o fileimport.o
+OBJS=mp4box.o filedump.o fileimport.o
 ifeq ($(DISABLE_STREAMING),no)
 OBJS+=live.o
 endif

gpac-2.0.0.tar.gz/applications/mp4box/filedump.c -> gpac-2.2.0.tar.gz/applications/mp4box/filedump.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / mp4box application
@@ -58,7 +58,9 @@
 #include <gpac/download.h>
 #include <gpac/mpd.h>
 
+#ifndef GPAC_DISABLE_SWF_IMPORT
 extern u32 swf_flags;
+#endif
 extern Float swf_flatten_angle;
 extern GF_FileType get_file_type_by_ext(char *inName);
 extern u32 fs_dump_flags;
@@ -72,7 +74,7 @@
 {
 	va_list vl;
 	va_start(vl, fmt);
-	vfprintf(stderr, fmt, vlist);
+	vfprintf(stderr, fmt, vl);
 	fflush(stderr);
 	va_end(vl);
 }
@@ -127,10 +129,12 @@
 	} else {
 		t = stdout;
 	}
-	gf_fwrite(tag, tag_len & 0x7FFFFFFF, t);
+	tag_len &= 0x7FFFFFFF;
+	if (gf_fwrite(tag, tag_len, t) != tag_len)
+		e = GF_IO_ERR;
 
 	if (inName) gf_fclose(t);
-	return GF_OK;
+	return e;
 }
 
 #ifndef GPAC_DISABLE_SCENE_DUMP
@@ -150,7 +154,9 @@
 	memset(&load, 0, sizeof(GF_SceneLoader));
 	load.fileName = file;
 	load.ctx = ctx;
+#ifndef GPAC_DISABLE_SWF_IMPORT
 	load.swf_import_flags = swf_flags;
+#endif
 	if (dump_mode == GF_SM_DUMP_SVG) {
 		load.swf_import_flags |= GF_SM_SWF_USE_SVG;
 		load.svgOutFile = inName;
@@ -811,7 +817,9 @@
 	fprintf(stdout, "<Boxes>\n");
 	//index 0 is our internal unknown box handler
 	for (i=1; i<count; i++) {
+#ifndef GPAC_DISABLE_ISOM_DUMP
 		gf_isom_dump_supported_box(i, stdout);
+#endif
 if (do_cov) {
 			u32 btype = gf_isom_get_supported_box_type(i);
 GF_Box *b=gf_isom_box_new(btype);
@@ -824,6 +832,27 @@
 }
 	}
 	fprintf(stdout, "</Boxes>\n");
+	if (do_cov) {
+		i=0;
+		//check all tags are registered in box factory
+		while (1) {
+			s32 res = gf_itags_get_type(i);
+			if (res==-1) break;
+			u32 itype = gf_itags_get_itag(i);
+			if (!itype) {
+				i++;
+				continue;
+			}
+ GF_Box *b=gf_isom_box_new(itype);
+ Bool valid = (!b || (b->type==GF_ISOM_BOX_TYPE_UNKNOWN)) ? GF_FALSE : GF_TRUE;
+			if (b) gf_isom_box_del(b);
+			if (!valid) {
+				M4_LOG(GF_LOG_ERROR, ("Tag %s not registered in box factory\n", gf_4cc_to_str(itype) ));
+				return 2;
+			}
+			i++;
+		}
+	}
 	return 1;
 }
 
@@ -1022,8 +1051,8 @@
 	u32 i, j, count, nb_descs, track, nalh_size, timescale, cur_extract_mode;
 	GF_Err e=GF_OK;
 	s32 countRef;
-	Bool is_adobe_protected = GF_FALSE;
-	Bool is_cenc_protected = GF_FALSE;
+	Bool is_adobe_protected;
+	Bool is_cenc_protected;
 	Bool is_hevc = GF_FALSE;
 	Bool is_vvc = GF_FALSE;
 #ifndef GPAC_DISABLE_AV_PARSERS
@@ -1171,6 +1200,14 @@
 					DUMP_ARRAY(ar->nalus, "VVCPPS", "vvcC", 0)
 				} else if (ar->type==GF_VVC_NALU_VID_PARAM) {
 					DUMP_ARRAY(ar->nalus, "VVCVPS", "vvcC", 0)
+				} else if (ar->type==GF_VVC_NALU_DEC_PARAM) {
+					DUMP_ARRAY(ar->nalus, "VVCDecParam", "vvcC", 0)
+				} else if (ar->type==GF_VVC_NALU_OPI) {
+					DUMP_ARRAY(ar->nalus, "VVCOPI", "vvcC", 0)
+				} else if (ar->type==GF_VVC_NALU_APS_PREFIX) {
+					DUMP_ARRAY(ar->nalus, "VVCAPSPrefix", "vvcC", 0)
+				} else if (ar->type==GF_VVC_NALU_SEI_PREFIX) {
+					DUMP_ARRAY(ar->nalus, "VVCSEIPrefix", "vvcC", 0)
 				} else {
 					DUMP_ARRAY(ar->nalus, "VVCUnknownPS", "vvcC", 0)
 				}
@@ -1224,8 +1261,6 @@
 
 	fprintf(dump, " <NALUSamples>\n");
 	gf_isom_set_nalu_extract_mode(file, track, GF_ISOM_NALU_EXTRACT_INSPECT);
-	is_adobe_protected = gf_isom_is_adobe_protection_media(file, track, 1);
-	is_cenc_protected = gf_isom_is_cenc_media(file, track, 1);
 	for (i=0; i<count; i++) {
 		u64 dts, cts;
 		Bool is_rap;
@@ -1236,6 +1271,10 @@
 			e = gf_isom_last_error(file);
 			break;
 		}
+
+		is_adobe_protected = gf_isom_is_adobe_protection_media(file, track, di);
+		is_cenc_protected = gf_isom_is_cenc_media(file, track, di);
+
 		dts = samp->DTS;
 		cts = dts + (s32) samp->CTS_Offset;
 		is_rap = samp->IsRAP;
@@ -1269,7 +1308,7 @@
 		}
 		while (size) {
 			if (size<nalh_size) {
-				fprintf(dump, " \n", idx, nal_size, size);
+				fprintf(dump, " \n", idx, nalh_size, size);
 				break;
 			}
 			nal_size = read_nal_size_hdr(ptr, nalh_size);
@@ -1283,7 +1322,7 @@
 #ifndef GPAC_DISABLE_AV_PARSERS
 				Bool is_encrypted = 0;
 				if (is_cenc_protected) {
-					GF_Err e = gf_isom_get_sample_cenc_info(file, track, i + 1, &is_encrypted, NULL, NULL, NULL, NULL);
+					e = gf_isom_get_sample_cenc_info(file, track, i + 1, &is_encrypted, NULL, NULL, NULL, NULL);
 					if (e != GF_OK) {
 						fprintf(dump, "dump_msg=\"Error %s while fetching encryption info for sample, assuming sample is encrypted\" ", gf_error_to_string(e) );
 						is_encrypted = GF_TRUE;
@@ -1320,12 +1359,14 @@
 
 static GF_Err dump_isom_obu(GF_ISOFile *file, GF_ISOTrackID trackID, FILE *dump, Bool dump_crc);
 static GF_Err dump_qt_prores(GF_ISOFile *file, GF_ISOTrackID trackID, FILE *dump, Bool dump_crc);
+static GF_Err dump_isom_opus(GF_ISOFile *file, GF_ISOTrackID trackID, FILE *dump, Bool dump_crc);
 
 GF_Err dump_isom_nal(GF_ISOFile *file, GF_ISOTrackID trackID, char *inName, Bool is_final_name, u32 dump_flags)
 {
 	char szFileNameGF_MAX_PATH;
 	Bool is_av1 = GF_FALSE;
 	Bool is_prores = GF_FALSE;
+ Bool is_opus = GF_FALSE;
 
 	FILE *dump;
 	if (inName) {
@@ -1349,11 +1390,16 @@
 			case GF_QT_SUBTYPE_AP4H:
 				is_prores = GF_TRUE;
 				break;
+ case GF_ISOM_SUBTYPE_OPUS:
+ is_opus = GF_TRUE;
+ break;
 			}
 		}
 		else if (esd->decoderConfig->objectTypeIndication == GF_CODECID_AV1) {
 			is_av1 = GF_TRUE;
-		}
+ } else if (esd->decoderConfig->objectTypeIndication == GF_CODECID_OPUS) {
+ is_opus = GF_TRUE;
+ }
 		if (esd) gf_odf_desc_del((GF_Descriptor*)esd);
 
 		if (!is_final_name) sprintf(szFileName, "%s_%d_%s.xml", inName, trackID, is_av1 ? "obu" : "nalu");
@@ -1371,6 +1417,8 @@
 		e = dump_isom_obu(file, trackID, dump, dump_flags);
 	else if (is_prores)
 		e = dump_qt_prores(file, trackID, dump, dump_flags);
+ else if (is_opus)
+ e = dump_isom_opus(file, trackID, dump, dump_flags);
 	else
 		e = dump_isom_nal_ex(file, trackID, dump, dump_flags);
 
@@ -1379,7 +1427,7 @@
 	if (!e && dump_check_xml) {
 		if (inName) {
 			GF_DOMParser *xml_parser = gf_xml_dom_new();
-			GF_Err e = gf_xml_dom_parse(xml_parser, szFileName, NULL, NULL);
+			e = gf_xml_dom_parse(xml_parser, szFileName, NULL, NULL);
 			if (e) {
 				fprintf(stderr, "Failed to parse XML dump %s: line %d: %s\n", szFileName, gf_xml_dom_get_line(xml_parser), gf_xml_dom_get_error(xml_parser) );
 			}
@@ -1392,6 +1440,74 @@
 }
 
 #ifndef GPAC_DISABLE_AV_PARSERS
+void gf_inspect_dump_opus(FILE *dump, u8 *ptr, u64 size, u32 channel_count, Bool dump_crc);
+#endif
+
+static GF_Err dump_isom_opus(GF_ISOFile *file, GF_ISOTrackID trackID, FILE *dump, Bool dump_crc)
+{
+ GF_Err e = GF_OK;
+#ifndef GPAC_DISABLE_AV_PARSERS
+ u32 i, count, track, timescale, channel_count;
+ GF_OpusConfig opcfg;
+ track = gf_isom_get_track_by_id(file, trackID);
+
+ e = gf_isom_opus_config_get_desc(file, track, 1, &opcfg);
+ if (e != GF_OK) {
+ M4_LOG(GF_LOG_ERROR, ("Error: Track #%d is not Opus!\n", trackID));
+ return GF_ISOM_INVALID_FILE;
+ }
+
+ count = gf_isom_get_sample_count(file, track);
+ timescale = gf_isom_get_media_timescale(file, track);
+
+ fprintf(dump, "<OpusTrack trackID=\"%d\" SampleCount=\"%d\" TimeScale=\"%d\">\n", trackID, count, timescale);
+
+	fprintf(dump, " <OpusConfig version=\"%d\" OutputChannelCount=\"%d\" PreSkip=\"%d\" InputSampleRate=\"%d\" OutputGain=\"%d\" ChannelMappingFamily=\"%d\"",
+			opcfg.version, opcfg.OutputChannelCount, opcfg.PreSkip, opcfg.InputSampleRate, opcfg.OutputGain, opcfg.ChannelMappingFamily);
+	if (opcfg.ChannelMappingFamily) {
+		fprintf(dump, " StreamCount=\"%d\" CoupledStreamCount=\"%d\" channelMapping=\"", opcfg.StreamCount, opcfg.CoupledCount);
+		for (i=0; i<opcfg.OutputChannelCount; i++) {
+			fprintf(dump, "%s%d", i ? " " : "", opcfg.ChannelMappingi);
+		}
+		fprintf(dump, "\"");
+	}
+	fprintf(dump, "/>\n");
+
+
+	channel_count = (opcfg.StreamCount ? opcfg.StreamCount : 1);
+
+ fprintf(dump, " <OpusSamples>\n");
+ e = GF_OK;
+ for (i=0; i<count; i++) {
+ u64 dts, cts;
+ GF_ISOSample *samp = gf_isom_get_sample(file, track, i+1, NULL);
+ if (!samp) {
+ e = gf_isom_last_error(file);
+ break;
+ }
+ dts = samp->DTS;
+ cts = dts + (s32) samp->CTS_Offset;
+
+ fprintf(dump, " <Sample number=\"%d\" DTS=\""LLD"\" CTS=\""LLD"\" size=\"%d\" RAP=\"%d\" >\n", i+1, dts, cts, samp->dataLength, samp->IsRAP);
+ if (cts<dts) fprintf(dump, "\n");
+
+		gf_inspect_dump_opus(dump, samp->data, samp->dataLength, channel_count, dump_crc);
+
+ fprintf(dump, " </Sample>\n");
+ gf_isom_sample_del(&samp);
+
+ fprintf(dump, "\n");
+
+ if (e<GF_OK) break;
+ gf_set_progress("Analysing Track Opus Sample", i+1, count);
+ }
+ fprintf(dump, " </OpusSamples>\n");
+ fprintf(dump, "</OpusTrack>\n");
+#endif
+ return e;
+}
+
+#ifndef GPAC_DISABLE_AV_PARSERS
 void gf_inspect_dump_obu(FILE *dump, AV1State *av1, u8 *obu, u64 obu_length, ObuType obu_type, u64 obu_size, u32 hdr_size, Bool dump_crc);
 #endif
 
@@ -2009,10 +2125,6 @@
 				e = dump_isom_obu(the_file, trackID, dump, GF_FALSE);
 				fmt_handled = GF_TRUE;
 			}
-			else if (msubtype == GF_ISOM_SUBTYPE_AV01) {
-				e = dump_isom_obu(the_file, trackID, dump, GF_FALSE);
-				fmt_handled = GF_TRUE;
-			}
 			else if ((msubtype == GF_QT_SUBTYPE_APCH) || (msubtype == GF_QT_SUBTYPE_APCO)
 				|| (msubtype == GF_QT_SUBTYPE_APCN) || (msubtype == GF_QT_SUBTYPE_APCS)
 				|| (msubtype == GF_QT_SUBTYPE_AP4X) || (msubtype == GF_QT_SUBTYPE_AP4H)
@@ -2030,6 +2142,10 @@
 					fmt_handled = GF_TRUE;
 				}
 			}
+ else if (msubtype == GF_ISOM_SUBTYPE_OPUS) {
+ e = dump_isom_opus(the_file, trackID, dump, GF_FALSE);
+ fmt_handled = GF_TRUE;
+ }
 
 			if (!fmt_handled) {
 				dumper.flags = GF_EXPORT_NHML | GF_EXPORT_NHML_FULL;
@@ -2110,14 +2226,14 @@
 	return szTime;
 }
 
-void print_udta(GF_ISOFile *file, u32 track_number, Bool has_itags)
+void print_udta(GF_ISOFile *file, u32 track_number, Bool has_meta_tags)
 {
 	u32 i, count;
 
 	count = gf_isom_get_udta_count(file, track_number);
 	if (!count) return;
 
-	if (has_itags) {
+	if (has_meta_tags) {
 		for (i=0; i<count; i++) {
 			u32 type;
 			bin128 uuid;
@@ -2139,18 +2255,32 @@
 		nb_items = gf_isom_get_user_data_count(file, track_number, type, uuid);
 		if (!nb_items) continue;
 
-		fprintf(stderr, "\n\t%s: ", gf_4cc_to_str(type));
+		s32 itag = gf_itags_find_by_itag(type);
+
+		fprintf(stderr, "\n\t%s: ", (itag<0) ? gf_4cc_to_str(type) : gf_itags_get_name(itag));
 		for (j=0; j<nb_items; j++) {
-			u8 *udta=NULL;
+			u8 *udta=NULL, *str;
 			u32 udta_size;
 			gf_isom_get_user_data(file, track_number, type, uuid, j+1, &udta, &udta_size);
 			if (!udta) continue;
 			if (j) fprintf(stderr, ", ");
-			if (udta_size && gf_utf8_is_legal(udta, udta_size)) {
+
+			str = udta;
+			if (itag>=0) {
+				u32 s = udta0;
+				s <<= 8;
+				s |= udta1;
+				if (s+4 == udta_size) {
+					udta_size = s;
+					str = udta+4;
+				}
+			}
+
+			if (udta_size && gf_utf8_is_legal(str, udta_size)) {
 				u32 idx;
 				for (idx=0; idx<udta_size; idx++) {
-					if (!udtaidx) break;
-					fprintf(stderr, "%c", udtaidx);
+					if (!stridx) break;
+					fprintf(stderr, "%c", stridx);
 				}
 			} else {
 				fprintf(stderr, " unknown type (%d bytes)", udta_size);
@@ -2209,9 +2339,11 @@
 	return GF_OK;
 }
 
-
 GF_Err dump_isom_chapters(GF_ISOFile *file, char *inName, Bool is_final_name, u32 dump_mode)
 {
+#ifdef GPAC_DISABLE_ISOM_DUMP
+	return GF_NOT_SUPPORTED;
+#else
 	FILE *t;
 	u32 i, count;
 	u32 chap_tk = 0;
@@ -2285,6 +2417,7 @@
 	}
 	if (inName) gf_fclose(t);
 	return GF_OK;
+#endif /*GPAC_DISABLE_ISOM_DUMP*/
 }
 
 
@@ -2361,7 +2494,7 @@
 
 		if (meta_type == GF_META_ITEM_TYPE_PICT) {
 			GF_ImageItemProperties img_props;
-			e = gf_isom_get_meta_image_props(file, root_meta, tk_num, ID, &img_props);
+			e = gf_isom_get_meta_image_props(file, root_meta, tk_num, ID, &img_props, NULL);
 			if (e) {
 				fprintf(stderr, " invalid image properties !");
 			} else {
@@ -2607,154 +2740,69 @@
 
 void gf_inspect_format_timecode(const u8 *data, u32 size, u32 tmcd_flags, u32 tc_num, u32 tc_den, u32 tmcd_fpt, char szFmt100);
 
-void DumpTrackInfo(GF_ISOFile *file, GF_ISOTrackID trackID, Bool full_dump, Bool is_track_num, Bool dump_m4sys)
+static void DumpStsdInfo(GF_ISOFile *file, u32 trackNum, Bool full_dump, Bool dump_m4sys, u32 mtype, u32 stsd_idx, Bool *is_od_track)
 {
 	char szCodecRFC6381_CODEC_NAME_SIZE_MAX;
-	Double scale, max_rate, rate;
-	Bool is_od_track = 0;
-	u32 trackNum, i, j, ts, mtype, msub_type, timescale, sr, nb_ch, count, alt_group, nb_groups, nb_edits, cdur, csize, bps, pfmt, codecid;
-	u64 time_slice, dur, size;
-	s32 cts_shift;
+	u32 i, j, msub_type, sr, nb_ch, count, bps, pfmt, codecid, w_dsisize=0;
 	GF_ESD *esd;
-	char szDur50;
-	char *lang;
-
-	if (!is_track_num) {
-		trackNum = gf_isom_get_track_by_id(file, trackID);
-	} else {
-		trackNum = trackID;
-		trackID = gf_isom_get_track_id(file, trackNum);
-	}
-	if (!trackNum) {
-		M4_LOG(GF_LOG_ERROR, ("No track with ID %d found\n", trackID));
-		return;
-	}
-
-	timescale = gf_isom_get_media_timescale(file, trackNum);
-	fprintf(stderr, "# Track %d Info - ID %d - TimeScale %d\n", trackNum, trackID, timescale);
-
-	dur = gf_isom_get_media_original_duration(file, trackNum);
-	size = gf_isom_get_media_duration(file, trackNum);
-	fprintf(stderr, "Media Duration %s ", format_duration(dur, timescale, szDur));
-	if (dur != size)
-		fprintf(stderr, " (recomputed %s)", format_duration(size, timescale, szDur));
-	fprintf(stderr, "\n");
-
-	if (gf_isom_check_data_reference(file, trackNum, 1) != GF_OK) {
-		M4_LOG(GF_LOG_WARNING, ("Track uses external data reference not supported by GPAC!\n"));
-	}
 
-	nb_edits = gf_isom_get_edits_count(file, trackNum);
-	if (nb_edits)
-		fprintf(stderr, "Track has %d edits: track duration is %s\n", nb_edits, format_duration(gf_isom_get_track_duration(file, trackNum), gf_isom_get_timescale(file), szDur));
-
-	cts_shift = gf_isom_get_composition_offset_shift(file, trackNum);
-	if (cts_shift)
-		fprintf(stderr, "Track composition offset shift (negative CTS offset): %d\n", cts_shift);
-
-	if (gf_isom_is_track_in_root_od(file, trackNum) ) fprintf(stderr, "Track is present in Root OD\n");
-
-	u32 tk_flags = gf_isom_get_track_flags(file, trackNum);
-	fprintf(stderr, "Track flags:");
-	if (tk_flags & GF_ISOM_TK_ENABLED) fprintf(stderr, " Enabled");
-	else fprintf(stderr, " Disabled");
-	if (tk_flags & GF_ISOM_TK_IN_MOVIE) fprintf(stderr, " In Movie");
-	if (tk_flags & GF_ISOM_TK_IN_PREVIEW) fprintf(stderr, " In Preview");
-	if (tk_flags & GF_ISOM_TK_SIZE_IS_AR) fprintf(stderr, " Size is AspectRatio");
-	fprintf(stderr, "\n");
-
-	gf_isom_get_media_language(file, trackNum, &lang);
-	fprintf(stderr, "Media Info: Language \"%s (%s)\" - ", GetLanguage(lang), lang );
-	gf_free(lang);
-	mtype = gf_isom_get_media_type(file, trackNum);
-	fprintf(stderr, "Type \"%s:", gf_4cc_to_str(mtype));
-	msub_type = gf_isom_get_mpeg4_subtype(file, trackNum, 1);
-	if (!msub_type) msub_type = gf_isom_get_media_subtype(file, trackNum, 1);
-	fprintf(stderr, "%s\" - %d samples\n", gf_4cc_to_str(msub_type), gf_isom_get_sample_count(file, trackNum));
+	msub_type = gf_isom_get_media_subtype(file, trackNum, stsd_idx);
+	if (msub_type==GF_ISOM_SUBTYPE_MPEG4_CRYP)
+		gf_isom_get_original_format_type(file, trackNum, stsd_idx, &msub_type);
 
 	pfmt = gf_pixel_fmt_from_qt_type(msub_type);
 	codecid = gf_codec_id_from_isobmf(msub_type);
 
-	count = gf_isom_get_track_kind_count(file, trackNum);
-	for (i = 0; i < count; i++) {
-		char *kind_scheme, *kind_value;
-		gf_isom_get_track_kind(file, trackNum, i, &kind_scheme, &kind_value);
-		fprintf(stderr, "Kind: %s - %s\n", kind_scheme ? kind_scheme : "null", kind_value ? kind_value : "null");
-		if (kind_scheme) gf_free(kind_scheme);
-		if (kind_value) gf_free(kind_value);
-	}
-
-	if (gf_isom_is_track_fragmented(file, trackID) ) {
-		u32 defaultDuration, defaultSize, defaultDescriptionIndex, defaultRandomAccess;
-		u8 defaultPadding;
-		u16 defaultDegradationPriority;
-		u32 frag_samples;
-		u64 frag_duration;
-		gf_isom_get_fragmented_samples_info(file, trackID, &frag_samples, &frag_duration);
-		fprintf(stderr, "Fragmented track: %d samples - Media Duration %s\n", frag_samples, format_duration(frag_duration, timescale, szDur));
-
-		gf_isom_get_fragment_defaults(file, trackNum, &defaultDuration, &defaultSize, &defaultDescriptionIndex, &defaultRandomAccess, &defaultPadding, &defaultDegradationPriority);
-
-		fprintf(stderr, "Fragment sample defaults: duration %d size %d stsd %d sync %d padding %d degradation_priority %d\n",
-				defaultDuration, defaultSize, defaultDescriptionIndex, defaultRandomAccess,
-				(u32) defaultPadding, (u32) defaultDegradationPriority
-		);
-	}
-
-	if (!gf_isom_is_self_contained(file, trackNum, 1)) {
-		const char *url, *urn;
-		gf_isom_get_data_reference(file, trackNum, 1, &url, &urn);
-		fprintf(stderr, "Media Data Location: %s\n", url ? url : urn);
-	}
-
+	u32 stsd_type = msub_type;
+	if (msub_type==GF_ISOM_SUBTYPE_MPEG4)
+		stsd_type = gf_isom_get_mpeg4_subtype(file, trackNum, stsd_idx);
 	if (full_dump) {
-		const char *handler_name;
-		gf_isom_get_handler_name(file, trackNum, &handler_name);
-		fprintf(stderr, "Handler name: %s\n", handler_name);
-	}
-
-	print_udta(file, trackNum, GF_FALSE);
-
-	DumpMetaItem(file, 0, trackNum, "\tTrack Meta");
-
-	gf_isom_get_track_switch_group_count(file, trackNum, &alt_group, &nb_groups);
-	if (alt_group) {
-		fprintf(stderr, "Alternate Group ID %d\n", alt_group);
-		for (i=0; i<nb_groups; i++) {
-			u32 nb_crit, switchGroupID;
-			const u32 *criterias = gf_isom_get_track_switch_parameter(file, trackNum, i+1, &switchGroupID, &nb_crit);
-			if (!nb_crit) {
-				fprintf(stderr, "\tNo criteria in %s group\n", switchGroupID ? "switch" : "alternate");
-			} else {
-				if (switchGroupID) {
-					fprintf(stderr, "\tSwitchGroup ID %d criterias: ", switchGroupID);
-				} else {
-					fprintf(stderr, "\tAlternate Group criterias: ");
-				}
-				for (j=0; j<nb_crit; j++) {
-					if (j) fprintf(stderr, " ");
-					fprintf(stderr, "%s", gf_4cc_to_str(criteriasj) );
+		if (stsd_idx>1) fprintf(stderr, "\n");
+		fprintf(stderr, "Sample Description #%u - %s:%s\n", stsd_idx, gf_4cc_to_str(mtype), gf_4cc_to_str(stsd_type));
+	} else {
+		if (stsd_type == GF_4CC('G','M','C','W')) {
+			u32 w_codec_id=0;
+			char *w_codec_str = NULL;
+			GF_GenericSampleDescription *gdesc = gf_isom_get_generic_sample_description(file, trackNum, stsd_idx);
+			if (gdesc) {
+				if (gdesc->extension_buf_size>16) {
+					GF_BitStream *bs = gf_bs_new(gdesc->extension_buf, gdesc->extension_buf_size, GF_BITSTREAM_READ);
+					gf_bs_read_u32(bs);
+					gf_bs_read_u32(bs);
+					gf_bs_read_u32(bs);
+					w_codec_id = gf_bs_read_u32(bs);
+					w_codec_str = gf_bs_read_utf8(bs);
+					gf_bs_read_u32(bs);
+					w_dsisize = (u32) gf_bs_available(bs);
+					gf_bs_del(bs);
 				}
-				fprintf(stderr, "\n");
+				if (gdesc->extension_buf) gf_free(gdesc->extension_buf);
+				gf_free(gdesc);
 			}
+			fprintf(stderr, "Media Type: %s:%s (GPAC wrapper for %s)\n", gf_4cc_to_str(mtype), gf_4cc_to_str(stsd_type), w_codec_str ? w_codec_str : gf_4cc_to_str(w_codec_id) );
+			if (w_codec_str) gf_free(w_codec_str);
+		} else {
+			fprintf(stderr, "Media Type: %s:%s\n", gf_4cc_to_str(mtype), gf_4cc_to_str(stsd_type));
 		}
 	}
 
+	if (!gf_isom_is_self_contained(file, trackNum, stsd_idx)) {
+		const char *url, *urn;
+		gf_isom_get_data_reference(file, trackNum, stsd_idx, &url, &urn);
+		fprintf(stderr, "Media Data Location: %s\n", url ? url : urn);
+	}
+
 	if (gf_isom_is_video_handler_type(mtype) ) {
-		s32 tx, ty;
 		u32 w, h;
 		u16 bit_depth;
 
-		gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
-		gf_isom_get_visual_bit_depth(file, trackNum, 1, &bit_depth);
-		fprintf(stderr, "Visual Sample Entry Info: width=%d height=%d (depth=%d bits)\n", w, h, (int)bit_depth);
-
-		gf_isom_get_track_layout_info(file, trackNum, &w, &h, &tx, &ty, NULL);
-		fprintf(stderr, "Visual Track layout: x=%d y=%d width=%d height=%d\n", tx, ty, w, h);
+		gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
+		gf_isom_get_visual_bit_depth(file, trackNum, stsd_idx, &bit_depth);
+		fprintf(stderr, "\tVisual Sample Entry Info: width=%d height=%d (depth=%d bits)\n", w, h, (int)bit_depth);
 
-		GF_DOVIDecoderConfigurationRecord *dovi = gf_isom_dovi_config_get(file, trackNum, 1);
+		GF_DOVIDecoderConfigurationRecord *dovi = gf_isom_dovi_config_get(file, trackNum, stsd_idx);
 		if (dovi) {
-			fprintf(stderr, "DolbyVision version %d.%d profile %d level %d (RPU: %d Base Layer: %d Enhancement Layer: %d Compatibility: %d)\n",
+			fprintf(stderr, "\tDolbyVision version %d.%d profile %d level %d (RPU: %d Base Layer: %d Enhancement Layer: %d Compatibility: %d)\n",
 				dovi->dv_version_major, dovi->dv_version_minor, dovi->dv_profile, dovi->dv_level,
 				dovi->rpu_present_flag, dovi->bl_present_flag, dovi->el_present_flag, dovi->dv_bl_signal_compatibility_id);
 
@@ -2762,13 +2810,9 @@
 		}
 	}
 
-	gf_isom_get_audio_info(file, trackNum, 1, &sr, &nb_ch, &bps);
+	gf_isom_get_audio_info(file, trackNum, stsd_idx, &sr, &nb_ch, &bps);
 	gf_isom_set_nalu_extract_mode(file, trackNum, GF_ISOM_NALU_EXTRACT_INSPECT);
 
-	msub_type = gf_isom_get_media_subtype(file, trackNum, 1);
-	if (msub_type==GF_ISOM_SUBTYPE_MPEG4_CRYP)
-		gf_isom_get_original_format_type(file, trackNum, 1, &msub_type);
-
 	if ((msub_type==GF_ISOM_SUBTYPE_MPEG4)
 	 || (msub_type==GF_ISOM_SUBTYPE_AVC_H264)
 	 || (msub_type==GF_ISOM_SUBTYPE_AVC2_H264)
@@ -2784,25 +2828,29 @@
 	 || (msub_type==GF_ISOM_SUBTYPE_LHV1)
 	 || (msub_type==GF_ISOM_SUBTYPE_LHE1)
 	 || (msub_type==GF_ISOM_SUBTYPE_HVT1)
+	 || (msub_type==GF_ISOM_SUBTYPE_DVHE)
+	 || (msub_type==GF_ISOM_SUBTYPE_DVH1)
+	 || (msub_type==GF_ISOM_SUBTYPE_DVA1)
+	 || (msub_type==GF_ISOM_SUBTYPE_DVAV)
 	 ) {
-		esd = gf_isom_get_esd(file, trackNum, 1);
+		esd = gf_isom_get_esd(file, trackNum, stsd_idx);
 		if (!esd || !esd->decoderConfig) {
-			M4_LOG(GF_LOG_WARNING, ("WARNING: Broken MPEG-4 Track\n"));
+			M4_LOG(GF_LOG_WARNING, ("\tWARNING: Broken MPEG-4 Track\n"));
 			if (esd) gf_odf_desc_del((GF_Descriptor *)esd);
 		} else {
 			const char *st = gf_stream_type_name(esd->decoderConfig->streamType);
 			if (dump_m4sys) {
 				if (st) {
-					fprintf(stderr, "MPEG-4 Config%s%s Stream - ObjectTypeIndication 0x%02x\n",
+					fprintf(stderr, "\tMPEG-4 Config%s%s Stream - ObjectTypeIndication 0x%02x\n",
 							full_dump ? "\n\t" : ": ", st, esd->decoderConfig->objectTypeIndication);
 				} else {
-					fprintf(stderr, "MPEG-4 Config%sStream Type 0x%02x - ObjectTypeIndication 0x%02x\n",
+					fprintf(stderr, "\tMPEG-4 Config%sStream Type 0x%02x - ObjectTypeIndication 0x%02x\n",
 							full_dump ? "\n\t" : ": ", esd->decoderConfig->streamType, esd->decoderConfig->objectTypeIndication);
 				}
 			}
 
 			if (esd->decoderConfig->streamType==GF_STREAM_OD)
-				is_od_track=1;
+				*is_od_track=1;
 
 			if (esd->decoderConfig->streamType==GF_STREAM_VISUAL) {
 				u32 w, h;
@@ -2812,8 +2860,8 @@
 #ifndef GPAC_DISABLE_AV_PARSERS
 					if (!esd->decoderConfig->decoderSpecificInfo) {
 #else
-					gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
-					fprintf(stderr, "MPEG-4 Visual Size %d x %d\n", w, h);
+					gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
+					fprintf(stderr, "\tMPEG-4 Visual Size %d x %d\n", w, h);
 #endif
 						M4_LOG(GF_LOG_WARNING, ("Non-compliant MPEG-4 Visual track: video_object_layer infos not found in sample description\n"));
 #ifndef GPAC_DISABLE_AV_PARSERS
@@ -2823,24 +2871,24 @@
 						if (full_dump) fprintf(stderr, "\t");
 						w = dsi.width;
 						h = dsi.height;
-						fprintf(stderr, "MPEG-4 Visual Size %d x %d - %s\n", w, h, gf_m4v_get_profile_name(dsi.VideoPL));
+						fprintf(stderr, "\tMPEG-4 Visual Size %d x %d - %s\n", w, h, gf_m4v_get_profile_name(dsi.VideoPL));
 						if (dsi.par_den && dsi.par_num) {
 							u32 tw, th;
 							gf_isom_get_track_layout_info(file, trackNum, &tw, &th, NULL, NULL, NULL);
-							fprintf(stderr, "Pixel Aspect Ratio %d:%d - Indicated track size %d x %d\n", dsi.par_num, dsi.par_den, tw, th);
+							fprintf(stderr, "\tPixel Aspect Ratio %d:%d - Indicated track size %d x %d\n", dsi.par_num, dsi.par_den, tw, th);
 						}
 					}
 #endif
-				} else if (gf_isom_get_avc_svc_type(file, trackNum, 1) != GF_ISOM_AVCTYPE_NONE) {
+				} else if (gf_isom_get_avc_svc_type(file, trackNum, stsd_idx) != GF_ISOM_AVCTYPE_NONE) {
 					GF_AVCConfig *avccfg, *svccfg, *mvccfg;
 
-					gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+					gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 					if (full_dump) fprintf(stderr, "\t");
-					fprintf(stderr, "AVC/H264 Video - Visual Size %d x %d\n", w, h);
+					fprintf(stderr, "\tAVC/H264 Video - Visual Size %d x %d\n", w, h);
 
-					avccfg = gf_isom_avc_config_get(file, trackNum, 1);
-					svccfg = gf_isom_svc_config_get(file, trackNum, 1);
-					mvccfg = gf_isom_mvc_config_get(file, trackNum, 1);
+					avccfg = gf_isom_avc_config_get(file, trackNum, stsd_idx);
+					svccfg = gf_isom_svc_config_get(file, trackNum, stsd_idx);
+					mvccfg = gf_isom_mvc_config_get(file, trackNum, stsd_idx);
 					if (!avccfg && !svccfg && !mvccfg) {
 						M4_LOG(GF_LOG_ERROR, ("\tNon-compliant AVC track: SPS/PPS not found in sample description\n"));
 					} else if (avccfg) {
@@ -2932,20 +2980,20 @@
 					hevc_state.sps_active_idx = -1;
 #endif
 
-					gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+					gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 					if (full_dump) fprintf(stderr, "\t");
-					fprintf(stderr, "HEVC Video - Visual Size %d x %d\n", w, h);
-					hevccfg = gf_isom_hevc_config_get(file, trackNum, 1);
-					lhvccfg = gf_isom_lhvc_config_get(file, trackNum, 1);
+					fprintf(stderr, "\tHEVC Video - Visual Size %d x %d\n", w, h);
+					hevccfg = gf_isom_hevc_config_get(file, trackNum, stsd_idx);
+					lhvccfg = gf_isom_lhvc_config_get(file, trackNum, stsd_idx);
 
 					if (msub_type==GF_ISOM_SUBTYPE_HVT1) {
 						const u8 *data;
 						u32 tsize;
 						u32 is_default, tx,ty,tw,th, id, independent;
 						Bool full_frame;
-						if (gf_isom_get_tile_info(file, trackNum, 1, &is_default, &id, &independent, &full_frame, &tx, &ty, &tw, &th)) {
+						if (gf_isom_get_tile_info(file, trackNum, stsd_idx, &is_default, &id, &independent, &full_frame, &tx, &ty, &tw, &th)) {
 							fprintf(stderr, "\tHEVC Tile - ID %d independent %d (x,y,w,h)=%d,%d,%d,%d \n", id, independent, tx, ty, tw, th);
-						} else if (gf_isom_get_sample_group_info(file, trackNum, 1, GF_ISOM_SAMPLE_GROUP_TRIF, &is_default, &data, &tsize)) {
+						} else if (gf_isom_get_sample_group_info(file, trackNum, stsd_idx, GF_ISOM_SAMPLE_GROUP_TRIF, &is_default, &data, &tsize)) {
 							fprintf(stderr, "\tHEVC Tile track containing a tile set\n");
 						} else {
 							fprintf(stderr, "\tHEVC Tile track without tiling info\n");
@@ -3000,7 +3048,7 @@
 				/*OGG media*/
 				else if (esd->decoderConfig->objectTypeIndication==GF_CODECID_THEORA) {
 					char *szName;
-					gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+					gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 					if (full_dump) fprintf(stderr, "\t");
 					szName = "Unknown";
 					if (esd->decoderConfig->decoderSpecificInfo
@@ -3009,23 +3057,23 @@
 					)
 						szName = "Theora";
 
-					fprintf(stderr, "Ogg/%s video / GPAC Mux - Visual Size %d x %d\n", szName, w, h);
+					fprintf(stderr, "\tOgg/%s video / GPAC Mux - Visual Size %d x %d\n", szName, w, h);
 				}
 				else {
 					//check if we know this codec from its OTI
 					u32 codec_id = gf_codecid_from_oti(GF_STREAM_VISUAL, esd->decoderConfig->objectTypeIndication);
 					if (codec_id) {
-						gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
-						fprintf(stderr, "%s - Visual Size %d x %d\n", gf_codecid_name(codec_id), w, h);
+						gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
+						fprintf(stderr, "\t%s - Visual Size %d x %d\n", gf_codecid_name(codec_id), w, h);
 					}
 				}
 				if (!w || !h) {
-					gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+					gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 					if (full_dump) fprintf(stderr, "\t");
-					fprintf(stderr, "Visual Size %d x %d\n", w, h);
+					fprintf(stderr, "\tVisual Size %d x %d\n", w, h);
 				}
-				if (gf_isom_get_rvc_config(file, trackNum, 1, &rvc_predef, NULL, NULL, NULL)==GF_OK) {
-					fprintf(stderr, "Has RVC signaled - Predefined configuration %d\n", rvc_predef);
+				if (gf_isom_get_rvc_config(file, trackNum, stsd_idx, &rvc_predef, NULL, NULL, NULL)==GF_OK) {
+					fprintf(stderr, "\tHas RVC signaled - Predefined configuration %d\n", rvc_predef);
 				}
 
 			} else if (esd->decoderConfig->streamType==GF_STREAM_AUDIO) {
@@ -3049,7 +3097,7 @@
 						e = gf_m4a_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &a_cfg);
 					if (full_dump) fprintf(stderr, "\t");
 					if (e) {
-						M4_LOG(GF_LOG_ERROR, ("Corrupted AAC Config\n"));
+						M4_LOG(GF_LOG_ERROR, ("\tCorrupted AAC Config\n"));
 					} else {
 						char *signaling = "implicit";
 						char *heaac = "";
@@ -3063,21 +3111,21 @@
 						} else {
 							signaling = "hierarchical";
 						}
-						fprintf(stderr, "%s (AOT=%d %s) %s- %d Channel(s) - SampleRate %d", gf_m4a_object_type_name(a_cfg.base_object_type), a_cfg.base_object_type, signaling, heaac, a_cfg.nb_chan, a_cfg.base_sr);
+						fprintf(stderr, "\t%s (AOT=%d %s) %s- %d Channel(s) - SampleRate %d", gf_m4a_object_type_name(a_cfg.base_object_type), a_cfg.base_object_type, signaling, heaac, a_cfg.nb_chan, a_cfg.base_sr);
 						if (is_mp2) fprintf(stderr, " (MPEG-2 Signaling)");
 						if (a_cfg.has_sbr) fprintf(stderr, " - SBR: SampleRate %d Type %s", a_cfg.sbr_sr, gf_m4a_object_type_name(a_cfg.sbr_object_type));
 						if (a_cfg.has_ps) fprintf(stderr, " - PS");
 						fprintf(stderr, "\n");
 					}
 #else
-					fprintf(stderr, "MPEG-2/4 Audio - %d Channels - SampleRate %d\n", nb_ch, sr);
+					fprintf(stderr, "\tMPEG-2/4 Audio - %d Channels - SampleRate %d\n", nb_ch, sr);
 #endif
 					break;
 				case GF_CODECID_MPEG2_PART3:
 				case GF_CODECID_MPEG_AUDIO:
 				case GF_CODECID_MPEG_AUDIO_L1:
 					if (msub_type == GF_ISOM_SUBTYPE_MPEG4_CRYP) {
-						fprintf(stderr, "MPEG-1/2 Audio - %d Channels - SampleRate %d\n", nb_ch, sr);
+						fprintf(stderr, "\tMPEG-1/2 Audio - %d Channels - SampleRate %d\n", nb_ch, sr);
 					} else {
 #ifndef GPAC_DISABLE_AV_PARSERS
 						GF_ISOSample *samp = gf_isom_get_sample(file, trackNum, 1, &oti);
@@ -3085,7 +3133,7 @@
 							if (samp->data && (samp->dataLength>4)) {
 								u32 mhdr = GF_4CC((u8)samp->data0, (u8)samp->data1, (u8)samp->data2, (u8)samp->data3);
 								if (full_dump) fprintf(stderr, "\t");
-								fprintf(stderr, "%s Audio - %d Channel(s) - SampleRate %d - Layer %d\n",
+								fprintf(stderr, "\t%s Audio - %d Channel(s) - SampleRate %d - Layer %d\n",
 										gf_mp3_version_name(mhdr),
 										gf_mp3_num_channels(mhdr),
 										gf_mp3_sampling_rate(mhdr),
@@ -3097,31 +3145,31 @@
 							M4_LOG(GF_LOG_ERROR, ("Error fetching sample: %s\n", gf_error_to_string(gf_isom_last_error(file)) ));
 						}
 #else
-						fprintf(stderr, "MPEG-1/2 Audio - %d Channels - SampleRate %d\n", nb_ch, sr);
+						fprintf(stderr, "\tMPEG-1/2 Audio - %d Channels - SampleRate %d\n", nb_ch, sr);
 #endif
 					}
 					break;
 				case GF_CODECID_EVRC:
-					fprintf(stderr, "EVRC Audio - Sample Rate 8000 - 1 channel\n");
+					fprintf(stderr, "\tEVRC Audio - Sample Rate 8000 - 1 channel\n");
 					break;
 				case GF_CODECID_SMV:
-					fprintf(stderr, "SMV Audio - Sample Rate 8000 - 1 channel\n");
+					fprintf(stderr, "\tSMV Audio - Sample Rate 8000 - 1 channel\n");
 					break;
 				case GF_CODECID_QCELP:
-					fprintf(stderr, "QCELP Audio - Sample Rate 8000 - 1 channel\n");
+					fprintf(stderr, "\tQCELP Audio - Sample Rate 8000 - 1 channel\n");
 					break;
 				/*packetVideo hack for EVRC...*/
 				case GF_CODECID_EVRC_PV:
 					if (esd->decoderConfig->decoderSpecificInfo && (esd->decoderConfig->decoderSpecificInfo->dataLength==8)
 					 && !strnicmp((char *)esd->decoderConfig->decoderSpecificInfo->data, "pvmm", 4)) {
 						if (full_dump) fprintf(stderr, "\t");
-						fprintf(stderr, "EVRC Audio (PacketVideo Mux) - Sample Rate 8000 - 1 channel\n");
+						fprintf(stderr, "\tEVRC Audio (PacketVideo Mux) - Sample Rate 8000 - 1 channel\n");
 					}
 					break;
 				default:
 					codec_id = gf_codecid_from_oti(GF_STREAM_AUDIO, esd->decoderConfig->objectTypeIndication);
 					if (codec_id) {
-						fprintf(stderr, "%s - Sample Rate %d - %d channel(s)\n", gf_codecid_name(codec_id), sr, nb_ch);
+						fprintf(stderr, "\t%s - Sample Rate %d - %d channel(s)\n", gf_codecid_name(codec_id), sr, nb_ch);
 					}
 					break;
 				}
@@ -3130,7 +3178,7 @@
 				if (esd->decoderConfig->objectTypeIndication<=4) {
 					GF_BIFSConfig *b_cfg = gf_odf_get_bifs_config(esd->decoderConfig->decoderSpecificInfo, esd->decoderConfig->objectTypeIndication);
 					if (b_cfg) {
-						fprintf(stderr, "BIFS Scene description - %s stream\n", b_cfg->elementaryMasks ? "Animation" : "Command");
+						fprintf(stderr, "\tBIFS Scene description - %s stream\n", b_cfg->elementaryMasks ? "Animation" : "Command");
 						if (full_dump && !b_cfg->elementaryMasks) {
 							fprintf(stderr, "\tWidth %d Height %d Pixel Metrics %s\n", b_cfg->pixelWidth, b_cfg->pixelHeight, b_cfg->pixelMetrics ? "yes" : "no");
 						}
@@ -3141,19 +3189,19 @@
 				} else if (esd->decoderConfig->objectTypeIndication==GF_CODECID_AFX) {
 					u8 tag = (esd->decoderConfig->decoderSpecificInfo && esd->decoderConfig->decoderSpecificInfo->data) ? esd->decoderConfig->decoderSpecificInfo->data0 : 0xFF;
 					const char *afxtype = gf_stream_type_afx_name(tag);
-					fprintf(stderr, "AFX Stream - type %s (%d)\n", afxtype, tag);
+					fprintf(stderr, "\tAFX Stream - type %s (%d)\n", afxtype, tag);
 				} else if (esd->decoderConfig->objectTypeIndication==GF_CODECID_FONT) {
-					fprintf(stderr, "Font Data stream\n");
+					fprintf(stderr, "\tFont Data stream\n");
 				} else if (esd->decoderConfig->objectTypeIndication==GF_CODECID_LASER) {
 					GF_LASERConfig l_cfg;
 					gf_odf_get_laser_config(esd->decoderConfig->decoderSpecificInfo, &l_cfg);
-					fprintf(stderr, "LASER Stream - %s\n", l_cfg.newSceneIndicator ? "Full Scene" : "Scene Segment");
+					fprintf(stderr, "\tLASER Stream - %s\n", l_cfg.newSceneIndicator ? "Full Scene" : "Scene Segment");
 				} else if (esd->decoderConfig->objectTypeIndication==GF_CODECID_TEXT_MPEG4) {
-					fprintf(stderr, "MPEG-4 Streaming Text stream\n");
+					fprintf(stderr, "\tMPEG-4 Streaming Text stream\n");
 				} else if (esd->decoderConfig->objectTypeIndication==GF_CODECID_SYNTHESIZED_TEXTURE) {
-					fprintf(stderr, "Synthetized Texture stream stream\n");
+					fprintf(stderr, "\tSynthetized Texture stream stream\n");
 				} else {
-					M4_LOG(GF_LOG_WARNING, ("Unknown Systems stream OTI %d\n", esd->decoderConfig->objectTypeIndication));
+					M4_LOG(GF_LOG_WARNING, ("\tUnknown Systems stream OTI %d\n", esd->decoderConfig->objectTypeIndication));
 				}
 			}
 
@@ -3161,9 +3209,9 @@
 			if (!full_dump) {
 				if (dump_m4sys) {
 					if (!esd->OCRESID || (esd->OCRESID == esd->ESID))
-						fprintf(stderr, "Self-synchronized\n");
+						fprintf(stderr, "\tSelf-synchronized\n");
 					else
-						fprintf(stderr, "Synchronized on stream %d\n", esd->OCRESID);
+						fprintf(stderr, "\tSynchronized on stream %d\n", esd->OCRESID);
 				}
 			} else {
 				fprintf(stderr, "\tDecoding Buffer size %d - Bitrate: avg %d - max %d kbps\n", esd->decoderConfig->bufferSizeDB, esd->decoderConfig->avgBitrate/1000, esd->decoderConfig->maxBitrate/1000);
@@ -3180,10 +3228,10 @@
 	} else if (msub_type == GF_ISOM_SUBTYPE_AV01) {
 		GF_AV1Config *av1c;
 		u32 w, h;
-		gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+		gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 		fprintf(stderr, "\tAOM AV1 stream - Resolution %d x %d\n", w, h);
 
-		av1c = gf_isom_av1_config_get(file, trackNum, 1);
+		av1c = gf_isom_av1_config_get(file, trackNum, stsd_idx);
 		if (!av1c) {
 			fprintf(stderr, "\tCorrupted av1 config\n");
 		} else {
@@ -3207,11 +3255,11 @@
 		}
 	} else if (msub_type == GF_ISOM_SUBTYPE_3GP_H263) {
 		u32 w, h;
-		gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+		gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 		fprintf(stderr, "\t3GPP H263 stream - Resolution %d x %d\n", w, h);
 	} else if (msub_type == GF_ISOM_SUBTYPE_MJP2) {
 		u32 w, h;
-		gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+		gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 		fprintf(stderr, "\tMotionJPEG2000 stream - Resolution %d x %d\n", w, h);
 	} else if ((msub_type == GF_ISOM_SUBTYPE_3GP_AMR) || (msub_type == GF_ISOM_SUBTYPE_3GP_AMR_WB)) {
 		fprintf(stderr, "\t3GPP AMR%s stream - Sample Rate %d - %d channel(s) %d bps\n", (msub_type == GF_ISOM_SUBTYPE_3GP_AMR_WB) ? " Wide Band" : "", sr, nb_ch, (u32) bps);
@@ -3224,41 +3272,50 @@
 	} else if ((msub_type == GF_ISOM_SUBTYPE_AC3) || (msub_type == GF_ISOM_SUBTYPE_EC3)) {
 		u32 br = 0;
 		const char *lfe = "";
+		Bool atmos=GF_FALSE;
+		u32 complexity_index_type=0;
 		Bool is_ec3 = (msub_type == GF_ISOM_SUBTYPE_EC3) ? GF_TRUE : GF_FALSE;
 #ifndef GPAC_DISABLE_AV_PARSERS
-		GF_AC3Config *ac3 = gf_isom_ac3_config_get(file, trackNum, 1);
+		GF_AC3Config *ac3 = gf_isom_ac3_config_get(file, trackNum, stsd_idx);
 		if (ac3) {
-			nb_ch = gf_ac3_get_channels(ac3->streams0.acmod);
-			for (i=0; i<ac3->streams0.nb_dep_sub; ++i) {
-				assert(ac3->streams0.nb_dep_sub == 1);
-				nb_ch += gf_ac3_get_channels(ac3->streams0.chan_loc);
+			nb_ch = gf_ac3_get_total_channels(ac3->streams0.acmod);
+			if (ac3->streams0.nb_dep_sub) {
+				nb_ch += gf_eac3_get_chan_loc_count(ac3->streams0.chan_loc);
 			}
 			if (ac3->streams0.lfon) lfe = ".1";
-			br = ac3->is_ec3 ? ac3->brcode : gf_ac3_get_bitrate(ac3->brcode);
+			br = ac3->is_ec3 ? (ac3->brcode*1000) : gf_ac3_get_bitrate(ac3->brcode);
 			is_ec3 = ac3->is_ec3;
+			if (is_ec3) {
+				atmos = ac3->atmos_ec3_ext;
+				complexity_index_type = ac3->complexity_index_type;
+			}
 			gf_free(ac3);
 		}
 #endif
-		fprintf(stderr, "\t%s stream - Sample Rate %d - %d%s channel(s) - bitrate %d\n", is_ec3 ? "EC-3" : "AC-3", sr, nb_ch, lfe, br);
+		fprintf(stderr, "\t%s stream - Sample Rate %d - %d%s channel(s) - bitrate %d", is_ec3 ? "EC-3" : "AC-3", sr, nb_ch, lfe, br);
+		if (atmos) {
+			fprintf(stderr, " - ATMOS complexity index type %d", complexity_index_type);
+		}
+		fprintf(stderr, "\n");
 	} else if (msub_type == GF_ISOM_SUBTYPE_3GP_SMV) {
 		fprintf(stderr, "\t3GPP SMV stream - Sample Rate %d - %d channel(s) %d bits per samples\n", sr, nb_ch, (u32) bps);
 	} else if (msub_type == GF_ISOM_SUBTYPE_3GP_DIMS) {
 		u32 w, h;
 		GF_DIMSDescription dims;
-		gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+		gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 
-		gf_isom_get_dims_description(file, trackNum, 1, &dims);
+		gf_isom_get_dims_description(file, trackNum, stsd_idx, &dims);
 		fprintf(stderr, "\t3GPP DIMS stream - size %d x %d - Profile %d - Level %d\n", w, h, dims.profile, dims.level);
 		fprintf(stderr, "\tpathComponents: %d - useFullRequestHost: %s\n", dims.pathComponents, dims.fullRequestHost ? "yes" : "no");
 		fprintf(stderr, "\tstream type: %s - redundant: %s\n", dims.streamType ? "primary" : "secondary", (dims.containsRedundant==1) ? "main" : ((dims.containsRedundant==2) ? "redundant" : "main+redundant") );
-		if (dims.textEncoding0) fprintf(stderr, "\ttext encoding %s\n", dims.textEncoding);
-		if (dims.contentEncoding0) fprintf(stderr, "\tcontent encoding %s\n", dims.contentEncoding);
-		if (dims.content_script_types) fprintf(stderr, "\tscript languages %s\n", dims.content_script_types);
+		if (dims.textEncoding && dims.textEncoding0) fprintf(stderr, "\ttext encoding %s\n", dims.textEncoding);
+		if (dims.contentEncoding && dims.contentEncoding0) fprintf(stderr, "\tcontent encoding %s\n", dims.contentEncoding);
+		if (dims.content_script_types && dims.content_script_types0) fprintf(stderr, "\tscript languages %s\n", dims.content_script_types);
 	} else if (mtype==GF_ISOM_MEDIA_HINT) {
 		u32 refTrack;
 		s32 refCount = gf_isom_get_reference_count(file, trackNum, GF_ISOM_REF_HINT);
 		if (refCount>0) {
-			fprintf(stderr, "Streaming Hint Track for track%s ", (refCount>1) ? "s" :"");
+			fprintf(stderr, "\tStreaming Hint Track for track%s ", (refCount>1) ? "s" :"");
 			for (i=0; i<(u32) refCount; i++) {
 				gf_isom_get_reference(file, trackNum, GF_ISOM_REF_HINT, i+1, &refTrack);
 				if (i) fprintf(stderr, " - ");
@@ -3266,7 +3323,7 @@
 			}
 			fprintf(stderr, "\n");
 		} else {
-			fprintf(stderr, "Streaming Hint Track (no refs)\n");
+			fprintf(stderr, "\tStreaming Hint Track (no refs)\n");
 		}
 #ifndef GPAC_DISABLE_ISOM_HINTING
 		refCount = gf_isom_get_payt_count(file, trackNum);
@@ -3278,7 +3335,7 @@
 		}
 #endif
 	} else if (mtype==GF_ISOM_MEDIA_FLASH) {
-		fprintf(stderr, "Macromedia Flash Movie\n");
+		fprintf(stderr, "\tMacromedia Flash Movie\n");
 	} else if ((mtype==GF_ISOM_MEDIA_TEXT) || (mtype==GF_ISOM_MEDIA_SUBT) || (mtype==GF_ISOM_MEDIA_MPEG_SUBT)) {
 		u32 w, h;
 		s16 l;
@@ -3291,8 +3348,8 @@
 		const char *auxiliary_mimes = NULL;
 		gf_isom_get_track_layout_info(file, trackNum, &w, &h, &tx, &ty, &l);
 		if (msub_type == GF_ISOM_SUBTYPE_SBTT) {
-			gf_isom_stxt_get_description(file, trackNum, 1, &mime, &content_encoding, &config);
-			fprintf(stderr, "Textual Subtitle Stream ");
+			gf_isom_stxt_get_description(file, trackNum, stsd_idx, &mime, &content_encoding, &config);
+			fprintf(stderr, "\tTextual Subtitle Stream ");
 			fprintf(stderr, "- mime %s", mime);
 			if (content_encoding != NULL) {
 				fprintf(stderr, " - encoding %s", content_encoding);
@@ -3301,8 +3358,8 @@
 				fprintf(stderr, " - %d bytes config", (u32) strlen(config));
 			}
 		} else if (msub_type == GF_ISOM_SUBTYPE_STXT) {
-			gf_isom_stxt_get_description(file, trackNum, 1, &mime, &content_encoding, &config);
-			fprintf(stderr, "Simple Timed Text Stream ");
+			gf_isom_stxt_get_description(file, trackNum, stsd_idx, &mime, &content_encoding, &config);
+			fprintf(stderr, "\tSimple Timed Text Stream ");
 			fprintf(stderr, "- mime %s", mime);
 			if (content_encoding != NULL) {
 				fprintf(stderr, " - encoding %s", content_encoding);
@@ -3311,8 +3368,8 @@
 				fprintf(stderr, " - %d bytes config", (u32) strlen(config));
 			}
 		} else if (msub_type == GF_ISOM_SUBTYPE_STPP) {
-			gf_isom_xml_subtitle_get_description(file, trackNum, 1, &_namespace, &schema_loc, &auxiliary_mimes);
-			fprintf(stderr, "XML Subtitle Stream ");
+			gf_isom_xml_subtitle_get_description(file, trackNum, stsd_idx, &_namespace, &schema_loc, &auxiliary_mimes);
+			fprintf(stderr, "\tXML Subtitle Stream ");
 			fprintf(stderr, "- namespace %s", _namespace);
 			if (schema_loc != NULL) {
 				fprintf(stderr, " - schema-location %s", schema_loc);
@@ -3321,9 +3378,9 @@
 				fprintf(stderr, " - auxiliary-mime-types %s", auxiliary_mimes);
 			}
 		} else if (mtype == GF_ISOM_MEDIA_SUBT) {
-			fprintf(stderr, "QT/3GPP subtitle");
+			fprintf(stderr, "\tQT/3GPP subtitle");
 		} else {
-			fprintf(stderr, "Unknown Text Stream");
+			fprintf(stderr, "\tUnknown Text Stream");
 		}
 		fprintf(stderr, "\n\tSize %d x %d - Translation X=%d Y=%d - Layer %d\n", w, h, tx, ty, l);
 	} else if (mtype == GF_ISOM_MEDIA_META) {
@@ -3331,8 +3388,8 @@
 		if (msub_type == GF_ISOM_SUBTYPE_METT) {
 			const char *mime = NULL;
 			const char *config = NULL;
-			gf_isom_stxt_get_description(file, trackNum, 1, &mime, &content_encoding, &config);
-			fprintf(stderr, "Textual Metadata Stream - mime %s", mime);
+			gf_isom_stxt_get_description(file, trackNum, stsd_idx, &mime, &content_encoding, &config);
+			fprintf(stderr, "\tTextual Metadata Stream - mime %s", mime);
 			if (content_encoding != NULL) {
 				fprintf(stderr, " - encoding %s", content_encoding);
 			}
@@ -3343,8 +3400,8 @@
 		} else if (msub_type == GF_ISOM_SUBTYPE_METX) {
 			const char *_namespace = NULL;
 			const char *schema_loc = NULL;
-			gf_isom_get_xml_metadata_description(file, trackNum, 1, &_namespace, &schema_loc, &content_encoding);
-			fprintf(stderr, "XML Metadata Stream - namespace %s", _namespace);
+			gf_isom_get_xml_metadata_description(file, trackNum, stsd_idx, &_namespace, &schema_loc, &content_encoding);
+			fprintf(stderr, "\tXML Metadata Stream - namespace %s", _namespace);
 			if (content_encoding != NULL) {
 				fprintf(stderr, " - encoding %s", content_encoding);
 			}
@@ -3353,7 +3410,7 @@
 			}
 			fprintf(stderr, "\n");
 		} else {
-			fprintf(stderr, "Unknown Metadata Stream\n");
+			fprintf(stderr, "\tUnknown Metadata Stream\n");
 		}
 	} else if ((msub_type==GF_ISOM_SUBTYPE_VVC1) || (msub_type==GF_ISOM_SUBTYPE_VVI1)) {
 		GF_VVCConfig *vvccfg;
@@ -3364,10 +3421,10 @@
 		if (vvc_state) vvc_state->sps_active_idx = -1;
 #endif
 
-		gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
+		gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
 		if (full_dump) fprintf(stderr, "\t");
-		fprintf(stderr, "VVC Video - Visual Size %d x %d\n", w, h);
-		vvccfg = gf_isom_vvc_config_get(file, trackNum, 1);
+		fprintf(stderr, "\tVVC Video - Visual Size %d x %d\n", w, h);
+		vvccfg = gf_isom_vvc_config_get(file, trackNum, stsd_idx);
 
 		if (!vvccfg) {
 			M4_LOG(GF_LOG_ERROR, ("Non-compliant VVC track: No vvcC found in sample description\n"));
@@ -3395,7 +3452,7 @@
 
 		fprintf(stderr, "\tMPEG-H Audio stream - Sample Rate %d\n", sr);
 
-		esd = gf_media_map_esd(file, trackNum, 1);
+		esd = gf_media_map_esd(file, trackNum, stsd_idx);
 		if (!esd || !esd->decoderConfig || !esd->decoderConfig->decoderSpecificInfo
 			|| !esd->decoderConfig->decoderSpecificInfo->data
 		) {
@@ -3424,7 +3481,7 @@
 			M4_LOG(GF_LOG_ERROR, ("Invalid MPEG-H audio config\n"));
 		}
 		if (esd) gf_odf_desc_del((GF_Descriptor *)esd);
-		compat_profiles = gf_isom_get_mpegh_compatible_profiles(file, trackNum, 1, &nb_compat_profiles);
+		compat_profiles = gf_isom_get_mpegh_compatible_profiles(file, trackNum, stsd_idx, &nb_compat_profiles);
 		for (i=0; i<nb_compat_profiles; i++) {
 			if (!i)
 				fprintf(stderr, "\tCompatible profiles:");
@@ -3433,33 +3490,33 @@
 		if (i) fprintf(stderr, "\n");
 	} else if (msub_type==GF_ISOM_SUBTYPE_MLPA) {
 		u32 fmt, prate;
-		if (gf_isom_truehd_config_get(file, trackNum, 1, &fmt, &prate) != GF_OK) {
+		if (gf_isom_truehd_config_get(file, trackNum, stsd_idx, &fmt, &prate) != GF_OK) {
 			fprintf(stderr, "\tInvalid TrueHD audio config\n");
 		}
-		fprintf(stderr, "TrueHD Audio stream - Sample Rate %u - channels %u - format %u peak rate %u\n", sr, nb_ch, fmt, prate);
+		fprintf(stderr, "\tTrueHD Audio stream - Sample Rate %u - channels %u - format %u peak rate %u\n", sr, nb_ch, fmt, prate);
 	} else if (codecid) {
 		if (gf_isom_is_video_handler_type(mtype) ) {
 			u32 w, h;
-			gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
-			fprintf(stderr, "%s - Resolution %d x %d\n", gf_codecid_name(codecid), w, h);
+			gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
+			fprintf(stderr, "\t%s - Resolution %d x %d\n", gf_codecid_name(codecid), w, h);
 		} else if (mtype==GF_ISOM_MEDIA_AUDIO) {
-			gf_isom_get_audio_info(file, trackNum, 1, &sr, &nb_ch, NULL);
-			fprintf(stderr, "%s - Sample Rate %d - %d channel(s)\n", gf_codecid_name(codecid), sr, nb_ch);
+			gf_isom_get_audio_info(file, trackNum, stsd_idx, &sr, &nb_ch, NULL);
+			fprintf(stderr, "\t%s - Sample Rate %d - %d channel(s)\n", gf_codecid_name(codecid), sr, nb_ch);
 		} else {
-			fprintf(stderr, "%s\n", gf_codecid_name(codecid) );
+			fprintf(stderr, "\t%s\n", gf_codecid_name(codecid) );
 		}
 	} else if (pfmt) {
 		u32 w, h;
-		gf_isom_get_visual_info(file, trackNum, 1, &w, &h);
-		fprintf(stderr, "Raw video %s - Resolution %d x %d\n", gf_pixel_fmt_name(pfmt), w, h);
+		gf_isom_get_visual_info(file, trackNum, stsd_idx, &w, &h);
+		fprintf(stderr, "\tRaw video %s - Resolution %d x %d\n", gf_pixel_fmt_name(pfmt), w, h);
 	} else if (msub_type==GF_QT_SUBTYPE_TMCD) {
-		u32 stsd_idx;
-		GF_ISOSample *sample = gf_isom_get_sample(file, trackNum, 1, &stsd_idx);
-		fprintf(stderr, "Time Code stream\n");
+		u32 a_stsd_idx;
+		GF_ISOSample *sample = gf_isom_get_sample(file, trackNum, 1, &a_stsd_idx);
+		fprintf(stderr, "\tTime Code stream\n");
 		if (sample) {
 			u32 tmcd_flags, tmcd_num, tmcd_den, tmcd_fpt;
 
-			gf_isom_get_tmcd_config(file, trackNum, stsd_idx, &tmcd_flags, &tmcd_num, &tmcd_den, &tmcd_fpt);
+			gf_isom_get_tmcd_config(file, trackNum, a_stsd_idx, &tmcd_flags, &tmcd_num, &tmcd_den, &tmcd_fpt);
 			if (sample->data) {
 				char szTimecode100;
 				gf_inspect_format_timecode(sample->data, sample->dataLength, tmcd_flags, tmcd_num, tmcd_den, tmcd_fpt, szTimecode);
@@ -3472,27 +3529,27 @@
 	} else {
 		GF_GenericSampleDescription *udesc;
 
-		udesc = gf_isom_get_generic_sample_description(file, trackNum, 1);
+		udesc = gf_isom_get_generic_sample_description(file, trackNum, stsd_idx);
 		if (udesc) {
 			if (gf_isom_is_video_handler_type(mtype) ) {
- fprintf(stderr, "%s - Compressor \"%s\" - Resolution %d x %d\n",
+ fprintf(stderr, "\t%s - Compressor \"%s\" - Resolution %d x %d\n",
 						( (mtype == GF_ISOM_MEDIA_VISUAL ? "Visual" : "Auxiliary Video") ),
 udesc->compressor_name, udesc->width, udesc->height);
 			} else if (mtype==GF_ISOM_MEDIA_AUDIO) {
-				fprintf(stderr, "Audio - Sample Rate %d - %d channel(s)\n", udesc->samplerate, udesc->nb_channels);
+				fprintf(stderr, "\tAudio - Sample Rate %d - %d channel(s)\n", udesc->samplerate, udesc->nb_channels);
 			} else {
-				fprintf(stderr, "Unknown media type\n");
+				fprintf(stderr, "\tUnknown media type\n");
 			}
 			if (udesc->vendor_code)
 				fprintf(stderr, "\tVendor code \"%s\" - Version %d - revision %d\n", gf_4cc_to_str(udesc->vendor_code), udesc->version, udesc->revision);
 
 			if (udesc->extension_buf) {
-				fprintf(stderr, "\tCodec configuration data size: %d bytes\n", udesc->extension_buf_size);
+				fprintf(stderr, "\tCodec configuration data size: %d bytes\n", w_dsisize ? w_dsisize : udesc->extension_buf_size);
 				gf_free(udesc->extension_buf);
 			}
 			gf_free(udesc);
 		} else {
-			fprintf(stderr, "Unknown track type\n");
+			fprintf(stderr, "\tUnknown media type\n");
 		}
 	}
 
@@ -3504,8 +3561,8 @@
 		u32 IV_size;
 		Bool use_sel_enc;
 
-		if (gf_isom_is_ismacryp_media(file, trackNum, 1)) {
-			gf_isom_get_ismacryp_info(file, trackNum, 1, NULL, &scheme_type, &version, &scheme_URI, &KMS_URI, &use_sel_enc, &IV_size, NULL);
+		if (gf_isom_is_ismacryp_media(file, trackNum, stsd_idx)) {
+			gf_isom_get_ismacryp_info(file, trackNum, stsd_idx, NULL, &scheme_type, &version, &scheme_URI, &KMS_URI, &use_sel_enc, &IV_size, NULL);
 			fprintf(stderr, "\n\tProtected by ISMA E&A scheme %s (version %d)\n", gf_4cc_to_str(scheme_type), version);
 			if (scheme_URI) fprintf(stderr, "scheme location: %s\n", scheme_URI);
 			if (KMS_URI) {
@@ -3514,11 +3571,11 @@
 			}
 			fprintf(stderr, "\tSelective Encryption: %s\n", use_sel_enc ? "Yes" : "No");
 			if (IV_size) fprintf(stderr, "\tInitialization Vector size: %d bits\n", IV_size*8);
-		} else if (gf_isom_is_omadrm_media(file, trackNum, 1)) {
+		} else if (gf_isom_is_omadrm_media(file, trackNum, stsd_idx)) {
 			const char *textHdrs;
 			u32 enc_type, hdr_len;
 			u64 orig_len;
-			gf_isom_get_omadrm_info(file, trackNum, 1, NULL, &scheme_type, &version, &scheme_URI, &KMS_URI, &textHdrs, &hdr_len, &orig_len, &enc_type, &use_sel_enc, &IV_size, NULL);
+			gf_isom_get_omadrm_info(file, trackNum, stsd_idx, NULL, &scheme_type, &version, &scheme_URI, &KMS_URI, &textHdrs, &hdr_len, &orig_len, &enc_type, &use_sel_enc, &IV_size, NULL);
 			fprintf(stderr, "\n\tProtected by OMA DRM scheme %s (version %d)\n", gf_4cc_to_str(scheme_type), version);
 			fprintf(stderr, "\tRights Issuer: %s\n", KMS_URI);
 			fprintf(stderr, "\tContent ID: %s\n", scheme_URI);
@@ -3541,15 +3598,15 @@
 			fprintf(stderr, "\tEncryption algorithm %s\n", (enc_type==1) ? "AEA 128 CBC" : (enc_type ? "AEA 128 CTR" : "None"));
 			fprintf(stderr, "\tSelective Encryption: %s\n", use_sel_enc ? "Yes" : "No");
 			if (IV_size) fprintf(stderr, "\tInitialization Vector size: %d bits\n", IV_size*8);
-		} else if(gf_isom_is_cenc_media(file, trackNum, 1)) {
+		} else if(gf_isom_is_cenc_media(file, trackNum, stsd_idx)) {
 			const u8 *def_key;
 			u32 def_key_size;
 			Bool IsEncrypted;
 			u8 crypt_byte_block, skip_byte_block;
 			IV_size = 0;
-			gf_isom_get_cenc_info(file, trackNum, 1, NULL, &scheme_type, &version);
+			gf_isom_get_cenc_info(file, trackNum, stsd_idx, NULL, &scheme_type, &version);
 
-			gf_isom_cenc_get_default_info(file, trackNum, 1, NULL, &IsEncrypted, &crypt_byte_block, &skip_byte_block, &def_key, &def_key_size);
+			gf_isom_cenc_get_default_info(file, trackNum, stsd_idx, NULL, &IsEncrypted, &crypt_byte_block, &skip_byte_block, &def_key, &def_key_size);
 
 			fprintf(stderr, "\n\tProtected by CENC scheme %s version 0x%08X", gf_4cc_to_str(scheme_type), version);
 
@@ -3561,8 +3618,8 @@
 			fprintf(stderr, "\n");
 			dump_key_info(def_key, def_key_size, IsEncrypted);
 
-		} else if(gf_isom_is_adobe_protection_media(file, trackNum, 1)) {
-			gf_isom_get_adobe_protection_info(file, trackNum, 1, NULL, &scheme_type, &version, NULL);
+		} else if(gf_isom_is_adobe_protection_media(file, trackNum, stsd_idx)) {
+			gf_isom_get_adobe_protection_info(file, trackNum, stsd_idx, NULL, &scheme_type, &version, NULL);
 			fprintf(stderr, "\nProtected by Adobe scheme %s (version %d)\n", gf_4cc_to_str(scheme_type), version);
 		} else {
 			fprintf(stderr, "\nProtected by unknown scheme %s\n", gf_4cc_to_str(gf_isom_is_media_encrypted(file, trackNum, 0) ));
@@ -3570,10 +3627,151 @@
 		fprintf(stderr, "\n");
 	}
 
-	if ( gf_media_get_rfc_6381_codec_name(file, trackNum, szCodec, GF_FALSE, GF_FALSE) == GF_OK) {
+	if ( gf_media_get_rfc_6381_codec_name(file, trackNum, stsd_idx, szCodec, GF_FALSE, GF_FALSE) == GF_OK) {
 		fprintf(stderr, "\tRFC6381 Codec Parameters: %s\n", szCodec);
 	}
+}
+
+void DumpTrackInfo(GF_ISOFile *file, GF_ISOTrackID trackID, Bool full_dump, Bool is_track_num, Bool dump_m4sys)
+{
+	Double scale, max_rate, rate;
+	Bool is_od_track = 0;
+	u32 trackNum, i, j, ts, mtype, msub_type, timescale, count, alt_group, nb_groups, nb_edits, cdur, csize;
+	u64 time_slice, dur, size;
+	s32 cts_shift;
+	char szDur50;
+	char *lang;
+
+	if (!is_track_num) {
+		trackNum = gf_isom_get_track_by_id(file, trackID);
+	} else {
+		trackNum = trackID;
+		trackID = gf_isom_get_track_id(file, trackNum);
+	}
+	if (!trackNum) {
+		M4_LOG(GF_LOG_ERROR, ("No track with ID %d found\n", trackID));
+		return;
+	}
+
+	timescale = gf_isom_get_media_timescale(file, trackNum);
+	fprintf(stderr, "# Track %d Info - ID %d - TimeScale %d\n", trackNum, trackID, timescale);
+
+	dur = gf_isom_get_media_original_duration(file, trackNum);
+	size = gf_isom_get_media_duration(file, trackNum);
+	fprintf(stderr, "Media Duration %s ", format_duration(dur, timescale, szDur));
+	if (dur != size)
+		fprintf(stderr, " (recomputed %s)", format_duration(size, timescale, szDur));
+	fprintf(stderr, "\n");
+
+	if (gf_isom_check_data_reference(file, trackNum, 1) != GF_OK) {
+		M4_LOG(GF_LOG_WARNING, ("Track uses external data reference not supported by GPAC!\n"));
+	}
+
+	nb_edits = gf_isom_get_edits_count(file, trackNum);
+	if (nb_edits)
+		fprintf(stderr, "Track has %d edits: track duration is %s\n", nb_edits, format_duration(gf_isom_get_track_duration(file, trackNum), gf_isom_get_timescale(file), szDur));
+
+	cts_shift = gf_isom_get_composition_offset_shift(file, trackNum);
+	if (cts_shift)
+		fprintf(stderr, "Track composition offset shift (negative CTS offset): %d\n", cts_shift);
+
+	if (gf_isom_is_track_in_root_od(file, trackNum) ) fprintf(stderr, "Track is present in Root OD\n");
+
+	u32 tk_flags = gf_isom_get_track_flags(file, trackNum);
+	fprintf(stderr, "Track flags:");
+	if (tk_flags & GF_ISOM_TK_ENABLED) fprintf(stderr, " Enabled");
+	else fprintf(stderr, " Disabled");
+	if (tk_flags & GF_ISOM_TK_IN_MOVIE) fprintf(stderr, " In Movie");
+	if (tk_flags & GF_ISOM_TK_IN_PREVIEW) fprintf(stderr, " In Preview");
+	if (tk_flags & GF_ISOM_TK_SIZE_IS_AR) fprintf(stderr, " Size is AspectRatio");
+	fprintf(stderr, "\n");
+
+	gf_isom_get_media_language(file, trackNum, &lang);
+	if (lang && strcmp(lang, "und"))
+		fprintf(stderr, "Media Language: %s (%s)\n", GetLanguage(lang), lang );
+	if (lang) gf_free(lang);
+
+	mtype = gf_isom_get_media_type(file, trackNum);
+	msub_type = gf_isom_get_mpeg4_subtype(file, trackNum, 1);
+	if (!msub_type) msub_type = gf_isom_get_media_subtype(file, trackNum, 1);
+
+	fprintf(stderr, "Media Samples: %d\n", gf_isom_get_sample_count(file, trackNum));
+
+	count = gf_isom_get_track_kind_count(file, trackNum);
+	for (i = 0; i < count; i++) {
+		char *kind_scheme, *kind_value;
+		gf_isom_get_track_kind(file, trackNum, i, &kind_scheme, &kind_value);
+		fprintf(stderr, "Kind: %s - %s\n", kind_scheme ? kind_scheme : "null", kind_value ? kind_value : "null");
+		if (kind_scheme) gf_free(kind_scheme);
+		if (kind_value) gf_free(kind_value);
+	}
+
+	if (gf_isom_is_track_fragmented(file, trackID) ) {
+		u32 defaultDuration, defaultSize, defaultDescriptionIndex, defaultRandomAccess;
+		u8 defaultPadding;
+		u16 defaultDegradationPriority;
+		u32 frag_samples;
+		u64 frag_duration;
+		gf_isom_get_fragmented_samples_info(file, trackID, &frag_samples, &frag_duration);
+		fprintf(stderr, "Fragmented track: %d samples - Media Duration %s\n", frag_samples, format_duration(frag_duration, timescale, szDur));
+
+		gf_isom_get_fragment_defaults(file, trackNum, &defaultDuration, &defaultSize, &defaultDescriptionIndex, &defaultRandomAccess, &defaultPadding, &defaultDegradationPriority);
+
+		fprintf(stderr, "Fragment sample defaults: duration %d size %d stsd %d sync %d padding %d degradation_priority %d\n",
+				defaultDuration, defaultSize, defaultDescriptionIndex, defaultRandomAccess,
+				(u32) defaultPadding, (u32) defaultDegradationPriority
+		);
+	}
+
+	if (full_dump) {
+		const char *handler_name;
+		gf_isom_get_handler_name(file, trackNum, &handler_name);
+		fprintf(stderr, "Handler name: %s\n", handler_name);
+	}
+
+	print_udta(file, trackNum, GF_FALSE);
+
+	DumpMetaItem(file, 0, trackNum, "\tTrack Meta");
+
+	if (gf_isom_is_video_handler_type(mtype) ) {
+		s32 tx, ty;
+		u32 w, h;
+
+		gf_isom_get_track_layout_info(file, trackNum, &w, &h, &tx, &ty, NULL);
+		fprintf(stderr, "Visual Track layout: x=%d y=%d width=%d height=%d\n", tx, ty, w, h);
+	}
+
+	gf_isom_get_track_switch_group_count(file, trackNum, &alt_group, &nb_groups);
+	if (alt_group) {
+		fprintf(stderr, "Alternate Group ID %d\n", alt_group);
+		for (i=0; i<nb_groups; i++) {
+			u32 nb_crit, switchGroupID;
+			const u32 *criterias = gf_isom_get_track_switch_parameter(file, trackNum, i+1, &switchGroupID, &nb_crit);
+			if (!nb_crit) {
+				fprintf(stderr, "\tNo criteria in %s group\n", switchGroupID ? "switch" : "alternate");
+			} else {
+				if (switchGroupID) {
+					fprintf(stderr, "\tSwitchGroup ID %d criterias: ", switchGroupID);
+				} else {
+					fprintf(stderr, "\tAlternate Group criterias: ");
+				}
+				for (j=0; j<nb_crit; j++) {
+					if (j) fprintf(stderr, " ");
+					fprintf(stderr, "%s", gf_4cc_to_str(criteriasj) );
+				}
+				fprintf(stderr, "\n");
+			}
+		}
+	}
 
+	count = gf_isom_get_sample_description_count(file, trackNum);
+	if (!full_dump && (count>1)) {
+		fprintf(stderr, "Sample Descriptions: %d\n\tuse MP4Box -info %d %s to list all sample descriptions\n", count, trackID, gf_isom_get_filename(file));
+		count = 1;
+	}
+	for (i=0; i<count; i++) {
+		DumpStsdInfo(file, trackNum, full_dump, dump_m4sys, mtype, i+1, &is_od_track);
+	}
 
 	switch (gf_isom_has_sync_points(file, trackNum)) {
 	case 0:
@@ -3643,7 +3841,7 @@
 	}
 	scale = 1000.0 / ts;
 	dur = (u64) (scale * dur);
-	fprintf(stderr, "\tTotal size "LLU" bytes - Total samples duration "LLU" ms\n", size, dur);
+	fprintf(stderr, "\tTotal size "LLU" bytes - Total samples duration "LLU" ms (%s)\n", size, dur, format_duration(dur, 1000, szDur));
 	if (!dur) {
 		fprintf(stderr, "\n");
 		return;
@@ -3689,7 +3887,7 @@
 	u32 i, brand, min, timescale, count, data_len;
 	const u8 *data;
 	u64 create, modif;
-	Bool has_itags = GF_FALSE;
+	Bool has_meta_tags = GF_FALSE;
 	char szDur50;
 
 	DumpMetaItem(file, 1, 0, "# File Meta");
@@ -3797,8 +3995,8 @@
 	}
 
 	if (gf_isom_apple_get_tag(file, 0, &data, &data_len) == GF_OK) {
-		has_itags = GF_TRUE;
-		fprintf(stderr, "\niTunes Info:\n");
+		has_meta_tags = GF_TRUE;
+		fprintf(stderr, "\nMeta-Data Tags:\n");
 
 		i=0;
 		while (1) {
@@ -3850,6 +4048,61 @@
 			fprintf(stderr, "\n");
 		}
 	}
+
+	i=0;
+	while (1) {
+		GF_QT_UDTAKey key;
+		u32 j;
+		GF_Err e = gf_isom_enum_udta_keys(file, i, &key);
+		if (e) break;
+		if (!i && !has_meta_tags) {
+			fprintf(stderr, "\nMeta-Data Tags:\n");
+		}
+		has_meta_tags=GF_TRUE;
+		i++;
+		fprintf(stderr, "\t%s", key.name);
+		if (key.ns && (key.ns!=GF_4CC('m','d','t','a')))
+			fprintf(stderr, " (ns %s)", gf_4cc_to_str(key.ns));
+		fprintf(stderr, ": ");
+		switch (key.type) {
+		case GF_QT_KEY_PNG: fprintf(stderr, "PNG Image (%d bytes)", key.value.data.data_len); break;
+		case GF_QT_KEY_JPEG: fprintf(stderr, "JPG Image (%d bytes)", key.value.data.data_len); break;
+		case GF_QT_KEY_BMP: fprintf(stderr, "BMP Image (%d bytes)", key.value.data.data_len); break;
+		case GF_QT_KEY_UTF8:
+		case GF_QT_KEY_UTF8_SORT: fprintf(stderr, "%s", key.value.string); break;
+
+		case GF_QT_KEY_FLOAT:
+		case GF_QT_KEY_DOUBLE:
+			fprintf(stderr, "%g", key.value.number); break;
+
+		case GF_QT_KEY_SIGNED_8:
+		case GF_QT_KEY_SIGNED_16:
+		case GF_QT_KEY_SIGNED_32:
+		case GF_QT_KEY_SIGNED_64:
+		case GF_QT_KEY_SIGNED_VSIZE:
+			fprintf(stderr, LLD, key.value.sint); break;
+		case GF_QT_KEY_UNSIGNED_8:
+		case GF_QT_KEY_UNSIGNED_16:
+		case GF_QT_KEY_UNSIGNED_32:
+		case GF_QT_KEY_UNSIGNED_64:
+		case GF_QT_KEY_UNSIGNED_VSIZE:
+			fprintf(stderr, LLU, key.value.uint); break;
+		case GF_QT_KEY_POINTF:
+		case GF_QT_KEY_SIZEF:
+			fprintf(stderr, "%gx%g", key.value.pos_size.x, key.value.pos_size.y); break;
+		case GF_QT_KEY_RECTF:
+			fprintf(stderr, "%gx%g@%gx%g", key.value.rect.x, key.value.rect.y, key.value.rect.w, key.value.rect.h); break;
+		case GF_QT_KEY_MATRIXF:
+			for (j=0; j<9; j++) {
+				fprintf(stderr, " %g", key.value.matrixj);
+			}
+			break;
+		default:
+			fprintf(stderr, "type %d size %d", key.type, key.value.data.data_len); break;
+		}
+		fprintf(stderr, "\n");
+	}
+
 	i=0;
 	while (1) {
 		u32 type, version;
@@ -3881,7 +4134,7 @@
 	}
 
 
-	print_udta(file, 0, has_itags);
+	print_udta(file, 0, has_meta_tags);
 	fprintf(stderr, "\n");
 	for (i=0; i<gf_isom_get_track_count(file); i++) {
 		DumpTrackInfo(file, i+1, full_dump, GF_TRUE, dump_m4sys);
@@ -4147,7 +4400,7 @@
 	if (out_name) {
 		char *pid = strrchr(out_name, '#');
 		if (pid) {
-			dumper.dump_pid = atoi(pid+1);
+			dumper.dump_pid = parse_u32(pid+1, "PID");
 			pid0 = 0;
 			sprintf(dumper.dump, "%s_%d.raw", out_name, dumper.dump_pid);
 			dumper.pes_out = gf_fopen(dumper.dump, "wb");

gpac-2.0.0.tar.gz/applications/mp4box/fileimport.c -> gpac-2.2.0.tar.gz/applications/mp4box/fileimport.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / mp4box application
@@ -75,15 +75,12 @@
 		return e;
 	}
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
 	if (!strnicmp(src, "base64", 6)) {
 		src += 7;
 		size = (u32) strlen(src);
 		data = gf_malloc(sizeof(char) * size);
 		size = gf_base64_decode((u8 *)src, size, data, size);
-	} else
-#endif
-	if (is_string) {
+	} else if (is_string) {
 		data = (u8 *) src;
 		size = (u32) strlen(src)+1;
 		is_box_array = 0;
@@ -106,21 +103,26 @@
 
 #ifndef GPAC_DISABLE_MEDIA_IMPORT
 
+#ifndef GPAC_DISABLE_SWF_IMPORT
 extern u32 swf_flags;
+#endif
+
 extern Float swf_flatten_angle;
 extern Bool keep_sys_tracks;
 extern u32 fs_dump_flags;
 
 void scene_coding_log(void *cbk, GF_LOG_Level log_level, GF_LOG_Tool log_tool, const char *fmt, va_list vlist);
 
-void convert_file_info(char *inName, GF_ISOTrackID trackID)
+GF_Err convert_file_info(char *inName, TrackIdentifier *track_id)
 {
 	GF_Err e;
-	u32 i;
+	u32 i, cur=1;
 	Bool found;
 	GF_MediaImporter import;
 	memset(&import, 0, sizeof(GF_MediaImporter));
-	import.trackID = trackID;
+	if (!track_id->type)
+		import.trackID = track_id->ID_or_num;
+
 	import.in_name = inName;
 	import.flags = GF_IMPORT_PROBE_ONLY;
 	import.print_stats_graph = fs_dump_flags;
@@ -128,15 +130,15 @@
 	e = gf_media_import(&import);
 	if (e) {
 		M4_LOG(GF_LOG_ERROR, ("Error probing file %s: %s\n", inName, gf_error_to_string(e)));
-		return;
+		return e;
 	}
-	if (trackID) {
-		fprintf(stderr, "Import probing results for track %s#%d:\n", inName, trackID);
+	if (track_id->ID_or_num) {
+		fprintf(stderr, "Import probing results for %s track %s%d:\n", inName, track_id->type ? "#" : "ID ", track_id->ID_or_num);
 	} else {
 		fprintf(stderr, "Import probing results for %s:\n", inName);
 		if (!import.nb_tracks) {
 			M4_LOG(GF_LOG_WARNING, ("File has no selectable tracks\n"));
-			return;
+			return GF_OK;
 		}
 		fprintf(stderr, "File has %d tracks\n", import.nb_tracks);
 	}
@@ -145,11 +147,31 @@
 	}
 	found = 0;
 	for (i=0; i<import.nb_tracks; i++) {
-		if (trackID && (trackID != import.tk_infoi.track_num)) continue;
-		if (!trackID) fprintf(stderr, "- Track %d type: ", import.tk_infoi.track_num);
+		u32 stype = import.tk_infoi.stream_type;
+		switch (track_id->type) {
+		case 0: //by trackID
+			if (track_id->ID_or_num && (track_id->ID_or_num != import.tk_infoi.track_num) ) continue;
+			break;
+		case 1: //by track nul
+			if (track_id->ID_or_num && (track_id->ID_or_num != i+1) ) continue;
+			break;
+		case 2: //by video
+			if (stype != GF_STREAM_VISUAL) continue;
+			break;
+		case 3: //by audio
+			if (stype != GF_STREAM_AUDIO) continue;
+			break;
+		case 4: //by text
+			if (stype != GF_STREAM_VISUAL) continue;
+			break;
+		}
+		if ((track_id->type>1) && track_id->ID_or_num && (track_id->ID_or_num<cur)) continue;
+		cur++;
+
+		if (!track_id->ID_or_num) fprintf(stderr, "- Track %d type: ", import.tk_infoi.track_num);
 		else fprintf(stderr, "Track type: ");
 
-		switch (import.tk_infoi.stream_type) {
+		switch (stype) {
 		case GF_STREAM_VISUAL:
 			if (import.tk_infoi.media_subtype == GF_ISOM_MEDIA_AUXV) fprintf(stderr, "Auxiliary Video");
 			else if (import.tk_infoi.media_subtype == GF_ISOM_MEDIA_PICT) fprintf(stderr, "Picture Sequence");
@@ -209,16 +231,19 @@
 			fprintf(stderr, "\tSampleRate %d - %d channels\n", import.tk_infoi.audio_info.sample_rate, import.tk_infoi.audio_info.nb_channels);
 		}
 
-		if (trackID) {
+		if (track_id->ID_or_num || (track_id->type>1)) {
 			found = 1;
 			break;
 		}
 	}
 	fprintf(stderr, "\n");
-	M4_LOG(GF_LOG_INFO, ("For more details, use `gpac -i %s inspect:deep:analyze=on|bs`\n", gf_file_basename(inName)));
-	if (!found && trackID) {
-		M4_LOG(GF_LOG_ERROR, ("Cannot find track %d in file\n", trackID));
+
+	if (!found && track_id->ID_or_num) {
+		M4_LOG(GF_LOG_ERROR, ("Cannot find track %d in file\n", track_id->ID_or_num));
+		return GF_BAD_PARAM;
 	}
+	M4_LOG(GF_LOG_INFO, ("For more details, use `gpac -i %s inspect:deep:analyze=on|bs`\n", gf_file_basename(inName)));
+	return GF_OK;
 }
 
 static GF_Err set_chapter_track(GF_ISOFile *file, u32 track, u32 chapter_ref_trak)
@@ -360,7 +385,7 @@
 		else if (!strcmp(sep+1, "hlg2100")) dv_compat_id=4;
 		else if (!strcmp(sep+1, "bt2020")) dv_compat_id=5;
 		else if (!strcmp(sep+1, "brd")) dv_compat_id=6;
-		else if ((sep1>='0') && (sep1<='9')) dv_compat_id=atoi(sep+1);
+		else if ((sep1>='0') && (sep1<='9')) dv_compat_id = parse_u32(sep+1, "DV compatibility mode");
 		else {
 			M4_LOG(GF_LOG_WARNING, ("DV compatibility mode %s not recognized, using none\n", sep+1));
 		}
@@ -373,10 +398,10 @@
 	if (!strcmp(dv_profile_str, "none")) {
 		remove = GF_TRUE;
 	} else {
-		dv_profile = atoi(dv_profile_str);
+		dv_profile = parse_u32(dv_profile_str, "DV profile");
 		if (dv_profile==8) {
-			if ((dv_compat_id!=1) && (dv_compat_id!=2)) {
-				M4_LOG(GF_LOG_ERROR, ("DV profile 8 must indicate a compatibility mode `hdr10` or `bt709`\n"));
+			if ((dv_compat_id!=1) && (dv_compat_id!=2) && (dv_compat_id!=4)) {
+				M4_LOG(GF_LOG_ERROR, ("DV profile 8 must indicate a compatibility mode `hdr10`, `bt709` or `hlg2100`\n"));
 				return GF_BAD_PARAM;
 			}
 		}
@@ -463,9 +488,21 @@
 		gf_isom_sample_del(&samp);
 	}
 
-	u64 mdur = gf_isom_get_media_duration(dest, track);
-	mdur /= nb_samples;
-	u32 timescale = gf_isom_get_media_timescale(dest, track);
+	//get dur and timescale to compute fps
+	//we don't divide mdur by nb_samples but rather multiple timescale with nb_samples
+	//this avoid rounding errors with non FPS-aligned input timescale (eg mkv using 1000 regardless of FPS)
+	u64 mdur;
+	u64 timescale = gf_isom_get_media_timescale(dest, track);
+	mdur = gf_isom_get_media_duration(dest, track);
+	if (timescale % 1000 == 0) {
+		timescale/=1000;
+		mdur/=1000;
+	}
+	else if (timescale % 1001 == 0) {
+		timescale/=1001;
+		mdur/=1001;
+	}
+	timescale *= nb_samples;
 
 	_dovi.dv_level = gf_dolby_vision_level(w, h, timescale, mdur, is_avc ? GF_CODECID_AVC : GF_CODECID_HEVC);
 	return gf_isom_set_dolby_vision_profile(dest, track, 1, &_dovi);
@@ -636,8 +673,9 @@
 	clap_wn = clap_wd = clap_hn = clap_hd = clap_hon = clap_hod = clap_von = clap_vod = 0;
 	GF_ISOMTrackFlagOp track_flags_mode=0;
 	u32 roll_change=0;
-	u32 roll = 0;
+	s32 roll = 0;
 	Bool src_is_isom = GF_FALSE;
+	s32 dlb_mode = -2;
 
 	dv_profile0 = 0;
 	rvc_predefined = 0;
@@ -701,9 +739,13 @@
 	if (ext) ext0 = 0;
 	if (!strlen(final_name) || !strcmp(final_name, "self")) {
 		fake_import = 2;
+		src_is_isom = GF_TRUE;
 	}
+	char *frag = strrchr(final_name, '#');
+	if (frag) frag0 = 0;
 	if (gf_isom_probe_file(final_name))
 		src_is_isom = GF_TRUE;
+	if (frag) frag0 = '#';
 
 	if (ext) ext0 = c_sep;
 
@@ -727,7 +769,7 @@
 			CHECK_FAKEIMPORT("dur")
 
 			if (strchr(ext, '-')) {
-				import.duration.num = atoi(ext+5);
+				import.duration.num = parse_s32(ext+5, "dur");
 				import.duration.den = 1;
 			} else {
 				gf_parse_frac(ext+5, &import.duration);
@@ -746,7 +788,7 @@
 		}
 		else if (!strnicmp(ext+1, "delay=", 6)) {
 			if (sscanf(ext+7, "%d/%u", &delay.num, &delay.den)!=2) {
-				delay.num = atoi(ext+7);
+				delay.num = parse_s32(ext+7, "delay");
 				delay.den = 1000; //in ms
 			}
 		}
@@ -832,12 +874,11 @@
 			do_disable = !stricmp(ext+1, "disable=no") ? 2 : 1;
 		}
 		else if (!strnicmp(ext+1, "group=", 6)) {
-			group = atoi(ext+7);
+			group = parse_u32(ext+7, "group");
 			if (!group) group = gf_isom_get_next_alternate_group_id(dest);
 		}
 		else if (!strnicmp(ext+1, "fps=", 4)) {
 			u32 ticks, dts_inc;
-			CHECK_FAKEIMPORT("fps")
 			if (!strcmp(ext+5, "auto")) {
 				M4_LOG(GF_LOG_ERROR, ("Warning, fps=auto option is deprecated\n"));
 			} else if ((sscanf(ext+5, "%u-%u", &ticks, &dts_inc) == 2) || (sscanf(ext+5, "%u/%u", &ticks, &dts_inc) == 2)) {
@@ -856,7 +897,7 @@
 		else if (!stricmp(ext+1, "rap")) rap_only = 1;
 		else if (!stricmp(ext+1, "refs")) refs_only = 1;
 		else if (!stricmp(ext+1, "trailing")) { CHECK_FAKEIMPORT("trailing") import_flags |= GF_IMPORT_KEEP_TRAILING; }
-		else if (!strnicmp(ext+1, "agg=", 4)) { CHECK_FAKEIMPORT("agg") frames_per_sample = atoi(ext+5); }
+		else if (!strnicmp(ext+1, "agg=", 4)) { CHECK_FAKEIMPORT("agg") frames_per_sample = parse_u32(ext+5, "agg"); }
 		else if (!stricmp(ext+1, "dref")) { CHECK_FAKEIMPORT("dref") import_flags |= GF_IMPORT_USE_DATAREF; }
 		else if (!stricmp(ext+1, "keep_refs")) { CHECK_FAKEIMPORT("keep_refs") import_flags |= GF_IMPORT_KEEP_REFS; }
 		else if (!stricmp(ext+1, "nodrop")) { CHECK_FAKEIMPORT("nodrop") import_flags |= GF_IMPORT_NO_FRAME_DROP; }
@@ -912,7 +953,7 @@
 		else if (!stricmp(ext+1, "xps_inbandx")) { CHECK_FAKEIMPORT("xps_inbandx") xps_inband = 2; }
 		else if (!stricmp(ext+1, "au_delim")) { CHECK_FAKEIMPORT("au_delim") keep_audelim = GF_TRUE; }
 		else if (!strnicmp(ext+1, "max_lid=", 8) || !strnicmp(ext+1, "max_tid=", 8)) {
-			s32 val = atoi(ext+9);
+			s32 val = parse_u32(ext+9, "Max TID/LID");
 			CHECK_FAKEIMPORT_2("max_lid/lhvcmode")
 			if (val < 0) {
 				M4_LOG(GF_LOG_ERROR, ("Warning: request max layer/temporal id is negative - ignoring\n"));
@@ -953,22 +994,22 @@
 
 		else if (!strnicmp(ext+1, "rescale=", 8)) {
 			if (sscanf(ext+9, "%u/%u", &rescale_num, &rescale_den) != 2) {
-				rescale_num = atoi(ext+9);
+				rescale_num = parse_u32(ext+9, "rescale");
 				rescale_den = 0;
 			}
 		}
 		else if (!strnicmp(ext+1, "sampdur=", 8)) {
 			if (sscanf(ext+9, "%u/%u", &rescale_den, &rescale_num) != 2) {
-				rescale_den = atoi(ext+9);
+				rescale_den = parse_u32(ext+9, "sampdur");
 				rescale_num = 0;
 			}
 			rescale_override = GF_TRUE;
 		}
 		else if (!strnicmp(ext+1, "timescale=", 10)) {
-			new_timescale = atoi(ext+11);
+			new_timescale = parse_u32(ext+11, "timescale");
 		}
 		else if (!strnicmp(ext+1, "moovts=", 7)) {
-			moov_timescale = atoi(ext+8);
+			moov_timescale = parse_u32(ext+8, "moovts");
 		}
 
 		else if (!stricmp(ext+1, "noedit")) { import_flags |= GF_IMPORT_NO_EDIT_LIST; }
@@ -987,23 +1028,30 @@
 			else if (!stricmp(ext+9, "extended")) profile = 88;
 			else if (!stricmp(ext+9, "main")) profile = 77;
 			else if (!stricmp(ext+9, "baseline")) profile = 66;
-			else profile = atoi(ext+9);
+			else profile = parse_u32(ext+9, "profile");
 		}
 		else if (!strnicmp(ext+1, "level=", 6)) {
 			if( atof(ext+7) < 6 )
 				level = (int)(10*atof(ext+7)+.5);
 			else
-				level = atoi(ext+7);
+				level = parse_u32(ext+7, "level");
 		}
 		else if (!strnicmp(ext+1, "compat=", 7)) {
-			compat = atoi(ext+8);
+			compat = parse_u32(ext+8, "compat");
+		}
+		else if (!strnicmp(ext+1, "dlba=", 5)) {
+			if (!strcmp(ext+6, "no")) dlb_mode=0;
+			else if (!strcmp(ext+6, "auto")) dlb_mode=-1;
+			else if (sscanf(ext+6, "%d", &dlb_mode) != 1) {
+				GOTO_EXIT("Unrecognized dolby atmos mode")
+			}
 		}
 
 		else if (!strnicmp(ext+1, "novpsext", 8)) { CHECK_FAKEIMPORT("novpsext") import_flags |= GF_IMPORT_NO_VPS_EXTENSIONS; }
 		else if (!strnicmp(ext+1, "keepav1t", 8)) { CHECK_FAKEIMPORT("keepav1t") import_flags |= GF_IMPORT_KEEP_AV1_TEMPORAL_OBU; }
 
 		else if (!strnicmp(ext+1, "font=", 5)) { CHECK_FAKEIMPORT("font") import.fontName = gf_strdup(ext+6); }
-		else if (!strnicmp(ext+1, "size=", 5)) { CHECK_FAKEIMPORT("size") import.fontSize = atoi(ext+6); }
+		else if (!strnicmp(ext+1, "size=", 5)) { CHECK_FAKEIMPORT("size") import.fontSize = parse_u32(ext+6, "size"); }
 		else if (!strnicmp(ext+1, "text_layout=", 12)) {
 			if ( sscanf(ext+13, "%dx%dx%dx%d", &txtw, &txth, &txtx, &txty)==4) {
 				text_layout = 1;
@@ -1058,7 +1106,7 @@
 			}
 		}
 		else if (!strnicmp(ext+1, "rate=", 5)) {
-			force_rate = atoi(ext+6);
+			force_rate = parse_s32(ext+6, "rate");
 		}
 		else if (!stricmp(ext+1, "stats") || !stricmp(ext+1, "fstat"))
 			print_stats_graph |= 1;
@@ -1103,13 +1151,13 @@
 			else
 				M4_LOG(GF_LOG_ERROR, ("Unrecognized audio sample entry mode %s, ignoring\n", mode));
 		}
-		else if (!strnicmp(ext+1, "audio_roll=", 11)) { roll_change = 3; roll = atoi(ext+12); }
-		else if (!strnicmp(ext+1, "roll=", 5)) { roll_change = 1; roll = atoi(ext+6); }
-		else if (!strnicmp(ext+1, "proll=", 6)) { roll_change = 2; roll = atoi(ext+7); }
+		else if (!strnicmp(ext+1, "audio_roll=", 11)) { roll_change = 3; roll = parse_s32(ext+12, "audio_roll"); }
+		else if (!strnicmp(ext+1, "roll=", 5)) { roll_change = 1; roll = parse_s32(ext+6, "roll"); }
+		else if (!strnicmp(ext+1, "proll=", 6)) { roll_change = 2; roll = parse_s32(ext+7, "proll"); }
 		else if (!strcmp(ext+1, "stz2")) {
 			use_stz2 = GF_TRUE;
 		} else if (!strnicmp(ext+1, "bitdepth=", 9)) {
-			bitdepth=atoi(ext+10);
+			bitdepth = parse_u32(ext+10, "bitdepth");
 		}
 		else if (!strnicmp(ext+1, "hdr=", 4)) {
 			hdr_file = gf_strdup(ext+5);
@@ -1154,7 +1202,13 @@
 				GOTO_EXIT("parsing colr option");
 			}
 		}
+		else if (!strnicmp(ext + 1, "dvp=", 4)) {
+			strncpy(dv_profile, ext + 5, 99);
+			dv_profile99=0;
+		}
+		//old name
 		else if (!strnicmp(ext + 1, "dv-profile=", 11)) {
+			M4_LOG(GF_LOG_WARNING, ("Deprecated option name, use `:dvp=` instead\n"));
 			strncpy(dv_profile, ext + 12, 99);
 			dv_profile99=0;
 		}
@@ -1239,13 +1293,13 @@
 			if (!strnicmp(ext+1, "lastsampdur=", 12)) {
 				if (sscanf(ext+13, "%d/%u", &last_sample_dur.num, &last_sample_dur.den)==2) {
 				} else {
-					last_sample_dur.num = atoi(ext+13);
+					last_sample_dur.num = parse_s32(ext+13, "lastsampdur");
 					last_sample_dur.den = 1000;
 				}
 			}
 		}
 		else if (!strnicmp(ext+1, "ID=", 3)) {
-			import.target_trackID = (u32) atoi(ext+4);
+			import.target_trackID = (u32) parse_u32(ext+4, "ID");
 		}
 		/*unrecognized, assume name has colon in it*/
 		else {
@@ -1296,8 +1350,8 @@
 		else if (!strnicmp(ext, "video", 5)) do_video = 1;
 		else if (!strnicmp(ext, "auxv", 4)) do_auxv = 1;
 		else if (!strnicmp(ext, "pict", 4)) do_pict = 1;
-		else if (!strnicmp(ext, "trackID=", 8)) track_id = atoi(&ext8);
-		else track_id = atoi(ext);
+		else if (!strnicmp(ext, "trackID=", 8)) track_id = parse_u32(&ext8, "trackID");
+		else track_id = parse_u32(ext, "ID");
 	}
 	else if (ext) {
 		ext++;
@@ -1314,8 +1368,8 @@
 		else if (!strnicmp(ext, "video", 5)) do_video = 1;
 else if (!strnicmp(ext, "auxv", 4)) do_auxv = 1;
 else if (!strnicmp(ext, "pict", 4)) do_pict = 1;
-		else if (!strnicmp(ext, "trackID=", 8)) track_id = atoi(&ext8);
-		else if (!strnicmp(ext, "PID=", 4)) track_id = atoi(&ext4);
+		else if (!strnicmp(ext, "trackID=", 8)) track_id = parse_u32(&ext8, "trackID");
+		else if (!strnicmp(ext, "PID=", 4)) track_id = parse_u32(&ext4, "ID");
 		else if (!strnicmp(ext, "program=", 8)) {
 			for (i=0; i<import.nb_progs; i++) {
 				if (!stricmp(import.pg_infoi.name, ext+8)) {
@@ -1326,10 +1380,10 @@
 			}
 		}
 		else if (!strnicmp(ext, "prog_id=", 8)) {
-			prog_id = atoi(ext+8);
+			prog_id = parse_u32(ext+8, "prog_id");
 			do_all = 0;
 		}
-		else track_id = atoi(ext);
+		else track_id = parse_u32(ext, "ID");
 
 		//figure out trackID
 		if (do_audio || do_video || do_auxv || do_pict || track_id) {
@@ -1673,6 +1727,17 @@
 				GOTO_EXIT("rescaling media track")
 				break;
 			}
+		} else if (src_is_isom && force_fps.den && force_fps.num) {
+			if (gf_isom_is_video_handler_type(gf_isom_get_media_type(dest, track))) {
+				e = gf_isom_set_media_timescale(dest, track, force_fps.num, force_fps.den, 2);
+ if (e==GF_EOS) {
+					M4_LOG(GF_LOG_WARNING, ("Rescale ignored, same config in source file\n"));
+					e = GF_OK;
+				}
+
+			} else {
+				M4_LOG(GF_LOG_WARNING, ("Cannot force FPS for media types %s - ignoring\n", gf_4cc_to_str( gf_isom_get_media_type(dest, track)) ));
+			}
 		}
 
 		if (has_last_sample_dur) {
@@ -1747,6 +1812,28 @@
 				break;
 			}
 		}
+		if ((dlb_mode>=-1) && (gf_isom_get_media_subtype(dest, track, 1)==GF_ISOM_SUBTYPE_EC3)) {
+			GF_AC3Config *ac3c = gf_isom_ac3_config_get(dest, track, 1);
+			if (ac3c) {
+				if (dlb_mode==0) {
+					ac3c->is_ec3 = GF_TRUE;
+					ac3c->atmos_ec3_ext=0;
+					ac3c->complexity_index_type=0;
+				} else {
+					u32 di;
+					GF_ISOSample *samp = gf_isom_get_sample(dest, track, 1, &di);
+					u32 pos;
+					gf_eac3_parser(samp->data, samp->dataLength, &pos, ac3c, GF_TRUE);
+
+					if (dlb_mode>0) {
+						ac3c->atmos_ec3_ext = 1;
+						ac3c->complexity_index_type = dlb_mode;
+					}
+				}
+				gf_isom_ac3_config_update(dest, track, 1, ac3c);
+				gf_free(ac3c);
+			}
+		}
 	}
 
 	if (chapter_name) {
@@ -1965,14 +2052,14 @@
 }
 
 extern u32 do_flat;
-extern Bool do_frag;
+extern Bool do_frag, use_mfra;
 extern Double interleaving_time;
 
 GF_Err split_isomedia_file(GF_ISOFile *mp4, Double split_dur, u64 split_size_kb, char *inName, Double InterleavingTime, Double chunk_start_time, u32 adjust_split_end, char *outName, Bool force_rap_split, const char *split_range_str, u32 fs_dump_flags)
 {
-	Bool chunk_extraction, rap_split, split_until_end;
+	Bool chunk_extraction, rap_split, split_until_end, use_splitrange=GF_TRUE;
 	GF_Err e;
-	char *ext, szNameGF_MAX_PATH, szFileGF_MAX_PATH+100, szArgs100;
+	char *ext, szNameGF_MAX_PATH, szFileGF_MAX_PATH+100, szArgs1000;
 	Double chunk_start = (Double) chunk_start_time;
 	char *filter_args = NULL;
 	GF_FilterSession *fs;
@@ -2022,7 +2109,8 @@
 		strcat(szFile, "_$num%03d$");
 	}
 
-	gf_dynstrcat(&filter_args, "reframer:splitrange", NULL);
+	gf_dynstrcat(&filter_args, "reframer", NULL);
+
 	if (rap_split) {
 		gf_dynstrcat(&filter_args, ":xs=SAP", NULL);
 	} else if (split_size_kb) {
@@ -2047,34 +2135,68 @@
 		}
 
 		if (split_range_str) {
-			Bool is_time = GF_FALSE;
-			char c;
-			//S-E syntax
-			char *end = (char *) strchr(split_range_str, '-');
-			if (!end) {
-				//S:E syntax
-				end = (char *) strchr(split_range_str, ':');
-				//if another `:` assume time format
-				if (end && strchr(end+1, ':'))
+			Bool first = GF_TRUE;
+			char *xs_a=NULL, *xe_a=NULL;
+			gf_dynstrcat(&xs_a, ":xs=", NULL);
+			gf_dynstrcat(&xe_a, ":xe=", NULL);
+			while (1) {
+				char c;
+				char *next_t = strchr(split_range_str, ',');
+				if (next_t) next_t0 = 0;
+				Bool is_time = GF_FALSE;
+
+				//S-E syntax
+				char *end = (char *) strchr(split_range_str, '-');
+				if (!end) {
+					//S:E syntax
+					end = (char *) strchr(split_range_str, ':');
+					//if another `:` assume time format
+					if (end && strchr(end+1, ':'))
+						is_time = GF_TRUE;
+				} else if (strchr(split_range_str, ':')) {
 					is_time = GF_TRUE;
-			} else if (strchr(split_range_str, ':')) {
-				is_time = GF_TRUE;
-			}
-			if (!end) {
-				gf_free(filter_args);
-				M4_LOG(GF_LOG_ERROR, ("Invalid range specifer %s, expecting START-END or START:END\n", split_range_str ));
-				gf_fs_del(fs);
-				return GF_BAD_PARAM;
-			}
-
-			c = end0;
-			end0 = 0;
-			if (is_time) {
-				sprintf(szArgs, ":xs=T%s:xe=T%s", split_range_str, end+1);
-			} else {
-				sprintf(szArgs, ":xs=%s:xe=%s", split_range_str, end+1);
+				}
+				if (!end) {
+					gf_free(filter_args);
+					M4_LOG(GF_LOG_ERROR, ("Invalid range specifer %s, expecting START-END or START:END\n", split_range_str ));
+					gf_fs_del(fs);
+					if (next_t) next_t0 = ',';
+					return GF_BAD_PARAM;
+				}
+
+				if (!first) {
+					gf_dynstrcat(&xs_a, ",", NULL);
+					gf_dynstrcat(&xe_a, ",", NULL);
+				}
+				first = GF_FALSE;
+				c = end0;
+				end0 = 0;
+				if (is_time) {
+					gf_dynstrcat(&xs_a, "T", NULL);
+					gf_dynstrcat(&xe_a, "T", NULL);
+				}
+				gf_dynstrcat(&xs_a, split_range_str, NULL);
+				gf_dynstrcat(&xe_a, end+1, NULL);
+				end0 = c;
+				if (!next_t) break;
+				next_t0 = ',';
+				split_range_str = next_t + 1;
+			}
+			if (xs_a) {
+				gf_dynstrcat(&filter_args, xs_a, NULL);
+				gf_free(xs_a);
+			}
+			if (xe_a) {
+				gf_dynstrcat(&filter_args, xe_a, NULL);
+				gf_free(xe_a);
+			}
+			szArgs0=0;
+			//if output set and no template, don't use split range
+			if (outName) {
+				xs_a = strchr(outName, '$');
+				if (!xs_a || !strchr(xs_a+1, '$'))
+					use_splitrange = GF_FALSE;
 			}
-			end0 = c;
 		} else if (split_until_end) {
 			Double end=0;
 			if (split_dur<-2) {
@@ -2092,12 +2214,14 @@
 		} else {
 			sprintf(szArgs, ":xs=%u/1000:xe=%u/1000", (u32) (chunk_start*1000), (u32) ((chunk_start+split_dur) * 1000) );
 		}
-		gf_dynstrcat(&filter_args, szArgs, NULL);
+		if (szArgs0)
+			gf_dynstrcat(&filter_args, szArgs, NULL);
+
 		if (!outName) {
 			sprintf(szFile, "%s_$FS$", szName);
 		}
 	} else if (split_dur) {
-		sprintf(szArgs, ":xs=D%u", (u32) (split_dur*1000));
+		sprintf(szArgs, ":xs=D%g", split_dur);
 		gf_dynstrcat(&filter_args, szArgs, NULL);
 		if (adjust_split_end) {
 			gf_dynstrcat(&filter_args, ":xadjust", NULL);
@@ -2109,6 +2233,9 @@
 		return GF_BAD_PARAM;
 	}
 
+	if (use_splitrange)
+		gf_dynstrcat(&filter_args, ":splitrange", NULL);
+
 	reframe = gf_fs_load_filter(fs, filter_args, &e);
 	gf_free(filter_args);
 	filter_args = NULL;
@@ -2155,6 +2282,8 @@
 		sprintf(szArgs, ":cdur=%g", interleaving_time);
 		strcat(szFile, szArgs);
 	}
+	if (use_mfra)
+		strcat(szFile, ":mfra");
 
 	dst = gf_fs_load_destination(fs, szFile, NULL, NULL, &e);
 	if (!dst) {
@@ -2260,7 +2389,8 @@
 		dst_tk = gf_isom_get_track_by_id(dest, tk_id);
 		gf_isom_set_nalu_extract_mode(orig, src_track, GF_ISOM_NALU_EXTRACT_INBAND_PS_FLAG);
 		if (!force_cat) {
-			gf_isom_avc_set_inband_config(dest, dst_tk, 1, GF_FALSE);
+			//set inband config but keep param sets
+			gf_isom_avc_set_inband_config(dest, dst_tk, 1, GF_TRUE);
 		} else {
 			M4_LOG(GF_LOG_WARNING, ("WARNING: Concatenating track ID %d even though sample descriptions do not match\n", tk_id));
 		}
@@ -2316,7 +2446,7 @@
 		dst_tk = gf_isom_get_track_by_id(dest, tk_id);
 		gf_isom_set_nalu_extract_mode(orig, src_track, GF_ISOM_NALU_EXTRACT_INBAND_PS_FLAG);
 		if (!force_cat) {
-			gf_isom_hevc_set_inband_config(dest, dst_tk, 1, GF_FALSE);
+			gf_isom_hevc_set_inband_config(dest, dst_tk, 1, GF_TRUE);
 		} else {
 			M4_LOG(GF_LOG_WARNING, ("WARNING: Concatenating track ID %d even though sample descriptions do not match\n", tk_id));
 		}
@@ -2404,7 +2534,10 @@
 		orig = gf_isom_open("temp", GF_ISOM_WRITE_EDIT, NULL);
 		if (opts) opts0 = ':';
 		e = import_file(orig, fileName, import_flags, force_fps, frames_per_sample, NULL, NULL, NULL, 0);
-		if (e) return e;
+		if (e) {
+			gf_isom_delete(orig);
+			return e;
+		}
 	} else {
 		//open read+edit mode to allow applying options on file
 		orig = gf_isom_open(fileName, GF_ISOM_OPEN_READ_EDIT, NULL);
@@ -2413,7 +2546,10 @@
 
 		if (opts) {
 			e = import_file(orig, fileName, 0xFFFFFFFF, force_fps, frames_per_sample, NULL, NULL, NULL, 0);
-			if (e) return e;
+			if (e) {
+				gf_isom_delete(orig);
+				return e;
+			}
 		}
 	}
 
@@ -2477,7 +2613,11 @@
 	aligned_to_DTS_frac.num = 0;
 	aligned_to_DTS_frac.den = 1;
 	for (i=0; i<gf_isom_get_track_count(dest); i++) {
-		u64 track_dur = gf_isom_get_media_duration(dest, i+1);
+		u32 last_samp = gf_isom_get_sample_count(dest, i+1);
+		if (!last_samp) continue;
+		//get next sample DTS - we do NOT use media duration as CTS offset could shift up everything
+		u64 track_dur = gf_isom_get_sample_dts(dest, i+1, last_samp);
+		track_dur += gf_isom_get_sample_duration(dest, i+1, last_samp);
 		u32 track_ts = gf_isom_get_media_timescale(dest, i+1);
 		if (gf_timestamp_less(aligned_to_DTS_frac.num, aligned_to_DTS_frac.den, track_dur, track_ts)) {
 			aligned_to_DTS_frac.num = track_dur;
@@ -2490,6 +2630,7 @@
 	for (i=0; i<nb_tracks; i++) {
 		u64 last_DTS, dest_track_dur_before_cat;
 		u32 nb_edits = 0;
+		Bool merge_nal_video = 1;
 		Bool skip_lang_test = 1;
 		Bool use_ts_dur = 1;
 		Bool merge_edits = 0;
@@ -2556,6 +2697,7 @@
 				if (subtype_dst != subtype_src) {
 					dst_tk_sample_entry = dst_tk;
 					dst_tk = 0;
+					merge_nal_video=0;
 				}
 			}
 		}
@@ -2630,7 +2772,7 @@
 				}
 			}
 
-			if (!dst_tk) {
+			if (!dst_tk && merge_nal_video) {
 				/*merge AVC config if possible*/
 				if ((stype == GF_ISOM_SUBTYPE_AVC_H264)
 				 || (stype == GF_ISOM_SUBTYPE_AVC2_H264)
@@ -2742,6 +2884,10 @@
 
 		gf_isom_enable_raw_pack(orig, i+1, 2048);
 
+		Bool adjust_first_sample=GF_FALSE;
+		if (count && (gf_isom_get_sample_duration(dest, dst_tk, count)==0)) {
+			adjust_first_sample = GF_TRUE;
+		}
 		last_DTS = 0;
 		count = gf_isom_get_sample_count(orig, i+1);
 		for (j=0; j<count; j++) {
@@ -2755,6 +2901,10 @@
 			last_DTS = samp->DTS;
 			samp->DTS = (u64) (ts_scale * samp->DTS + (new_track ? 0 : insert_dts));
 			samp->CTS_Offset = (u32) (samp->CTS_Offset * ts_scale);
+			if (adjust_first_sample) {
+				samp->DTS++;
+				adjust_first_sample = 0;
+			}
 
 			if (gf_isom_is_self_contained(orig, i+1, di)) {
 				if (orig_nal_len && dst_nal_len) {
@@ -2788,6 +2938,8 @@
 			gf_set_progress("Appending", nb_done, nb_samp);
 			nb_done++;
 		}
+		gf_isom_update_duration(dest);
+
 		/*scene description and text: compute last sample duration based on original media duration*/
 		if (!use_ts_dur) {
 			u64 extend_dur = gf_isom_get_media_duration(orig, i+1) - last_DTS;
@@ -2806,10 +2958,6 @@
 			gf_isom_set_edit(dest, dst_tk, 0, (u64) (s64) (insert_dts*rescale), 0, GF_ISOM_EDIT_EMPTY);
 			gf_isom_set_edit(dest, dst_tk, (u64) (s64) (insert_dts*rescale), (u64) (s64) (media_dur*rescale), 0, GF_ISOM_EDIT_NORMAL);
 		} else if (merge_edits) {
-			/*convert from media time to track time*/
-			u32 movts_dst = gf_isom_get_timescale(dest);
-			u32 trackts_dst = gf_isom_get_media_timescale(dest, dst_tk);
-			u32 trackts_orig = gf_isom_get_media_timescale(orig, i+1);
 
 			/*get the first edit normal mode and add the new track dur*/
 			for (j=nb_edits; j>0; j--) {
@@ -2818,23 +2966,14 @@
 				gf_isom_get_edit(dest, dst_tk, j, &editTime, &segmentDuration, &mediaTime, &editMode);
 
 				if (editMode==GF_ISOM_EDIT_NORMAL) {
-					Double prev_dur = (Double) (s64) dest_track_dur_before_cat;
-					Double dur = (Double) (s64) gf_isom_get_media_duration(orig, i+1);
-
-					/*safety test: some files have broken edit lists. If no more than 2 entries, check that the segment duration
-					is less or equal to the movie duration*/
-					if (prev_dur * movts_dst < segmentDuration * trackts_dst) {
-						M4_LOG(GF_LOG_WARNING, ("Warning: suspicious edit list entry found: duration %g sec but longest track duration before cat is %g - fixing it\n", (Double) (s64) segmentDuration/movts_dst, prev_dur/trackts_dst));
-						segmentDuration = (dest_track_dur_before_cat - mediaTime) * movts_dst;
-						segmentDuration /= trackts_dst;
-					}
-
-					//express original dur in new timescale
-					dur /= trackts_orig;
-					dur *= movts_dst;
-
-					segmentDuration += (u64) (s64) dur;
-					gf_isom_modify_edit(dest, dst_tk, j, segmentDuration, mediaTime, editMode);
+					u64 new_dur = gf_isom_get_media_duration(dest, dst_tk);
+					if ((mediaTime>0) && (mediaTime<new_dur))
+						new_dur -= mediaTime;
+					/*convert from media time to track/moov time*/
+					u32 movts_dst = gf_isom_get_timescale(dest);
+					u32 trackts_dst = gf_isom_get_media_timescale(dest, dst_tk);
+					new_dur = gf_timestamp_rescale(new_dur, trackts_dst, movts_dst);
+					gf_isom_modify_edit(dest, dst_tk, j, new_dur, mediaTime, editMode);
 					break;
 				}
 			}
@@ -2861,6 +3000,7 @@
 				if (segmentDuration)
 					gf_isom_set_edit(dest, dst_tk, editTime, segmentDuration, mediaTime, GF_ISOM_EDIT_NORMAL);
 			} else {
+				mediaTime = 0;
 				editTime = 0;
 				segmentDuration = 0;
 			}
@@ -2890,6 +3030,13 @@
 				}
 				gf_isom_set_edit(dest, dst_tk, editTime, segmentDuration, mediaTime, editMode);
 			}
+			//no edit in added track, add duration
+			if (!count && (segmentDuration || mediaTime) && gf_isom_get_edits_count(dest, dst_tk)) {
+				t = (Double) (s64) gf_isom_get_media_duration(orig, i+1);
+				t *= gf_isom_get_timescale(dest);
+				t /= gf_isom_get_media_timescale(orig, i+1);
+				gf_isom_set_edit(dest, dst_tk, editTime, segmentDuration+(u64) t, mediaTime, editMode);
+			}
 		}
 		gf_media_update_bitrate(dest, dst_tk);
 
@@ -3100,7 +3247,9 @@
 	memset(&load, 0, sizeof(GF_SceneLoader));
 	load.fileName = in;
 	load.ctx = ctx;
+#ifndef GPAC_DISABLE_SWF_IMPORT
 	load.swf_import_flags = swf_flags;
+#endif
 	load.swf_flatten_limit = swf_flatten_angle;
 	/*since we're encoding we must get MPEG4 nodes only*/
 	load.flags = GF_SM_LOAD_MPEG4_STRICT;
@@ -3362,10 +3511,11 @@
 			if (data) {
 				sprintf(szName, "%s-%02d-%02d.bifs", szRad, sc->ESID, j);
 				f = gf_fopen(szName, "wb");
-				gf_fwrite(data, data_len, f);
+				if (gf_fwrite(data, data_len, f) != data_len) e = GF_IO_ERR;
 				gf_fclose(f);
 				gf_free(data);
 			}
+			if (e) break;
 		}
 		if (delete_esd) gf_odf_desc_del((GF_Descriptor*)esd);
 	}
@@ -3484,7 +3634,6 @@
 #endif /*GPAC_DISABLE_MEDIA_IMPORT*/
 
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
 void sax_node_start(void *sax_cbck, const char *node_name, const char *name_space, const GF_XMLAttribute *attributes, u32 nb_attributes)
 {
 	char szCheck100;
@@ -3769,7 +3918,7 @@
 			j = 0;
 			while ((att = gf_list_enum(stream->attributes, &j))) {
 				if (!strcmp(att->name, "id")) {
-					u32 id = atoi(att->value);
+					u32 id = parse_u32(att->value, "id");
 					track = gf_isom_get_track_by_id(movie, id);
 					if (!track) {
 						fprintf(stderr, "HDR XML: no track with ID %d, ignoring attribute\n", id);
@@ -3788,23 +3937,23 @@
 			if (!strcmp(box->name, "mdcv")) {
 				k = 0;
 				while ((att = gf_list_enum(box->attributes, &k))) {
-					if (!strcmp(att->name, "display_primaries_0_x")) mdcv.display_primaries0.x = atoi(att->value);
-					else if (!strcmp(att->name, "display_primaries_0_y")) mdcv.display_primaries0.y = atoi(att->value);
-					else if (!strcmp(att->name, "display_primaries_1_x")) mdcv.display_primaries1.x = atoi(att->value);
-					else if (!strcmp(att->name, "display_primaries_1_y")) mdcv.display_primaries1.y = atoi(att->value);
-					else if (!strcmp(att->name, "display_primaries_2_x")) mdcv.display_primaries2.x = atoi(att->value);
-					else if (!strcmp(att->name, "display_primaries_2_y")) mdcv.display_primaries2.y = atoi(att->value);
-					else if (!strcmp(att->name, "white_point_x")) mdcv.white_point_x = atoi(att->value);
-					else if (!strcmp(att->name, "white_point_y")) mdcv.white_point_y = atoi(att->value);
-					else if (!strcmp(att->name, "max_display_mastering_luminance")) mdcv.max_display_mastering_luminance = atoi(att->value);
-					else if (!strcmp(att->name, "min_display_mastering_luminance")) mdcv.min_display_mastering_luminance = atoi(att->value);
+					if (!strcmp(att->name, "display_primaries_0_x")) mdcv.display_primaries0.x = parse_u32(att->value, "display_primaries_0_x");
+					else if (!strcmp(att->name, "display_primaries_0_y")) mdcv.display_primaries0.y = parse_u32(att->value, "display_primaries_0_y");
+					else if (!strcmp(att->name, "display_primaries_1_x")) mdcv.display_primaries1.x = parse_u32(att->value, "display_primaries_1_x");
+					else if (!strcmp(att->name, "display_primaries_1_y")) mdcv.display_primaries1.y = parse_u32(att->value, "display_primaries_1_y");
+					else if (!strcmp(att->name, "display_primaries_2_x")) mdcv.display_primaries2.x = parse_u32(att->value, "display_primaries_2_x");
+					else if (!strcmp(att->name, "display_primaries_2_y")) mdcv.display_primaries2.y = parse_u32(att->value, "display_primaries_2_y");
+					else if (!strcmp(att->name, "white_point_x")) mdcv.white_point_x = parse_u32(att->value, "white_point_x");
+					else if (!strcmp(att->name, "white_point_y")) mdcv.white_point_y = parse_u32(att->value, "white_point_y");
+					else if (!strcmp(att->name, "max_display_mastering_luminance")) mdcv.max_display_mastering_luminance = parse_u32(att->value, "max_display_mastering_luminance");
+					else if (!strcmp(att->name, "min_display_mastering_luminance")) mdcv.min_display_mastering_luminance = parse_u32(att->value, "min_display_mastering_luminance");
 					else fprintf(stderr, "HDR XML: ignoring box \"%s\" attribute \"%s\"\n", box->name, att->name);
 				}
 			} else if (!strcmp(box->name, "clli")) {
 				k = 0;
 				while ((att = gf_list_enum(box->attributes, &k))) {
-					if (!strcmp(att->name, "max_content_light_level")) clli.max_content_light_level = atoi(att->value);
-					else if (!strcmp(att->name, "max_pic_average_light_level")) clli.max_pic_average_light_level = atoi(att->value);
+					if (!strcmp(att->name, "max_content_light_level")) clli.max_content_light_level = parse_u32(att->value, "max_content_light_level");
+					else if (!strcmp(att->name, "max_pic_average_light_level")) clli.max_pic_average_light_level = parse_u32(att->value, "max_pic_average_light_level");
 					else fprintf(stderr, "HDR XML: ignoring box \"%s\" attribute \"%s\"\n", box->name, att->name);
 				}
 			} else {
@@ -3833,20 +3982,6 @@
 	return e;
 }
 
-#else
-GF_ISOFile *package_file(char *file_name, char *fcc, Bool make_wgt)
-{
-	M4_LOG(GF_LOG_ERROR, ("XML Not supported in this build of GPAC - cannot package file\n"));
-	return NULL;
-}
-
-GF_Err parse_high_dynamc_range_xml_desc(GF_ISOFile* movie, u32 track, char* file_name)
-{
-	M4_LOG(GF_LOG_ERROR, ("XML Not supported in this build of GPAC - cannot process HDR parameter file\n"));
-	return GF_OK;
-}
-#endif //#ifndef GPAC_DISABLE_CORE_TOOLS
-
 
 #endif /*GPAC_DISABLE_ISOM_WRITE*/

gpac-2.0.0.tar.gz/applications/mp4box/live.c -> gpac-2.2.0.tar.gz/applications/mp4box/live.c Changed

@@ -370,23 +370,23 @@
 		char *arg = argvi;
 		if (arg0 != '-') filename = arg;
 		else if (!strnicmp(arg, "-dst=", 5)) dst = arg+5;
-		else if (!strnicmp(arg, "-port=", 6)) dst_port = atoi(arg+6);
+		else if (!strnicmp(arg, "-port=", 6)) dst_port = parse_u32(arg+6, "port");
 		else if (!strnicmp(arg, "-sdp=", 5)) sdp_name = arg+5;
-		else if (!strnicmp(arg, "-mtu=", 5)) path_mtu = atoi(arg+5);
-		else if (!strnicmp(arg, "-ttl=", 5)) ttl = atoi(arg+5);
+		else if (!strnicmp(arg, "-mtu=", 5)) path_mtu = parse_u32(arg+5, "mtu");
+		else if (!strnicmp(arg, "-ttl=", 5)) ttl = parse_u32(arg+5, "ttl");
 		else if (!strnicmp(arg, "-no-rap", 7)) no_rap = 1;
 		else if (!strnicmp(arg, "-dims", 5)) load_type = GF_SM_LOAD_DIMS;
 		else if (!strnicmp(arg, "-src=", 5)) src_name = arg+5;
 		else if (!strnicmp(arg, "-udp=", 5)) {
-			sk_port = atoi(arg+5);
+			sk_port = parse_u32(arg+5, "udp");
 			udp = 1;
 		}
 		else if (!strnicmp(arg, "-tcp=", 5)) {
-			sk_port = atoi(arg+5);
+			sk_port = parse_u32(arg+5, "tcp");
 			udp = 0;
 		}
 		else if (!stricmp(arg, "-run-for")) {
-			runfor = 1 + 1000 * atoi(argvi+1);
+			runfor = 1 + 1000 * parse_u32(argvi+1, "run-for");
 			i++;
 		}
 	}
@@ -598,18 +598,18 @@
 					while (1) {
 						char *sep = strchr(flag, ' ');
 						if (sep) sep0 = 0;
-						if (!strnicmp(flag, "esid=", 5)) es_id = atoi(flag+5);
-						else if (!strnicmp(flag, "period=", 7)) period = atoi(flag+7);
-						else if (!strnicmp(flag, "ts=", 3)) ts_delta = atoi(flag+3);
-						else if (!strnicmp(flag, "carousel=", 9)) aggregate_on_stream = atoi(flag+9);
-						else if (!strnicmp(flag, "restamp=", 8)) adjust_carousel_time = atoi(flag+8);
-
-						else if (!strnicmp(flag, "discard=", 8)) discard_pending = atoi(flag+8);
-						else if (!strnicmp(flag, "aggregate=", 10)) aggregate_au = atoi(flag+10);
-						else if (!strnicmp(flag, "force_rap=", 10)) force_rap = atoi(flag+10);
-						else if (!strnicmp(flag, "rap=", 4)) signal_rap = atoi(flag+4);
-						else if (!strnicmp(flag, "critical=", 9)) signal_critical = atoi(flag+9);
-						else if (!strnicmp(flag, "vers_inc=", 9)) version_inc = atoi(flag+9);
+						if (!strnicmp(flag, "esid=", 5)) es_id = parse_u32(flag+5, "esid");
+						else if (!strnicmp(flag, "period=", 7)) period = parse_u32(flag+7, "period");
+						else if (!strnicmp(flag, "ts=", 3)) ts_delta = parse_u32(flag+3, "ts");
+						else if (!strnicmp(flag, "carousel=", 9)) aggregate_on_stream = parse_u32(flag+9, "carousel");
+						else if (!strnicmp(flag, "restamp=", 8)) adjust_carousel_time = parse_u32(flag+8, "restamp");
+
+						else if (!strnicmp(flag, "discard=", 8)) discard_pending = parse_u32(flag+8, "discard");
+						else if (!strnicmp(flag, "aggregate=", 10)) aggregate_au = parse_u32(flag+10, "aggregate");
+						else if (!strnicmp(flag, "force_rap=", 10)) force_rap = parse_u32(flag+10, "force_rap");
+						else if (!strnicmp(flag, "rap=", 4)) signal_rap = parse_u32(flag+4, "rap");
+						else if (!strnicmp(flag, "critical=", 9)) signal_critical = parse_u32(flag+9, "critical");
+						else if (!strnicmp(flag, "vers_inc=", 9)) version_inc = parse_u32(flag+9, "vers_inc");
 						if (sep) {
 							sep0 = ' ';
 							flag = sep+1;

gpac-2.2.0.tar.gz/applications/mp4box/mp4box.c Added

@@ -0,0 +1,6851 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2000-2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / mp4box application
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+
+#include "mp4box.h"
+
+#ifdef GPAC_DISABLE_ISOM
+
+#error "Cannot compile MP4Box if GPAC is not built with ISO File Format support"
+
+#else
+
+#if defined(WIN32) && !defined(_WIN32_WCE)
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+#include <gpac/media_tools.h>
+#include <gpac/main.h>
+
+/*RTP packetizer flags*/
+#ifndef GPAC_DISABLE_STREAMING
+#include <gpac/ietf.h>
+#endif
+
+#ifndef GPAC_DISABLE_CRYPTO
+#include <gpac/crypt_tools.h>
+#endif
+
+#include <gpac/constants.h>
+#include <gpac/filters.h>
+
+#include <gpac/mpd.h>
+
+#define BUFFSIZE	8192
+#define DEFAULT_INTERLEAVING_IN_SEC 0.5
+
+//undefine to check validity of defined args' syntax
+//#define TEST_ARGS
+
+
+static u32 mp4box_cleanup(u32 ret_code);
+
+/*
+ * 		START OF ARGUMENT VALUES DECLARATION
+ */
+
+
+
+typedef struct
+{
+	TrackIdentifier track_id;
+	char *line;
+} SDPLine;
+
+typedef enum {
+	META_ACTION_SET_TYPE			= 0,
+	META_ACTION_ADD_ITEM			= 1,
+	META_ACTION_REM_ITEM			= 2,
+	META_ACTION_SET_PRIMARY_ITEM	= 3,
+	META_ACTION_SET_XML				= 4,
+	META_ACTION_SET_BINARY_XML		= 5,
+	META_ACTION_REM_XML				= 6,
+	META_ACTION_DUMP_ITEM			= 7,
+	META_ACTION_DUMP_XML			= 8,
+	META_ACTION_ADD_IMAGE_ITEM		= 9,
+	META_ACTION_ADD_IMAGE_DERIVED	= 10,
+} MetaActionType;
+
+typedef struct {
+	u32 ref_item_id;
+	u32 ref_type;
+} MetaRef;
+
+typedef struct
+{
+	MetaActionType act_type;
+	Bool root_meta, use_dref;
+	TrackIdentifier track_id;
+	u32 meta_4cc;
+	char *szPath, *szName, *mime_type, *enc_type, *keep_props;
+	u32 item_id;
+	Bool primary;
+	Bool replace;
+	u32 item_type;
+	u32 ref_item_id;
+	GF_List *item_refs;
+	u32 group_id;
+	u32 group_type;
+	GF_ImageItemProperties *image_props;
+} MetaAction;
+
+
+typedef enum {
+	TRACK_ACTION_REM_TRACK= 0,
+	TRACK_ACTION_SET_LANGUAGE,
+	TRACK_ACTION_SET_DELAY,
+	TRACK_ACTION_SET_KMS_URI,
+	TRACK_ACTION_SET_PAR,
+	TRACK_ACTION_SET_HANDLER_NAME,
+	TRACK_ACTION_ENABLE,
+	TRACK_ACTION_DISABLE,
+	TRACK_ACTION_REFERENCE,
+	TRACK_ACTION_RAW_EXTRACT,
+	TRACK_ACTION_REM_NON_RAP,
+	TRACK_ACTION_SET_KIND,
+	TRACK_ACTION_REM_KIND,
+	TRACK_ACTION_SET_ID,
+	TRACK_ACTION_SET_UDTA,
+	TRACK_ACTION_SWAP_ID,
+	TRACK_ACTION_REM_NON_REFS,
+	TRACK_ACTION_SET_CLAP,
+	TRACK_ACTION_SET_MX,
+	TRACK_ACTION_SET_EDITS,
+	TRACK_ACTION_SET_TIME,
+	TRACK_ACTION_SET_MEDIA_TIME,
+} TrackActionType;
+
+#define LANG_SIZE	50
+typedef struct
+{
+	TrackActionType act_type;
+	TrackIdentifier target_track;
+	char langLANG_SIZE;
+	GF_Fraction delay;
+	const char *kms;
+	const char *hdl_name;
+	s32 par_num, par_den;
+	u8 force_par, rewrite_bs;
+	u32 dump_type, sample_num;
+	char *out_name;
+	char *src_name;
+	char *string;
+	u32 udta_type;
+	char *kind_scheme, *kind_value;
+	TrackIdentifier newTrackID;
+	s32 clap_wnum, clap_wden, clap_hnum, clap_hden, clap_honum, clap_hoden, clap_vonum, clap_voden;
+	s32 mx9;
+	u64 time;
+} TrackAction;
+
+enum
+{
+	GF_ISOM_CONV_TYPE_ISMA = 1,
+	GF_ISOM_CONV_TYPE_ISMA_EX,
+	GF_ISOM_CONV_TYPE_3GPP,
+	GF_ISOM_CONV_TYPE_IPOD,
+	GF_ISOM_CONV_TYPE_PSP,
+	GF_ISOM_CONV_TYPE_MOV
+};
+
+typedef enum {
+	TSEL_ACTION_SET_PARAM = 0,
+	TSEL_ACTION_REMOVE_TSEL = 1,
+	TSEL_ACTION_REMOVE_ALL_TSEL_IN_GROUP = 2,
+} TSELActionType;
+
+typedef struct
+{
+	TSELActionType act_type;
+	TrackIdentifier target_track;
+	TrackIdentifier reference_track;
+
+	u32 criteria30;
+	u32 nb_criteria;
+	Bool is_switchGroup;
+	u32 switchGroupID;
+} TSELAction;
+
+GF_FileType get_file_type_by_ext(char *inName);
+
+//All static variables - DO NOT set init value here, use \ref init_global_vars
+char outfileGF_MAX_PATH;
+
+#ifndef GPAC_DISABLE_SCENE_ENCODER
+GF_SMEncodeOptions smenc_opts;
+u32 swf_flags;
+#endif
+GF_Fraction import_fps;
+
+#ifdef GPAC_CONFIG_ANDROID
+u32 mp4b_help_flags;
+FILE *mp4b_helpout;
+
+#define help_flags mp4b_help_flags
+#define helpout mp4b_helpout
+
+#else
+FILE *helpout;
+u32 help_flags;
+#endif
+
+Double interleaving_time, split_duration, split_start, dash_duration, dash_subduration, swf_flatten_angle, mpd_live_duration, min_buffer, mpd_update_time;
+
+Bool arg_parse_res, dash_duration_strict, dvbhdemux, keep_sys_tracks, align_cat;
+Bool do_hint, do_save, full_interleave, do_frag, hint_interleave, dump_rtp, regular_iod, remove_sys_tracks, remove_hint, remove_root_od;
+Bool print_sdp, open_edit, dump_cr, force_ocr, encode, do_scene_log, dump_srt, dump_ttxt, do_saf, dump_m2ts, dump_cart, dump_chunk, dump_check_xml;
+Bool do_hash, verbose, force_cat, pack_wgt, single_group, clean_groups, dash_live, no_fragments_defaults, single_traf_per_moof, tfdt_per_traf;
+Bool hls_clock, do_mpd_rip, merge_vtt_cues, get_nb_tracks, no_inplace, merge_last_seg, freeze_box_order, no_odf_conf;
+Bool insert_utc, chunk_mode, HintCopy, hint_no_offset, do_bin_xml, frag_real_time, force_co64, live_scene, use_mfra, dump_iod, samplegroups_in_traf;
+Bool mvex_after_traks, daisy_chain_sidx, use_ssix, single_segment, single_file, segment_timeline, has_add_image;
+Bool strict_cues, use_url_template, seg_at_rap, frag_at_rap, memory_frags, keep_utc, has_next_arg, no_cache, no_loop;
+
+u32 stat_level, hint_flags, import_flags, nb_add, nb_cat, crypt, agg_samples, nb_sdp_ex, max_ptime, split_size, nb_meta_act;
+u32 nb_track_act, rtp_rate, major_brand, nb_alt_brand_add, nb_alt_brand_rem, old_interleave, minor_version, conv_type, nb_tsel_acts;
+u32 program_number, time_shift_depth, initial_moof_sn, dump_std, import_subtitle, dump_saps_mode, force_new, compress_moov;
+u32 track_dump_type, dump_isom, dump_timestamps, dump_nal_type, do_flat, print_info;
+u32 size_top_box, fs_dump_flags, dump_chap, dump_udta_type, moov_pading, sdtp_in_traf, segment_marker, timescale, dash_scale;
+u32 MTUSize, run_for, dash_cumulated_time, dash_prev_time, dash_now_time, adjust_split_end, nb_mpd_base_urls, nb_dash_inputs;
+
+u64 initial_tfdt;
+
+s32 subsegs_per_sidx, laser_resolution, ast_offset_ms;
+
+char *inName, *outName, *mediaSource, *input_ctx, *output_ctx, *drm_file, *avi2raw, *cprt, *chap_file, *chap_file_qt, *itunes_tags, *pack_file;
+char *raw_cat, *seg_name, *dash_ctx_file, *compress_top_boxes, *high_dynamc_range_filename, *use_init_seg, *box_patch_filename, *udp_dest;
+char *do_mpd_conv, *dash_start_date, *dash_profile_extension, *dash_cues, *do_wget, *mux_name, *seg_ext, *init_seg_ext, *dash_title, *dash_source;
+char *dash_more_info, *split_range_str;
+
+GF_DASH_ContentLocationMode cp_location_mode;
+GF_MemTrackerType mem_track;
+GF_DASHPSSHMode pssh_mode;
+GF_DashProfile dash_profile;
+GF_DASH_SplitMode dash_split_mode;
+GF_DashSwitchingMode bitstream_switching_mode;
+GF_DashDynamicMode dash_mode;
+#ifndef GPAC_DISABLE_SCENE_DUMP
+GF_SceneDumpFormat dump_mode;
+#endif
+
+//things to free upon cleanup
+MetaAction *metas;
+TrackAction *tracks;
+TSELAction *tsel_acts;
+SDPLine *sdp_lines;
+u32 *brand_add;
+u32 *brand_rem;
+char **mpd_base_urls;
+GF_DashSegmenterInput *dash_inputs;
+FILE *logfile;
+GF_ISOFile *file;
+
+TrackIdentifier info_track_id;
+TrackIdentifier ttxt_track_id;
+TrackIdentifier dump_nal_track;
+TrackIdentifier dump_saps_track;
+TrackIdentifier box_patch_track;
+TrackIdentifier dump_udta_track;
+
+
+static void init_global_vars()
+{
+	//Bool
+	dash_duration_strict = dvbhdemux = keep_sys_tracks = do_hint = do_save = full_interleave = do_frag = hint_interleave = GF_FALSE;
+	dump_rtp = regular_iod = remove_sys_tracks = remove_hint = remove_root_od = print_sdp = open_edit = GF_FALSE;
+	dump_cr = force_ocr = encode = do_scene_log = dump_srt = dump_ttxt = do_saf = dump_m2ts = dump_cart = dump_chunk = GF_FALSE;
+	dump_check_xml = do_hash = verbose = force_cat = pack_wgt = single_group = clean_groups = dash_live = no_fragments_defaults = GF_FALSE;
+	single_traf_per_moof = tfdt_per_traf = hls_clock = do_mpd_rip = merge_vtt_cues = get_nb_tracks = GF_FALSE;
+	no_inplace = merge_last_seg = freeze_box_order = no_odf_conf = GF_FALSE;
+	insert_utc = chunk_mode = HintCopy = hint_no_offset = do_bin_xml = frag_real_time = force_co64 = live_scene = GF_FALSE;
+	use_mfra = dump_iod = samplegroups_in_traf = mvex_after_traks = daisy_chain_sidx = use_ssix = single_segment = single_file = GF_FALSE;
+	segment_timeline = has_add_image = strict_cues = use_url_template = seg_at_rap = frag_at_rap = memory_frags = keep_utc = GF_FALSE;
+	has_next_arg = no_cache = no_loop = GF_FALSE;
+
+	/*align cat is the new default behavior for -cat*/
+	align_cat=GF_TRUE;
+
+	//u32
+	arg_parse_res = nb_mpd_base_urls = nb_dash_inputs = help_flags = 0;
+	stat_level = hint_flags = import_flags = nb_add = nb_cat = crypt = 0;
+	agg_samples = nb_sdp_ex = max_ptime = split_size = nb_meta_act = nb_track_act = 0;
+	rtp_rate = major_brand = nb_alt_brand_add = nb_alt_brand_rem = old_interleave = minor_version = 0;
+	conv_type = nb_tsel_acts = program_number = time_shift_depth = initial_moof_sn = dump_std = 0;
+	import_subtitle = dump_saps_mode = force_new = compress_moov = 0;
+	track_dump_type = dump_isom = dump_timestamps = dump_nal_type = do_flat = print_info = 0;
+	size_top_box = fs_dump_flags = dump_chap = dump_udta_type = moov_pading = sdtp_in_traf = 0;
+	segment_marker = timescale = adjust_split_end = run_for = dash_cumulated_time = dash_prev_time = dash_now_time = 0;
+	dash_scale = 1000;
+	MTUSize = 1450;
+
+	//s32
+	subsegs_per_sidx = laser_resolution = ast_offset_ms = 0;
+
+	//Double
+	interleaving_time = split_duration = dash_duration = dash_subduration = swf_flatten_angle = mpd_live_duration = mpd_update_time = 0.0;
+	split_start = -1.0;
+	min_buffer = 1.5;
+
+	//u64
+	initial_tfdt = 0;
+
+	//char
+	outfile0 = 0;
+
+	//char *
+	split_range_str = inName = outName = mediaSource = input_ctx = output_ctx = drm_file = avi2raw = cprt = NULL;
+	chap_file = chap_file_qt = itunes_tags = pack_file = raw_cat = seg_name = dash_ctx_file = compress_top_boxes = NULL;
+	high_dynamc_range_filename = use_init_seg = box_patch_filename = udp_dest = do_mpd_conv = dash_start_date = NULL;
+	dash_profile_extension = dash_cues = do_wget = mux_name = seg_ext = init_seg_ext = dash_title = dash_source = dash_more_info = NULL;
+
+#ifndef GPAC_DISABLE_SCENE_ENCODER
+	memset(&smenc_opts, 0, sizeof(GF_SMEncodeOptions));
+	swf_flags = GF_SM_SWF_SPLIT_TIMELINE;
+#endif
+	import_fps.num = 0;
+	import_fps.den = 0;
+
+	memset(&info_track_id, 0, sizeof(TrackIdentifier));
+	memset(&ttxt_track_id, 0, sizeof(TrackIdentifier));
+	memset(&dump_nal_track, 0, sizeof(TrackIdentifier));
+	memset(&dump_saps_track, 0, sizeof(TrackIdentifier));
+	memset(&box_patch_track, 0, sizeof(TrackIdentifier));
+	memset(&dump_udta_track, 0, sizeof(TrackIdentifier));
+
+	//allocated
+	metas = NULL;
+	tracks = NULL;
+	tsel_acts = NULL;
+	sdp_lines = NULL;
+	brand_add = NULL;
+	brand_rem = NULL;
+	mpd_base_urls = NULL;
+	dash_inputs = NULL;
+
+	//constants
+#ifndef GPAC_DISABLE_SCENE_DUMP
+	dump_mode=GF_SM_DUMP_NONE;
+#endif
+	bitstream_switching_mode = GF_DASH_BSMODE_DEFAULT;
+	dash_mode = GF_DASH_STATIC;
+	cp_location_mode = GF_DASH_CPMODE_ADAPTATION_SET;
+	pssh_mode = GF_DASH_PSSH_MOOV;
+	dash_split_mode = GF_DASH_SPLIT_OUT;
+	dash_profile = GF_DASH_PROFILE_AUTO;
+	mem_track = GF_MemTrackerNone;
+
+	logfile = NULL;
+	helpout = NULL;
+	file = NULL;
+}
+
+
+typedef u32 (*parse_arg_fun)(char *arg_val, u32 param);
+typedef u32 (*parse_arg_fun2)(char *arg_name, char *arg_val, u32 param);
+
+//other custom option parsing functions definitions are in mp4box.h
+static u32 parse_meta_args(char *opts, MetaActionType act_type);
+static Bool parse_tsel_args(char *opts, TSELActionType act);
+
+u32 parse_u32(char *val, char *log_name)
+{
+	u32 res;
+	if (sscanf(val, "%u", &res)==1) return res;
+	M4_LOG(GF_LOG_ERROR, ("%s must be an unsigned integer (got %s), using 0\n", log_name, val));
+	return 0;
+}
+
+s32 parse_s32(char *val, char *log_name)
+{
+	s32 res;
+	if (sscanf(val, "%d", &res)==1) return res;
+	M4_LOG(GF_LOG_ERROR, ("%s must be a signed integer (got %s), using 0\n", log_name, val));
+	return 0;
+}
+
+static Bool parse_track_id(TrackIdentifier *tkid, char *arg_val, Bool allow_all)
+{
+	tkid->ID_or_num = 0;
+	tkid->type = 0;
+
+	if (!strcmp(arg_val, "*")) {
+		if (allow_all) {
+			tkid->ID_or_num = (u32) -1;
+			return GF_TRUE;
+		}
+		return GF_FALSE;
+	}
+	if (!strncmp(arg_val, "video", 5)) {
+		arg_val += 5;
+		tkid->type = 2;
+	}
+	else if (!strncmp(arg_val, "audio", 5)) {
+		arg_val += 5;
+		tkid->type = 3;
+	}
+	else if (!strncmp(arg_val, "text", 4)) {
+		arg_val += 4;
+		tkid->type = 4;
+	}
+	else if (!strnicmp(arg_val, "n", 1)) {
+		arg_val += 1;
+		tkid->type = 1;
+	}
+
+	if (!arg_val0) return (tkid->type>1) ? GF_TRUE : GF_FALSE;
+	u32 len = (u32) strlen(arg_val);
+	while (len) {
+		if ((arg_vallen-1<'0') || (arg_vallen-1>'9')) {
+			tkid->ID_or_num = 0;
+			tkid->type = 0;
+			return GF_FALSE;
+		}
+		len--;
+	}
+	//don't use parse_u32 we don't want a warning
+	if (sscanf(arg_val, "%u", &tkid->ID_or_num) != 1)
+		tkid->ID_or_num = 0;
+	if (!tkid->ID_or_num) {
+		tkid->type = 0;
+		return GF_FALSE;
+	}
+	return GF_TRUE;
+}
+
+/*
+ * 		START OF ARGS PARSING AND HELP
+ */
+
+
+Bool print_version(char *arg_val, u32 param)
+{
+	fprintf(stderr, "MP4Box - GPAC version %s\n"
+	 "%s\n"
+	 "GPAC Configuration: " GPAC_CONFIGURATION "\n"
+	 "Features: %s %s\n", gf_gpac_version(), gf_gpac_copyright_cite(), gf_sys_features(GF_FALSE), gf_sys_features(GF_TRUE));
+	return GF_TRUE;
+}
+
+//arg will toggle open_edit
+#define ARG_OPEN_EDIT		1
+//arg will toggle do_save
+#define ARG_NEED_SAVE		1<<1
+#define ARG_NO_INPLACE		1<<2
+#define ARG_BIT_MASK		1<<3
+#define ARG_BIT_MASK_REM	1<<4
+#define ARG_HAS_VALUE		1<<5
+#define ARG_DIV_1000		1<<6
+#define ARG_NON_ZERO		1<<7
+#define ARG_64BITS			1<<8
+#define ARG_IS_4CC			1<<9
+#define ARG_BOOL_REV		1<<10
+#define ARG_INT_INC			1<<11
+#define ARG_IS_FUN			1<<12
+#define ARG_EMPTY			1<<13
+#define ARG_PUSH_SYSARGS	1<<14
+#define ARG_IS_FUN2			1<<15
+
+
+
+typedef struct
+{
+	GF_GPAC_ARG_BASE
+
+	void *arg_ptr;
+	u32 argv_val;
+	u16 parse_flags;
+} MP4BoxArg;
+
+#define MP4BOX_ARG(_a, _c, _f, _g, _h, _i, _j) {_a, NULL, _c, NULL, NULL, _f, _g, _h, _i, _j}
+#define MP4BOX_ARG_ALT(_a, _b, _c, _f, _g, _h, _i, _j) {_a, _b, _c, NULL, NULL, _f, _g, _h, _i, _j}
+#define MP4BOX_ARG_S(_a, _s, _c, _g, _h, _i, _j) {_a, NULL, _c, _s, NULL, GF_ARG_CUSTOM, _g, _h, _i, _j}
+#define MP4BOX_ARG_S_ALT(_a, _b, _s, _c, _g, _h, _i, _j) {_a, _b, _c, _s, NULL, GF_ARG_CUSTOM, _g, _h, _i, _j}
+
+
+MP4BoxArg m4b_gen_args =
+{
+#ifdef GPAC_MEMORY_TRACKING
+ 	MP4BOX_ARG("mem-track", "enable memory tracker", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, NULL, 0, 0),
+ 	MP4BOX_ARG("mem-track-stack", "enable memory tracker with stack dumping", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, NULL, 0, 0),
+#endif
+ 	MP4BOX_ARG("p", "use indicated profile for the global GPAC config. If not found, config file is created. If a file path is indicated, this will load profile from that file. Otherwise, this will create a directory of the specified name and store new config there. Reserved name `0` means a new profile, not stored to disk. Works using -p=NAME or -p NAME", GF_ARG_STRING, GF_ARG_HINT_EXPERT, NULL, 0, 0),
+ 	{"inter", NULL, "interleave file, producing track chunks with given duration in ms. A value of 0 disables interleaving ", "0.5", NULL, GF_ARG_DOUBLE, 0, parse_store_mode, 0, ARG_IS_FUN},
+ 	MP4BOX_ARG("old-inter", "same as -inter() but without drift correction", GF_ARG_DOUBLE, GF_ARG_HINT_EXPERT, parse_store_mode, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("tight", "tight interleaving (sample based) of the file. This reduces disk seek operations but increases file size", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &full_interleave, 0, ARG_OPEN_EDIT|ARG_NEED_SAVE),
+ 	MP4BOX_ARG("flat", "store file with all media data first, non-interleaved. This speeds up writing time when creating new files", GF_ARG_BOOL, 0, &do_flat, 0, ARG_NO_INPLACE),
+ 	MP4BOX_ARG("frag", "fragment file, producing track fragments of given duration in ms. This disables interleaving", GF_ARG_DOUBLE, 0, parse_store_mode, 2, ARG_IS_FUN),
+ 	MP4BOX_ARG("out", "specify ISOBMFF output file name. By default input file is overwritten", GF_ARG_STRING, 0, &outName, 0, 0),
+ 	MP4BOX_ARG("co64","force usage of 64-bit chunk offsets for ISOBMF files", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &force_co64, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("new", "force creation of a new destination file", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &force_new, 0, 0),
+ 	MP4BOX_ARG("newfs", "force creation of a new destination file without temp file but interleaving support", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, parse_store_mode, 3, ARG_IS_FUN),
+ 	MP4BOX_ARG_ALT("no-sys", "nosys", "remove all MPEG-4 Systems info except IOD, kept for profiles. This is the default when creating regular AV content", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &remove_sys_tracks, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("no-iod", "remove MPEG-4 InitialObjectDescriptor from file", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &remove_root_od, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("mfra", "insert movie fragment random offset when fragmenting file (ignored in dash mode)", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &use_mfra, 0, 0),
+ 	MP4BOX_ARG("isma", "rewrite the file as an ISMA 1.0 file", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_ISMA, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("ismax", "same as -isma() and remove all clock references", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_ISMA_EX, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("3gp", "rewrite as 3GPP(2) file (no more MPEG-4 Systems Info), always enabled if destination file extension is `.3gp`, `.3g2` or `.3gpp`. Some tracks may be removed in the process", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_3GPP, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("ipod", "rewrite the file for iPod/old iTunes", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_IPOD, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("psp", "rewrite the file for PSP devices", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &conv_type, GF_ISOM_CONV_TYPE_PSP, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("brand", "set major brand of file (`ABCD`) or brand with optional version (`ABCD:v`)", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_brand, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("ab", "add given brand to file's alternate brand list", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_brand, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("rb", "remove given brand to file's alternate brand list", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_brand, 2, ARG_IS_FUN),
+ 	MP4BOX_ARG("cprt", "add copyright string to file", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &cprt, 0, 0),
+ 	MP4BOX_ARG("chap", "set chapter information from given file. The following formats are supported (but cannot be mixed) in the chapter text file:\n"
+		" - ZoomPlayer: `AddChapter(nb_frames,chapter name)`, `AddChapterBySeconds(nb_sec,chapter name)` and `AddChapterByTime(h,m,s,chapter name)` with 1 chapter per line\n"
+		" - Time codes: `h:m:s chapter_name`, `h:m:s:ms chapter_name` and `h:m:s.ms chapter_name` with 1 chapter per line\n"
+		" - SMPTE codes: `h:m:s;nb_f/fps chapter_name` and `h:m:s;nb_f chapter_name` with `nb_f` the number of frames and `fps` the framerate with 1 chapter per line\n"
+		" - Common syntax: `CHAPTERX=h:m:s:ms or .ms` on first line and `CHAPTERXNAME=name` on next line (reverse order accepted)", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &chap_file, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("chapqt", "set chapter information from given file, using QT signaling for text tracks", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &chap_file_qt, 0, ARG_OPEN_EDIT),
+	MP4BOX_ARG_S("set-track-id", "tkID:id2", "change id of track to id2", 0, parse_track_action, TRACK_ACTION_SET_ID, ARG_IS_FUN),
+	MP4BOX_ARG_S("swap-track-id", "tkID1:tkID1", "swap the id between tracks with id1 to id2", 0, parse_track_action, TRACK_ACTION_SWAP_ID, ARG_IS_FUN),
+ 	MP4BOX_ARG("rem", "remove given track from file", GF_ARG_INT, 0, parse_track_action, TRACK_ACTION_REM_TRACK, ARG_IS_FUN),
+ 	MP4BOX_ARG("rap", "remove all non-RAP samples from given track", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_rap_ref, 0, ARG_IS_FUN | ARG_EMPTY),
+ 	MP4BOX_ARG("refonly", "remove all non-reference pictures from given track", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_rap_ref, 1, ARG_IS_FUN | ARG_EMPTY),
+ 	MP4BOX_ARG("enable", "enable given track", GF_ARG_INT, 0, parse_track_action, TRACK_ACTION_ENABLE, ARG_IS_FUN),
+ 	MP4BOX_ARG("disable", "disable given track", GF_ARG_INT, 0, parse_track_action, TRACK_ACTION_DISABLE, ARG_IS_FUN),
+ 	{"timescale", NULL, "set movie timescale to given value (ticks per second)", "600", NULL, GF_ARG_INT, 0, &timescale, 0, ARG_OPEN_EDIT},
+ 	MP4BOX_ARG_S("lang", "tkID=LAN", "set language. LAN is the BCP-47 code (eng, en-UK, ...). If no track ID is given, sets language to all tracks", 0, parse_track_action, TRACK_ACTION_SET_LANGUAGE, ARG_IS_FUN),
+ 	MP4BOX_ARG_S("delay", "tkID=TIME", "set track start delay (>0) or initial skip (<0) in ms or in fractional seconds (`N/D`)", 0, parse_track_action, TRACK_ACTION_SET_DELAY, ARG_IS_FUN),
+ 	MP4BOX_ARG_S("par", "tkID=PAR", "set visual track pixel aspect ratio. PAR is:\n"
+					" - N:D: set PAR to N:D in track, do not modify the bitstream\n"
+					" - wN:D: set PAR to N:D in track and try to modify the bitstream\n"
+					" - none: remove PAR info from track, do not modify the bitstream\n"
+					" - auto: retrieve PAR info from bitstream and set it in track\n"
+					" - force: force 1:1 PAR in track, do not modify the bitstream", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_PAR, ARG_IS_FUN
+					),
+ 	MP4BOX_ARG_S("clap", "tkID=CLAP", "set visual track clean aperture. CLAP is `Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd` or `none`\n"
+ 			"- n, d: numerator, denominator\n"
+	 "- W, H, HO, VO: clap width, clap height, clap horizontal offset, clap vertical offset\n"
+ 			, GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_CLAP, ARG_IS_FUN),
+ 	MP4BOX_ARG_S("mx", "tkID=MX", "set track matrix, with MX is M1:M2:M3:M4:M5:M6:M7:M8:M9 in 16.16 fixed point integers or hexa"
+ 			, GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_MX, ARG_IS_FUN),
+	MP4BOX_ARG_S("kind", "tkID=schemeURI=value", "set kind for the track or for all tracks using `all=schemeURI=value`", 0, parse_track_action, TRACK_ACTION_SET_KIND, ARG_IS_FUN),
+	MP4BOX_ARG_S("kind-rem", "tkID=schemeURI=value", "remove kind if given schemeID for the track or for all tracks with `all=schemeURI=value`", 0, parse_track_action, TRACK_ACTION_REM_KIND, ARG_IS_FUN),
+ 	MP4BOX_ARG_S("name", "tkID=NAME", "set track handler name to NAME (UTF-8 string)", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_HANDLER_NAME, ARG_IS_FUN),
+	MP4BOX_ARG_ALT("tags", "itags", "set iTunes tags to file, see `-h tags`", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &itunes_tags, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("group-add", "create a new grouping information in the file. Format is a colon-separated list of following options:\n"
+	 "- refTrack=ID: track used as a group reference. If not set, the track will belong to the same group as the "
+	 "previous trackID specified. If 0 or no previous track specified, a new alternate group will be created\n"
+	 "- switchID=ID: ID of the switch group to create. If 0, a new ID will be computed for you. If <0, disables SwitchGroup\n"
+	 "- criteria=string: list of space-separated 4CCs\n"
+	 "- trackID=ID: track to add to this group\n"
+	 " \n"
+	 "Warning: Options modify state as they are parsed, `trackID=1:criteria=lang:trackID=2` is different from `criteria=lang:trackID=1:trackID=2`"
+	 "\n", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, parse_tsel_args, TSEL_ACTION_SET_PARAM, ARG_IS_FUN),
+
+	MP4BOX_ARG("group-rem-track", "remove given track from its group", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_tsel_args, TSEL_ACTION_REMOVE_TSEL, ARG_IS_FUN),
+	MP4BOX_ARG("group-rem", "remove the track's group", GF_ARG_INT, GF_ARG_HINT_ADVANCED, parse_tsel_args, TSEL_ACTION_REMOVE_ALL_TSEL_IN_GROUP, ARG_IS_FUN),
+	MP4BOX_ARG("group-clean", "remove all group information from all tracks", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &clean_groups, 0, ARG_OPEN_EDIT),
+	MP4BOX_ARG_S("ref", "tkID:XXXX:refID", "add a reference of type 4CC from track ID to track refID", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_REFERENCE, ARG_IS_FUN),
+	MP4BOX_ARG("keep-utc", "keep UTC timing in the file after edit", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &keep_utc, 0, 0),
+	MP4BOX_ARG_S("udta", "tkID:OPTS", "set udta for given track or movie if tkID is 0. OPTS is a colon separated list of:\n"
+	 "- type=CODE: 4CC code of the UDTA (not needed for `box=` option)\n"
+	 "- box=FILE: location of the udta data, formatted as serialized boxes\n"
+	 "- box=base64,DATA: base64 encoded udta data, formatted as serialized boxes\n"
+	 "- src=FILE: location of the udta data (will be stored in a single box of type CODE)\n"
+	 "- src=base64,DATA: base64 encoded udta data (will be stored in a single box of type CODE)\n"
+	 "- str=STRING: use the given string as payload for the udta box\n"
+	 "Note: If no source is set, UDTA of type CODE will be removed\n", GF_ARG_HINT_ADVANCED, parse_track_action, TRACK_ACTION_SET_UDTA, ARG_IS_FUN|ARG_OPEN_EDIT),
+	MP4BOX_ARG_S("patch", "tkID=FILE", "apply box patch described in FILE, for given trackID if set", GF_ARG_HINT_ADVANCED, parse_boxpatch, 0, ARG_IS_FUN),
+	MP4BOX_ARG("bo", "freeze the order of boxes in input file", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, &freeze_box_order, 0, 0),
+	MP4BOX_ARG("init-seg", "use the given file as an init segment for dumping or for encryption", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &use_init_seg, 0, 0),
+	MP4BOX_ARG("zmov", "compress movie box according to ISOBMFF box compression", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, parse_compress, 0, ARG_IS_FUN),
+	MP4BOX_ARG("xmov", "same as zmov and wraps ftyp in otyp", GF_ARG_BOOL, GF_ARG_HINT_ADVANCED, parse_compress, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG_S("edits", "tkID=EDITS", "set edit list. The following syntax is used (no separators between entries):\n"
+			" - `r`: removes all edits\n"
+			" - `eSTART`: add empty edit with given start time. START can be\n"
+			" - `VAL`: start time in seconds (int, double, fraction), media duration used as edit duration\n"
+			" - `VAL-DUR`: start time and duration in seconds (int, double, fraction)\n"
+			" - `eSTART,MEDIA,RATE`: add regular edit with given start, media start time in seconds (int, double, fraction) and rate (fraction or INT)\n"
+			" - Examples: \n"
+			" - `re0-5e5-3,4`: remove edits, add empty edit at 0s for 5s, then add regular edit at 5s for 3s starting at 4s in media track\n"
+			" - `re0-4,0,0.5`: remove edits, add single edit at 0s for 4s starting at 0s in media track and playing at speed 0.5\n"
+				, 0, parse_track_action, TRACK_ACTION_SET_EDITS, ARG_IS_FUN),
+ 	MP4BOX_ARG("moovpad", "specify amount of padding to keep after moov box for later inplace editing - if 0, moov padding is disabled", GF_ARG_INT, GF_ARG_HINT_EXPERT, &moov_pading, 0, ARG_NEED_SAVE),
+ 	MP4BOX_ARG("no-inplace", "disable inplace rewrite", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &no_inplace, 0, 0),
+ 	MP4BOX_ARG("hdr", "update HDR information based on given XML, 'none' removes HDR info", GF_ARG_STRING, GF_ARG_HINT_EXPERT, &high_dynamc_range_filename, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG_S("time", "tkID=DAY/MONTH/YEAR-H:M:S", "set movie or track creation time", GF_ARG_HINT_EXPERT, parse_track_action, TRACK_ACTION_SET_TIME, ARG_IS_FUN),
+ 	MP4BOX_ARG_S("mtime", "tkID=DAY/MONTH/YEAR-H:M:S", "set media creation time", GF_ARG_HINT_EXPERT, parse_track_action, TRACK_ACTION_SET_MEDIA_TIME, ARG_IS_FUN),
+	{0}
+};
+
+void PrintGeneralUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# General Options\n"
+		"MP4Box is a multimedia packager, with a vast number of functionalities: conversion, splitting, hinting, dumping, DASH-ing, encryption, transcoding and others.\n"
+		"MP4Box provides a large set of options, classified by categories (see -h()). These options do not follow any particular ordering.\n"
+		" \n"
+		"By default, MP4Box rewrites the input file. You can change this behavior by using the -out() option.\n"
+		"MP4Box stores by default the file with 0.5 second interleaving and meta-data (`moov` ...) at the beginning, making it suitable for HTTP download-and-play. This may however takes longer to store the file, use -flat() to change this behavior.\n"
+		" \n"
+		"MP4Box usually generates a temporary file when creating a new IsoMedia file. The location of this temporary file is OS-dependent, and it may happen that the drive/partition the temporary file is created on has not enough space or no write access. In such a case, you can specify a temporary file location with -tmp().\n"
+		" \n"
+		"Track identifier for track-based operations (usually referred to as `tkID` in the help) use the following syntax:\n"
+		"- INT: target is track with ID `INT`\n"
+		"- n`INT`: target is track number `INT`\n"
+		"- `audio`, `video`, `text`: target is first `audio`, `video` or `text` track\n"
+		"- `audioN`, `videoN`, `textN`: target is the `N`th `audio`, `video` or `text` track, with `N=1` being the first track of desired type\n"
+		" \n"
+		"Option values:\n"
+		"Unless specified otherwise, a track operation option of type `integer` expects a track identifer value following it.\n"
+		"An option of type `boolean` expects no following value.\n"
+		" \n"
+	);
+
+
+	while (m4b_gen_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_gen_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-gen");
+	}
+}
+
+
+MP4BoxArg m4b_split_args =
+{
+ 	MP4BOX_ARG("split", "split in files of given max duration (float number) in seconds. A trailing unit can be specified:\n"
+	"- `M`, `m`: duration is in minutes\n"
+	"- `H`, `h`: size is in hours", GF_ARG_STRING, 0, parse_split, 0, ARG_IS_FUN),
+	MP4BOX_ARG_ALT("split-rap", "splitr", "split in files at each new RAP", GF_ARG_STRING, 0, parse_split, 1, ARG_IS_FUN),
+	MP4BOX_ARG_ALT("split-size", "splits", "split in files of given max size (integer number) in kilobytes. A trailing unit can be specified:\n"
+	"- `M`, `m`: size is in megabytes\n"
+	"- `G`, `g`: size is in gigabytes", GF_ARG_STRING, 0, parse_split, 2, ARG_IS_FUN),
+	MP4BOX_ARG_ALT("split-chunk", "splitx", "extract the specified time range as follows:\n"
+	"- the start time is moved to the RAP sample closest to the specified start time\n"
+	"- the end time is kept as requested"
+		, GF_ARG_STRING, 0, parse_split, 3, ARG_IS_FUN),
+	MP4BOX_ARG("splitz", "extract the specified time range so that ranges `A:B` and `B:C` share exactly the same boundary `B`:\n"
+	"- the start time is moved to the RAP sample at or after the specified start time\n"
+	"- the end time is moved to the frame preceding the RAP sample at or following the specified end time"
+		, GF_ARG_STRING, 0, parse_split, 4, ARG_IS_FUN),
+	MP4BOX_ARG("splitg", "extract the specified time range as follows:\n"
+	"- the start time is moved to the RAP sample at or before the specified start time\n"
+	"- the end time is moved to the frame preceding the RAP sample at or following the specified end time"
+		, GF_ARG_STRING, 0, parse_split, 5, ARG_IS_FUN),
+	MP4BOX_ARG("splitf", "extract the specified time range and insert edits such that the extracted output is exactly the specified range\n", GF_ARG_STRING, 0, parse_split, 6, ARG_IS_FUN),
+	{0}
+};
+
+
+static void PrintSplitUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, " \n"
+		"# File splitting\n"
+		"MP4Box can split input files by size, duration or extract a given part of the file to new IsoMedia file(s).\n"
+		"This requires that at most one track in the input file has non random-access points (typically one video track at most).\n"
+		"Splitting will ignore all MPEG-4 Systems tracks and hint tracks, but will try to split private media tracks.\n"
+		"The input file must have enough random access points in order to be split. If this is not the case, you will have to re-encode the content.\n"
+		"You can add media to a file and split it in the same pass. In this case, the destination file (the one which would be obtained without splitting) will not be stored.\n"
+		" \n"
+		"Time ranges are specified as follows:\n"
+		"- `S-E`: `S` start and `E` end times, formatted as `HH:MM:SS.ms`, `MM:SS.ms` or time in seconds (int, double, fraction)\n"
+		"- `S:E`: `S` start time and `E` end times in seconds (int, double, fraction). If `E` is prefixed with `D`, this sets `E = S + time`\n"
+		"- `S:end` or `S:end-N`: `S` start time in seconds (int, double), `N` number of seconds (int, double) before the end\n"
+		" \n"
+		"MP4Box splitting runs a filter session using the `reframer` filter as follows:\n"
+		"- `splitrange` option of the reframer is always set\n"
+		"- source is demultiplexed with `alltk` option set\n"
+		"- start and end ranges are passed to `xs` and `xe` options of the reframer\n"
+		"- for `-splitz`, options `xadjust` and `xround=after` are enforced\n"
+		"- for `-splitg`, options `xadjust` and `xround=before` are enforced\n"
+		"- for `-splitf`, option `xround=seek` is enforced and `propbe_ref`set if not specified at prompt\n"
+		"- for `-splitx`, option `xround=closest` and `propbe_ref` are enforced if not specified at prompt\n"
+		" \n"
+		"The default output storage mode is to full interleave and will require a temp file for each output. This behavior can be modified using `-flat`, `-newfs`, `-inter` and `-frag`.\n"
+		"The output file name(s) can be specified using `-out` and templates (e.g. `-out split$num%%04d$.mp4` produces split0001.mp4, split0002.mp4, ...).\n"
+		"Multiple time ranges can be specified as a comma-seperated list for `-splitx`, `-splitz` and `-splitg`.\n"
+		" \n"
+	);
+
+	i=0;
+	while (m4b_split_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_split_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-split");
+	}
+
+}
+
+
+MP4BoxArg m4b_dash_args =
+{
+ 	MP4BOX_ARG ("dash", "create DASH from input files with given segment (subsegment for onDemand profile) duration in ms", GF_ARG_DOUBLE, 0, &dash_duration, 0, ARG_NON_ZERO),
+ 	MP4BOX_ARG("dash-live", "generate a live DASH session using the given segment duration in ms; using `-dash-live=F` will also write the live context to `F`. MP4Box will run the live session until `q` is pressed or a fatal error occurs", GF_ARG_DOUBLE, 0, parse_dashlive, 0, ARG_IS_FUN2),
+ 	MP4BOX_ARG("ddbg-live", "same as -dash-live() without time regulation for debug purposes", GF_ARG_DOUBLE, 0, parse_dashlive, 1, ARG_IS_FUN2),
+	MP4BOX_ARG("frag", "specify the fragment duration in ms. If not set, this is the DASH duration (one fragment per segment)", GF_ARG_DOUBLE, 0, parse_store_mode, 2, ARG_IS_FUN),
+	MP4BOX_ARG("out", "specify the output MPD file name", GF_ARG_STRING, 0, &outName, 0, 0),
+	MP4BOX_ARG_ALT("profile", "dash-profile", "specify the target DASH profile, and set default options to ensure conformance to the desired profile. Default profile is `full` in static mode, `live` in dynamic mode (old syntax using `:live` instead of `.live` as separator still possible). Defined values are onDemand, live, main, simple, full, hbbtv1.5.live, dashavc264.live, dashavc264.onDemand, dashif.ll", GF_ARG_STRING, 0, parse_dash_profile, 0, ARG_IS_FUN),
+	MP4BOX_ARG("profile-ext", "specify a list of profile extensions, as used by DASH-IF and DVB. The string will be colon-concatenated with the profile used", GF_ARG_STRING, 0, &dash_profile_extension, 0, 0),
+	MP4BOX_ARG("rap", "ensure that segments begin with random access points, segment durations might vary depending on the source encoding", GF_ARG_BOOL, 0, parse_rap_ref, 0, ARG_IS_FUN | ARG_EMPTY),
+	MP4BOX_ARG("frag-rap", "ensure that all fragments begin with random access points (duration might vary depending on the source encoding)", GF_ARG_BOOL, 0, &frag_at_rap, 0, 0),
+	MP4BOX_ARG("segment-name", "set the segment name for generated segments. If not set (default), segments are concatenated in output file except in `live` profile where `dash_%%s`. Supported replacement strings are:\n"
+	 "- $Number%%0Nd$ is replaced by the segment number, possibly prefixed with 0\n"
+	 "- $RepresentationID$ is replaced by representation name\n"
+	 "- $Time$ is replaced by segment start time\n"
+	 "- $Bandwidth$ is replaced by representation bandwidth\n"
+	 "- $Init=NAME$ is replaced by NAME for init segment, ignored otherwise\n"
+	 "- $Index=NAME$ is replaced by NAME for index segments, ignored otherwise\n"
+	 "- $Path=PATH$ is replaced by PATH when creating segments, ignored otherwise\n"
+	 "- $Segment=NAME$ is replaced by NAME for media segments, ignored for init segments", GF_ARG_STRING, 0, &seg_name, 0, 0),
+	{"segment-ext", NULL, "set the segment extension, `null` means no extension", "m4s", NULL, GF_ARG_STRING, 0, &seg_ext, 0, 0},
+	{"init-segment-ext", NULL, "set the segment extension for init, index and bitstream switching segments, `null` means no extension\n", "mp4", NULL, GF_ARG_STRING, 0, &init_seg_ext, 0, 0},
+	MP4BOX_ARG("segment-timeline", "use `SegmentTimeline` when generating segments", GF_ARG_BOOL, 0, &segment_timeline, 0, 0),
+	MP4BOX_ARG("segment-marker", "add a box of given type (4CC) at the end of each DASH segment", GF_ARG_STRING, 0, &segment_marker, 0, ARG_IS_4CC),
+	MP4BOX_ARG("insert-utc", "insert UTC clock at the beginning of each ISOBMF segment", GF_ARG_BOOL, 0, &insert_utc, 0, 0),
+	MP4BOX_ARG("base-url", "set Base url at MPD level. Can be used several times. \nWarning: this does not modify generated files location", GF_ARG_STRING, 0, parse_base_url, 0, ARG_IS_FUN),
+	MP4BOX_ARG("mpd-title", "set MPD title", GF_ARG_STRING, 0, &dash_title, 0, 0),
+	MP4BOX_ARG("mpd-source", "set MPD source", GF_ARG_STRING, 0, &dash_source, 0, 0),
+	MP4BOX_ARG("mpd-info-url", "set MPD info url", GF_ARG_STRING, 0, &dash_more_info, 0, 0),
+ 	MP4BOX_ARG("cprt", "add copyright string to MPD", GF_ARG_STRING, GF_ARG_HINT_ADVANCED, &cprt, 0, 0),
+	MP4BOX_ARG("dash-ctx", "store/restore DASH timing from indicated file", GF_ARG_STRING, 0, &dash_ctx_file, 0, 0),
+	MP4BOX_ARG("dynamic", "use dynamic MPD type instead of static", GF_ARG_BOOL, 0, &dash_mode, GF_DASH_DYNAMIC, 0),
+	MP4BOX_ARG("last-dynamic", "same as -dynamic() but close the period (insert lmsg brand if needed and update duration)", GF_ARG_BOOL, 0, &dash_mode, GF_DASH_DYNAMIC_LAST, 0),
+	MP4BOX_ARG("mpd-duration", "set the duration in second of a live session (if `0`, you must use -mpd-refresh())", GF_ARG_DOUBLE, 0, &mpd_live_duration, 0, 0),
+	MP4BOX_ARG("mpd-refresh", "specify MPD update time in seconds", GF_ARG_DOUBLE, 0, &mpd_update_time, 0, 0),
+	MP4BOX_ARG("time-shift", "specify MPD time shift buffer depth in seconds, `-1` to keep all files)", GF_ARG_INT, 0, &time_shift_depth, 0, 0),
+	MP4BOX_ARG("subdur", "specify maximum duration in ms of the input file to be dashed in LIVE or context mode. This does not change the segment duration, but stops dashing once segments produced exceeded the duration. If there is not enough samples to finish a segment, data is looped unless -no-loop() is used which triggers a period end", GF_ARG_DOUBLE, 0, &dash_subduration, 0, 0),
+	MP4BOX_ARG("run-for", "run for given ms the dash-live session then exits", GF_ARG_INT, 0, &run_for, 0, 0),
+	MP4BOX_ARG("min-buffer", "specify MPD min buffer time in ms", GF_ARG_INT, 0, &min_buffer, 0, ARG_DIV_1000),
+	MP4BOX_ARG("ast-offset", "specify MPD AvailabilityStartTime offset in ms if positive, or availabilityTimeOffset of each representation if negative", GF_ARG_INT, 0, &ast_offset_ms, 0, 0),
+	MP4BOX_ARG("dash-scale", "specify that timing for -dash(), -dash-live(), -subdur() and -do_frag() are expressed in given timescale (units per seconds) rather than ms", GF_ARG_INT, 0, &dash_scale, 0, ARG_NON_ZERO),
+	MP4BOX_ARG("mem-frags", "fragmentation happens in memory rather than on disk before flushing to disk", GF_ARG_BOOL, 0, &memory_frags, 0, 0),
+	MP4BOX_ARG("pssh", "set pssh store mode\n"
+	"- v: initial movie\n"
+	"- f: movie fragments\n"
+	"- m: MPD\n"
+	"- mv, vm: in initial movie and MPD\n"
+	"- mf, fm: in movie fragments and MPD\n"
+	"- n: remove PSSH from MPD, initial movie and movie fragments", GF_ARG_INT, 0, parse_pssh, 0, ARG_IS_FUN),
+	MP4BOX_ARG("sample-groups-traf", "store sample group descriptions in traf (duplicated for each traf). If not set, sample group descriptions are stored in the initial movie", GF_ARG_BOOL, 0, &samplegroups_in_traf, 0, 0),
+	MP4BOX_ARG("mvex-after-traks", "store `mvex` box after `trak` boxes within the moov box. If not set, `mvex` is before", GF_ARG_BOOL, 0, &mvex_after_traks, 0, 0),
+	MP4BOX_ARG("sdtp-traf", "use `sdtp` box in `traf` (Smooth-like)\n"
+	"- no: do not use sdtp\n"
+	"- sdtp: use sdtp box to indicate sample dependencies and do not write info in trun sample flags\n"
+	"- both: use sdtp box to indicate sample dependencies and also write info in trun sample flags\n", GF_ARG_INT, 0, parse_sdtp, 0, ARG_IS_FUN),
+	MP4BOX_ARG("no-cache", "disable file cache for dash inputs", GF_ARG_BOOL, 0, &no_cache, 0, 0),
+	MP4BOX_ARG("no-loop", "disable looping content in live mode and uses period switch instead", GF_ARG_BOOL, 0, &no_loop, 0, 0),
+	MP4BOX_ARG("hlsc", "insert UTC in variant playlists for live HLS", GF_ARG_BOOL, 0, &hls_clock, 0, 0),
+	MP4BOX_ARG("bound", "segmentation will always try to split before or at, but never after, the segment boundary", GF_ARG_BOOL, 0, &dash_split_mode, GF_DASH_SPLIT_IN, 0),
+	MP4BOX_ARG("closest", "segmentation will use the closest frame to the segment boundary (before or after)", GF_ARG_BOOL, 0, &dash_split_mode, GF_DASH_SPLIT_CLOSEST, 0),
+	MP4BOX_ARG_ALT("subsegs-per-sidx", "frags-per-sidx", "set the number of subsegments to be written in each SIDX box\n"
+	"- 0: a single SIDX box is used per segment\n"
+	"- -1: no SIDX box is used", GF_ARG_INT, GF_ARG_HINT_EXPERT, &subsegs_per_sidx, 0, 0),
+	MP4BOX_ARG("ssix", "enable SubsegmentIndexBox describing 2 ranges, first one from moof to end of first I-frame, second one unmapped. This does not work with daisy chaining mode enabled", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &use_ssix, 0, 0),
+	MP4BOX_ARG("url-template", "use SegmentTemplate instead of explicit sources in segments. Ignored if segments are stored in the output file", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &use_url_template, 1, 0),
+	MP4BOX_ARG("url-template-sim", "use SegmentTemplate simulation while converting HLS to MPD", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &use_url_template, 2, 0),
+	MP4BOX_ARG("daisy-chain", "use daisy-chain SIDX instead of hierarchical. Ignored if frags/sidx is 0", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &daisy_chain_sidx, 0, 0),
+	MP4BOX_ARG("single-segment", "use a single segment for the whole file (OnDemand profile)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &single_segment, 0, 0),
+	{"single-file", NULL, "use a single file for the whole file (default)", "yes", NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &single_file, 0, 0},
+	{"bs-switching", NULL, "set bitstream switching mode\n"
+	"- inband: use inband param set and a single init segment\n"
+	"- merge: try to merge param sets in a single sample description, fallback to `no`\n"
+	"- multi: use several sample description, one per quality\n"
+	"- no: use one init segment per quality\n"
+	"- pps: use out of band VPS,SPS,DCI, inband for PPS,APS and a single init segment\n"
+	"- single: to test with single input", "inband", "inband|merge|multi|no|single", GF_ARG_STRING, GF_ARG_HINT_EXPERT, parse_bs_switch, 0, ARG_IS_FUN},
+	MP4BOX_ARG("moof-sn", "set sequence number of first moof to given value", GF_ARG_INT, GF_ARG_HINT_EXPERT, &initial_moof_sn, 0, 0),
+	MP4BOX_ARG("tfdt", "set TFDT of first traf to given value in SCALE units (cf -dash-scale)", GF_ARG_INT, GF_ARG_HINT_EXPERT, &initial_tfdt, 0, ARG_64BITS),
+	MP4BOX_ARG("no-frags-default", "disable default fragments flags in trex (required by some dash-if profiles and CMAF/smooth streaming compatibility)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &no_fragments_defaults, 0, 0),
+	MP4BOX_ARG("single-traf", "use a single track fragment per moof (smooth streaming and derived specs may require this)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &single_traf_per_moof, 0, 0),
+	MP4BOX_ARG("tfdt-traf", "use a tfdt per track fragment (when -single-traf is used)", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &tfdt_per_traf, 0, 0),
+	MP4BOX_ARG("dash-ts-prog", "program_number to be considered in case of an MPTS input file", GF_ARG_INT, GF_ARG_HINT_EXPERT, &program_number, 0, 0),
+	MP4BOX_ARG("frag-rt", "when using fragments in live mode, flush fragments according to their timing", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &frag_real_time, 0, 0),
+	MP4BOX_ARG("cp-location", "set ContentProtection element location\n"
+	 "- as: sets ContentProtection in AdaptationSet element\n"
+	 "- rep: sets ContentProtection in Representation element\n"
+	 "- both: sets ContentProtection in both elements", GF_ARG_STRING, GF_ARG_HINT_EXPERT, parse_cp_loc, 0, ARG_IS_FUN),
+	MP4BOX_ARG("start-date", "for live mode, set start date (as xs:date, e.g. YYYY-MM-DDTHH:MM:SSZ). Default is current UTC\n"
+	"Warning: Do not use with multiple periods, nor when DASH duration is not a multiple of GOP size", GF_ARG_STRING, GF_ARG_HINT_EXPERT, &dash_start_date, 0, 0),
+	MP4BOX_ARG("cues", "ignore dash duration and segment according to cue times in given XML file (tests/media/dash_cues for examples)", GF_ARG_STRING, GF_ARG_HINT_EXPERT, &dash_cues, 0, 0),
+	MP4BOX_ARG("strict-cues", "throw error if something is wrong while parsing cues or applying cue-based segmentation", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &strict_cues, 0, 0),
+	MP4BOX_ARG("merge-last-seg", "merge last segment if shorter than half the target duration", GF_ARG_BOOL, GF_ARG_HINT_EXPERT, &merge_last_seg, 0, 0),
+	{0}
+};
+
+void PrintDASHUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# DASH Options\n"
+		"Also see:\n"
+		"- the dasher `gpac -h dash`(dasher) filter documentation\n"
+		"- DASH wiki|DASH-intro.\n"
+		"\n"
+		"# Specifying input files\n"
+		"Input media files to dash can use the following modifiers\n"
+		"- #trackID=N: only use the track ID N from the source file\n"
+		"- #N: only use the track ID N from the source file (mapped to -tkid(mp4dmx))\n"
+		"- #video: only use the first video track from the source file\n"
+		"- #audio: only use the first audio track from the source file\n"
+		"- :id=NAME: set the representation ID to NAME. Reserved value `NULL` disables representation ID for multiplexed inputs. If not set, a default value is computed and all selected tracks from the source will be in the same output multiplex.\n"
+		"- :dur=VALUE: process VALUE seconds (fraction) from the media. If VALUE is longer than media duration, last sample duration is extended.\n"
+		"- :period=NAME: set the representation's period to NAME. Multiple periods may be used. Periods appear in the MPD in the same order as specified with this option\n"
+		"- :BaseURL=NAME: set the BaseURL. Set multiple times for multiple BaseURLs\nWarning: This does not modify generated files location (see segment template).\n"
+		"- :bandwidth=VALUE: set the representation's bandwidth to a given value\n"
+		"- :pdur=VALUE: sets the duration of the associated period to VALUE seconds (fraction) (alias for period_duration:VALUE). This is only used when no input media is specified (remote period insertion), e.g. `:period=X:xlink=Z:pdur=Y`\n"
+		"- :ddur=VALUE: override target DASH segment duration to VALUE seconds (fraction) for this input (alias for duration:VALUE)\n"
+		"- :xlink=VALUE: set the xlink value for the period containing this element. Only the xlink declared on the first rep of a period will be used\n"
+		"- :asID=VALUE: set the AdaptationSet ID to VALUE (unsigned int)\n"
+		"- :role=VALUE: set the role of this representation (cf DASH spec). Media with different roles belong to different adaptation sets.\n"
+		"- :desc_p=VALUE: add a descriptor at the Period level. Value must be a properly formatted XML element.\n"
+		"- :desc_as=VALUE: add a descriptor at the AdaptationSet level. Value must be a properly formatted XML element. Two input files with different values will be in different AdaptationSet elements.\n"
+		"- :desc_as_c=VALUE: add a descriptor at the AdaptationSet level. Value must be a properly formatted XML element. Value is ignored while creating AdaptationSet elements.\n"
+		"- :desc_rep=VALUE: add a descriptor at the Representation level. Value must be a properly formatted XML element. Value is ignored while creating AdaptationSet elements.\n"
+		"- :sscale: force movie timescale to match media timescale of the first track in the segment.\n"
+		"- :trackID=N: only use the track ID N from the source file\n"
+		"- @f1:args@fN:args@@fK:args: set a filter chain to insert between the source and the dasher. Each filter in the chain is formatted as a regular filter, see filter doc `gpac -h doc`(filters_general). If several filters are set:\n"
+		" - they will be chained in the given order if separated by a single `@`\n"
+		" - a new filter chain will be created if separated by a double `@@`. In this case, no representation ID is assigned to the source.\n"
+		"EX source.mp4:@c=avc:b=1M@@c=avc:b=500k\n"
+		"This will load a filter chain with two encoders connected to the source and to the dasher.\n"
+		"EX source.mp4:@c=avc:b=1M@c=avc:b=500k\n"
+		"This will load a filter chain with the second encoder connected to the output of the first (!!).\n"
+		"\n"
+		"Note: `@f` must be placed after all other options.\n"
+		"\n"
+		"# Options\n"
+		);
+
+
+	while (m4b_dash_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_dash_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-dash");
+	}
+}
+
+
+MP4BoxArg m4b_imp_args =
+{
+	MP4BOX_ARG("add", "add given file tracks to file. Multiple inputs can be specified using `+`, e.g. `-add url1+url2`", GF_ARG_STRING, 0, &nb_add, 0, ARG_INT_INC),
+	MP4BOX_ARG("cat", "concatenate given file samples to file, creating tracks if needed. Multiple inputs can be specified using `+`, e.g/ `-cat url1+url2`. \nNote: This aligns initial timestamp of the file to be concatenated", GF_ARG_STRING, 0, &nb_cat, 0, ARG_INT_INC),
+ 	MP4BOX_ARG("catx", "same as -cat() but new tracks can be imported before concatenation by specifying `+ADD_COMMAND` where `ADD_COMMAND` is a regular -add() syntax", GF_ARG_STRING, 0, &nb_cat, 0, ARG_INT_INC),
+ 	MP4BOX_ARG("catpl", "concatenate files listed in the given playlist file (one file per line, lines starting with # are comments). \nNote: Each listed file is concatenated as if called with -cat", GF_ARG_STRING, 0, &nb_cat, 0, ARG_INT_INC),
+ 	MP4BOX_ARG("unalign-cat", "do not attempt to align timestamps of samples in-between tracks", GF_ARG_BOOL, 0, &align_cat, 0, ARG_BOOL_REV),
+ 	MP4BOX_ARG("force-cat", "skip media configuration check when concatenating file. \nWarning: THIS MAY BREAK THE CONCATENATED TRACK(S)", GF_ARG_BOOL, 0, &force_cat, 0, 0),
+ 	MP4BOX_ARG("keep-sys", "keep all MPEG-4 Systems info when using -add() and -cat() (only used when adding IsoMedia files)", GF_ARG_BOOL, 0, &keep_sys_tracks, 0, 0),
+	MP4BOX_ARG("dref", "keep media data in original file using `data referencing`. The resulting file only contains the meta-data of the presentation (frame sizes, timing, etc...) and references media data in the original file. This is extremely useful when developing content, since importing and storage of the MP4 file is much faster and the resulting file much smaller. \nNote: Data referencing may fail on some files because it requires the framed data (e.g. an IsoMedia sample) to be continuous in the original file, which is not always the case depending on the original interleaving or bitstream format (__AVC__ or __HEVC__ cannot use this option)", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_USE_DATAREF, ARG_BIT_MASK),
+ 	MP4BOX_ARG_ALT("no-drop", "nodrop", "force constant FPS when importing AVI video", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_NO_FRAME_DROP, ARG_BIT_MASK),
+ 	MP4BOX_ARG("packed", "force packed bitstream when importing raw MPEG-4 part 2 Advanced Simple Profile", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_FORCE_PACKED, ARG_BIT_MASK),
+ 	MP4BOX_ARG("sbr", "backward compatible signaling of AAC-SBR", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_SBR_IMPLICIT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("sbrx", "non-backward compatible signaling of AAC-SBR", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_SBR_EXPLICIT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("ps", "backward compatible signaling of AAC-PS", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_PS_IMPLICIT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("psx", "non-backward compatible signaling of AAC-PS", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_PS_EXPLICIT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("ovsbr", "oversample SBR import (SBR AAC, PS AAC and oversampled SBR cannot be detected at import time)", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_OVSBR, ARG_BIT_MASK),
+ 	MP4BOX_ARG("fps", "force frame rate for video and SUB subtitles import to the given value, expressed as a number, as `TS-inc` or `TS/inc`. \nNote: For raw H263 import, default FPS is `15`, otherwise `25`. This is accepted for ISOBMFF import but `:rescale` option should be preferred", GF_ARG_STRING, 0, parse_fps, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("mpeg4", "force MPEG-4 sample descriptions when possible. For AAC, forces MPEG-4 AAC signaling even if MPEG-2", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_FORCE_MPEG4, ARG_BIT_MASK),
+ 	MP4BOX_ARG("agg", "aggregate N audio frames in 1 sample (3GP media only, maximum value is 15)", GF_ARG_INT, 0, &agg_samples, 0, 0),
+	{0}
+};
+
+
+static MP4BoxArg m4b_imp_fileopt_args = {
+	GF_DEF_ARG("dur", NULL, "`XC` import only the specified duration from the media. Value can be:\n"
+		" - positive float: specifies duration in seconds\n"
+		" - fraction: specifies duration as NUM/DEN fraction\n"
+		" - negative integer: specifies duration in number of coded frames", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("start", NULL, "`C` target start time in source media, may not be supported depending on the source", NULL, NULL, GF_ARG_DOUBLE, 0),
+	GF_DEF_ARG("lang", NULL, "`S` set imported media language code", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("delay", NULL, "`S` set imported media initial delay (>0) or initial skip (<0) in ms or as fractional seconds (`N/D`)", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("par", NULL, "`S` set visual pixel aspect ratio (see -par(MP4B_GEN) )", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("clap", NULL, "`S` set visual clean aperture (see -clap(MP4B_GEN) )", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("mx", NULL, "`S` set track matrix (see -mx(MP4B_GEN) )", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("name", NULL, "`S` set track handler name", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("ext", NULL, "override file extension when importing", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("hdlr", NULL, "`S` set track handler type to the given code point (4CC)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("stype", NULL, "`S` force sample description type to given code point (4CC), may likely break the file", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("tkhd", NULL, "`S` set track header flags has hex integer or as comma-separated list of `enable`, `movie`, `preview`, `size_ar` keywords (use `tkhd+=FLAGS` to add and `tkhd-=FLAGS` to remove)", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("disable", NULL, "`S` disable imported track(s), use `disable=no` to force enabling a disabled track", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("group", NULL, "`S` add the track as part of the G alternate group. If G is 0, the first available GroupID will be picked", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("fps", NULL, "`S` same as -fps()", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("rap", NULL, "`DS` import only RAP samples", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("refs", NULL, "`DS` import only reference pictures", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("trailing", NULL, "keep trailing 0-bytes in AVC/HEVC samples", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("agg", NULL, "`X` same as -agg()", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("dref", NULL, "`XC` same as -dref()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("keep_refs", NULL, "`C` keep track reference when importing a single track", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("nodrop", NULL, "same as -nodrop()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("packed", NULL, "`X` same as -packed()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("sbr", NULL, "same as -sbr()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("sbrx", NULL, "same as -sbrx()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("ovsbr", NULL, "same as -ovsbr()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("ps", NULL, "same as -ps()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("psx", NULL, "same as -psx()", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("asemode", NULL, "`XS` set the mode to create the AudioSampleEntry. Value can be:\n"
+		" - v0-bs: use MPEG AudioSampleEntry v0 and the channel count from the bitstream (even if greater than 2) - default\n"
+		" - v0-2: use MPEG AudioSampleEntry v0 and the channel count is forced to 2\n"
+		" - v1: use MPEG AudioSampleEntry v1 and the channel count from the bitstream\n"
+		" - v1-qt: use QuickTime Sound Sample Description Version 1 and the channel count from the bitstream (even if greater than 2). This will also trigger using alis data references instead of url, even for non-audio tracks", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("audio_roll", NULL, "`S` add a roll sample group with roll_distance `N` for audio tracks", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("roll", NULL, "`S` add a roll sample group with roll_distance `N`", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("proll", NULL, "`S` add a preroll sample group with roll_distance `N`", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("mpeg4", NULL, "`X` same as -mpeg4() option", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("nosei", NULL, "discard all SEI messages during import", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("svc", NULL, "import SVC/LHVC with explicit signaling (no AVC base compatibility)", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("nosvc", NULL, "discard SVC/LHVC data when importing", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("svcmode", NULL, "`DS` set SVC/LHVC import mode. Value can be:\n"
+		" - split: each layer is in its own track\n"
+		" - merge: all layers are merged in a single track\n"
+		" - splitbase: all layers are merged in a track, and the AVC base in another\n"
+		" - splitnox: each layer is in its own track, and no extractors are written\n"
+		" - splitnoxib: each layer is in its own track, no extractors are written, using inband param set signaling", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("temporal", NULL, "`DS` set HEVC/LHVC temporal sublayer import mode. Value can be:\n"
+		" - split: each sublayer is in its own track\n"
+		" - splitbase: all sublayers are merged in a track, and the HEVC base in another\n"
+		" - splitnox: each layer is in its own track, and no extractors are written", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("subsamples", NULL, "add SubSample information for AVC+SVC", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("deps", NULL, "import sample dependency information for AVC and HEVC", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("ccst", NULL, "`S` add default HEIF ccst box to visual sample entry", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("forcesync", NULL, "force non IDR samples with I slices (OpenGOP or GDR) to be marked as sync points\n"
+		"Warning: RESULTING FILE IS NOT COMPLIANT WITH THE SPEC but will fix seeking in most players", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("xps_inband", NULL, "`XC` set xPS inband for AVC/H264 and HEVC (for reverse operation, re-import from raw media)", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("xps_inbandx", NULL, "`XC` same as xps_inband and also keep first xPS in sample description", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("au_delim", NULL, "keep AU delimiter NAL units in the imported file", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("max_lid", NULL, "set HEVC max layer ID to be imported to `N` (by default imports all layers)", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("max_tid", NULL, "set HEVC max temporal ID to be imported to `N` (by default imports all temporal sublayers)", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("tiles", NULL, "`S` add HEVC tiles signaling and NALU maps without splitting the tiles into different tile tracks", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("split_tiles", NULL, "`DS` split HEVC tiles into different tile tracks, one tile (or all tiles of one slice) per track", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("negctts", NULL, "`S` use negative CTS-DTS offsets (ISO4 brand). Use `negctts=no` to force using positive offset on existing track", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("chap", NULL, "`S` specify the track is a chapter track", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("chapter", NULL, "`S` add a single chapter (old nero format) with given name lasting the entire file", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("chapfile", NULL, "`S` add a chapter file (old nero format)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("layout", NULL, "`S` specify the track layout as `WxHxXxYxLAYER`. If `W` (resp `H`) is 0, the max width (resp height) of the tracks in the file are used", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("rescale", NULL, "`S` force media timescale to TS (int or fraction) and change the media duration", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("sampdur", NULL, "`S` force all samples duration (`D`) or sample durations and media timescale (`D/TS`), used to patch CFR files with broken timings", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("timescale", NULL, "`S` set imported media timescale to TS", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("moovts", NULL, "`S` set movie timescale to TS. A negative value picks the media timescale of the first track imported", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("noedit", NULL, "`XS` do not set edit list when importing B-frames video tracks", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("rvc", NULL, "`S` set RVC configuration for the media", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("fmt", NULL, "override format detection with given format - disable data probing and force `ext` option on source", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("profile", NULL, "`S` override AVC profile. Integer value, or `high444`, `high`, `extended`, `main`, `baseline`", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("level", NULL, "`S` override AVC level, if value < 6, interpreted as decimal expression", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("compat", NULL, "`S` force the profile compatibility flags for the H.264 content", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("novpsext", NULL, "remove VPS extensions from HEVC VPS", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("keepav1t", NULL, "keep AV1 temporal delimiter OBU in samples, might help if source file had losses", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("dlba", NULL, "`S` force DolbyAtmos mode for EAC3. Value can be\n"
+		"- no: disable Atmos signaling\n"
+		"- auto: use Atmos signaling from first sample\n"
+		"- N: force Atmos signaling using complexibility type index N", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("font", NULL, "specify font name for text import (default `Serif`)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("size", NULL, "specify font size for text import (default `18`)", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("text_layout", NULL, "specify the track text layout as WxHxXxY\n"
+		" - if W (resp H) = 0: the max width (resp height) of the tracks in the file are used\n"
+		" - if Y=-1: the layout is moved to the bottom of the track area\n"
+		" - X and Y can be omitted: `:layout=WxH`", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("swf-global", NULL, "all SWF defines are placed in first scene replace rather than when needed", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-no-ctrl", NULL, "use a single stream for movie control and dictionary (this will disable ActionScript)", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-no-text", NULL, "remove all SWF text", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-no-font", NULL, "remove all embedded SWF Fonts (local playback host fonts used)", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-no-line", NULL, "remove all lines from SWF shapes", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-no-grad", NULL, "remove all gradients from SWF shapes", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-quad", NULL, "use quadratic bezier curves instead of cubic ones", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-xlp", NULL, "support for lines transparency and scalability", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-ic2d", NULL, "use indexed curve 2D hardcoded proto", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-same-app", NULL, "appearance nodes are reused", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("swf-flatten", NULL, "complementary angle below which 2 lines are merged, `0` means no flattening", NULL, NULL, GF_ARG_DOUBLE, 0),
+	GF_DEF_ARG("kind", NULL, "`S` set kind for the track as `schemeURI=value`", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("txtflags", NULL, "set display flags (hexa number) of text track. Use `txtflags+=FLAGS` to add flags and `txtflags-=FLAGS` to remove flags", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("rate", NULL, "force average rate and max rate to VAL (in bps) in btrt box. If 0, removes btrt box", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("stz2", NULL, "`S` use compact size table (for low-bitrates)", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("bitdepth", NULL, "set bit depth to VAL for imported video content (default is 24)", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("colr", NULL, "`S` set color profile for imported video content. Value is formatted as:\n"
+		" - nclc,p,t,m: with `p` colour primary (int or string), `t` transfer characteristics (int or string) and `m` matrix coef (int or string), cf `-h cicp`\n"
+		" - nclx,p,t,m,r: same as `nclx` with r full range flag (`yes`, `on` or `no`, `off`)\n"
+		" - prof,path: with path indicating the file containing the ICC color profile\n"
+		" - rICC,path: with path indicating the file containing the restricted ICC color profile\n"
+		" - 'none': removes color info", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("hdr", NULL, "`S` set HDR info on track (see -hdr(MP4B_GEN) ), 'none' removes HDR info", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("dvp", "dv-profile", "`S` set the Dolby Vision profile on imported track\n"
+	"- Profile is an integer, or `none` to remove DV signaling\n"
+	"- Profile can be suffixed with compatibility ID, e.g. `5.hdr10`\n"
+	"- Allowed compatibility ID are `none`, `hdr10`, `bt709`, `hlg709`, `hlg2100`, `bt2020`, `brd`, or integer value as per DV spec\n"
+	"- Profile can be prefixed with 'f' to force DV codec type signaling, e.g. `f8.2`", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("fullrange", NULL, "`S` force the video fullrange type in VUI for the AVC|H264 content (value `yes`, `on` or `no`, `off`)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("videofmt", NULL, "`S` force the video format in VUI for AVC|H264 and HEVC content, value can be `component`, `pal`, `ntsc`, `secam`, `mac`, `undef`", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("colorprim", NULL, "`S` force the colour primaries in VUI for AVC|H264 and HEVC (int or string, cf `-h cicp`)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("colortfc", NULL, "`S` force transfer characteristics in VUI for AVC|H264 and HEVC (int or string, cf `-h cicp`)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("colormx", NULL, "`S` force the matrix coefficients in VUI for the AVC|H264 and HEVC content (int or string, cf `-h cicp`)", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("tc", NULL, "`S` inject a single QT timecode. Value is formatted as:\n"
+		" - dFPS/FPS_den,h,m,s,f,framespertick: optional drop flag, framerate (integer or fractional), hours, minutes, seconds and frame number\n"
+		" - : `d` is an optional flag used to indicate that the counter is in drop-frame format\n"
+		" - : the `framespertick` is optional and defaults to round(framerate); it indicates the number of frames per counter tick", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("edits", NULL, "`S` override edit list, same syntax as -edits()", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("lastsampdur", NULL, "`S` set duration of the last sample. Value is formatted as:\n"
+		" - no value: use the previous sample duration\n"
+		" - integer: indicate the duration in milliseconds\n"
+		" - N/D: indicate the duration as fractional second", NULL, NULL, GF_ARG_STRING, 0),
+	GF_DEF_ARG("ID", NULL, "`S` set target ID\n"
+		" - a value of 0 (default) will try to keep source track ID\n"
+		" - a value of -1 will ignore source track ID\n"
+		" - other value will try to set track ID to this value if no other track with same ID is present"
+		"", NULL, NULL, GF_ARG_INT, 0),
+	GF_DEF_ARG("stats", "fstat", "`C` print filter session stats after import", NULL, NULL, GF_ARG_BOOL, 0),
+	GF_DEF_ARG("graph", "fgraph", "`C` print filter session graph after import", NULL, NULL, GF_ARG_BOOL, 0),
+	{"sopt:OPTS", NULL, "set `OPTS` as additional arguments to source filter. `OPTS` can be any usual filter argument, see filter doc `gpac -h doc`(Filters)"},
+	{"dopt:OPTS", NULL, "`X` set `OPTS` as additional arguments to destination filter(mp4mx). OPTS can be any usual filter argument, see filter doc `gpac -h doc`(Filters)"},
+	{"@f1:args@fN:args", NULL, "set a filter chain to insert before the multiplexer. Each filter in the chain is formatted as a regular filter, see filter doc `gpac -h doc`(Filters). A `@@` separator starts a new chain (see DASH help). The last filter in each chain shall not have any ID specified"},
+	{0}
+};
+
+void PrintImportUsage()
+{
+	u32 i;
+
+	gf_sys_format_help(helpout, help_flags, "# Importing Options\n"
+		"# File importing\n"
+		"Syntax is -add() / -cat() `URL#FRAGMENT:opt1...:optN=val`\n"
+		"This process will create the destination file if not existing, and add the track(s) to it. If you wish to always create a new destination file, add -new(MP4B_GEN).\n"
+		"The supported input media types depend on your installation, check filters documentation(Filters) for more info.\n"
+		" \n"
+		"To select a desired media track from a source, a fragment identifier '#' can be specified, before any other options. The following syntax is used:\n"
+		"- `#video`: adds the first video track found in source\n"
+		"- `#audio`: adds the first audio track found in source\n"
+		"- `#auxv`: adds the first auxiliary video track found in source\n"
+		"- `#pict`: adds the first picture track found in source\n"
+		"- `#trackID=ID` or `#ID`: adds the specified track. For IsoMedia files, ID is the track ID. For other media files, ID is the value indicated by `MP4Box -info inputFile`\n"
+		"- `#pid=ID`: number of desired PID for MPEG-2 TS sources\n"
+		"- `#prog_id=ID`: number of desired program for MPEG-2 TS sources\n"
+		"- `#program=NAME`: name of desired program for MPEG-2 TS sources\n"
+		" \n"
+		"By default all imports are performed sequentially, and final interleaving is done at the end; this however requires a temporary file holding original ISOBMF file (if any) and added files before creating the final output. Since this can become quite large, it is possible to add media to a new file without temporary storage, using -flat(MP4B_GEN) option, but this disables media interleaving.\n"
+		" \n"
+		"If you wish to create an interleaved new file with no temporary storage, use the -newfs(MP4B_GEN) option. The interleaving might not be as precise as when using -new() since it is dependent on multiplexer input scheduling (each execution might lead to a slightly different result). Additionally in this mode: \n"
+		" - Some multiplexing options (marked with `X` below) will be activated for all inputs (e.g. it is not possible to import one AVC track with `xps_inband` and another without).\n"
+		" - Some multiplexing options (marked as `D` below) cannot be used as they require temporary storage for file edition.\n"
+		" - Usage of -cat() is possible, but concatenated sources will not be interleaved in the output. If you wish to perform more complex cat/add operations without temp file, use a playlist(flist).\n"
+		" \n"
+		"Source URL can be any URL supported by GPAC, not limited to local files.\n"
+		" \n"
+		"Note: When importing SRT or SUB files, MP4Box will choose default layout options to make the subtitle appear at the bottom of the video. You SHOULD NOT import such files before any video track is added to the destination file, otherwise the results will likely not be useful (default SRT/SUB importing uses default serif font, fontSize 18 and display size 400x60). For more details, check TTXT doc(Subtitling-with-GPAC).\n"
+		" \n"
+		"When importing several tracks/sources in one pass, all options will be applied if relevant to each source. These options are set for all imported streams. If you need to specify these options per stream, set per-file options using the syntax `-add stream:opt1:...:optN`.\n"
+		" \n"
+		"The import file name may be set to empty or `self`, indicating that the import options should be applied to the destination file track(s).\n"
+		"EX -add self:moovts=-1:noedit src.mp4\n"
+		"This will apply `moovts` and `noedit` option to all tracks in src.mp4\n"
+		"EX -add self#2:moovts=-1:noedit src.mp4\n"
+		"This will apply `moovts` and `noedit` option to track with `ID=2` in src.mp4\n"
+		"Only per-file options marked with a `S` are possible in this mode.\n"
+		" \n"
+		"When importing an ISOBMFF/QT file, only options marked as `C` or `S` can be used.\n"
+		" \n"
+		"Allowed per-file options:\n\n"
+	);
+
+	i=0;
+	while (m4b_imp_fileopt_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_imp_fileopt_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags | GF_PRINTARG_NO_DASH, arg, "mp4box-import");
+	}
+
+	gf_sys_format_help(helpout, help_flags, "\n"
+		"Note: `sopt`, `dopt` and `@f` must be placed after all other options.\n"
+		"# Global import options\n"
+	);
+
+	i=0;
+	while (m4b_imp_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_imp_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-import");
+	}
+}
+
+Bool mp4box_check_isom_fileopt(char *opt)
+{
+	GF_GPACArg *arg = NULL;
+	u32 i=0;
+
+	while (m4b_imp_fileopt_argsi.name) {
+		arg = (GF_GPACArg *) &m4b_imp_fileopt_argsi;
+		i++;
+		if (!stricmp(arg->name, opt)) break;
+		arg = NULL;
+	}
+	if (!arg) {
+		fprintf(stderr, "Option %s not described in doc, please report to GPAC devs!\n", opt);
+		return GF_FALSE;
+	}
+	if (arg->description0 != '`')
+		return GF_FALSE;
+	const char *d = arg->description+1;
+	while (d0 != '`') {
+		if (d0=='S') return GF_TRUE;
+		if (d0=='C') return GF_TRUE;
+		d++;
+	}
+	return GF_FALSE;
+}
+
+
+MP4BoxArg m4b_senc_args =
+{
+#ifndef GPAC_DISABLE_SCENE_ENCODER
+ 	MP4BOX_ARG("mp4", "specify input file is for BIFS/LASeR encoding", GF_ARG_BOOL, 0, &encode, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("def", "encode DEF names in BIFS", GF_ARG_BOOL, 0, &smenc_opts.flags, GF_SM_ENCODE_USE_NAMES, ARG_BIT_MASK),
+ 	MP4BOX_ARG("sync", "force BIFS sync sample generation every given time in ms (cannot be used with -shadow() or -carousel() )", GF_ARG_INT, 0, parse_senc_param, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("shadow", "force BIFS sync shadow sample generation every given time in ms (cannot be used with -sync() or -carousel() )", GF_ARG_INT, 0, parse_senc_param, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("carousel", "use BIFS carousel (cannot be used with -sync() or -shadow() )", GF_ARG_INT, 0, parse_senc_param, 2, ARG_IS_FUN),
+
+ 	MP4BOX_ARG("sclog", "generate scene codec log file if available", GF_ARG_BOOL, 0, &do_scene_log, 0, 0),
+ 	MP4BOX_ARG("ms", "import tracks from the given file", GF_ARG_STRING, 0, &mediaSource, 0, 0),
+ 	MP4BOX_ARG("ctx-in", "specify initial context (MP4/BT/XMT) file for chunk processing. Input file must be a commands-only file", GF_ARG_STRING, 0, parse_senc_param, 5, ARG_IS_FUN),
+ 	MP4BOX_ARG("ctx-out", "specify storage of updated context (MP4/BT/XMT) file for chunk processing, optional", GF_ARG_STRING, 0, &output_ctx, 0, 0),
+ 	MP4BOX_ARG("resolution", "resolution factor (-8 to 7, default 0) for LASeR encoding, and all coordinates are multiplied by `2^res` before truncation (LASeR encoding)", GF_ARG_INT, 0, &smenc_opts.resolution, 0, 0),
+ 	MP4BOX_ARG("coord-bits", "number of bits used for encoding truncated coordinates (0 to 31, default 12) (LASeR encoding)", GF_ARG_INT, 0, &smenc_opts.coord_bits, 0, 0),
+ 	MP4BOX_ARG("scale-bits", "extra bits used for encoding truncated scales (0 to 4, default 0) (LASeR encoding)", GF_ARG_INT, 0, &smenc_opts.scale_bits, 0, 0),
+ 	MP4BOX_ARG("auto-quant", "resolution is given as if using -resolution() but coord-bits and scale-bits are inferred (LASeR encoding)", GF_ARG_INT, 0, parse_senc_param, 3, ARG_IS_FUN),
+ 	MP4BOX_ARG("global-quant", "resolution is given as if using -resolution() but the res is inferred (BIFS encoding)", GF_ARG_INT, 0, parse_senc_param, 4, ARG_IS_FUN),
+#endif
+ 	{0}
+};
+
+
+void PrintEncodeUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# MPEG-4 Scene Encoding Options\n"
+		"## General considerations\n"
+		"MP4Box supports encoding and decoding of of BT, XMT, VRML and (partially) X3D formats int MPEG-4 BIFS, and encoding and decoding of XSR and SVG into MPEG-4 LASeR\n"
+		"Any media track specified through a `MuxInfo` element will be imported in the resulting MP4 file.\n"
+		"See https://wiki.gpac.io/MPEG-4-BIFS-Textual-Format and related pages.\n"
+		"## Scene Random Access\n"
+		"MP4Box can encode BIFS or LASeR streams and insert random access points at a given frequency. This is useful when packaging content for broadcast, where users will not turn in the scene at the same time. In MPEG-4 terminology, this is called the __scene carousel__."
+		"## BIFS Chunk Processing\n"
+		"The BIFS chunk encoding mode allows encoding single BIFS access units from an initial context and a set of commands.\n"
+		"The generated AUs are raw BIFS (not SL-packetized), in files called FILE-ESID-AUIDX.bifs, with FILE the basename of the input file.\n"
+		"Commands with a timing of 0 in the input will modify the carousel version only (i.e. output context).\n"
+		"Commands with a timing different from 0 in the input will generate new AUs.\n"
+		" \n"
+		"Options:\n"
+	);
+
+	while (m4b_senc_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_senc_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-senc");
+	}
+}
+
+MP4BoxArg m4b_crypt_args =
+{
+ 	MP4BOX_ARG("crypt", "encrypt the input file using the given `CryptFile`", GF_ARG_STRING, 0, parse_cryp, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("decrypt", "decrypt the input file, potentially using the given `CryptFile`. If `CryptFile` is not given, will fail if the key management system is not supported", GF_ARG_STRING, 0, parse_cryp, 1, ARG_IS_FUN | ARG_EMPTY),
+ 	MP4BOX_ARG_S("set-kms", "tkID=kms_uri", "change ISMA/OMA KMS location for a given track or for all tracks if `all=` is used", 0, parse_track_action, TRACK_ACTION_SET_KMS_URI, ARG_IS_FUN),
+ 	{0}
+};
+
+void PrintEncryptUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# Encryption/Decryption Options\n"
+	"MP4Box supports encryption and decryption of ISMA, OMA and CENC content, see encryption filter `gpac -h cecrypt`(cecrypt).\n"
+	"It requires a specific XML file called `CryptFile`, whose syntax is available at https://wiki.gpac.io/Common-Encryption\n"
+	"Image files (HEIF) can also be crypted / decrypted, using CENC only.\n"
+	" \n"
+	"Options:\n"
+	);
+	while (m4b_crypt_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_crypt_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-crypt");
+	}
+}
+
+MP4BoxArg m4b_hint_args =
+{
+#ifndef GPAC_DISABLE_STREAMING
+ 	MP4BOX_ARG("hint", "hint the file for RTP/RTSP", GF_ARG_BOOL, 0, &do_hint, 0, ARG_OPEN_EDIT),
+ 	{"mtu", NULL, "specify RTP MTU (max size) in bytes (this includes 12 bytes RTP header)", "1450", NULL, GF_ARG_INT, 0, &MTUSize, 0, 0},
+ 	MP4BOX_ARG("copy", "copy media data to hint track rather than reference (speeds up server but takes much more space)", GF_ARG_BOOL, 0, &HintCopy, 0, 0),
+ 	MP4BOX_ARG_S("multi", "maxptime", "enable frame concatenation in RTP packets if possible (with max duration 100 ms or `maxptime` ms if given)", 0, parse_multi_rtp, 0, ARG_IS_FUN),
+ 	{"rate", NULL, "specify rtp rate in Hz when no default for payload", "90000", NULL, GF_ARG_INT, 0, &rtp_rate, 0, 0},
+ 	MP4BOX_ARG("mpeg4", "force MPEG-4 generic payload whenever possible", GF_ARG_BOOL, 0, &import_flags, GF_IMPORT_FORCE_MPEG4, ARG_BIT_MASK),
+ 	MP4BOX_ARG("latm", "force MPG4-LATM transport for AAC streams", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_USE_LATM_AAC, ARG_BIT_MASK),
+ 	MP4BOX_ARG("static", "enable static RTP payload IDs whenever possible (by default, dynamic payloads are always used)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_USE_STATIC_ID, ARG_BIT_MASK),
+ 	MP4BOX_ARG("add-sdp", "add given SDP string to movie (`string`) or track (`tkID:string`), `tkID` being the track ID or the hint track ID", GF_ARG_STRING, 0, parse_sdp_ext, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("no-offset", "signal no random offset for sequence number and timestamp (support will depend on server)", GF_ARG_BOOL, 0, &hint_no_offset, 0, 0),
+ 	MP4BOX_ARG("unhint", "remove all hinting information from file", GF_ARG_BOOL, 0, &remove_hint, 0, ARG_OPEN_EDIT),
+ 	MP4BOX_ARG("group-single", "put all tracks in a single hint group", GF_ARG_BOOL, 0, &single_group, 0, 0),
+ 	MP4BOX_ARG("ocr", "force all MPEG-4 streams to be synchronized (MPEG-4 Systems only)", GF_ARG_BOOL, 0, &force_ocr, 0, 0),
+ 	MP4BOX_ARG("rap", "signal random access points in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, parse_rap_ref, 0, ARG_IS_FUN | ARG_EMPTY),
+ 	MP4BOX_ARG("ts", "signal AU Time Stamps in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_SIGNAL_TS, ARG_BIT_MASK),
+	MP4BOX_ARG("size", "signal AU size in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_SIGNAL_SIZE, ARG_BIT_MASK),
+ 	MP4BOX_ARG("idx", "signal AU sequence numbers in RTP packets (MPEG-4 Systems)", GF_ARG_BOOL, 0, &hint_flags, GP_RTP_PCK_SIGNAL_AU_IDX, ARG_BIT_MASK),
+ 	MP4BOX_ARG("iod", "prevent systems tracks embedding in IOD (MPEG-4 Systems), not compatible with -isma()", GF_ARG_BOOL, 0, &regular_iod, 0, 0),
+#endif
+ 	{0}
+};
+
+void PrintHintUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# Hinting Options\n"
+		"IsoMedia hinting consists in creating special tracks in the file that contain transport protocol specific information and optionally multiplexing information. These tracks are then used by the server to create the actual packets being sent over the network, in other words they provide the server with hints on how to build packets, hence their names `hint tracks`.\n"
+		"MP4Box supports creation of hint tracks for RTSP servers supporting these such as QuickTime Streaming Server, DarwinStreaming Server or 3GPP-compliant RTSP servers.\n"
+		"Note: GPAC streaming tools rtp output(rtpout) and rtsp server(rtspout) do not use hint tracks, they use on-the-fly packetization "
+		"from any media sources, not just MP4\n"
+		" \n"
+		"Options:\n"
+	);
+	while (m4b_hint_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_hint_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-hint");
+	}
+}
+
+
+MP4BoxArg m4b_extr_args =
+{
+ 	MP4BOX_ARG("raw", "extract given track in raw format when supported. Use `tkID:output=FileName` to set output file name", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_NATIVE, ARG_IS_FUN),
+ 	MP4BOX_ARG("raws", "extract each sample of the given track to a file. Use `tkID:N` to extract the Nth sample", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_RAW_SAMPLES, ARG_IS_FUN),
+ 	MP4BOX_ARG("nhnt", "extract given track to NHNT(nhntr) format", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_NHNT, ARG_IS_FUN),
+ 	MP4BOX_ARG("nhml", "extract given track to NHML(nhmlr) format. Use `tkID:full` for full NHML dump with all packet properties", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_NHML, ARG_IS_FUN),
+ 	MP4BOX_ARG("webvtt-raw", "extract given track as raw media in WebVTT as metadata. Use `tkID:embedded` to include media data in the WebVTT file", GF_ARG_STRING, 0, parse_track_dump, GF_EXPORT_WEBVTT_META, ARG_IS_FUN),
+ 	MP4BOX_ARG("single", "extract given track to a new mp4 file", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_MP4, ARG_IS_FUN),
+ 	MP4BOX_ARG("six", "extract given track as raw media in **experimental** XML streaming instructions", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_SIX, ARG_IS_FUN),
+ 	MP4BOX_ARG("mux", "multiplex input file to given destination", GF_ARG_STRING, 0, &mux_name, 0, 0),
+ 	MP4BOX_ARG("qcp", "same as -raw() but defaults to QCP file for EVRC/SMV", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_NATIVE | GF_EXPORT_USE_QCP, ARG_IS_FUN),
+ 	MP4BOX_ARG("saf", "multiplex input file to SAF multiplex", GF_ARG_BOOL, 0, &do_saf, 0, 0),
+ 	MP4BOX_ARG("dvbhdemux", "demultiplex DVB-H file into IP Datagrams sent on the network", GF_ARG_BOOL, 0, &dvbhdemux, 0, 0),
+ 	MP4BOX_ARG("raw-layer", "same as -raw() but skips SVC/MVC/LHVC extractors when extracting", GF_ARG_INT, 0, parse_track_dump, GF_EXPORT_NATIVE | GF_EXPORT_SVC_LAYER, ARG_IS_FUN),
+ 	MP4BOX_ARG("diod", "extract file IOD in raw format", GF_ARG_BOOL, 0, &dump_iod, 0, 0),
+ 	MP4BOX_ARG("mpd", "convert given HLS or smooth manifest (local or remote http) to MPD - options `-url-template` and `-segment-timeline`can be used in this mode. \nNote: This only provides basic conversion, for more advanced conversions, see `gpac -h dasher`\n \nWarning: This is not compatible with other DASH options and does not convert associated segments", GF_ARG_STRING, 0, &do_mpd_conv, 0, 0),
+ 	{0}
+};
+
+void PrintExtractUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# Extracting Options\n"
+	"MP4Box can be used to extract media tracks from MP4 files. If you need to convert these tracks however, please check the filters doc(Filters).\n"
+	" \n"
+	"Options:\n"
+	);
+	while (m4b_extr_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_extr_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
+	}
+}
+
+MP4BoxArg m4b_dump_args =
+{
+ 	MP4BOX_ARG("std", "dump/write to stdout and assume stdout is opened in binary mode", GF_ARG_BOOL, 0, &dump_std, 2, 0),
+ 	MP4BOX_ARG("stdb", "dump/write to stdout and try to reopen stdout in binary mode", GF_ARG_BOOL, 0, &dump_std, 1, 0),
+ 	MP4BOX_ARG("tracks", "print the number of tracks on stdout", GF_ARG_BOOL, 0, &get_nb_tracks, 0, 0),
+ 	MP4BOX_ARG("info", "print movie info (no parameter) or track extended info with specified ID", GF_ARG_STRING, 0, parse_file_info, 0, ARG_IS_FUN|ARG_EMPTY),
+ 	MP4BOX_ARG("infon", "print track info for given track number, 1 being the first track in the file", GF_ARG_STRING, 0, parse_file_info, 1, ARG_IS_FUN|ARG_EMPTY),
+ 	MP4BOX_ARG("infox", "print movie and track extended info (same as -info N` for each track)", GF_ARG_BOOL, 0, parse_file_info, 2, ARG_IS_FUN|ARG_EMPTY),
+ 	MP4BOX_ARG_ALT("diso", "dmp4", "dump IsoMedia file boxes in XML output", GF_ARG_BOOL, 0, &dump_isom, 1, 0),
+ 	MP4BOX_ARG("dxml", "dump IsoMedia file boxes and known track samples in XML output", GF_ARG_BOOL, 0, &dump_isom, 2, 0),
+ 	MP4BOX_ARG("disox", "dump IsoMedia file boxes except sample tables in XML output", GF_ARG_BOOL, 0, &dump_isom, 3, 0),
+ 	MP4BOX_ARG("keep-ods", "do not translate ISOM ODs and ESDs tags (debug purpose only)", GF_ARG_BOOL, 0, &no_odf_conf, 0, 0),
+#ifndef GPAC_DISABLE_SCENE_DUMP
+ 	MP4BOX_ARG("bt", "dump scene to BT format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_BT, ARG_HAS_VALUE),
+ 	MP4BOX_ARG("xmt", "dump scene to XMT format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_XMTA, 0),
+ 	MP4BOX_ARG("wrl", "dump scene to VRML format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_VRML, 0),
+ 	MP4BOX_ARG("x3d", "dump scene to X3D XML format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_X3D_XML, 0),
+ 	MP4BOX_ARG("x3dv", "dump scene to X3D VRML format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_X3D_VRML, 0),
+ 	MP4BOX_ARG("lsr", "dump scene to LASeR XML (XSR) format", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_LASER, 0),
+ 	MP4BOX_ARG("svg", "dump scene to SVG", GF_ARG_BOOL, 0, &dump_mode, GF_SM_DUMP_SVG, 0),
+#endif
+ 	MP4BOX_ARG("drtp", "dump rtp hint samples structure to XML output", GF_ARG_BOOL, 0, &dump_rtp, 0, 0),
+ 	MP4BOX_ARG("dts", "print sample timing, size and position in file to text output", GF_ARG_BOOL, 0, parse_dump_ts, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("dtsx", "same as -dts() but does not print offset", GF_ARG_BOOL, 0, &dump_timestamps, 2, 0),
+ 	MP4BOX_ARG("dtsc", "same as -dts() but analyses each sample for duplicated dts/cts (__slow !__)", GF_ARG_BOOL, 0, &dump_timestamps, 3, 0),
+ 	MP4BOX_ARG("dtsxc", "same as -dtsc() but does not print offset (__slow !__)", GF_ARG_BOOL, 0, &dump_timestamps, 4, 0),
+ 	MP4BOX_ARG("dnal", "print NAL sample info of given track", GF_ARG_INT, 0, parse_dnal, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("dnalc", "print NAL sample info of given track, adding CRC for each nal", GF_ARG_INT, 0, parse_dnal, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("dnald", "print NAL sample info of given track without DTS and CTS info", GF_ARG_INT, 0, parse_dnal, 2, ARG_IS_FUN),
+ 	MP4BOX_ARG("dnalx", "print NAL sample info of given track without DTS and CTS info and adding CRC for each nal", GF_ARG_INT, 0, parse_dnal, 2|1, ARG_IS_FUN),
+ 	MP4BOX_ARG("sdp", "dump SDP description of hinted file", GF_ARG_BOOL, 0, &print_sdp, 0, 0),
+ 	MP4BOX_ARG("dsap", "dump DASH SAP cues (see -cues) for a given track", GF_ARG_INT, 0, parse_dsap, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("dsaps", "same as -dsap() but only print sample number", GF_ARG_INT, 0, parse_dsap, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("dsapc", "same as -dsap() but only print CTS", GF_ARG_INT, 0, parse_dsap, 2, ARG_IS_FUN),
+ 	MP4BOX_ARG("dsapd", "same as -dsap() but only print DTS", GF_ARG_INT, 0, parse_dsap, 3, ARG_IS_FUN),
+ 	MP4BOX_ARG("dsapp", "same as -dsap() but only print presentation time", GF_ARG_INT, 4, parse_dsap, 4, ARG_IS_FUN),
+ 	MP4BOX_ARG("dcr", "dump ISMACryp samples structure to XML output", GF_ARG_BOOL, 0, &dump_cr, 0, 0),
+ 	MP4BOX_ARG("dchunk", "dump chunk info", GF_ARG_BOOL, 0, &dump_chunk, 0, 0),
+ 	MP4BOX_ARG("dump-cover", "extract cover art", GF_ARG_BOOL, 0, &dump_cart, 0, 0),
+ 	MP4BOX_ARG("dump-chap", "extract chapter file as TTXT format", GF_ARG_BOOL, 0, &dump_chap, 1, 0),
+ 	MP4BOX_ARG("dump-chap-ogg", "extract chapter file as OGG format", GF_ARG_BOOL, 0, &dump_chap, 2, 0),
+ 	MP4BOX_ARG("dump-chap-zoom", "extract chapter file as zoom format", GF_ARG_BOOL, 0, &dump_chap, 3, 0),
+ 	MP4BOX_ARG_S("dump-udta", "tkID:4cc", "extract user data for the given 4CC. If `tkID` is given, dumps from UDTA of the given track ID, otherwise moov is used", 0, parse_dump_udta, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("mergevtt", "merge vtt cues while dumping", GF_ARG_BOOL, 0, &merge_vtt_cues, 0, 0),
+ 	MP4BOX_ARG("ttxt", "convert input subtitle to GPAC TTXT format if no parameter. Otherwise, dump given text track to GPAC TTXT format", GF_ARG_INT, 0, parse_ttxt, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("srt", "convert input subtitle to SRT format if no parameter. Otherwise, dump given text track to SRT format", GF_ARG_INT, 0, parse_ttxt, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("nstat", "generate node/field statistics for scene", GF_ARG_BOOL, 0, &stat_level, 1, 0),
+ 	MP4BOX_ARG("nstats", "generate node/field statistics per Access Unit", GF_ARG_BOOL, 0, &stat_level, 2, 0),
+ 	MP4BOX_ARG("nstatx", "generate node/field statistics for scene after each AU", GF_ARG_BOOL, 0, &stat_level, 3, 0),
+ 	MP4BOX_ARG("hash", "generate SHA-1 Hash of the input file", GF_ARG_BOOL, 0, &do_hash, 0, 0),
+ 	MP4BOX_ARG("comp", "replace with compressed version all top level box types given as parameter, formatted as `orig_4cc_1=comp_4cc_1,orig_4cc_2=comp_4cc_2`", GF_ARG_STRING, 0, parse_comp_box, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("topcount", "print to stdout the number of top-level boxes matching box types given as parameter, formatted as `4cc_1,4cc_2N`", GF_ARG_STRING, 0, parse_comp_box, 2, ARG_IS_FUN),
+ 	MP4BOX_ARG("topsize", "print to stdout the number of bytes of top-level boxes matching types given as parameter, formatted as `4cc_1,4cc_2N` or `all` for all boxes", GF_ARG_STRING, 0, parse_comp_box, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("bin", "convert input XML file using NHML bitstream syntax to binary", GF_ARG_BOOL, 0, &do_bin_xml, 0, 0),
+ 	MP4BOX_ARG("mpd-rip", "fetch MPD and segment to disk", GF_ARG_BOOL, 0, &do_mpd_rip, 0, 0),
+ 	//MP4BOX_ARG_S("udp-write", "IP:port", "write input name to UDP (default port 2345)", GF_FS_ARG_HINT_EXPERT, &udp_dest, 0, GF_ARG_STRING),
+	{"udp-write", NULL, "write input name to UDP (default port 2345)", "IP:port", NULL, GF_ARG_STRING, GF_FS_ARG_HINT_EXPERT, &udp_dest, 0, 0},
+ 	MP4BOX_ARG("raw-cat", "raw concatenation of given file with input file", GF_ARG_STRING, GF_FS_ARG_HINT_EXPERT, &raw_cat, 0, 0),
+ 	MP4BOX_ARG("wget", "fetch resource from http(s) URL", GF_ARG_STRING, GF_FS_ARG_HINT_EXPERT, &do_wget, 0, 0),
+ 	MP4BOX_ARG("dm2ts", "dump timing of an input MPEG-2 TS stream sample timing", GF_ARG_BOOL, 0, &dump_m2ts, 0, 0),
+ 	MP4BOX_ARG("check-xml", "check XML output format for -dnal*, -diso* and -dxml options", GF_ARG_BOOL, 0, &dump_check_xml, 0, 0),
+ 	{0}
+};
+
+void PrintDumpUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# File Dumping\n"
+	" \n"
+	"MP4Box has many dump functionalities, from simple track listing to more complete reporting of special tracks.\n"
+	" \n"
+	"Options:\n"
+	);
+	while (m4b_dump_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_dump_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
+	}
+}
+
+MP4BoxArg m4b_meta_args =
+{
+ 	MP4BOX_ARG_S("set-meta", "ABCD:tk=tkID", "set meta box type, with `ABCD` the four char meta type (NULL or 0 to remove meta)\n"
+		"- tk not set: use root (file) meta\n"
+		"- tkID == 0: use moov meta\n"
+		"- tkID != 0: use meta of given track", 0, parse_meta_args, META_ACTION_SET_TYPE, ARG_IS_FUN),
+ 	MP4BOX_ARG("add-item", "add resource to meta, with parameter syntax `file_path:opt1:optN`\n"
+		"- file_path `this` or `self`: item is the file itself\n"
+		"- tk=tkID: meta location (file, moov, track)\n"
+		"- name=str: item name, none if not set\n"
+		"- type=itype: item 4cc type (not needed if mime is provided)\n"
+		"- mime=mtype: item mime type, none if not set\n"
+		"- encoding=enctype: item content-encoding type, none if not set\n"
+		"- id=ID: item ID\n"
+		"- ref=4cc,id: reference of type 4cc to an other item (can be set multiple times)\n"
+		"- group=id,type: indicate the id and type of an alternate group for this item\n"
+		"- replace: replace existing item by new item"
+		, GF_ARG_STRING, 0, parse_meta_args, META_ACTION_ADD_ITEM, ARG_IS_FUN),
+	MP4BOX_ARG("add-image", "add the given file as HEIF image item, with parameter syntax `file_path:opt1:optN`. If `filepath` is omitted, source is the input MP4 file\n"
+		"- name, id, ref: see -add-item()\n"
+		"- primary: indicate that this item should be the primary item\n"
+		"- time=t-e/i: use the next sync sample after time t (float, in sec, default 0). A negative time imports ALL intra frames as items\n"
+		" - If `e` is set (float, in sec), import all sync samples between `t` and `e`\n"
+		" - If `i` is set (float, in sec), sets time increment between samples to import\n"
+		"- split_tiles: for an HEVC tiled image, each tile is stored as a separate item\n"
+		"- image-size=wxh: force setting the image size and ignoring the bitstream info, used for grid, overlay and identity derived images also\n"
+		"- rotation=a: set the rotation angle for this image to 90*a degrees anti-clockwise\n"
+		"- mirror-axis=axis: set the mirror axis: vertical, horizontal\n"
+		"- clap=Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd: see track clap\n"
+ 		"- image-pasp=axb: force the aspect ratio of the image\n"
+ 		"- image-pixi=(a|a,b,c): force the bit depth (1 or 3 channels)\n"
+		"- hidden: indicate that this image item should be hidden\n"
+		"- icc_path: path to icc data to add as color info\n"
+		"- alpha: indicate that the image is an alpha image (should use ref=auxl also)\n"
+		"- depth: indicate that the image is a depth image (should use ref=auxl also)\n"
+		"- it=ID: indicate the item ID of the source item to import\n"
+		"- itp=ID: same as `it=` but copy over all properties of the source item\n"
+		"- tk=tkID: indicate the track ID of the source sample. If 0, uses the first video track in the file\n"
+		"- samp=N: indicate the sample number of the source sample\n"
+		"- ref: do not copy the data but refer to the final sample/item location, ignored if `filepath` is set\n"
+		"- agrid=AR: creates an automatic grid from the image items present in the file, in their declaration order. The grid will **try to** have `AR` aspect ratio if specified (float), or the aspect ratio of the source otherwise. The grid will be the primary item and all other images will be hidden\n"
+		"- av1_op_index: select the AV1 operating point to use via a1op box\n"
+		"- replace: replace existing image by new image, keeping props listed in `keep_props`\n"
+		"- keep_props=4CCs: coma-separated list of properties types to keep when replacing the image, e.g. `keep_props=auxC`\n"
+		"- auxt=URN: mark image as auxiliary using given `URN`\n"
+		"- auxd=FILE: use data from `FILE` as auxiliary extensions (cf `auxC` box)\n"
+		"- any other options will be passed as options to the media importer, see -add()"
+		, GF_ARG_STRING, 0, parse_meta_args, META_ACTION_ADD_IMAGE_ITEM, ARG_IS_FUN),
+	MP4BOX_ARG("add-derived-image", "create an image grid, overlay or identity item, with parameter syntax `:type=(grid|iovl|iden):opt1:optN`\n"
+		"- image-grid-size=rxc: set the number of rows and columns of the grid\n"
+ 		"- image-overlay-offsets=h,v,h,v*: set the horizontal and vertical offsets of the images in the overlay\n"
+ 		"- image-overlay-color=r,g,b,a: set the canvas color of the overlay 0-65535\n"
+	 "- any other options from -add-image() can be used\n", GF_ARG_STRING, 0, parse_meta_args, META_ACTION_ADD_IMAGE_DERIVED, ARG_IS_FUN),
+	MP4BOX_ARG_S_ALT("rem-item", "rem-image", "item_ID:tk=tkID", "remove resource from meta", 0, parse_meta_args, META_ACTION_REM_ITEM, ARG_IS_FUN),
+	MP4BOX_ARG_S("set-primary", "item_ID:tk=tkID", "set item as primary for meta", 0, parse_meta_args, META_ACTION_SET_PRIMARY_ITEM, ARG_IS_FUN),
+	MP4BOX_ARG_S("set-xml", "xml_file_path:tk=tkID:binary", "set meta XML data", 0, parse_meta_args, META_ACTION_SET_XML, ARG_IS_FUN),
+	MP4BOX_ARG_S("rem-xml", "tk=tkID", "remove meta XML data", 0, parse_meta_args, META_ACTION_REM_XML, ARG_IS_FUN),
+	MP4BOX_ARG_S("dump-xml", "file_path:tk=tkID", "dump meta XML to file", 0, parse_meta_args, META_ACTION_DUMP_XML, ARG_IS_FUN),
+	MP4BOX_ARG_S("dump-item", "item_ID:tk=tkID:path=fileName", "dump item to file", 0, parse_meta_args, META_ACTION_DUMP_ITEM, ARG_IS_FUN),
+	MP4BOX_ARG("package", "package input XML file into an ISO container, all media referenced except hyperlinks are added to file", GF_ARG_STRING, 0, &pack_file, 0, 0),
+	MP4BOX_ARG("mgt", "package input XML file into an MPEG-U widget with ISO container, all files contained in the current folder are added to the widget package", GF_ARG_STRING, 0, parse_mpegu, 0, ARG_IS_FUN),
+	{0}
+};
+
+void PrintMetaUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# Meta and HEIF Options\n"
+	"IsoMedia files can be used as generic meta-data containers, for examples storing XML information and sample images for a movie. The resulting file may not always contain a movie as is the case with some HEIF files or MPEG-21 files.\n"
+	" \n"
+	"These information can be stored at the file root level, as is the case for HEIF/IFF and MPEG-21 file formats, or at the movie or track level for a regular movie."
+	" \n \n");
+	while (m4b_meta_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_meta_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
+	}
+}
+
+MP4BoxArg m4b_swf_args =
+{
+#ifndef GPAC_DISABLE_SCENE_ENCODER
+ 	MP4BOX_ARG("global", "all SWF defines are placed in first scene replace rather than when needed", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_STATIC_DICT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("no-ctrl", "use a single stream for movie control and dictionary (this will disable ActionScript)", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_SPLIT_TIMELINE, ARG_BIT_MASK_REM),
+ 	MP4BOX_ARG("no-text", "remove all SWF text", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_TEXT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("no-font", "remove all embedded SWF Fonts (local playback host fonts used)", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_FONT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("no-line", "remove all lines from SWF shapes", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_LINE, ARG_BIT_MASK),
+ 	MP4BOX_ARG("no-grad", "remove all gradients from swf shapes", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_NO_GRADIENT, ARG_BIT_MASK),
+ 	MP4BOX_ARG("quad", "use quadratic bezier curves instead of cubic ones", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_QUAD_CURVE, ARG_BIT_MASK),
+ 	MP4BOX_ARG("xlp", "support for lines transparency and scalability", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_SCALABLE_LINE, ARG_BIT_MASK),
+	MP4BOX_ARG("ic2d", "use indexed curve 2D hardcoded proto", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_USE_IC2D, ARG_BIT_MASK),
+	MP4BOX_ARG("same-app", "appearance nodes are reused", GF_ARG_BOOL, 0, &swf_flags, GF_SM_SWF_REUSE_APPEARANCE, ARG_BIT_MASK),
+ 	MP4BOX_ARG("flatten", "complementary angle below which 2 lines are merged, value `0` means no flattening", GF_ARG_DOUBLE, 0, &swf_flatten_angle, 0, 0),
+#endif
+	{0}
+};
+
+void PrintSWFUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# SWF Importer Options\n"
+	 "\n"
+	 "MP4Box can import simple Macromedia Flash files (\".SWF\")\n"
+	 "You can specify a SWF input file with \'-bt\', \'-xmt\' and \'-mp4\' options\n"
+	 " \n"
+	 "Options:\n"
+	);
+	while (m4b_swf_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_swf_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
+	}
+}
+
+MP4BoxArg m4b_liveenc_args =
+{
+ 	MP4BOX_ARG("live", "enable live BIFS/LASeR encoder", GF_ARG_BOOL, 0, &live_scene, 0, 0),
+ 	GF_DEF_ARG("dst", NULL, "destination IP", NULL, NULL, GF_ARG_STRING, 0),
+ 	GF_DEF_ARG("port", NULL, "destination port", "7000", NULL, GF_ARG_INT, 0),
+ 	GF_DEF_ARG("mtu", NULL, "path MTU for RTP packets", "1450", NULL, GF_ARG_INT, 0),
+ 	GF_DEF_ARG("ifce", NULL, "IP address of the physical interface to use", NULL, NULL, GF_ARG_STRING, 0),
+ 	GF_DEF_ARG("ttl", NULL, "time to live for multicast packets", "1", NULL, GF_ARG_INT, 0),
+ 	GF_DEF_ARG("sdp", NULL, "output SDP file", "session.sdp", NULL, GF_ARG_STRING, 0),
+ 	GF_DEF_ARG("dims", NULL, "turn on DIMS mode for SVG input", NULL, NULL, GF_ARG_BOOL, 0),
+ 	GF_DEF_ARG("no-rap", NULL, "disable RAP sending and carousel generation", NULL, NULL, GF_ARG_BOOL, 0),
+ 	GF_DEF_ARG("src", NULL, "source of scene updates", NULL, NULL, GF_ARG_STRING, 0),
+ 	GF_DEF_ARG("rap", NULL, "duration in ms of base carousel; you can specify the RAP period of a single ESID (not in DIMS) using `ESID=X:time`", NULL, NULL, GF_ARG_INT, 0),
+ 	{0}
+};
+
+void PrintLiveUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "# Live Scene Encoder Options\n"
+	 "The options shall be specified as `opt_name=opt_val.\n"
+	 "Options:\n"
+	 "\n"
+	);
+	while (m4b_liveenc_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_liveenc_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-extract");
+	}
+
+	gf_sys_format_help(helpout, help_flags, " \n"
+		"Runtime options:\n"
+		"- q: quits\n"
+		"- u: inputs some commands to be sent\n"
+		"- U: same as u but signals the updates as critical\n"
+		"- e: inputs some commands to be sent without being aggregated\n"
+		"- E: same as e but signals the updates as critical\n"
+		"- f: forces RAP sending\n"
+		"- F: forces RAP regeneration and sending\n"
+		"- p: dumps current scene\n"
+	);
+}
+
+void PrintCoreUsage()
+{
+	gf_sys_format_help(helpout, help_flags, "# libgpac core options\n");
+	gf_sys_print_core_help(helpout, 0, GF_ARGMODE_ALL, 0);
+}
+
+void PrintTags()
+{
+	u32 i = 0;
+
+	gf_sys_format_help(helpout, help_flags, "# Tagging support\n"
+	"Tags are specified as a colon-separated list `tag_name=tag_value:tag2=val2`\n"
+	"Setting a tag with no value or value `NULL` removes the tag.\n"
+	"Special tag value `clear` (or `reset`) removes all tags.\n"
+	"Unsupported tags can be added using their four character code as a tag name, and string value will be assumed.\n"
+	"If the tag name length is 3, the prefix 0xA9 is used to create the four character code.\n"
+	" \n"
+	"Tags can also be loaded from a text file using `-itags filename`. The file must be in UTF8 with:\n"
+	"- lines starting with `tag_name=value` specify the start of a tag\n"
+	"- other lines specify the remainder of the last declared tag\n"
+	" \n"
+	"If tag name starts with `WM/`, the tag is added to `Xtra` box (WMA tag, string only).\n"
+	" \n"
+	"## QT metadata key\n"
+	"The tag is added as a QT metadata key if:\n"
+	"- `tag_name` starts with `QT/`\n"
+	"- or `tag_name` is not recognized and longer than 4 characters\n"
+	" \n"
+	"The `tag_name` can optionnally be prefixed with `HDLR@`, indicating the tag namespace 4CC, the default namespace being `mdta`.\n"
+	"The `tag_value` can be prefixed with:\n"
+	"- S: force string encoding (must be placed first) instead of parsing the tag value\n"
+	"- b: use 8-bit encoding for signed or unsigned int\n"
+	"- s: use 16-bit encoding for signed or unsigned int\n"
+	"- l: use 32-bit encoding for signed or unsigned int\n"
+	"- L: use 64-bit encoding for signed or unsigned int\n"
+	"- f: force float encoding for numbers\n"
+	"Numbers are converted by default and stored in variable-size mode.\n"
+	"To force a positive integer to use signed storage, add `+` in front of the number.\n"
+	"EX -tags io.gpac.some_tag=s+32\n"
+	"This will force storing value `32` in signed 16 bit format.\n"
+	"The `tag_value` can also be formatted as:\n"
+	"- XxY@WxH: a rectangle type\n"
+	"- XxY: a point type\n"
+	"- W@H: a size type\n"
+	"- A,B,C,D,E,F,G,H,I: a 3x3 matrix\n"
+	"- FNAME: data is loaded from `FNAME`, type set to jpeg or png if needed\n"
+	" \n"
+	"## Supported tag names (name, value, type, aliases)\n"
+	);
+
+	while (1) {
+		s32 type = gf_itags_get_type(i);
+		if (type<0) break;
+		const char *name = gf_itags_get_name(i);
+		u32 itag = gf_itags_get_itag(i);
+		gf_sys_format_help(helpout, help_flags | GF_PRINTARG_HIGHLIGHT_FIRST , "%s", name);
+		gf_sys_format_help(helpout, help_flags, " (%s) ", gf_4cc_to_str(itag) );
+		switch (type) {
+		case GF_ITAG_STR:
+			gf_sys_format_help(helpout, help_flags, "string"); break;
+		case GF_ITAG_INT8:
+		case GF_ITAG_INT16:
+		case GF_ITAG_INT32:
+		case GF_ITAG_INT64:
+			gf_sys_format_help(helpout, help_flags, "integer"); break;
+		case GF_ITAG_FRAC6:
+		case GF_ITAG_FRAC8:
+			gf_sys_format_help(helpout, help_flags, "fraction (syntax: `A/B` or `A`, B will be 0)"); break;
+		case GF_ITAG_BOOL:
+			gf_sys_format_help(helpout, help_flags, "bool (`yes` or `no`)"); break;
+		case GF_ITAG_ID3_GENRE:
+			gf_sys_format_help(helpout, help_flags, "string (ID3 genre tag)"); break;
+		case GF_ITAG_FILE:
+			gf_sys_format_help(helpout, help_flags, "file path"); break;
+		}
+		name = gf_itags_get_alt_name(i);
+		if (name) {
+			gf_sys_format_help(helpout, help_flags, " (`alias` %s)", name);
+		}
+
+		gf_sys_format_help(helpout, help_flags, "\n");
+		i++;
+	}
+}
+
+void PrintCICP()
+{
+	u32 i;
+	gf_sys_format_help(helpout, help_flags, "# Video CICP (ISO/IEC 23091-2) Constants\n");
+	gf_sys_format_help(helpout, help_flags, "CICP Color Primaries:\n");
+	for (i=0; i<GF_CICP_PRIM_LAST; i++) {
+		const char *name = gf_cicp_color_primaries_name(i);
+		if (!name || !strcmp(name, "unknown")) continue;
+		gf_sys_format_help(helpout, help_flags, " - `%s` (value %d)\n", name, i);
+	}
+	gf_sys_format_help(helpout, help_flags, " \nCICP Color Transfer Characteristics:\n");
+	for (i=0; i<GF_CICP_TRANSFER_LAST; i++) {
+		const char *name = gf_cicp_color_transfer_name(i);
+		if (!name) continue;
+		gf_sys_format_help(helpout, help_flags, " - `%s` (value %d)\n", name, i);
+	}
+	gf_sys_format_help(helpout, help_flags, " \nCICP Color Matrix Coefficients:\n");
+	for (i=0; i<GF_CICP_MX_LAST; i++) {
+		const char *name = gf_cicp_color_matrix_name(i);
+		if (!name) continue;
+		gf_sys_format_help(helpout, help_flags, " - `%s` (value %d)\n", name, i);
+	}
+}
+
+MP4BoxArg m4b_usage_args =
+{
+ 	MP4BOX_ARG("h", "print help\n"
+ 		"- general: general options help\n"
+		"- hint: hinting options help\n"
+		"- dash: DASH segmenter help\n"
+		"- split: split options help\n"
+		"- import: import options help\n"
+		"- encode: scene description encoding options help\n"
+		"- meta: meta (HEIF, MPEG-21) handling options help\n"
+		"- extract: extraction options help\n"
+		"- dump: dump options help\n"
+		"- swf: Flash (SWF) options help\n"
+		"- crypt: ISMA E&A options help\n"
+		"- format: supported formats help\n"
+		"- live: BIFS streamer help\n"
+		"- core: libgpac core options\n"
+		"- all: print all the above help screens\n"
+		"- opts: print all options\n"
+		"- tags: print supported iTunes tags\n"
+		"- cicp: print various CICP code points\n"
+		"- VAL: search for option named `VAL` (without `-` or `--`) in MP4Box, libgpac core and all filters\n"
+		, GF_ARG_STRING, 0, parse_help, 0, ARG_IS_FUN | ARG_EMPTY | ARG_PUSH_SYSARGS),
+ 	MP4BOX_ARG("hx", "look for given string in name and descriptions of all MP4Box and filters options"
+		, GF_ARG_STRING, 0, parse_help, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("nodes", "list supported MPEG4 nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("nodex", "list supported MPEG4 nodes and print nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("node", "get given MPEG4 node syntax and QP infolist", GF_ARG_STRING, 0, PrintNode, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("xnodes", "list supported X3D nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 2, ARG_IS_FUN),
+ 	MP4BOX_ARG("xnodex", "list supported X3D nodes and print nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 3, ARG_IS_FUN),
+ 	MP4BOX_ARG("xnode", "get given X3D node syntax", GF_ARG_STRING, 0, PrintNode, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG("snodes", "list supported SVG nodes", GF_ARG_BOOL, 0, PrintBuiltInNodes, 4, ARG_IS_FUN),
+ 	MP4BOX_ARG("languages", "list supported ISO 639 languages", GF_ARG_BOOL, 0, PrintLanguages, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("boxes", "list all supported ISOBMF boxes and their syntax", GF_ARG_BOOL, 0, PrintBuiltInBoxes, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("boxcov", "perform coverage of box IO coode", GF_ARG_BOOL, GF_ARG_HINT_HIDE, PrintBuiltInBoxes, 1, ARG_IS_FUN|ARG_PUSH_SYSARGS),
+ 	MP4BOX_ARG_ALT("stats", "fstat", "print filter session statistics (import/export/encrypt/decrypt/dashing)", GF_ARG_BOOL, 0, &fs_dump_flags, 1, ARG_BIT_MASK),
+ 	MP4BOX_ARG_ALT("graph", "fgraph", "print filter session graph (import/export/encrypt/decrypt/dashing)", GF_ARG_BOOL, 0, &fs_dump_flags, 2, ARG_BIT_MASK),
+ 	MP4BOX_ARG("v", "verbose mode", GF_ARG_BOOL, 0, &verbose, 0, ARG_INT_INC),
+ 	MP4BOX_ARG("version", "get build version", GF_ARG_BOOL, 0, print_version, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("genmd", "generate MD doc", GF_ARG_BOOL, GF_ARG_HINT_HIDE, parse_gendoc, 0, ARG_IS_FUN),
+ 	MP4BOX_ARG("genman", "generate man doc", GF_ARG_BOOL, GF_ARG_HINT_HIDE, parse_gendoc, 1, ARG_IS_FUN),
+ 	MP4BOX_ARG_S("-", "INPUT", "escape option if INPUT starts with `-` character", 0, NULL, 0, 0),
+ 	{0}
+};
+
+void PrintUsage()
+{
+	u32 i=0;
+	gf_sys_format_help(helpout, help_flags, "MP4Box option input option\n"
+		" \n"
+		"# General Options:\n"
+	);
+	while (m4b_usage_argsi.name) {
+		GF_GPACArg *arg = (GF_GPACArg *) &m4b_usage_argsi;
+		i++;
+		gf_sys_print_arg(helpout, help_flags, arg, "mp4box-general");
+	}
+}
+
+/*
+ * 		END OF ARGS PARSING AND HELP
+ */
+
+
+enum
+{
+	SEARCH_ARG_EXACT,
+	SEARCH_ARG_CLOSE,
+	SEARCH_DESC,
+};
+
+static u32 PrintHelpForArgs(char *arg_name, MP4BoxArg *args, GF_GPACArg *_args, u32 search_type, char *class_name)
+{
+	char szDesc100;
+	u32 res=0;
+	u32 i=0;
+	u32 alen = (u32) strlen(arg_name);
+
+	sprintf(szDesc, "see MP4Box -h %s", class_name);
+
+	while (1) {
+		u32 flags=0;
+		GF_GPACArg *arg;
+		GF_GPACArg an_arg;
+		Bool do_match = GF_FALSE;
+		if (args) {
+			if (!argsi.name)
+				break;
+			arg = (GF_GPACArg *) &argsi;
+		} else {
+			if (!_argsi.name)
+				break;
+			arg = &_argsi;
+		}
+
+		if (args == m4b_imp_fileopt_args) {
+			flags = GF_PRINTARG_COLON;
+			if (!strncmp(arg_name, arg->name, alen) && ((arg->namealen==0) || (arg->namealen=='=')))
+				do_match = GF_TRUE;
+		}
+		else if (!strcmp(arg_name, arg->name))
+			do_match = GF_TRUE;
+		else if ((alen < (u32) strlen(arg->name)) && (arg->namealen==' ') && !strncmp(arg_name, arg->name, alen))
+			do_match = GF_TRUE;
+
+		if (arg_name0 == '@')
+			do_match = GF_TRUE;
+
+		if ((search_type==SEARCH_ARG_EXACT) && !do_match) {
+			i++;
+			continue;
+		}
+		if ((search_type==SEARCH_ARG_CLOSE) && !gf_sys_word_match(arg_name, arg->name)) {
+			i++;
+			continue;
+		}
+		if ((search_type==SEARCH_DESC) && strcmp(arg->name, arg_name) && !gf_strnistr(arg->description, arg_name, alen)) {
+			i++;
+			continue;
+		}
+
+		an_arg = *arg;
+		if (search_type!=SEARCH_ARG_EXACT) {
+			if (search_type == SEARCH_DESC)
+				an_arg.description = szDesc;
+			else
+				an_arg.description = NULL;
+			an_arg.type = GF_ARG_BOOL;
+			gf_sys_print_arg(helpout, flags, (GF_GPACArg *) &an_arg, "");
+
+		} else {
+			gf_sys_print_arg(helpout, flags, (GF_GPACArg *) &an_arg, "");
+		}
+		res++;
+		i++;
+	}
+	return res;
+}
+static Bool PrintHelpArg(char *arg_name, u32 search_type, GF_FilterSession *fs)
+{
+	char szDesc100;
+	Bool first=GF_TRUE;
+	GF_GPACArg an_arg;
+	u32 i, count;
+	u32 res = 0;
+	u32 alen = (u32) strlen(arg_name);
+	res += PrintHelpForArgs(arg_name, m4b_gen_args, NULL, search_type, "general");
+	res += PrintHelpForArgs(arg_name, m4b_split_args, NULL, search_type, "split");
+	res += PrintHelpForArgs(arg_name, m4b_dash_args, NULL, search_type, "dash");
+	res += PrintHelpForArgs(arg_name, m4b_imp_args, NULL, search_type, "import");
+	res += PrintHelpForArgs(arg_name, m4b_imp_fileopt_args, NULL, search_type, "import (per-file option)");
+	res += PrintHelpForArgs(arg_name, m4b_senc_args, NULL, search_type, "encode");
+	res += PrintHelpForArgs(arg_name, m4b_crypt_args, NULL, search_type, "crypt");
+	res += PrintHelpForArgs(arg_name, m4b_hint_args, NULL, search_type, "hint");
+	res += PrintHelpForArgs(arg_name, m4b_extr_args, NULL, search_type, "extract");
+	res += PrintHelpForArgs(arg_name, m4b_dump_args, NULL, search_type, "dump");
+	res += PrintHelpForArgs(arg_name, m4b_meta_args, NULL, search_type, "meta");
+	res += PrintHelpForArgs(arg_name, m4b_swf_args, NULL, search_type, "swf");
+	res += PrintHelpForArgs(arg_name, m4b_liveenc_args, NULL, search_type, "live");
+	res += PrintHelpForArgs(arg_name, m4b_usage_args, NULL, search_type, "");
+	res += PrintHelpForArgs(arg_name, NULL, (GF_GPACArg *) gf_sys_get_options(), search_type, "core");
+
+	if (!fs) return res;
+
+	memset(&an_arg, 0, sizeof(GF_GPACArg));
+	count = gf_fs_filters_registers_count(fs);
+	for (i=0; i<count; i++) {
+		u32 j=0;
+		const GF_FilterRegister *reg = gf_fs_get_filter_register(fs, i);
+
+		while (reg->args) {
+			u32 len;
+			const GF_FilterArgs *arg = &reg->argsj;
+			if (!arg || !arg->arg_name) break;
+			j++;
+			if ((search_type==SEARCH_ARG_EXACT) && strcmp(arg->arg_name, arg_name)) continue;
+
+			if ((search_type==SEARCH_ARG_CLOSE) && !gf_sys_word_match(arg->arg_name, arg_name)) continue;
+
+			if (search_type==SEARCH_DESC) {
+				if (stricmp(arg->arg_name, arg_name) && !gf_strnistr(arg->arg_desc, arg_name, alen)) continue;
+			}
+
+			an_arg.name = arg->arg_name;
+			if (search_type==SEARCH_ARG_EXACT) {
+				an_arg.description = arg->arg_desc;
+				switch (arg->arg_type) {
+				case GF_PROP_BOOL:
+					an_arg.type = GF_ARG_BOOL;
+					break;
+				case GF_PROP_UINT:
+				case GF_PROP_SINT:
+					an_arg.type = GF_ARG_INT;
+					break;
+				case GF_PROP_DOUBLE:
+					an_arg.type = GF_ARG_DOUBLE;
+					break;
+				case GF_PROP_STRING_LIST:
+				case GF_PROP_UINT_LIST:
+				case GF_PROP_SINT_LIST:
+				case GF_PROP_VEC2I_LIST:
+					an_arg.type = GF_ARG_STRINGS;
+					break;
+				case GF_PROP_4CC:
+					an_arg.type = GF_ARG_4CC;
+					break;
+				case GF_PROP_4CC_LIST:
+					an_arg.type = GF_ARG_4CCS;
+					break;
+				default:
+					an_arg.type = GF_ARG_STRING;
+					break;
+				}
+				if (first) {
+					first = GF_FALSE;
+					gf_sys_format_help(helpout, 0, "\nGlobal filter session arguments matching %s:\n", arg_name);
+					//. Syntax is `--arg` or `--arg=VAL`. `F` indicates filter name. See `gpac -h` and `gpac -h F` for more info.\n");
+				}
+				fprintf(helpout, "%s", reg->name);
+				len = (u32)strlen(reg->name);
+				while (len<10) {
+					len++;
+					fprintf(helpout, " ");
+				}
+				fprintf(helpout, " ");
+			} else if (search_type==SEARCH_DESC) {
+				sprintf(szDesc, "see filter %s", reg->name);
+				an_arg.description = szDesc;
+			}
+
+			gf_sys_print_arg(helpout, GF_PRINTARG_ADD_DASH, &an_arg, "TEST");
+			res++;
+		}
+	}
+	if (res) return GF_TRUE;
+	return GF_FALSE;
+}
+
+static void PrintHelp(char *arg_name, Bool search_desc, Bool no_match)
+{
+	GF_FilterSession *fs;
+	Bool res;
+
+	fs = gf_fs_new_defaults(0);
+
+	if (arg_name0=='-')
+		arg_name++;
+
+	if (search_desc) {
+		char *_arg_name = gf_strdup(arg_name);
+		strlwr(_arg_name);
+		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Possible options mentioning `%s`:\n", arg_name));
+		PrintHelpArg(_arg_name, SEARCH_DESC, fs);
+		gf_free(_arg_name);
+	} else {
+		res = no_match ? GF_FALSE : PrintHelpArg(arg_name, SEARCH_ARG_EXACT, fs);
+		if (!res) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Option -%s unknown, please check usage.\n", arg_name));
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Possible options are:\n"));
+
+			PrintHelpArg(arg_name, SEARCH_ARG_CLOSE, fs);
+		}
+	}
+	if (fs)
+		gf_fs_del(fs);
+}
+
+
+u32 parse_sdp_ext(char *arg_val, u32 param)
+{
+	char *id;
+	sdp_lines = gf_realloc(sdp_lines, sizeof(SDPLine) * (nb_sdp_ex + 1));
+	if (!sdp_lines) return 2;
+	id = strchr(arg_val, ':');
+	if (id) {
+		id0 = 0;
+		if (parse_track_id(&sdp_linesnb_sdp_ex.track_id, arg_val, GF_FALSE)) {
+			id0 = ':';
+			sdp_linesnb_sdp_ex.line = id + 1;
+		}
+		else {
+			id0 = ':';
+			sdp_linesnb_sdp_ex.line = arg_val;
+		}
+	}
+	else {
+		sdp_linesnb_sdp_ex.line = arg_val;
+		sdp_linesnb_sdp_ex.track_id.type = 0;
+		sdp_linesnb_sdp_ex.track_id.ID_or_num = 0;
+	}
+	open_edit = GF_TRUE;
+	nb_sdp_ex++;
+	return GF_FALSE;
+}
+
+
+#ifndef GPAC_DISABLE_ISOM_WRITE
+static u32 parse_meta_args(char *opts, MetaActionType act_type)
+{
+	MetaAction *meta;
+
+	metas = gf_realloc(metas, sizeof(MetaAction) * (nb_meta_act + 1));
+	if (!metas) return 2;
+	meta = &metasnb_meta_act;
+	nb_meta_act ++;
+
+	memset(meta, 0, sizeof(MetaAction));
+	meta->act_type = act_type;
+	meta->root_meta = 1;
+	open_edit = GF_TRUE;
+
+	if (!opts) return 2;
+
+	if (act_type == META_ACTION_ADD_IMAGE_ITEM)
+		has_add_image = GF_TRUE;
+
+#define CHECK_IMGPROP\
+			if (!meta->image_props) {\
+				GF_SAFEALLOC(meta->image_props, GF_ImageItemProperties);\
+				if (!meta->image_props) return 2;\
+			}\
+
+	while (1) {
+		char *next;
+		char *szSlot;
+		if (!opts || !opts0) return 0;
+		if (opts0==':') opts += 1;
+
+		szSlot = opts;
+		next = gf_url_colon_suffix(opts, '=');
+		if (next) next0 = 0;
+		if (next && !strncmp(szSlot, "auxt", 4)) {
+			next0 = ':';
+			char *sep = strchr(next, '=');
+			if (sep) {
+				next = sep;
+				while (next0 != ':')
+					next--;
+
+				next0 = 0;
+			}
+		}
+
+		if (!strnicmp(szSlot, "tk=", 3)) {
+			parse_track_id(&meta->track_id, szSlot+3, GF_FALSE);
+			if (act_type == META_ACTION_ADD_ITEM)
+				meta->root_meta = 0;
+		}
+		else if (!strnicmp(szSlot, "id=", 3)) {
+			meta->item_id = parse_u32(szSlot+3, "id");
+		}
+		else if (!strnicmp(szSlot, "type=", 5)) {
+			meta->item_type = GF_4CC(szSlot5, szSlot6, szSlot7, szSlot8);
+		}
+		//"ref" (without '=') is for data reference, "ref=" is for item references
+		else if (!strnicmp(szSlot, "ref=", 4)) {
+			char type5;
+			MetaRef	*ref;
+			if (!meta->item_refs) {
+				meta->item_refs = gf_list_new();
+				if (!meta->item_refs) return 2;
+			}
+			GF_SAFEALLOC(ref, MetaRef);
+			if (!ref) return 2;
+			sscanf(szSlot, "ref=%4s,%u", type, &(ref->ref_item_id));
+			ref->ref_type = GF_4CC(type0, type1, type2, type3);
+			gf_list_add(meta->item_refs, ref);
+		}
+		else if (!strnicmp(szSlot, "name=", 5)) {
+			meta->szName = gf_strdup(szSlot+5);
+		}
+		else if (!strnicmp(szSlot, "path=", 5)) {
+			meta->szPath = gf_strdup(szSlot+5);
+		}
+		else if (!strnicmp(szSlot, "mime=", 5)) {
+			meta->item_type = GF_META_ITEM_TYPE_MIME;
+			meta->mime_type = gf_strdup(szSlot+5);
+		}
+		else if (!strnicmp(szSlot, "encoding=", 9)) {
+			meta->enc_type = gf_strdup(szSlot+9);
+		}
+		else if (!strnicmp(szSlot, "image-size=", 11)) {
+			CHECK_IMGPROP
+			sscanf(szSlot+11, "%dx%d", &meta->image_props->width, &meta->image_props->height);
+		}
+		else if (!strnicmp(szSlot, "image-grid-size=", 16)) {
+			CHECK_IMGPROP
+			sscanf(szSlot+16, "%dx%d", &meta->image_props->num_grid_rows, &meta->image_props->num_grid_columns);
+		}
+		else if (!strnicmp(szSlot, "image-overlay-color=", 20)) {
+			CHECK_IMGPROP
+			sscanf(szSlot+20, "%d,%d,%d,%d", &meta->image_props->overlay_canvas_fill_value_r,&meta->image_props->overlay_canvas_fill_value_g,&meta->image_props->overlay_canvas_fill_value_b,&meta->image_props->overlay_canvas_fill_value_a);
+		}
+		else if (!strnicmp(szSlot, "image-overlay-offsets=", 22)) {
+			CHECK_IMGPROP
+			u32 position = 22;
+			u32 comma_count = 0;
+			u32 offset_index = 0;
+			char *prev = szSlot+position;
+			char *sub_next = strchr(szSlot+position, ',');
+			while (sub_next != NULL) {
+				comma_count++;
+				sub_next++;
+				sub_next = strchr(sub_next, ',');
+			}
+			meta->image_props->overlay_count = comma_count/2+1;
+			meta->image_props->overlay_offsets = (GF_ImageItemOverlayOffset *)gf_malloc(meta->image_props->overlay_count*sizeof(GF_ImageItemOverlayOffset));
+			if (!meta->image_props->overlay_offsets) {
+				return 0;
+			}
+			sub_next = strchr(szSlot+position, ',');
+			while (sub_next != NULL) {
+				*sub_next = 0;
+				meta->image_props->overlay_offsetsoffset_index.horizontal = parse_u32(prev, "image-overlay-offsets.horizontal");
+				*sub_next = ',';
+				sub_next++;
+				prev = sub_next;
+				if (sub_next) {
+					sub_next = strchr(sub_next, ',');
+					if (sub_next) *sub_next = 0;
+					meta->image_props->overlay_offsetsoffset_index.vertical = parse_u32(prev, "image-overlay-offsets.horizontal");
+					if (sub_next) {
+						*sub_next = ',';
+						sub_next++;
+						prev = sub_next;
+						sub_next = strchr(sub_next, ',');
+					}
+				} else {
+					meta->image_props->overlay_offsetsoffset_index.vertical = 0;
+				}
+				offset_index++;
+			}
+		}
+		else if (!strnicmp(szSlot, "image-pasp=", 11)) {
+			CHECK_IMGPROP
+			sscanf(szSlot+11, "%dx%d", &meta->image_props->hSpacing, &meta->image_props->vSpacing);
+		}
+		else if (!strnicmp(szSlot, "image-pixi=", 11)) {
+			CHECK_IMGPROP
+			if (strchr(szSlot+11, ',') == NULL) {
+				meta->image_props->num_channels = 1;
+				meta->image_props->bits_per_channel0 = parse_u32(szSlot+11, "image-pixi");
+			} else {
+				meta->image_props->num_channels = 3;
+				sscanf(szSlot+11, "%u,%u,%u", &(meta->image_props->bits_per_channel0), &(meta->image_props->bits_per_channel1), &(meta->image_props->bits_per_channel2));
+			}
+		}
+		else if (!strnicmp(szSlot, "image-rloc=", 11)) {
+			CHECK_IMGPROP
+			sscanf(szSlot+11, "%dx%d", &meta->image_props->hOffset, &meta->image_props->vOffset);
+		}
+		else if (!strnicmp(szSlot, "rotation=", 9)) {
+			CHECK_IMGPROP
+			meta->image_props->angle = parse_u32(szSlot+9, "rotation");
+		}
+		else if (!strnicmp(szSlot, "mirror-axis=", 12)) {
+			CHECK_IMGPROP
+			meta->image_props->mirror = (!strnicmp(szSlot+12, "vertical", 8) ? 1 : 2);
+		}
+		else if (!strnicmp(szSlot, "clap=", 5)) {
+			CHECK_IMGPROP
+			sscanf(szSlot + 5, "%d,%d,%d,%d,%d,%d,%d,%d", &meta->image_props->clap_wnum, &meta->image_props->clap_wden,
+					 &meta->image_props->clap_hnum, &meta->image_props->clap_hden,
+					 &meta->image_props->clap_honum, &meta->image_props->clap_hoden,
+					 &meta->image_props->clap_vonum, &meta->image_props->clap_voden);
+		}
+		else if (!stricmp(szSlot, "hidden")) {
+			CHECK_IMGPROP
+			meta->image_props->hidden = GF_TRUE;
+		}
+		else if (!stricmp(szSlot, "alpha")) {
+			CHECK_IMGPROP
+			meta->image_props->alpha = GF_TRUE;
+		}
+		else if (!stricmp(szSlot, "depth")) {
+			CHECK_IMGPROP
+			meta->image_props->depth = GF_TRUE;
+ 		}
+		//"ref" (without '=') is for data reference, "ref=" is for item references
+		else if (!stricmp(szSlot, "ref")) {
+			CHECK_IMGPROP
+			meta->image_props->use_reference = GF_TRUE;
+		}
+		else if (!strnicmp(szSlot, "it=", 3)) {
+			CHECK_IMGPROP
+			meta->image_props->item_ref_id = parse_u32(szSlot+3, "it");
+		}
+		else if (!strnicmp(szSlot, "itp=", 4)) {
+			CHECK_IMGPROP
+			meta->image_props->item_ref_id = parse_u32(szSlot+4, "itp");
+			meta->image_props->copy_props = 1;
+		}
+		else if (!strnicmp(szSlot, "time=", 5)) {
+			Float s=0, e=0, step=0;
+			CHECK_IMGPROP
+			if (sscanf(szSlot+5, "%f-%f/%f", &s, &e, &step)==3) {
+				meta->image_props->time = s;
+				meta->image_props->end_time = e;
+				meta->image_props->step_time = step;
+			} else if (sscanf(szSlot+5, "%f-%f", &s, &e)==2) {
+				meta->image_props->time = s;
+				meta->image_props->end_time = e;
+			} else if (sscanf(szSlot+5, "%f/%f", &s, &step)==2) {
+				meta->image_props->time = s;
+				meta->image_props->step_time = step;
+			} else if (sscanf(szSlot+5, "%f", &s)==1) {
+				meta->image_props->time = s;
+			}
+		}
+		else if (!strnicmp(szSlot, "samp=", 5)) {
+			CHECK_IMGPROP
+			meta->image_props->sample_num = parse_u32(szSlot+5, "samp");
+			meta->root_meta = 1;
+		}
+		else if (!strnicmp(szSlot, "group=", 6)) {
+			char type5;
+			sscanf(szSlot, "group=%4s,%u", type, &meta->group_id);
+			meta->group_type = GF_4CC(type0, type1, type2, type3);
+		}
+		else if (!stricmp(szSlot, "split_tiles")) {
+			CHECK_IMGPROP
+			meta->image_props->tile_mode = TILE_ITEM_ALL_BASE;
+		}
+		else if (!stricmp(szSlot, "dref")) {
+			meta->use_dref = 1;
+		}
+		else if (!stricmp(szSlot, "primary")) {
+			meta->primary = 1;
+		}
+		else if (!stricmp(szSlot, "binary")) {
+			if (meta->act_type==META_ACTION_SET_XML) meta->act_type=META_ACTION_SET_BINARY_XML;
+		}
+		else if (!strnicmp(szSlot, "icc_path=", 9)) {
+			CHECK_IMGPROP
+			strcpy(meta->image_props->iccPath, szSlot+9);
+		}
+		else if (!stricmp(szSlot, "agrid") || !strnicmp(szSlot, "agrid=", 6)) {
+			CHECK_IMGPROP
+			meta->image_props->auto_grid = GF_TRUE;
+			if (!strnicmp(szSlot, "agrid=", 6))
+				meta->image_props->auto_grid_ratio = atof(szSlot+6);
+		}
+		else if (!strnicmp(szSlot, "av1_op_index=", 13)) {
+			CHECK_IMGPROP
+			meta->image_props->av1_op_index = parse_u32(szSlot+13, "av1_op_index");
+		}
+		else if (!stricmp(szSlot, "replace")) {
+			meta->replace = GF_TRUE;
+		}
+		else if (!strnicmp(szSlot, "keep_props=", 11)) {
+			CHECK_IMGPROP
+			meta->keep_props = gf_strdup(szSlot+11);
+		}
+		else if (!strnicmp(szSlot, "auxt=", 5)) {
+			CHECK_IMGPROP
+			meta->image_props->aux_urn = gf_strdup(szSlot+5);
+		}
+		else if (!strnicmp(szSlot, "auxd=", 5)) {
+			CHECK_IMGPROP
+			GF_Err e = gf_file_load_data(szSlot+5, (u8 **) &meta->image_props->aux_data, &meta->image_props->aux_data_len);
+			if (e) {
+				M4_LOG(GF_LOG_ERROR, ("Failed to load auxiliary data file %s: %s\n", szSlot+5, gf_error_to_string(e) ));
+				return 1;
+			}
+		}
+		else if (!strchr(szSlot, '=')) {
+			switch (meta->act_type) {
+			case META_ACTION_SET_TYPE:
+				if (!stricmp(szSlot, "null") || !stricmp(szSlot, "0")) meta->meta_4cc = 0;
+				else meta->meta_4cc = GF_4CC(szSlot0, szSlot1, szSlot2, szSlot3);
+				break;
+			case META_ACTION_ADD_ITEM:
+			case META_ACTION_ADD_IMAGE_ITEM:
+			case META_ACTION_SET_XML:
+			case META_ACTION_DUMP_XML:
+				if (!strncmp(szSlot, "dopt", 4) || !strncmp(szSlot, "sopt", 4) || !strncmp(szSlot, "@", 1)) {
+					if (next) next0=':';
+					next=NULL;
+				}
+				//cat as -add arg
+				gf_dynstrcat(&meta->szPath, szSlot, ":");
+				if (!meta->szPath) return 2;
+				break;
+			case META_ACTION_REM_ITEM:
+			case META_ACTION_SET_PRIMARY_ITEM:
+			case META_ACTION_DUMP_ITEM:
+				meta->item_id = parse_u32(szSlot, "Item ID");
+				break;
+			default:
+				break;
+			}
+		}
+		if (!next) break;
+		opts += strlen(szSlot);
+		next0 = ':';
+	}
+	return 0;
+}
+#endif //GPAC_DISABLE_ISOM_WRITE
+
+
+#ifndef GPAC_DISABLE_ISOM_WRITE
+static Bool parse_tsel_args(char *opts, TSELActionType act)
+{
+	TrackIdentifier refTrackID = {0, 0};
+	Bool has_switch_id;
+	u32 switch_id = 0;
+	u32 criteria30;
+	u32 nb_criteria = 0;
+	TSELAction *tsel_act;
+	char szSlot1024;
+
+	has_switch_id = 0;
+
+	if (!opts) return 0;
+	while (1) {
+		char *next;
+		if (!opts || !opts0) return 0;
+		if (opts0==':') opts += 1;
+		strcpy(szSlot, opts);
+		next = gf_url_colon_suffix(szSlot, '=');
+		if (next) next0 = 0;
+
+
+		if (!strnicmp(szSlot, "refTrack=", 9)) {
+			parse_track_id(&refTrackID, szSlot+9, GF_FALSE);
+		} else if (!strnicmp(szSlot, "switchID=", 9)) {
+			if (parse_s32(szSlot+9, "switchID")<0) {
+				switch_id = 0;
+				has_switch_id = 0;
+			} else {
+				switch_id = parse_u32(szSlot+9, "switchID");
+				has_switch_id = 1;
+			}
+		}
+		else if (!strnicmp(szSlot, "switchID", 8)) {
+			switch_id = 0;
+			has_switch_id = 1;
+		}
+		else if (!strnicmp(szSlot, "criteria=", 9)) {
+			u32 j=9;
+			nb_criteria = 0;
+			while (j+3<strlen(szSlot)) {
+				criterianb_criteria = GF_4CC(szSlotj, szSlotj+1, szSlotj+2, szSlotj+3);
+				j+=5;
+				nb_criteria++;
+			}
+		}
+		else if (!strnicmp(szSlot, "trackID=", 8) || !strchr(szSlot, '=') ) {
+			tsel_acts = gf_realloc(tsel_acts, sizeof(TSELAction) * (nb_tsel_acts + 1));
+			if (!tsel_acts) return 2;
+
+			tsel_act = &tsel_actsnb_tsel_acts;
+			nb_tsel_acts++;
+
+			memset(tsel_act, 0, sizeof(TSELAction));
+			tsel_act->act_type = act;
+			char *tk_id = strchr(szSlot, '=');
+			if (!tk_id) tk_id = szSlot;
+			else tk_id++;
+
+			parse_track_id(&tsel_act->target_track, tk_id, GF_FALSE);
+
+			tsel_act->reference_track = refTrackID;
+			tsel_act->switchGroupID = switch_id;
+			tsel_act->is_switchGroup = has_switch_id;
+			tsel_act->nb_criteria = nb_criteria;
+			memcpy(tsel_act->criteria, criteria, sizeof(u32)*nb_criteria);
+
+			if (!refTrackID.ID_or_num)
+				refTrackID = tsel_act->target_track;
+
+			open_edit = GF_TRUE;
+		}
+		opts += strlen(szSlot);
+	}
+	return 0;
+}
+#endif // GPAC_DISABLE_ISOM_WRITE
+
+
+GF_DashSegmenterInput *set_dash_input(GF_DashSegmenterInput *dash_inputs, char *name, u32 *nb_dash_inputs)
+{
+	GF_DashSegmenterInput *di;
+	Bool skip_rep_id = GF_FALSE;
+	char *other_opts = NULL;
+	char *sep = gf_url_colon_suffix(name, '=');
+
+	dash_inputs = gf_realloc(dash_inputs, sizeof(GF_DashSegmenterInput) * (*nb_dash_inputs + 1) );
+	memset(&dash_inputs*nb_dash_inputs, 0, sizeof(GF_DashSegmenterInput) );
+	di = &dash_inputs*nb_dash_inputs;
+	(*nb_dash_inputs)++;
+
+	if (sep) {
+		char *opts, *first_opt;
+		first_opt = sep;
+		opts = sep+1;
+		while (opts) {
+			char *xml_start = strchr(opts, '<');
+			//none of our options use filenames, so don't check for '='
+			sep = gf_url_colon_suffix(opts, 0);
+			//escape XML
+			if (xml_start && (xml_start<sep)) {
+				char *xml_end = strstr(opts, ">:");
+				if (xml_end) sep = xml_end+1;
+				else sep = NULL;
+			}
+
+			if (sep && !strncmp(sep, "://", 3) && strncmp(sep, ":@", 2)) sep = gf_url_colon_suffix(sep+3, 0);
+			if (sep) sep0 = 0;
+
+			if (!strnicmp(opts, "id=", 3)) {
+				if (!stricmp(opts+3, "NULL"))
+					skip_rep_id = GF_TRUE;
+				else
+					di->representationID = gf_strdup(opts+3);
+				/*we allow the same repID to be set to force muxed representations*/
+			}
+			else if (!strnicmp(opts, "dur=", 4)) gf_parse_lfrac(opts+4, &di->media_duration);
+			else if (!strnicmp(opts, "period=", 7)) di->periodID = gf_strdup(opts+7);
+			else if (!strnicmp(opts, "BaseURL=", 8)) {
+				di->baseURL = (char **)gf_realloc(di->baseURL, (di->nb_baseURL+1)*sizeof(char *));
+				di->baseURLdi->nb_baseURL = gf_strdup(opts+8);
+				di->nb_baseURL++;
+			} else if (!strnicmp(opts, "bandwidth=", 10)) di->bandwidth = parse_u32(opts+10, "bandwidth");
+			else if (!strnicmp(opts, "role=", 5)) {
+				di->roles = gf_realloc(di->roles, sizeof (char *) * (di->nb_roles+1));
+				di->rolesdi->nb_roles = gf_strdup(opts+5);
+				di->nb_roles++;
+			} else if (!strnicmp(opts, "desc", 4)) {
+				u32 *nb_descs=NULL;
+				char ***descs=NULL;
+				u32 opt_offset=0;
+				u32 len;
+				if (!strnicmp(opts, "desc_p=", 7)) {
+					nb_descs = &di->nb_p_descs;
+					descs = &di->p_descs;
+					opt_offset = 7;
+				} else if (!strnicmp(opts, "desc_as=", 8)) {
+					nb_descs = &di->nb_as_descs;
+					descs = &di->as_descs;
+					opt_offset = 8;
+				} else if (!strnicmp(opts, "desc_as_c=", 8)) {
+					nb_descs = &di->nb_as_c_descs;
+					descs = &di->as_c_descs;
+					opt_offset = 10;
+				} else if (!strnicmp(opts, "desc_rep=", 8)) {
+					nb_descs = &di->nb_rep_descs;
+					descs = &di->rep_descs;
+					opt_offset = 9;
+				}
+				if (opt_offset) {
+					(*nb_descs)++;
+					opts += opt_offset;
+					len = (u32) strlen(opts);
+					(*descs) = (char **)gf_realloc((*descs), (*nb_descs)*sizeof(char *));
+					(*descs)(*nb_descs)-1 = (char *)gf_malloc((len+1)*sizeof(char));
+					memcpy((*descs)(*nb_descs)-1, opts, len);
+					(*descs)(*nb_descs)-1len = 0;
+				}
+
+			}
+			else if (!strnicmp(opts, "xlink=", 6)) di->xlink = gf_strdup(opts+6);
+			else if (!strnicmp(opts, "sscale", 6)) di->sscale = GF_TRUE;
+			else if (!strnicmp(opts, "pdur=", 5)) gf_parse_frac(opts+5, &di->period_duration);
+			else if (!strnicmp(opts, "period_duration=", 16)) gf_parse_frac(opts+16, &di->period_duration);
+			else if (!strnicmp(opts, "ddur=", 5)) gf_parse_frac(opts+5, &di->dash_duration);
+			else if (!strnicmp(opts, "duration=", 9)) gf_parse_frac(opts+9, &di->dash_duration);
+			else if (!strnicmp(opts, "asID=", 5)) di->asID = parse_u32(opts+5, "asID");
+			else if (!strnicmp(opts, "sn=", 3)) di->startNumber = parse_u32(opts+3, "sn");
+			else if (!strnicmp(opts, "tpl=", 4)) di->seg_template = gf_strdup(opts+4);
+			else if (!strnicmp(opts, "hls=", 4)) di->hls_pl = gf_strdup(opts+4);
+			else if (!strnicmp(opts, "trackID=", 8)) di->track_id = parse_u32(opts+8, "trackID");
+			else if (!strnicmp(opts, "@", 1)) {
+				Bool old_syntax = (opts1=='@') ? GF_TRUE : GF_FALSE;
+				if (sep) sep0 = ':';
+				di->filter_chain = gf_strdup(opts + (old_syntax ? 2 : 1) );
+				sep = NULL;
+				if (!old_syntax && (strstr(di->filter_chain, "@@")!=NULL)) {
+					skip_rep_id = GF_TRUE;
+				}
+			} else {
+				gf_dynstrcat(&other_opts, opts, ":");
+			}
+
+			if (!sep) break;
+			sep0 = ':';
+			opts = sep+1;
+		}
+		first_opt0 = '\0';
+	}
+	di->file_name = name;
+	di->source_opts = other_opts;
+
+	if (!skip_rep_id && !di->representationID) {
+		char szRep100;
+		sprintf(szRep, "%d", *nb_dash_inputs);
+		di->representationID = gf_strdup(szRep);
+	}
+
+	return dash_inputs;
+}
+
+static Bool create_new_track_action(char *arg_val, u32 act_type, u32 dump_type)
+{
+	TrackAction *tka;
+	char *param = arg_val;
+	tracks = (TrackAction *)gf_realloc(tracks, sizeof(TrackAction) * (nb_track_act+1));
+	if (!tracks) return GF_FALSE;
+
+	tka = & tracksnb_track_act;
+	nb_track_act++;
+
+	memset(tka, 0, sizeof(TrackAction) );
+	tka->act_type = act_type;
+	tka->dump_type = dump_type;
+	if (act_type != TRACK_ACTION_RAW_EXTRACT) {
+		open_edit = GF_TRUE;
+		do_save = GF_TRUE;
+	}
+
+	if ((act_type==TRACK_ACTION_SET_ID) || (act_type==TRACK_ACTION_SWAP_ID)) {
+		char *sep = strchr(param, ':');
+		if (!sep) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for -set-track-id - expecting \"id1:id2\" got \"%s\"\n", param));
+			return GF_FALSE;
+		}
+		sep0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		sep0 = ':';
+		if (act_type==TRACK_ACTION_SWAP_ID)
+			parse_track_id(&tka->newTrackID, sep+1, GF_FALSE);
+		else
+			tka->newTrackID.ID_or_num = parse_u32(sep+1, "ID");
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_SET_PAR) {
+		char *ext;
+		ext = strchr(param, '=');
+		if (!ext) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track par - expecting tkID=none or tkID=PAR_NUM:PAR_DEN got %s\n", param));
+			return GF_FALSE;
+		}
+		ext0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		ext0 = '=';
+
+		if (!stricmp(ext+1, "none"))
+			tka->par_num = tka->par_den = 0;
+		else if (!stricmp(ext+1, "auto")) {
+			tka->par_num = tka->par_den = -1;
+			tka->force_par = 1;
+		}
+		else if (!stricmp(ext+1, "force")) {
+			tka->par_num = tka->par_den = 1;
+			tka->force_par = 1;
+		}
+		else {
+			if (ext1=='w') {
+				tka->rewrite_bs = 1;
+				ext++;
+			}
+			if (sscanf(ext+1, "%d:%d", &tka->par_num, &tka->par_den) != 2) {
+				M4_LOG(GF_LOG_ERROR, ("Bad format for track par - expecting tkID=PAR_NUM:PAR_DEN got %s\n", param));
+				return GF_FALSE;
+			}
+		}
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_SET_CLAP) {
+		char *ext = strchr(param, '=');
+		if (!ext) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track clap - expecting tkID=none or tkID=Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd got %s\n", param));
+			return GF_FALSE;
+		}
+		ext0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		ext0 = '=';
+		if (stricmp(ext + 1, "none")) {
+			if (sscanf(ext + 1, "%d,%d,%d,%d,%d,%d,%d,%d", &tka->clap_wnum, &tka->clap_wden, &tka->clap_hnum, &tka->clap_hden, &tka->clap_honum, &tka->clap_hoden, &tka->clap_vonum, &tka->clap_voden) != 8) {
+
+				M4_LOG(GF_LOG_ERROR, ("Bad format for track clap - expecting tkID=none or tkID=Wn,Wd,Hn,Hd,HOn,HOd,VOn,VOd got %s\n", param));
+				return GF_FALSE;
+			}
+		}
+		return GF_TRUE;
+	}
+
+	if (act_type==TRACK_ACTION_SET_MX) {
+		char *ext = strchr(param, '=');
+		if (!ext) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track matrix - expecting ID=none or ID=M1:M2:M3:M4:M5:M6:M7:M8:M9 got %s\n", param));
+			return GF_FALSE;
+		}
+		ext0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		ext0 = '=';
+		if (!stricmp(ext + 1, "none")) {
+			memset(tka->mx, 0, sizeof(s32)*9);
+			tka->mx0 = tka->mx4 = tka->mx8 = 1;
+		} else {
+			s32 res;
+			if (strstr(ext+1, "0x")) {
+				res = sscanf(ext + 1, "0x%d:0x%d:0x%d:0x%d:0x%d:0x%d:0x%d:0x%d:0x%d", &tka->mx0, &tka->mx1, &tka->mx2, &tka->mx3, &tka->mx4, &tka->mx5, &tka->mx6, &tka->mx7, &tka->mx8);
+			} else {
+				res = sscanf(ext + 1, "%d:%d:%d:%d:%d:%d:%d:%d:%d", &tka->mx0, &tka->mx1, &tka->mx2, &tka->mx3, &tka->mx4, &tka->mx5, &tka->mx6, &tka->mx7, &tka->mx8);
+			}
+			if (res != 9) {
+				M4_LOG(GF_LOG_ERROR, ("Bad format for track matrix - expecting ID=none or ID=M1:M2:M3:M4:M5:M6:M7:M8:M9 got %s\n", param));
+				return GF_FALSE;
+			}
+		}
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_SET_EDITS) {
+		char *ext = strchr(param, '=');
+		if (!ext) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track edits - expecting ID=EDITS got %s\n", param));
+			return GF_FALSE;
+		}
+		ext0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		ext0 = '=';
+		tka->string = gf_strdup(ext+1);
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_SET_LANGUAGE) {
+		char *ext = strchr(param, '=');
+		if (!strnicmp(param, "all=", 4)) {
+			strncpy(tka->lang, param + 4, LANG_SIZE-1);
+		}
+		else if (!ext) {
+			strncpy(tka->lang, param, LANG_SIZE-1);
+		} else {
+			strncpy(tka->lang, ext + 1, LANG_SIZE-1);
+			ext0 = 0;
+			parse_track_id(&tka->target_track, param, GF_FALSE);
+			ext0 = '=';
+		}
+		return GF_TRUE;
+	}
+	if ((act_type==TRACK_ACTION_SET_KIND) || (act_type==TRACK_ACTION_REM_KIND)) {
+		char *ext;
+		char *scheme_start = NULL;
+
+		//extract trackID
+		if (!strnicmp(param, "all=", 4)) {
+			scheme_start = param + 4;
+		} else {
+			ext = strchr(param, '=');
+			if (ext) {
+				ext0 = 0;
+				parse_track_id(&tka->target_track, param, GF_FALSE);
+				if (tka->target_track.ID_or_num) {
+					scheme_start = ext + 1;
+				} else {
+					scheme_start = param;
+				}
+				ext0 = '=';
+			} else {
+				scheme_start = param;
+			}
+		}
+
+		//extract scheme and value - if not, remove kind
+		if (!scheme_start || !scheme_start0) {
+			M4_LOG(GF_LOG_ERROR, ("Missing kind scheme - expecting ID=schemeURI=value got %s\n", param));
+			return GF_FALSE;
+		} else {
+			ext = strchr(scheme_start, '=');
+			if (!ext) {
+				tka->kind_scheme = gf_strdup(scheme_start);
+			} else {
+				ext0 = 0;
+				tka->kind_scheme = gf_strdup(scheme_start);
+				ext0 = '=';
+				tka->kind_value = gf_strdup(ext + 1);
+			}
+		}
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_SET_DELAY) {
+		char *ext = strchr(param, '=');
+		if (!ext) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track delay - expecting tkID=DLAY got %s\n", param));
+			return GF_FALSE;
+		}
+		ext0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		ext0 = '=';
+		if (sscanf(ext+1, "%d/%u", &tka->delay.num, &tka->delay.den) != 2) {
+			tka->delay.num = parse_s32(ext + 1, "delay");
+			tka->delay.den = 1000;
+		}
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_REFERENCE) {
+		char *ext = strchr(param, '=');
+		if (!ext) ext = strchr(param, ':');
+		if (!ext) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track reference - expecting tkID:XXXX:refID got %s\n", param));
+			return GF_FALSE;
+		}
+		ext0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		ext0 = '=';
+
+		char *ext2 = strchr(ext, ':');
+		if (!ext2) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track reference - expecting tkID:XXXX:refID got %s\n", param));
+			return GF_FALSE;
+		}
+		ext20 = 0;
+		strncpy(tka->lang, ext+1, LANG_SIZE-1);
+		ext20 = ':';
+		parse_track_id(&tka->newTrackID, ext2 + 1, GF_FALSE);
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_SET_HANDLER_NAME) {
+		char *ext = strchr(param, '=');
+		if (!ext) {
+			M4_LOG(GF_LOG_ERROR, ("Bad format for track name - expecting tkID=name got %s\n", param));
+			return GF_FALSE;
+		}
+		ext0 = 0;
+		parse_track_id(&tka->target_track, param, GF_FALSE);
+		ext0 = '=';
+		tka->hdl_name = ext + 1;
+		return GF_TRUE;
+	}
+	if (act_type==TRACK_ACTION_SET_KMS_URI) {
+		char *ext = strchr(param, '=');
+
+		if (!strnicmp(param, "all=", 4)) {
+			tka->kms = param + 4;
+		} else if (!ext) {
+			tka->kms = param;
+		} else {
+			tka->kms = ext + 1;
+			ext0 = 0;
+			parse_track_id(&tka->target_track, param, GF_FALSE);
+			ext0 = '=';
+		}
+		return GF_TRUE;
+	}
+	if ((act_type==TRACK_ACTION_SET_TIME) || (act_type==TRACK_ACTION_SET_MEDIA_TIME)) {
+		struct tm time;
+		char *ext = strchr(arg_val, '=');
+		if (ext) {
+			ext0 = 0;
+			parse_track_id(&tka->target_track, arg_val, GF_FALSE);
+			ext0 = '=';
+			arg_val = ext+1;
+		}
+		memset(&time, 0, sizeof(struct tm));
+		sscanf(arg_val, "%d/%d/%d-%d:%d:%d", &time.tm_mday, &time.tm_mon, &time.tm_year, &time.tm_hour, &time.tm_min, &time.tm_sec);
+		time.tm_isdst = 0;
+		time.tm_year -= 1900;
+		time.tm_mon -= 1;
+		tka->time = GF_ISOM_MAC_TIME_OFFSET;
+		tka->time += mktime(&time);
+		return GF_TRUE;
+	}
+
+	while (param) {
+		param = gf_url_colon_suffix(param, '=');
+		if (param) {
+			*param = 0;
+			param++;
+#ifndef GPAC_DISABLE_MEDIA_EXPORT
+			if (!strncmp("vttnomerge", param, 10)) {
+				tka->dump_type |= GF_EXPORT_WEBVTT_NOMERGE;
+			} else if (!strncmp("layer", param, 5)) {
+				tka->dump_type |= GF_EXPORT_SVC_LAYER;
+			} else if (!strncmp("full", param, 4)) {
+				tka->dump_type |= GF_EXPORT_NHML_FULL;
+			} else if (!strncmp("embedded", param, 8)) {
+				tka->dump_type |= GF_EXPORT_WEBVTT_META_EMBEDDED;
+			} else if (!strncmp("output=", param, 7)) {
+				tka->out_name = gf_strdup(param+7);
+			} else if (!strncmp("src=", param, 4)) {
+				tka->src_name = gf_strdup(param+4);
+			} else if (!strncmp("str=", param, 4)) {
+				tka->string = gf_strdup(param+4);
+			} else if (!strncmp("box=", param, 4)) {
+				tka->src_name = gf_strdup(param+4);
+				tka->sample_num = 1;
+			} else if (!strncmp("type=", param, 4)) {
+				tka->udta_type = GF_4CC(param5, param6, param7, param8);
+			} else if (tka->dump_type == GF_EXPORT_RAW_SAMPLES) {
+				tka->sample_num = parse_u32(param, "Sample number");
+			}
+#endif
+		}
+	}
+	if (arg_val) {
+		parse_track_id(&tka->target_track, arg_val, GF_TRUE);
+	}
+	return GF_TRUE;
+}
+
+u32 parse_track_dump(char *arg, u32 dump_type)
+{
+	if (!create_new_track_action(arg, TRACK_ACTION_RAW_EXTRACT, dump_type))
+		return 2;
+	track_dump_type = dump_type;
+	return 0;
+}
+u32 parse_track_action(char *arg, u32 act_type)
+{
+	if (!create_new_track_action(arg, act_type, 0)) {
+		return 2;
+	}
+	return 0;
+}
+
+u32 parse_comp_box(char *arg_val, u32 opt)
+{
+	compress_top_boxes = arg_val;
+	size_top_box = opt;
+	return 0;
+}
+u32 parse_dnal(char *arg_val, u32 opt)
+{
+	parse_track_id(&dump_nal_track, arg_val, GF_FALSE);
+	dump_nal_type = opt;
+	return 0;
+}
+u32 parse_dsap(char *arg_val, u32 opt)
+{
+	parse_track_id(&dump_saps_track, arg_val, GF_FALSE);
+	dump_saps_mode = opt;
+	return 0;
+}
+
+u32 parse_bs_switch(char *arg_val, u32 opt)
+{
+	if (!stricmp(arg_val, "no") || !stricmp(arg_val, "off")) bitstream_switching_mode = GF_DASH_BSMODE_NONE;
+	else if (!stricmp(arg_val, "merge")) bitstream_switching_mode = GF_DASH_BSMODE_MERGED;
+	else if (!stricmp(arg_val, "multi")) bitstream_switching_mode = GF_DASH_BSMODE_MULTIPLE_ENTRIES;
+	else if (!stricmp(arg_val, "single")) bitstream_switching_mode = GF_DASH_BSMODE_SINGLE;
+	else if (!stricmp(arg_val, "inband")) bitstream_switching_mode = GF_DASH_BSMODE_INBAND;
+	else if (!stricmp(arg_val, "pps")) bitstream_switching_mode = GF_DASH_BSMODE_INBAND_PPS;
+	else {
+		M4_LOG(GF_LOG_ERROR, ("Unrecognized bitstream switching mode \"%s\" - please check usage\n", arg_val));
+		return 2;
+	}
+	return 0;
+}
+
+u32 parse_cp_loc(char *arg_val, u32 opt)
+{
+	if (!strcmp(arg_val, "both")) cp_location_mode = GF_DASH_CPMODE_BOTH;
+	else if (!strcmp(arg_val, "as")) cp_location_mode = GF_DASH_CPMODE_ADAPTATION_SET;
+	else if (!strcmp(arg_val, "rep")) cp_location_mode = GF_DASH_CPMODE_REPRESENTATION;
+	else {
+		M4_LOG(GF_LOG_ERROR, ("Unrecognized ContentProtection loction mode \"%s\" - please check usage\n", arg_val));
+		return 2;
+	}
+	return 0;
+}
+
+u32 parse_pssh(char *arg_val, u32 opt)
+{
+	if (!strcmp(arg_val, "f")) pssh_mode = GF_DASH_PSSH_MOOF;
+	else if (!strcmp(arg_val, "v")) pssh_mode = GF_DASH_PSSH_MOOV;
+	else if (!strcmp(arg_val, "m")) pssh_mode = GF_DASH_PSSH_MPD;
+	else if (!strcmp(arg_val, "mf") || !strcmp(arg_val, "fm")) pssh_mode = GF_DASH_PSSH_MOOF_MPD;
+	else if (!strcmp(arg_val, "mv") || !strcmp(arg_val, "vm")) pssh_mode = GF_DASH_PSSH_MOOV_MPD;
+	else if (!strcmp(arg_val, "n")) pssh_mode = GF_DASH_PSSH_NONE;
+	else pssh_mode = GF_DASH_PSSH_MOOV;
+	return 0;
+}
+u32 parse_sdtp(char *arg_val, u32 opt)
+{
+	if (!stricmp(arg_val, "both")) sdtp_in_traf = 2;
+	else if (!stricmp(arg_val, "sdtp")) sdtp_in_traf = 1;
+	else sdtp_in_traf = 0;
+	return 0;
+}
+
+u32 parse_rap_ref(char *arg_val, u32 opt)
+{
+	if (arg_val) {
+		TrackIdentifier tkid;
+		if (parse_track_id(&tkid, arg_val, GF_FALSE)) {
+			parse_track_action(arg_val, opt ? TRACK_ACTION_REM_NON_REFS : TRACK_ACTION_REM_NON_RAP);
+		}
+	}
+#ifndef GPAC_DISABLE_STREAMING
+	hint_flags |= GP_RTP_PCK_SIGNAL_RAP;
+#endif
+	seg_at_rap = 1;
+	return 0;
+}
+u32 parse_store_mode(char *arg_val, u32 opt)
+{
+	do_save = GF_TRUE;
+	if ((opt == 0) || (opt == 1)) {
+		interleaving_time = atof(arg_val) / 1000;
+		if (!interleaving_time) do_flat = 2;
+		open_edit = GF_TRUE;
+		no_inplace = GF_TRUE;
+		if (opt==1) old_interleave = 1;
+	} else if (opt==2) {
+		interleaving_time = atof(arg_val);
+		do_frag = GF_TRUE;
+	} else {
+		force_new = 2;
+		interleaving_time = 0.5;
+		do_flat = 1;
+	}
+	return 0;
+}
+u32 parse_base_url(char *arg_val, u32 opt)
+{
+	mpd_base_urls = gf_realloc(mpd_base_urls, (nb_mpd_base_urls + 1)*sizeof(char**));
+	if (!mpd_base_urls) return 2;
+	mpd_base_urlsnb_mpd_base_urls = arg_val;
+	nb_mpd_base_urls++;
+	return 0;
+}
+u32 parse_multi_rtp(char *arg_val, u32 opt)
+{
+#ifndef GPAC_DISABLE_STREAMING
+	hint_flags |= GP_RTP_PCK_USE_MULTI;
+#endif
+	if (arg_val)
+		max_ptime = parse_u32(arg_val, "maxptime");
+	return 0;
+}
+
+u32 parse_senc_param(char *arg_val, u32 opt)
+{
+#ifndef GPAC_DISABLE_SCENE_ENCODER
+	switch (opt) {
+	case 0: //-sync
+		smenc_opts.flags |= GF_SM_ENCODE_RAP_INBAND;
+		smenc_opts.rap_freq = parse_u32(arg_val, "sync");
+		break;
+	case 1: //-shadow
+		smenc_opts.flags &= ~GF_SM_ENCODE_RAP_INBAND;
+		smenc_opts.flags |= GF_SM_ENCODE_RAP_SHADOW;
+		smenc_opts.rap_freq = parse_u32(arg_val, "shadow");
+		break;
+	case 2: //-carousel
+		smenc_opts.flags &= ~(GF_SM_ENCODE_RAP_INBAND | GF_SM_ENCODE_RAP_SHADOW);
+		smenc_opts.rap_freq = parse_u32(arg_val, "carousel");
+		break;
+	case 3: //-auto-quant
+		smenc_opts.resolution = parse_s32(arg_val, "auto-quant");
+		smenc_opts.auto_quant = 1;
+		break;
+	case 4: //-global-quant
+		smenc_opts.resolution = parse_s32(arg_val, "global-quant");
+		smenc_opts.auto_quant = 2;
+		break;
+	case 5: //-ctx-in or -inctx
+		chunk_mode = GF_TRUE;
+		input_ctx = arg_val;
+	}
+#endif
+	return 0;
+}
+u32 parse_cryp(char *arg_val, u32 opt)
+{
+	open_edit = GF_TRUE;
+	if (!opt) {
+		crypt = 1;
+		drm_file = arg_val;
+		open_edit = GF_TRUE;
+		return 0;
+	}
+	crypt = 2;
+	if (arg_val && get_file_type_by_ext(arg_val) != 1) {
+		drm_file = arg_val;
+		return 0;
+	}
+	return 3;
+}
+
+u32 parse_dash_profile(char *arg_val, u32 opt)
+{
+	if (!stricmp(arg_val, "live") || !stricmp(arg_val, "simple")) dash_profile = GF_DASH_PROFILE_LIVE;
+	else if (!stricmp(arg_val, "onDemand")) dash_profile = GF_DASH_PROFILE_ONDEMAND;
+	else if (!stricmp(arg_val, "hbbtv1.5:live") || !stricmp(arg_val, "hbbtv1.5.live"))
+		dash_profile = GF_DASH_PROFILE_HBBTV_1_5_ISOBMF_LIVE;
+	else if (!stricmp(arg_val, "dashavc264:live") || !stricmp(arg_val, "dashavc264.live"))
+		dash_profile = GF_DASH_PROFILE_AVC264_LIVE;
+	else if (!stricmp(arg_val, "dashavc264:onDemand") || !stricmp(arg_val, "dashavc264.onDemand"))
+		dash_profile = GF_DASH_PROFILE_AVC264_ONDEMAND;
+	else if (!stricmp(arg_val, "dashif.ll")) dash_profile = GF_DASH_PROFILE_DASHIF_LL;
+	else if (!stricmp(arg_val, "main")) dash_profile = GF_DASH_PROFILE_MAIN;
+	else if (!stricmp(arg_val, "full")) dash_profile = GF_DASH_PROFILE_FULL;
+	else {
+		M4_LOG(GF_LOG_ERROR, ("Unrecognized DASH profile \"%s\" - please check usage\n", arg_val));
+		return 2;
+	}
+	return 0;
+}
+
+u32 parse_fps(char *arg_val, u32 opt)
+{
+	u32 ticks, dts_inc;
+	if (!strcmp(arg_val, "auto")) {
+		M4_LOG(GF_LOG_WARNING, ("Warning, fps=auto option is deprecated\n"));
+	}
+	else if ((sscanf(arg_val, "%u-%u", &ticks, &dts_inc)==2) || (sscanf(arg_val, "%u/%u", &ticks, &dts_inc)==2) ) {
+		if (!dts_inc) dts_inc = 1;
+		import_fps.num = ticks;
+		import_fps.den = dts_inc;
+	} else {
+		gf_parse_frac(arg_val, &import_fps);
+	}
+	return 0;
+}
+
+u32 parse_split(char *arg_val, u32 opt)
+{
+	u32 scale=1;
+	char *unit;
+	switch (opt) {
+	case 0://-split
+		unit = arg_val + (u32) (strlen(arg_val) - 1);
+		if (strchr("Mm", unit0)) scale = 60;
+		else if (strchr("Hh", unit0)) scale = 3600;
+		if (scale > 1) {
+			char c = unit0;
+			unit0 = 0;
+			split_duration = scale * atof(arg_val);
+			unit0 = c;
+		} else {
+			split_duration = atof(arg_val);
+		}
+		if (split_duration < 0) split_duration = 0;
+		split_size = 0;
+		break;
+	case 1: //-split-rap, -splitr
+		split_duration = -1;
+		split_size = -1;
+		break;
+	case 2: //-split-size, -splits
+		unit = arg_val + (u32) (strlen(arg_val) - 1);
+		if (strchr("Mm", unit0)) scale = 1000;
+		else if (strchr("Gg", unit0)) scale = 1000000;
+		if (scale > 1) {
+			char c = unit0;
+			unit0 = 0;
+			split_size = scale * parse_u32(arg_val, "Split size");
+			unit0 = c;
+		} else {
+			split_size = (u32)parse_u32(arg_val, "Split size");
+		}
+		split_duration = 0;
+		break;
+	case 3: //-split-chunk, -splitx
+	case 4: //-splitz
+	case 5: //-splitg
+	case 6: //-splitf
+		adjust_split_end = opt-3;
+		if (!strstr(arg_val, ":") && !strstr(arg_val, "-")) {
+			M4_LOG(GF_LOG_ERROR, ("Chunk extraction usage: \"-split* start:end\" expressed in seconds\n"));
+			return 2;
+		}
+		if (strstr(arg_val, "end")) {
+			if (strstr(arg_val, "end-")) {
+				Double dur_end=0;
+				sscanf(arg_val, "%lf:end-%lf", &split_start, &dur_end);
+				split_duration = -2 - dur_end;
+			} else {
+				sscanf(arg_val, "%lf:end", &split_start);
+				split_duration = -2;
+			}
+		} else {
+			split_range_str = arg_val;
+		}
+		split_size = 0;
+		break;
+	}
+	return 0;
+}
+
+u32 parse_brand(char *b, u32 opt)
+{
+	open_edit = GF_TRUE;
+	switch (opt) {
+	case 0: //-brand
+		major_brand = GF_4CC(b0, b1, b2, b3);
+		if (b4 == ':') {
+			if (!strncmp(b+5, "0x", 2))
+				sscanf(b+5, "0x%x", &minor_version);
+			else
+				minor_version = parse_u32(b + 5, "version");
+		}
+		break;
+	case 1: //-ab
+		brand_add = (u32*)gf_realloc(brand_add, sizeof(u32) * (nb_alt_brand_add + 1));
+		if (!brand_add) return 2;
+		brand_addnb_alt_brand_add = GF_4CC(b0, b1, b2, b3);
+		nb_alt_brand_add++;
+		break;
+	case 2: //-rb
+		brand_rem = (u32*)gf_realloc(brand_rem, sizeof(u32) * (nb_alt_brand_rem + 1));
+		if (!brand_rem) return 2;
+		brand_remnb_alt_brand_rem = GF_4CC(b0, b1, b2, b3);
+		nb_alt_brand_rem++;
+		break;
+	}
+	return 0;
+}
+
+u32 parse_mpegu(char *arg_val, u32 opt)
+{
+	pack_file = arg_val;
+	pack_wgt = GF_TRUE;
+	return 0;
+}
+
+u32 parse_file_info(char *arg_val, u32 opt)
+{
+	print_info = opt ? 2 : 1;
+	if (opt==2) {
+		print_info = 2;
+		if (arg_val) return 3;
+		return 0;
+	}
+	if (arg_val) {
+		if (!parse_track_id(&info_track_id, arg_val, GF_FALSE))
+			return 3;
+	}
+	return 0;
+}
+u32 parse_boxpatch(char *arg_val, u32 opt)
+{
+	box_patch_filename = arg_val;
+	char *sep = strchr(box_patch_filename, '=');
+	if (sep) {
+		sep0 = 0;
+		parse_track_id(&box_patch_track, box_patch_filename, GF_FALSE);
+		sep0 = '=';
+		box_patch_filename = sep+1;
+	}
+	open_edit = GF_TRUE;
+	return 0;
+}
+u32 parse_compress(char *arg_val, u32 opt)
+{
+	compress_moov = opt ? 2 : 1;
+	open_edit = GF_TRUE;
+	return 0;
+}
+
+
+u32 parse_dump_udta(char *code, u32 opt)
+{
+	char *sep;
+	sep = strchr(code, ':');
+	if (sep) {
+		sep0 = 0;
+		parse_track_id(&dump_udta_track, code, GF_FALSE);
+		sep0 = ':';
+		code = sep + 1;
+	}
+
+	if (strlen(code) == 4) {
+		dump_udta_type = GF_4CC(code0, code1, code2, code3);
+	} else if (strlen(code) == 8) {
+		// hex representation on 8 chars
+		u32 hex1, hex2, hex3, hex4;
+		if (sscanf(code, "%02x%02x%02x%02x", &hex1, &hex2, &hex3, &hex4) != 4) {
+			M4_LOG(GF_LOG_ERROR, ("udta code is either a 4CC or 8 hex chars for non-printable 4CC\n"));
+			return 2;
+		}
+		dump_udta_type = GF_4CC(hex1, hex2, hex3, hex4);
+	} else {
+		M4_LOG(GF_LOG_ERROR, ("udta code is either a 4CC or 8 hex chars for non-printable 4CC\n"));
+		return 2;
+	}
+	return 0;
+}
+
+u32 parse_dump_ts(char *arg_val, u32 opt)
+{
+	dump_timestamps = 1;
+	if (arg_val) {
+		if (isdigit(arg_val0)) {
+			program_number = parse_u32(arg_val, "Program");
+		} else {
+			return 3;
+		}
+	}
+	return 0;
+}
+
+u32 parse_ttxt(char *arg_val, u32 opt)
+{
+	if (opt) //-srt
+		dump_srt = GF_TRUE;
+	else
+		dump_ttxt = GF_TRUE;
+
+	import_subtitle = 1;
+	ttxt_track_id.type = 0;
+	ttxt_track_id.ID_or_num = 0;
+
+	if (arg_val && (!strcmp(arg_val, "*") || !strcmp(arg_val, "@") || !strcmp(arg_val, "all")) ) {
+		ttxt_track_id.ID_or_num = (u32)-1;
+	} else if (arg_val) {
+		if (parse_track_id(&ttxt_track_id, arg_val, GF_FALSE)==GF_FALSE)
+			return 3;
+	}
+	return 0;
+}
+
+u32 parse_dashlive(char *arg, char *arg_val, u32 opt)
+{
+	dash_mode = opt ? GF_DASH_DYNAMIC_DEBUG : GF_DASH_DYNAMIC;
+	dash_live = 1;
+	if (arg10 == '=') {
+		dash_ctx_file = arg + 11;
+	}
+	dash_duration = atof(arg_val);
+	return 0;
+}
+
+u32 parse_help(char *arg_val, u32 opt)
+{
+	if (!arg_val) PrintUsage();
+	else if (opt) PrintHelp(arg_val, GF_TRUE, GF_FALSE);
+	else if (!strcmp(arg_val, "general")) PrintGeneralUsage();
+	else if (!strcmp(arg_val, "extract")) PrintExtractUsage();
+	else if (!strcmp(arg_val, "split")) PrintSplitUsage();
+	else if (!strcmp(arg_val, "dash")) PrintDASHUsage();
+	else if (!strcmp(arg_val, "dump")) PrintDumpUsage();
+	else if (!strcmp(arg_val, "import")) PrintImportUsage();
+	else if (!strcmp(arg_val, "format")) {
+		M4_LOG(GF_LOG_WARNING, ("see filters documentation(Filters), `gpac -h codecs`, `gpac -h formats` and `gpac -h protocols` \n"));
+	}
+	else if (!strcmp(arg_val, "hint")) PrintHintUsage();
+	else if (!strcmp(arg_val, "encode")) PrintEncodeUsage();
+	else if (!strcmp(arg_val, "crypt")) PrintEncryptUsage();
+	else if (!strcmp(arg_val, "meta")) PrintMetaUsage();
+	else if (!strcmp(arg_val, "swf")) PrintSWFUsage();
+#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
+	else if (!strcmp(arg_val, "rtp")) {
+		M4_LOG(GF_LOG_WARNING, ("RTP streaming deprecated in MP4Box, use gpac application\n"));
+	}
+	else if (!strcmp(arg_val, "live")) PrintLiveUsage();
+#endif
+	else if (!strcmp(arg_val, "core")) PrintCoreUsage();
+	else if (!strcmp(arg_val, "tags")) PrintTags();
+	else if (!strcmp(arg_val, "cicp")) PrintCICP();
+	else if (!strcmp(arg_val, "all")) {
+		PrintGeneralUsage();
+		PrintExtractUsage();
+		PrintDASHUsage();
+		PrintSplitUsage();
+		PrintDumpUsage();
+		PrintImportUsage();
+		PrintHintUsage();
+		PrintEncodeUsage();
+		PrintEncryptUsage();
+		PrintMetaUsage();
+		PrintSWFUsage();
+#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
+		PrintLiveUsage();
+#endif
+		PrintCoreUsage();
+		PrintTags();
+		PrintCICP();
+	} else if (!strcmp(arg_val, "opts")) {
+		PrintHelp("@", GF_FALSE, GF_FALSE);
+	} else {
+		PrintHelp(arg_val, GF_FALSE, GF_FALSE);
+	}
+	return 1;
+}
+
+#define DOC_AUTOGEN_WARNING \
+	"\n"
+
+u32 parse_gendoc(char *name, u32 opt)
+{
+	u32 i=0;
+	//gen MD
+	if (!opt) {
+		help_flags = GF_PRINTARG_MD | GF_PRINTARG_IS_APP;
+		helpout = gf_fopen("mp4box-gen-opts.md", "w");
+
+		fprintf(helpout, DOC_AUTOGEN_WARNING);
+		fprintf(helpout, "# Syntax\n");
+		gf_sys_format_help(helpout, help_flags, "MP4Box option input option other_dash_inputs\n"
+			" \n"
+		);
+		PrintGeneralUsage();
+		PrintEncryptUsage();
+		fprintf(helpout, "# Help Options\n");
+		while (m4b_usage_argsi.name) {
+			GF_GPACArg *g_arg = (GF_GPACArg *) &m4b_usage_argsi;
+			i++;
+			gf_sys_print_arg(helpout, help_flags, g_arg, "mp4box-general");
+		}
+
+		gf_fclose(helpout);
+
+		helpout = gf_fopen("mp4box-import-opts.md", "w");
+		fprintf(helpout, DOC_AUTOGEN_WARNING);
+		PrintImportUsage();
+		gf_fclose(helpout);
+
+		helpout = gf_fopen("mp4box-dash-opts.md", "w");
+		fprintf(helpout, DOC_AUTOGEN_WARNING);
+		PrintDASHUsage();
+		gf_fclose(helpout);
+
+		helpout = gf_fopen("mp4box-dump-opts.md", "w");
+		fprintf(helpout, DOC_AUTOGEN_WARNING);
+		PrintExtractUsage();
+		PrintDumpUsage();
+		PrintSplitUsage();
+		gf_fclose(helpout);
+
+		helpout = gf_fopen("mp4box-meta-opts.md", "w");
+		fprintf(helpout, DOC_AUTOGEN_WARNING);
+		PrintMetaUsage();
+		gf_fclose(helpout);
+
+
+		helpout = gf_fopen("mp4box-scene-opts.md", "w");
+		fprintf(helpout, DOC_AUTOGEN_WARNING);
+		PrintEncodeUsage();
+#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
+		PrintLiveUsage();
+#endif
+		PrintSWFUsage();
+		gf_fclose(helpout);
+
+		helpout = gf_fopen("mp4box-other-opts.md", "w");
+		fprintf(helpout, DOC_AUTOGEN_WARNING);
+		PrintHintUsage();
+		PrintTags();
+		gf_fclose(helpout);
+	}
+	//gen man
+	else {
+		help_flags = GF_PRINTARG_MAN;
+		helpout = gf_fopen("mp4box.1", "w");
+
+
+		fprintf(helpout, ".TH MP4Box 1 2019 MP4Box GPAC\n");
+		fprintf(helpout, ".\n.SH NAME\n.LP\nMP4Box \\- GPAC command-line media packager\n.SH SYNOPSIS\n.LP\n.B MP4Box\n.RI options \\ file \\ options\n.br\n.\n");
+
+		PrintGeneralUsage();
+		PrintExtractUsage();
+		PrintDASHUsage();
+		PrintSplitUsage();
+		PrintDumpUsage();
+		PrintImportUsage();
+		PrintHintUsage();
+		PrintEncodeUsage();
+		PrintEncryptUsage();
+		PrintMetaUsage();
+		PrintSWFUsage();
+		PrintTags();
+#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
+		PrintLiveUsage();
+#endif
+
+		fprintf(helpout, ".SH EXAMPLES\n.TP\nBasic and advanced examples are available at https://wiki.gpac.io/MP4Box\n");
+		fprintf(helpout, ".SH MORE\n.LP\nAuthors: GPAC developers, see git repo history (-log)\n"
+		".br\nFor bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac\n"
+		".br\nbuild: %s\n"
+		".br\nCopyright: %s\n.br\n"
+		".SH SEE ALSO\n"
+		".LP\ngpac(1)\n", gf_gpac_version(), gf_gpac_copyright());
+
+		gf_fclose(helpout);
+	}
+	return 1;
+}
+
+u32 mp4box_parse_single_arg_class(int argc, char **argv, char *arg, u32 *arg_index, MP4BoxArg *arg_class)
+{
+	MP4BoxArg *arg_desc = NULL;
+	char *arg_val = NULL;
+	u32 i=0;
+	while (arg_classi.name) {
+		arg_desc = (MP4BoxArg *) &arg_classi;
+		i++;
+
+#ifdef TEST_ARGS
+		char *sep = strchr(arg_desc->name, ' ');
+		if (sep) {
+			M4_LOG(GF_LOG_ERROR, ("Invalid arg %s, space not allowed\n", arg_desc->name));
+			exit(1);
+		}
+#endif
+		if (!strcmp(arg_desc->name, arg+1))
+			break;
+		if (arg_desc->altname && !strcmp(arg_desc->altname, arg+1))
+			break;
+
+		if (arg_desc->parse_flags & ARG_IS_FUN2) {
+			if (!strncmp(arg_desc->name, arg+1, strlen(arg_desc->name) ))
+				break;
+		}
+		arg_desc = NULL;
+	}
+	if (!arg_desc)
+		return GF_FALSE;
+
+	if (arg_desc->parse_flags & ARG_OPEN_EDIT) open_edit = GF_TRUE;
+	if (arg_desc->parse_flags & ARG_NEED_SAVE) do_save = GF_TRUE;
+	if (arg_desc->parse_flags & ARG_NO_INPLACE) no_inplace = GF_TRUE;
+
+	if (arg_desc->type != GF_ARG_BOOL) {
+		Bool has_next = GF_TRUE;
+		if (*arg_index + 1 == (u32) argc)
+			has_next = GF_FALSE;
+		else if (argv*arg_index + 10 == '-') {
+			s32 v;
+			if (sscanf(argv*arg_index + 1, "%d", &v)!=1)
+				has_next = GF_FALSE;
+		}
+		if (!has_next && ! (arg_desc->parse_flags & ARG_EMPTY) ) {
+			M4_LOG(GF_LOG_ERROR, ("Missing argument value for %s - please check usage\n", arg));
+			arg_parse_res = 2;
+			return GF_TRUE;
+		}
+
+		if (has_next && (arg_desc->parse_flags & ARG_EMPTY) && (arg_desc->type==GF_ARG_INT)) {
+			s32 ival;
+			if (sscanf(argv*arg_index + 1, "%d", &ival) != 1) {
+				has_next = GF_FALSE;
+				arg_val = NULL;
+			}
+		}
+		if (has_next) {
+			has_next_arg = GF_TRUE;
+			*arg_index += 1;
+			arg_val = argv*arg_index;
+		}
+	}
+	if (!arg_desc->arg_ptr) return GF_TRUE;
+
+	if (arg_desc->parse_flags & (ARG_IS_FUN|ARG_IS_FUN2) ) {
+		u32 res;
+		if (arg_desc->parse_flags & ARG_PUSH_SYSARGS)
+			gf_sys_set_args(argc, (const char**) argv);
+
+		if (arg_desc->parse_flags & ARG_IS_FUN) {
+			parse_arg_fun fun = (parse_arg_fun) arg_desc->arg_ptr;
+			res = fun(arg_val, arg_desc->argv_val);
+		} else {
+			parse_arg_fun2 fun2 = (parse_arg_fun2) arg_desc->arg_ptr;
+			res = fun2(arg, arg_val, arg_desc->argv_val);
+		}
+		//rewind, not our arg
+		if ((res==3) && argv) {
+			*arg_index -= 1;
+			res = 0;
+		}
+		arg_parse_res = res;
+		return GF_TRUE;
+	}
+
+	if (arg_desc->parse_flags & ARG_INT_INC) {
+		* (u32 *) arg_desc->arg_ptr += 1;
+		return GF_TRUE;
+	}
+
+	if (arg_desc->type == GF_ARG_BOOL) {
+		if (!arg_desc->parse_flags) {
+			if (arg_desc->argv_val) {
+				* (u32 *) arg_desc->arg_ptr = arg_desc->argv_val;
+			} else {
+				* (Bool *) arg_desc->arg_ptr = GF_TRUE;
+			}
+		} else if (arg_desc->parse_flags & ARG_BOOL_REV) {
+			* (Bool *) arg_desc->arg_ptr = GF_FALSE;
+		} else if (arg_desc->parse_flags & ARG_HAS_VALUE) {
+			* (u32 *) arg_desc->arg_ptr = 0;
+		} else if (arg_desc->parse_flags & ARG_BIT_MASK) {
+			* (u32 *) arg_desc->arg_ptr |= arg_desc->argv_val;
+		} else if (arg_desc->parse_flags & ARG_BIT_MASK_REM) {
+			* (u32 *) arg_desc->arg_ptr &= ~arg_desc->argv_val;
+		} else if (arg_desc->argv_val) {
+			* (u32 *) arg_desc->arg_ptr = arg_desc->argv_val;
+		} else {
+			* (u32 *) arg_desc->arg_ptr = GF_TRUE;
+		}
+		return GF_TRUE;
+	}
+
+	if (arg_desc->type == GF_ARG_STRING) {
+		if (arg_desc->parse_flags & ARG_IS_4CC) {
+			u32 alen = arg_val ? (u32) strlen(arg_val) : 0;
+			if ((alen<3) || (alen>4)) {
+				M4_LOG(GF_LOG_ERROR, ("Value for %s must be a 4CC, %s is not - please check usage\n", arg, arg_val));
+				arg_parse_res = 2;
+				return GF_TRUE;
+			}
+			* (u32 *) arg_desc->arg_ptr = GF_4CC(arg_val0, arg_val1, arg_val2, arg_val3);
+			return GF_TRUE;
+		}
+
+		* (char **) arg_desc->arg_ptr = arg_val;
+		return GF_TRUE;
+	}
+	if (!arg_val) {
+		M4_LOG(GF_LOG_ERROR, ("Missing value for %s - please check usage\n", arg));
+		arg_parse_res = 2;
+		return GF_TRUE;
+	}
+
+	if (arg_desc->type == GF_ARG_DOUBLE) {
+		Double v = atof(arg_val);
+		if (arg_desc->parse_flags & ARG_DIV_1000) {
+			v /= 1000;
+		}
+		if ((arg_desc->parse_flags & ARG_NON_ZERO) && !v) {
+			M4_LOG(GF_LOG_ERROR, ("Value for %s shall not be 0 - please check usage\n", arg));
+			arg_parse_res = 2;
+			return GF_TRUE;
+		}
+		* (Double *) arg_desc->arg_ptr = v;
+		return GF_TRUE;
+	}
+
+	if (arg_desc->type != GF_ARG_INT) {
+		M4_LOG(GF_LOG_ERROR, ("Unsupported argument type for %s - please report to gpac devs\n", arg));
+		arg_parse_res = 2;
+		return GF_TRUE;
+	}
+	if (arg_desc->parse_flags & ARG_64BITS) {
+		u64 v;
+		sscanf(arg_val, LLU, &v);
+		if (arg_desc->parse_flags & ARG_DIV_1000) {
+			v /= 1000;
+		}
+		if ((arg_desc->parse_flags & ARG_NON_ZERO) && !v) {
+			M4_LOG(GF_LOG_ERROR, ("Value for %s shall not be 0 - please check usage\n", arg));
+			arg_parse_res = 2;
+			return GF_TRUE;
+		}
+		* (u64 *) arg_desc->arg_ptr = v;
+	} else {
+		s32 v;
+		if (sscanf(arg_val, "%d", &v) != 1) {
+			M4_LOG(GF_LOG_ERROR, ("Value for %s shall not be an integer - please check usage\n", arg));
+			arg_parse_res = 2;
+			return GF_TRUE;
+		}
+		if (arg_desc->parse_flags & ARG_DIV_1000) {
+			v /= 1000;
+		}
+		if ((arg_desc->parse_flags & ARG_NON_ZERO) && !v) {
+			M4_LOG(GF_LOG_ERROR, ("Value for %s shall not be 0 - please check usage\n", arg));
+			arg_parse_res = 2;
+			return GF_TRUE;
+		}
+		* (s32 *) arg_desc->arg_ptr = v;
+	}
+	return GF_TRUE;
+}
+
+Bool mp4box_parse_single_arg(int argc, char **argv, char *arg, u32 *arg_index)
+{
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_gen_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_split_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_dash_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_imp_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_senc_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_crypt_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_hint_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_extr_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_dump_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_meta_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_swf_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_liveenc_args)) return GF_TRUE;
+	if (mp4box_parse_single_arg_class(argc, argv, arg, arg_index, m4b_usage_args)) return GF_TRUE;
+
+	return GF_FALSE;
+}
+
+
+u32 mp4box_parse_args(int argc, char **argv)
+{
+	u32 i;
+	/*parse our args*/
+	for (i = 1; i < (u32)argc; i++) {
+		char *arg = argvi;
+		/*input file(s)*/
+		if ((arg0 != '-') || !stricmp(arg, "--")) {
+			char *arg_val = arg;
+			if (!stricmp(arg, "--")) {
+				if (i+1==(u32)argc) {
+					M4_LOG(GF_LOG_ERROR, ("Missing arg for `--` - please check usage\n"));
+					return 2;
+				}
+				has_next_arg = GF_TRUE;
+				arg_val = argvi + 1;
+				i++;
+			}
+			if (argc < 3) {
+				M4_LOG(GF_LOG_ERROR, ("Error - only one input file found as argument, please check usage\n"));
+				return 2;
+			}
+			else if (inName) {
+				if (dash_duration) {
+					if (!nb_dash_inputs) {
+						dash_inputs = set_dash_input(dash_inputs, inName, &nb_dash_inputs);
+					}
+					dash_inputs = set_dash_input(dash_inputs, arg_val, &nb_dash_inputs);
+				}
+				else {
+					M4_LOG(GF_LOG_ERROR, ("Error - 2 input names specified, please check usage\n"));
+					return 2;
+				}
+			}
+			else {
+				inName = arg_val;
+			}
+		}
+		//all deprecated options
+		else if (!stricmp(arg, "-grab-ts") || !stricmp(arg, "-atsc") || !stricmp(arg, "-rtp")) {
+			M4_LOG(GF_LOG_ERROR, ("Deprecated fuctionnality `%s` - use gpac application\n", arg));
+			return 2;
+		}
+		else if (!stricmp(arg, "-write-buffer")) {
+			M4_LOG(GF_LOG_WARNING, ("`%s` option deprecated, use `-bs-cache-size`", arg));
+			gf_opts_set_key("temp", "bs-cache-size", argvi + 1);
+			i++;
+		}
+		else if (!stricmp(arg, "-pssh-moof")) {
+			M4_LOG(GF_LOG_ERROR, ("`-pssh-moof` option deprecated , use `-pssh` option\n"));
+			return 2;
+		}
+		else if (!stricmp(arg, "-tag-list")) {
+			M4_LOG(GF_LOG_ERROR, ("`-tag-list` option deprecated, use `-h tags`\n"));
+			return 2;
+		}
+		else if (!stricmp(arg, "-aviraw")) {
+			M4_LOG(GF_LOG_ERROR, ("`-aviraw` option deprecated, use `-raw`\n"));
+			return 2;
+		}
+		else if (!stricmp(arg, "-avi")) {
+			M4_LOG(GF_LOG_ERROR, ("`-avi` option deprecated, use `-mux`\n"));
+			return 2;
+		}
+		else if (!strncmp(arg, "-p=", 3)) {
+			continue;
+		}
+#ifndef GPAC_MEMORY_TRACKING
+		else if (!strcmp(arg, "-mem-track") || !strcmp(arg, "-mem-track-stack")) {
+			continue;
+		}
+#endif
+
+		//parse argument
+		else if (mp4box_parse_single_arg(argc, argv, arg, &i)) {
+			if (arg_parse_res)
+				return mp4box_cleanup(arg_parse_res);
+		}
+		//not a MP4Box arg
+		else {
+			u32 res = gf_sys_is_gpac_arg(arg);
+			if (res==0) {
+				PrintHelp(arg, GF_FALSE, GF_TRUE);
+				return 2;
+			} else if (res==2) {
+				i++;
+			}
+		}
+		//live scene encoder does not use the unified parsing and should be moved as a scene encoder filter
+		if (live_scene) return 0;
+	}
+	return 0;
+}
+
+/*
+	END OF OPTION PARSING CODE
+*/
+
+
+
+void scene_coding_log(void *cbk, GF_LOG_Level log_level, GF_LOG_Tool log_tool, const char *fmt, va_list vlist)
+{
+	FILE *logs = cbk;
+	if (log_tool != GF_LOG_CODING) return;
+	vfprintf(logs, fmt, vlist);
+	fflush(logs);
+}
+
+
+#ifndef GPAC_DISABLE_ISOM_HINTING
+
+/*
+		MP4 File Hinting
+*/
+
+void SetupClockReferences(GF_ISOFile *file)
+{
+	u32 i, count, ocr_id;
+	count = gf_isom_get_track_count(file);
+	if (count==1) return;
+	ocr_id = 0;
+	for (i=0; i<count; i++) {
+		if (!gf_isom_is_track_in_root_od(file, i+1)) continue;
+		ocr_id = gf_isom_get_track_id(file, i+1);
+		break;
+	}
+	/*doesn't look like MP4*/
+	if (!ocr_id) return;
+	for (i=0; i<count; i++) {
+		GF_ESD *esd = gf_isom_get_esd(file, i+1, 1);
+		if (esd) {
+			esd->OCRESID = ocr_id;
+			gf_isom_change_mpeg4_description(file, i+1, 1, esd);
+			gf_odf_desc_del((GF_Descriptor *) esd);
+		}
+	}
+}
+
+/*base RTP payload type used (you can specify your own types if needed)*/
+#define BASE_PAYT		96
+
+GF_Err HintFile(GF_ISOFile *file, u32 MTUSize, u32 max_ptime, u32 rtp_rate, u32 base_flags, Bool copy_data, Bool interleave, Bool regular_iod, Bool single_group, Bool hint_no_offset)
+{
+	GF_ESD *esd;
+	GF_InitialObjectDescriptor *iod;
+	u32 i, val, res, streamType;
+	u32 sl_mode, prev_ocr, single_ocr, nb_done, tot_bw, bw, flags, spec_type;
+	GF_Err e;
+	char szPayload30;
+	GF_RTPHinter *hinter;
+	Bool copy, has_iod, single_av;
+	u8 init_payt = BASE_PAYT;
+	u32 mtype;
+	GF_SDP_IODProfile iod_mode = GF_SDP_IOD_NONE;
+	u32 media_group = 0;
+	u8 media_prio = 0;
+
+	tot_bw = 0;
+	prev_ocr = 0;
+	single_ocr = 1;
+
+	has_iod = 1;
+	iod = (GF_InitialObjectDescriptor *) gf_isom_get_root_od(file);
+	if (!iod) has_iod = 0;
+	else {
+		if (!gf_list_count(iod->ESDescriptors)) has_iod = 0;
+		gf_odf_desc_del((GF_Descriptor *) iod);
+	}
+
+	spec_type = gf_isom_guess_specification(file);
+	single_av = single_group ? 1 : gf_isom_is_single_av(file);
+
+	/*first make sure we use a systems track as base OCR*/
+	for (i=0; i<gf_isom_get_track_count(file); i++) {
+		res = gf_isom_get_media_type(file, i+1);
+		if ((res==GF_ISOM_MEDIA_SCENE) || (res==GF_ISOM_MEDIA_OD)) {
+			if (gf_isom_is_track_in_root_od(file, i+1)) {
+				gf_isom_set_default_sync_track(file, i+1);
+				break;
+			}
+		}
+	}
+
+	nb_done = 0;
+	for (i=0; i<gf_isom_get_track_count(file); i++) {
+		sl_mode = base_flags;
+		copy = copy_data;
+		/*skip emty tracks (mainly MPEG-4 interaction streams...*/
+		if (!gf_isom_get_sample_count(file, i+1)) continue;
+		if (!gf_isom_is_track_enabled(file, i+1)) {
+			M4_LOG(GF_LOG_INFO, ("Track ID %d disabled - skipping hint\n", gf_isom_get_track_id(file, i+1) ));
+			continue;
+		}
+
+		mtype = gf_isom_get_media_type(file, i+1);
+		switch (mtype) {
+		case GF_ISOM_MEDIA_VISUAL:
+			if (single_av) {
+				media_group = 2;
+				media_prio = 2;
+			}
+			break;
+ case GF_ISOM_MEDIA_AUXV:
+ if (single_av) {
+ media_group = 2;
+ media_prio = 3;
+ }
+ break;
+ case GF_ISOM_MEDIA_PICT:
+ if (single_av) {
+ media_group = 2;
+ media_prio = 4;
+ }
+ break;
+		case GF_ISOM_MEDIA_AUDIO:
+			if (single_av) {
+				media_group = 2;
+				media_prio = 1;
+			}
+			break;
+		case GF_ISOM_MEDIA_HINT:
+			continue;
+		default:
+			/*no hinting of systems track on isma*/
+			if (spec_type==GF_ISOM_BRAND_ISMA) continue;
+		}
+		mtype = gf_isom_get_media_subtype(file, i+1, 1);
+		if ((mtype==GF_ISOM_SUBTYPE_MPEG4) || (mtype==GF_ISOM_SUBTYPE_MPEG4_CRYP) ) mtype = gf_isom_get_mpeg4_subtype(file, i+1, 1);
+
+		if (!single_av) {
+			/*one media per group only (we should prompt user for group selection)*/
+			media_group ++;
+			media_prio = 1;
+		}
+
+		streamType = 0;
+		esd = gf_isom_get_esd(file, i+1, 1);
+		if (esd && esd->decoderConfig) {
+			streamType = esd->decoderConfig->streamType;
+			if (!prev_ocr) {
+				prev_ocr = esd->OCRESID;
+				if (!esd->OCRESID) prev_ocr = esd->ESID;
+			} else if (esd->OCRESID && prev_ocr != esd->OCRESID) {
+				single_ocr = 0;
+			}
+			/*OD MUST BE WITHOUT REFERENCES*/
+			if (streamType==1) copy = 1;
+		}
+		gf_odf_desc_del((GF_Descriptor *) esd);
+
+		if (!regular_iod && gf_isom_is_track_in_root_od(file, i+1)) {
+			/*single AU - check if base64 would fit in ESD (consider 33% overhead of base64), otherwise stream*/
+			if (gf_isom_get_sample_count(file, i+1)==1) {
+				GF_ISOSample *samp = gf_isom_get_sample(file, i+1, 1, &val);
+				if (streamType && samp) {
+					res = gf_hinter_can_embbed_data(samp->data, samp->dataLength, streamType);
+				} else {
+					/*not a system track, we shall hint it*/
+					res = 0;
+				}
+				if (samp) gf_isom_sample_del(&samp);
+				if (res) continue;
+			}
+		}
+		if (interleave) sl_mode |= GP_RTP_PCK_USE_INTERLEAVING;
+
+		hinter = gf_hinter_track_new(file, i+1, MTUSize, max_ptime, rtp_rate, sl_mode, init_payt, copy, media_group, media_prio, &e);
+
+		if (!hinter) {
+			if (e) {
+				M4_LOG(nb_done ? GF_LOG_WARNING : GF_LOG_ERROR, ("Cannot create hinter (%s)\n", gf_error_to_string(e) ));
+				if (!nb_done) return e;
+			}
+			continue;
+		}
+
+		if (hint_no_offset)
+			gf_hinter_track_force_no_offsets(hinter);
+
+		bw = gf_hinter_track_get_bandwidth(hinter);
+		tot_bw += bw;
+		flags = gf_hinter_track_get_flags(hinter);
+
+		//set extraction mode for AVC/SVC
+		gf_isom_set_nalu_extract_mode(file, i+1, GF_ISOM_NALU_EXTRACT_LAYER_ONLY);
+
+		gf_hinter_track_get_payload_name(hinter, szPayload);
+		M4_LOG(GF_LOG_INFO, ("Hinting track ID %d - Type \"%s:%s\" (%s) - BW %d kbps\n", gf_isom_get_track_id(file, i+1), gf_4cc_to_str(mtype), gf_4cc_to_str(mtype), szPayload, bw));
+		if (flags & GP_RTP_PCK_SYSTEMS_CAROUSEL) M4_LOG(GF_LOG_INFO, ("\tMPEG-4 Systems stream carousel enabled\n"));
+		e = gf_hinter_track_process(hinter);
+
+		if (!e) e = gf_hinter_track_finalize(hinter, has_iod);
+		gf_hinter_track_del(hinter);
+
+		if (e) {
+			M4_LOG(GF_LOG_ERROR, ("Error while hinting (%s)\n", gf_error_to_string(e)));
+			return e;
+		}
+		init_payt++;
+		nb_done ++;
+	}
+
+	if (has_iod) {
+		iod_mode = GF_SDP_IOD_ISMA;
+		if (regular_iod) iod_mode = GF_SDP_IOD_REGULAR;
+	} else {
+		iod_mode = GF_SDP_IOD_NONE;
+	}
+	gf_hinter_finalize(file, iod_mode, tot_bw);
+
+	if (!single_ocr)
+		M4_LOG(GF_LOG_WARNING, ("Warning: at least 2 timelines found in the file\nThis may not be supported by servers/players\n\n"));
+
+	return GF_OK;
+}
+
+#endif /*GPAC_DISABLE_ISOM_HINTING*/
+
+#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_AV_PARSERS)
+
+static void check_media_profile(GF_ISOFile *file, u32 track)
+{
+	u8 PL;
+	GF_ESD *esd = gf_isom_get_esd(file, track, 1);
+	if (!esd) return;
+
+	switch (esd->decoderConfig->streamType) {
+	case 0x04:
+		PL = gf_isom_get_pl_indication(file, GF_ISOM_PL_VISUAL);
+		if (esd->decoderConfig->objectTypeIndication==GF_CODECID_MPEG4_PART2) {
+			GF_M4VDecSpecInfo vdsi;
+			gf_m4v_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &vdsi);
+			if (vdsi.VideoPL > PL) gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, vdsi.VideoPL);
+		} else if ((esd->decoderConfig->objectTypeIndication==GF_CODECID_AVC) || (esd->decoderConfig->objectTypeIndication==GF_CODECID_SVC)) {
+			gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0x15);
+		} else if (!PL) {
+			gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0xFE);
+		}
+		break;
+	case 0x05:
+		PL = gf_isom_get_pl_indication(file, GF_ISOM_PL_AUDIO);
+		switch (esd->decoderConfig->objectTypeIndication) {
+		case GF_CODECID_AAC_MPEG2_MP:
+		case GF_CODECID_AAC_MPEG2_LCP:
+		case GF_CODECID_AAC_MPEG2_SSRP:
+		case GF_CODECID_AAC_MPEG4:
+		{
+			GF_M4ADecSpecInfo adsi;
+			gf_m4a_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &adsi);
+			if (adsi.audioPL > PL) gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, adsi.audioPL);
+		}
+			break;
+		default:
+			if (!PL) gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, 0xFE);
+		}
+		break;
+	}
+	gf_odf_desc_del((GF_Descriptor *) esd);
+}
+void remove_systems_tracks(GF_ISOFile *file)
+{
+	u32 i, count;
+
+	count = gf_isom_get_track_count(file);
+	if (count==1) return;
+
+	/*force PL rewrite*/
+	gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0);
+	gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, 0);
+	gf_isom_set_pl_indication(file, GF_ISOM_PL_OD, 1);	/*the lib always remove IOD when no profiles are specified..*/
+
+	for (i=0; i<gf_isom_get_track_count(file); i++) {
+		switch (gf_isom_get_media_type(file, i+1)) {
+		case GF_ISOM_MEDIA_VISUAL:
+ case GF_ISOM_MEDIA_AUXV:
+ case GF_ISOM_MEDIA_PICT:
+		case GF_ISOM_MEDIA_AUDIO:
+		case GF_ISOM_MEDIA_TEXT:
+		case GF_ISOM_MEDIA_SUBT:
+			gf_isom_remove_track_from_root_od(file, i+1);
+			check_media_profile(file, i+1);
+			break;
+		/*only remove real systems tracks (eg, delaing with scene description & presentation)
+		but keep meta & all unknown tracks*/
+		case GF_ISOM_MEDIA_SCENE:
+			switch (gf_isom_get_media_subtype(file, i+1, 1)) {
+			case GF_ISOM_MEDIA_DIMS:
+				gf_isom_remove_track_from_root_od(file, i+1);
+				continue;
+			default:
+				break;
+			}
+		case GF_ISOM_MEDIA_OD:
+		case GF_ISOM_MEDIA_OCR:
+		case GF_ISOM_MEDIA_MPEGJ:
+			gf_isom_remove_track(file, i+1);
+			i--;
+			break;
+		default:
+			break;
+		}
+	}
+	/*none required*/
+	if (!gf_isom_get_pl_indication(file, GF_ISOM_PL_AUDIO)) gf_isom_set_pl_indication(file, GF_ISOM_PL_AUDIO, 0xFF);
+	if (!gf_isom_get_pl_indication(file, GF_ISOM_PL_VISUAL)) gf_isom_set_pl_indication(file, GF_ISOM_PL_VISUAL, 0xFF);
+
+	gf_isom_set_pl_indication(file, GF_ISOM_PL_OD, 0xFF);
+	gf_isom_set_pl_indication(file, GF_ISOM_PL_SCENE, 0xFF);
+	gf_isom_set_pl_indication(file, GF_ISOM_PL_GRAPHICS, 0xFF);
+	gf_isom_set_pl_indication(file, GF_ISOM_PL_INLINE, 0);
+}
+
+#endif /*!defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_AV_PARSERS)*/
+
+GF_FileType get_file_type_by_ext(char *inName)
+{
+	GF_FileType type = GF_FILE_TYPE_NOT_SUPPORTED;
+	char *ext = strrchr(inName, '.');
+	if (ext) {
+		char *sep;
+		if (!strcmp(ext, ".gz")) ext = strrchr(ext-1, '.');
+		ext+=1;
+		sep = strchr(ext, '.');
+		if (sep) sep0 = 0;
+
+		if (!stricmp(ext, "mp4") || !stricmp(ext, "3gp") || !stricmp(ext, "mov") || !stricmp(ext, "3g2") || !stricmp(ext, "3gs")) {
+			type = GF_FILE_TYPE_ISO_MEDIA;
+		} else if (!stricmp(ext, "bt") || !stricmp(ext, "wrl") || !stricmp(ext, "x3dv")) {
+			type = GF_FILE_TYPE_BT_WRL_X3DV;
+		} else if (!stricmp(ext, "xmt") || !stricmp(ext, "x3d")) {
+			type = GF_FILE_TYPE_XMT_X3D;
+		} else if (!stricmp(ext, "lsr") || !stricmp(ext, "saf")) {
+			type = GF_FILE_TYPE_LSR_SAF;
+		} else if (!stricmp(ext, "svg") || !stricmp(ext, "xsr") || !stricmp(ext, "xml")) {
+			type = GF_FILE_TYPE_SVG;
+		} else if (!stricmp(ext, "swf")) {
+			type = GF_FILE_TYPE_SWF;
+		} else if (!stricmp(ext, "jp2")) {
+			if (sep) sep0 = '.';
+			return GF_FILE_TYPE_NOT_SUPPORTED;
+		}
+		else type = GF_FILE_TYPE_NOT_SUPPORTED;
+
+		if (sep) sep0 = '.';
+	}
+
+
+	/*try open file in read mode*/
+	if (!type && gf_isom_probe_file(inName)) type = GF_FILE_TYPE_ISO_MEDIA;
+	return type;
+}
+
+
+static GF_Err xml_bs_to_bin(char *inName, char *outName, u32 dump_std)
+{
+	GF_Err e;
+	GF_XMLNode *root;
+	u8 *data = NULL;
+	u32 data_size;
+
+	GF_DOMParser *dom = gf_xml_dom_new();
+	e = gf_xml_dom_parse(dom, inName, NULL, NULL);
+	if (e) {
+		gf_xml_dom_del(dom);
+		M4_LOG(GF_LOG_ERROR, ("Failed to parse XML file: %s\n", gf_error_to_string(e)));
+		return e;
+	}
+	root = gf_xml_dom_get_root_idx(dom, 0);
+	if (!root) {
+		gf_xml_dom_del(dom);
+		return GF_OK;
+	}
+
+	e = gf_xml_parse_bit_sequence(root, inName, &data, &data_size);
+	gf_xml_dom_del(dom);
+
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("Failed to parse binary sequence: %s\n", gf_error_to_string(e)));
+		return e;
+	}
+
+	if (dump_std) {
+		gf_fwrite(data, data_size, stdout);
+	} else {
+		FILE *t;
+		char szFileGF_MAX_PATH;
+		if (outName) {
+			strcpy(szFile, outName);
+		} else {
+			strcpy(szFile, inName);
+			strcat(szFile, ".bin");
+		}
+		t = gf_fopen(szFile, "wb");
+		if (!t) {
+			M4_LOG(GF_LOG_ERROR, ("Failed to open file %s\n", szFile));
+			e = GF_IO_ERR;
+		} else {
+			if (gf_fwrite(data, data_size, t) != data_size) {
+				M4_LOG(GF_LOG_ERROR, ("Failed to write output to file %s\n", szFile));
+				e = GF_IO_ERR;
+			}
+			gf_fclose(t);
+		}
+	}
+	gf_free(data);
+	return e;
+}
+
+static u64 do_size_top_boxes(char *inName, char *compress_top_boxes, u32 mode)
+{
+	FILE *in;
+	u64 top_size = 0;
+	Bool do_all = GF_FALSE;
+	GF_BitStream *bs_in;
+	if (!compress_top_boxes) return GF_BAD_PARAM;
+	if (!strcmp(compress_top_boxes, "all") || !strcmp(compress_top_boxes, "*") || !strcmp(compress_top_boxes, "@"))
+		do_all = GF_TRUE;
+
+	in = gf_fopen(inName, "rb");
+	if (!in) return GF_URL_ERROR;
+	bs_in = gf_bs_from_file(in, GF_BITSTREAM_READ);
+	while (gf_bs_available(bs_in)) {
+		const char *stype;
+		u32 hdr_size = 8;
+		u64 lsize = gf_bs_read_u32(bs_in);
+		u32 type = gf_bs_read_u32(bs_in);
+
+		if (lsize==1) {
+			lsize = gf_bs_read_u64(bs_in);
+			hdr_size = 16;
+		} else if (lsize==0) {
+			lsize = gf_bs_available(bs_in) + 8;
+		}
+		stype = gf_4cc_to_str(type);
+		if (do_all || strstr(compress_top_boxes, stype)) {
+			//only count boxes
+			if (mode==2) {
+				top_size += 1;
+			} else {
+				top_size += lsize;
+			}
+		}
+		gf_bs_skip_bytes(bs_in, lsize - hdr_size);
+	}
+	gf_bs_del(bs_in);
+	gf_fclose(in);
+	return top_size;
+
+}
+
+static GF_Err do_compress_top_boxes(char *inName, char *outName)
+{
+	FILE *in, *out;
+	u8 *buf;
+	u32 buf_alloc, comp_size;
+	s32 bytes_comp=0;
+	s32 bytes_uncomp=0;
+	GF_Err e = GF_OK;
+	u64 source_size, dst_size;
+	u32 orig_box_overhead;
+	u32 final_box_overhead;
+	u32 nb_added_box_bytes=0;
+	Bool has_mov = GF_FALSE;
+	Bool replace_all = !strcmp(compress_top_boxes, "*");
+	GF_BitStream *bs_in, *bs_out;
+
+	if (!outName) {
+		M4_LOG(GF_LOG_ERROR, ("Missing output file name\n"));
+		return GF_BAD_PARAM;
+	}
+
+	in = gf_fopen(inName, "rb");
+	if (!in) return GF_URL_ERROR;
+	out = gf_fopen(outName, "wb");
+	if (!out) return GF_IO_ERR;
+
+	buf_alloc = 4096;
+	buf = gf_malloc(buf_alloc);
+
+	bs_in = gf_bs_from_file(in, GF_BITSTREAM_READ);
+	source_size = gf_bs_get_size(bs_in);
+
+	bs_out = gf_bs_from_file(out, GF_BITSTREAM_WRITE);
+
+	orig_box_overhead = 0;
+	final_box_overhead = 0;
+	while (gf_bs_available(bs_in)) {
+		u32 size = gf_bs_read_u32(bs_in);
+		u32 type = gf_bs_read_u32(bs_in);
+		const char *b4cc = gf_4cc_to_str(type);
+		const u8 *replace = (const u8 *) strstr(compress_top_boxes, b4cc);
+		if (!strcmp(b4cc, "moov")) has_mov = GF_TRUE;
+
+		if (!replace && !replace_all) {
+			gf_bs_write_u32(bs_out, size);
+			gf_bs_write_u32(bs_out, type);
+
+			size-=8;
+			while (size) {
+				u32 nbytes = size;
+				if (nbytes>buf_alloc) nbytes=buf_alloc;
+				gf_bs_read_data(bs_in, buf, nbytes);
+				gf_bs_write_data(bs_out, buf, nbytes);
+				size-=nbytes;
+			}
+			continue;
+		}
+		orig_box_overhead += size;
+
+		size-=8;
+
+		if (size>buf_alloc) {
+			buf_alloc = size;
+			buf = gf_realloc(buf, buf_alloc);
+		}
+		gf_bs_read_data(bs_in, buf, size);
+
+		replace+=5;
+
+		comp_size = buf_alloc;
+
+		e = gf_gz_compress_payload(&buf, size, &comp_size);
+		if (e) break;
+
+		if (comp_size>buf_alloc) {
+			buf_alloc = comp_size;
+		}
+		bytes_uncomp += size;
+		bytes_comp += comp_size;
+
+		//write size
+		gf_bs_write_u32(bs_out, comp_size+8);
+		//write type
+		gf_bs_write_data(bs_out, replace, 4);
+		//write data
+		gf_bs_write_data(bs_out, buf, comp_size);
+
+		final_box_overhead += 8+comp_size;
+	}
+	dst_size = gf_bs_get_position(bs_out);
+
+	if (buf) gf_free(buf);
+	gf_bs_del(bs_in);
+	gf_bs_del(bs_out);
+	gf_fclose(in);
+	gf_fclose(out);
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("Error compressing: %s\n", gf_error_to_string(e)));
+		return e;
+	}
+
+	if (has_mov) {
+		u32 i, nb_tracks, nb_samples;
+		GF_ISOFile *mov;
+		Double rate, new_rate, duration;
+
+		mov = gf_isom_open(inName, GF_ISOM_OPEN_READ, NULL);
+		duration = (Double) gf_isom_get_duration(mov);
+		duration /= gf_isom_get_timescale(mov);
+
+		nb_samples = 0;
+		nb_tracks = gf_isom_get_track_count(mov);
+		for (i=0; i<nb_tracks; i++) {
+			nb_samples += gf_isom_get_sample_count(mov, i+1);
+		}
+		gf_isom_close(mov);
+
+		rate = (Double) source_size;
+		rate /= duration;
+		rate /= 1000;
+
+		new_rate = (Double) dst_size;
+		new_rate /= duration;
+		new_rate /= 1000;
+
+
+		fprintf(stderr, "Log format:\nname\torig\tcomp\tgain\tadded_bytes\torate\tcrate\tsamples\tduration\tobbps\tcbbps\n");
+		fprintf(stdout, "%s\t%d\t%d\t%g\t%d\t%g\t%g\t%d\t%g\t%g\t%g\n", inName, bytes_uncomp, bytes_comp, ((Double)(bytes_uncomp-bytes_comp)*100)/bytes_uncomp, nb_added_box_bytes, rate, new_rate, nb_samples, duration, ((Double)orig_box_overhead)/nb_samples, ((Double)final_box_overhead)/nb_samples );
+
+		fprintf(stderr, "%s Compressing top-level boxes saved %d bytes out of %d (reduced by %g %%) additional bytes %d original rate %g kbps new rate %g kbps, orig %g box bytes/sample final %g bytes/sample\n", inName, bytes_uncomp-bytes_comp, bytes_uncomp, ((Double)(bytes_uncomp-bytes_comp)*100)/bytes_uncomp, nb_added_box_bytes, rate, new_rate, ((Double)orig_box_overhead)/nb_samples, ((Double)final_box_overhead)/nb_samples );
+
+	} else {
+		fprintf(stderr, "Log format:\nname\torig\tcomp\tgain\tadded_bytes\n");
+		fprintf(stdout, "%s\t%d\t%d\t%g\t%d\n", inName, bytes_uncomp, bytes_comp, ((Double) (bytes_uncomp - bytes_comp)*100)/(bytes_uncomp), nb_added_box_bytes);
+
+		fprintf(stderr, "%s Compressing top-level boxes saved %d bytes out of %d (reduced by %g %%) additional bytes %d\n", inName, bytes_uncomp-bytes_comp, bytes_uncomp, ((Double)(bytes_uncomp-bytes_comp)*100)/bytes_uncomp, nb_added_box_bytes);
+
+	}
+	return GF_OK;
+}
+
+static GF_Err hash_file(char *name, u32 dump_std)
+{
+	u32 i;
+	u8 hash20;
+	GF_Err e = gf_media_get_file_hash(name, hash);
+	if (e) return e;
+	if (dump_std==2) {
+		gf_fwrite(hash, 20, stdout);
+	} else if (dump_std==1) {
+		for (i=0; i<20; i++) fprintf(stdout, "%02X", hashi);
+	}
+	fprintf(stderr, "File hash (SHA-1): ");
+	for (i=0; i<20; i++) fprintf(stderr, "%02X", hashi);
+	fprintf(stderr, "\n");
+
+	return GF_OK;
+}
+
+static u32 do_raw_cat()
+{
+	char chunk4096;
+	int ret=0;
+	FILE *fin, *fout;
+	s64 to_copy, done;
+	fin = gf_fopen(raw_cat, "rb");
+	if (!fin) return mp4box_cleanup(1);
+
+	fout = gf_fopen(inName, "a+b");
+	if (!fout) {
+		gf_fclose(fin);
+		return mp4box_cleanup(1);
+	}
+	gf_fseek(fin, 0, SEEK_END);
+	to_copy = gf_ftell(fin);
+	gf_fseek(fin, 0, SEEK_SET);
+	done = 0;
+	while (1) {
+		u32 nb_bytes = (u32) gf_fread(chunk, 4096, fin);
+		if (gf_fwrite(chunk, nb_bytes, fout) != nb_bytes) {
+			ret = 1;
+			fprintf(stderr, "Error appengin file\n");
+			break;
+		}
+		done += nb_bytes;
+		fprintf(stderr, "Appending file %s - %02.2f done\r", raw_cat, 100.0*done/to_copy);
+		if (done >= to_copy) break;
+	}
+	gf_fclose(fin);
+	gf_fclose(fout);
+	return mp4box_cleanup(ret);
+}
+
+static u32 do_write_udp()
+{
+	GF_Err e;
+	u32 res = 0;
+	GF_Socket *sock = gf_sk_new(GF_SOCK_TYPE_UDP);
+	u16 port = 2345;
+	char *sep = strrchr(udp_dest, ':');
+	if (sep) {
+		sep0 = 0;
+		port = parse_u32(sep+1, "port");
+	}
+	e = gf_sk_bind( sock, NULL, port, udp_dest, port, 0);
+	if (sep) sep0 = ':';
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("Failed to bind socket to %s: %s\n", udp_dest, gf_error_to_string(e) ));
+		res = 1;
+	} else {
+		e = gf_sk_send(sock, (u8 *) inName, (u32)strlen(inName));
+		if (e) {
+			M4_LOG(GF_LOG_ERROR, ("Failed to send datagram: %s\n", gf_error_to_string(e) ));
+			res = 1;
+		}
+	}
+	gf_sk_del(sock);
+	return res;
+}
+
+#ifndef GPAC_DISABLE_MPD
+static u32 convert_mpd()
+{
+	GF_Err e;
+	Bool remote = GF_FALSE;
+	GF_MPD *mpd;
+	char *mpd_base_url = NULL;
+	if (!strnicmp(inName, "http://", 7) || !strnicmp(inName, "https://", 8)) {
+		e = gf_dm_wget(inName, "tmp_main.m3u8", 0, 0, &mpd_base_url);
+		if (e != GF_OK) {
+			M4_LOG(GF_LOG_ERROR, ("Cannot retrieve M3U8 (%s): %s\n", inName, gf_error_to_string(e)));
+			if (mpd_base_url) gf_free(mpd_base_url);
+			return mp4box_cleanup(1);
+		}
+		remote = GF_TRUE;
+
+		if (outName)
+			strcpy(outfile, outName);
+		else {
+			const char *sep = gf_file_basename(inName);
+			char *ext = gf_file_ext_start(sep);
+			if (ext) ext0 = 0;
+			sprintf(outfile, "%s.mpd", sep);
+			if (ext) ext0 = '.';
+		}
+	} else {
+		if (outName)
+			strcpy(outfile, outName);
+		else {
+			char *dst = strdup(inName);
+			char *ext = strstr(dst, ".m3u8");
+			if (ext) ext0 = 0;
+			sprintf(outfile, "%s.mpd", dst);
+			gf_free(dst);
+		}
+	}
+
+	mpd = gf_mpd_new();
+	if (!mpd) {
+		e = GF_OUT_OF_MEM;
+		M4_LOG(GF_LOG_ERROR, ("DASH Error: MPD creation problem %s\n", gf_error_to_string(e)));
+		mp4box_cleanup(1);
+	}
+	FILE *f = gf_fopen(remote ? "tmp_main.m3u8" : inName, "r");
+	u32 manif_type = 0;
+	if (f) {
+		char szDATA1000;
+		s32 read;
+		szDATA999=0;
+		read = (s32) gf_fread(szDATA, 999, f);
+		if (read<0) read = 0;
+		szDATAread=0;
+		gf_fclose(f);
+		if (strstr(szDATA, "SmoothStreamingMedia"))
+			manif_type = 2;
+		else if (strstr(szDATA, "#EXTM3U"))
+			manif_type = 1;
+	}
+
+	if (manif_type==1) {
+		e = gf_m3u8_to_mpd(remote ? "tmp_main.m3u8" : inName, mpd_base_url ? mpd_base_url : inName, outfile, 0, "video/mp2t", GF_TRUE, use_url_template, segment_timeline, NULL, mpd, GF_TRUE, GF_TRUE);
+	} else if (manif_type==2) {
+		e = gf_mpd_smooth_to_mpd(remote ? "tmp_main.m3u8" : inName, mpd, mpd_base_url ? mpd_base_url : inName);
+	} else {
+		e = GF_NOT_SUPPORTED;
+	}
+	if (!e)
+		gf_mpd_write_file(mpd, outfile);
+
+	if (mpd)
+		gf_mpd_del(mpd);
+	if (mpd_base_url)
+		gf_free(mpd_base_url);
+
+	if (remote) {
+		gf_file_delete("tmp_main.m3u8");
+	}
+	if (e != GF_OK) {
+		M4_LOG(GF_LOG_ERROR, ("Error converting %s (%s) to MPD (%s): %s\n", (manif_type==1) ? "HLS" : "Smooth", inName, outfile, gf_error_to_string(e)));
+		return mp4box_cleanup(1);
+	} else {
+		M4_LOG(GF_LOG_INFO, ("Done converting %s (%s) to MPD (%s)\n", (manif_type==1) ? "HLS" : "Smooth", inName, outfile));
+		return mp4box_cleanup(0);
+	}
+}
+#endif
+
+static u32 do_import_sub()
+{
+	/* We import the subtitle file,
+	 i.e. we parse it and store the content as samples of a 3GPP Timed Text track in an ISO file,
+	 possibly for later export (e.g. when converting SRT to TTXT, ...) */
+#ifndef GPAC_DISABLE_MEDIA_IMPORT
+	GF_Err e;
+	GF_MediaImporter import;
+	/* Prepare the importer */
+	file = gf_isom_open("ttxt_convert", GF_ISOM_OPEN_WRITE, NULL);
+	if (timescale && file) gf_isom_set_timescale(file, timescale);
+
+	memset(&import, 0, sizeof(GF_MediaImporter));
+	import.dest = file;
+	import.in_name = inName;
+	/* Start the import */
+	e = gf_media_import(&import);
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("Error importing %s: %s\n", inName, gf_error_to_string(e)));
+		gf_isom_delete(file);
+		gf_file_delete("ttxt_convert");
+		return mp4box_cleanup(1);
+	}
+	/* Prepare the export */
+	strcpy(outfile, inName);
+	if (strchr(outfile, '.')) {
+		while (outfilestrlen(outfile)-1 != '.') outfilestrlen(outfile)-1 = 0;
+		outfilestrlen(outfile)-1 = 0;
+	}
+#ifndef GPAC_DISABLE_ISOM_DUMP
+	/* Start the export of the track #1, in the appropriate dump type, indicating it's a conversion */
+	dump_isom_timed_text(file, gf_isom_get_track_id(file, 1),
+						 dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE,
+						 GF_TRUE,
+						 (import_subtitle==2) ? GF_TEXTDUMPTYPE_SVG : (dump_srt ? GF_TEXTDUMPTYPE_SRT : GF_TEXTDUMPTYPE_TTXT));
+#endif
+	/* Clean the importer */
+	gf_isom_delete(file);
+	gf_file_delete("ttxt_convert");
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("Error converting %s: %s\n", inName, gf_error_to_string(e)));
+		return mp4box_cleanup(1);
+	}
+	return mp4box_cleanup(0);
+#else
+	M4_LOG(GF_LOG_ERROR, ("Feature not supported\n"));
+	return mp4box_cleanup(1);
+#endif
+}
+
+#if !defined(GPAC_DISABLE_MEDIA_IMPORT) && !defined(GPAC_DISABLE_ISOM_WRITE)
+static u32 do_add_cat(int argc, char **argv)
+{
+	GF_Err e;
+	u32 i, ipass, nb_pass = 1;
+	char *mux_args=NULL;
+	char *mux_sid=NULL;
+	GF_FilterSession *fs = NULL;
+	if (nb_add) {
+
+		GF_ISOOpenMode open_mode = GF_ISOM_OPEN_EDIT;
+		if (force_new) {
+			open_mode = (do_flat || (force_new==2)) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
+		} else {
+			FILE *test = gf_fopen(inName, "rb");
+			if (!test) {
+				open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
+				if (!outName) outName = inName;
+			} else {
+				gf_fclose(test);
+				if (! gf_isom_probe_file(inName) ) {
+					open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
+					if (!outName) outName = inName;
+				}
+			}
+		}
+		open_edit = do_flat ? GF_FALSE : GF_TRUE;
+		file = gf_isom_open(inName, open_mode, NULL);
+		if (!file) {
+			M4_LOG(GF_LOG_ERROR, ("Cannot open destination file %s: %s\n", inName, gf_error_to_string(gf_isom_last_error(NULL)) ));
+			return mp4box_cleanup(1);
+		}
+
+		if (freeze_box_order)
+			gf_isom_freeze_order(file);
+
+		if (do_flat) {
+			if (major_brand)
+				gf_isom_set_brand_info(file, major_brand, minor_version);
+			for (i=0; i<nb_alt_brand_add; i++) {
+				gf_isom_modify_alternate_brand(file, brand_addi, GF_TRUE);
+				do_save = GF_TRUE;
+			}
+
+			if (!major_brand && !nb_alt_brand_add && has_add_image) {
+				gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_MIF1, GF_TRUE);
+			}
+		}
+	}
+
+	if (file && keep_utc && open_edit) {
+		gf_isom_keep_utc_times(file, 1);
+	}
+
+	if (do_flat && interleaving_time) {
+		char szSubArg100;
+		gf_isom_set_storage_mode(file, GF_ISOM_STORE_FASTSTART);
+		do_flat = 2;
+		nb_pass = 2;
+		fs = gf_fs_new_defaults(0);
+		if (!fs) {
+			M4_LOG(GF_LOG_ERROR, ("Error creating filter session\n"));
+			gf_isom_delete(file);
+			return mp4box_cleanup(1);
+		}
+
+		//mux args
+		gf_dynstrcat(&mux_args, "mp4mx:importer:store=fstart", ":");
+
+		sprintf(szSubArg, "file=%p", file);
+		gf_dynstrcat(&mux_args, szSubArg, ":");
+		sprintf(szSubArg, "cdur=%g", interleaving_time);
+		gf_dynstrcat(&mux_args, szSubArg, ":");
+	}
+
+	for (ipass=0; ipass<nb_pass; ipass++) {
+		u32 tk_idx = 1;
+		for (i=0; i<(u32) argc; i++) {
+			char *margs=NULL;
+			char *msid = NULL;
+			if (!strcmp(argvi, "-add")) {
+				char *src = argvi+1;
+
+				while (src) {
+					char *loc_src = src;
+					char *sep = NULL;
+					while (1) {
+						char *opt_sep;
+						sep = strchr(loc_src, '+');
+						if (!sep) break;
+
+						sep0 = 0;
+						if (strstr(src, "://"))
+							break;
+
+						opt_sep = gf_url_colon_suffix(src, '=');
+						if (opt_sep)
+							opt_sep0 = 0;
+						if (gf_file_exists(src)) {
+							if (opt_sep)
+								opt_sep0 = ':';
+							break;
+						}
+						if (opt_sep)
+							opt_sep0 = ':';
+
+						sep0 = '+';
+						loc_src = sep+1;
+					}
+					if (fs && (ipass==0)) {
+						e = import_file(file, src, import_flags, import_fps, agg_samples, fs, &margs, &msid, tk_idx);
+					} else {
+						e = import_file(file, src, import_flags, import_fps, agg_samples, fs, NULL, NULL, tk_idx);
+					}
+					tk_idx++;
+
+					if (margs) {
+						gf_dynstrcat(&mux_args, margs, ":");
+						gf_free(margs);
+					}
+					if (msid) {
+						gf_dynstrcat(&mux_sid, msid, ",");
+						gf_free(msid);
+					}
+
+					if (e) {
+						M4_LOG(GF_LOG_ERROR, ("Error importing %s: %s\n", argvi+1, gf_error_to_string(e)));
+						gf_isom_delete(file);
+						if (fs)
+							gf_fs_del(fs);
+						return mp4box_cleanup(1);
+					}
+					if (sep) {
+						sep0 = '+';
+						src = sep+1;
+					} else {
+						break;
+					}
+				}
+				i++;
+			} else if (!strcmp(argvi, "-cat") || !strcmp(argvi, "-catx") || !strcmp(argvi, "-catpl")) {
+				if (nb_pass == 2) {
+					M4_LOG(GF_LOG_ERROR, ("Cannot cat files when using -newfs mode\n"));
+					return mp4box_cleanup(1);
+				}
+				if (!file) {
+					u8 open_mode = GF_ISOM_OPEN_EDIT;
+					if (force_new) {
+						open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
+					} else {
+						FILE *test = gf_fopen(inName, "rb");
+						if (!test) {
+							open_mode = (do_flat) ? GF_ISOM_OPEN_WRITE : GF_ISOM_WRITE_EDIT;
+							if (!outName) outName = inName;
+						}
+						else gf_fclose(test);
+					}
+
+					open_edit = GF_TRUE;
+					file = gf_isom_open(inName, open_mode, NULL);
+					if (!file) {
+						M4_LOG(GF_LOG_ERROR, ("Cannot open destination file %s: %s\n", inName, gf_error_to_string(gf_isom_last_error(NULL)) ));
+						return mp4box_cleanup(1);
+					}
+				}
+
+				e = cat_isomedia_file(file, argvi+1, import_flags, import_fps, agg_samples, force_cat, align_cat, !strcmp(argvi, "-catx") ? GF_TRUE : GF_FALSE, !strcmp(argvi, "-catpl") ? GF_TRUE : GF_FALSE);
+				if (e) {
+					M4_LOG(GF_LOG_ERROR, ("Error appending %s: %s\n", argvi+1, gf_error_to_string(e)));
+					gf_isom_delete(file);
+					return mp4box_cleanup(1);
+				}
+				i++;
+			}
+		}
+		if ((nb_pass == 2) && !ipass) {
+			if (mux_sid) {
+				gf_dynstrcat(&mux_args, "SID=", ":");
+				gf_dynstrcat(&mux_args, mux_sid, NULL);
+			}
+			GF_Filter *mux_filter = gf_fs_load_filter(fs, mux_args, NULL);
+			gf_free(mux_args);
+			if (!mux_filter) {
+				M4_LOG(GF_LOG_ERROR, ("Error loadin isobmff mux filter\n"));
+				gf_isom_delete(file);
+				gf_fs_del(fs);
+				return mp4box_cleanup(1);
+			}
+
+			e = gf_fs_run(fs);
+			if (e==GF_EOS) e = GF_OK;
+
+			if (!e) e = gf_fs_get_last_connect_error(fs);
+			if (!e) e = gf_fs_get_last_process_error(fs);
+
+			if (e) {
+				M4_LOG(GF_LOG_ERROR, ("Error importing sources: %s\n", gf_error_to_string(e)));
+				gf_isom_delete(file);
+				gf_fs_del(fs);
+				return mp4box_cleanup(1);
+			}
+		}
+	}
+	if (fs) {
+		gf_fs_print_non_connected(fs);
+		if (fs_dump_flags & 1) gf_fs_print_stats(fs);
+		if (fs_dump_flags & 2) gf_fs_print_connections(fs);
+		gf_fs_del(fs);
+	}
+
+	/*unless explicitly asked, remove all systems tracks*/
+#ifndef GPAC_DISABLE_AV_PARSERS
+	if (!keep_sys_tracks) remove_systems_tracks(file);
+#endif
+	do_save = GF_TRUE;
+
+	return 0;
+}
+#endif /*!GPAC_DISABLE_MEDIA_IMPORT && !GPAC_DISABLE_ISOM_WRITE*/
+
+
+#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+static GF_Err do_scene_encode()
+{
+	GF_Err e;
+	FILE *logs = NULL;
+	if (do_scene_log) {
+		char alogfileGF_MAX_PATH;
+		strcpy(alogfile, inName);
+		if (strchr(alogfile, '.')) {
+			while (alogfilestrlen(alogfile)-1 != '.') alogfilestrlen(alogfile)-1 = 0;
+			alogfilestrlen(alogfile)-1 = 0;
+		}
+		strcat(alogfile, "_enc.logs");
+		logs = gf_fopen(alogfile, "wt");
+	}
+	strcpy(outfile, outName ? outName : inName);
+	if (strchr(outfile, '.')) {
+		while (outfilestrlen(outfile)-1 != '.') outfilestrlen(outfile)-1 = 0;
+		outfilestrlen(outfile)-1 = 0;
+	}
+	strcat(outfile, ".mp4");
+	file = gf_isom_open(outfile, GF_ISOM_WRITE_EDIT, NULL);
+	smenc_opts.mediaSource = mediaSource ? mediaSource : outfile;
+	e = EncodeFile(inName, file, &smenc_opts, logs);
+	if (logs) gf_fclose(logs);
+	if (e) return e;
+	do_save = GF_TRUE;
+	if (do_saf) {
+		do_save = GF_FALSE;
+		open_edit = GF_FALSE;
+	}
+	return GF_OK;
+}
+#endif //!defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+
+
+static GF_Err do_dash()
+{
+	GF_Err e;
+	u32 i;
+	Bool del_file = GF_FALSE;
+	char szMPDGF_MAX_PATH, *sep;
+	char szStateFileGF_MAX_PATH;
+	Bool dyn_state_file = GF_FALSE;
+	u32 do_abort = 0;
+	GF_DASHSegmenter *dasher=NULL;
+
+	if (crypt) {
+		M4_LOG(GF_LOG_ERROR, ("MP4Box cannot use -crypt and -dash in the same pass. Please encrypt your content first, or specify encryption filters on dash sources.\n"));
+		return GF_BAD_PARAM;
+	}
+
+	strcpy(outfile, outName ? outName : gf_url_get_resource_name(inName) );
+	sep = strrchr(outfile, '.');
+	if (sep) sep0 = 0;
+	if (!outName) strcat(outfile, "_dash");
+	strcpy(szMPD, outfile);
+	if (outName && sep) {
+		sep0 = '.';
+		strcat(szMPD, sep);
+	} else {
+		strcat(szMPD, ".mpd");
+	}
+
+	if ((dash_subduration>0) && (dash_duration > dash_subduration)) {
+		M4_LOG(GF_LOG_WARNING, ("Warning: -subdur parameter (%g s) should be greater than segment duration (%g s), using segment duration instead\n", dash_subduration, dash_duration));
+		dash_subduration = dash_duration;
+	}
+
+	if (dash_mode && dash_live)
+		M4_LOG(GF_LOG_INFO, ("Live DASH-ing - press 'q' to quit, 's' to save context and quit\n"));
+
+	if (!dash_ctx_file && dash_live) {
+		u32 r1;
+		u64 add = (u64) (intptr_t) &dasher;
+		add ^= gf_net_get_utc();
+		r1 = (u32) add ^ (u32) (add/0xFFFFFFFF);
+		r1 ^= gf_rand();
+		sprintf(szStateFile, "%s/dasher_%X.xml", gf_get_default_cache_directory(), r1 );
+		dash_ctx_file = szStateFile;
+		dyn_state_file = GF_TRUE;
+	} else if (dash_ctx_file) {
+		if (force_new)
+			gf_file_delete(dash_ctx_file);
+	}
+
+	if (dash_profile==GF_DASH_PROFILE_AUTO)
+		dash_profile = dash_mode ? GF_DASH_PROFILE_LIVE : GF_DASH_PROFILE_FULL;
+
+	if (!dash_mode) {
+		time_shift_depth = 0;
+		mpd_update_time = 0;
+	} else if ((dash_profile>=GF_DASH_PROFILE_MAIN) && !use_url_template && !mpd_update_time) {
+		/*use a default MPD update of dash_duration sec*/
+		mpd_update_time = (Double) (dash_subduration ? dash_subduration : dash_duration);
+		M4_LOG(GF_LOG_INFO, ("Using default MPD refresh of %g seconds\n", mpd_update_time));
+	}
+
+	if (file && do_save) {
+		gf_isom_close(file);
+		file = NULL;
+		del_file = GF_TRUE;
+	}
+
+	/*setup dash*/
+	dasher = gf_dasher_new(szMPD, dash_profile, NULL, dash_scale, dash_ctx_file);
+	if (!dasher) {
+		return mp4box_cleanup(1);
+	}
+	e = gf_dasher_set_info(dasher, dash_title, cprt, dash_more_info, dash_source, NULL);
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("DASH Error: %s\n", gf_error_to_string(e)));
+		gf_dasher_del(dasher);
+		return e;
+	}
+
+	gf_dasher_set_start_date(dasher, dash_start_date);
+	gf_dasher_set_location(dasher, dash_source);
+	for (i=0; i < nb_mpd_base_urls; i++) {
+		e = gf_dasher_add_base_url(dasher, mpd_base_urlsi);
+		if (e) {
+			M4_LOG(GF_LOG_ERROR, ("DASH Error: %s\n", gf_error_to_string(e)));
+			gf_dasher_del(dasher);
+			return e;
+		}
+	}
+
+	if (segment_timeline && !use_url_template) {
+		M4_LOG(GF_LOG_WARNING, ("DASH Warning: using -segment-timeline with no -url-template. Forcing URL template.\n"));
+		use_url_template = GF_TRUE;
+	}
+
+	e = gf_dasher_enable_url_template(dasher, (Bool) use_url_template, seg_name, seg_ext, init_seg_ext);
+	if (!e) e = gf_dasher_enable_segment_timeline(dasher, segment_timeline);
+	if (!e) e = gf_dasher_enable_single_segment(dasher, single_segment);
+	if (!e) e = gf_dasher_enable_single_file(dasher, single_file);
+	if (!e) e = gf_dasher_set_switch_mode(dasher, bitstream_switching_mode);
+	if (!e) e = gf_dasher_set_durations(dasher, dash_duration, interleaving_time, dash_subduration);
+	if (!e) e = gf_dasher_enable_rap_splitting(dasher, seg_at_rap, frag_at_rap);
+	if (!e) e = gf_dasher_set_segment_marker(dasher, segment_marker);
+	if (!e) e = gf_dasher_enable_sidx(dasher, (subsegs_per_sidx>=0) ? 1 : 0, (u32) subsegs_per_sidx, daisy_chain_sidx, use_ssix);
+	if (!e) e = gf_dasher_set_dynamic_mode(dasher, dash_mode, mpd_update_time, time_shift_depth, mpd_live_duration);
+	if (!e) e = gf_dasher_set_min_buffer(dasher, min_buffer);
+	if (!e) e = gf_dasher_set_ast_offset(dasher, ast_offset_ms);
+	if (!e) e = gf_dasher_enable_memory_fragmenting(dasher, memory_frags);
+	if (!e) e = gf_dasher_set_initial_isobmf(dasher, initial_moof_sn, initial_tfdt);
+	if (!e) e = gf_dasher_configure_isobmf_default(dasher, no_fragments_defaults, pssh_mode, samplegroups_in_traf, single_traf_per_moof, tfdt_per_traf, mvex_after_traks, sdtp_in_traf);
+	if (!e) e = gf_dasher_enable_utc_ref(dasher, insert_utc);
+	if (!e) e = gf_dasher_enable_real_time(dasher, frag_real_time);
+	if (!e) e = gf_dasher_set_content_protection_location_mode(dasher, cp_location_mode);
+	if (!e) e = gf_dasher_set_profile_extension(dasher, dash_profile_extension);
+	if (!e) e = gf_dasher_enable_cached_inputs(dasher, no_cache);
+	if (!e) e = gf_dasher_enable_loop_inputs(dasher, ! no_loop);
+	if (!e) e = gf_dasher_set_split_mode(dasher, dash_split_mode);
+	if (!e) e = gf_dasher_set_last_segment_merge(dasher, merge_last_seg);
+	if (!e) e = gf_dasher_set_hls_clock(dasher, hls_clock);
+	if (!e && dash_cues) e = gf_dasher_set_cues(dasher, dash_cues, strict_cues);
+	if (!e) e = gf_dasher_print_session_info(dasher, fs_dump_flags);
+	if (!e) e = gf_dasher_keep_source_utc(dasher, keep_utc);
+
+	for (i=0; i < nb_dash_inputs; i++) {
+		if (!e) e = gf_dasher_add_input(dasher, &dash_inputsi);
+	}
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("DASH Setup Error: %s\n", gf_error_to_string(e)));
+		gf_dasher_del(dasher);
+		return e;
+	}
+
+	dash_cumulated_time=0;
+
+	while (1) {
+		if (run_for && (dash_cumulated_time >= run_for)) {
+			M4_LOG(GF_LOG_INFO, ("Done running, computing static MPD\n"));
+			do_abort = 3;
+		}
+
+		dash_prev_time=gf_sys_clock();
+		if (do_abort>=2) {
+			e = gf_dasher_set_dynamic_mode(dasher, GF_DASH_DYNAMIC_LAST, 0, time_shift_depth, mpd_live_duration);
+		}
+
+		if (!e) e = gf_dasher_process(dasher);
+		if (!dash_live && (e==GF_EOS) ) {
+			M4_LOG(GF_LOG_INFO, ("Nothing to dash, too early ...\n"));
+			e = GF_OK;
+		}
+
+		if (do_abort)
+			break;
+
+		//this happens when reading file while writing them (local playback of the live session ...)
+		if (dash_live && (e==GF_IO_ERR) ) {
+			M4_LOG(GF_LOG_WARNING, ("Error dashing file (%s) but continuing ...\n", gf_error_to_string(e) ));
+			e = GF_OK;
+		}
+
+		if (e) break;
+
+		if (dash_live) {
+			u64 ms_in_session=0;
+			u32 slept = gf_sys_clock();
+			u32 sleep_for = gf_dasher_next_update_time(dasher, &ms_in_session);
+			M4_LOG(GF_LOG_INFO, ("Next generation scheduled in %u ms (DASH time "LLU" ms)\r", sleep_for, ms_in_session));
+			if (run_for && (ms_in_session>=run_for)) {
+				dash_cumulated_time = 1+run_for;
+				continue;
+			}
+
+			while (1) {
+				if (gf_prompt_has_input()) {
+					char c = (char) gf_prompt_get_char();
+					if (c=='X') {
+						do_abort = 1;
+						break;
+					}
+					if (c=='q') {
+						do_abort = 2;
+						break;
+					}
+					if (c=='s') {
+						do_abort = 3;
+						break;
+					}
+				}
+
+				if (dash_mode == GF_DASH_DYNAMIC_DEBUG) {
+					break;
+				}
+				if (!sleep_for) break;
+
+				gf_sleep(sleep_for/10);
+				sleep_for = gf_dasher_next_update_time(dasher, NULL);
+				if (sleep_for<=1) {
+					dash_now_time=gf_sys_clock();
+					dash_cumulated_time+=(dash_now_time-dash_prev_time);
+					M4_LOG(GF_LOG_INFO, ("Slept for %d ms before generation, dash cumulated time %d\n", dash_now_time - slept, dash_cumulated_time));
+					break;
+				}
+			}
+		} else {
+			break;
+		}
+	}
+
+	gf_dasher_del(dasher);
+
+	if (!run_for && dash_ctx_file && (do_abort==3) && (dyn_state_file) && !gf_sys_is_test_mode() ) {
+		char szName1024;
+		M4_LOG(GF_LOG_INFO, ("Enter file name to save dash context:\n"));
+		if (scanf("%1023s", szName) == 1) {
+			gf_file_move(dash_ctx_file, szName);
+		}
+	}
+	if (e) M4_LOG(GF_LOG_ERROR, ("Error DASHing file: %s\n", gf_error_to_string(e)));
+	if (file) gf_isom_delete(file);
+	if (del_file)
+		gf_file_delete(inName);
+
+	return e;
+}
+
+static GF_Err do_export_tracks_non_isobmf()
+{
+	u32 i;
+
+	GF_MediaExporter mdump;
+	char szFileGF_MAX_PATH+24;
+	for (i=0; i<nb_track_act; i++) {
+		GF_Err e;
+		TrackAction *tka = &tracksi;
+		if (tka->act_type != TRACK_ACTION_RAW_EXTRACT) continue;
+		memset(&mdump, 0, sizeof(mdump));
+		mdump.in_name = inName;
+		mdump.flags = tka->dump_type;
+		mdump.trackID = tka->target_track.ID_or_num;
+		if (tka->target_track.type>1)
+			mdump.track_type = tka->target_track.type-1;
+		mdump.sample_num = tka->sample_num;
+
+		if (dump_std) {
+			mdump.out_name = "std";
+		}
+		else if (outName) {
+			mdump.out_name = outName;
+			mdump.flags |= GF_EXPORT_MERGE;
+		} else if (nb_track_act>1) {
+			sprintf(szFile, "%s_track%d", outfile, mdump.trackID);
+			mdump.out_name = szFile;
+		} else {
+			mdump.out_name = outfile;
+		}
+		mdump.print_stats_graph = fs_dump_flags;
+		e = gf_media_export(&mdump);
+		if (e) return e;
+	}
+	return GF_OK;
+}
+
+
+static GF_Err do_dump_iod()
+{
+	GF_Err e = GF_OK;
+	GF_InitialObjectDescriptor *iod = (GF_InitialObjectDescriptor *)gf_isom_get_root_od(file);
+	if (!iod) {
+		M4_LOG(GF_LOG_WARNING, ("File %s has no IOD\n", inName));
+	} else {
+		char szNameGF_MAX_PATH+10;
+		FILE *iodf;
+		sprintf(szName, "%s.iod", outfile);
+		iodf = gf_fopen(szName, "wb");
+		if (!iodf) {
+			M4_LOG(GF_LOG_ERROR, ("Cannot open destination %s\n", szName));
+			e = GF_IO_ERR;
+		} else {
+			u8 *desc;
+			u32 size;
+			GF_BitStream *bs = gf_bs_from_file(iodf, GF_BITSTREAM_WRITE);
+			e = gf_odf_desc_write((GF_Descriptor *)iod, &desc, &size);
+			if (e==GF_OK) {
+				if (gf_fwrite(desc, size, iodf)!=size) e = GF_IO_ERR;
+				gf_free(desc);
+			} else {
+				e = GF_IO_ERR;
+			}
+			if (e) {
+				M4_LOG(GF_LOG_ERROR, ("Error writing IOD %s\n", szName));
+			}
+			gf_bs_del(bs);
+			gf_fclose(iodf);
+		}
+		gf_odf_desc_del((GF_Descriptor*)iod);
+	}
+	return e;
+}
+
+static u32 get_track_id(GF_ISOFile *file, TrackIdentifier *tkid)
+{
+	u32 cur_tk=0, i, count = gf_isom_get_track_count(file);
+	if (tkid->type==1) {
+		if (!tkid->ID_or_num || (count < tkid->ID_or_num)) return 0;
+		return gf_isom_get_track_id(file, tkid->ID_or_num);
+	}
+	if (tkid->type==0) {
+		return tkid->ID_or_num;
+	}
+	for (i=0; i<count; i++) {
+		u32 mtype = gf_isom_get_media_type(file, i+1);
+		if (tkid->type==2) {
+			if (!gf_isom_is_video_handler_type(mtype)) continue;
+		}
+		else if (tkid->type==3) {
+			if (mtype != GF_ISOM_MEDIA_AUDIO) continue;
+		} else if (tkid->type==4) {
+			if ((mtype != GF_ISOM_MEDIA_TEXT) && (mtype != GF_ISOM_MEDIA_SUBT)) continue;
+		} else {
+			continue;
+		}
+		cur_tk++;
+		if (tkid->ID_or_num && (cur_tk != tkid->ID_or_num)) continue;
+		return gf_isom_get_track_id(file, i+1);
+	}
+	return 0;
+}
+
+static GF_Err do_export_tracks()
+{
+	GF_Err e;
+	u32 i;
+	char szFileGF_MAX_PATH+24;
+	GF_MediaExporter mdump;
+	for (i=0; i<nb_track_act; i++) {
+		u32 j;
+		TrackAction *tka = &tracksi;
+		if (tka->act_type != TRACK_ACTION_RAW_EXTRACT) continue;
+		memset(&mdump, 0, sizeof(mdump));
+		mdump.file = file;
+		mdump.flags = tka->dump_type;
+		mdump.sample_num = tka->sample_num;
+		//this can be 0
+		mdump.trackID = get_track_id(file, &tka->target_track);
+
+		if (tka->out_name) {
+			mdump.out_name = tka->out_name;
+		} else if (outName) {
+			mdump.out_name = outName;
+			mdump.flags |= GF_EXPORT_MERGE;
+			/*don't infer extension on user-given filename*/
+			mdump.flags |= GF_EXPORT_NO_FILE_EXT;
+		} else if (mdump.trackID) {
+			sprintf(szFile, "%s_track%d", outfile, mdump.trackID);
+			mdump.out_name = szFile;
+		} else {
+			sprintf(szFile, "%s_export", outfile);
+			mdump.out_name = szFile;
+		}
+		if (tka->target_track.ID_or_num==(u32) -1) {
+			for (j=0; j<gf_isom_get_track_count(file); j++) {
+				mdump.trackID = gf_isom_get_track_id(file, j+1);
+				sprintf(szFile, "%s_track%d", outfile, mdump.trackID);
+				mdump.out_name = szFile;
+				mdump.print_stats_graph = fs_dump_flags;
+				e = gf_media_export(&mdump);
+				if (e) return e;
+			}
+		} else {
+			mdump.print_stats_graph = fs_dump_flags;
+			e = gf_media_export(&mdump);
+			if (e) return e;
+		}
+	}
+	return GF_OK;
+}
+
+static GF_Err do_meta_act()
+{
+	u32 i;
+	for (i=0; i<nb_meta_act; i++) {
+		GF_Err e = GF_OK;
+		u32 tk = 0;
+#ifndef GPAC_DISABLE_ISOM_WRITE
+		Bool self_ref;
+#endif
+		MetaAction *meta = &metasi;
+		u32 tk_id = get_track_id(file, &meta->track_id);
+
+		if (tk_id) tk = gf_isom_get_track_by_id(file, tk_id);
+
+		switch (meta->act_type) {
+#ifndef GPAC_DISABLE_ISOM_WRITE
+		case META_ACTION_SET_TYPE:
+			/*note: we don't handle file brand modification, this is an author stuff and cannot be guessed from meta type*/
+			e = gf_isom_set_meta_type(file, meta->root_meta, tk, meta->meta_4cc);
+			gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_ISO2, GF_TRUE);
+			do_save = GF_TRUE;
+			break;
+		case META_ACTION_ADD_ITEM:
+
+			if (meta->replace) {
+				if (!gf_isom_get_meta_item_by_id(file, meta->root_meta, tk, meta->item_id)) {
+					M4_LOG(GF_LOG_WARNING, ("No item with ID %d, ignoring replace\n", meta->item_id));
+					meta->item_id = 0;
+				} else {
+					e = gf_isom_remove_meta_item(file, meta->root_meta, tk, meta->item_id, GF_TRUE, meta->keep_props);
+					if (e) break;
+				}
+			}
+
+			self_ref = !stricmp(meta->szPath, "NULL") || !stricmp(meta->szPath, "this") || !stricmp(meta->szPath, "self");
+			e = gf_isom_add_meta_item(file, meta->root_meta, tk, self_ref, self_ref ? NULL : meta->szPath,
+			 meta->szName,
+			 meta->item_id,
+									 meta->item_type,
+			 meta->mime_type,
+			 meta->enc_type,
+			 meta->use_dref ? meta->szPath : NULL, NULL,
+			 meta->image_props);
+			if (meta->item_refs && gf_list_count(meta->item_refs)) {
+				u32 ref_i;
+				for (ref_i = 0; ref_i < gf_list_count(meta->item_refs); ref_i++) {
+					MetaRef	*ref_entry = gf_list_get(meta->item_refs, ref_i);
+					e = gf_isom_meta_add_item_ref(file, meta->root_meta, tk, meta->item_id, ref_entry->ref_item_id, ref_entry->ref_type, NULL);
+				}
+			}
+			do_save = GF_TRUE;
+			break;
+		case META_ACTION_ADD_IMAGE_ITEM:
+		{
+			u32 old_tk_count = gf_isom_get_track_count(file);
+			u32 src_tk_id = 1;
+			GF_Fraction _frac = {0,0};
+			GF_ISOFile *fsrc = file;
+			self_ref = GF_FALSE;
+
+			tk = 0;
+			if (meta->image_props && meta->image_props->auto_grid) {
+				e = GF_OK;
+				self_ref = GF_TRUE;
+			} else if (!meta->szPath || (meta->image_props && meta->image_props->sample_num && meta->image_props->use_reference)) {
+				e = GF_OK;
+				self_ref = GF_TRUE;
+				src_tk_id = tk_id;
+			} else if (meta->szPath) {
+				if (meta->image_props && gf_isom_probe_file(meta->szPath) && !meta->image_props->tile_mode) {
+					meta->image_props->src_file = gf_isom_open(meta->szPath, GF_ISOM_OPEN_READ, NULL);
+					e = gf_isom_last_error(meta->image_props->src_file);
+					fsrc = meta->image_props->src_file;
+					if (meta->image_props->item_ref_id)
+						src_tk_id = 0;
+				} else {
+					gf_isom_disable_brand_rewrite(file, GF_TRUE);
+					e = import_file(file, meta->szPath, 0, _frac, 0, NULL, NULL, NULL, 0);
+					gf_isom_disable_brand_rewrite(file, GF_FALSE);
+				}
+			} else {
+				M4_LOG(GF_LOG_ERROR, ("Missing file name to import\n"));
+				e = GF_BAD_PARAM;
+			}
+			if (e == GF_OK) {
+				u32 meta_type = gf_isom_get_meta_type(file, meta->root_meta, tk);
+				if (!meta_type) {
+					e = gf_isom_set_meta_type(file, meta->root_meta, tk, GF_META_ITEM_TYPE_PICT);
+				} else {
+					if (meta_type != GF_META_ITEM_TYPE_PICT) {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("Warning: file already has a root 'meta' box of type %s\n", gf_4cc_to_str(meta_type)));
+						e = GF_BAD_PARAM;
+					}
+				}
+				if (e == GF_OK) {
+					if (!meta->item_id) {
+						e = gf_isom_meta_get_next_item_id(file, meta->root_meta, tk, &meta->item_id);
+					}
+					if (e == GF_OK) {
+						if (!src_tk_id && (!meta->image_props || !meta->image_props->item_ref_id) ) {
+							u32 j;
+							for (j=0; j<gf_isom_get_track_count(fsrc); j++) {
+								if (gf_isom_is_video_handler_type (gf_isom_get_media_type(fsrc, j+1))) {
+									src_tk_id = gf_isom_get_track_id(fsrc, j+1);
+									break;
+								}
+							}
+
+							if (!src_tk_id) {
+								M4_LOG(GF_LOG_ERROR, ("No video track in file, cannot add image from track\n"));
+								e = GF_BAD_PARAM;
+							}
+						}
+
+						if (e == GF_OK && meta->replace) {
+							if (!gf_isom_get_meta_item_by_id(file, meta->root_meta, tk, meta->item_id)) {
+								M4_LOG(GF_LOG_WARNING, ("No item with ID %d, ignoring replace\n", meta->item_id));
+								meta->item_id = 0;
+							} else {
+								e = gf_isom_remove_meta_item(file, meta->root_meta, tk, meta->item_id, GF_TRUE, meta->keep_props);
+							}
+						}
+						if (e==GF_OK)
+							e = gf_isom_iff_create_image_item_from_track(file, meta->root_meta, tk, src_tk_id, meta->szName, meta->item_id, meta->image_props, NULL);
+
+						if (e == GF_OK && meta->primary) {
+							e = gf_isom_set_meta_primary_item(file, meta->root_meta, tk, meta->item_id);
+						}
+						if (e == GF_OK && meta->item_refs && gf_list_count(meta->item_refs)) {
+							u32 ref_i;
+							for (ref_i = 0; ref_i < gf_list_count(meta->item_refs); ref_i++) {
+								MetaRef	*ref_entry = gf_list_get(meta->item_refs, ref_i);
+								e = gf_isom_meta_add_item_ref(file, meta->root_meta, tk, meta->item_id, ref_entry->ref_item_id, ref_entry->ref_type, NULL);
+							}
+						}
+						if (e == GF_OK && meta->group_type) {
+							e = gf_isom_meta_add_item_group(file, meta->root_meta, tk, meta->item_id, meta->group_id, meta->group_type);
+						}
+					}
+				}
+			}
+			if (meta->image_props && meta->image_props->src_file) {
+				gf_isom_delete(meta->image_props->src_file);
+				meta->image_props->src_file = NULL;
+			} else if (!self_ref) {
+				gf_isom_remove_track(file, old_tk_count+1);
+				if (do_flat) {
+					M4_LOG(GF_LOG_ERROR, ("Warning: -flat storage cannot be used when using -add-image on external file\n"));
+					e = GF_NOT_SUPPORTED;
+				}
+			}
+			do_save = GF_TRUE;
+		}
+			break;
+		case META_ACTION_ADD_IMAGE_DERIVED:
+		{
+			u32 meta_type = gf_isom_get_meta_type(file, meta->root_meta, tk);
+			e = GF_OK;
+			if (!meta_type) {
+				e = gf_isom_set_meta_type(file, meta->root_meta, tk, GF_META_ITEM_TYPE_PICT);
+			} else {
+				if (meta_type != GF_META_ITEM_TYPE_PICT) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("Warning: file already has a root 'meta' box of type %s\n", gf_4cc_to_str(meta_type)));
+					e = GF_BAD_PARAM;
+				}
+			}
+			if (e) break;
+			if (!meta->item_id) {
+				e = gf_isom_meta_get_next_item_id(file, meta->root_meta, tk, &meta->item_id);
+			}
+			if (e == GF_OK && meta->item_type) {
+				if (meta->item_type == GF_4CC('g','r','i','d')) {
+					e = gf_isom_iff_create_image_grid_item(file, meta->root_meta, tk,
+							meta->szName && strlen(meta->szName) ? meta->szName : NULL,
+							meta->item_id,
+							meta->image_props);
+				} else if (meta->item_type == GF_4CC('i','o','v','l')) {
+					e = gf_isom_iff_create_image_overlay_item(file, meta->root_meta, tk,
+							meta->szName && strlen(meta->szName) ? meta->szName : NULL,
+							meta->item_id,
+							meta->image_props);
+				} else if (meta->item_type == GF_4CC('i','d','e','n')) {
+					e = gf_isom_iff_create_image_identity_item(file, meta->root_meta, tk,
+							meta->szName && strlen(meta->szName) ? meta->szName : NULL,
+							meta->item_id,
+							meta->image_props);
+				} else {
+					e = GF_NOT_SUPPORTED;
+				}
+				if (e) break;
+				if (meta->primary) {
+					e = gf_isom_set_meta_primary_item(file, meta->root_meta, tk, meta->item_id);
+					if (e) break;
+				}
+				if (meta->item_refs && gf_list_count(meta->item_refs)) {
+					u32 ref_i;
+					for (ref_i = 0; ref_i < gf_list_count(meta->item_refs); ref_i++) {
+						MetaRef	*ref_entry = gf_list_get(meta->item_refs, ref_i);
+						e = gf_isom_meta_add_item_ref(file, meta->root_meta, tk, meta->item_id, ref_entry->ref_item_id, ref_entry->ref_type, NULL);
+						if (e) break;
+					}
+				}
+			}
+			do_save = GF_TRUE;
+		}
+			break;
+		case META_ACTION_REM_ITEM:
+			e = gf_isom_remove_meta_item(file, meta->root_meta, tk, meta->item_id, GF_FALSE, NULL);
+			do_save = GF_TRUE;
+			break;
+		case META_ACTION_SET_PRIMARY_ITEM:
+			e = gf_isom_set_meta_primary_item(file, meta->root_meta, tk, meta->item_id);
+			do_save = GF_TRUE;
+			break;
+		case META_ACTION_SET_XML:
+		case META_ACTION_SET_BINARY_XML:
+			e = gf_isom_set_meta_xml(file, meta->root_meta, tk, meta->szPath, NULL, 0, (meta->act_type==META_ACTION_SET_BINARY_XML) ? 1 : 0);
+			do_save = GF_TRUE;
+			break;
+		case META_ACTION_REM_XML:
+			if (gf_isom_get_meta_item_count(file, meta->root_meta, tk)) {
+				e = gf_isom_remove_meta_xml(file, meta->root_meta, tk);
+				do_save = GF_TRUE;
+			} else {
+				M4_LOG(GF_LOG_WARNING, ("No meta box in input file\n"));
+				e = GF_OK;
+			}
+			break;
+		case META_ACTION_DUMP_ITEM:
+			if (gf_isom_get_meta_item_count(file, meta->root_meta, tk)) {
+				e = gf_isom_extract_meta_item(file, meta->root_meta, tk, meta->item_id, meta->szPath && strlen(meta->szPath) ? meta->szPath : NULL);
+			} else {
+				M4_LOG(GF_LOG_WARNING, ("No meta box in input file\n"));
+				e = GF_OK;
+			}
+			break;
+#endif // GPAC_DISABLE_ISOM_WRITE
+
+		case META_ACTION_DUMP_XML:
+			if (gf_isom_has_meta_xml(file, meta->root_meta, tk)) {
+				e = gf_isom_extract_meta_xml(file, meta->root_meta, tk, meta->szPath, NULL);
+			} else {
+				M4_LOG(GF_LOG_WARNING, ("No meta box in input file\n"));
+				e = GF_OK;
+			}
+			break;
+		default:
+			break;
+		}
+		if (meta->item_refs) {
+			while (gf_list_count(meta->item_refs)) {
+				gf_free(gf_list_pop_back(meta->item_refs));
+			}
+			gf_list_del(meta->item_refs);
+			meta->item_refs = NULL;
+		}
+		// meta->image_props is freed in mp4box_cleanup
+		if (e) return e;
+	}
+	return GF_OK;
+}
+
+static GF_Err do_tsel_act()
+{
+	u32 i;
+	GF_Err e;
+	for (i=0; i<nb_tsel_acts; i++) {
+		u32 refID, trackID = get_track_id(file, &tsel_actsi.target_track);
+		if (!trackID) {
+			M4_LOG(GF_LOG_ERROR, ("Track not found\n"));
+			e = GF_BAD_PARAM;
+			return e;
+		}
+
+		switch (tsel_actsi.act_type) {
+		case TSEL_ACTION_SET_PARAM:
+			refID = get_track_id(file, &tsel_actsi.reference_track);
+			e = gf_isom_set_track_switch_parameter(file,
+			 gf_isom_get_track_by_id(file, trackID),
+			 refID,
+			 tsel_actsi.is_switchGroup ? 1 : 0,
+			 &tsel_actsi.switchGroupID,
+			 tsel_actsi.criteria, tsel_actsi.nb_criteria);
+			if (e == GF_BAD_PARAM) {
+				u32 alternateGroupID, nb_groups;
+				gf_isom_get_track_switch_group_count(file, gf_isom_get_track_by_id(file, trackID), &alternateGroupID, &nb_groups);
+				if (alternateGroupID) {
+					M4_LOG(GF_LOG_ERROR, ("Error - for adding more tracks to group, using: -group-add -refTrack=ID1:criteria:trackID=ID2\n"));
+				} else {
+					M4_LOG(GF_LOG_ERROR, ("Error - for creating a new grouping information, using -group-add -trackID=ID1:criteria:trackID=ID2\n"));
+				}
+			}
+			if (e) return e;
+			do_save = GF_TRUE;
+			break;
+		case TSEL_ACTION_REMOVE_TSEL:
+			e = gf_isom_reset_track_switch_parameter(file, gf_isom_get_track_by_id(file, trackID), 0);
+			if (e) return e;
+			do_save = GF_TRUE;
+			break;
+		case TSEL_ACTION_REMOVE_ALL_TSEL_IN_GROUP:
+			e = gf_isom_reset_track_switch_parameter(file, gf_isom_get_track_by_id(file, trackID), 1);
+			if (e) return e;
+			do_save = GF_TRUE;
+			break;
+		default:
+			break;
+		}
+	}
+	return GF_OK;
+}
+
+static void do_ipod_conv()
+{
+	u32 i, ipod_major_brand = 0;
+	M4_LOG(GF_LOG_INFO, ("Setting up iTunes/iPod file\n"));
+
+	for (i=0; i<gf_isom_get_track_count(file); i++) {
+		u32 mType = gf_isom_get_media_type(file, i+1);
+		switch (mType) {
+		case GF_ISOM_MEDIA_VISUAL:
+		case GF_ISOM_MEDIA_AUXV:
+		case GF_ISOM_MEDIA_PICT:
+			ipod_major_brand = GF_ISOM_BRAND_M4V;
+			gf_isom_set_ipod_compatible(file, i+1);
+			break;
+		case GF_ISOM_MEDIA_AUDIO:
+			if (!ipod_major_brand) ipod_major_brand = GF_ISOM_BRAND_M4A;
+			else gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_M4A, GF_TRUE);
+			break;
+		case GF_ISOM_MEDIA_TEXT:
+			/*this is a text track track*/
+			if (gf_isom_get_media_subtype(file, i+1, 1) == GF_ISOM_SUBTYPE_TX3G) {
+				Bool is_chap = 0;
+				u32 j;
+				for (j=0; j<gf_isom_get_track_count(file); j++) {
+					s32 count = gf_isom_get_reference_count(file, j+1, GF_ISOM_REF_CHAP);
+					if (count>0) {
+						u32 tk, k;
+						for (k=0; k<(u32) count; k++) {
+							gf_isom_get_reference(file, j+1, GF_ISOM_REF_CHAP, k+1, &tk);
+							if (tk==i+1) {
+								is_chap = 1;
+								break;
+							}
+						}
+						if (is_chap) break;
+					}
+					if (is_chap) break;
+				}
+				/*this is a subtitle track*/
+				if (!is_chap)
+					gf_isom_set_media_type(file, i+1, GF_ISOM_MEDIA_SUBT);
+			}
+			break;
+		}
+	}
+	gf_isom_set_brand_info(file, ipod_major_brand, 1);
+	gf_isom_modify_alternate_brand(file, GF_ISOM_BRAND_MP42, GF_TRUE);
+	do_save = GF_TRUE;
+}
+
+static GF_Err do_track_act()
+{
+	u32 j;
+	for (j=0; j<nb_track_act; j++) {
+		u32 i;
+		GF_Err e = GF_OK;
+		TrackAction *tka = &tracksj;
+		u32 trackID = get_track_id(file, &tka->target_track);
+		u32 track = trackID ? gf_isom_get_track_by_id(file, trackID) : 0;
+
+		u32 newTrackID = get_track_id(file, &tka->newTrackID);
+
+		timescale = gf_isom_get_timescale(file);
+		switch (tka->act_type) {
+		case TRACK_ACTION_REM_TRACK:
+			e = gf_isom_remove_track(file, track);
+			if (e) {
+				M4_LOG(GF_LOG_ERROR, ("Error Removing track ID %d: %s\n", trackID, gf_error_to_string(e)));
+			} else {
+				M4_LOG(GF_LOG_INFO, ("Removing track ID %d\n", trackID));
+			}
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_LANGUAGE:
+			for (i=0; i<gf_isom_get_track_count(file); i++) {
+				if (track && (track != i+1)) continue;
+				e = gf_isom_set_media_language(file, i+1, tka->lang);
+				if (e) return e;
+				do_save = GF_TRUE;
+			}
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_KIND:
+			for (i=0; i<gf_isom_get_track_count(file); i++) {
+				if (track && (track != i+1)) continue;
+				e = gf_isom_add_track_kind(file, i+1, tka->kind_scheme, tka->kind_value);
+				if (e) return e;
+				do_save = GF_TRUE;
+			}
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_REM_KIND:
+			for (i=0; i<gf_isom_get_track_count(file); i++) {
+				if (track && (track != i+1)) continue;
+				e = gf_isom_remove_track_kind(file, i+1, tka->kind_scheme, tka->kind_value);
+				if (e) return e;
+				do_save = GF_TRUE;
+			}
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_DELAY:
+			if (tka->delay.num && tka->delay.den) {
+				u64 tk_dur;
+
+				e = gf_isom_remove_edits(file, track);
+				if (e) return e;
+				tk_dur = gf_isom_get_track_duration(file, track);
+				if (gf_isom_get_edits_count(file, track))
+					do_save = GF_TRUE;
+				if (tka->delay.num>0) {
+					//cast to u64, delay_ms * timescale can be quite big before / 1000
+					e = gf_isom_append_edit(file, track, ((u64) tka->delay.num) * timescale / tka->delay.den, 0, GF_ISOM_EDIT_EMPTY);
+					if (e) return e;
+					e = gf_isom_append_edit(file, track, tk_dur, 0, GF_ISOM_EDIT_NORMAL);
+					if (e) return e;
+					do_save = GF_TRUE;
+				} else {
+					//cast to u64, delay_ms * timescale can be quite big before / 1000
+					u64 to_skip = ((u64) -tka->delay.num) * timescale / tka->delay.den;
+					if (to_skip<tk_dur) {
+						//cast to u64, delay_ms * timescale can be quite big before / 1000
+						u64 media_time = ((u64) -tka->delay.num) * gf_isom_get_media_timescale(file, track) / tka->delay.den;
+						e = gf_isom_append_edit(file, track, tk_dur-to_skip, media_time, GF_ISOM_EDIT_NORMAL);
+						if (e) return e;
+						do_save = GF_TRUE;
+					} else {
+						M4_LOG(GF_LOG_WARNING, ("Warning: request negative delay longer than track duration - ignoring\n"));
+					}
+				}
+			} else if (gf_isom_get_edits_count(file, track)) {
+				e = gf_isom_remove_edits(file, track);
+				if (e) return e;
+				do_save = GF_TRUE;
+			}
+			break;
+		case TRACK_ACTION_SET_KMS_URI:
+			for (i=0; i<gf_isom_get_track_count(file); i++) {
+				if (track && (track != i+1)) continue;
+				if (!gf_isom_is_media_encrypted(file, i+1, 1)) continue;
+				if (!gf_isom_is_ismacryp_media(file, i+1, 1)) continue;
+				e = gf_isom_change_ismacryp_protection(file, i+1, 1, NULL, (char *) tka->kms);
+				if (e) return e;
+				do_save = GF_TRUE;
+			}
+			break;
+		case TRACK_ACTION_SET_ID:
+			if (!trackID && (gf_isom_get_track_count(file) == 1)) {
+				M4_LOG(GF_LOG_WARNING, ("Warning: track id is not specified, but file has only one track - assume that you want to change id for this track\n"));
+				track = 1;
+			}
+			if (track) {
+				u32 newTrack;
+				newTrack = gf_isom_get_track_by_id(file, newTrackID);
+				if (newTrack != 0) {
+					M4_LOG(GF_LOG_WARNING, ("Cannot set track id with value %d because a track already exists - ignoring", tka->newTrackID));
+				} else {
+					e = gf_isom_set_track_id(file, track, newTrackID);
+					if (e) return e;
+					do_save = GF_TRUE;
+				}
+			} else {
+				M4_LOG(GF_LOG_WARNING, ("Error: Cannot change id for track %d because it does not exist - ignoring", trackID));
+			}
+			break;
+		case TRACK_ACTION_SWAP_ID:
+			if (track) {
+				u32 tk1, tk2;
+				tk1 = gf_isom_get_track_by_id(file, trackID);
+				tk2 = gf_isom_get_track_by_id(file, newTrackID);
+				if (!tk1 || !tk2) {
+					M4_LOG(GF_LOG_WARNING, ("Error: Cannot swap track IDs because not existing - ignoring"));
+				} else {
+					e = gf_isom_set_track_id(file, tk2, 0);
+					if (e) return e;
+					e = gf_isom_set_track_id(file, tk1, newTrackID);
+					if (e) return e;
+					e = gf_isom_set_track_id(file, tk2, trackID);
+					if (e) return e;
+					do_save = GF_TRUE;
+				}
+			} else {
+				M4_LOG(GF_LOG_WARNING, ("Error: Cannot change id for track %d because it does not exist - ignoring", trackID));
+			}
+			break;
+		case TRACK_ACTION_SET_PAR:
+			e = gf_media_change_par(file, track, tka->par_num, tka->par_den, tka->force_par, tka->rewrite_bs);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_CLAP:
+			e = gf_isom_set_clean_aperture(file, track, 1, tka->clap_wnum, tka->clap_wden, tka->clap_hnum, tka->clap_hden, tka->clap_honum, tka->clap_hoden, tka->clap_vonum, tka->clap_voden);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_MX:
+			e = gf_isom_set_track_matrix(file, track, tka->mx);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_HANDLER_NAME:
+			e = gf_isom_set_handler_name(file, track, tka->hdl_name);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_ENABLE:
+			if (!gf_isom_is_track_enabled(file, track)) {
+				e = gf_isom_set_track_enabled(file, track, GF_TRUE);
+				do_save = GF_TRUE;
+			}
+			break;
+		case TRACK_ACTION_DISABLE:
+			if (gf_isom_is_track_enabled(file, track)) {
+				e = gf_isom_set_track_enabled(file, track, GF_FALSE);
+				do_save = GF_TRUE;
+			}
+			break;
+		case TRACK_ACTION_REFERENCE:
+			e = gf_isom_set_track_reference(file, track, GF_4CC(tka->lang0, tka->lang1, tka->lang2, tka->lang3), newTrackID);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_REM_NON_RAP:
+			e = gf_media_remove_non_rap(file, track, GF_FALSE);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_REM_NON_REFS:
+			e = gf_media_remove_non_rap(file, track, GF_TRUE);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_UDTA:
+			e = set_file_udta(file, track, tka->udta_type, tka->string ? tka->string : tka->src_name , tka->sample_num ? GF_TRUE : GF_FALSE, tka->string ? GF_TRUE : GF_FALSE);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_EDITS:
+			e = apply_edits(file, track, tka->string);
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_TIME:
+			if (!trackID) {
+				e = gf_isom_set_creation_time(file, tka->time, tka->time);
+				if (e) return e;
+				for (i=0; i<gf_isom_get_track_count(file); i++) {
+					e = gf_isom_set_track_creation_time(file, i+1, tka->time, tka->time);
+					if (e) return e;
+				}
+			} else {
+				e = gf_isom_set_track_creation_time(file, track, tka->time, tka->time);
+			}
+			do_save = GF_TRUE;
+			break;
+		case TRACK_ACTION_SET_MEDIA_TIME:
+			for (i=0; i<gf_isom_get_track_count(file); i++) {
+				if (track && (track != i+1)) continue;
+				e = gf_isom_set_media_creation_time(file, i+1, tka->time, tka->time);
+				if (e) return e;
+			}
+			do_save = GF_TRUE;
+			break;
+		default:
+			break;
+		}
+		if (e) return e;
+	}
+	return GF_OK;
+}
+
+
+
+static Bool do_qt_keys(char *name, char *val)
+{
+	GF_Err e = gf_media_isom_apply_qt_key(file, name, val);
+	if (e) return GF_FALSE;
+	do_save = GF_TRUE;
+	return GF_TRUE;
+}
+
+static GF_Err do_itunes_tag()
+{
+	GF_Err e;
+	char *itunes_data = NULL;
+	char *tags = itunes_tags;
+
+	if (gf_file_exists(itunes_tags)) {
+		u32 len;
+		e = gf_file_load_data(itunes_tags, (u8 **) &itunes_data, &len);
+		if (e) return e;
+		tags = itunes_data;
+	}
+
+	while (tags) {
+		char *val;
+		Bool clear = GF_FALSE;
+		Bool is_wma = GF_FALSE;
+		u32 tlen, tagtype=0, itag = 0;
+		s32 tag_idx=-1;
+		char *sep = itunes_data ? strchr(tags, '\n') : gf_url_colon_suffix(tags, '=');
+		while (sep) {
+			char *eq = strchr(sep+1, '=');
+			if (eq) eq0 = 0;
+			s32 next_tag_idx = gf_itags_find_by_name(sep+1);
+			if (next_tag_idx<0) {
+				//4CC tag
+				if ( strlen(sep+1)==4) {
+					next_tag_idx = 0;
+				}
+				//3CC tag, changed to @tag
+				if ( strlen(sep+1)==3) {
+					next_tag_idx = 0;
+				}
+				//unrecognized tag tag
+				else if (strlen(sep+1)) {
+					M4_LOG(GF_LOG_WARNING, ("Unrecognize tag \"%s\", assuming part of previous tag\n", sep+1));
+				}
+			}
+
+			if (eq) eq0 = '=';
+			if (next_tag_idx>=0) {
+				sep0 = 0;
+				break;
+			}
+			sep = itunes_data ? strchr(sep+1, '\n') : gf_url_colon_suffix(sep+1, '=');
+		}
+		val = strchr(tags, '=');
+		if (val) val0 = 0;
+		if (!strcmp(tags, "clear") || !strcmp(tags, "reset")) {
+			clear = GF_TRUE;
+		} else if (!strncmp(tags, "WM/", 3) ) {
+			is_wma = GF_TRUE;
+		} else if (!strncmp(tags, "QT/", 3) ) {
+			tags+=3;
+		} else {
+			tag_idx = gf_itags_find_by_name(tags);
+			if (tag_idx<0) {
+				if (strlen(tags)==4) {
+					itag = GF_4CC(tags0, tags1, tags2, tags3);
+					tagtype = GF_ITAG_STR;
+				} else if (strlen(tags)==3) {
+					itag = GF_4CC(0xA9, tags0, tags1, tags2);
+					tagtype = GF_ITAG_STR;
+				}
+			}
+		}
+		if (!itag && !clear && !is_wma) {
+			if (tag_idx<0) {
+				if (val && !do_qt_keys(tags, val+1)) {
+					M4_LOG(GF_LOG_WARNING, ("Invalid iTune tag name \"%s\" - ignoring\n", tags));
+				}
+				if (val) val0 = '=';
+				goto tag_done;
+			}
+			itag = gf_itags_get_itag(tag_idx);
+			tagtype = gf_itags_get_type(tag_idx);
+		}
+		if (val) {
+			val0 = '=';
+			val++;
+		}
+		if (!val || (val0==':') || !val0 || !stricmp(val, "NULL") ) val = NULL;
+
+		//if val is NULL, use tlen=1 to force removal of tag
+		if (val) {
+			tlen = (u32) strlen(val);
+			while (tlen && ( (valtlen-1=='\n') || (valtlen-1=='\r')))
+				tlen--;
+		} else {
+			tlen = 1;
+		}
+
+		if (clear) {
+			e = gf_isom_apple_set_tag(file, GF_ISOM_ITUNE_RESET, NULL, 0, 0, 0);
+			e |= gf_isom_set_qt_key(file, NULL);
+		}
+		else if (is_wma) {
+			if (val) val-1 = 0;
+			e = gf_isom_wma_set_tag(file, tags, val);
+			if (val) val-1 = '=';
+		}
+		else if (val && (tagtype==GF_ITAG_FILE)) {
+			u32 flen = (u32) strlen(val);
+			u8 *d=NULL;
+			while (flen && valflen-1=='\n') flen--;
+			valflen = 0;
+			e = gf_file_load_data(val, (u8 **) &d, &tlen);
+			valflen = '\n';
+
+			if (!e)
+				e = gf_isom_apple_set_tag(file, itag, d, tlen, 0, 0);
+
+			if (d) gf_free(d);
+		} else {
+			e = gf_isom_apple_set_tag(file, itag, (u8 *) val, tlen, 0, 0);
+		}
+		if (e) {
+			M4_LOG(GF_LOG_ERROR, ("Error assigning tag %s: %s\n", tags, gf_error_to_string(e) ));
+		}
+
+		do_save = GF_TRUE;
+
+tag_done:
+		if (sep) {
+			sep0 = itunes_data ? '\n' : ':';
+			tags = sep+1;
+		} else {
+			tags = NULL;
+		}
+	}
+	if (itunes_data) gf_free(itunes_data);
+	return GF_OK;
+}
+
+#if !defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)
+static void set_sdp_ext()
+{
+	u32 i, j;
+	for (i=0; i<nb_sdp_ex; i++) {
+		u32 trackID = get_track_id(file, &sdp_linesi.track_id);
+		if (trackID) {
+			u32 track = gf_isom_get_track_by_id(file, trackID);
+			if (gf_isom_get_media_type(file, track)!=GF_ISOM_MEDIA_HINT) {
+				s32 ref_count;
+				u32 k, count = gf_isom_get_track_count(file);
+				for (j=0; j<count; j++) {
+					if (gf_isom_get_media_type(file, j+1)!=GF_ISOM_MEDIA_HINT) continue;
+					ref_count = gf_isom_get_reference_count(file, j+1, GF_ISOM_REF_HINT);
+					if (ref_count<0) continue;
+					for (k=0; k<(u32) ref_count; k++) {
+						u32 refTk;
+						if (gf_isom_get_reference(file, j+1, GF_ISOM_REF_HINT, k+1, &refTk)) continue;
+						if (refTk==track) {
+							track = j+1;
+							j=count;
+							break;
+						}
+					}
+				}
+			}
+			gf_isom_sdp_add_track_line(file, track, sdp_linesi.line);
+			do_save = GF_TRUE;
+		} else {
+			gf_isom_sdp_add_line(file, sdp_linesi.line);
+			do_save = GF_TRUE;
+		}
+	}
+}
+#endif /*!defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)*/
+
+static GF_Err do_remux_file()
+{
+	GF_MediaExporter mdump;
+	memset(&mdump, 0, sizeof(GF_MediaExporter));
+	mdump.in_name = inName;
+	mdump.out_name = mux_name;
+	mdump.flags = GF_EXPORT_REMUX;
+	mdump.print_stats_graph = fs_dump_flags;
+	return gf_media_export(&mdump);
+}
+
+static u32 mp4box_cleanup(u32 ret_code) {
+	if (mpd_base_urls) {
+		gf_free(mpd_base_urls);
+		mpd_base_urls = NULL;
+	}
+	if (sdp_lines) {
+		gf_free(sdp_lines);
+		sdp_lines = NULL;
+	}
+	if (metas) {
+		u32 i;
+		for (i=0; i<nb_meta_act; i++) {
+			if (metasi.enc_type) gf_free(metasi.enc_type);
+			if (metasi.mime_type) gf_free(metasi.mime_type);
+			if (metasi.szName) gf_free(metasi.szName);
+			if (metasi.szPath) gf_free(metasi.szPath);
+			if (metasi.keep_props) gf_free(metasi.keep_props);
+			if (metasi.image_props) {
+				GF_ImageItemProperties *iprops = metasi.image_props;
+				if (iprops->overlay_offsets) gf_free(iprops->overlay_offsets);
+				if (iprops->aux_urn) gf_free((char *) iprops->aux_urn);
+				if (iprops->aux_data) gf_free((char *) iprops->aux_data);
+				gf_free(iprops);
+			}
+		}
+		gf_free(metas);
+		metas = NULL;
+	}
+	if (tracks) {
+		u32 i;
+		for (i = 0; i<nb_track_act; i++) {
+			if (tracksi.out_name)
+				gf_free(tracksi.out_name);
+			if (tracksi.src_name)
+				gf_free(tracksi.src_name);
+			if (tracksi.string)
+				gf_free(tracksi.string);
+			if (tracksi.kind_scheme)
+				gf_free(tracksi.kind_scheme);
+			if (tracksi.kind_value)
+				gf_free(tracksi.kind_value);
+		}
+		gf_free(tracks);
+		tracks = NULL;
+	}
+	if (tsel_acts) {
+		gf_free(tsel_acts);
+		tsel_acts = NULL;
+	}
+	if (brand_add) {
+		gf_free(brand_add);
+		brand_add = NULL;
+	}
+	if (brand_rem) {
+		gf_free(brand_rem);
+		brand_rem = NULL;
+	}
+	if (dash_inputs) {
+		u32 i, j;
+		for (i = 0; i<nb_dash_inputs; i++) {
+			GF_DashSegmenterInput *di = &dash_inputsi;
+			if (di->nb_baseURL) {
+				for (j = 0; j<di->nb_baseURL; j++) {
+					gf_free(di->baseURLj);
+				}
+				gf_free(di->baseURL);
+			}
+			if (di->rep_descs) {
+				for (j = 0; j<di->nb_rep_descs; j++) {
+					gf_free(di->rep_descsj);
+				}
+				gf_free(di->rep_descs);
+			}
+			if (di->as_descs) {
+				for (j = 0; j<di->nb_as_descs; j++) {
+					gf_free(di->as_descsj);
+				}
+				gf_free(di->as_descs);
+			}
+			if (di->as_c_descs) {
+				for (j = 0; j<di->nb_as_c_descs; j++) {
+					gf_free(di->as_c_descsj);
+				}
+				gf_free(di->as_c_descs);
+			}
+			if (di->p_descs) {
+				for (j = 0; j<di->nb_p_descs; j++) {
+					gf_free(di->p_descsj);
+				}
+				gf_free(di->p_descs);
+			}
+			if (di->representationID) gf_free(di->representationID);
+			if (di->periodID) gf_free(di->periodID);
+			if (di->xlink) gf_free(di->xlink);
+			if (di->seg_template) gf_free(di->seg_template);
+			if (di->hls_pl) gf_free(di->hls_pl);
+			if (di->source_opts) gf_free(di->source_opts);
+			if (di->filter_chain) gf_free(di->filter_chain);
+
+			if (di->roles) {
+				for (j = 0; j<di->nb_roles; j++) {
+					gf_free(di->rolesj);
+				}
+				gf_free(di->roles);
+			}
+		}
+		gf_free(dash_inputs);
+		dash_inputs = NULL;
+	}
+	if (logfile) gf_fclose(logfile);
+	gf_sys_close();
+
+#ifdef GPAC_MEMORY_TRACKING
+	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
+		gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
+		gf_memory_print();
+	}
+#endif
+
+	return ret_code;
+}
+
+
+
+int mp4box_main(int argc, char **argv)
+{
+	u32 i, j;
+	const char *gpac_profile = "0";
+	GF_Err e = GF_OK;
+
+	init_global_vars();
+
+#ifdef TEST_ARGS
+	i=0;
+	mp4box_parse_single_arg(argc, argv, "", &i);
+#endif
+
+	for (i = 1; i < (u32) argc ; i++) {
+		if (!strcmp(argvi, "-mem-track") || !strcmp(argvi, "-mem-track-stack")) {
+#ifdef GPAC_MEMORY_TRACKING
+ mem_track = !strcmp(argvi, "-mem-track-stack") ? GF_MemTrackerBackTrace : GF_MemTrackerSimple;
+#else
+			M4_LOG(GF_LOG_WARNING, ("WARNING - GPAC not compiled with Memory Tracker - ignoring \"%s\"\n", argvi));
+#endif
+			break;
+		}
+		else if (!strcmp(argvi, "-p")) {
+			if (i+1<(u32) argc)
+				gpac_profile = argvi+1;
+			else {
+				M4_LOG(GF_LOG_ERROR, ("Bad argument for -p, expecting profile name but no more args\n"));
+				return 1;
+			}
+		}
+		else if (!strncmp(argvi, "-p=", 3))
+			gpac_profile = argvi+3;
+	}
+
+#ifdef _TWO_DIGIT_EXPONENT
+	_set_output_format(_TWO_DIGIT_EXPONENT);
+#endif
+
+	/*init libgpac*/
+	gf_sys_init(mem_track, gpac_profile);
+#ifdef GPAC_CONFIG_ANDROID
+	//prevent destruction of JSRT until we unload the JNI gpac wrapper (see applications/gpac_android/src/main/jni/gpac_jni.cpp)
+	gf_opts_set_key("temp", "static-jsrt", "true");
+#endif
+
+	if (argc < 2) {
+		M4_LOG(GF_LOG_ERROR, ("Not enough arguments - check usage with -h\n"));
+		M4_LOG(GF_LOG_INFO, ("MP4Box - GPAC version %s\n"
+	 "%s\n", gf_gpac_version(), gf_gpac_copyright_cite() ));
+		gf_sys_close();
+		return 0;
+	}
+
+	helpout = stdout;
+
+	i = mp4box_parse_args(argc, argv);
+	if (i) {
+		return mp4box_cleanup(i - 1);
+	}
+#if !defined(GPAC_DISABLE_STREAMING) && !defined(GPAC_DISABLE_SENG)
+	if (live_scene) {
+		int ret = live_session(argc, argv);
+		return mp4box_cleanup(ret);
+	}
+#endif
+
+	if (!dash_duration && interleaving_time && do_frag)
+		interleaving_time /= 1000;
+
+	if (do_mpd_conv) inName = do_mpd_conv;
+
+#ifndef GPAC_DISABLE_STREAMING
+	if (import_flags & GF_IMPORT_FORCE_MPEG4)
+		hint_flags |= GP_RTP_PCK_FORCE_MPEG4;
+#endif
+
+	if (!inName && dump_std)
+		inName = "std";
+
+	if (!dash_duration && cprt)
+		open_edit = GF_TRUE;
+
+	if (!inName) {
+		if (has_next_arg) {
+			M4_LOG(GF_LOG_ERROR, ("Broken argument specifier or file name missing - check usage with -h\n"));
+		} else {
+			PrintUsage();
+		}
+		return mp4box_cleanup(1);
+	}
+	if (!strcmp(inName, "std")) dump_std = 2;
+	if (!strcmp(inName, "stdb")) {
+		inName = "std";
+		dump_std = 1;
+	}
+
+	if (!interleaving_time) {
+		/*by default use single fragment per dash segment*/
+		if (dash_duration)
+			interleaving_time = dash_duration;
+		else if (!do_flat && !(split_duration || split_size || split_range_str)) {
+			interleaving_time = DEFAULT_INTERLEAVING_IN_SEC;
+		}
+	}
+
+	if (dump_std)
+		outName = "std";
+
+	if (dump_std==2) {
+#ifdef WIN32
+		if ( _setmode(_fileno(stdout), _O_BINARY) == -1 )
+#else
+		if ( freopen(NULL, "wb", stdout) == NULL)
+#endif
+		{
+			M4_LOG(GF_LOG_ERROR, ("Fatal error: cannot reopen stdout in binary mode.\n"));
+			return mp4box_cleanup(1);
+		}
+	}
+
+	GF_LOG_Level level = verbose ? GF_LOG_DEBUG : GF_LOG_INFO;
+	gf_log_set_tool_level(GF_LOG_CONTAINER, level);
+	gf_log_set_tool_level(GF_LOG_SCENE, level);
+	gf_log_set_tool_level(GF_LOG_PARSER, level);
+	gf_log_set_tool_level(GF_LOG_MEDIA, level);
+	gf_log_set_tool_level(GF_LOG_CODING, level);
+	gf_log_set_tool_level(GF_LOG_DASH, level);
+#ifdef GPAC_MEMORY_TRACKING
+	if (mem_track)
+		gf_log_set_tool_level(GF_LOG_MEMORY, level);
+#endif
+
+	e = gf_sys_set_args(argc, (const char **) argv);
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("Error assigning libgpac arguments: %s\n", gf_error_to_string(e) ));
+		return mp4box_cleanup(1);
+	}
+
+	if (raw_cat)
+		return do_raw_cat();
+
+	if (compress_top_boxes) {
+		if (size_top_box) {
+			u64 top_size = do_size_top_boxes(inName, compress_top_boxes, size_top_box);
+			fprintf(stdout, LLU"\n", top_size);
+			return mp4box_cleanup(e ? 1 : 0);
+		} else {
+			e = do_compress_top_boxes(inName, outName);
+			return mp4box_cleanup(e ? 1 : 0);
+		}
+	}
+
+	if (do_mpd_rip) {
+		e = rip_mpd(inName, outName);
+		return mp4box_cleanup(e ? 1 : 0);
+	}
+
+	if (do_wget != NULL) {
+		e = gf_dm_wget(do_wget, inName, 0, 0, NULL);
+		if (e != GF_OK) {
+			M4_LOG(GF_LOG_ERROR, ("Cannot retrieve %s: %s\n", do_wget, gf_error_to_string(e) ));
+			return mp4box_cleanup(1);
+		}
+		return mp4box_cleanup(0);
+	}
+
+	if (udp_dest)
+		return do_write_udp();
+
+#ifndef GPAC_DISABLE_MPD
+	if (do_mpd_conv)
+		return convert_mpd();
+#endif
+
+	if (dash_duration && !nb_dash_inputs) {
+		dash_inputs = set_dash_input(dash_inputs, inName, &nb_dash_inputs);
+	}
+
+	if (do_saf && !encode) {
+		switch (get_file_type_by_ext(inName)) {
+		case GF_FILE_TYPE_BT_WRL_X3DV:
+		case GF_FILE_TYPE_XMT_X3D:
+		case GF_FILE_TYPE_SVG:
+			encode = GF_TRUE;
+			break;
+		case GF_FILE_TYPE_NOT_SUPPORTED:
+		case GF_FILE_TYPE_ISO_MEDIA:
+		case GF_FILE_TYPE_SWF:
+		case GF_FILE_TYPE_LSR_SAF:
+			break;
+		}
+	}
+
+#ifndef GPAC_DISABLE_SCENE_DUMP
+	if (dump_mode == GF_SM_DUMP_SVG) {
+		if (strstr(inName, ".srt") || strstr(inName, ".ttxt")) import_subtitle = 2;
+	}
+#endif
+
+	if (import_subtitle && !ttxt_track_id.type && !ttxt_track_id.ID_or_num)
+		return do_import_sub();
+
+
+#if !defined(GPAC_DISABLE_MEDIA_IMPORT) && !defined(GPAC_DISABLE_ISOM_WRITE)
+	if (nb_add || nb_cat) {
+		u32 res = do_add_cat(argc, argv);
+		if (res) return res;
+	}
+#endif /*!GPAC_DISABLE_MEDIA_IMPORT && !GPAC_DISABLE_ISOM_WRITE*/
+
+#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+	else if (chunk_mode) {
+		if (!inName) {
+			M4_LOG(GF_LOG_ERROR, ("chunk encoding syntax: -outctx outDump -inctx inScene auFile\n"));
+			return mp4box_cleanup(1);
+		}
+		e = EncodeFileChunk(inName, outName ? outName : inName, input_ctx, output_ctx);
+		if (e) {
+			M4_LOG(GF_LOG_ERROR, ("Error encoding chunk file %s\n", gf_error_to_string(e)));
+			return mp4box_cleanup(1);
+		}
+		goto exit;
+	}
+#endif // !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+
+	else if (encode) {
+#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+		e = do_scene_encode();
+		if (e) goto err_exit;
+#endif //!defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_SCENE_ENCODER) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+	}
+
+#ifndef GPAC_DISABLE_ISOM_WRITE
+	else if (pack_file) {
+		//don't use any check for ':', the first word must be the four CC
+		char *fileName = gf_url_colon_suffix(pack_file, 0);
+		if (fileName && ((fileName - pack_file)==4)) {
+			fileName0 = 0;
+			file = package_file(fileName + 1, pack_file, pack_wgt);
+			fileName0 = ':';
+		} else {
+			file = package_file(pack_file, NULL, pack_wgt);
+			if (!file) {
+				M4_LOG(GF_LOG_ERROR, ("Failed to package file\n"));
+				return mp4box_cleanup(1);
+			}
+		}
+		if (!outName) outName = inName;
+		do_save = GF_TRUE;
+		open_edit = GF_TRUE;
+	}
+#endif //GPAC_DISABLE_ISOM_WRITE
+
+	if (dash_duration) {
+		e = do_dash();
+		if (e) return mp4box_cleanup(1);
+		goto exit;
+	}
+
+	if (split_duration || split_size || split_range_str) {
+		if (force_new==2) {
+			do_flat = 3;
+			force_new = 0;
+		}
+	} else {
+		if (do_flat)
+			open_edit = GF_TRUE;
+	}
+
+	//need to open input
+	if (!file && !do_hash) {
+		FILE *st = gf_fopen(inName, "rb");
+		Bool file_exists = 0;
+		GF_ISOOpenMode omode;
+		if (st) {
+			file_exists = 1;
+			gf_fclose(st);
+		}
+		switch (get_file_type_by_ext(inName)) {
+		case 1:
+			omode = (u8) (force_new ? GF_ISOM_WRITE_EDIT : (open_edit ? GF_ISOM_OPEN_EDIT : ( ((dump_isom>0) || print_info) ? GF_ISOM_OPEN_READ_DUMP : GF_ISOM_OPEN_READ) ) );
+
+			if (crypt) {
+				//keep fragment signaling in moov
+				omode = GF_ISOM_OPEN_READ;
+				if (use_init_seg)
+					file = gf_isom_open(use_init_seg, GF_ISOM_OPEN_READ, NULL);
+			}
+			if (!crypt && use_init_seg) {
+				file = gf_isom_open(use_init_seg, GF_ISOM_OPEN_READ_DUMP, NULL);
+				if (file) {
+					e = gf_isom_open_segment(file, inName, 0, 0, 0);
+					if (e==GF_ISOM_INCOMPLETE_FILE) {
+						M4_LOG(GF_LOG_WARNING, ("Segment %s: %s\n", inName, gf_error_to_string(e) ));
+					} else if (e) {
+						M4_LOG(GF_LOG_ERROR, ("Error opening segment %s: %s\n", inName, gf_error_to_string(e) ));
+						gf_isom_delete(file);
+						file = NULL;
+					}
+				}
+			}
+			if (!file)
+				file = gf_isom_open(inName, omode, NULL);
+
+			if (!file && (gf_isom_last_error(NULL) == GF_ISOM_INCOMPLETE_FILE) && !open_edit) {
+				u64 missing_bytes;
+				gf_isom_open_progressive(inName, 0, 0, GF_FALSE, &file, &missing_bytes);
+				M4_LOG(GF_LOG_ERROR, ("Incomplete file - missing "LLD" bytes\n", missing_bytes));
+			}
+
+			if (!file) {
+				if (open_edit && nb_meta_act) {
+					file = gf_isom_open(inName, GF_ISOM_WRITE_EDIT, NULL);
+					if (!outName && file) outName = inName;
+				}
+
+				if (!file) {
+					M4_LOG(GF_LOG_ERROR, ("Error opening file %s: %s\n", inName, gf_error_to_string(gf_isom_last_error(NULL))));
+					return mp4box_cleanup(1);
+				}
+			}
+			if (freeze_box_order)
+				gf_isom_freeze_order(file);
+			break;
+		/*allowed for bt<->xmt*/
+		case 2:
+		case 3:
+		/*allowed for svg->lsr**/
+		case 4:
+		/*allowed for swf->bt, swf->xmt, swf->svg*/
+		case 5:
+			break;
+		/*used for .saf / .lsr dump*/
+		case 6:
+#ifndef GPAC_DISABLE_SCENE_DUMP
+			if ((dump_mode==GF_SM_DUMP_LASER) || (dump_mode==GF_SM_DUMP_SVG)) {
+				break;
+			}
+#endif
+
+		default:
+			if (!open_edit && file_exists && !gf_isom_probe_file(inName) && track_dump_type) {
+			}
+#ifndef GPAC_DISABLE_ISOM_WRITE
+			else if (!open_edit && file_exists /* && !gf_isom_probe_file(inName) */
+#ifndef GPAC_DISABLE_SCENE_DUMP
+			 && dump_mode == GF_SM_DUMP_NONE
+#endif //GPAC_DISABLE_SCENE_DUMP
+			 ) {
+				/*************************************************************************************************/
+#ifndef GPAC_DISABLE_MEDIA_IMPORT
+				if(dvbhdemux)
+				{
+					GF_MediaImporter import;
+					file = gf_isom_open("ttxt_convert", GF_ISOM_OPEN_WRITE, NULL);
+					memset(&import, 0, sizeof(GF_MediaImporter));
+					import.dest = file;
+					import.in_name = inName;
+					import.flags = GF_IMPORT_MPE_DEMUX;
+					e = gf_media_import(&import);
+					if (e) {
+						M4_LOG(GF_LOG_ERROR, ("Error importing %s: %s\n", inName, gf_error_to_string(e)));
+						gf_isom_delete(file);
+						gf_file_delete("ttxt_convert");
+						return mp4box_cleanup(1);
+					}
+				}
+#endif /*GPAC_DISABLE_MEDIA_IMPORT*/
+
+				if (dump_m2ts) {
+#ifndef GPAC_DISABLE_MPEG2TS
+					dump_mpeg2_ts(inName, outName, program_number);
+#endif
+				} else if (dump_timestamps) {
+#ifndef GPAC_DISABLE_MPEG2TS
+					dump_mpeg2_ts(inName, outName, program_number);
+#endif
+				} else if (do_bin_xml) {
+					xml_bs_to_bin(inName, outName, dump_std);
+				} else if (do_hash) {
+					hash_file(inName, dump_std);
+				} else if (print_info) {
+#ifndef GPAC_DISABLE_MEDIA_IMPORT
+					e = convert_file_info(inName, &info_track_id);
+					if (e) goto err_exit;
+#endif
+				} else {
+					if (mux_name) {
+						e = do_remux_file();
+						if (e) goto err_exit;
+						if (file) gf_isom_delete(file);
+						goto exit;
+					} else {
+						M4_LOG(GF_LOG_ERROR, ("Input %s is not an MP4 file, operation not allowed\n", inName));
+						return mp4box_cleanup(1);
+					}
+				}
+				goto exit;
+			}
+#endif /*GPAC_DISABLE_ISOM_WRITE*/
+			else if (open_edit) {
+				file = gf_isom_open(inName, GF_ISOM_WRITE_EDIT, NULL);
+				if (!outName && file) outName = inName;
+			} else if (!file_exists) {
+				M4_LOG(GF_LOG_ERROR, ("Error %s file %s: %s\n", force_new ? "creating" : "opening", inName, gf_error_to_string(GF_URL_ERROR)));
+				return mp4box_cleanup(1);
+			} else {
+				M4_LOG(GF_LOG_ERROR, ("Cannot open %s - extension not supported\n", inName));
+				return mp4box_cleanup(1);
+			}
+		}
+	}
+
+	if (high_dynamc_range_filename) {
+		e = parse_high_dynamc_range_xml_desc(file, 0, high_dynamc_range_filename);
+		if (e) goto err_exit;
+	}
+
+	if (file && keep_utc) {
+		gf_isom_keep_utc_times(file, 1);
+	}
+
+	if ( gf_strlcpy(outfile, outName ? outName : inName, sizeof(outfile)) >= sizeof(outfile) ) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Filename too long (limit is %d)\n", GF_MAX_PATH));
+		return mp4box_cleanup(1);
+	}
+
+	char *szExt = gf_file_ext_start(outfile);
+	if (szExt) {
+		/*turn on 3GP saving*/
+		if (!stricmp(szExt, ".3gp") || !stricmp(szExt, ".3gpp") || !stricmp(szExt, ".3g2"))
+			conv_type = GF_ISOM_CONV_TYPE_3GPP;
+		else if (!stricmp(szExt, ".m4a") || !stricmp(szExt, ".m4v"))
+			conv_type = GF_ISOM_CONV_TYPE_IPOD;
+		else if (!stricmp(szExt, ".psp"))
+			conv_type = GF_ISOM_CONV_TYPE_PSP;
+		else if (!stricmp(szExt, ".mov") || !stricmp(szExt, ".qt"))
+			conv_type = GF_ISOM_CONV_TYPE_MOV;
+
+		//remove extension from outfile
+		*szExt = 0;
+	}
+
+#ifndef GPAC_DISABLE_MEDIA_EXPORT
+	if (!open_edit && track_dump_type && !gf_isom_probe_file(inName)) {
+		e = do_export_tracks_non_isobmf();
+		if (e) goto err_exit;
+		goto exit;
+	}
+	if (mux_name) {
+		e = do_remux_file();
+		if (e) goto err_exit;
+		if (file) gf_isom_delete(file);
+		goto exit;
+	}
+
+
+
+#endif /*GPAC_DISABLE_MEDIA_EXPORT*/
+
+#ifndef GPAC_DISABLE_SCENE_DUMP
+	if (dump_mode != GF_SM_DUMP_NONE) {
+		e = dump_isom_scene(inName, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_mode, do_scene_log, no_odf_conf);
+		if (e) goto err_exit;
+	}
+#endif
+
+#ifndef GPAC_DISABLE_SCENE_STATS
+	if (stat_level) dump_isom_scene_stats(inName, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, stat_level);
+#endif
+
+#ifndef GPAC_DISABLE_ISOM_HINTING
+	if (!do_hint && print_sdp) dump_isom_sdp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
+#endif
+	if (get_nb_tracks) {
+		fprintf(stdout, "%d\n", gf_isom_get_track_count(file));
+	}
+	if (print_info) {
+		if (!file) {
+			M4_LOG(GF_LOG_ERROR, ("Cannot print info on a non ISOM file (%s)\n", inName));
+		} else {
+			u32 info_tk_id = get_track_id(file, &info_track_id);
+			if (info_tk_id) {
+				DumpTrackInfo(file, info_tk_id, 1, (print_info==2) ? GF_TRUE : GF_FALSE, GF_FALSE);
+			}
+			else DumpMovieInfo(file, (print_info==2) ? GF_TRUE : GF_FALSE);
+		}
+	}
+#ifndef GPAC_DISABLE_ISOM_DUMP
+	if (dump_isom) {
+		e = dump_isom_xml(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, (dump_isom==2) ? GF_TRUE : GF_FALSE, merge_vtt_cues, use_init_seg ? GF_TRUE : GF_FALSE, (dump_isom==3) ? GF_TRUE : GF_FALSE);
+		if (e) goto err_exit;
+	}
+	if (dump_cr) dump_isom_ismacryp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
+
+	if (dump_ttxt || dump_srt) {
+		u32 ttxt_tkid = get_track_id(file, &ttxt_track_id);
+		if (ttxt_tkid == (u32)-1) {
+			for (j=0; j<gf_isom_get_track_count(file); j++) {
+				ttxt_tkid = gf_isom_get_track_id(file, j+1);
+				dump_isom_timed_text(file, ttxt_tkid, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE,
+									GF_FALSE, dump_srt ? GF_TEXTDUMPTYPE_SRT : GF_TEXTDUMPTYPE_TTXT);
+			}
+
+		}
+		else if (ttxt_tkid) {
+			dump_isom_timed_text(file, ttxt_tkid, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE,
+								GF_FALSE, dump_srt ? GF_TEXTDUMPTYPE_SRT : GF_TEXTDUMPTYPE_TTXT);
+		}
+	}
+
+#ifndef GPAC_DISABLE_ISOM_HINTING
+	if (dump_rtp) dump_isom_rtp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
+#endif
+
+#endif
+
+	if (dump_timestamps) dump_isom_timestamps(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_timestamps);
+
+	u32 dump_tkid = get_track_id(file, &dump_nal_track);
+	if (dump_tkid) {
+		e = dump_isom_nal(file, dump_tkid, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_nal_type);
+		if (e) goto err_exit;
+	}
+	dump_tkid = get_track_id(file, &dump_saps_track);
+	if (dump_tkid) dump_isom_saps(file, dump_tkid, dump_saps_mode, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
+
+	if (do_hash) {
+		e = hash_file(inName, dump_std);
+		if (e) goto err_exit;
+	}
+	if (do_bin_xml) {
+		e = xml_bs_to_bin(inName, outName, dump_std);
+		if (e) goto err_exit;
+	}
+
+	if (dump_chunk) dump_isom_chunks(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
+	if (dump_cart) dump_isom_cover_art(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
+	if (dump_chap) dump_isom_chapters(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_chap);
+	if (dump_udta_type) {
+		dump_tkid = get_track_id(file, &dump_udta_track);
+		dump_isom_udta(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE, dump_udta_type, dump_tkid);
+	}
+
+	if (dump_iod) {
+		e = do_dump_iod();
+		if (e) goto err_exit;
+	}
+
+#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+	if (split_duration || split_size || split_range_str) {
+		e = split_isomedia_file(file, split_duration, split_size, inName, interleaving_time, split_start, adjust_split_end, outName, seg_at_rap, split_range_str, fs_dump_flags);
+		if (e) goto err_exit;
+
+		/*never save file when splitting is desired*/
+		open_edit = GF_FALSE;
+		do_save = GF_FALSE;
+	}
+#endif // !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_MEDIA_IMPORT)
+
+#ifndef GPAC_DISABLE_MEDIA_EXPORT
+	if (track_dump_type) {
+		e = do_export_tracks();
+		if (e) goto err_exit;
+	} else if (do_saf) {
+		GF_MediaExporter mdump;
+		memset(&mdump, 0, sizeof(mdump));
+		mdump.file = file;
+		mdump.flags = GF_EXPORT_SAF;
+		mdump.out_name = outfile;
+		mdump.print_stats_graph = fs_dump_flags;
+		e = gf_media_export(&mdump);
+		if (e) goto err_exit;
+	}
+#endif
+
+	e = do_meta_act();
+	if (e) goto err_exit;
+
+	if (!open_edit && !do_save) {
+		if (file) gf_isom_delete(file);
+		goto exit;
+	}
+
+
+#ifndef GPAC_DISABLE_ISOM_WRITE
+	if (clean_groups) {
+		e = gf_isom_reset_switch_parameters(file);
+		if (e) goto err_exit;
+		do_save = GF_TRUE;
+	}
+
+
+	e = do_tsel_act();
+	if (e) goto err_exit;
+
+	if (remove_sys_tracks) {
+#ifndef GPAC_DISABLE_AV_PARSERS
+		remove_systems_tracks(file);
+#endif
+		do_save = GF_TRUE;
+		if (conv_type < GF_ISOM_CONV_TYPE_ISMA_EX) conv_type = 0;
+	}
+	if (remove_root_od) {
+		gf_isom_remove_root_od(file);
+		do_save = GF_TRUE;
+	}
+#ifndef GPAC_DISABLE_ISOM_HINTING
+	if (remove_hint) {
+		for (i=0; i<gf_isom_get_track_count(file); i++) {
+			if (gf_isom_get_media_type(file, i+1) == GF_ISOM_MEDIA_HINT) {
+				M4_LOG(GF_LOG_INFO, ("Removing hint track ID %d\n", gf_isom_get_track_id(file, i+1)));
+				gf_isom_remove_track(file, i+1);
+				i--;
+			}
+		}
+		gf_isom_sdp_clean(file);
+		do_save = GF_TRUE;
+	}
+#endif // GPAC_DISABLE_ISOM_HINTING
+
+	if (timescale && (timescale != gf_isom_get_timescale(file))) {
+		gf_isom_set_timescale(file, timescale);
+		do_save = GF_TRUE;
+	}
+
+	if (!encode) {
+		if (!file) {
+			M4_LOG(GF_LOG_INFO, ("Nothing to do - exiting\n"));
+			goto exit;
+		}
+		if (outName) {
+			strcpy(outfile, outName);
+		} else {
+			const char *tmp_dir = gf_opts_get_key("core", "tmp");
+			char *rel_name = strrchr(inName, GF_PATH_SEPARATOR);
+			if (!rel_name) rel_name = strrchr(inName, '/');
+
+			strcpy(outfile, "");
+			if (tmp_dir) {
+				strcpy(outfile, tmp_dir);
+				if (!strchr("\\/", tmp_dirstrlen(tmp_dir)-1)) strcat(outfile, "/");
+			}
+			if (!pack_file) strcat(outfile, "out_");
+			strcat(outfile, rel_name ? rel_name + 1 : inName);
+
+			if (pack_file) {
+				strcpy(outfile, rel_name ? rel_name + 1 : inName);
+				rel_name = strrchr(outfile, '.');
+				if (rel_name) rel_name0 = 0;
+				strcat(outfile, ".m21");
+			}
+		}
+#ifndef GPAC_DISABLE_MEDIA_IMPORT
+		if ((conv_type == GF_ISOM_CONV_TYPE_ISMA) || (conv_type == GF_ISOM_CONV_TYPE_ISMA_EX)) {
+			M4_LOG(GF_LOG_INFO, ("Converting to ISMA Audio-Video MP4 file\n"));
+			/*keep ESIDs when doing ISMACryp*/
+			e = gf_media_make_isma(file, crypt ? 1 : 0, GF_FALSE, (conv_type==GF_ISOM_CONV_TYPE_ISMA_EX) ? 1 : 0);
+			if (e) goto err_exit;
+			do_save = GF_TRUE;
+		}
+		if (conv_type == GF_ISOM_CONV_TYPE_3GPP) {
+			M4_LOG(GF_LOG_INFO, ("Converting to 3GP file\n"));
+			e = gf_media_make_3gpp(file);
+			if (e) goto err_exit;
+			do_save = GF_TRUE;
+		}
+		if (conv_type == GF_ISOM_CONV_TYPE_PSP) {
+			M4_LOG(GF_LOG_INFO, ("Converting to PSP file\n"));
+			e = gf_media_make_psp(file);
+			if (e) goto err_exit;
+			do_save = GF_TRUE;
+		}
+		if (conv_type == GF_ISOM_CONV_TYPE_MOV) {
+			e = gf_media_check_qt_prores(file);
+			if (e) goto err_exit;
+			do_save = GF_TRUE;
+			if (interleaving_time) interleaving_time = 0.5;
+		}
+#endif /*GPAC_DISABLE_MEDIA_IMPORT*/
+		if (conv_type == GF_ISOM_CONV_TYPE_IPOD) {
+			do_ipod_conv();
+		}
+
+	} else if (outName) {
+		strcpy(outfile, outName);
+	}
+
+	e = do_track_act();
+	if (e) goto err_exit;
+
+	if (itunes_tags) {
+		e = do_itunes_tag();
+		if (e) goto err_exit;
+	}
+
+	if (cprt) {
+		e = gf_isom_set_copyright(file, "und", cprt);
+		do_save = GF_TRUE;
+		if (e) goto err_exit;
+	}
+	if (chap_file || chap_file_qt) {
+#ifndef GPAC_DISABLE_MEDIA_IMPORT
+		Bool chap_qt = GF_FALSE;
+		if (chap_file_qt) {
+			chap_file = chap_file_qt;
+			chap_qt = GF_TRUE;
+		}
+		e = gf_media_import_chapters(file, chap_file, import_fps, chap_qt);
+		do_save = GF_TRUE;
+#else
+		M4_LOG(GF_LOG_WARNING, ("Warning: GPAC compiled without Media Import, chapters can't be imported\n"));
+		e = GF_NOT_SUPPORTED;
+#endif
+		if (e) goto err_exit;
+	}
+
+	if (major_brand) {
+		gf_isom_set_brand_info(file, major_brand, minor_version);
+		do_save = GF_TRUE;
+	}
+	for (i=0; i<nb_alt_brand_add; i++) {
+		gf_isom_modify_alternate_brand(file, brand_addi, GF_TRUE);
+		do_save = GF_TRUE;
+	}
+	for (i=0; i<nb_alt_brand_rem; i++) {
+		gf_isom_modify_alternate_brand(file, brand_remi, GF_FALSE);
+		do_save = GF_TRUE;
+	}
+	if (box_patch_filename) {
+		e = gf_isom_apply_box_patch(file, get_track_id(file, &box_patch_track), box_patch_filename, GF_FALSE);
+		if (e) {
+			M4_LOG(GF_LOG_ERROR, ("Failed to apply box patch %s: %s\n", box_patch_filename, gf_error_to_string(e) ));
+			goto err_exit;
+		}
+		do_save = GF_TRUE;
+	}
+
+#ifndef GPAC_DISABLE_CRYPTO
+	if (crypt) {
+		if (!drm_file && (crypt==1) ) {
+			M4_LOG(GF_LOG_ERROR, ("Missing DRM file location - usage '-%s drm_file input_file\n", (crypt==1) ? "crypt" : "decrypt"));
+			e = GF_BAD_PARAM;
+			goto err_exit;
+		}
+		if (crypt == 1) {
+			if (use_init_seg) {
+				e = gf_crypt_fragment(file, drm_file, outfile, inName, fs_dump_flags);
+			} else {
+				e = gf_crypt_file(file, drm_file, outfile, interleaving_time, fs_dump_flags);
+			}
+		} else if (crypt ==2) {
+			if (use_init_seg) {
+				e = gf_decrypt_fragment(file, drm_file, outfile, inName, fs_dump_flags);
+			} else {
+				e = gf_decrypt_file(file, drm_file, outfile, interleaving_time, fs_dump_flags);
+			}
+		}
+		if (e) goto err_exit;
+		do_save = outName ? GF_FALSE : GF_TRUE;
+
+		if (!do_frag && !do_hint && !full_interleave && !force_co64) {
+			char szNameGF_MAX_PATH;
+			strcpy(szName, gf_isom_get_filename(file) );
+			gf_isom_delete(file);
+			file = NULL;
+			if (!outName) {
+				e = gf_file_move(outfile, szName);
+				if (e) goto err_exit;
+			}
+			goto exit;
+		}
+	}
+#endif /*GPAC_DISABLE_CRYPTO*/
+
+#ifndef GPAC_DISABLE_ISOM_FRAGMENTS
+	if (do_frag) {
+		if (!interleaving_time) interleaving_time = DEFAULT_INTERLEAVING_IN_SEC;
+		if (do_hint) M4_LOG(GF_LOG_WARNING, ("Warning: cannot hint and fragment - ignoring hint\n"));
+		M4_LOG(GF_LOG_INFO, ("Fragmenting file (%.3f seconds fragments)\n", interleaving_time));
+		e = gf_media_fragment_file(file, outfile, interleaving_time, use_mfra);
+		if (e) M4_LOG(GF_LOG_ERROR, ("Error while fragmenting file: %s\n", gf_error_to_string(e)));
+		if (!e && !outName) {
+			if (gf_file_exists(inName) && gf_file_delete(inName)) {
+				M4_LOG(GF_LOG_INFO, ("Error removing file %s\n", inName));
+			}
+			else if (gf_file_move(outfile, inName)) {
+				M4_LOG(GF_LOG_INFO, ("Error renaming file %s to %s\n", outfile, inName));
+			}
+		}
+		if (e) goto err_exit;
+		gf_isom_delete(file);
+		goto exit;
+	}
+#endif
+
+#ifndef GPAC_DISABLE_ISOM_HINTING
+	if (do_hint) {
+		if (force_ocr) SetupClockReferences(file);
+		MTUSize -= 12;
+		e = HintFile(file, MTUSize, max_ptime, rtp_rate, hint_flags, HintCopy, hint_interleave, regular_iod, single_group, hint_no_offset);
+		if (e) goto err_exit;
+		do_save = GF_TRUE;
+		if (print_sdp) dump_isom_sdp(file, dump_std ? NULL : (outName ? outName : outfile), outName ? GF_TRUE : GF_FALSE);
+	}
+#endif
+
+#if !defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)
+	set_sdp_ext();
+#endif /*!defined(GPAC_DISABLE_ISOM_HINTING) && !defined(GPAC_DISABLE_SENG)*/
+
+	if (force_co64)
+		gf_isom_force_64bit_chunk_offset(file, GF_TRUE);
+
+	if (compress_moov)
+		gf_isom_enable_compression(file, GF_ISOM_COMP_ALL, (compress_moov==2) ? GF_ISOM_COMP_WRAP_FTYPE : 0);
+
+	if (no_inplace)
+		gf_isom_disable_inplace_rewrite(file);
+
+	if (moov_pading)
+		gf_isom_set_inplace_padding(file, moov_pading);
+
+	if (outName) {
+		gf_isom_set_final_name(file, outfile);
+	} else if (!encode && !force_new && !gf_isom_is_inplace_rewrite(file)) {
+		gf_isom_set_final_name(file, outfile);
+	}
+
+	Bool is_inplace = gf_isom_is_inplace_rewrite(file);
+
+
+	/*full interleave (sample-based) if just hinted*/
+	if (full_interleave) {
+		e = gf_isom_set_storage_mode(file, GF_ISOM_STORE_TIGHT);
+	} else if (do_flat) {
+		e = gf_isom_set_storage_mode(file, (do_flat==1) ? GF_ISOM_STORE_FLAT : GF_ISOM_STORE_STREAMABLE);
+		do_save = GF_TRUE;
+	}
+	//do not set storage mode unless inplace rewrite is disabled , either by user or due to operations on file
+	else if (!is_inplace) {
+		e = gf_isom_make_interleave(file, interleaving_time);
+		if (!e && old_interleave) e = gf_isom_set_storage_mode(file, GF_ISOM_STORE_INTERLEAVED);
+	}
+
+	if (e) goto err_exit;
+
+
+	if (do_save) {
+
+		if (!gf_sys_is_quiet()) {
+			if (outName) {
+			} else if (encode || pack_file) {
+				M4_LOG(GF_LOG_INFO, ("Saving to %s: ", gf_isom_get_filename(file) ));
+			} else {
+				M4_LOG(GF_LOG_INFO, ("Saving %s: ", inName));
+			}
+			if (is_inplace) {
+				M4_LOG(GF_LOG_INFO, ("In-place rewrite\n"));
+			} else if (do_hint && full_interleave) {
+				M4_LOG(GF_LOG_INFO, ("Hinted file - Full Interleaving\n"));
+			} else if (full_interleave) {
+				M4_LOG(GF_LOG_INFO, ("Full Interleaving\n"));
+			} else if ((force_new==2) && interleaving_time) {
+				M4_LOG(GF_LOG_INFO, ("Fast-start interleaved storage\n"));
+			} else if (do_flat || !interleaving_time) {
+				M4_LOG(GF_LOG_INFO, ("Flat storage\n"));
+			} else {
+				M4_LOG(GF_LOG_INFO, ("%.3f secs Interleaving%s\n", interleaving_time, old_interleave ? " - no drift control" : ""));
+			}
+		}
+
+		e = gf_isom_close(file);
+		file = NULL;
+
+		if (!e && !outName && !encode && !force_new && !pack_file && !is_inplace) {
+			if (gf_file_exists(inName)) {
+				e = gf_file_delete(inName);
+				if (e) {
+					M4_LOG(GF_LOG_ERROR, ("Error removing file %s\n", inName));
+				}
+			}
+
+			e = gf_file_move(outfile, inName);
+			if (e) {
+				M4_LOG(GF_LOG_ERROR, ("Error renaming file %s to %s\n", outfile, inName));
+			}
+		}
+	} else {
+		gf_isom_delete(file);
+	}
+
+	if (e) {
+		M4_LOG(GF_LOG_ERROR, ("Error: %s\n", gf_error_to_string(e)));
+		goto err_exit;
+	}
+	goto exit;
+
+#else
+	/*close libgpac*/
+	gf_isom_delete(file);
+	M4_LOG(GF_LOG_ERROR, ("Error: Read-only version of MP4Box.\n"));
+	return mp4box_cleanup(1);
+#endif //GPAC_DISABLE_ISOM_WRITE
+
+
+err_exit:
+	/*close libgpac*/
+	if (file) gf_isom_delete(file);
+	M4_LOG(GF_LOG_ERROR, ("\n\tError: %s\n", gf_error_to_string(e)));
+	return mp4box_cleanup(1);
+
+exit:
+	mp4box_cleanup(0);
+
+#ifdef GPAC_MEMORY_TRACKING
+	if (mem_track && (gf_memory_size() || gf_file_handles_count() )) {
+		gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
+		gf_memory_print();
+		return 2;
+	}
+#endif
+	return 0;
+}
+
+#ifndef GPAC_CONFIG_ANDROID
+
+GF_MAIN_FUNC(mp4box_main)
+
+#endif //GPAC_CONFIG_ANDROID
+
+
+#endif /*GPAC_DISABLE_ISOM*/

gpac-2.0.0.tar.gz/applications/mp4box/mp4box.h -> gpac-2.2.0.tar.gz/applications/mp4box/mp4box.h Changed

gpac-2.0.0.tar.gz/applications/testapps/broadcaster/Makefile -> gpac-2.2.0.tar.gz/applications/testapps/broadcaster/Makefile Changed

gpac-2.0.0.tar.gz/applications/testapps/hevcbench/Makefile -> gpac-2.2.0.tar.gz/applications/testapps/hevcbench/Makefile Changed

gpac-2.0.0.tar.gz/applications/testapps/udptsseg/Makefile -> gpac-2.2.0.tar.gz/applications/testapps/udptsseg/Makefile Changed

gpac-2.0.0.tar.gz/build/android/README -> gpac-2.2.0.tar.gz/build/android/README Changed

@@ -2,73 +2,5 @@
 * How to build GPAC for Android *
 *********************************
 
-To compile GPAC for Android, please execute the following steps:
 
-1) Check out the GPAC GIT repository (but if you read this you probably already checkouted the GPAC repository):
- 
-	git clone https://github.com/gpac/gpac
-	This directory will be reminded as <GPAC_DIR>
-
-Get the extra lib packages from http://download.tsi.telecom-paristech.fr/gpac/gpac_extra_libs.zip and unzip the archive.
-This directory will be reminded as <GPAC_EXTRA_DIR>
-
-
-2) Get the Android softwares:
- 
-	A. Download the Android NDK at http://developer.android.com/sdk/ndk/index.html and unzip it at a place of your choice (referenced as <ANDROID_NDK_DIR>).
-		
-	B. Download the Java Development Kit at http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html (referenced as <JDK_DIR>)
- 
-	C. One of the following tools i) or ii) are needed for building the Android Package (APK):
-		i) GPAC provides scripts to build the APK from the shell. No IDE is needed.
-				You will then ignore every step in this readme that follow the ii) mark (as it concerns only people using Android Studio).
-
-		ii) Android Studio is useful if you want to go beyond the build (ie debug, add features, use the simulator etc). Firstly get Android Studio at https://developer.android.com/studio/index.html
-				
- 
-	D. Get and install SDK Component for Android:
- 
-		i) If you build without Android Studio, download the basic Android command line tools at https://developer.android.com/studio/index.html (at the bottom of the page), unzip it and launch tools/android. This opens a window. In "Tools" folder select "Android SDK Build-tools 23.0.3" and "Android API 23", in "Extras" folder select "Android Support Repository" and "Google Repository" and then Install packages at SDK Path (referenced as <ANDROID_SDK_DIR>).
- 
-		ii) If you use Android Studio, during installation you should tick the option Android SDK, so it will be downloaded
-
-3) Compile extra-libs for android 
-
-	A. Unzip all libs
-	
-		Go to <GPAC_EXTRA_DIR>. Set the right to execute the unzip_all script (e.g. chmod +x unzip_all.sh)
-		Run the script as follows : ./unzip_all
-
-	B. Build all extra-libs
-	
-		Go to <GPAC_EXTRA_DIR>/build/android. Set the right to execute the script gpac_build_all_extra_libs (e.g. chmod u+x gpac_build_all_extra_libs ).
-		Run the script as follows : ./gpac_build_all_extra_libs <ANDROID_NDK_DIR>
-	
-		NOTE: In case there is an error compiling ffmpeg, make sure there is permission to execute the script compile_ffmpeg_android as well (e.g. chmod u+rxw compile_ffmpeg_android)
-	
- 	C. Copy all the compiled extra lib to the right folder
-	
-		Go back to <GPAC_EXTRA_DIR>
-		Copy the just compiled libs into <GPAC_DIR>/extra_lib/lib/android by entering this command : 
-		cp -r lib/android/* <GPAC_DIR>/extra_lib/lib/android/
-
-4) Building GPAC for Android
- 
-	(optional) Links the Android SDK and NDK directories
- 
-		* cd /opt/
-		* sudo ln -s /home/xxx/xxx/<Android SDK> android_sdk /* /opt/android_sdk will then become your new <ANDROID_SDK_DIR> */
-		* sudo ln -s /home/xxx/xxx/<Android NDK> android_ndk /* /opt/android_ndk will then become your new <ANDROID_NDK_DIR> */
-
-	i) Building Osmo4.apk without Android Studio
-
-		 Go to GPAC_DIR/build/android/jni and launch the script 
-		./gpac_build_android -ndk=<ANDROID_NDK_DIR> -sdk=<ANDROID_SDK_DIR> -jdk=<JDK_DIR>
-		It will generate the package Osmo4.apk.
-		You can find the APK in <GPAC_DIR>/applications/osmo4_android_studio/app/build/outputs/apk
- 
- ii)Building Osmo4.apk with Android Studio
-
-		Go to GPAC_DIR/build/android/jni and launch the script 
-		./gpac_build_android <ANDROID_NDK_DIR>
-		Open Android Studio, click on "open an existing Android Studio project" and put <GPAC_DIR>/applications/osmo4_android_studio and build project
+See https://wiki.gpac.io/GPAC-Build-Guide-for-Android

gpac-2.0.0.tar.gz/build/android/default.properties -> gpac-2.2.0.tar.gz/build/android/default.properties Changed

gpac-2.0.0.tar.gz/build/android/jni/Android.mk -> gpac-2.2.0.tar.gz/build/android/jni/Android.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/Application.mk -> gpac-2.2.0.tar.gz/build/android/jni/Application.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/common.mk -> gpac-2.2.0.tar.gz/build/android/jni/common.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/gpac_build_android -> gpac-2.2.0.tar.gz/build/android/jni/gpac_build_android Changed

@@ -1,75 +1,93 @@
 #!/bin/bash -e
 
-echo -e "\n\03332m If you have problem using this script, read the README in  trunk/gpac/build/android \0330m\n"
-
 NDK=0
 SDK=0
 JDK=0
 REBUILD=0
 CLEAN=0
+#DEBUG="NDK_DEBUG=0"
+DEBUG="NDK_DEBUG=0 APP_OPTIM=release"
+#default should be assembleRelease but not working with gradle 2, to fix 
+GRADLE_FLAG="assembleDebug"
+VERB=""
 
-for i in $*
-do
+#parse options
+for i in $* ; do
 
 #! Check for force rebuild
- if  "$i" = "-force_rebuild" 
-then
+if  "$i" = "-force_rebuild"  ; then
   echo -e "\03331m Usage: $0 Force Rebuild : Activated \0330m"
   REBUILD=1
 fi
 
- if  "$i" = "-clean" 
-then
+if  "$i" = "-clean" ; then
   CLEAN=1
 fi
 
+if  "$i" = "-debug" ; then
+  DEBUG="NDK_DEBUG=1"
+  GRADLE_FLAG="assembleDebug"
+fi
+
+if  "$i" = "-v" ; then
+  VERB="V=1"
+fi
+
 #! Check for the NDK path
- if  "${i%=*}" = "-ndk" 
-then
+if  "${i%=*}" = "-ndk"  ; then
   echo -e "\03331m Usage: $0 Path to Android NDK : Ok \0330m"
   NDK=1
   export PATH="$(echo $i | cut -d"=" -f2):$PATH"
 fi
 
 #! Check for the SDK path
- if  "${i%=*}" = "-sdk" 
-then
+if  "${i%=*}" = "-sdk"  ; then
   echo -e "\03331m Usage: $0 Path to Android SDK : Ok \0330m"
   SDK=1
   export PATH="$(echo $i | cut -d"=" -f2)/tools:$PATH"
   export ANDROID_HOME="$(echo $i | cut -d"=" -f2)/"
-
 fi
 
 #! Check for the JDK path
- if  "${i%=*}" = "-jdk" 
-then
-  echo -e "\03331m Usage: $0 Path to JDK : Ok \0330m"
-  JDK=1
-  export JAVA_HOME="$(echo $i | cut -d"=" -f2)"
+if  "${i%=*}" = "-jdk"  ; then
+ echo -e "\03331m Usage: $0 Path to JDK : Ok \0330m"
+ JDK=1
+ export JAVA_HOME="$(echo $i | cut -d"=" -f2)"
+fi
+
+if  "$i" = "-h" ; then
+echo "Usage: "
+echo "-ndk=PATH: path to android NDK"
+echo "-sdk=PATH: path to android SDK (for command-line build of APK)"
+echo "-jdk=PATH: path to JDK (for command-line build of APK)"
+echo "-force_rebuild: forces clean before build"
+echo "-clean: remove objs and libs"
+echo "-debug: build with debug symbols "
+echo "-h: print this screen"
+echo "-v: verbose build"
+echo ""
+echo -e "\n\03332m If you have problem using this script, check wiki.gpac.io/GPAC-Build-Guide-for-Android or gpac/build/android/README \0330m\n"
+exit 0
 fi
 
 done
+#args
+
 
 if  $NDK -eq 0 
 then
-  echo "\nUsage: $0 PATH_TO_ANDROID_NDK ADDITIONAL_NDK-BUILD arguments : You must give as first argument the directory path of the NDK, add -ndk=PATH_TO_NDK"
+  echo "\nUsage: $0 ndk=PATH_TO_ANDROID_NDK ADDITIONAL_NDK-BUILD arguments : You must give as first argument the directory path of the NDK, add -ndk=PATH_TO_NDK"
   exit 1
 fi
 
 if  $SDK -eq 0 
 then
-  echo -e "\n\03334m Usage: $0 PATH_TO_ANDROID_SDK : You have not give the directory path of SDK. Auto build of Osmo4.apk not possible. Build it with Eclipse or add -sdk=PATH_TO_SDK\0330m"
+  echo -e "\n\03334m You have not give the directory path of SDK, build of GPAC.apk not possible. Build it with Android Studio or add -sdk=PATH_TO_SDK\0330m"
 fi
 
 if  $JDK -eq 0 
 then
-  echo -e "\n\03334m Usage: $0 PATH_TO_JDK : You have not give the directory path of JDK. Auto build of Osmo4.apk not possible. Build it with Eclipse or add -jdk=PATH_TO_JDK \0330m"
-fi
-
-if  $REBUILD -eq 0 
-then
-  echo -e "\n\03333m Usage: $0 Force Rebuild : Add -force_rebuild to rebuild the whole solution \0330m"
+  echo -e "\n\03334m Usage: $0 PATH_TO_JDK : You have not give the directory path of JDK, build of GPAC.apk not possible. Build it with with Android Studio or add -jdk=PATH_TO_JDK \0330m"
 fi
 
 if  -z $JAVA_HOME 
@@ -94,7 +112,7 @@
 export BUILDPATH=$(pwd)
 echo "Current Dir = $BUILDPATH"
 
-echo "Building lib gpac ..."
+echo "Building libgpac"
 cd ../../../
 BASEPATH=$(pwd)
 #check revision.h is here
@@ -107,40 +125,33 @@
 
 if  $CLEAN -eq 1 
 then
-echo -n "Cleaning all from $BUILDPATH..."
+echo -n "Cleaning all from $BUILDPATH"
 ndk-build clean
-cd $BASEPATH/applications/osmo4_android_studio/
+cd $BASEPATH/applications/gpac_android/
 ./gradlew clean
 cd -
 exit 0
 fi
 
-echo -n "Buiding all libs from $BUILDPATH..."
+echo -n "Buiding all libs from $BUILDPATH"
 if  $REBUILD -eq 1 
 then
 ndk-build clean
-cd $BASEPATH/applications/osmo4_android_studio/
+cd $BASEPATH/applications/gpac_android/
 ./gradlew clean
 cd -
-ndk-build -B
+ndk-build -B $VERB $DEBUG
 else
-ndk-build
+ndk-build $VERB $DEBUG
 fi
 echo "OK build successful."
 
-#echo "Copying modules to modules dir..."
 cd ../libs/
-#for i in $(find . -name 'gm*.so')
-#do
-#	echo -n "$i..."
-#	cp "$i" "$BASEPATH/applications/osmo4_android/res/raw/"
-#done
-#echo
-#echo "OK success."
-
-LIBS_DIR="$BASEPATH/applications/osmo4_android_studio/app/src/main/libs"
+
+
+LIBS_DIR="$BASEPATH/applications/gpac_android/src/main/libs"
 mkdir -p $LIBS_DIR
-echo "Copying libs to libs dir $LIBS_DIR ..."
+echo "GPAC.apk: Copying libs to libs dir $LIBS_DIR ..."
 for i in $(find . -name '*.so')
 do
 	echo -n " Copy $i"
@@ -150,26 +161,12 @@
 	cp "$i" "$LIBS_DIR/$i"
 done
 echo
-echo "OK success module for Osmo4."
-
-
-LIBS_DIR="$BASEPATH/applications/mp4box_android/app/src/main/libs"
-mkdir -p $LIBS_DIR
-echo "Copying libs to libs dir $LIBS_DIR ..."
-for i in $(find . $ -name '*.so' $ )
-do
-	echo " Copy $i"
-	TMP_DIR=$(dirname $i)
-	mkdir -p "$LIBS_DIR/$TMP_DIR"
-	cp "$i" "$LIBS_DIR/$i"
-done
-echo
-echo "OK success module for MP4box."
+echo "Done."
 
-LIBS_DIR="$BASEPATH/applications/osmo4_android_studio/app/src/main/libs"
+LIBS_DIR="$BASEPATH/applications/gpac_android/src/main/libs"
 mkdir -p $LIBS_DIR
 cd "$BASEPATH/extra_lib/lib/android"
-echo "Copying all extra libs to $LIBS_DIR ..."
+echo "GPAC.apk: Copying all extra libs to $LIBS_DIR ..."
 for i in $(find . $ -name '*.so' $)
 do
 	echo " Copy $i"
@@ -177,59 +174,35 @@
 	mkdir -p "$LIBS_DIR/$TMP_DIR"
 	cp "$i" "$LIBS_DIR/$i"
 done
-echo "OK success extra lib for Osmo4."
-
-LIBS_DIR="$BASEPATH/applications/mp4box_android/app/src/main/libs"
-mkdir -p $LIBS_DIR
-cd "$BASEPATH/extra_lib/lib/android"
-echo "Copying all extra libs to $LIBS_DIR ..."
-
-for i in $(find . $ -name '*.so' $ )
-do
-	echo " Copy $i"
-	TMP_DIR=$(dirname $i)
-	mkdir -p "$LIBS_DIR/$TMP_DIR"
-	cp "$i" "$LIBS_DIR/$i"
-done
-echo "OK success extra lib MP4box."
+echo "Done."
 
-ASSETS_DIR="$BASEPATH/applications/osmo4_android_studio/app/src/main/assets/"
+ASSETS_DIR="$BASEPATH/applications/gpac_android/src/main/assets/share"
 mkdir -p $ASSETS_DIR
 
-echo "Copying shared resources (GUI, scripts, shaders...) to $ASSETS_DIR ..."
+echo "GPAC.apk: Copying shared resources (GUI, scripts, shaders...) to $ASSETS_DIR ..."
 cp -R "$BASEPATH/share/gui" $ASSETS_DIR
 cp -R "$BASEPATH/share/shaders" $ASSETS_DIR
 cp -R "$BASEPATH/share/scripts" $ASSETS_DIR
 cp -R "$BASEPATH/share/res" $ASSETS_DIR
-echo "OK success shared resources for Osmo4."
+echo "Done."
 
 if  $ $SDK -eq 1 $ -a $ $JDK -eq 1 $ 
 then
 
 	TAG="$(grep "\#define GPAC_VERSION " $BASEPATH/include/gpac/version.h | cut -d "\"" -f 2 )"
 
-	echo "Building osmo4 apk"
-	cd $BASEPATH/applications/osmo4_android_studio/
-	./gradlew assembleDebug
+	echo "Building GPAC.apk"
+	cd $BASEPATH/applications/gpac_android/
+	./gradlew $GRADLE_FLAG
 	cd -
-	if  -f $BASEPATH/osmo4-$TAG-rev$version.apk 
+	if  -f $BASEPATH/gpac-$TAG-rev$version.apk 
 	then
-	echo -e "\nOld Osmo4.apk found. Removing it ..."
-	rm $BASEPATH/osmo4-$TAG-rev$version.apk
+	echo -e "\nOld GPAC.apk found. Removing it ..."
+	rm $BASEPATH/gpac-$TAG-rev$version.apk
 	fi
 
-	cp $BASEPATH/applications/osmo4_android_studio/app/build/outputs/apk/app-debug.apk $BASEPATH/osmo4-$TAG-rev$version.apk
-	echo "OK success Building osmo4 apk"
-
-	echo "Building mp4box apk"
-	cd $BASEPATH/applications/mp4box_android/
-	./gradlew assembleDebug
-	cd -
-
-	# uncomment to copy apk to public build dir
-	# rm -f $BASEPATH/mp4box-$TAG-rev$version.apk
-	# cp $BASEPATH/applications/mp4box_android/app/build/outputs/apk/app-debug.apk $BASEPATH/mp4box-$TAG-rev$version.apk
-	echo "OK success Building mp4box apk"
+	cp $BASEPATH/applications/gpac_android/build/outputs/apk/gpac_android-debug.apk $BASEPATH/gpac-$TAG-rev$version.apk
+	echo "OK success Building GPAC apk"
 else
 	echo "Run project with Android studio to generate APK"
 fi

gpac-2.0.0.tar.gz/build/android/jni/libgpac/Android.mk -> gpac-2.2.0.tar.gz/build/android/jni/libgpac/Android.mk Changed

@@ -1,5 +1,4 @@
 LOCAL_PATH:= $(call my-dir)
-APP_ABI          := armeabi armeabi-v7a x86
 
 include $(CLEAR_VARS)
 include $(LOCAL_PATH)/../common.mk
@@ -15,7 +14,6 @@
 LOCAL_C_INCLUDES 	+= $(LOCAL_PATH)/../../../../extra_lib/include/jpeg/
 LOCAL_C_INCLUDES 	+= $(LOCAL_PATH)/../../../../extra_lib/include/png/
 LOCAL_C_INCLUDES 	+= $(LOCAL_PATH)/../../../../extra_lib/include/faad
-LOCAL_C_INCLUDES 	+= $(LOCAL_PATH)/../../../../extra_lib/include/ffmpeg_android/
 LOCAL_C_INCLUDES 	+= $(LOCAL_PATH)/../../../../extra_lib/include/openjpeg
 +LOCAL_C_INCLUDES 	+= $(LOCAL_PATH)/../../../../extra_lib/include/openssl_android/
 LOCAL_C_INCLUDES 	+= $(LOCAL_PATH)/../../../../modules
@@ -27,16 +25,9 @@
 #ffmpeg
 LOCAL_LDLIBS    += -lavcodec -lavformat -lswresample -lavfilter -lavutil -lavdevice -lswscale
 
-#mediacodec - removed  ljavaenv from original settings
+#mediacodec
 LOCAL_LDLIBS    += -llog -lOpenMAXAL -lmediandk -landroid
 
-#LOCAL_SHARED_LIBRARIES    += -L$(LOCAL_PATH)/../../../../extra_lib/lib/android/$(TARGET_ARCH_ABI)
-#LOCAL_SHARED_LIBRARIES    += -lGLESv2 -ldl
-#LOCAL_SHARED_LIBRARIES    += -lft2 -ljpegdroid -lopenjpeg -lpng -lz
-
-#LOCAL_EXPORT_LDLIBS= -lft2 -ljpeg -lopenjpeg -lpng -lz
-
-
 LOCAL_CFLAGS +=	-DGPAC_HAVE_CONFIG_H
 LOCAL_CFLAGS += -DNO_MALLINFO
 LOCAL_CFLAGS += -DGPAC_CONFIG_ANDROID
@@ -193,6 +184,7 @@
 	../../../../src/filters/encrypt_cenc_isma.c \
 	../../../../src/filters/ff_common.c \
 	../../../../src/filters/ff_avf.c \
+	../../../../src/filters/ff_bsf.c \
 	../../../../src/filters/ff_dec.c \
 	../../../../src/filters/ff_dmx.c \
 	../../../../src/filters/ff_enc.c \
@@ -223,6 +215,7 @@
 	../../../../src/filters/mux_avi.c \
 	../../../../src/filters/mux_gsf.c \
 	../../../../src/filters/mux_isom.c \
+	../../../../src/filters/mux_ogg.c \
 	../../../../src/filters/mux_ts.c \
 	../../../../src/filters/out_audio.c \
 	../../../../src/filters/out_file.c \
@@ -260,13 +253,16 @@
 	../../../../src/filters/tileagg.c \
 	../../../../src/filters/tilesplit.c \
 	../../../../src/filters/tssplit.c \
+	../../../../src/filters/ttml_conv.c \
 	../../../../src/filters/unit_test_filter.c \
+	../../../../src/filters/unframer.c \
 	../../../../src/filters/vcrop.c \
 	../../../../src/filters/vflip.c \
 	../../../../src/filters/write_generic.c \
 	../../../../src/filters/write_nhml.c \
 	../../../../src/filters/write_nhnt.c \
 	../../../../src/filters/write_qcp.c \
+	../../../../src/filters/write_tx3g.c \
 	../../../../src/filters/write_vtt.c \
 	../../../../src/ietf/rtcp.c \
 	../../../../src/ietf/rtp.c \
@@ -395,7 +391,6 @@
 	../../../../src/scene_manager/swf_parse.c \
 	../../../../src/scene_manager/swf_svg.c \
 	../../../../src/scene_manager/text_to_bifs.c \
-	../../../../src/terminal/terminal.c \
 	../../../../src/utils/alloc.c \
 	../../../../src/utils/base_encoding.c \
 	../../../../src/utils/bitstream.c \
@@ -419,6 +414,7 @@
 	../../../../src/utils/path2d.c \
 	../../../../src/utils/path2d_stroker.c \
 	../../../../src/utils/sha1.c \
+	../../../../src/utils/sha256.c \
 	../../../../src/utils/token.c \
 	../../../../src/utils/uni_bidi.c \
 	../../../../src/utils/unicode.c \

gpac-2.0.0.tar.gz/build/android/jni/libgpac/Application.mk -> gpac-2.2.0.tar.gz/build/android/jni/libgpac/Application.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/modules/Android.mk -> gpac-2.2.0.tar.gz/build/android/jni/modules/Android.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/modules/Application.mk -> gpac-2.2.0.tar.gz/build/android/jni/modules/Application.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/modules/base.mk -> gpac-2.2.0.tar.gz/build/android/jni/modules/base.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/wrapper/Android.mk -> gpac-2.2.0.tar.gz/build/android/jni/wrapper/Android.mk Changed

gpac-2.0.0.tar.gz/build/android/jni/wrapper/Application.mk -> gpac-2.2.0.tar.gz/build/android/jni/wrapper/Application.mk Changed

gpac-2.2.0.tar.gz/build/deprecated Added

gpac-2.2.0.tar.gz/build/deprecated/msvc14 Added

gpac-2.2.0.tar.gz/build/deprecated/msvc14/mp4client.vcxproj Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian Added

gpac-2.2.0.tar.gz/build/deprecated/symbian/Icons.mk Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/aac_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/amr_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/bifs_dec.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/bld.inf Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/ctx_load.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/dummy_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/epoc_hw.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/ffmpeg_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/ft_font.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/gpac_module_symbianU.def Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/img_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/ismacryp.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/isom_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/laser_dec.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/libgpac.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/libgpac_symbianU.def Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/module_base.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/mp3_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/odf_dec.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/osmo4.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/rtp_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/saf_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/sis Added

gpac-2.2.0.tar.gz/build/deprecated/symbian/sis/GPAC.cfg Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/sis/backup_registration.xml Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/sis/gpac.cer Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/sis/gpac.key Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/sis/osmo4_gcce.pkg Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/sis/osmo4_thumb.pkg Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/soft_raster.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/svg_in.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/symbian_dll_entry.cpp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/timedtext.mmp Changed

gpac-2.2.0.tar.gz/build/deprecated/symbian/xvid_dec.mmp Changed

gpac-2.0.0.tar.gz/build/msvc14/gpac.sln -> gpac-2.2.0.tar.gz/build/msvc14/gpac.sln Changed

@@ -2,8 +2,6 @@
 # Visual Studio 14
 VisualStudioVersion = 14.0.25420.1
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mp4client", "mp4client.vcxproj", "{A35D99BF-D72D-4F56-99A1-97249B22BCE2}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dx_hw", "dx_hw.vcxproj", "{B64736BD-9245-4F40-961D-EB9822265764}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ft_font", "ft_font.vcxproj", "{042D3628-67F3-4B5C-8BC0-CD9AFA416974}"
@@ -50,18 +48,6 @@
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Debug - MP4Box_only|Win32.ActiveCfg = Debug|Win32
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Debug - MP4Box_only|x64.ActiveCfg = Debug|x64
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Debug|Win32.ActiveCfg = Debug|Win32
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Debug|Win32.Build.0 = Debug|Win32
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Debug|x64.ActiveCfg = Debug|x64
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Debug|x64.Build.0 = Debug|x64
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Release - MP4Box_only|Win32.ActiveCfg = Release|Win32
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Release - MP4Box_only|x64.ActiveCfg = Release|x64
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Release|Win32.ActiveCfg = Release|Win32
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Release|Win32.Build.0 = Release|Win32
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Release|x64.ActiveCfg = Release|x64
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2}.Release|x64.Build.0 = Release|x64
 		{B64736BD-9245-4F40-961D-EB9822265764}.Debug - MP4Box_only|Win32.ActiveCfg = Debug|Win32
 		{B64736BD-9245-4F40-961D-EB9822265764}.Debug - MP4Box_only|x64.ActiveCfg = Debug|x64
 		{B64736BD-9245-4F40-961D-EB9822265764}.Debug|Win32.ActiveCfg = Debug|Win32
@@ -207,7 +193,6 @@
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{A35D99BF-D72D-4F56-99A1-97249B22BCE2} = {B7FFDE3D-6BF0-4EE1-B6FD-BD15A503DBBA}
 		{B64736BD-9245-4F40-961D-EB9822265764} = {6274F5D2-A9CB-4DF9-BF9E-818416ACD347}
 		{042D3628-67F3-4B5C-8BC0-CD9AFA416974} = {6274F5D2-A9CB-4DF9-BF9E-818416ACD347}
 		{233014D5-F6E5-419D-8757-FA9CE7337088} = {BC1A9F4D-C716-467F-8B11-6F58FB74FF3B}

gpac-2.0.0.tar.gz/build/msvc14/gpac.vcxproj -> gpac-2.2.0.tar.gz/build/msvc14/gpac.vcxproj Changed

gpac-2.0.0.tar.gz/build/msvc14/libgpac.vcxproj -> gpac-2.2.0.tar.gz/build/msvc14/libgpac.vcxproj Changed

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 <ItemGroup Label="ProjectConfigurations">
 <ProjectConfiguration Include="Debug - MP4Box_only|Win32">
@@ -77,7 +77,6 @@
 <ClInclude Include="..\..\include\gpac\internal\scenegraph_dev.h" />
 <ClInclude Include="..\..\include\gpac\internal\smjs_api.h" />
 <ClInclude Include="..\..\include\gpac\internal\swf_dev.h" />
- <ClInclude Include="..\..\include\gpac\internal\terminal_dev.h" />
 <ClInclude Include="..\..\include\gpac\internal\vobsub.h" />
 <ClInclude Include="..\..\include\gpac\crypt_tools.h" />
 <ClInclude Include="..\..\include\gpac\iso639.h" />
@@ -105,7 +104,6 @@
 <ClInclude Include="..\..\include\gpac\nodes_mpeg4.h" />
 <ClInclude Include="..\..\include\gpac\nodes_svg.h" />
 <ClInclude Include="..\..\include\gpac\nodes_x3d.h" />
- <ClInclude Include="..\..\include\gpac\options.h" />
 <ClInclude Include="..\..\include\gpac\path2d.h" />
 <ClInclude Include="..\..\include\gpac\Remotery.h" />
 <ClInclude Include="..\..\include\gpac\revision.h" />
@@ -118,13 +116,10 @@
 <ClInclude Include="..\..\include\gpac\setup.h" />
 <ClInclude Include="..\..\include\gpac\svg_types.h" />
 <ClInclude Include="..\..\include\gpac\sync_layer.h" />
- <ClInclude Include="..\..\include\gpac\terminal.h" />
- <ClInclude Include="..\..\include\gpac\term_info.h" />
 <ClInclude Include="..\..\include\gpac\thread.h" />
 <ClInclude Include="..\..\include\gpac\token.h" />
 <ClInclude Include="..\..\include\gpac\tools.h" />
 <ClInclude Include="..\..\include\gpac\unicode.h" />
- <ClInclude Include="..\..\include\gpac\user.h" />
 <ClInclude Include="..\..\include\gpac\utf.h" />
 <ClInclude Include="..\..\include\gpac\version.h" />
 <ClInclude Include="..\..\include\gpac\webvtt.h" />
@@ -289,6 +284,7 @@
 <ClCompile Include="..\..\src\filters\enc_png.c" />
 <ClCompile Include="..\..\src\filters\ff_common.c" />
 <ClCompile Include="..\..\src\filters\ff_avf.c" />
+ <ClCompile Include="..\..\src\filters\ff_bsf.c" />
 <ClCompile Include="..\..\src\filters\ff_dec.c" />
 <ClCompile Include="..\..\src\filters\ff_dmx.c" />
 <ClCompile Include="..\..\src\filters\ff_enc.c" />
@@ -320,6 +316,7 @@
 <ClCompile Include="..\..\src\filters\mux_avi.c" />
 <ClCompile Include="..\..\src\filters\mux_gsf.c" />
 <ClCompile Include="..\..\src\filters\mux_isom.c" />
+ <ClCompile Include="..\..\src\filters\mux_ogg.c" />
 <ClCompile Include="..\..\src\filters\mux_ts.c" />
 <ClCompile Include="..\..\src\filters\out_audio.c" />
 <ClCompile Include="..\..\src\filters\out_file.c" />
@@ -359,13 +356,16 @@
 <ClCompile Include="..\..\src\filters\tileagg.c" />
 <ClCompile Include="..\..\src\filters\tilesplit.c" />
 <ClCompile Include="..\..\src\filters\tssplit.c" />
+ <ClCompile Include="..\..\src\filters\ttml_conv.c" />
 <ClCompile Include="..\..\src\filters\unit_test_filter.c" />
+ <ClCompile Include="..\..\src\filters\unframer.c" />
 <ClCompile Include="..\..\src\filters\vcrop.c" />
 <ClCompile Include="..\..\src\filters\vflip.c" />
 <ClCompile Include="..\..\src\filters\write_generic.c" />
 <ClCompile Include="..\..\src\filters\write_nhml.c" />
 <ClCompile Include="..\..\src\filters\write_nhnt.c" />
 <ClCompile Include="..\..\src\filters\write_qcp.c" />
+ <ClCompile Include="..\..\src\filters\write_tx3g.c" />
 <ClCompile Include="..\..\src\filters\write_vtt.c" />
 <ClCompile Include="..\..\src\filter_core\filter.c" />
 <ClCompile Include="..\..\src\filter_core\filter_pck.c" />
@@ -554,7 +554,6 @@
 <ClCompile Include="..\..\src\scene_manager\swf_parse.c" />
 <ClCompile Include="..\..\src\scene_manager\swf_svg.c" />
 <ClCompile Include="..\..\src\scene_manager\text_to_bifs.c" />
- <ClCompile Include="..\..\src\terminal\terminal.c" />
 <ClCompile Include="..\..\src\utils\alloc.c" />
 <ClCompile Include="..\..\src\utils\base_encoding.c" />
 <ClCompile Include="..\..\src\utils\bitstream.c" />
@@ -580,6 +579,7 @@
 <ClCompile Include="..\..\src\utils\path2d_stroker.c" />
 <ClCompile Include="..\..\src\utils\Remotery.c" />
 <ClCompile Include="..\..\src\utils\sha1.c" />
+ <ClCompile Include="..\..\src\utils\sha256.c" />
 <ClCompile Include="..\..\src\utils\token.c" />
 <ClCompile Include="..\..\src\utils\unicode.c" />
 <ClCompile Include="..\..\src\utils\uni_bidi.c" />
@@ -1007,4 +1007,4 @@
 <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
 <ImportGroup Label="ExtensionTargets">
 </ImportGroup>
-</Project>
\ No newline at end of file
+</Project>

gpac-2.0.0.tar.gz/build/msvc14/libgpac.vcxproj.filters -> gpac-2.2.0.tar.gz/build/msvc14/libgpac.vcxproj.filters Changed

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 <ItemGroup>
 <Filter Include="include">
@@ -34,9 +34,6 @@
 <Filter Include="utils">
 <UniqueIdentifier>{8bbc563e-abf0-404a-9661-85d8795b63e1}</UniqueIdentifier>
 </Filter>
- <Filter Include="terminal">
- <UniqueIdentifier>{a7234dfd-5749-46dc-8ee2-586084f8d11d}</UniqueIdentifier>
- </Filter>
 <Filter Include="scenegraph">
 <UniqueIdentifier>{ceeb1cac-c751-485b-b5f3-abec90144298}</UniqueIdentifier>
 </Filter>
@@ -168,9 +165,6 @@
 <ClInclude Include="..\..\include\gpac\internal\swf_dev.h">
 <Filter>include\internal</Filter>
 </ClInclude>
- <ClInclude Include="..\..\include\gpac\internal\terminal_dev.h">
- <Filter>include\internal</Filter>
- </ClInclude>
 <ClInclude Include="..\..\include\gpac\internal\vobsub.h">
 <Filter>include\internal</Filter>
 </ClInclude>
@@ -321,9 +315,6 @@
 <ClInclude Include="..\..\include\gpac\nodes_x3d.h">
 <Filter>include</Filter>
 </ClInclude>
- <ClInclude Include="..\..\include\gpac\options.h">
- <Filter>include</Filter>
- </ClInclude>
 <ClInclude Include="..\..\include\gpac\path2d.h">
 <Filter>include</Filter>
 </ClInclude>
@@ -357,12 +348,6 @@
 <ClInclude Include="..\..\include\gpac\sync_layer.h">
 <Filter>include</Filter>
 </ClInclude>
- <ClInclude Include="..\..\include\gpac\term_info.h">
- <Filter>include</Filter>
- </ClInclude>
- <ClInclude Include="..\..\include\gpac\terminal.h">
- <Filter>include</Filter>
- </ClInclude>
 <ClInclude Include="..\..\include\gpac\thread.h">
 <Filter>include</Filter>
 </ClInclude>
@@ -375,9 +360,6 @@
 <ClInclude Include="..\..\include\gpac\unicode.h">
 <Filter>include</Filter>
 </ClInclude>
- <ClInclude Include="..\..\include\gpac\user.h">
- <Filter>include</Filter>
- </ClInclude>
 <ClInclude Include="..\..\include\gpac\utf.h">
 <Filter>include</Filter>
 </ClInclude>
@@ -1010,9 +992,6 @@
 <ClCompile Include="..\..\src\scenegraph\xml_ns.c">
 <Filter>scenegraph</Filter>
 </ClCompile>
- <ClCompile Include="..\..\src\terminal\terminal.c">
- <Filter>terminal</Filter>
- </ClCompile>
 <ClCompile Include="..\..\src\utils\alloc.c">
 <Filter>utils</Filter>
 </ClCompile>
@@ -1073,6 +1052,9 @@
 <ClCompile Include="..\..\src\utils\sha1.c">
 <Filter>utils</Filter>
 </ClCompile>
+ <ClCompile Include="..\..\src\utils\sha256.c">
+ <Filter>utils</Filter>
+ </ClCompile>
 <ClCompile Include="..\..\src\utils\token.c">
 <Filter>utils</Filter>
 </ClCompile>
@@ -1325,6 +1307,9 @@
 <ClCompile Include="..\..\src\filters\mux_isom.c">
 <Filter>filters</Filter>
 </ClCompile>
+ <ClCompile Include="..\..\src\filters\mux_ogg.c">
+ <Filter>filters</Filter>
+ </ClCompile>
 <ClCompile Include="..\..\src\filters\out_audio.c">
 <Filter>filters</Filter>
 </ClCompile>
@@ -1403,6 +1388,9 @@
 <ClCompile Include="..\..\src\filters\unit_test_filter.c">
 <Filter>filters</Filter>
 </ClCompile>
+ <ClCompile Include="..\..\src\filters\unframer.c">
+ <Filter>filters</Filter>
+ </ClCompile>
 <ClCompile Include="..\..\src\filters\vcrop.c">
 <Filter>filters</Filter>
 </ClCompile>
@@ -1583,6 +1571,9 @@
 <ClCompile Include="..\..\src\filters\ff_avf.c">
 <Filter>filters</Filter>
 </ClCompile>
+ <ClCompile Include="..\..\src\filters\ff_bsf.c">
+ <Filter>filters</Filter>
+ </ClCompile>
 <ClCompile Include="..\..\src\evg\raster3d.c">
 <Filter>evg</Filter>
 </ClCompile>
@@ -1592,6 +1583,12 @@
 <ClCompile Include="..\..\src\filters\tssplit.c">
 <Filter>filters</Filter>
 </ClCompile>
+ <ClCompile Include="..\..\src\filters\ttml_conv.c">
+ <Filter>filters</Filter>
+ </ClCompile>
+ <ClCompile Include="..\..\src\filters\write_tx3g.c">
+ <Filter>filters</Filter>
+ </ClCompile>
 <ClCompile Include="..\..\src\filters\dec_mediacodec.c">
 <Filter>filters</Filter>
 </ClCompile>
@@ -1604,4 +1601,4 @@
 <Filter>filters</Filter>
 </None>
 </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>

gpac-2.0.0.tar.gz/build/msvc14/mp4box.vcxproj -> gpac-2.2.0.tar.gz/build/msvc14/mp4box.vcxproj Changed

@@ -247,6 +247,9 @@
 <Bscmake>
 <SuppressStartupBanner>true</SuppressStartupBanner>
 </Bscmake>
+ <Manifest>
+ <AdditionalManifestFiles>$(SolutionDir)gpac_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+ </Manifest>
 </ItemDefinitionGroup>
 <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 <Midl>
@@ -336,6 +339,9 @@
 <Bscmake>
 <SuppressStartupBanner>true</SuppressStartupBanner>
 </Bscmake>
+ <Manifest>
+ <AdditionalManifestFiles>$(SolutionDir)gpac_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+ </Manifest>
 </ItemDefinitionGroup>
 <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 <Midl>
@@ -426,6 +432,9 @@
 <Command>
 </Command>
 </PostBuildEvent>
+ <Manifest>
+ <AdditionalManifestFiles>$(SolutionDir)gpac_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+ </Manifest>
 </ItemDefinitionGroup>
 <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 <Midl>
@@ -513,6 +522,9 @@
 <Command>
 </Command>
 </PostBuildEvent>
+ <Manifest>
+ <AdditionalManifestFiles>$(SolutionDir)gpac_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+ </Manifest>
 </ItemDefinitionGroup>
 <ItemGroup>
 <ClCompile Include="..\..\applications\mp4box\filedump.c">
@@ -552,7 +564,7 @@
 <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release - MP4Box_only|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
 </ClCompile>
 <ClCompile Include="..\..\applications\mp4box\live.c" />
- <ClCompile Include="..\..\applications\mp4box\main.c">
+ <ClCompile Include="..\..\applications\mp4box\mp4box.c">
 <Optimization Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Disabled</Optimization>
 <Optimization Condition="'$(Configuration)|$(Platform)'=='Release - MP4Box_only|x64'">Disabled</Optimization>
 <Optimization Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Disabled</Optimization>
@@ -573,6 +585,12 @@
 <Project>{233014d5-f6e5-419d-8757-fa9ce7337088}</Project>
 </ProjectReference>
 </ItemGroup>
+ <ItemGroup>
+ <ResourceCompile Include="..\..\applications\gpac\gpac.rc" />
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="..\..\applications\gpac\resource.h" />
+ </ItemGroup>
 <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
 <ImportGroup Label="ExtensionTargets">
 </ImportGroup>

gpac-2.0.0.tar.gz/build/xcode/generate_ios.sh -> gpac-2.2.0.tar.gz/build/xcode/generate_ios.sh Changed

@@ -10,9 +10,9 @@
 rev="$REVISION-$BRANCH"
 if "$rev" != "" 
 then
-	sed 's/<string>.*<\/string>/<string>'"$version"'<\/string>/' ../../applications/osmo4_ios/osmo4ios-Info.plist > ../../applications/osmo4_ios/osmo4ios-Info.plist.new
-	sed 's/<string>.*<\/string>/<string>'"$rev"'<\/string>/' ../../applications/osmo4_ios/osmo4ios-Info.plist.new > ../../applications/osmo4_ios/osmo4ios-Info.plist
-	rm ../../applications/osmo4_ios/osmo4ios-Info.plist.new
+	sed 's/<string>.*<\/string>/<string>'"$version"'<\/string>/' ../../applications/gpac/ios-Info.plist > ../../applications/gpac/ios-Info.plist.new
+	sed 's/<string>.*<\/string>/<string>'"$rev"'<\/string>/' ../../applications/gpac/ios-Info.plist.new > ../../applications/gpac/ios-Info.plist
+	rm ../../applications/gpac/ios-Info.plist.new
 fi
 
 if "$rev" != "" 
@@ -23,21 +23,21 @@
 	full_version="$version-$(date +%Y%m%d)"
 fi
 
-echo "*** Compile and archive osmo4ios ***"
-xcodebuild archive -project gpac4ios.xcodeproj -scheme osmo4ios -archivePath osmo4ios.xcarchive
+echo "*** Compile and archive gpac4ios ***"
+xcodebuild archive -project gpac4ios.xcodeproj -scheme gpac4ios -archivePath gpac4ios.xcarchive
 if $? != 0 ; then
 	exit 1
 fi
 
 echo "*** Generate IPA ***"
 mkdir -p Payload
-mv osmo4ios.xcarchive/Products/Applications/osmo4ios.app Payload/
+mv gpac4ios.xcarchive/Products/Applications/gpac4ios.app Payload/
 if ! -d "../../bin/iOS" ; then
 	mkdir -p "../../bin/iOS"
 fi
-zip -r "../../bin/iOS/osmo4-$full_version-ios.ipa" Payload
+zip -r "../../bin/iOS/gpac-$full_version-ios.ipa" Payload
 rm -rf Payload
-rm -rf osmo4ios.xcarchive
+rm -rf gpac4ios.xcarchive
 #git pull
 
-echo "*** GPAC generation for iOS completed ($full_version)! ***"
+echo "*** GPAC generation for iOS completed ($full_version) ! ***"

gpac-2.0.0.tar.gz/build/xcode/gpac.xcodeproj/project.pbxproj -> gpac-2.2.0.tar.gz/build/xcode/gpac.xcodeproj/project.pbxproj Changed

@@ -7,7 +7,6 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		28C5AA801A16277200372C59 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 28C5AA741A15FF0000372C59 /* Carbon.framework */; };
 		920100B018D5A444003D1ACA /* arith_decoder.c in Sources */ = {isa = PBXBuildFile; fileRef = 9201FF8A18D5A444003D1ACA /* arith_decoder.c */; };
 		920100B118D5A444003D1ACA /* bifs_codec.c in Sources */ = {isa = PBXBuildFile; fileRef = 9201FF8B18D5A444003D1ACA /* bifs_codec.c */; };
 		920100B218D5A444003D1ACA /* bifs_node_tables.c in Sources */ = {isa = PBXBuildFile; fileRef = 9201FF8C18D5A444003D1ACA /* bifs_node_tables.c */; };
@@ -214,7 +213,6 @@
 		924E805D206D357A00AB580F /* reframe_rawvid.c in Sources */ = {isa = PBXBuildFile; fileRef = 924E805C206D357A00AB580F /* reframe_rawvid.c */; };
 		924E805F206D427A00AB580F /* reframe_rawpcm.c in Sources */ = {isa = PBXBuildFile; fileRef = 924E805E206D427A00AB580F /* reframe_rawpcm.c */; };
 		924FEE821BA6C63A003F77A6 /* iff.c in Sources */ = {isa = PBXBuildFile; fileRef = 924FEE811BA6C63A003F77A6 /* iff.c */; };
-		9251CA8A1E9D3E960089DDC6 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = 9251CA881E9D3E2B0089DDC6 /* main.c */; };
 		9251E5442524EB9800CEB84D /* reframe_mhas.c in Sources */ = {isa = PBXBuildFile; fileRef = 9251E5432524EB9700CEB84D /* reframe_mhas.c */; };
 		9256B38B208662FC00088537 /* mux_ts.c in Sources */ = {isa = PBXBuildFile; fileRef = 9256B38A208662FB00088537 /* mux_ts.c */; };
 		9257307F2056948D009DB328 /* rewrite_adts.c in Sources */ = {isa = PBXBuildFile; fileRef = 9257307D2056948D009DB328 /* rewrite_adts.c */; };
@@ -231,13 +229,18 @@
 		925975042215BA3A0007E02B /* rast_soft.h in Headers */ = {isa = PBXBuildFile; fileRef = 925974FB2215BA3A0007E02B /* rast_soft.h */; };
 		925975052215BA3A0007E02B /* raster_yuv.c in Sources */ = {isa = PBXBuildFile; fileRef = 925974FC2215BA3A0007E02B /* raster_yuv.c */; };
 		925975082215BAC30007E02B /* evg.h in Headers */ = {isa = PBXBuildFile; fileRef = 925975072215BAC30007E02B /* evg.h */; };
+		925A760F292F965D00664F38 /* sha256.c in Sources */ = {isa = PBXBuildFile; fileRef = 925A760E292F965D00664F38 /* sha256.c */; };
 		925CE3451FA2E642004EC6F5 /* decrypt_cenc_isma.c in Sources */ = {isa = PBXBuildFile; fileRef = 925CE3441FA2E641004EC6F5 /* decrypt_cenc_isma.c */; };
 		925E564C2798B87300BBD530 /* bs_agg.c in Sources */ = {isa = PBXBuildFile; fileRef = 925E564B2798B87300BBD530 /* bs_agg.c */; };
+		926209BF27F6026A0024415A /* write_tx3g.c in Sources */ = {isa = PBXBuildFile; fileRef = 926209BE27F6026A0024415A /* write_tx3g.c */; };
+		926209C127FC630A0024415A /* ttml_conv.c in Sources */ = {isa = PBXBuildFile; fileRef = 926209C027FC630A0024415A /* ttml_conv.c */; };
 		926245981FD691A000184072 /* ff_common.h in Headers */ = {isa = PBXBuildFile; fileRef = 926245971FD691A000184072 /* ff_common.h */; };
 		9265307A27AD295200DEBE4B /* restamp.c in Sources */ = {isa = PBXBuildFile; fileRef = 9265307927AD295200DEBE4B /* restamp.c */; };
 		926656C41F7D3DF700299CC6 /* dec_theora.c in Sources */ = {isa = PBXBuildFile; fileRef = 926656C31F7D3DF700299CC6 /* dec_theora.c */; };
 		926656C61F7D45F700299CC6 /* dmx_ogg.c in Sources */ = {isa = PBXBuildFile; fileRef = 926656C51F7D45F700299CC6 /* dmx_ogg.c */; };
 		926656C81F7E92C200299CC6 /* dmx_m2ts.c in Sources */ = {isa = PBXBuildFile; fileRef = 926656C71F7E92C200299CC6 /* dmx_m2ts.c */; };
+		92683EBF2811E4980034D320 /* compositor_tools.c in Sources */ = {isa = PBXBuildFile; fileRef = 92683EBE2811E4980034D320 /* compositor_tools.c */; };
+		92683EC128129D3D0034D320 /* gpac_help.c in Sources */ = {isa = PBXBuildFile; fileRef = 92683EC028129D3D0034D320 /* gpac_help.c */; };
 		926998B41FEACE8F00AA759D /* dmx_vobsub.c in Sources */ = {isa = PBXBuildFile; fileRef = 926998B31FEACE8F00AA759D /* dmx_vobsub.c */; };
 		926C7E642019D75300E90AF6 /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 92A7E95E2003BACB000C22DE /* AudioToolbox.framework */; };
 		926C7E652019D76300E90AF6 /* Security.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 92A7E9602003BAE8000C22DE /* Security.framework */; };
@@ -247,6 +250,7 @@
 		926F15531FE867B000C40779 /* write_vtt.c in Sources */ = {isa = PBXBuildFile; fileRef = 926F15521FE867B000C40779 /* write_vtt.c */; };
 		926F15551FE964D000C40779 /* write_nhnt.c in Sources */ = {isa = PBXBuildFile; fileRef = 926F15541FE964CF00C40779 /* write_nhnt.c */; };
 		926F15571FE986B000C40779 /* write_nhml.c in Sources */ = {isa = PBXBuildFile; fileRef = 926F15561FE986B000C40779 /* write_nhml.c */; };
+		9272B50427E34CDF00D9D304 /* mux_ogg.c in Sources */ = {isa = PBXBuildFile; fileRef = 9272B50327E34CDF00D9D304 /* mux_ogg.c */; };
 		9273463323506D370081AF74 /* storage.c in Sources */ = {isa = PBXBuildFile; fileRef = 9273463223506D370081AF74 /* storage.c */; };
 		9274295824647AB8009ADD8D /* bsrw.c in Sources */ = {isa = PBXBuildFile; fileRef = 9274295724647AB8009ADD8D /* bsrw.c */; };
 		92754D60207D24F600170383 /* filelist.c in Sources */ = {isa = PBXBuildFile; fileRef = 92754D5F207D24F600170383 /* filelist.c */; };
@@ -263,6 +267,8 @@
 		9288E8641FB1BF07005460C5 /* reframe_mpgvid.c in Sources */ = {isa = PBXBuildFile; fileRef = 9288E8631FB1BF07005460C5 /* reframe_mpgvid.c */; };
 		9289D9F51FDEFFCE00C24F83 /* out_file.c in Sources */ = {isa = PBXBuildFile; fileRef = 9289D9F41FDEFFCD00C24F83 /* out_file.c */; };
 		928A7F812059372C00E02E89 /* out_video.c in Sources */ = {isa = PBXBuildFile; fileRef = 928A7F802059372C00E02E89 /* out_video.c */; };
+		928E0BD628E2FC1900F2BA27 /* unframer.c in Sources */ = {isa = PBXBuildFile; fileRef = 928E0BD528E2FC1800F2BA27 /* unframer.c */; };
+		928E0BDA28E328A100F2BA27 /* ff_bsf.c in Sources */ = {isa = PBXBuildFile; fileRef = 928E0BD928E328A100F2BA27 /* ff_bsf.c */; };
 		928E7AC51FB9F2B800D2470E /* dmx_nhnt.c in Sources */ = {isa = PBXBuildFile; fileRef = 928E7AC41FB9F2B800D2470E /* dmx_nhnt.c */; };
 		928E7AC71FB9FCDD00D2470E /* dmx_nhml.c in Sources */ = {isa = PBXBuildFile; fileRef = 928E7AC61FB9FCDD00D2470E /* dmx_nhml.c */; };
 		928E9F9F250F5BA6000C0631 /* route.h in Headers */ = {isa = PBXBuildFile; fileRef = 928E9F9E250F5BA6000C0631 /* route.h */; };
@@ -275,7 +281,6 @@
 		9293839C23548C8F00AAAFA8 /* webgl.c in Sources */ = {isa = PBXBuildFile; fileRef = 9293839B23548C8F00AAAFA8 /* webgl.c */; };
 		9293839E2354A10800AAAFA8 /* webgl.h in Headers */ = {isa = PBXBuildFile; fileRef = 9293839D2354A10800AAAFA8 /* webgl.h */; };
 		9296BF2222CF7F5300DC9742 /* reframe_flac.c in Sources */ = {isa = PBXBuildFile; fileRef = 9296BF2122CF7F5300DC9742 /* reframe_flac.c */; };
-		929867752355DED1008A2CC6 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = 927AACF61E44ED58008C8E69 /* main.c */; };
 		9298677D235A146E008A2CC6 /* gltools.c in Sources */ = {isa = PBXBuildFile; fileRef = 9298677C235A146D008A2CC6 /* gltools.c */; };
 		929DE7472417DC020056AFA7 /* gzio.c in Sources */ = {isa = PBXBuildFile; fileRef = 929DE7462417DC020056AFA7 /* gzio.c */; };
 		92A08DBD20D946B7003589FF /* tileagg.c in Sources */ = {isa = PBXBuildFile; fileRef = 92A08DBC20D946B6003589FF /* tileagg.c */; };
@@ -292,7 +297,6 @@
 		92B2A4AB229D64EF002A65A7 /* hevcsplit.c in Sources */ = {isa = PBXBuildFile; fileRef = 92B2A4A9229D64EF002A65A7 /* hevcsplit.c */; };
 		92B9A5071F83FD7800A24FE4 /* in_dvb4linux.c in Sources */ = {isa = PBXBuildFile; fileRef = 92B9A5061F83FD7700A24FE4 /* in_dvb4linux.c */; };
 		92B9A50A1F840A6800A24FE4 /* dec_vtb.c in Sources */ = {isa = PBXBuildFile; fileRef = 92B9A5081F840A6700A24FE4 /* dec_vtb.c */; };
-		92B9A5111F8660B500A24FE4 /* terminal.c in Sources */ = {isa = PBXBuildFile; fileRef = 92B9A50C1F8660B500A24FE4 /* terminal.c */; };
 		92B9A5661F8660D700A24FE4 /* svg_font.c in Sources */ = {isa = PBXBuildFile; fileRef = 92B9A5161F8660CD00A24FE4 /* svg_font.c */; };
 		92B9A5671F8660D700A24FE4 /* mpeg4_geometry_ifs2d.c in Sources */ = {isa = PBXBuildFile; fileRef = 92B9A5171F8660CE00A24FE4 /* mpeg4_geometry_ifs2d.c */; };
 		92B9A5681F8660D700A24FE4 /* mpeg4_layer_3d.c in Sources */ = {isa = PBXBuildFile; fileRef = 92B9A5181F8660CE00A24FE4 /* mpeg4_layer_3d.c */; };
@@ -465,7 +469,6 @@
 		92BBFCF01A7122AD006A7735 /* nodes_mpeg4.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC8F1A7122AD006A7735 /* nodes_mpeg4.h */; };
 		92BBFCF11A7122AD006A7735 /* nodes_svg.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC901A7122AD006A7735 /* nodes_svg.h */; };
 		92BBFCF21A7122AD006A7735 /* nodes_x3d.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC911A7122AD006A7735 /* nodes_x3d.h */; };
-		92BBFCF41A7122AD006A7735 /* options.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC931A7122AD006A7735 /* options.h */; };
 		92BBFCF51A7122AD006A7735 /* path2d.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC941A7122AD006A7735 /* path2d.h */; };
 		92BBFCF61A7122AD006A7735 /* revision.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC951A7122AD006A7735 /* revision.h */; };
 		92BBFCF81A7122AD006A7735 /* rtp_streamer.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC971A7122AD006A7735 /* rtp_streamer.h */; };
@@ -477,12 +480,9 @@
 		92BBFCFE1A7122AD006A7735 /* setup.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC9D1A7122AD006A7735 /* setup.h */; };
 		92BBFCFF1A7122AD006A7735 /* svg_types.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC9E1A7122AD006A7735 /* svg_types.h */; };
 		92BBFD001A7122AD006A7735 /* sync_layer.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFC9F1A7122AD006A7735 /* sync_layer.h */; };
-		92BBFD011A7122AD006A7735 /* term_info.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA01A7122AD006A7735 /* term_info.h */; };
-		92BBFD021A7122AD006A7735 /* terminal.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA11A7122AD006A7735 /* terminal.h */; };
 		92BBFD031A7122AD006A7735 /* thread.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA21A7122AD006A7735 /* thread.h */; };
 		92BBFD041A7122AD006A7735 /* token.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA31A7122AD006A7735 /* token.h */; };
 		92BBFD051A7122AD006A7735 /* tools.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA41A7122AD006A7735 /* tools.h */; };
-		92BBFD071A7122AD006A7735 /* user.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA61A7122AD006A7735 /* user.h */; };
 		92BBFD081A7122AD006A7735 /* utf.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA71A7122AD006A7735 /* utf.h */; };
 		92BBFD091A7122AD006A7735 /* version.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA81A7122AD006A7735 /* version.h */; };
 		92BBFD0A1A7122AD006A7735 /* webvtt.h in Headers */ = {isa = PBXBuildFile; fileRef = 92BBFCA91A7122AD006A7735 /* webvtt.h */; };
@@ -493,15 +493,16 @@
 		92BD556D205AE99A007C4C06 /* OpenGL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 92B02F4E1DD2004400F85E77 /* OpenGL.framework */; };
 		92BD5571205AE9BD007C4C06 /* AppKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 92BD5570205AE9BD007C4C06 /* AppKit.framework */; };
 		92BE50A318D632DA00AA59D8 /* libgpac.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 9201F93718D5A38A003D1ACA /* libgpac.dylib */; };
-		92BE50D518D6D66C00AA59D8 /* libgpac.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 9201F93718D5A38A003D1ACA /* libgpac.dylib */; };
 		92C0F37E21EC7BB0002961C8 /* out_rtp.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C0F37D21EC7BB0002961C8 /* out_rtp.c */; };
 		92C236DD25769BA500CD59A9 /* tilesplit.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C236DC25769BA500CD59A9 /* tilesplit.c */; };
 		92C23723257841A100CD59A9 /* CoreAudio.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 28C5AA6C1A15FE4A00372C59 /* CoreAudio.framework */; };
 		92C403DD2181F17E00331F39 /* dec_openhevc.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C403DC2181F17E00331F39 /* dec_openhevc.c */; };
 		92C403EA2181F57600331F39 /* libgpac.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 9201F93718D5A38A003D1ACA /* libgpac.dylib */; };
+		92C69C5C281315B400051866 /* carbon_hook.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C69C5B281315B400051866 /* carbon_hook.c */; };
 		92CDAEE81FBD9D0C0007C1C0 /* reframe_nalu.c in Sources */ = {isa = PBXBuildFile; fileRef = 92CDAEE71FBD9D0C0007C1C0 /* reframe_nalu.c */; };
+		92D15559282BF1BA00AE8BC9 /* gpac.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D15558282BF1BA00AE8BC9 /* gpac.c */; };
+		92D1555B282BF1D400AE8BC9 /* mp4box.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D1555A282BF1D400AE8BC9 /* mp4box.c */; };
 		92D211942370832900128AE2 /* raster3d.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D211932370832900128AE2 /* raster3d.c */; };
-		92D535711A5C0D1400F2442A /* carbon_events.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D5356F1A5C0CF700F2442A /* carbon_events.c */; };
 		92D6C59B2343BED700262217 /* scene_js.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D6C5992343BED700262217 /* scene_js.c */; };
 		92D6C59C2343BED700262217 /* xhr.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D6C59A2343BED700262217 /* xhr.c */; };
 		92D6C5A02343BEFF00262217 /* svg_js.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D6C59D2343BEFF00262217 /* svg_js.c */; };
@@ -510,7 +511,6 @@
 		92D7A2E925D580DD00FD4034 /* fileimport.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D7A2E425D580DC00FD4034 /* fileimport.c */; };
 		92D7A2EA25D580DD00FD4034 /* live.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D7A2E525D580DD00FD4034 /* live.c */; };
 		92D7A2EB25D580DD00FD4034 /* filedump.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D7A2E725D580DD00FD4034 /* filedump.c */; };
-		92D7A2EC25D580DD00FD4034 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D7A2E825D580DD00FD4034 /* main.c */; };
 		92DB148D1E4F05B500382A81 /* filters.h in Headers */ = {isa = PBXBuildFile; fileRef = 92DB148B1E4F05B500382A81 /* filters.h */; };
 		92DB148E1E4F05B500382A81 /* main.h in Headers */ = {isa = PBXBuildFile; fileRef = 92DB148C1E4F05B500382A81 /* main.h */; };
 		92E164AB20F8EBAE0024A9CA /* dec_nvdec_sdk.c in Sources */ = {isa = PBXBuildFile; fileRef = 92E164A820F8EBAE0024A9CA /* dec_nvdec_sdk.c */; };
@@ -553,20 +553,6 @@
 /* End PBXBuildRule section */
 
 /* Begin PBXContainerItemProxy section */
-		92AAF17018D6F87100E2FF12 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 9201F92918D5A359003D1ACA /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 92AAF0D218D6DB2D00E2FF12;
-			remoteInfo = sdl_out;
-		};
-		92AAF17218D6F87A00E2FF12 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 9201F92918D5A359003D1ACA /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 92AAF16418D6F40400E2FF12;
-			remoteInfo = ft_font;
-		};
 		92BD5562205AB89D007C4C06 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 9201F92918D5A359003D1ACA /* Project object */;
@@ -581,20 +567,6 @@
 			remoteGlobalIDString = 92AAF16418D6F40400E2FF12;
 			remoteInfo = ft_font;
 		};
-		92C403E02181F1F100331F39 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 9201F92918D5A359003D1ACA /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 92C403D62181F10500331F39;
-			remoteInfo = openhevc_dec;
-		};
-		92C403E22181F1FC00331F39 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 9201F92918D5A359003D1ACA /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 92C403D62181F10500331F39;
-			remoteInfo = openhevc_dec;
-		};
 		92C403E42181F20800331F39 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 9201F92918D5A359003D1ACA /* Project object */;
@@ -609,13 +581,6 @@
 			remoteGlobalIDString = 92AAF16418D6F40400E2FF12;
 			remoteInfo = ft_font;
 		};
-		92C403E82181F21000331F39 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 9201F92918D5A359003D1ACA /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 92C403D62181F10500331F39;
-			remoteInfo = openhevc_dec;
-		};
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -637,15 +602,6 @@
 			);
 			runOnlyForDeploymentPostprocessing = 1;
 		};
-		92BE50C518D6D60100AA59D8 /* CopyFiles */ = {
-			isa = PBXCopyFilesBuildPhase;
-			buildActionMask = 2147483647;
-			dstPath = /usr/share/man/man1/;
-			dstSubfolderSpec = 0;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 1;
-		};
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
@@ -873,7 +829,6 @@
 		924E805C206D357A00AB580F /* reframe_rawvid.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_rawvid.c; path = filters/reframe_rawvid.c; sourceTree = "<group>"; };
 		924E805E206D427A00AB580F /* reframe_rawpcm.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_rawpcm.c; path = filters/reframe_rawpcm.c; sourceTree = "<group>"; };
 		924FEE811BA6C63A003F77A6 /* iff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = iff.c; sourceTree = "<group>"; };
-		9251CA881E9D3E2B0089DDC6 /* main.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = main.c; path = ../../applications/mp4client/main.c; sourceTree = "<group>"; };
 		9251E5432524EB9700CEB84D /* reframe_mhas.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_mhas.c; path = filters/reframe_mhas.c; sourceTree = "<group>"; };
 		9256B38A208662FB00088537 /* mux_ts.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = mux_ts.c; path = filters/mux_ts.c; sourceTree = "<group>"; };
 		9257307D2056948D009DB328 /* rewrite_adts.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = rewrite_adts.c; path = filters/rewrite_adts.c; sourceTree = "<group>"; };
@@ -890,16 +845,22 @@
 		925974FB2215BA3A0007E02B /* rast_soft.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = rast_soft.h; path = evg/rast_soft.h; sourceTree = "<group>"; };
 		925974FC2215BA3A0007E02B /* raster_yuv.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = raster_yuv.c; path = evg/raster_yuv.c; sourceTree = "<group>"; };
 		925975072215BAC30007E02B /* evg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = evg.h; path = ../include/gpac/evg.h; sourceTree = "<group>"; };
+		925A760E292F965D00664F38 /* sha256.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = sha256.c; sourceTree = "<group>"; };
 		925CE3441FA2E641004EC6F5 /* decrypt_cenc_isma.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = decrypt_cenc_isma.c; path = filters/decrypt_cenc_isma.c; sourceTree = "<group>"; };
 		925E564B2798B87300BBD530 /* bs_agg.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bs_agg.c; path = filters/bs_agg.c; sourceTree = "<group>"; };
 		92609BD2252F56CC00DB821E /* export.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = export.cpp; sourceTree = "<group>"; };
 		92609BD3252F570200DB821E /* share */ = {isa = PBXFileReference; lastKnownFileType = folder; name = share; path = ../../share; sourceTree = "<group>"; };
+		926209BE27F6026A0024415A /* write_tx3g.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = write_tx3g.c; path = filters/write_tx3g.c; sourceTree = "<group>"; };
+		926209C027FC630A0024415A /* ttml_conv.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ttml_conv.c; path = filters/ttml_conv.c; sourceTree = "<group>"; };
 		926245971FD691A000184072 /* ff_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ff_common.h; path = filters/ff_common.h; sourceTree = "<group>"; };
 		9265307927AD295200DEBE4B /* restamp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = restamp.c; path = filters/restamp.c; sourceTree = "<group>"; };
 		926656C11F7D10F400299CC6 /* dec_vorbis.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dec_vorbis.c; path = filters/dec_vorbis.c; sourceTree = "<group>"; };
 		926656C31F7D3DF700299CC6 /* dec_theora.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dec_theora.c; path = filters/dec_theora.c; sourceTree = "<group>"; };
 		926656C51F7D45F700299CC6 /* dmx_ogg.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dmx_ogg.c; path = filters/dmx_ogg.c; sourceTree = "<group>"; };
 		926656C71F7E92C200299CC6 /* dmx_m2ts.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dmx_m2ts.c; path = filters/dmx_m2ts.c; sourceTree = "<group>"; };
+		92683EBE2811E4980034D320 /* compositor_tools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = compositor_tools.c; path = ../../applications/gpac/compositor_tools.c; sourceTree = "<group>"; };
+		92683EC028129D3D0034D320 /* gpac_help.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gpac_help.c; path = ../../applications/gpac/gpac_help.c; sourceTree = "<group>"; };
+		92683EC228129FED0034D320 /* gpac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = gpac.h; path = ../../applications/gpac/gpac.h; sourceTree = "<group>"; };
 		926998B31FEACE8F00AA759D /* dmx_vobsub.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dmx_vobsub.c; path = filters/dmx_vobsub.c; sourceTree = "<group>"; };
 		926CE14C1FE7E388002B3CF6 /* write_generic.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = write_generic.c; path = filters/write_generic.c; sourceTree = "<group>"; };
 		926CE14E1FE81865002B3CF6 /* constants.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = constants.c; sourceTree = "<group>"; };
@@ -907,10 +868,10 @@
 		926F15521FE867B000C40779 /* write_vtt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = write_vtt.c; path = filters/write_vtt.c; sourceTree = "<group>"; };
 		926F15541FE964CF00C40779 /* write_nhnt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = write_nhnt.c; path = filters/write_nhnt.c; sourceTree = "<group>"; };
 		926F15561FE986B000C40779 /* write_nhml.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = write_nhml.c; path = filters/write_nhml.c; sourceTree = "<group>"; };
+		9272B50327E34CDF00D9D304 /* mux_ogg.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = mux_ogg.c; path = filters/mux_ogg.c; sourceTree = "<group>"; };
 		9273463223506D370081AF74 /* storage.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = storage.c; path = jsmods/storage.c; sourceTree = "<group>"; };
 		9274295724647AB8009ADD8D /* bsrw.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bsrw.c; path = filters/bsrw.c; sourceTree = "<group>"; };
 		92754D5F207D24F600170383 /* filelist.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = filelist.c; path = filters/filelist.c; sourceTree = "<group>"; };
-		927AACF61E44ED58008C8E69 /* main.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = main.c; path = ../../applications/gpac/main.c; sourceTree = "<group>"; };
 		927AACFD1E44EEDC008C8E69 /* gpac */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = gpac; sourceTree = BUILT_PRODUCTS_DIR; };
 		927DB14B21A3C7100032D205 /* reframe_latm.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_latm.c; path = filters/reframe_latm.c; sourceTree = "<group>"; };
 		9285D1A6266F671F008FCD14 /* quickjs-libc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = "quickjs-libc.c"; path = "quickjs/quickjs-libc.c"; sourceTree = "<group>"; };
@@ -924,6 +885,8 @@
 		9288E8631FB1BF07005460C5 /* reframe_mpgvid.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_mpgvid.c; path = filters/reframe_mpgvid.c; sourceTree = "<group>"; };
 		9289D9F41FDEFFCD00C24F83 /* out_file.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = out_file.c; path = filters/out_file.c; sourceTree = "<group>"; };
 		928A7F802059372C00E02E89 /* out_video.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = out_video.c; path = filters/out_video.c; sourceTree = "<group>"; };
+		928E0BD528E2FC1800F2BA27 /* unframer.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = unframer.c; path = filters/unframer.c; sourceTree = "<group>"; };
+		928E0BD928E328A100F2BA27 /* ff_bsf.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ff_bsf.c; path = filters/ff_bsf.c; sourceTree = "<group>"; };
 		928E7AC41FB9F2B800D2470E /* dmx_nhnt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dmx_nhnt.c; path = filters/dmx_nhnt.c; sourceTree = "<group>"; };
 		928E7AC61FB9FCDD00D2470E /* dmx_nhml.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dmx_nhml.c; path = filters/dmx_nhml.c; sourceTree = "<group>"; };
 		928E9F9E250F5BA6000C0631 /* route.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = route.h; path = ../include/gpac/route.h; sourceTree = "<group>"; };
@@ -957,7 +920,6 @@
 		92B2A4A9229D64EF002A65A7 /* hevcsplit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = hevcsplit.c; path = filters/hevcsplit.c; sourceTree = "<group>"; };
 		92B9A5061F83FD7700A24FE4 /* in_dvb4linux.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = in_dvb4linux.c; path = filters/in_dvb4linux.c; sourceTree = "<group>"; };
 		92B9A5081F840A6700A24FE4 /* dec_vtb.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dec_vtb.c; path = filters/dec_vtb.c; sourceTree = "<group>"; };
-		92B9A50C1F8660B500A24FE4 /* terminal.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = terminal.c; sourceTree = "<group>"; };
 		92B9A5161F8660CD00A24FE4 /* svg_font.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = svg_font.c; sourceTree = "<group>"; };
 		92B9A5171F8660CE00A24FE4 /* mpeg4_geometry_ifs2d.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = mpeg4_geometry_ifs2d.c; sourceTree = "<group>"; };
 		92B9A5181F8660CE00A24FE4 /* mpeg4_layer_3d.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = mpeg4_layer_3d.c; sourceTree = "<group>"; };
@@ -1132,7 +1094,6 @@
 		92BBFC8F1A7122AD006A7735 /* nodes_mpeg4.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = nodes_mpeg4.h; path = ../include/gpac/nodes_mpeg4.h; sourceTree = "<group>"; };
 		92BBFC901A7122AD006A7735 /* nodes_svg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = nodes_svg.h; path = ../include/gpac/nodes_svg.h; sourceTree = "<group>"; };
 		92BBFC911A7122AD006A7735 /* nodes_x3d.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = nodes_x3d.h; path = ../include/gpac/nodes_x3d.h; sourceTree = "<group>"; };
-		92BBFC931A7122AD006A7735 /* options.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = options.h; path = ../include/gpac/options.h; sourceTree = "<group>"; };
 		92BBFC941A7122AD006A7735 /* path2d.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = path2d.h; path = ../include/gpac/path2d.h; sourceTree = "<group>"; };
 		92BBFC951A7122AD006A7735 /* revision.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = revision.h; path = ../include/gpac/revision.h; sourceTree = "<group>"; };
 		92BBFC971A7122AD006A7735 /* rtp_streamer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = rtp_streamer.h; path = ../include/gpac/rtp_streamer.h; sourceTree = "<group>"; };
@@ -1144,12 +1105,9 @@
 		92BBFC9D1A7122AD006A7735 /* setup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = setup.h; path = ../include/gpac/setup.h; sourceTree = "<group>"; };
 		92BBFC9E1A7122AD006A7735 /* svg_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = svg_types.h; path = ../include/gpac/svg_types.h; sourceTree = "<group>"; };
 		92BBFC9F1A7122AD006A7735 /* sync_layer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = sync_layer.h; path = ../include/gpac/sync_layer.h; sourceTree = "<group>"; };
-		92BBFCA01A7122AD006A7735 /* term_info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = term_info.h; path = ../include/gpac/term_info.h; sourceTree = "<group>"; };
-		92BBFCA11A7122AD006A7735 /* terminal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = terminal.h; path = ../include/gpac/terminal.h; sourceTree = "<group>"; };
 		92BBFCA21A7122AD006A7735 /* thread.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = thread.h; path = ../include/gpac/thread.h; sourceTree = "<group>"; };
 		92BBFCA31A7122AD006A7735 /* token.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = token.h; path = ../include/gpac/token.h; sourceTree = "<group>"; };
 		92BBFCA41A7122AD006A7735 /* tools.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = tools.h; path = ../include/gpac/tools.h; sourceTree = "<group>"; };
-		92BBFCA61A7122AD006A7735 /* user.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = user.h; path = ../include/gpac/user.h; sourceTree = "<group>"; };
 		92BBFCA71A7122AD006A7735 /* utf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = utf.h; path = ../include/gpac/utf.h; sourceTree = "<group>"; };
 		92BBFCA81A7122AD006A7735 /* version.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = version.h; path = ../include/gpac/version.h; sourceTree = "<group>"; };
 		92BBFCA91A7122AD006A7735 /* webvtt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = webvtt.h; path = ../include/gpac/webvtt.h; sourceTree = "<group>"; };
@@ -1158,14 +1116,15 @@
 		92BD556E205AE9B0007C4C06 /* CoreImage.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreImage.framework; path = System/Library/Frameworks/CoreImage.framework; sourceTree = SDKROOT; };
 		92BD5570205AE9BD007C4C06 /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = System/Library/Frameworks/AppKit.framework; sourceTree = SDKROOT; };
 		92BE509018D6325E00AA59D8 /* MP4Box */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = MP4Box; sourceTree = BUILT_PRODUCTS_DIR; };
-		92BE50C718D6D60100AA59D8 /* MP4Client */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = MP4Client; sourceTree = BUILT_PRODUCTS_DIR; };
 		92C0F37D21EC7BB0002961C8 /* out_rtp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = out_rtp.c; path = filters/out_rtp.c; sourceTree = "<group>"; };
 		92C236DC25769BA500CD59A9 /* tilesplit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = tilesplit.c; path = filters/tilesplit.c; sourceTree = "<group>"; };
 		92C403D72181F10500331F39 /* gf_openhevc_dec.dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = gf_openhevc_dec.dylib; sourceTree = BUILT_PRODUCTS_DIR; };
 		92C403DC2181F17E00331F39 /* dec_openhevc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dec_openhevc.c; path = ../../src/filters/dec_openhevc.c; sourceTree = "<group>"; };
+		92C69C5B281315B400051866 /* carbon_hook.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = carbon_hook.c; path = ../../applications/gpac/carbon_hook.c; sourceTree = "<group>"; };
 		92CDAEE71FBD9D0C0007C1C0 /* reframe_nalu.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_nalu.c; path = filters/reframe_nalu.c; sourceTree = "<group>"; };
+		92D15558282BF1BA00AE8BC9 /* gpac.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gpac.c; path = ../../applications/gpac/gpac.c; sourceTree = "<group>"; };
+		92D1555A282BF1D400AE8BC9 /* mp4box.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = mp4box.c; path = ../../applications/mp4box/mp4box.c; sourceTree = "<group>"; };
 		92D211932370832900128AE2 /* raster3d.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = raster3d.c; path = evg/raster3d.c; sourceTree = "<group>"; };
-		92D5356F1A5C0CF700F2442A /* carbon_events.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = carbon_events.c; path = ../../applications/mp4client/carbon_events.c; sourceTree = "<group>"; };
 		92D6C5992343BED700262217 /* scene_js.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = scene_js.c; path = jsmods/scene_js.c; sourceTree = "<group>"; };
 		92D6C59A2343BED700262217 /* xhr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xhr.c; path = jsmods/xhr.c; sourceTree = "<group>"; };
 		92D6C59D2343BEFF00262217 /* svg_js.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = svg_js.c; sourceTree = "<group>"; };
@@ -1175,7 +1134,6 @@
 		92D7A2E525D580DD00FD4034 /* live.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = live.c; path = ../../applications/mp4box/live.c; sourceTree = "<group>"; };
 		92D7A2E625D580DD00FD4034 /* mp4box.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = mp4box.h; path = ../../applications/mp4box/mp4box.h; sourceTree = "<group>"; };
 		92D7A2E725D580DD00FD4034 /* filedump.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = filedump.c; path = ../../applications/mp4box/filedump.c; sourceTree = "<group>"; };
-		92D7A2E825D580DD00FD4034 /* main.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = main.c; path = ../../applications/mp4box/main.c; sourceTree = "<group>"; };
 		92DB148B1E4F05B500382A81 /* filters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = filters.h; path = ../include/gpac/filters.h; sourceTree = "<group>"; };
 		92DB148C1E4F05B500382A81 /* main.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = main.h; path = ../include/gpac/main.h; sourceTree = "<group>"; };
 		92E164A820F8EBAE0024A9CA /* dec_nvdec_sdk.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dec_nvdec_sdk.c; path = filters/dec_nvdec_sdk.c; sourceTree = "<group>"; };
@@ -1258,15 +1216,6 @@
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
-		92BE50C418D6D60100AA59D8 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				28C5AA801A16277200372C59 /* Carbon.framework in Frameworks */,
-				92BE50D518D6D66C00AA59D8 /* libgpac.dylib in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
 		92C403D52181F10500331F39 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
@@ -1389,14 +1338,6 @@
 			path = scenegraph;
 			sourceTree = "<group>";
 		};
-		9201007718D5A444003D1ACA /* terminal */ = {
-			isa = PBXGroup;
-			children = (
-				92B9A50C1F8660B500A24FE4 /* terminal.c */,
-			);
-			path = terminal;
-			sourceTree = "<group>";
-		};
 		9201008C18D5A444003D1ACA /* utils */ = {
 			isa = PBXGroup;
 			children = (
@@ -1427,6 +1368,7 @@
 				920100A218D5A444003D1ACA /* path2d_stroker.c */,
 				92E164BA20F8F2860024A9CA /* Remotery.c */,
 				920100A418D5A444003D1ACA /* sha1.c */,
+				925A760E292F965D00664F38 /* sha256.c */,
 				920100A718D5A444003D1ACA /* token.c */,
 				920100A818D5A444003D1ACA /* uni_bidi.c */,
 				920100A918D5A444003D1ACA /* unicode.c */,
@@ -1456,7 +1398,6 @@
 			isa = PBXGroup;
 			children = (
 				92BE509018D6325E00AA59D8 /* MP4Box */,
-				92BE50C718D6D60100AA59D8 /* MP4Client */,
 				9201F93718D5A38A003D1ACA /* libgpac.dylib */,
 				92AAF0D318D6DB2D00E2FF12 /* gm_sdl_out.dylib */,
 				92AAF16518D6F40400E2FF12 /* gm_ft_font.dylib */,
@@ -1486,7 +1427,6 @@
 				92334C8E2333A8B800DA6051 /* quickjs */,
 				9201004E18D5A444003D1ACA /* scene_manager */,
 				9201005D18D5A444003D1ACA /* scenegraph */,
-				9201007718D5A444003D1ACA /* terminal */,
 				9201008C18D5A444003D1ACA /* utils */,
 				92C1FF4A1E7C42A40093B61E /* builtin_modules */,
 			);
@@ -1686,15 +1626,6 @@
 			name = in_rtp;
 			sourceTree = "<group>";
 		};
-		9251CA871E9D3DFE0089DDC6 /* MP4Client */ = {
-			isa = PBXGroup;
-			children = (
-				92D5356F1A5C0CF700F2442A /* carbon_events.c */,
-				9251CA881E9D3E2B0089DDC6 /* main.c */,
-			);
-			name = MP4Client;
-			sourceTree = "<group>";
-		};
 		92586A6E1EA7663A00A0838A /* ft_font */ = {
 			isa = PBXGroup;
 			children = (
@@ -1733,7 +1664,11 @@
 		927AACF81E44ED5C008C8E69 /* gpac */ = {
 			isa = PBXGroup;
 			children = (
-				927AACF61E44ED58008C8E69 /* main.c */,
+				92D15558282BF1BA00AE8BC9 /* gpac.c */,
+				92683EC228129FED0034D320 /* gpac.h */,
+				92683EC028129D3D0034D320 /* gpac_help.c */,
+				92683EBE2811E4980034D320 /* compositor_tools.c */,
+				92C69C5B281315B400051866 /* carbon_hook.c */,
 			);
 			name = gpac;
 			sourceTree = "<group>";
@@ -1800,6 +1735,7 @@
 				92BB855C1F7BFB61009BC9C8 /* ff_common.c */,
 				926245971FD691A000184072 /* ff_common.h */,
 				928607122396DF8500FDA1ED /* ff_avf.c */,
+				928E0BD928E328A100F2BA27 /* ff_bsf.c */,
 				92BB85501F7BFB60009BC9C8 /* ff_dec.c */,
 				92BB85601F7BFB62009BC9C8 /* ff_dmx.c */,
 				92E9167B2073F1DB00EE92FB /* ff_enc.c */,
@@ -1854,7 +1790,6 @@
 				92BBFC8F1A7122AD006A7735 /* nodes_mpeg4.h */,
 				92BBFC901A7122AD006A7735 /* nodes_svg.h */,
 				92BBFC911A7122AD006A7735 /* nodes_x3d.h */,
-				92BBFC931A7122AD006A7735 /* options.h */,
 				92BBFC941A7122AD006A7735 /* path2d.h */,
 				92BBFC951A7122AD006A7735 /* revision.h */,
 				9231B3AE2321533F00ADB4A9 /* Remotery.h */,
@@ -1868,12 +1803,9 @@
 				92BBFC9D1A7122AD006A7735 /* setup.h */,
 				92BBFC9E1A7122AD006A7735 /* svg_types.h */,
 				92BBFC9F1A7122AD006A7735 /* sync_layer.h */,
-				92BBFCA01A7122AD006A7735 /* term_info.h */,
-				92BBFCA11A7122AD006A7735 /* terminal.h */,
 				92BBFCA21A7122AD006A7735 /* thread.h */,
 				92BBFCA31A7122AD006A7735 /* token.h */,
 				92BBFCA41A7122AD006A7735 /* tools.h */,
-				92BBFCA61A7122AD006A7735 /* user.h */,
 				92BBFCA71A7122AD006A7735 /* utf.h */,
 				92BBFCA81A7122AD006A7735 /* version.h */,
 				92BBFCA91A7122AD006A7735 /* webvtt.h */,
@@ -1926,7 +1858,6 @@
 			isa = PBXGroup;
 			children = (
 				92D7A2E325D580B200FD4034 /* MP4Box */,
-				9251CA871E9D3DFE0089DDC6 /* MP4Client */,
 				927AACF81E44ED5C008C8E69 /* gpac */,
 			);
 			name = applications;
@@ -1982,10 +1913,10 @@
 		92D7A2E325D580B200FD4034 /* MP4Box */ = {
 			isa = PBXGroup;
 			children = (
+				92D1555A282BF1D400AE8BC9 /* mp4box.c */,
 				92D7A2E725D580DD00FD4034 /* filedump.c */,
 				92D7A2E425D580DC00FD4034 /* fileimport.c */,
 				92D7A2E525D580DD00FD4034 /* live.c */,
-				92D7A2E825D580DD00FD4034 /* main.c */,
 				92D7A2E625D580DD00FD4034 /* mp4box.h */,
 			);
 			name = MP4Box;
@@ -2078,6 +2009,7 @@
 				922E29812051940C00C8DCBB /* mux_avi.c */,
 				9206823320EA96AA0041169F /* mux_gsf.c */,
 				9290F5101FAB4C2C0038C30D /* mux_isom.c */,
+				9272B50327E34CDF00D9D304 /* mux_ogg.c */,
 				9256B38A208662FB00088537 /* mux_ts.c */,
 				92E164AE20F8EBB60024A9CA /* nvdec */,
 				922E29822051940C00C8DCBB /* out_audio.c */,
@@ -2118,13 +2050,16 @@
 				92A08DBC20D946B6003589FF /* tileagg.c */,
 				92C236DC25769BA500CD59A9 /* tilesplit.c */,
 				9286070E239576D900FDA1ED /* tssplit.c */,
+				926209C027FC630A0024415A /* ttml_conv.c */,
 				92BB85631F7BFB63009BC9C8 /* unit_test_filter.c */,
+				928E0BD528E2FC1800F2BA27 /* unframer.c */,
 				92E318D020651834007BE021 /* vcrop.c */,
 				9212C0FA222D7AC000FE3580 /* vflip.c */,
 				926CE14C1FE7E388002B3CF6 /* write_generic.c */,
 				926F15561FE986B000C40779 /* write_nhml.c */,
 				926F15541FE964CF00C40779 /* write_nhnt.c */,
 				9288350B1FE82E63002F603D /* write_qcp.c */,
+				926209BE27F6026A0024415A /* write_tx3g.c */,
 				926F15521FE867B000C40779 /* write_vtt.c */,
 			);
 			name = filters;
@@ -2177,7 +2112,6 @@
 				92BBFCF51A7122AD006A7735 /* path2d.h in Headers */,
 				920100BA18D5A444003D1ACA /* quant.h in Headers */,
 				92BBFCE61A7122AD006A7735 /* hardcoded_proto.h in Headers */,
-				92BBFD021A7122AD006A7735 /* terminal.h in Headers */,
 				92BBFCD81A7122AD006A7735 /* vobsub.h in Headers */,
 				92BBFCB31A7122AD006A7735 /* config_file.h in Headers */,
 				92BBFCC61A7122AD006A7735 /* compositor_dev.h in Headers */,
@@ -2216,7 +2150,6 @@
 				92BBFCB51A7122AD006A7735 /* constants.h in Headers */,
 				92BBFD041A7122AD006A7735 /* token.h in Headers */,
 				92BBFCB11A7122AD006A7735 /* color.h in Headers */,
-				92BBFCF41A7122AD006A7735 /* options.h in Headers */,
 				92BBFCAD1A7122AD006A7735 /* base_coding.h in Headers */,
 				92BBFCE51A7122AD006A7735 /* font.h in Headers */,
 				92BBFCD61A7122AD006A7735 /* swf_dev.h in Headers */,
@@ -2224,7 +2157,6 @@
 				925975042215BA3A0007E02B /* rast_soft.h in Headers */,
 				92493D8220E2A81700203C2C /* crypt_tools.h in Headers */,
 				92BBFCF81A7122AD006A7735 /* rtp_streamer.h in Headers */,
-				92BBFD071A7122AD006A7735 /* user.h in Headers */,
 				92B9A59B1F8660D700A24FE4 /* nodes_stacks.h in Headers */,
 				92BBFCFA1A7122AD006A7735 /* scene_manager.h in Headers */,
 				92BBFCB71A7122AD006A7735 /* dash.h in Headers */,
@@ -2257,7 +2189,6 @@
 				920101B418D5A445003D1ACA /* module_wrap.h in Headers */,
 				92BBFD001A7122AD006A7735 /* sync_layer.h in Headers */,
 				92DB148D1E4F05B500382A81 /* filters.h in Headers */,
-				92BBFD011A7122AD006A7735 /* term_info.h in Headers */,
 				92BBFCF01A7122AD006A7735 /* nodes_mpeg4.h in Headers */,
 				92BBFCDA1A7122AD006A7735 /* iso639.h in Headers */,
 				923E89CC20B6F04600F299B2 /* tiny_aes.h in Headers */,
@@ -2336,7 +2267,6 @@
 			buildRules = (
 			);
 			dependencies = (
-				92C403E12181F1F100331F39 /* PBXTargetDependency */,
 				92C403DF2181F1ED00331F39 /* PBXTargetDependency */,
 				92BD5563205AB89D007C4C06 /* PBXTargetDependency */,
 			);
@@ -2390,7 +2320,6 @@
 			buildRules = (
 			);
 			dependencies = (
-				92C403E92181F21000331F39 /* PBXTargetDependency */,
 				92C403E72181F20C00331F39 /* PBXTargetDependency */,
 				92C403E52181F20800331F39 /* PBXTargetDependency */,
 			);
@@ -2399,26 +2328,6 @@
 			productReference = 92BE509018D6325E00AA59D8 /* MP4Box */;
 			productType = "com.apple.product-type.tool";
 		};
-		92BE50C618D6D60100AA59D8 /* MP4Client */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 92BE50CE18D6D60100AA59D8 /* Build configuration list for PBXNativeTarget "MP4Client" */;
-			buildPhases = (
-				92BE50C318D6D60100AA59D8 /* Sources */,
-				92BE50C418D6D60100AA59D8 /* Frameworks */,
-				92BE50C518D6D60100AA59D8 /* CopyFiles */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				92C403E32181F1FC00331F39 /* PBXTargetDependency */,
-				92AAF17318D6F87A00E2FF12 /* PBXTargetDependency */,
-				92AAF17118D6F87100E2FF12 /* PBXTargetDependency */,
-			);
-			name = MP4Client;
-			productName = MP4Client;
-			productReference = 92BE50C718D6D60100AA59D8 /* MP4Client */;
-			productType = "com.apple.product-type.tool";
-		};
 		92C403D62181F10500331F39 /* openhevc_dec */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 92C403DA2181F10500331F39 /* Build configuration list for PBXNativeTarget "openhevc_dec" */;
@@ -2471,7 +2380,6 @@
 			targets = (
 				9201F93618D5A38A003D1ACA /* libgpac */,
 				92BE508F18D6325E00AA59D8 /* MP4Box */,
-				92BE50C618D6D60100AA59D8 /* MP4Client */,
 				92AAF0D218D6DB2D00E2FF12 /* sdl_out */,
 				92AAF16418D6F40400E2FF12 /* ft_font */,
 				927AACFC1E44EEDC008C8E69 /* gpac */,
@@ -2514,6 +2422,7 @@
 				92B9A5AC1F8660D700A24FE4 /* svg_media.c in Sources */,
 				9251E5442524EB9800CEB84D /* reframe_mhas.c in Sources */,
 				920101B718D5A445003D1ACA /* os_module.c in Sources */,
+				926209BF27F6026A0024415A /* write_tx3g.c in Sources */,
 				92B9A5A41F8660D700A24FE4 /* scene.c in Sources */,
 				922CF1251FCEE5D600F2F6A4 /* dmx_mpegps.c in Sources */,
 				925730802056948D009DB328 /* rewrite_nalu.c in Sources */,
@@ -2564,7 +2473,6 @@
 				9256B38B208662FC00088537 /* mux_ts.c in Sources */,
 				9288E8641FB1BF07005460C5 /* reframe_mpgvid.c in Sources */,
 				92B9A5991F8660D700A24FE4 /* mpeg4_audio.c in Sources */,
-				92B9A5111F8660B500A24FE4 /* terminal.c in Sources */,
 				92B9A5881F8660D700A24FE4 /* scene_ns.c in Sources */,
 				92B9A50A1F840A6800A24FE4 /* dec_vtb.c in Sources */,
 				92B9A5771F8660D700A24FE4 /* mpeg4_background.c in Sources */,
@@ -2580,6 +2488,7 @@
 				9201010B18D5A444003D1ACA /* rtp_pck_3gpp.c in Sources */,
 				92061A851FE0484600B5C464 /* reframer.c in Sources */,
 				9201010C18D5A444003D1ACA /* rtp_pck_mpeg12.c in Sources */,
+				925A760F292F965D00664F38 /* sha256.c in Sources */,
 				92B9A5821F8660D700A24FE4 /* hc_flash_shape.c in Sources */,
 				9246EE7524A0DA2700F72EAD /* filter_session_js.c in Sources */,
 				9201010D18D5A444003D1ACA /* rtp_pck_mpeg4.c in Sources */,
@@ -2672,6 +2581,7 @@
 				92B9A57C1F8660D700A24FE4 /* svg_filters.c in Sources */,
 				92B9A5A01F8660D700A24FE4 /* mpeg4_sensors.c in Sources */,
 				9201014518D5A445003D1ACA /* dash_client.c in Sources */,
+				928E0BDA28E328A100F2BA27 /* ff_bsf.c in Sources */,
 				925975052215BA3A0007E02B /* raster_yuv.c in Sources */,
 				92E318D120651834007BE021 /* vcrop.c in Sources */,
 				92B9A5971F8660D700A24FE4 /* audio_render.c in Sources */,
@@ -2746,6 +2656,7 @@
 				9286070F239576D900FDA1ED /* tssplit.c in Sources */,
 				92BB85751F7BFB63009BC9C8 /* inspect.c in Sources */,
 				92B9A5721F8660D700A24FE4 /* mpeg4_animstream.c in Sources */,
+				9272B50427E34CDF00D9D304 /* mux_ogg.c in Sources */,
 				9201016B18D5A445003D1ACA /* encode_isom.c in Sources */,
 				92BB85851F7C606A009BC9C8 /* reframe_amr.c in Sources */,
 				926F15551FE964D000C40779 /* write_nhnt.c in Sources */,
@@ -2821,6 +2732,7 @@
 				92BB856C1F7BFB63009BC9C8 /* reframe_adts.c in Sources */,
 				9239B8D6207369E5005F7264 /* enc_jpg.c in Sources */,
 				92B9A5961F8660D700A24FE4 /* font_engine.c in Sources */,
+				926209C127FC630A0024415A /* ttml_conv.c in Sources */,
 				922E29842051940C00C8DCBB /* out_audio.c in Sources */,
 				922CF1271FCF169900F2F6A4 /* dmx_avi.c in Sources */,
 				9201018F18D5A445003D1ACA /* x3d_nodes.c in Sources */,
@@ -2840,6 +2752,7 @@
 				926F15531FE867B000C40779 /* write_vtt.c in Sources */,
 				920101AA18D5A445003D1ACA /* color.c in Sources */,
 				92B9A5841F8660D700A24FE4 /* mpeg4_form.c in Sources */,
+				928E0BD628E2FC1900F2BA27 /* unframer.c in Sources */,
 				92BB9A671F9C827600524E5B /* dmx_dash.c in Sources */,
 				92B9A5A71F8660D700A24FE4 /* texturing_gl.c in Sources */,
 				92B9A5A51F8660D700A24FE4 /* mpeg4_gradients.c in Sources */,
@@ -2892,7 +2805,10 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				929867752355DED1008A2CC6 /* main.c in Sources */,
+				92683EBF2811E4980034D320 /* compositor_tools.c in Sources */,
+				92683EC128129D3D0034D320 /* gpac_help.c in Sources */,
+				92D15559282BF1BA00AE8BC9 /* gpac.c in Sources */,
+				92C69C5C281315B400051866 /* carbon_hook.c in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -2918,19 +2834,10 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				92D7A2EC25D580DD00FD4034 /* main.c in Sources */,
 				92D7A2EB25D580DD00FD4034 /* filedump.c in Sources */,
 				92D7A2E925D580DD00FD4034 /* fileimport.c in Sources */,
 				92D7A2EA25D580DD00FD4034 /* live.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		92BE50C318D6D60100AA59D8 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				9251CA8A1E9D3E960089DDC6 /* main.c in Sources */,
-				92D535711A5C0D1400F2442A /* carbon_events.c in Sources */,
+				92D1555B282BF1D400AE8BC9 /* mp4box.c in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -2945,16 +2852,6 @@
 /* End PBXSourcesBuildPhase section */
 
 /* Begin PBXTargetDependency section */
-		92AAF17118D6F87100E2FF12 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 92AAF0D218D6DB2D00E2FF12 /* sdl_out */;
-			targetProxy = 92AAF17018D6F87100E2FF12 /* PBXContainerItemProxy */;
-		};
-		92AAF17318D6F87A00E2FF12 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 92AAF16418D6F40400E2FF12 /* ft_font */;
-			targetProxy = 92AAF17218D6F87A00E2FF12 /* PBXContainerItemProxy */;
-		};
 		92BD5563205AB89D007C4C06 /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 92AAF0D218D6DB2D00E2FF12 /* sdl_out */;
@@ -2965,16 +2862,6 @@
 			target = 92AAF16418D6F40400E2FF12 /* ft_font */;
 			targetProxy = 92C403DE2181F1ED00331F39 /* PBXContainerItemProxy */;
 		};
-		92C403E12181F1F100331F39 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 92C403D62181F10500331F39 /* openhevc_dec */;
-			targetProxy = 92C403E02181F1F100331F39 /* PBXContainerItemProxy */;
-		};
-		92C403E32181F1FC00331F39 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 92C403D62181F10500331F39 /* openhevc_dec */;
-			targetProxy = 92C403E22181F1FC00331F39 /* PBXContainerItemProxy */;
-		};
 		92C403E52181F20800331F39 /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 92AAF0D218D6DB2D00E2FF12 /* sdl_out */;
@@ -2985,11 +2872,6 @@
 			target = 92AAF16418D6F40400E2FF12 /* ft_font */;
 			targetProxy = 92C403E62181F20C00331F39 /* PBXContainerItemProxy */;
 		};
-		92C403E92181F21000331F39 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 92C403D62181F10500331F39 /* openhevc_dec */;
-			targetProxy = 92C403E82181F21000331F39 /* PBXContainerItemProxy */;
-		};
 /* End PBXTargetDependency section */
 
 /* Begin XCBuildConfiguration section */
@@ -3016,6 +2898,7 @@
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
+				EXCLUDED_ARCHS = "";
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = GPAC_CONFIG_DARWIN;
 				GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS = "";
@@ -3061,6 +2944,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				EXCLUDED_ARCHS = "";
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = GPAC_CONFIG_DARWIN;
 				GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS = "";
@@ -3087,11 +2971,12 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = NO;
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = lib;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
@@ -3109,8 +2994,6 @@
 					GPAC_HAS_LIBA52,
 					GPAC_HAS_VORBIS,
 					GPAC_HAS_THEORA,
-					GPAC_HAS_OPENSVC,
-					GPAC_HAS_OPENHEVC,
 					GPAC_HAS_FFMPEG,
 					FFMPEG_ENABLE_VVC,
 				);
@@ -3129,12 +3012,15 @@
 					../../include,
 					/opt/local/include,
 					/usr/local/include,
-					"/opt/local/include/openjpeg-1.5",
-					"/usr/local/include/openjpeg-1.5",
+					"/opt/local/include/openjpeg-2.5",
+					"/usr/local/include/openjpeg-2.5",
+					/opt/homebrew/include,
+					"/opt/homebrew/include/openjpeg-2.5",
 				);
 				LIBRARY_SEARCH_PATHS = (
 					/usr/local/lib,
 					/opt/local/lib,
+					/opt/homebrew/lib,
 				);
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				OBJROOT = build;
@@ -3157,7 +3043,6 @@
 					"-lx265",
 					"-lavdevice",
 					"-lpostproc",
-					"-lavresample",
 					"-lavfilter",
 					"-ldav1d",
 					"-liconv",
@@ -3172,11 +3057,10 @@
 					"-lfaad",
 					"-lmad",
 					"-lxvidcore",
-					"-lopenjpeg",
+					"-lopenjp2",
 					"-la52",
 					"-lvorbis",
 					"-ltheora",
-					"-lOpenSVCDec",
 					"-lxcb",
 					"-lxcb-shm",
 					"-lxcb-shape",
@@ -3188,7 +3072,6 @@
 					"-lkvazaar",
 					"-lnghttp2",
 					"-lvmaf",
-					"-lvvdec",
 					"-lc++",
 					"-lxml2",
 					"-lmp3lame",
@@ -3207,6 +3090,8 @@
 					CoreServices,
 					"-framework",
 					Metal,
+					"-lovvc",
+					"-lvvdec",
 				);
 				PRODUCT_NAME = gpac;
 				SDKROOT = macosx;
@@ -3219,12 +3104,13 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = lib;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
@@ -3239,8 +3125,6 @@
 					GPAC_HAS_LIBA52,
 					GPAC_HAS_VORBIS,
 					GPAC_HAS_THEORA,
-					GPAC_HAS_OPENSVC,
-					GPAC_HAS_OPENHEVC,
 					GPAC_HAS_FFMPEG,
 					FFMPEG_ENABLE_VVC,
 				);
@@ -3258,15 +3142,19 @@
 					../../include,
 					/opt/local/include,
 					/usr/local/include,
-					"/opt/local/include/openjpeg-1.5",
-					"/usr/local/include/openjpeg-1.5",
+					"/opt/local/include/openjpeg-2.5",
+					"/usr/local/include/openjpeg-2.5",
+					/opt/homebrew/include,
+					"/opt/homebrew/include/openjpeg-2.5",
 				);
 				LIBRARY_SEARCH_PATHS = (
 					/usr/local/lib,
 					/opt/local/lib,
+					/opt/homebrew/lib,
 				);
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				OBJROOT = build;
+				ONLY_ACTIVE_ARCH = YES;
 				OTHER_CFLAGS = "-Wno-conversion";
 				OTHER_LDFLAGS = (
 					"-w",
@@ -3285,7 +3173,6 @@
 					"-lx265",
 					"-lavdevice",
 					"-lpostproc",
-					"-lavresample",
 					"-lavfilter",
 					"-ldav1d",
 					"-liconv",
@@ -3300,11 +3187,10 @@
 					"-lfaad",
 					"-lmad",
 					"-lxvidcore",
-					"-lopenjpeg",
+					"-lopenjp2",
 					"-la52",
 					"-lvorbis",
 					"-ltheora",
-					"-lOpenSVCDec",
 					"-lxcb",
 					"-lxcb-shm",
 					"-lxcb-shape",
@@ -3316,7 +3202,6 @@
 					"-lkvazaar",
 					"-lnghttp2",
 					"-lvmaf",
-					"-lvvdec",
 					"-lc++",
 					"-lxml2",
 					"-lmp3lame",
@@ -3335,6 +3220,8 @@
 					CoreServices,
 					"-framework",
 					Metal,
+					"-lovvc",
+					"-lvvdec",
 				);
 				PRODUCT_NAME = gpac;
 				SDKROOT = macosx;
@@ -3347,7 +3234,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
@@ -3360,6 +3247,7 @@
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DEVELOPMENT_TEAM = Q46G522WGV;
+				EXCLUDED_ARCHS = "";
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
@@ -3372,6 +3260,7 @@
 				LIBRARY_SEARCH_PATHS = "";
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
 			};
@@ -3381,7 +3270,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
@@ -3395,12 +3284,14 @@
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEVELOPMENT_TEAM = Q46G522WGV;
 				ENABLE_NS_ASSERTIONS = NO;
+				EXCLUDED_ARCHS = "";
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				LIBRARY_SEARCH_PATHS = "";
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				MTL_ENABLE_DEBUG_INFO = NO;
+				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
 			};
@@ -3410,10 +3301,11 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = NO;
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = gm_;
 				FRAMEWORK_SEARCH_PATHS = (
 					"$(inherited)",
@@ -3437,13 +3329,15 @@
 					../../include,
 					/usr/local/include/SDL2,
 					/opt/local/include/SDL2,
+					/opt/homebrew/include/SDL2,
 				);
 				INSTALL_PATH = "";
 				LIBRARY_SEARCH_PATHS = (
 					/usr/local/lib,
 					/opt/local/lib,
+					/opt/homebrew/lib,
 				);
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
 				ONLY_ACTIVE_ARCH = YES;
 				OTHER_LDFLAGS = "-lSDL2";
 				PRODUCT_NAME = "$(TARGET_NAME)";
@@ -3455,11 +3349,12 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = gm_;
 				FRAMEWORK_SEARCH_PATHS = (
 					"$(inherited)",
@@ -3476,13 +3371,16 @@
 					../../include,
 					/usr/local/include/SDL2,
 					/opt/local/include/SDL2,
+					/opt/homebrew/include/SDL2,
 				);
 				INSTALL_PATH = "";
 				LIBRARY_SEARCH_PATHS = (
 					/usr/local/lib,
 					/opt/local/lib,
+					/opt/homebrew/lib,
 				);
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				ONLY_ACTIVE_ARCH = YES;
 				OTHER_LDFLAGS = "-lSDL2";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
@@ -3493,10 +3391,11 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = NO;
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = gm_;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
@@ -3516,11 +3415,13 @@
 					../../include,
 					/opt/local/include/freetype2,
 					/usr/local/include/freetype2,
+					/opt/homebrew/include/freetype2,
 				);
 				INSTALL_PATH = "";
 				LIBRARY_SEARCH_PATHS = (
 					/opt/local/lib,
 					/usr/local/lib,
+					/opt/homebrew/lib,
 				);
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				ONLY_ACTIVE_ARCH = YES;
@@ -3534,11 +3435,12 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = gm_;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
@@ -3551,13 +3453,16 @@
 					../../include,
 					/opt/local/include/freetype2,
 					/usr/local/include/freetype2,
+					/opt/homebrew/include/freetype2,
 				);
 				INSTALL_PATH = "";
 				LIBRARY_SEARCH_PATHS = (
 					/opt/local/lib,
 					/usr/local/lib,
+					/opt/homebrew/lib,
 				);
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				ONLY_ACTIVE_ARCH = YES;
 				OTHER_LDFLAGS = "-lfreetype";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
@@ -3568,10 +3473,11 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				CODE_SIGN_IDENTITY = "-";
 				COPY_PHASE_STRIP = NO;
+				EXCLUDED_ARCHS = "";
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
@@ -3601,11 +3507,12 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ENABLE_OBJC_WEAK = YES;
 				CODE_SIGN_IDENTITY = "-";
 				COPY_PHASE_STRIP = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				EXCLUDED_ARCHS = "";
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
@@ -3617,66 +3524,10 @@
 				INSTALL_PATH = "";
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				OBJROOT = build;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SDKROOT = macosx;
-				SYMROOT = ../../bin/osx/;
-			};
-			name = Release;
-		};
-		92BE50CF18D6D60100AA59D8 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CODE_SIGN_IDENTITY = "-";
-				COPY_PHASE_STRIP = NO;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_INHIBIT_ALL_WARNINGS = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				INSTALL_PATH = "";
-				LIBRARY_SEARCH_PATHS = "";
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		92BE50D018D6D60100AA59D8 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CODE_SIGN_IDENTITY = "-";
-				COPY_PHASE_STRIP = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_INHIBIT_ALL_WARNINGS = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				INSTALL_PATH = "";
-				LIBRARY_SEARCH_PATHS = "";
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SDKROOT = macosx;
+				SYMROOT = ../../bin/osx/;
 			};
 			name = Release;
 		};
@@ -3684,7 +3535,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
@@ -3705,6 +3556,7 @@
 				DYLIB_COMPATIBILITY_VERSION = 1;
 				DYLIB_CURRENT_VERSION = 1;
 				DYLIB_INSTALL_NAME_BASE = "";
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = gf_;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_DYNAMIC_NO_PIC = NO;
@@ -3730,6 +3582,7 @@
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
 				OTHER_LDFLAGS = "-lopenhevc";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
@@ -3741,7 +3594,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = x86_64;
+				ARCHS = "$(ARCHS_STANDARD)";
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
@@ -3763,6 +3616,7 @@
 				DYLIB_CURRENT_VERSION = 1;
 				DYLIB_INSTALL_NAME_BASE = "";
 				ENABLE_NS_ASSERTIONS = NO;
+				EXCLUDED_ARCHS = "";
 				EXECUTABLE_PREFIX = gf_;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_PREPROCESSOR_DEFINITIONS = (
@@ -3785,6 +3639,7 @@
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
 				OTHER_LDFLAGS = "-lopenhevc";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
@@ -3848,15 +3703,6 @@
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
-		};
-		92BE50CE18D6D60100AA59D8 /* Build configuration list for PBXNativeTarget "MP4Client" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				92BE50CF18D6D60100AA59D8 /* Debug */,
-				92BE50D018D6D60100AA59D8 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
 		};
 		92C403DA2181F10500331F39 /* Build configuration list for PBXNativeTarget "openhevc_dec" */ = {
 			isa = XCConfigurationList;

gpac-2.2.0.tar.gz/build/xcode/gpac4ios.entitlements Added

gpac-2.0.0.tar.gz/build/xcode/gpac4ios.xcodeproj/project.pbxproj -> gpac-2.2.0.tar.gz/build/xcode/gpac4ios.xcodeproj/project.pbxproj Changed

@@ -22,7 +22,6 @@
 		2897039C1A13C4050063E9C0 /* libswresample.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 2897039B1A13C4050063E9C0 /* libswresample.a */; };
 		7141FF301292CB9200FCB27D /* alloc.c in Sources */ = {isa = PBXBuildFile; fileRef = 7141FF2F1292CB9200FCB27D /* alloc.c */; };
 		7147426012B918C900DB5A59 /* cache.c in Sources */ = {isa = PBXBuildFile; fileRef = 7147425F12B918C900DB5A59 /* cache.c */; };
-		71A19B2112796B6F00ACFF58 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = 71A19B2012796B6F00ACFF58 /* main.c */; };
 		71A19BB212797D1B00ACFF58 /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 71A19BB112797D1B00ACFF58 /* OpenGLES.framework */; };
 		71A19BC412797D9200ACFF58 /* libobjc.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 71A19BC312797D9200ACFF58 /* libobjc.dylib */; };
 		71A19BCD12797DBA00ACFF58 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 71A19BCC12797DBA00ACFF58 /* UIKit.framework */; settings = {ATTRIBUTES = (Required, ); }; };
@@ -216,7 +215,6 @@
 		71CCF3131277045100339E12 /* vrml_tools.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF2101277045100339E12 /* vrml_tools.c */; };
 		71CCF3141277045100339E12 /* x3d_nodes.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF2111277045100339E12 /* x3d_nodes.c */; };
 		71CCF3161277045100339E12 /* xml_ns.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF2131277045100339E12 /* xml_ns.c */; };
-		71CCF32A1277045100339E12 /* terminal.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF2281277045100339E12 /* terminal.c */; };
 		71CCF32B1277045100339E12 /* base_encoding.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF22A1277045100339E12 /* base_encoding.c */; };
 		71CCF32C1277045100339E12 /* bitstream.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF22B1277045100339E12 /* bitstream.c */; };
 		71CCF32D1277045100339E12 /* color.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF22C1277045100339E12 /* color.c */; };
@@ -252,7 +250,6 @@
 		71CCF3BB12770A8C00339E12 /* download.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF36A12770A8C00339E12 /* download.h */; };
 		71CCF3BC12770A8C00339E12 /* dvb_mpe.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF36B12770A8C00339E12 /* dvb_mpe.h */; };
 		71CCF3BE12770A8C00339E12 /* events.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF36D12770A8C00339E12 /* events.h */; };
-		71CCF3BF12770A8C00339E12 /* filestreamer.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF36E12770A8C00339E12 /* filestreamer.h */; };
 		71CCF3C012770A8C00339E12 /* ietf.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF36F12770A8C00339E12 /* ietf.h */; };
 		71CCF3C112770A8C00339E12 /* avilib.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF37112770A8C00339E12 /* avilib.h */; };
 		71CCF3C212770A8C00339E12 /* bifs_dev.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF37212770A8C00339E12 /* bifs_dev.h */; };
@@ -295,8 +292,6 @@
 		71CCF3E912770A8C00339E12 /* nodes_mpeg4.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF39A12770A8C00339E12 /* nodes_mpeg4.h */; };
 		71CCF3EA12770A8C00339E12 /* nodes_svg.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF39B12770A8C00339E12 /* nodes_svg.h */; };
 		71CCF3EB12770A8C00339E12 /* nodes_x3d.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF39C12770A8C00339E12 /* nodes_x3d.h */; };
-		71CCF3EC12770A8C00339E12 /* nodes_xbl.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF39D12770A8C00339E12 /* nodes_xbl.h */; };
-		71CCF3ED12770A8C00339E12 /* options.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF39E12770A8C00339E12 /* options.h */; };
 		71CCF3EE12770A8C00339E12 /* path2d.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF39F12770A8C00339E12 /* path2d.h */; };
 		71CCF3EF12770A8C00339E12 /* rtp_streamer.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3A012770A8C00339E12 /* rtp_streamer.h */; };
 		71CCF3F012770A8C00339E12 /* scene_engine.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3A112770A8C00339E12 /* scene_engine.h */; };
@@ -307,15 +302,11 @@
 		71CCF3F512770A8C00339E12 /* setup.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3A612770A8C00339E12 /* setup.h */; };
 		71CCF3F612770A8C00339E12 /* svg_types.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3A712770A8C00339E12 /* svg_types.h */; };
 		71CCF3F712770A8C00339E12 /* sync_layer.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3A812770A8C00339E12 /* sync_layer.h */; };
-		71CCF3F812770A8C00339E12 /* term_info.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3A912770A8C00339E12 /* term_info.h */; };
-		71CCF3F912770A8C00339E12 /* terminal.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3AA12770A8C00339E12 /* terminal.h */; };
 		71CCF3FA12770A8C00339E12 /* thread.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3AB12770A8C00339E12 /* thread.h */; };
 		71CCF3FB12770A8C00339E12 /* token.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3AC12770A8C00339E12 /* token.h */; };
 		71CCF3FC12770A8C00339E12 /* tools.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3AD12770A8C00339E12 /* tools.h */; };
-		71CCF3FD12770A8C00339E12 /* user.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3AE12770A8C00339E12 /* user.h */; };
 		71CCF3FE12770A8C00339E12 /* utf.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3AF12770A8C00339E12 /* utf.h */; };
 		71CCF3FF12770A8C00339E12 /* xml.h in Headers */ = {isa = PBXBuildFile; fileRef = 71CCF3B012770A8C00339E12 /* xml.h */; };
-		71EC88E11396273B004DCB6A /* osmo.icns in Resources */ = {isa = PBXBuildFile; fileRef = 71EC88E01396273B004DCB6A /* osmo.icns */; };
 		8925C0EE25DD6F8900AFB064 /* libnghttp2.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 8925C0ED25DD6F8900AFB064 /* libnghttp2.a */; };
 		8959AC77211C9A26004D2C87 /* dmx_gsf.c in Sources */ = {isa = PBXBuildFile; fileRef = 8959AC76211C9A26004D2C87 /* dmx_gsf.c */; };
 		8959AC79211C9B29004D2C87 /* reframe_av1.c in Sources */ = {isa = PBXBuildFile; fileRef = 8959AC78211C9B29004D2C87 /* reframe_av1.c */; };
@@ -330,11 +321,9 @@
 		896CBC8921105A6900220377 /* libaom.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 896CBC8821105A6900220377 /* libaom.a */; };
 		9210BA1D234A909400ED2DFF /* evg.c in Sources */ = {isa = PBXBuildFile; fileRef = 9210BA1C234A909400ED2DFF /* evg.c */; };
 		9212C0FD222D7B3700FE3580 /* vflip.c in Sources */ = {isa = PBXBuildFile; fileRef = 9212C0FC222D7B3700FE3580 /* vflip.c */; };
+		9212C69F281847660058F76A /* gpac.icns in Resources */ = {isa = PBXBuildFile; fileRef = 9212C69E281847660058F76A /* gpac.icns */; };
 		921FEBA01CF8670A00B437C2 /* CoreLocation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 921FEB9E1CF8665900B437C2 /* CoreLocation.framework */; };
 		921FEBA11CF8671300B437C2 /* CoreMotion.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 921FEB9C1CF8664800B437C2 /* CoreMotion.framework */; };
-		921FEBA51CF881DE00B437C2 /* sensors_def.h in Headers */ = {isa = PBXBuildFile; fileRef = 921FEBA21CF881DE00B437C2 /* sensors_def.h */; };
-		921FEBA61CF881DE00B437C2 /* sensors.h in Headers */ = {isa = PBXBuildFile; fileRef = 921FEBA31CF881DE00B437C2 /* sensors.h */; };
-		921FEBA71CF881DE00B437C2 /* sensors.m in Sources */ = {isa = PBXBuildFile; fileRef = 921FEBA41CF881DE00B437C2 /* sensors.m */; };
 		92261A89239E326900C14199 /* out_http.c in Sources */ = {isa = PBXBuildFile; fileRef = 92261A88239E326900C14199 /* out_http.c */; };
 		9227B8582799F8E700BF3D1B /* bs_agg.c in Sources */ = {isa = PBXBuildFile; fileRef = 9227B8562799F8E600BF3D1B /* bs_agg.c */; };
 		9227B8592799F8E700BF3D1B /* bs_split.c in Sources */ = {isa = PBXBuildFile; fileRef = 9227B8572799F8E600BF3D1B /* bs_split.c */; };
@@ -361,17 +350,22 @@
 		92359C8A250F657B00525A42 /* in_route.c in Sources */ = {isa = PBXBuildFile; fileRef = 92359C89250F657A00525A42 /* in_route.c */; };
 		923EB53423D1B87E00E1FFA1 /* libbf.c in Sources */ = {isa = PBXBuildFile; fileRef = 923EB53323D1B87E00E1FFA1 /* libbf.c */; };
 		9246EE7724A1240600F72EAD /* filter_session_js.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246EE7624A1240600F72EAD /* filter_session_js.c */; };
+		924AB67F281438E100EC006F /* default.cfg in Resources */ = {isa = PBXBuildFile; fileRef = 924AB67E281438E000EC006F /* default.cfg */; };
+		924AB68128143DF500EC006F /* ios_main.m in Sources */ = {isa = PBXBuildFile; fileRef = 924AB68028143DF500EC006F /* ios_main.m */; };
+		924AB6832816F1DA00EC006F /* Metal.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 924AB6822816F1DA00EC006F /* Metal.framework */; };
+		924AB6852816F1E200EC006F /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 924AB6842816F1E200EC006F /* GameController.framework */; };
 		9251E540251E398700CEB84D /* res in Resources */ = {isa = PBXBuildFile; fileRef = 9251E53F251E398600CEB84D /* res */; };
 		9251E542251E39A300CEB84D /* scripts in Resources */ = {isa = PBXBuildFile; fileRef = 9251E541251E39A300CEB84D /* scripts */; };
 		925730A21A0916D20057FF04 /* libiconv.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 925730A11A0916D20057FF04 /* libiconv.dylib */; };
 		925730A41A0916DB0057FF04 /* libbz2.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 925730A31A0916DB0057FF04 /* libbz2.dylib */; };
+		925A7611292F998500664F38 /* sha256.c in Sources */ = {isa = PBXBuildFile; fileRef = 925A7610292F998500664F38 /* sha256.c */; };
 		925FF2A51ABC53F30085B04C /* odf_parse_common.h in Headers */ = {isa = PBXBuildFile; fileRef = 925FF2A31ABC53F30085B04C /* odf_parse_common.h */; };
 		925FF2A61ABC53F30085B04C /* smjs_api.h in Headers */ = {isa = PBXBuildFile; fileRef = 925FF2A41ABC53F30085B04C /* smjs_api.h */; };
 		925FF2A71ABC55030085B04C /* os_file.c in Sources */ = {isa = PBXBuildFile; fileRef = 71CCF2361277045100339E12 /* os_file.c */; };
 		9262B10C24B7791B009B059D /* core.c in Sources */ = {isa = PBXBuildFile; fileRef = 9262B10B24B7791B009B059D /* core.c */; };
+		9272B50627E4EFAD00D9D304 /* mux_ogg.c in Sources */ = {isa = PBXBuildFile; fileRef = 9272B50527E4EFAD00D9D304 /* mux_ogg.c */; };
 		92734635235084A50081AF74 /* storage.c in Sources */ = {isa = PBXBuildFile; fileRef = 92734634235084A50081AF74 /* storage.c */; };
 		9274295A24647B98009ADD8D /* bsrw.c in Sources */ = {isa = PBXBuildFile; fileRef = 9274295924647B98009ADD8D /* bsrw.c */; };
-		9280E7251DD23FFE001E6441 /* iTunesArtwork in Resources */ = {isa = PBXBuildFile; fileRef = 9236FDEF1DD23F1400B3E86F /* iTunesArtwork */; };
 		9281B63021C92D00006B0FD5 /* gui in Resources */ = {isa = PBXBuildFile; fileRef = 9281B62E21C92D00006B0FD5 /* gui */; };
 		9281B63121C92D00006B0FD5 /* shaders in Resources */ = {isa = PBXBuildFile; fileRef = 9281B62F21C92D00006B0FD5 /* shaders */; };
 		92852443237ACC2700165130 /* raster3d.c in Sources */ = {isa = PBXBuildFile; fileRef = 92852442237ACC2700165130 /* raster3d.c */; };
@@ -384,6 +378,8 @@
 		9288A54825AF6FCC006F7355 /* io_fcryp.c in Sources */ = {isa = PBXBuildFile; fileRef = 9288A54725AF6FCC006F7355 /* io_fcryp.c */; };
 		928B2D131BE11BC100CAC65D /* libcrypto.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 928B2D111BE11BC100CAC65D /* libcrypto.a */; };
 		928B2D141BE11BC100CAC65D /* libssl.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 928B2D121BE11BC100CAC65D /* libssl.a */; };
+		928E0BD828E2FC5F00F2BA27 /* unframer.c in Sources */ = {isa = PBXBuildFile; fileRef = 928E0BD728E2FC5F00F2BA27 /* unframer.c */; };
+		928E0BDC28E43D8200F2BA27 /* ff_bsf.c in Sources */ = {isa = PBXBuildFile; fileRef = 928E0BDB28E43D8200F2BA27 /* ff_bsf.c */; };
 		928EB67525271B5800E47747 /* rewrite_mhas.c in Sources */ = {isa = PBXBuildFile; fileRef = 928EB67425271B5800E47747 /* rewrite_mhas.c */; };
 		9290E74E25263F4F00BC0EE3 /* reframe_mhas.c in Sources */ = {isa = PBXBuildFile; fileRef = 9290E74D25263F4E00BC0EE3 /* reframe_mhas.c */; };
 		92910FAA233A44110052365D /* jsfilter.c in Sources */ = {isa = PBXBuildFile; fileRef = 92910FA9233A44110052365D /* jsfilter.c */; };
@@ -394,11 +390,8 @@
 		9296BF2422CFBB3900DC9742 /* reframe_flac.c in Sources */ = {isa = PBXBuildFile; fileRef = 9296BF2322CFBB3900DC9742 /* reframe_flac.c */; };
 		9298677A2357A0DA008A2CC6 /* webgl.h in Headers */ = {isa = PBXBuildFile; fileRef = 929867782357A0DA008A2CC6 /* webgl.h */; };
 		9298677F235A1587008A2CC6 /* gltools.c in Sources */ = {isa = PBXBuildFile; fileRef = 9298677E235A1587008A2CC6 /* gltools.c */; };
-		929A929C16EF8BC200B7C64F /* Default-568h@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 929A929616EF8BC200B7C64F /* Default-568h@2x.png */; };
-		929A929D16EF8BC200B7C64F /* icon_ipad_retina.png in Resources */ = {isa = PBXBuildFile; fileRef = 929A929716EF8BC200B7C64F /* icon_ipad_retina.png */; };
-		929A929E16EF8BC200B7C64F /* icon_ipad.png in Resources */ = {isa = PBXBuildFile; fileRef = 929A929816EF8BC200B7C64F /* icon_ipad.png */; };
-		929A929F16EF8BC200B7C64F /* icon_retina.png in Resources */ = {isa = PBXBuildFile; fileRef = 929A929916EF8BC200B7C64F /* icon_retina.png */; };
-		929A92A016EF8BC200B7C64F /* icon.png in Resources */ = {isa = PBXBuildFile; fileRef = 929A929A16EF8BC200B7C64F /* icon.png */; };
+		929A29272801EBD700635DEB /* ttml_conv.c in Sources */ = {isa = PBXBuildFile; fileRef = 929A29252801EBD700635DEB /* ttml_conv.c */; };
+		929A29282801EBD700635DEB /* write_tx3g.c in Sources */ = {isa = PBXBuildFile; fileRef = 929A29262801EBD700635DEB /* write_tx3g.c */; };
 		929DE74924183FB40056AFA7 /* gzio.c in Sources */ = {isa = PBXBuildFile; fileRef = 929DE74824183FB40056AFA7 /* gzio.c */; };
 		929FA64321A3E83F000455A7 /* reframe_latm.c in Sources */ = {isa = PBXBuildFile; fileRef = 929FA64221A3E83E000455A7 /* reframe_latm.c */; };
 		92A8710025150CF70047560D /* out_route.c in Sources */ = {isa = PBXBuildFile; fileRef = 92A870FF25150CF70047560D /* out_route.c */; };
@@ -416,6 +409,17 @@
 		92BC213716EF8E7A000E0620 /* video.c in Sources */ = {isa = PBXBuildFile; fileRef = 71A1999E1278778800ACFF58 /* video.c */; };
 		92C0F38021EDFA8E002961C8 /* out_rtp.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C0F37F21EDFA8D002961C8 /* out_rtp.c */; };
 		92C236E82576DC4E00CD59A9 /* tilesplit.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C236E72576DC4E00CD59A9 /* tilesplit.c */; };
+		92C69C62281323B800051866 /* compositor_tools.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C69C5F281323B800051866 /* compositor_tools.c */; };
+		92C69C63281323B800051866 /* gpac_help.c in Sources */ = {isa = PBXBuildFile; fileRef = 92C69C60281323B800051866 /* gpac_help.c */; };
+		92C69C65281323D700051866 /* ios-Info.plist in Resources */ = {isa = PBXBuildFile; fileRef = 92C69C64281323D700051866 /* ios-Info.plist */; };
+		92C69C6D281323EA00051866 /* icon_ipad.png in Resources */ = {isa = PBXBuildFile; fileRef = 92C69C66281323EA00051866 /* icon_ipad.png */; };
+		92C69C6E281323EA00051866 /* icon_ipad_retina.png in Resources */ = {isa = PBXBuildFile; fileRef = 92C69C67281323EA00051866 /* icon_ipad_retina.png */; };
+		92C69C6F281323EA00051866 /* iTunesArtwork in Resources */ = {isa = PBXBuildFile; fileRef = 92C69C68281323EA00051866 /* iTunesArtwork */; };
+		92C69C70281323EA00051866 /* icon.png in Resources */ = {isa = PBXBuildFile; fileRef = 92C69C69281323EA00051866 /* icon.png */; };
+		92C69C71281323EA00051866 /* Default-568h@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 92C69C6A281323EA00051866 /* Default-568h@2x.png */; };
+		92C69C72281323EA00051866 /* icon_retina.png in Resources */ = {isa = PBXBuildFile; fileRef = 92C69C6B281323EA00051866 /* icon_retina.png */; };
+		92C69C77281323FA00051866 /* sensors.m in Sources */ = {isa = PBXBuildFile; fileRef = 92C69C74281323FA00051866 /* sensors.m */; };
+		92D1555D282BF23500AE8BC9 /* gpac.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D1555C282BF23500AE8BC9 /* gpac.c */; };
 		92D6C5A62343BF6A00262217 /* xhr.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D6C5A42343BF6A00262217 /* xhr.c */; };
 		92D6C5A72343BF6A00262217 /* scene_js.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D6C5A52343BF6A00262217 /* scene_js.c */; };
 		92D6C5AB2343BF9400262217 /* svg_js.c in Sources */ = {isa = PBXBuildFile; fileRef = 92D6C5A82343BF9400262217 /* svg_js.c */; };
@@ -554,8 +558,6 @@
 		970A26CD13434D780007362C /* m3u8.h in Headers */ = {isa = PBXBuildFile; fileRef = 970A26CB13434D780007362C /* m3u8.h */; };
 		970A26CE13434D780007362C /* mpd.h in Headers */ = {isa = PBXBuildFile; fileRef = 970A26CC13434D780007362C /* mpd.h */; };
 		970A26D213434D960007362C /* cache.h in Headers */ = {isa = PBXBuildFile; fileRef = 970A26CF13434D960007362C /* cache.h */; };
-		970A26D313434D960007362C /* ringbuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 970A26D013434D960007362C /* ringbuffer.h */; };
-		970A26D413434D960007362C /* unicode.h in Headers */ = {isa = PBXBuildFile; fileRef = 970A26D113434D960007362C /* unicode.h */; };
 		970A26D813434DAC0007362C /* unicode.c in Sources */ = {isa = PBXBuildFile; fileRef = 970A26D613434DAC0007362C /* unicode.c */; };
 		97116F211646E38D00BD1AD0 /* box_code_adobe.c in Sources */ = {isa = PBXBuildFile; fileRef = 97116F201646E38D00BD1AD0 /* box_code_adobe.c */; };
 		9719CE751704C35000381CE6 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 9793AE341704C0BD00E0C938 /* CoreGraphics.framework */; };
@@ -614,9 +616,7 @@
 		71A1999C1278778800ACFF58 /* sdl_out.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = sdl_out.c; sourceTree = "<group>"; };
 		71A1999D1278778800ACFF58 /* sdl_out.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sdl_out.h; sourceTree = "<group>"; };
 		71A1999E1278778800ACFF58 /* video.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = video.c; sourceTree = "<group>"; };
-		71A19B1A12796B5600ACFF58 /* osmo4ios.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = osmo4ios.app; sourceTree = BUILT_PRODUCTS_DIR; };
-		71A19B1C12796B5700ACFF58 /* osmo4ios-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = "osmo4ios-Info.plist"; path = "../../applications/osmo4_ios/osmo4ios-Info.plist"; sourceTree = "<group>"; };
-		71A19B2012796B6F00ACFF58 /* main.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = main.c; path = ../../applications/osmo4_ios/main.c; sourceTree = SOURCE_ROOT; };
+		71A19B1A12796B5600ACFF58 /* gpac4ios.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = gpac4ios.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		71A19BB112797D1B00ACFF58 /* OpenGLES.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenGLES.framework; path = System/Library/Frameworks/OpenGLES.framework; sourceTree = SDKROOT; };
 		71A19BC312797D9200ACFF58 /* libobjc.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libobjc.dylib; path = usr/lib/libobjc.dylib; sourceTree = SDKROOT; };
 		71A19BCC12797DBA00ACFF58 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; };
@@ -811,7 +811,6 @@
 		71CCF2101277045100339E12 /* vrml_tools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = vrml_tools.c; sourceTree = "<group>"; };
 		71CCF2111277045100339E12 /* x3d_nodes.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = x3d_nodes.c; sourceTree = "<group>"; };
 		71CCF2131277045100339E12 /* xml_ns.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = xml_ns.c; sourceTree = "<group>"; };
-		71CCF2281277045100339E12 /* terminal.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = terminal.c; sourceTree = "<group>"; };
 		71CCF22A1277045100339E12 /* base_encoding.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = base_encoding.c; sourceTree = "<group>"; };
 		71CCF22B1277045100339E12 /* bitstream.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = bitstream.c; sourceTree = "<group>"; };
 		71CCF22C1277045100339E12 /* color.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = color.c; sourceTree = "<group>"; };
@@ -848,7 +847,6 @@
 		71CCF36A12770A8C00339E12 /* download.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = download.h; sourceTree = "<group>"; };
 		71CCF36B12770A8C00339E12 /* dvb_mpe.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dvb_mpe.h; sourceTree = "<group>"; };
 		71CCF36D12770A8C00339E12 /* events.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = events.h; sourceTree = "<group>"; };
-		71CCF36E12770A8C00339E12 /* filestreamer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = filestreamer.h; sourceTree = "<group>"; };
 		71CCF36F12770A8C00339E12 /* ietf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ietf.h; sourceTree = "<group>"; };
 		71CCF37112770A8C00339E12 /* avilib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = avilib.h; sourceTree = "<group>"; };
 		71CCF37212770A8C00339E12 /* bifs_dev.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bifs_dev.h; sourceTree = "<group>"; };
@@ -891,8 +889,6 @@
 		71CCF39A12770A8C00339E12 /* nodes_mpeg4.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nodes_mpeg4.h; sourceTree = "<group>"; };
 		71CCF39B12770A8C00339E12 /* nodes_svg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nodes_svg.h; sourceTree = "<group>"; };
 		71CCF39C12770A8C00339E12 /* nodes_x3d.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nodes_x3d.h; sourceTree = "<group>"; };
-		71CCF39D12770A8C00339E12 /* nodes_xbl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nodes_xbl.h; sourceTree = "<group>"; };
-		71CCF39E12770A8C00339E12 /* options.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = options.h; sourceTree = "<group>"; };
 		71CCF39F12770A8C00339E12 /* path2d.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = path2d.h; sourceTree = "<group>"; };
 		71CCF3A012770A8C00339E12 /* rtp_streamer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rtp_streamer.h; sourceTree = "<group>"; };
 		71CCF3A112770A8C00339E12 /* scene_engine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scene_engine.h; sourceTree = "<group>"; };
@@ -903,15 +899,11 @@
 		71CCF3A612770A8C00339E12 /* setup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = setup.h; sourceTree = "<group>"; };
 		71CCF3A712770A8C00339E12 /* svg_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = svg_types.h; sourceTree = "<group>"; };
 		71CCF3A812770A8C00339E12 /* sync_layer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sync_layer.h; sourceTree = "<group>"; };
-		71CCF3A912770A8C00339E12 /* term_info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = term_info.h; sourceTree = "<group>"; };
-		71CCF3AA12770A8C00339E12 /* terminal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = terminal.h; sourceTree = "<group>"; };
 		71CCF3AB12770A8C00339E12 /* thread.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = thread.h; sourceTree = "<group>"; };
 		71CCF3AC12770A8C00339E12 /* token.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = token.h; sourceTree = "<group>"; };
 		71CCF3AD12770A8C00339E12 /* tools.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tools.h; sourceTree = "<group>"; };
-		71CCF3AE12770A8C00339E12 /* user.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = user.h; sourceTree = "<group>"; };
 		71CCF3AF12770A8C00339E12 /* utf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utf.h; sourceTree = "<group>"; };
 		71CCF3B012770A8C00339E12 /* xml.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xml.h; sourceTree = "<group>"; };
-		71EC88E01396273B004DCB6A /* osmo.icns */ = {isa = PBXFileReference; explicitFileType = image.icns; name = osmo.icns; path = ../../applications/osmo4_ios/Resources/osmo.icns; sourceTree = SOURCE_ROOT; };
 		71F2A45012830B1400C384DE /* libfaad.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libfaad.a; path = ../../extra_lib/lib/iOS/libfaad.a; sourceTree = SOURCE_ROOT; };
 		71F2A45112830B1400C384DE /* libfreetype.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libfreetype.a; path = ../../extra_lib/lib/iOS/libfreetype.a; sourceTree = SOURCE_ROOT; };
 		71F2A45312830B1400C384DE /* libjpeg.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libjpeg.a; path = ../../extra_lib/lib/iOS/libjpeg.a; sourceTree = SOURCE_ROOT; };
@@ -932,11 +924,9 @@
 		896CBC8821105A6900220377 /* libaom.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libaom.a; path = ../../extra_lib/lib/iOS/libaom.a; sourceTree = "<group>"; };
 		9210BA1C234A909400ED2DFF /* evg.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = evg.c; path = ../../src/jsmods/evg.c; sourceTree = "<group>"; };
 		9212C0FC222D7B3700FE3580 /* vflip.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = vflip.c; path = ../../src/filters/vflip.c; sourceTree = "<group>"; };
+		9212C69E281847660058F76A /* gpac.icns */ = {isa = PBXFileReference; lastKnownFileType = image.icns; name = gpac.icns; path = ../../applications/gpac/ios_res/gpac.icns; sourceTree = "<group>"; };
 		921FEB9C1CF8664800B437C2 /* CoreMotion.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreMotion.framework; path = System/Library/Frameworks/CoreMotion.framework; sourceTree = SDKROOT; };
 		921FEB9E1CF8665900B437C2 /* CoreLocation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreLocation.framework; path = System/Library/Frameworks/CoreLocation.framework; sourceTree = SDKROOT; };
-		921FEBA21CF881DE00B437C2 /* sensors_def.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = sensors_def.h; path = ../../applications/osmo4_ios/sensors_def.h; sourceTree = "<group>"; };
-		921FEBA31CF881DE00B437C2 /* sensors.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = sensors.h; path = ../../applications/osmo4_ios/sensors.h; sourceTree = "<group>"; };
-		921FEBA41CF881DE00B437C2 /* sensors.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = sensors.m; path = ../../applications/osmo4_ios/sensors.m; sourceTree = "<group>"; };
 		92261A88239E326900C14199 /* out_http.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = out_http.c; path = ../../src/filters/out_http.c; sourceTree = "<group>"; };
 		9227B8562799F8E600BF3D1B /* bs_agg.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bs_agg.c; path = ../../src/filters/bs_agg.c; sourceTree = "<group>"; };
 		9227B8572799F8E600BF3D1B /* bs_split.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bs_split.c; path = ../../src/filters/bs_split.c; sourceTree = "<group>"; };
@@ -961,16 +951,22 @@
 		92359C80250F651900525A42 /* Remotery.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Remotery.h; sourceTree = "<group>"; };
 		92359C87250F652700525A42 /* route_dmx.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = route_dmx.c; sourceTree = "<group>"; };
 		92359C89250F657A00525A42 /* in_route.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = in_route.c; path = ../../src/filters/in_route.c; sourceTree = "<group>"; };
-		9236FDEF1DD23F1400B3E86F /* iTunesArtwork */ = {isa = PBXFileReference; lastKnownFileType = file; name = iTunesArtwork; path = ../../applications/osmo4_ios/Resources/iTunesArtwork; sourceTree = "<group>"; };
 		923EB53323D1B87E00E1FFA1 /* libbf.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = libbf.c; path = ../../src/quickjs/libbf.c; sourceTree = "<group>"; };
 		9246EE7624A1240600F72EAD /* filter_session_js.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = filter_session_js.c; path = ../../src/filter_core/filter_session_js.c; sourceTree = "<group>"; };
+		924AB67E281438E000EC006F /* default.cfg */ = {isa = PBXFileReference; lastKnownFileType = text; name = default.cfg; path = ../../share/default.cfg; sourceTree = "<group>"; };
+		924AB68028143DF500EC006F /* ios_main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = ios_main.m; path = ../../applications/gpac/ios_main.m; sourceTree = "<group>"; };
+		924AB6822816F1DA00EC006F /* Metal.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Metal.framework; path = System/Library/Frameworks/Metal.framework; sourceTree = SDKROOT; };
+		924AB6842816F1E200EC006F /* GameController.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = GameController.framework; path = System/Library/Frameworks/GameController.framework; sourceTree = SDKROOT; };
+		924AB6862816F20300EC006F /* CoreHaptics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreHaptics.framework; path = System/Library/Frameworks/CoreHaptics.framework; sourceTree = SDKROOT; };
 		9251E53F251E398600CEB84D /* res */ = {isa = PBXFileReference; lastKnownFileType = folder; name = res; path = ../../share/res; sourceTree = "<group>"; };
 		9251E541251E39A300CEB84D /* scripts */ = {isa = PBXFileReference; lastKnownFileType = folder; name = scripts; path = ../../share/scripts; sourceTree = "<group>"; };
 		925730A11A0916D20057FF04 /* libiconv.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libiconv.dylib; path = usr/lib/libiconv.dylib; sourceTree = SDKROOT; };
 		925730A31A0916DB0057FF04 /* libbz2.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libbz2.dylib; path = usr/lib/libbz2.dylib; sourceTree = SDKROOT; };
+		925A7610292F998500664F38 /* sha256.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = sha256.c; sourceTree = "<group>"; };
 		925FF2A31ABC53F30085B04C /* odf_parse_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = odf_parse_common.h; sourceTree = "<group>"; };
 		925FF2A41ABC53F30085B04C /* smjs_api.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = smjs_api.h; sourceTree = "<group>"; };
 		9262B10B24B7791B009B059D /* core.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = core.c; path = ../../src/jsmods/core.c; sourceTree = "<group>"; };
+		9272B50527E4EFAD00D9D304 /* mux_ogg.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = mux_ogg.c; path = ../../src/filters/mux_ogg.c; sourceTree = "<group>"; };
 		92734634235084A50081AF74 /* storage.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = storage.c; path = ../../src/jsmods/storage.c; sourceTree = "<group>"; };
 		9274295924647B98009ADD8D /* bsrw.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bsrw.c; path = ../../src/filters/bsrw.c; sourceTree = "<group>"; };
 		9281B62E21C92D00006B0FD5 /* gui */ = {isa = PBXFileReference; lastKnownFileType = folder; name = gui; path = ../../share/gui; sourceTree = "<group>"; };
@@ -985,6 +981,8 @@
 		9288A54725AF6FCC006F7355 /* io_fcryp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = io_fcryp.c; path = ../../src/filters/io_fcryp.c; sourceTree = "<group>"; };
 		928B2D111BE11BC100CAC65D /* libcrypto.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libcrypto.a; path = ../../extra_lib/lib/iOS/libcrypto.a; sourceTree = "<group>"; };
 		928B2D121BE11BC100CAC65D /* libssl.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libssl.a; path = ../../extra_lib/lib/iOS/libssl.a; sourceTree = "<group>"; };
+		928E0BD728E2FC5F00F2BA27 /* unframer.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = unframer.c; path = ../../src/filters/unframer.c; sourceTree = "<group>"; };
+		928E0BDB28E43D8200F2BA27 /* ff_bsf.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ff_bsf.c; path = ../../src/filters/ff_bsf.c; sourceTree = "<group>"; };
 		928EB67425271B5800E47747 /* rewrite_mhas.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = rewrite_mhas.c; path = ../../src/filters/rewrite_mhas.c; sourceTree = "<group>"; };
 		9290E74D25263F4E00BC0EE3 /* reframe_mhas.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_mhas.c; path = ../../src/filters/reframe_mhas.c; sourceTree = "<group>"; };
 		92910FA9233A44110052365D /* jsfilter.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jsfilter.c; path = ../../src/filters/jsfilter.c; sourceTree = "<group>"; };
@@ -995,11 +993,8 @@
 		9296BF2322CFBB3900DC9742 /* reframe_flac.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_flac.c; path = ../../src/filters/reframe_flac.c; sourceTree = "<group>"; };
 		929867782357A0DA008A2CC6 /* webgl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = webgl.h; path = ../../src/jsmods/webgl.h; sourceTree = "<group>"; };
 		9298677E235A1587008A2CC6 /* gltools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = gltools.c; sourceTree = "<group>"; };
-		929A929616EF8BC200B7C64F /* Default-568h@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = "Default-568h@2x.png"; path = "../../applications/osmo4_ios/Resources/Default-568h@2x.png"; sourceTree = SOURCE_ROOT; };
-		929A929716EF8BC200B7C64F /* icon_ipad_retina.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon_ipad_retina.png; path = ../../applications/osmo4_ios/Resources/icon_ipad_retina.png; sourceTree = SOURCE_ROOT; };
-		929A929816EF8BC200B7C64F /* icon_ipad.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon_ipad.png; path = ../../applications/osmo4_ios/Resources/icon_ipad.png; sourceTree = SOURCE_ROOT; };
-		929A929916EF8BC200B7C64F /* icon_retina.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon_retina.png; path = ../../applications/osmo4_ios/Resources/icon_retina.png; sourceTree = SOURCE_ROOT; };
-		929A929A16EF8BC200B7C64F /* icon.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon.png; path = ../../applications/osmo4_ios/Resources/icon.png; sourceTree = SOURCE_ROOT; };
+		929A29252801EBD700635DEB /* ttml_conv.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ttml_conv.c; path = ../../src/filters/ttml_conv.c; sourceTree = "<group>"; };
+		929A29262801EBD700635DEB /* write_tx3g.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = write_tx3g.c; path = ../../src/filters/write_tx3g.c; sourceTree = "<group>"; };
 		929DE74824183FB40056AFA7 /* gzio.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = gzio.c; sourceTree = "<group>"; };
 		929FA64221A3E83E000455A7 /* reframe_latm.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = reframe_latm.c; path = ../../src/filters/reframe_latm.c; sourceTree = "<group>"; };
 		92A870FF25150CF70047560D /* out_route.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = out_route.c; path = ../../src/filters/out_route.c; sourceTree = "<group>"; };
@@ -1010,6 +1005,20 @@
 		92B2A4AD229D6646002A65A7 /* hevcsplit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = hevcsplit.c; path = ../../src/filters/hevcsplit.c; sourceTree = "<group>"; };
 		92C0F37F21EDFA8D002961C8 /* out_rtp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = out_rtp.c; path = ../../src/filters/out_rtp.c; sourceTree = "<group>"; };
 		92C236E72576DC4E00CD59A9 /* tilesplit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = tilesplit.c; path = ../../src/filters/tilesplit.c; sourceTree = "<group>"; };
+		92C69C5E281323B800051866 /* gpac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = gpac.h; path = ../../applications/gpac/gpac.h; sourceTree = "<group>"; };
+		92C69C5F281323B800051866 /* compositor_tools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = compositor_tools.c; path = ../../applications/gpac/compositor_tools.c; sourceTree = "<group>"; };
+		92C69C60281323B800051866 /* gpac_help.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gpac_help.c; path = ../../applications/gpac/gpac_help.c; sourceTree = "<group>"; };
+		92C69C64281323D700051866 /* ios-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = "ios-Info.plist"; path = "../../applications/gpac/ios-Info.plist"; sourceTree = "<group>"; };
+		92C69C66281323EA00051866 /* icon_ipad.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon_ipad.png; path = ../../applications/gpac/ios_res/icon_ipad.png; sourceTree = "<group>"; };
+		92C69C67281323EA00051866 /* icon_ipad_retina.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon_ipad_retina.png; path = ../../applications/gpac/ios_res/icon_ipad_retina.png; sourceTree = "<group>"; };
+		92C69C68281323EA00051866 /* iTunesArtwork */ = {isa = PBXFileReference; lastKnownFileType = file; name = iTunesArtwork; path = ../../applications/gpac/ios_res/iTunesArtwork; sourceTree = "<group>"; };
+		92C69C69281323EA00051866 /* icon.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon.png; path = ../../applications/gpac/ios_res/icon.png; sourceTree = "<group>"; };
+		92C69C6A281323EA00051866 /* Default-568h@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = "Default-568h@2x.png"; path = "../../applications/gpac/ios_res/Default-568h@2x.png"; sourceTree = "<group>"; };
+		92C69C6B281323EA00051866 /* icon_retina.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = icon_retina.png; path = ../../applications/gpac/ios_res/icon_retina.png; sourceTree = "<group>"; };
+		92C69C74281323FA00051866 /* sensors.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = sensors.m; path = ../../applications/gpac/ios_sensors/sensors.m; sourceTree = "<group>"; };
+		92C69C75281323FA00051866 /* sensors_def.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = sensors_def.h; path = ../../applications/gpac/ios_sensors/sensors_def.h; sourceTree = "<group>"; };
+		92C69C76281323FA00051866 /* sensors.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = sensors.h; path = ../../applications/gpac/ios_sensors/sensors.h; sourceTree = "<group>"; };
+		92D1555C282BF23500AE8BC9 /* gpac.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gpac.c; path = ../../applications/gpac/gpac.c; sourceTree = "<group>"; };
 		92D6C5A42343BF6A00262217 /* xhr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xhr.c; path = ../../src/jsmods/xhr.c; sourceTree = "<group>"; };
 		92D6C5A52343BF6A00262217 /* scene_js.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = scene_js.c; path = ../../src/jsmods/scene_js.c; sourceTree = "<group>"; };
 		92D6C5A82343BF9400262217 /* svg_js.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = svg_js.c; sourceTree = "<group>"; };
@@ -1149,8 +1158,6 @@
 		970A26CB13434D780007362C /* m3u8.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = m3u8.h; sourceTree = "<group>"; };
 		970A26CC13434D780007362C /* mpd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpd.h; sourceTree = "<group>"; };
 		970A26CF13434D960007362C /* cache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cache.h; sourceTree = "<group>"; };
-		970A26D013434D960007362C /* ringbuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ringbuffer.h; sourceTree = "<group>"; };
-		970A26D113434D960007362C /* unicode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unicode.h; sourceTree = "<group>"; };
 		970A26D613434DAC0007362C /* unicode.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = unicode.c; sourceTree = "<group>"; };
 		970A270D1343540C0007362C /* libgcc_s.1.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libgcc_s.1.dylib; path = usr/lib/libgcc_s.1.dylib; sourceTree = SDKROOT; };
 		97116F201646E38D00BD1AD0 /* box_code_adobe.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = box_code_adobe.c; sourceTree = "<group>"; };
@@ -1174,6 +1181,8 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				924AB6852816F1E200EC006F /* GameController.framework in Frameworks */,
+				924AB6832816F1DA00EC006F /* Metal.framework in Frameworks */,
 				8925C0EE25DD6F8900AFB064 /* libnghttp2.a in Frameworks */,
 				92EB6E4220E4ECD500A97A49 /* AVFoundation.framework in Frameworks */,
 				92EB6E4020E4EC9700A97A49 /* libavfilter.a in Frameworks */,
@@ -1227,13 +1236,14 @@
 		29B97314FDCFA39411CA2CEA /* CustomTemplate */ = {
 			isa = PBXGroup;
 			children = (
+				924AB67E281438E000EC006F /* default.cfg */,
 				9251E541251E39A300CEB84D /* scripts */,
 				9251E53F251E398600CEB84D /* res */,
 				9281B62E21C92D00006B0FD5 /* gui */,
 				9281B62F21C92D00006B0FD5 /* shaders */,
 				71CCF1381277041D00339E12 /* libgpac */,
 				929A929516EF8A7500B7C64F /* modules */,
-				71A19B1412796AC700ACFF58 /* osmo4iOS */,
+				71A19B1412796AC700ACFF58 /* GPAC */,
 				7184780712785F7B00917298 /* Frameworks */,
 				71CCF1321277037A00339E12 /* Products */,
 				92EB6E3920E4E62200A97A49 /* Recovered References */,
@@ -1244,6 +1254,9 @@
 		7184780712785F7B00917298 /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
+				924AB6862816F20300EC006F /* CoreHaptics.framework */,
+				924AB6842816F1E200EC006F /* GameController.framework */,
+				924AB6822816F1DA00EC006F /* Metal.framework */,
 				8925C0ED25DD6F8900AFB064 /* libnghttp2.a */,
 				92EB6E4120E4ECD500A97A49 /* AVFoundation.framework */,
 				92EB6E3F20E4EC9700A97A49 /* libavfilter.a */,
@@ -1300,30 +1313,27 @@
 			path = ../../modules/sdl_out;
 			sourceTree = SOURCE_ROOT;
 		};
-		71A19B1412796AC700ACFF58 /* osmo4iOS */ = {
+		71A19B1412796AC700ACFF58 /* GPAC */ = {
 			isa = PBXGroup;
 			children = (
-				921FEBA21CF881DE00B437C2 /* sensors_def.h */,
-				921FEBA31CF881DE00B437C2 /* sensors.h */,
-				921FEBA41CF881DE00B437C2 /* sensors.m */,
-				929A929616EF8BC200B7C64F /* Default-568h@2x.png */,
-				929A929716EF8BC200B7C64F /* icon_ipad_retina.png */,
-				929A929816EF8BC200B7C64F /* icon_ipad.png */,
-				929A929916EF8BC200B7C64F /* icon_retina.png */,
-				929A929A16EF8BC200B7C64F /* icon.png */,
-				9236FDEF1DD23F1400B3E86F /* iTunesArtwork */,
-				71EC88E01396273B004DCB6A /* osmo.icns */,
-				71A19B2012796B6F00ACFF58 /* main.c */,
-				71A19B1C12796B5700ACFF58 /* osmo4ios-Info.plist */,
+				92D1555C282BF23500AE8BC9 /* gpac.c */,
+				92C69C60281323B800051866 /* gpac_help.c */,
+				92C69C5E281323B800051866 /* gpac.h */,
+				92C69C5F281323B800051866 /* compositor_tools.c */,
+				924AB68028143DF500EC006F /* ios_main.m */,
+				92C69C7A2813F1CD00051866 /* Resources */,
+				92C69C75281323FA00051866 /* sensors_def.h */,
+				92C69C76281323FA00051866 /* sensors.h */,
+				92C69C74281323FA00051866 /* sensors.m */,
 			);
-			name = osmo4iOS;
+			name = GPAC;
 			sourceTree = "<group>";
 		};
 		71CCF1321277037A00339E12 /* Products */ = {
 			isa = PBXGroup;
 			children = (
 				71CCF1311277037A00339E12 /* libgpac_static.a */,
-				71A19B1A12796B5600ACFF58 /* osmo4ios.app */,
+				71A19B1A12796B5600ACFF58 /* gpac4ios.app */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -1347,7 +1357,6 @@
 				92334CBB2333AB8200DA6051 /* quickjs */,
 				71CCF1EF1277045100339E12 /* scene_manager */,
 				71CCF1FD1277045100339E12 /* scenegraph */,
-				71CCF2141277045100339E12 /* terminal */,
 				71CCF2291277045100339E12 /* utils */,
 			);
 			name = libgpac;
@@ -1380,22 +1389,12 @@
 		71CCF14A1277045100339E12 /* compositor */ = {
 			isa = PBXGroup;
 			children = (
-				92EB6E2720E4E58D00A97A49 /* clock.c */,
-				92EB6E2B20E4E58E00A97A49 /* media_object.c */,
-				92EB6E2420E4E58D00A97A49 /* mpeg4_inline.c */,
-				92EB6E2320E4E58D00A97A49 /* mpeg4_inputsensor.c */,
-				92EB6E2C20E4E58E00A97A49 /* mpeg4_mediacontrol.c */,
-				92EB6E2920E4E58E00A97A49 /* mpeg4_mediasensor.c */,
-				92EB6E2D20E4E58E00A97A49 /* object_manager.c */,
-				92EB6E2520E4E58D00A97A49 /* scene_node_init.c */,
-				92EB6E2820E4E58E00A97A49 /* scene_ns.c */,
-				92EB6E2A20E4E58E00A97A49 /* scene.c */,
-				92EB6E2620E4E58D00A97A49 /* svg_external.c */,
 				71CCF14B1277045100339E12 /* audio_input.c */,
 				71CCF14C1277045100339E12 /* audio_mixer.c */,
 				71CCF14D1277045100339E12 /* audio_render.c */,
 				71CCF14E1277045100339E12 /* bindable.c */,
 				71CCF14F1277045100339E12 /* camera.c */,
+				92EB6E2720E4E58D00A97A49 /* clock.c */,
 				71CCF1501277045100339E12 /* compositor.c */,
 				71CCF1511277045100339E12 /* compositor_2d.c */,
 				71CCF1521277045100339E12 /* compositor_3d.c */,
@@ -1407,6 +1406,7 @@
 				71CCF1581277045100339E12 /* gl_inc.h */,
 				71CCF1591277045100339E12 /* hardcoded_protos.c */,
 				71CCF15A1277045100339E12 /* hc_flash_shape.c */,
+				92EB6E2B20E4E58E00A97A49 /* media_object.c */,
 				71CCF15B1277045100339E12 /* mesh.c */,
 				71CCF15C1277045100339E12 /* mesh_collide.c */,
 				71CCF15D1277045100339E12 /* mesh_tesselate.c */,
@@ -1426,10 +1426,14 @@
 				71CCF16B1277045100339E12 /* mpeg4_grouping.h */,
 				71CCF16C1277045100339E12 /* mpeg4_grouping_2d.c */,
 				71CCF16D1277045100339E12 /* mpeg4_grouping_3d.c */,
+				92EB6E2420E4E58D00A97A49 /* mpeg4_inline.c */,
+				92EB6E2320E4E58D00A97A49 /* mpeg4_inputsensor.c */,
 				71CCF16E1277045100339E12 /* mpeg4_layer_2d.c */,
 				71CCF16F1277045100339E12 /* mpeg4_layer_3d.c */,
 				71CCF1701277045100339E12 /* mpeg4_layout.c */,
 				71CCF1711277045100339E12 /* mpeg4_lighting.c */,
+				92EB6E2C20E4E58E00A97A49 /* mpeg4_mediacontrol.c */,
+				92EB6E2920E4E58E00A97A49 /* mpeg4_mediasensor.c */,
 				71CCF1721277045100339E12 /* mpeg4_path_layout.c */,
 				71CCF1731277045100339E12 /* mpeg4_sensors.c */,
 				71CCF1741277045100339E12 /* mpeg4_sound.c */,
@@ -1438,10 +1442,15 @@
 				71CCF1771277045100339E12 /* mpeg4_timesensor.c */,
 				71CCF1781277045100339E12 /* mpeg4_viewport.c */,
 				71CCF1791277045100339E12 /* navigate.c */,
+				92EB6E2D20E4E58E00A97A49 /* object_manager.c */,
 				71CCF17A1277045100339E12 /* nodes_stacks.h */,
 				71CCF17B1277045100339E12 /* offscreen_cache.c */,
 				71CCF17C1277045100339E12 /* offscreen_cache.h */,
+				92EB6E2520E4E58D00A97A49 /* scene_node_init.c */,
+				92EB6E2820E4E58E00A97A49 /* scene_ns.c */,
+				92EB6E2A20E4E58E00A97A49 /* scene.c */,
 				71CCF17D1277045100339E12 /* svg_base.c */,
+				92EB6E2620E4E58D00A97A49 /* svg_external.c */,
 				71CCF17E1277045100339E12 /* svg_filters.c */,
 				71CCF17F1277045100339E12 /* svg_font.c */,
 				71CCF1801277045100339E12 /* svg_geometry.c */,
@@ -1638,26 +1647,14 @@
 			path = ../../src/scenegraph;
 			sourceTree = SOURCE_ROOT;
 		};
-		71CCF2141277045100339E12 /* terminal */ = {
-			isa = PBXGroup;
-			children = (
-				71CCF2281277045100339E12 /* terminal.c */,
-			);
-			name = terminal;
-			path = ../../src/terminal;
-			sourceTree = SOURCE_ROOT;
-		};
 		71CCF2291277045100339E12 /* utils */ = {
 			isa = PBXGroup;
 			children = (
-				8959AC8E211C9C77004D2C87 /* Remotery.c */,
-				92EB6E3A20E4EBDB00A97A49 /* constants.c */,
-				97FF065F138CE4C400D6C707 /* os_config_init.c */,
-				970A26D613434DAC0007362C /* unicode.c */,
-				7147425F12B918C900DB5A59 /* cache.c */,
 				7141FF2F1292CB9200FCB27D /* alloc.c */,
 				71CCF22A1277045100339E12 /* base_encoding.c */,
 				71CCF22B1277045100339E12 /* bitstream.c */,
+				92EB6E3A20E4EBDB00A97A49 /* constants.c */,
+				7147425F12B918C900DB5A59 /* cache.c */,
 				71CCF22C1277045100339E12 /* color.c */,
 				71CCF22D1277045100339E12 /* configfile.c */,
 				71CCF22F1277045100339E12 /* downloader.c */,
@@ -1666,10 +1663,11 @@
 				9298677E235A1587008A2CC6 /* gltools.c */,
 				71CCF2321277045100339E12 /* list.c */,
 				71CCF2331277045100339E12 /* math.c */,
+				71CCF2351277045100339E12 /* module_wrap.h */,
 				71CCF2341277045100339E12 /* module.c */,
+				97FF065F138CE4C400D6C707 /* os_config_init.c */,
 				92F930841A5ADC1A0072A85C /* os_divers.c */,
 				92F930851A5ADC1A0072A85C /* os_file.c */,
-				71CCF2351277045100339E12 /* module_wrap.h */,
 				71CCF2361277045100339E12 /* os_file.c */,
 				71CCF2371277045100339E12 /* os_module.c */,
 				71CCF2381277045100339E12 /* os_net.c */,
@@ -1677,8 +1675,11 @@
 				71CCF23A1277045100339E12 /* path2d.c */,
 				71CCF23B1277045100339E12 /* path2d_stroker.c */,
 				97DDAFEE1569631900528219 /* sha1.c */,
+				925A7610292F998500664F38 /* sha256.c */,
 				71CCF23E1277045100339E12 /* token.c */,
+				8959AC8E211C9C77004D2C87 /* Remotery.c */,
 				71CCF23F1277045100339E12 /* uni_bidi.c */,
+				970A26D613434DAC0007362C /* unicode.c */,
 				71CCF2401277045100339E12 /* url.c */,
 				71CCF2411277045100339E12 /* utf.c */,
 				71CCF2421277045100339E12 /* xml_parser.c */,
@@ -1719,8 +1720,6 @@
 				9747B6ED14864C6400280D95 /* dsmcc.h */,
 				9747B6EE14864C6400280D95 /* events_constants.h */,
 				970A26CF13434D960007362C /* cache.h */,
-				970A26D013434D960007362C /* ringbuffer.h */,
-				970A26D113434D960007362C /* unicode.h */,
 				71CCF36012770A8C00339E12 /* avparse.h */,
 				71CCF36112770A8C00339E12 /* base_coding.h */,
 				71CCF36212770A8C00339E12 /* bifs.h */,
@@ -1734,7 +1733,6 @@
 				71CCF36A12770A8C00339E12 /* download.h */,
 				71CCF36B12770A8C00339E12 /* dvb_mpe.h */,
 				71CCF36D12770A8C00339E12 /* events.h */,
-				71CCF36E12770A8C00339E12 /* filestreamer.h */,
 				71CCF36F12770A8C00339E12 /* ietf.h */,
 				71CCF37012770A8C00339E12 /* internal */,
 				71CCF38512770A8C00339E12 /* iso639.h */,
@@ -1751,8 +1749,6 @@
 				71CCF39A12770A8C00339E12 /* nodes_mpeg4.h */,
 				71CCF39B12770A8C00339E12 /* nodes_svg.h */,
 				71CCF39C12770A8C00339E12 /* nodes_x3d.h */,
-				71CCF39D12770A8C00339E12 /* nodes_xbl.h */,
-				71CCF39E12770A8C00339E12 /* options.h */,
 				71CCF39F12770A8C00339E12 /* path2d.h */,
 				71CCF3A012770A8C00339E12 /* rtp_streamer.h */,
 				71CCF3A112770A8C00339E12 /* scene_engine.h */,
@@ -1763,12 +1759,9 @@
 				71CCF3A612770A8C00339E12 /* setup.h */,
 				71CCF3A712770A8C00339E12 /* svg_types.h */,
 				71CCF3A812770A8C00339E12 /* sync_layer.h */,
-				71CCF3A912770A8C00339E12 /* term_info.h */,
-				71CCF3AA12770A8C00339E12 /* terminal.h */,
 				71CCF3AB12770A8C00339E12 /* thread.h */,
 				71CCF3AC12770A8C00339E12 /* token.h */,
 				71CCF3AD12770A8C00339E12 /* tools.h */,
-				71CCF3AE12770A8C00339E12 /* user.h */,
 				71CCF3AF12770A8C00339E12 /* utf.h */,
 				71CCF3B012770A8C00339E12 /* xml.h */,
 			);
@@ -1846,6 +1839,21 @@
 			name = modules;
 			sourceTree = "<group>";
 		};
+		92C69C7A2813F1CD00051866 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				9212C69E281847660058F76A /* gpac.icns */,
+				92C69C6A281323EA00051866 /* Default-568h@2x.png */,
+				92C69C67281323EA00051866 /* icon_ipad_retina.png */,
+				92C69C66281323EA00051866 /* icon_ipad.png */,
+				92C69C6B281323EA00051866 /* icon_retina.png */,
+				92C69C69281323EA00051866 /* icon.png */,
+				92C69C68281323EA00051866 /* iTunesArtwork */,
+				92C69C64281323D700051866 /* ios-Info.plist */,
+			);
+			name = Resources;
+			sourceTree = "<group>";
+		};
 		92D6C5A32343BF5000262217 /* jsmods */ = {
 			isa = PBXGroup;
 			children = (
@@ -1949,6 +1957,7 @@
 				92EB6D7A20E4E19200A97A49 /* ff_common.c */,
 				92EB6DBD20E4E19700A97A49 /* ff_common.h */,
 				928607142398F4C800FDA1ED /* ff_avf.c */,
+				928E0BDB28E43D8200F2BA27 /* ff_bsf.c */,
 				92EB6D7120E4E19200A97A49 /* ff_dec.c */,
 				92EB6DAC20E4E19600A97A49 /* ff_dmx.c */,
 				92EB6DC120E4E19700A97A49 /* ff_enc.c */,
@@ -1982,6 +1991,7 @@
 				92EB6D9A20E4E19500A97A49 /* mux_avi.c */,
 				8959AC80211C9C3C004D2C87 /* mux_gsf.c */,
 				92EB6DB320E4E19600A97A49 /* mux_isom.c */,
+				9272B50527E4EFAD00D9D304 /* mux_ogg.c */,
 				92EB6D6F20E4E19200A97A49 /* mux_ts.c */,
 				92EB6D8720E4E19300A97A49 /* out_audio.c */,
 				92EB6D7020E4E19200A97A49 /* out_file.c */,
@@ -2019,13 +2029,16 @@
 				8959AC83211C9C3C004D2C87 /* rewrite_obu.c */,
 				92EB6DB520E4E19600A97A49 /* tileagg.c */,
 				928607102395C0DE00FDA1ED /* tssplit.c */,
+				929A29252801EBD700635DEB /* ttml_conv.c */,
 				92EB6DC620E4E19700A97A49 /* unit_test_filter.c */,
+				928E0BD728E2FC5F00F2BA27 /* unframer.c */,
 				92EB6DBC20E4E19700A97A49 /* vcrop.c */,
 				9212C0FC222D7B3700FE3580 /* vflip.c */,
 				92EB6DAA20E4E19600A97A49 /* write_generic.c */,
 				92EB6D8820E4E19300A97A49 /* write_nhml.c */,
 				92EB6DA320E4E19500A97A49 /* write_nhnt.c */,
 				92EB6D7920E4E19200A97A49 /* write_qcp.c */,
+				929A29262801EBD700635DEB /* write_tx3g.c */,
 				92EB6D9620E4E19400A97A49 /* write_vtt.c */,
 			);
 			name = filters;
@@ -2060,7 +2073,6 @@
 				71CCF2961277045100339E12 /* visual_manager_2d.h in Headers */,
 				71CCF2991277045100339E12 /* visual_manager_3d.h in Headers */,
 				925FF2A61ABC53F30085B04C /* smjs_api.h in Headers */,
-				921FEBA51CF881DE00B437C2 /* sensors_def.h in Headers */,
 				71CCF2E11277045100339E12 /* mpeg2_ps.h in Headers */,
 				922EB5861AAE13C500DF46D0 /* version.h in Headers */,
 				71CCF3361277045100339E12 /* module_wrap.h in Headers */,
@@ -2082,7 +2094,6 @@
 				71CCF3BB12770A8C00339E12 /* download.h in Headers */,
 				71CCF3BC12770A8C00339E12 /* dvb_mpe.h in Headers */,
 				71CCF3BE12770A8C00339E12 /* events.h in Headers */,
-				71CCF3BF12770A8C00339E12 /* filestreamer.h in Headers */,
 				92E9DFA32215CE9A00628420 /* tiny_aes.h in Headers */,
 				71CCF3C012770A8C00339E12 /* ietf.h in Headers */,
 				71CCF3C112770A8C00339E12 /* avilib.h in Headers */,
@@ -2116,7 +2127,6 @@
 				71CCF3DB12770A8C00339E12 /* mediaobject.h in Headers */,
 				71CCF3DC12770A8C00339E12 /* module.h in Headers */,
 				71CCF3DD12770A8C00339E12 /* audio_out.h in Headers */,
-				921FEBA61CF881DE00B437C2 /* sensors.h in Headers */,
 				71CCF3DE12770A8C00339E12 /* codec.h in Headers */,
 				71CCF3DF12770A8C00339E12 /* font.h in Headers */,
 				71CCF3E012770A8C00339E12 /* ipmp.h in Headers */,
@@ -2134,9 +2144,7 @@
 				92334CDD2333AB9A00DA6051 /* quickjs.h in Headers */,
 				71CCF3EA12770A8C00339E12 /* nodes_svg.h in Headers */,
 				71CCF3EB12770A8C00339E12 /* nodes_x3d.h in Headers */,
-				71CCF3EC12770A8C00339E12 /* nodes_xbl.h in Headers */,
 				9298677A2357A0DA008A2CC6 /* webgl.h in Headers */,
-				71CCF3ED12770A8C00339E12 /* options.h in Headers */,
 				71CCF3EE12770A8C00339E12 /* path2d.h in Headers */,
 				71CCF3EF12770A8C00339E12 /* rtp_streamer.h in Headers */,
 				71CCF3F012770A8C00339E12 /* scene_engine.h in Headers */,
@@ -2150,20 +2158,15 @@
 				92359C86250F651900525A42 /* Remotery.h in Headers */,
 				92EB6D6D20E4E17F00A97A49 /* filter_session.h in Headers */,
 				71CCF3F712770A8C00339E12 /* sync_layer.h in Headers */,
-				71CCF3F812770A8C00339E12 /* term_info.h in Headers */,
-				71CCF3F912770A8C00339E12 /* terminal.h in Headers */,
 				71CCF3FA12770A8C00339E12 /* thread.h in Headers */,
 				71CCF3FB12770A8C00339E12 /* token.h in Headers */,
 				71CCF3FC12770A8C00339E12 /* tools.h in Headers */,
-				71CCF3FD12770A8C00339E12 /* user.h in Headers */,
 				71CCF3FE12770A8C00339E12 /* utf.h in Headers */,
 				71CCF3FF12770A8C00339E12 /* xml.h in Headers */,
 				970A26CD13434D780007362C /* m3u8.h in Headers */,
 				970A26CE13434D780007362C /* mpd.h in Headers */,
 				922EB5821AAE13C500DF46D0 /* html5_mse.h in Headers */,
 				970A26D213434D960007362C /* cache.h in Headers */,
-				970A26D313434D960007362C /* ringbuffer.h in Headers */,
-				970A26D413434D960007362C /* unicode.h in Headers */,
 				92359C84250F651900525A42 /* route.h in Headers */,
 				922EB5871AAE13C500DF46D0 /* webvtt.h in Headers */,
 				9747B6EF14864C6400280D95 /* ait.h in Headers */,
@@ -2177,9 +2180,9 @@
 /* End PBXHeadersBuildPhase section */
 
 /* Begin PBXNativeTarget section */
-		71A19B1912796B5600ACFF58 /* osmo4ios */ = {
+		71A19B1912796B5600ACFF58 /* gpac4ios */ = {
 			isa = PBXNativeTarget;
-			buildConfigurationList = 71A19B1F12796B5800ACFF58 /* Build configuration list for PBXNativeTarget "osmo4ios" */;
+			buildConfigurationList = 71A19B1F12796B5800ACFF58 /* Build configuration list for PBXNativeTarget "gpac4ios" */;
 			buildPhases = (
 				71A19B1612796B5600ACFF58 /* Resources */,
 				71A19B1712796B5600ACFF58 /* Sources */,
@@ -2191,9 +2194,9 @@
 			dependencies = (
 				047ACFD416DF56BF00F2BF65 /* PBXTargetDependency */,
 			);
-			name = osmo4ios;
-			productName = osmo4ios;
-			productReference = 71A19B1A12796B5600ACFF58 /* osmo4ios.app */;
+			name = gpac4ios;
+			productName = gpac4ios;
+			productReference = 71A19B1A12796B5600ACFF58 /* gpac4ios.app */;
 			productType = "com.apple.product-type.application";
 		};
 		71CCF1301277037A00339E12 /* libgpac_static */ = {
@@ -2244,7 +2247,7 @@
 			projectRoot = "";
 			targets = (
 				71CCF1301277037A00339E12 /* libgpac_static */,
-				71A19B1912796B5600ACFF58 /* osmo4ios */,
+				71A19B1912796B5600ACFF58 /* gpac4ios */,
 			);
 		};
 /* End PBXProject section */
@@ -2254,17 +2257,19 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				924AB67F281438E100EC006F /* default.cfg in Resources */,
 				9281B63021C92D00006B0FD5 /* gui in Resources */,
+				92C69C6E281323EA00051866 /* icon_ipad_retina.png in Resources */,
+				92C69C70281323EA00051866 /* icon.png in Resources */,
+				92C69C71281323EA00051866 /* Default-568h@2x.png in Resources */,
+				92C69C65281323D700051866 /* ios-Info.plist in Resources */,
+				92C69C72281323EA00051866 /* icon_retina.png in Resources */,
+				92C69C6D281323EA00051866 /* icon_ipad.png in Resources */,
 				9251E542251E39A300CEB84D /* scripts in Resources */,
-				9280E7251DD23FFE001E6441 /* iTunesArtwork in Resources */,
-				71EC88E11396273B004DCB6A /* osmo.icns in Resources */,
 				9251E540251E398700CEB84D /* res in Resources */,
-				929A929C16EF8BC200B7C64F /* Default-568h@2x.png in Resources */,
-				929A929D16EF8BC200B7C64F /* icon_ipad_retina.png in Resources */,
-				929A929E16EF8BC200B7C64F /* icon_ipad.png in Resources */,
 				9281B63121C92D00006B0FD5 /* shaders in Resources */,
-				929A929F16EF8BC200B7C64F /* icon_retina.png in Resources */,
-				929A92A016EF8BC200B7C64F /* icon.png in Resources */,
+				92C69C6F281323EA00051866 /* iTunesArtwork in Resources */,
+				9212C69F281847660058F76A /* gpac.icns in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -2292,7 +2297,10 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				71A19B2112796B6F00ACFF58 /* main.c in Sources */,
+				92C69C63281323B800051866 /* gpac_help.c in Sources */,
+				92C69C77281323FA00051866 /* sensors.m in Sources */,
+				924AB68128143DF500EC006F /* ios_main.m in Sources */,
+				92C69C62281323B800051866 /* compositor_tools.c in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -2329,7 +2337,6 @@
 				92EB6DF620E4E19700A97A49 /* rewrite_mp4v.c in Sources */,
 				92EB6DF420E4E19700A97A49 /* isoffin_read_ch.c in Sources */,
 				92BC210C16EF8E7A000E0620 /* ft_font.c in Sources */,
-				921FEBA71CF881DE00B437C2 /* sensors.m in Sources */,
 				92E9DFB62215CEA700628420 /* raster_565.c in Sources */,
 				92D6C5AB2343BF9400262217 /* svg_js.c in Sources */,
 				92EB6DDF20E4E19700A97A49 /* out_audio.c in Sources */,
@@ -2360,6 +2367,7 @@
 				71CCF2511277045100339E12 /* quantize.c in Sources */,
 				71CCF2531277045100339E12 /* script_dec.c in Sources */,
 				71CCF2541277045100339E12 /* script_enc.c in Sources */,
+				928E0BD828E2FC5F00F2BA27 /* unframer.c in Sources */,
 				92EB6DDC20E4E19700A97A49 /* reframe_amr.c in Sources */,
 				71CCF2551277045100339E12 /* unquantize.c in Sources */,
 				71CCF2561277045100339E12 /* audio_input.c in Sources */,
@@ -2371,6 +2379,7 @@
 				71CCF25A1277045100339E12 /* camera.c in Sources */,
 				92EB6E1B20E4E19700A97A49 /* dec_vtb.c in Sources */,
 				71CCF25B1277045100339E12 /* compositor.c in Sources */,
+				929A29272801EBD700635DEB /* ttml_conv.c in Sources */,
 				92EB6E3220E4E58E00A97A49 /* clock.c in Sources */,
 				71CCF25C1277045100339E12 /* compositor_2d.c in Sources */,
 				71CCF25D1277045100339E12 /* compositor_3d.c in Sources */,
@@ -2422,6 +2431,7 @@
 				71CCF2861277045100339E12 /* offscreen_cache.c in Sources */,
 				71CCF2881277045100339E12 /* svg_base.c in Sources */,
 				8959AC8A211C9C3C004D2C87 /* mux_gsf.c in Sources */,
+				928E0BDC28E43D8200F2BA27 /* ff_bsf.c in Sources */,
 				71CCF2891277045100339E12 /* svg_filters.c in Sources */,
 				71CCF28A1277045100339E12 /* svg_font.c in Sources */,
 				92EB6DCC20E4E19700A97A49 /* dec_openhevc.c in Sources */,
@@ -2454,6 +2464,7 @@
 				9288A54825AF6FCC006F7355 /* io_fcryp.c in Sources */,
 				71CCF29F1277045100339E12 /* rtp_packetizer.c in Sources */,
 				71CCF2A01277045100339E12 /* rtp_pck_3gpp.c in Sources */,
+				92D1555D282BF23500AE8BC9 /* gpac.c in Sources */,
 				92EB6DD920E4E19700A97A49 /* rewrite_adts.c in Sources */,
 				92EB6DF820E4E19700A97A49 /* dec_faad.c in Sources */,
 				92EB6E0F20E4E19700A97A49 /* load_svg.c in Sources */,
@@ -2571,6 +2582,7 @@
 				71CCF2F91277045100339E12 /* loader_xmt.c in Sources */,
 				71CCF2FA1277045100339E12 /* scene_dump.c in Sources */,
 				71CCF2FB1277045100339E12 /* scene_engine.c in Sources */,
+				925A7611292F998500664F38 /* sha256.c in Sources */,
 				92EB6DDA20E4E19700A97A49 /* dec_webvtt.c in Sources */,
 				71CCF2FC1277045100339E12 /* scene_manager.c in Sources */,
 				71CCF2FD1277045100339E12 /* scene_stats.c in Sources */,
@@ -2631,7 +2643,6 @@
 				929DE74924183FB40056AFA7 /* gzio.c in Sources */,
 				92EB6DF320E4E19700A97A49 /* dmx_avi.c in Sources */,
 				92EB6DFD20E4E19700A97A49 /* reframe_mp3.c in Sources */,
-				71CCF32A1277045100339E12 /* terminal.c in Sources */,
 				92E9DFB32215CEA700628420 /* raster_argb.c in Sources */,
 				71CCF32B1277045100339E12 /* base_encoding.c in Sources */,
 				71CCF32C1277045100339E12 /* bitstream.c in Sources */,
@@ -2648,8 +2659,10 @@
 				92EB6DF020E4E19700A97A49 /* dec_vorbis.c in Sources */,
 				9274295A24647B98009ADD8D /* bsrw.c in Sources */,
 				71CCF3351277045100339E12 /* module.c in Sources */,
+				929A29282801EBD700635DEB /* write_tx3g.c in Sources */,
 				71CCF3381277045100339E12 /* os_module.c in Sources */,
 				92E9DFA62215CE9A00628420 /* g_crypt_openssl.c in Sources */,
+				9272B50627E4EFAD00D9D304 /* mux_ogg.c in Sources */,
 				71CCF3391277045100339E12 /* os_net.c in Sources */,
 				9227B8592799F8E700BF3D1B /* bs_split.c in Sources */,
 				71CCF33A1277045100339E12 /* os_thread.c in Sources */,
@@ -2732,9 +2745,9 @@
 					../../include,
 					../../extra_lib/include,
 				);
-				INFOPLIST_FILE = "../../applications/osmo4_ios/osmo4ios-Info.plist";
+				INFOPLIST_FILE = "../../applications/gpac/ios-Info.plist";
 				INSTALL_PATH = /Applications;
-				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
 				LIBRARY_SEARCH_PATHS = (
 					"$(inherited)",
 					"\"$(SRCROOT)/../../extra_lib/lib/iOS\"",
@@ -2744,7 +2757,7 @@
 				OTHER_CPLUSPLUSFLAGS = "";
 				OTHER_LDFLAGS = "";
 				PRODUCT_BUNDLE_IDENTIFIER = "com.telecom-paristech.gpac";
-				PRODUCT_NAME = osmo4ios;
+				PRODUCT_NAME = gpac4ios;
 				PROVISIONING_PROFILE = "";
 				"PROVISIONING_PROFILEsdk=iphoneos*" = "";
 				SDKROOT = iphoneos;
@@ -2777,9 +2790,9 @@
 					../../include,
 					../../extra_lib/include,
 				);
-				INFOPLIST_FILE = "../../applications/osmo4_ios/osmo4ios-Info.plist";
+				INFOPLIST_FILE = "../../applications/gpac/ios-Info.plist";
 				INSTALL_PATH = /Applications;
-				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
 				LIBRARY_SEARCH_PATHS = (
 					"$(inherited)",
 					"\"$(SRCROOT)/../../extra_lib/lib/iOS\"",
@@ -2790,7 +2803,7 @@
 				OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)";
 				OTHER_LDFLAGS = "";
 				PRODUCT_BUNDLE_IDENTIFIER = "com.telecom-paristech.gpac";
-				PRODUCT_NAME = osmo4ios;
+				PRODUCT_NAME = gpac4ios;
 				PROVISIONING_PROFILE = "";
 				"PROVISIONING_PROFILEsdk=iphoneos*" = "";
 				SDKROOT = iphoneos;
@@ -2951,7 +2964,7 @@
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
-		71A19B1F12796B5800ACFF58 /* Build configuration list for PBXNativeTarget "osmo4ios" */ = {
+		71A19B1F12796B5800ACFF58 /* Build configuration list for PBXNativeTarget "gpac4ios" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				71A19B1D12796B5700ACFF58 /* Debug */,

gpac-2.2.0.tar.gz/build/xcode/gpac4ios.xcodeproj/xcshareddata/xcschemes/gpac4ios.xcscheme Added

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+ LastUpgradeVersion = "1020"
+ version = "1.3">
+ <BuildAction
+ parallelizeBuildables = "YES"
+ buildImplicitDependencies = "YES">
+ <BuildActionEntries>
+ <BuildActionEntry
+ buildForTesting = "YES"
+ buildForRunning = "YES"
+ buildForProfiling = "YES"
+ buildForArchiving = "YES"
+ buildForAnalyzing = "YES">
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "71A19B1912796B5600ACFF58"
+ BuildableName = "gpac4ios.app"
+ BlueprintName = "gpac4ios"
+ ReferencedContainer = "container:gpac4ios.xcodeproj">
+ </BuildableReference>
+ </BuildActionEntry>
+ </BuildActionEntries>
+ </BuildAction>
+ <TestAction
+ buildConfiguration = "Debug"
+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+ shouldUseLaunchSchemeArgsEnv = "YES">
+ <MacroExpansion>
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "71A19B1912796B5600ACFF58"
+ BuildableName = "gpac4ios.app"
+ BlueprintName = "gpac4ios"
+ ReferencedContainer = "container:gpac4ios.xcodeproj">
+ </BuildableReference>
+ </MacroExpansion>
+ <Testables>
+ </Testables>
+ </TestAction>
+ <LaunchAction
+ buildConfiguration = "Debug"
+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+ launchStyle = "0"
+ useCustomWorkingDirectory = "NO"
+ ignoresPersistentStateOnLaunch = "NO"
+ debugDocumentVersioning = "YES"
+ debugServiceExtension = "internal"
+ allowLocationSimulation = "YES">
+ <BuildableProductRunnable
+ runnableDebuggingMode = "0">
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "71A19B1912796B5600ACFF58"
+ BuildableName = "gpac4ios.app"
+ BlueprintName = "gpac4ios"
+ ReferencedContainer = "container:gpac4ios.xcodeproj">
+ </BuildableReference>
+ </BuildableProductRunnable>
+ <CommandLineArguments>
+ <CommandLineArgument
+ argument = "-gui video://:dev=0:video_size=1920x1080"
+ isEnabled = "NO">
+ </CommandLineArgument>
+ <CommandLineArgument
+ argument = "-p=:reload -gui video://:dev=1:video_size=1920x1080"
+ isEnabled = "NO">
+ </CommandLineArgument>
+ <CommandLineArgument
+ argument = "-gui"
+ isEnabled = "YES">
+ </CommandLineArgument>
+ <CommandLineArgument
+ argument = "-h ffavin"
+ isEnabled = "NO">
+ </CommandLineArgument>
+ </CommandLineArguments>
+ </LaunchAction>
+ <ProfileAction
+ buildConfiguration = "Release"
+ shouldUseLaunchSchemeArgsEnv = "YES"
+ savedToolIdentifier = ""
+ useCustomWorkingDirectory = "NO"
+ debugDocumentVersioning = "YES">
+ <BuildableProductRunnable
+ runnableDebuggingMode = "0">
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "71A19B1912796B5600ACFF58"
+ BuildableName = "gpac4ios.app"
+ BlueprintName = "gpac4ios"
+ ReferencedContainer = "container:gpac4ios.xcodeproj">
+ </BuildableReference>
+ </BuildableProductRunnable>
+ </ProfileAction>
+ <AnalyzeAction
+ buildConfiguration = "Debug">
+ </AnalyzeAction>
+ <ArchiveAction
+ buildConfiguration = "Release"
+ revealArchiveInOrganizer = "YES">
+ </ArchiveAction>
+</Scheme>

gpac-2.0.0.tar.gz/build/xcode/script_libgpac.sh -> gpac-2.2.0.tar.gz/build/xcode/script_libgpac.sh Changed

gpac-2.0.0.tar.gz/change_version.sh -> gpac-2.2.0.tar.gz/change_version.sh Changed

@@ -2,11 +2,12 @@
 
 
 version="`grep '#define GPAC_VERSION ' \"./include/gpac/version.h\" | cut -d '"' -f 2`"
-#version_major=`grep '#define GPAC_VERSION_MAJOR ' ./include/gpac/version.h | sed 's/^0-9*//g'`
-#version_minor=`grep '#define GPAC_VERSION_MINOR ' ./include/gpac/version.h | sed 's/^0-9*//g'`
-#version_micro=`grep '#define GPAC_VERSION_MICRO ' ./include/gpac/version.h | sed 's/^0-9*//g'`
+version_major=`grep '#define GPAC_VERSION_MAJOR ' ./include/gpac/version.h | sed 's/^0-9*//g'`
+version_minor=`grep '#define GPAC_VERSION_MINOR ' ./include/gpac/version.h | sed 's/^0-9*//g'`
+version_micro=`grep '#define GPAC_VERSION_MICRO ' ./include/gpac/version.h | sed 's/^0-9*//g'`
+libgac_version="$version_major.$version_minor.$version_micro"
 
-echo "Version is $version"
+echo "Version is $version - libgpac $libgac_version"
 
 #patch README.md
 source="README.md"
@@ -15,10 +16,9 @@
 mv ftmp $source
 
 
-#patch applications/osmo4_ios/osmo4ios-Info.plist 
-
-source="applications/osmo4_ios/osmo4ios-Info.plist"
-sed -e "/CFBundleShortVersionString/{n;s/.*/	<string>$version<\/string>/;}" $source > ftmp
+#patch applications/gpac/ios-Info.plist
+source="applications/gpac/ios-Info.plist"
+sed -e "/CFBundleShortVersionString/{n;s/.*/	<string>$version<\/string>/;}" $source | sed -e "/CFBundleVersion/{n;s/.*/	<string>$libgac_version<\/string>/;}" > ftmp
 rm $source
 mv ftmp $source
 
@@ -30,7 +30,7 @@
 
 # patch file gpac.spec
 source="gpac.spec"
-sed -e "s/Version:.*/Version: $version/;" $source | sed -e "s/Release:.*/Release: $version/;" | sed -e "s/Source0:.*/Source0: gpac-$version.tar.gz%{?_with_amr:Source1:http:\/\/www.3gpp.org\/ftp\/Specs\/archive\/26_series\/26.073\/26073-700.zip}/;" > ftmp
+sed -e "s/Version:.*/Version: $version/;" $source | sed -e "s/Release:.*/Release: $version/;" | sed -e "s/Source0:.*/Source0: gpac-$version.tar.gz/;" > ftmp
 rm $source
 mv ftmp $source
 
@@ -46,8 +46,9 @@
 rm $source
 mv ftmp $source
 
-# patch file share/doc/configuration.html
-source="share/doc/configuration.html"
-sed -e "s/GPAC Version.*</GPAC Version $version</;" $source > ftmp
+#patch packagers/osx/GPAC.app/Contents/Info.plist
+source="packagers/osx/GPAC.app/Contents/Info.plist"
+sed -e "/CFBundleShortVersionString/{n;s/.*/	<string>$version<\/string>/;}" $source | sed -e "/CFBundleVersion/{n;s/.*/	<string>$libgac_version<\/string>/;}" > ftmp
 rm $source
 mv ftmp $source
+

gpac-2.0.0.tar.gz/configure -> gpac-2.2.0.tar.gz/configure Changed

@@ -27,6 +27,9 @@
 TMPS="${TMPDIR1}/gpac-conf-${RANDOM}-$$-${RANDOM}.S"
 TMPL="${TMPDIR1}/gpac-conf-${RANDOM}-$$-${RANDOM}.LOG"
 
+# DO NOT DECLARE variables called disable_, this is reserved for features:
+#each feature FOO declare upon load the variable disable_FOO ('-' replaced with '_' in var name)
+
 #default parameters
 DESTDIR=""
 prefix="/usr/local"
@@ -34,7 +37,6 @@
 cross_prefix=""
 targetos=""
 dxsdk_path=""
-moz_path="local"
 
 cc_orig=$CC
 if test "$cc_orig" = "" ; then
@@ -61,123 +63,21 @@
 sdl_local="no"
 sdl_static="no"
 verbose="no"
-xulsdk_path="/usr/lib/xulrunner/sdk/include"
-xul_flags=""
 libdir="lib"
-
-#GPAC module config
-static_modules="no"
-lm_lib=""
-has_mingw_directx="no"
-has_js="no"
-has_platinum="no"
-has_ft="no"
-has_jpeg="no"
-has_png="no"
-has_xvid="no"
-has_mad="no"
-has_faad="no"
-has_ffmpeg="no"
-ffmpeg_vvc="no"
-has_amr_nb_fixed="no"
-has_amr_nb="no"
-has_amr_wb="no"
-has_ogg="no"
-has_vorbis="no"
-has_theora="no"
-has_a52="no"
-has_pulseaudio="no"
-has_oss_audio="no"
-has_alsa="no"
-has_jack="no"
-has_directfb="no"
-has_x11="no"
-has_x11_shm="no"
-has_x11_xv="no"
 no_gcc_opt="no"
 use_fixed_point="no"
 use_memory_tracking="no"
-has_opengl="no"
-has_tinygl="no"
-enable_tinygl="no"
-has_ssl="no"
-has_ipv6="no"
-has_dvb4linux="no"
-has_openjpeg="no"
 gprof_build="no"
-static_build="no"
 want_pic="no"
 want_gcov="no"
-has_joystick="no"
-has_hid="no"
-has_sock_un="no"
-has_lzma="no"
-has_nghttp2="no"
-enable_joystick="no"
-static_bin="no"
-disable_core_tools="no"
-disable_3d="no"
-disable_svg="no"
-disable_vrml="no"
-disable_x3d="no"
-disable_od="no"
-disable_bifs="no"
-disable_bifs_enc="no"
-disable_laser="no"
-disable_saf="no"
-disable_smgr="no"
-disable_seng="no"
-disable_qtvr="no"
-disable_avi="no"
-disable_m2ps="no"
-disable_m2ts="no"
-disable_m2ts_mux="no"
-disable_ogg="no"
-disable_parsers="no"
-disable_import="no"
-disable_export="no"
-disable_swf="no"
-disable_scene_stats="no"
-disable_scene_dump="no"
-disable_scene_encode="no"
-disable_loader_isoff="no"
-disable_loader_bt="no"
-disable_loader_xmt="no"
-disable_od_dump="no"
-disable_od_parse="no"
-disable_isom_dump="no"
-disable_crypto="no"
-disable_mpd="no"
-disable_dash="no"
-disable_isoff="no"
-disable_isoff_write="no"
-disable_isoff_frag="no"
-disable_isoff_hint="no"
-disable_isoff_frag="no"
-disable_isoff_hds="no"
-disable_streaming="no"
-disable_player="no"
-disable_scenegraph="no"
-disable_dvbx="yes"
-disable_vobsub="no"
-disable_ttxt="no"
-disable_ttml="no"
-disable_hevc="no"
-disable_route="no"
-disable_crypto="no"
-disable_log="no"
-disable_nvdec="no"
-enable_qjs="yes"
-enable_qjs_libc="yes"
-enable_depth_compositor="no"
 enable_sanitizer="no"
-has_opensvc="no"
-has_openhevc="no"
-has_vtb="no"
-has_strlcpy="no"
-disable_codecs="no"
-enable_qjs_stack_check="no"
-
+libgpac_cflags=""
+libgpac_extralibs=""
+static_build="no"
+static_bin="no"
+static_modules="no"
+lm_lib=""
+has_directx="no"
 win32="no"
 mingw32="no"
 cygwin="no"
@@ -196,12 +96,143 @@
 GPAC_SH_FLAGS=-lpthread
 DYN_LIB_SUFFIX=".so"
 X11_PATH="/usr/X11R6"
-OSS_CFLAGS=""
-OSS_LDFLAGS=""
 INSTFLAGS=""
 is_64="no"
+
+
+#flags not set by generic lib config
+has_x11="no"
+has_x11_shm="no"
+has_x11_xv="no"
+has_x11_glx="no"
+ffmpeg_vvc="no"
+
+has_strlcpy="no"
+
 ffmpeg_extra_ldflags=""
-has_st_nsec="no"
+
+nb_features=0
+all_features=""
+all_descs=""
+
+push_feature()
+{
+ name=$1
+ #var=${name//-/_}
+ var=$(printf '%s' "$name" | tr '-' '_')
+ desc="$2"
+
+ fc=`echo $desc | cut -c1-1`
+ if test "$fc" = "!" ; then
+ eval "disable_$var=\"yes\""
+ else
+ eval "disable_$var=\"no\""
+ fi
+
+ if -z $all_features ; then
+ all_features="$1"
+ all_descs="$desc"
+ else
+ all_features="$all_features|$1"
+ all_descs="$all_descs|$desc"
+ fi
+ nb_features=$((nb_features+1))
+}
+
+#all features enabled with --enable- or --disable-
+#if first character is !, feature is disabled by default otherwise enabled by default
+
+push_feature "log" "logging support"
+push_feature "3d" "3D rendering"
+push_feature "crypto" "crypto support"
+push_feature "svg" "SVG 1.2 support"
+push_feature "vrml" "MPEG-4/VRML/X3D support"
+push_feature "x3d" "X3D-only support"
+push_feature "depth" "!depth handling in the compositor"
+push_feature "odf" "full support of MPEG-4 OD Framework"
+push_feature "bifs" "MPEG-4 BIFS decoding"
+push_feature "bifs-enc" "MPEG-4 BIFS encoding"
+push_feature "laser" "MPEG-4 LaSer encode and decode"
+push_feature "seng" "scene encoder engine"
+push_feature "qtvr" "import of Cubic QTVR files"
+push_feature "swf" "SWF import"
+push_feature "scene-stats" "scene graph statistics"
+push_feature "scene-dump" "scene graph dump"
+push_feature "scene-encode" "BIFS & LASeR to ISOBMFF"
+push_feature "loader-isoff" "scene loading from ISO File Format"
+push_feature "loader-bt" "scene loading from BT/VRML files"
+push_feature "loader-xmt" "scene loading from XMT/X3D files"
+push_feature "od-dump" "MPEG-4 OD dump"
+push_feature "od-parse" "MPEG-4 OD parse"
+push_feature "scenegraph" "scenegraph, scene parsers and player (compositor)"
+push_feature "smgr" "scene manager"
+push_feature "codecs" "All audio and video codec support"
+push_feature "parsers" "AV bitstream parsers"
+push_feature "import" "media importers"
+push_feature "export" "media exporters"
+push_feature "avi" "AVI read and write"
+push_feature "ogg" "OGG read and write"
+push_feature "m2ps" "MPEG-2 PS read"
+push_feature "m2ts" "MPEG-2 TS demultiplexer"
+push_feature "m2ts-mux" "MPEG-2 TS multiplexer"
+push_feature "saf" "SAF container"
+push_feature "isom-dump" "ISOBMFF file dump"
+push_feature "isoff" "ISOBMFF support"
+push_feature "isoff-write" "ISOBMFF edit/write support"
+push_feature "isoff-hint" "ISOBMFF hinting support"
+push_feature "isoff-frag" "ISOBMFF fragments support"
+push_feature "isoff-hds" "Adobe HDS in ISOBMFF support"
+push_feature "streaming" "RTP/RTSP/SDP support"
+push_feature "player" "player (compositor)"
+push_feature "dvbx" "!DVB-specific tools (MPE, FEC, DSM-CC)"
+push_feature "vobsub" "VobSub support"
+push_feature "ttxt" "TTXT (3GPP / MPEG-4 Timed Text) support"
+push_feature "ttml" "TTML/EBU TTD support"
+push_feature "vtt" "WebVTT support"
+push_feature "mpd" "DASH MPD read/write support"
+push_feature "dash" "DASH and HLS support"
+push_feature "hevc" "HEVC support"
+push_feature "route" "ROUTE (ATSC3) support"
+push_feature "qjs" "QuickJS support"
+push_feature "qjs-libc" "QuickJS libc module support"
+push_feature "qjs-stack" "!stack depth checking in QuickJS (WILL CRASH in multithreaded modes)"
+push_feature "nvdec" "NVDec support"
+push_feature "tinygl" "!TinyGL support"
+
+ar_it=""
+get_item()
+{
+ idx=$1
+ IFS='|'
+ set -- $2
+ eval "ar_it=\${$idx}"
+ IFS=' '
+}
+get_item2()
+{
+ idx=$1
+ set -- $2
+ eval "ar_it=\${$idx}"
+}
+
+
+nb_it=0
+get_size()
+{
+ nb_it=`echo "$1" | wc -w`
+}
+
+#zlib MUST be first
+all_packages="zlib opensvc openhevc platinum freetype ssl jpeg openjpeg png mad a52 xvid faad ffmpeg freenect vorbis theora ogg nghttp2"
+all_packages="$all_packages oss dvb4linux alsa pulseaudio jack directfb hid lzma tinygl vtb"
+disabled_packages=""
+
+#init all has_FOO=no and set FOO_cflags=
+for pck in $all_packages ; do
+ eval "has_$pck=\"no\""
+
+ eval "cflags_$pck=\"\""
+done
 
 logs="config.log"
 echo "Logs for GPAC configure $GPAC_CONFIGURATION" > $logs
@@ -214,140 +245,234 @@
 Usage: configure options
 Options: defaults in brackets after descriptions
 
-GPAC configuration options:
+GPAC build options:
 --help print this message
 --prefix=PREFIX install in PREFIX $prefix
+ --libdir=DIR lib dir in DIR $libdir
 --mandir=DIR man documentation in DIR PREFIX/share/man
-
 --verbose enable verbose building $verbose
 --source-path=PATH path of source code $source_path
 --cross-prefix=PREFIX use PREFIX for compile tools $cross_prefix
 --target-os=TARGETOS use TARGETOS for compile tools $targetos
 --cc=CC use C compiler CC $cc
- --cxx=CXX use C++ compiler CXX $cxx
+ --cxx=CXX use C++ compiler CXX $cxx (also valid as --cpp=CXX)
 --make=MAKE use specified make $make
 --extra-cflags=ECFLAGS add ECFLAGS to CFLAGS $CFLAGS
 --extra-ldflags=ELDFLAGS add ELDFLAGS to LDFLAGS $LDFLAGS
 --extra-libs=ELIBS add ELIBS $ELIBS
 --cpu=CPU force cpu to CPU $cpu
- --sdl-cfg=SDL_PATH specify path to sdl-config for local install $sdl_path
- --enable-sdl-static use static SDL linking default=no
- --X11-path=X11_PATH specify path for X11 includes and libraries $X11_PATH
- --dxsdk-path=DX_PATH specify directX SDK for MinGW $dxsdk_path
- --xulsdk-path=XUL_PATH specify Mozilla XUL (Gecko) SDK include path $xulsdk_path
- --mozdir=MOZ_PATH specify mozilla main directory path for system install
- --extra-ff-ldflags=ELDFLAGS add ELDFLAGS to FFMPEG LDFLAGS $ffmpeg_extra_ldflags
-
 --enable-debug produce debug version
 --enable-gprof enable profiling
 --enable-gcov enable coverage
 --enable-pic enable Position Independant Code for shared objects
 --strip enable strip
 --std-allocator uses standard lib memory allocator
- --enable-mem-track enable tracking of all memory allocated by gpac
 --enable-sanitizer enable address sanitizer
 --enable-afl enable instrumentation for American Fuzzy Lop
 --enable-afl-clang enable instrumentation for American Fuzzy Lop using afl-clang(++)
 --disable-opt disable GCC optimizations
+ --static-build link statically against libgpac but still allow dependencies to shared libraries (enable --static-modules)
+ --static-bin enable static linking of MP4Box and gpac only (will enable --static-build), disable all libraries not linkable statically.
+ --sdl-cfg=SDL_PATH specify path to sdl-config for local install $sdl_path
+ --enable-sdl-static use static SDL linking default=no
+ --X11-path=X11_PATH specify path for X11 includes and libraries $X11_PATH
+ --dxsdk-path=DX_PATH specify DirectX SDK for MinGW $dxsdk_path
+ --extra-ff-ldflags=EF add EF flags to FFMPEG LDFLAGS $ffmpeg_extra_ldflags
+
+GPAC core configuration:
+ --static-modules embed modules in libgpac rather than using dynamic library modules
+ --enable-fixed-point enable fixed-point math
 --disable-ipv6 disable IPV6 support
- --disable-platinum disable Platinum UPnP support
- --disable-alsa disable Alsa audio
- --disable-oss-audio disable OSS audio
- --enable-jack enable Jack audio
- --disable-jack disable Jack audio
- --enable-pulseaudio enable Pulse audio
- --disable-pulseaudio disable Pulse audio
+ --enable-mem-track enable tracking of all memory allocated by gpac
 --disable-x11 disable X11
 --disable-x11-shm disable X11 shared memory support
 --disable-x11-xv disable X11 Xvideo support
- --enable-fixed-point enable fixed-point math
- --enable-tinygl enable TinyGL support
- --enable-joystick enable joystick support
- --disable-ssl disable OpenSSL support
- --enable-amr-nb-fixed enable AMR NB fixed-point decoder
- --enable-amr-nb enable AMR NB library
- --enable-amr-wb enable AMR WB library
- --enable-amr enable both AMR NB and WB libraries
- --static-modules use static modules in libgpac rather than dynamic library modules
- --static-build link statically against libgpac but still allow dependencies to shared libraries (enable --static-modules)
- --enable-static-bin old name for --static-build, deprecated
- --static-bin enable static linking of MP4Box and gpac only (enable --static-build), disable MP4Client and all libraries not linkable statically.
- --static-mp4box old name for --static-bin, deprecated
- --enable-depth enables depth handling in the compositor
- --enable-qjs-stack enables stack depth checking in QuickJS (WILL CRASH in multithreaded modes)
-
-Configuration options for libgpac - all options can be enabled with --enable-optname
- --disable-all disables all features in libgpac
- --disable-3d disable 3D rendering
- --disable-svg disable SVG
- --disable-vrml disable MPEG-4/VRML/X3D
- --disable-x3d disable X3D only
- --disable-odf disable full support of MPEG-4 OD Framework
- --disable-bifs disable BIFS
- --disable-bifs-enc disable BIFS coder
- --disable-laser disable LASeR coder
- --disable-saf disable SAF container
- --disable-seng disable scene encoder engine
- --disable-qtvr disable import of Cubic QTVR files
- --disable-avi disable AVI
- --disable-ogg disable OGG
- --disable-m2ps disable MPEG2 PS
- --disable-m2ts disable MPEG2 TS
- --disable-m2ts-mux disable MPEG2 TS Multiplexer
- --disable-dvb4linux disable dvb4linux support
- --disable-parsers disable AV parsers
- --disable-import disable media importers
- --disable-export disable media exporters
- --disable-swf disable SWF import
- --disable-scene-stats disable scene graph statistics
- --disable-scene-dump disable scene graph dump
- --disable-scene-encode disable BIFS & LASeR to ISO File Format encoding
- --disable-loader-isoff disable scene loading from ISO File Format
- --disable-loader-bt disable scene loading from ISO File Format
- --disable-loader-xmt disable scene loading from ISO File Format
- --disable-od-dump disable OD dump
- --disable-isom-dump disable ISOM dump
- --disable-crypt disable crypto tools
- --disable-isoff disable ISO File Format
- --disable-isoff-write disable ISO File Format edit/write
- --disable-isoff-hint disable ISO File Format hinting
- --disable-isoff-frag disable fragments in ISO File Format
- --disable-isoff-hds disable HDS support in ISO File Format
- --disable-streaming disable RTP/RTSP/SDP
- --disable-dvbx disable DVB-specific tools (MPE, FEC, DSM-CC)
- --disable-vobsub disable VobSub support
- --disable-sman disable scene manager
- --disable-ttxt disable TTXT (3GPP / MPEG-4 Timed Text) support
- --disable-player disable player (terminal and compositor)
- --disable-scenegraph disable scenegraph, scene parsers and player (terminal and compositor)
- --disable-hevc disable HEVC support
- --disable-route disable ROUTE (ATSC3) support
- --disable-crypto disable crypto support
- --disable-nvdec disable NVDec support
- --disable-codecs disable all media decoders and encoders
-
-Extra libraries configuration. You can turn a library off or force using the local version in gpac/extra_lib/
- --use-ft=OPT force FreeType OPT=no,local
- --use-zlib=OPT force ZLIB OPT=no,system,local
- --use-jpeg=OPT force JPEG OPT=no,local
- --use-png=OPT force PNG OPT=no,local
- --use-faad=OPT force FAAD OPT=no,local
- --use-mad=OPT force MAD OPT=no,local
- --use-xvid=OPT force XVID OPT=no,local
- --use-ffmpeg=OPT force FFMPEG OPT=no,local
- --use-ogg=OPT force OGG OPT=no,system,local
- --use-vorbis=OPT force vorbis OPT=no,system,local
- --use-theora=OPT force theora OPT=no,system,local
- --use-openjpeg=OPT force openjpeg OPT=no,system,local
- --use-a52=OPT force a52 (ac3) OPT=no,system,local
+ --enable-depth enables depth handling in the compositor (experimental for stereoscopic rendering)
+ --disable-all disables all features in libgpac (see below)
+ --isomedia-only disables all features except "parsers import export isom-dump isoff isoff-write isoff-hint isoff-frag isoff-hds ttxt ttml vtt mpd dash hevc"
+
+
+Extra libraries configuration:
+You can turn a library off or force using the local version in gpac/extra_lib/
+ --use-FOO=no disable library FOO
+ --use-FOO=local force use of library FOO in gpac/extra_lib/include, gpac/extra_lib/lib/gcc/bin/
+ --use-FOO=system force using system version only of library FOO
+ --use-FOO=PATH force use of library FOO in \$PATH/include, \$PATH/lib
+
+Extra libraries used are: $all_packages
+EOF
+
+cat << EOF
+
+Features for libgpac configuration:
+Feature FOO can be enabled with --enable-FOO or disabled with --disable-FOO
+EOF
+
+idx=1
+while $idx -le $nb_features ; do
+ get_item $idx "$all_features"
+ name="$ar_it"
+ get_item $idx "$all_descs"
+ desc="$ar_it"
+
+ enabled="on"
+ fc=`echo $desc | cut -c1-1`
+ if test "$fc" = "!" ; then
+ enabled="disabled"
+ desc=`echo $desc | cut -c2-`
+ fi
+
+ while ${#name} -le 12 
+ do
+ name="$name "
+ done
+
+ echo " $name $desc (default: $enabled)"
+ idx=$((idx+1))
+done
+
+cat << EOF
+
+
 
 NOTE: The object files are built at the place where configure is launched
 EOF
 exit 1
 fi
+#end help
+
+#append $2 to $1 if not already present, or prepend if $3 is yes
+append() {
+ if -z "$2" ; then
+ return
+ fi
+ prepend="no"
+ if test "$3" = "yes" ; then
+ prepend="yes"
+ fi
+
+ all_vars="$2"
+ get_size "$all_vars"
+ nb_items=$nb_it
+
+ skip="no"
+ var=$1
+
+ idx=1
+ while $idx -le $nb_items ; do
+ get_item2 $idx "$all_vars"
+ n="$ar_it"
+
+ if test "$n" = "-framework" ; then
+ idx=$((idx+1))
+ get_item2 $idx "$all_vars"
+ n2="$ar_it"
+ n="$n $n2"
+ fi
+
+ eval "tmpv=\"\$$var\""
+ case "$tmpv" in
+ *"$n"*) idx=$((idx+1))
+		continue
+		;;
+ esac
+
+ if -z "$var" ; then
+ eval "$var=\"$n\""
+ elif test "$prepend" = "yes" ; then
+ eval "$var=\"$n \$$var\""
+ else
+ eval "$var=\"\$$var $n\""
+ fi
+ idx=$((idx+1))
+ done
+}
+
+#set feature $1 to $2 (yes or no)
+set_feature()
+{
+ name="$1"
+ disable_feat="$2"
 
-use_static="no"
 
+ idx=1
+ while $idx -le $nb_features ; do
+ get_item $idx "$all_features"
+ iname="$ar_it"
+
+ if test "$iname" = "$name" ; then
+ var=$(printf '%s' "$name" | tr '-' '_')
+ eval "disable_$var=\"$disable_feat\""
+ return
+ fi
+ idx=$((idx+1))
+ done
+
+ #allow --disable for packages
+ if test "$disable_feat" = "yes" ; then
+ for i in $all_packages ; do
+ pck_name="$i"
+ case "$name" in
+ "$pck_name"*) append disabled_packages "$name "
+ return
+ ;;
+ esac
+ done
+ fi
+
+ echo "! Unknown feature \"$name\", ignoring - please check help (-h) ! "
+}
+
+#disable all features
+disable_all_features()
+{
+
+ idx=1
+ while $idx -le $nb_features ; do
+ get_item $idx "$all_features"
+ name="$ar_it"
+ var=$(printf '%s' "$name" | tr '-' '_')
+ eval "disable_$var=\"yes\""
+ idx=$((idx+1))
+ done
+}
+
+#enable all features in $1
+enable_features ()
+{
+ params="$1"
+ for i in $params ; do
+ set_feature "$i" "no"
+ done
+}
+
+
+#store $1 (FOO=BAR from --use-FOO=BAR) for later package check
+lib_args=""
+set_package ()
+{
+ for i in $all_packages ; do
+ pck_name="$i="
+ case "$1" in
+ "$pck_name"*) opt=`echo $1 | cut -d '=' -f 2`
+ if "$opt" = "local" -o "$opt" = "system" -o "$opt" = "no" ; then
+ lib_args="$lib_args $1"
+ elif -d "$opt" ; then
+ lib_args="$lib_args $1"
+ else
+ echo "Invalid package option $opt - please check help (-h)"
+ exit 1
+ fi
+ return
+ ;;
+ esac
+ done
+
+ echo "no package pck $1 - please check help (-h)"
+ exit 1
+}
+
+#parse all options
 for opt do
 case "$opt" in
 --prefix=*) prefix=`echo $opt | cut -d '=' -f 2`
@@ -392,16 +517,78 @@
 ;;
 --verbose) verbose="yes";
 ;;
- --static-bin) use_static="yes"
+ --static-bin) static_bin="yes"
 ;;
- --static-mp4box) use_static="yes"
+ --static-mp4box) echo "$opt deprecated, use --static-bin instead"
+ static_bin="yes"
 ;;
 --enable-sanitizer) enable_sanitizer="yes"
 ;;
+ --static-modules) static_modules="yes"
+ ;;
+ --sdl-cfg=*) sdl_path=`echo $opt | cut -d '=' -f 2`; sdl_local="yes"
+ ;;
+ --enable-sdl-static=*) sdl_static="yes"
+ ;;
+ --enable-jack) has_jack="yes"
+ ;;
+ --X11-path=*) X11_PATH=`echo $opt | cut -d '=' -f 2`
+ ;;
+ --dxsdk-path=*) dxsdk_path=`echo $opt | cut -d '=' -f 2`
+ ;;
+ --disable-pulseaudio) has_pulseaudio="no"
+ ;;
+ --disable-oggvorbis) has_oggvorbis="no"
+ ;;
+ --disable-jack) has_jack="no"
+ ;;
+ --disable-alsa) has_alsa="no"
+ ;;
+ --enable-gprof) gprof_build="yes";
+ ;;
+ --static-build) static_build="yes";
+ ;;
+ --enable-static-bin)
+ echo "$opt deprecated, use --static-build instead"
+ static_build="yes";
+ ;;
+ --enable-fixed-point) use_fixed_point="yes"
+ ;;
+ --strip) INSTFLAGS="-s $INSTFLAGS"
+ ;;
+ --enable-mem-track) use_memory_tracking="yes"
+ ;;
+ --disable-x11) append disabled_packages "x11"
+ ;;
+ --disable-x11-shm) append disabled_packages "x11_shm"
+ ;;
+ --disable-x11-xv) append disabled_packages "x11_xv"
+ ;;
+ --disable-all) disable_all_features
+ ;;
+ --isomedia-only) disable_all_features
+ #disable all packages except first one "zlib"
+ disabled_packages=`echo $opt | cut -c6-`
+ append disabled_packages "x11 sdl directx "
+ #enable all parsers, dash and isobmff related
+ enable_features "parsers import export isom-dump isoff isoff-write isoff-hint isoff-frag isoff-hds ttxt ttml vtt mpd dash hevc"
+ ;;
+ --use-*) v=`echo $opt | cut -c7-`
+ 	set_package "$v"
+ ;;
+ --disable-ipv6) append disabled_packages "ipv6 "
+ ;;
+ --disable-*) v=`echo $opt | cut -c11-`
+	 set_feature "$v" "yes"
+ ;;
+ --enable-*) v=`echo $opt | cut -c10-`
+ 	set_feature "$v" "no"
+ ;;
+ *) echo "! Unrecognized option $opt, ignoring !"
+ ;;
 esac
 done
 
-
 cc="${cc_orig}"
 cxx="${cxx_orig}"
 
@@ -437,6 +624,14 @@
 armv4l|arm)
 cpu="armv4l"
 ;;
+ aarch64)
+ cpu="aarch64"
+ if -z "`echo $CFLAGS | grep -- -m32`" ; then
+ is_64="yes"
+ PIC_CFLAGS="-fPIC -DPIC"
+ want_pic="yes"
+ fi
+ ;;
 alpha)
 cpu="alpha"
 ;;
@@ -481,13 +676,13 @@
 windres="${cross_prefix}${windres}"
 
 if test "$enable_sanitizer" = "yes" ; then
-if test "$use_static" = "yes" ; then
+if test "$static_bin" = "yes" ; then
 echo "Cannot use static bin with sanitizer, disabling static bin"
-use_static="no"
+static_bin="no"
 fi
 fi
 
-if test "$use_static" = "yes" ; then
+if test "$static_bin" = "yes" ; then
 pkg_config="${pkg_config} --static"
 if test "$darwin" != "yes" ; then
 LDFLAGS="-static $LDFLAGS"
@@ -588,7 +783,11 @@
 
 Darwin)
 CFLAGS_DIR="-I$prefix/include"
- LDFLAGS="-L$prefix/$libdir"
+ if test "$static_bin" = "yes" ; then
+ LDFLAGS="-L$prefix/$libdir"
+ else
+ LDFLAGS="$LDFLAGS -L$prefix/$libdir"
+ fi
 if test -d /sw/bin ; then
 alt_macosx_dir="/sw"
 CFLAGS_DIR="-I/sw/include $CFLAGS_DIR"
@@ -598,11 +797,13 @@
 CFLAGS_DIR="-I/opt/local/include $CFLAGS_DIR"
 LDFLAGS="-L/opt/local/lib $LDFLAGS"
 fi
+ CFLAGS="$CFLAGS_DIR $CFLAGS"
 Mac_Applications="/Applications"
 SHFLAGS="-dynamiclib"
 DYN_LIB_SUFFIX=".dylib"
 extralibs=""
 GPAC_SH_FLAGS=""
+ X11_PATH=""
 strip="strip -x"
 if test "$is_64" = "yes" ; then
 LDFLAGS="$LDFLAGS"
@@ -692,7 +893,6 @@
 #fi
 
 
-#OK check for all local & systems lib
 local_inc=$source_path/extra_lib/include
 local_lib=$source_path/extra_lib/lib/gcc
 execdir=$source_path/bin/gcc
@@ -722,6 +922,8 @@
 
 
 docxx() {
+ #for logs
+ cat $TMPCXX > $TMPC
 $cc -o $TMPO $TMPCXX $@ 0>/dev/null 2>$TMPL
 dolog $@
 }
@@ -770,7 +972,7 @@
 cc="$cc $CFLAGS"
 cxx="$cxx $CXXFLAGS"
 
-#look for zlib
+#check sse support
 cat > $TMPC << EOF
 #include <emmintrin.h>
 int main( void ) { return 0; }
@@ -781,38 +983,24 @@
 fi
 
 
-#look for zlib
-cat > $TMPC << EOF
-#include <string.h>
-#include <stdio.h>
-#include <zlib.h>
-int main( void ) { if (strcmp(zlibVersion(), ZLIB_VERSION)) { puts("zlib version differs !!!"); return 1; } return 0; }
-EOF
-has_zlib="no"
-if docc -lz $LDFLAGS ; then
- has_zlib="system"
-fi
-if test "$has_zlib" = "no" ; then
- if docc -I"$local_inc/zlib" -L$local_lib -lz ; then
- has_zlib="local"
- fi
-fi
-
-#check dlopen
+#check dlopen support
+has_dlopen="no"
 cat > $TMPC << EOF
 #include <dlfcn.h>
 int main( void ) { dlopen("foo", 0); return 0; }
 EOF
 
 if docc ; then
- dlopen="yes"
+ has_dlopen="yes"
 elif docc $LDFLAGS -ldl ; then
 GPAC_SH_FLAGS="$GPAC_SH_FLAGS -ldl"
+ has_dlopen="yes"
 fi
 
 
 
-#check st_mtim.tv_nsec
+#check st_mtim.tv_nsec support
+has_st_nsec="no"
 cat > $TMPC << EOF
 #include <sys/stat.h>
 int main( void ) { struct stat st; st.st_mtim.tv_nsec = 0; return 0; }
@@ -823,130 +1011,7 @@
 fi
 
 
-#look for platinum support
-cat > $TMPCXX << EOF
-#include <Platinum.h>
-int main( void ) { return 0; }
-EOF
-if docxx -I$local_inc/platinum $LDFLAGS -L$local_lib -lPlatinum -lPltMediaServer -lPltMediaConnect -lPltMediaRenderer -lNeptune -lZlib -lpthread ; then
- has_platinum="yes"
-fi
-
-
-#look for opensvc support
-
-if test "$darwin" = "yes" ; then
- osvc_cflags="-I/usr/include -I/usr/local/include"
- osvc_ldflags="-L/usr/lib -L/usr/local/lib -lOpenSVCDec"
-else
- osvc_cflags=""
- osvc_ldflags="-lOpenSVCDec"
-fi
-
-cat > $TMPC << EOF
-#include <OpenSVCDecoder/SVCDecoder_ietr_api.h>
-int main( void ) { return 0; }
-EOF
-if docc $osvc_cflags $LDFLAGS $osvc_ldflags ; then
- has_opensvc="yes"
-else
-osvc_cflags="-idirafter $local_inc"
-osvc_ldflags="-lOpenSVCDec"
-
-if docc $osvc_cflags $LDFLAGS -L$local_lib $osvc_ldflags ; then
- has_opensvc="yes"
- osvc_ldflags="-L$local_lib $osvc_ldflags"
-fi
-
-fi
-
-#look for openhevc support
-
-if test "$darwin" = "yes" ; then
- ohevc_cflags="-I/usr/include -I/usr/local/include"
- ohevc_ldflags="-L/usr/lib -L/usr/local/lib -lopenhevc -lm -lpthread "
-elif test "$cross_prefix" = "" ; then
- ohevc_cflags="-I/usr/include -I/usr/local/include"
- ohevc_ldflags="-L/usr/lib -L/usr/local/lib -lopenhevc -lm -lpthread"
-else
- ohevc_cflags="-I${prefix}include"
- ohevc_ldflags="-lopenhevc -lm -lpthread"
-fi
-
-cat > $TMPC << EOF
-#include <stdio.h>
-#include <libopenhevc/openhevc.h>
-int main( void ) { oh_init(1, 1); return 0; }
-EOF
-if docc $ohevc_cflags $ohevc_ldflags $LDFLAGS ; then
- has_openhevc="yes"
-else
- ohevc_cflags="-I$local_inc"
- ohevc_ldflags="-lopenhevc -lm -lpthread"
- if docc $ohevc_cflags $ohevc_ldflags $LDFLAGS -L$local_lib ; then
- has_openhevc="yes"
- ohevc_ldflags="-L$local_lib $ohevc_ldflags"
- elif docc $ohevc_cflags $ohevc_ldflags $LDFLAGS -L$execdir ; then
- has_openhevc="yes"
- ohevc_ldflags="-L$execdir $ohevc_ldflags"
- fi
-fi
-
-#look for freetype support
-cat > $TMPC << EOF
-#include <ft2build.h>
-#include FT_FREETYPE_H
-#include FT_GLYPH_H
-#include FT_OUTLINE_H
-int main( void ) { return 0; }
-EOF
-ft_cflags="-I$prefix/include "
-ft_lflags="-L$prefix/$libdir -lfreetype"
-if docc $CFLAGS_DIR $ft_cflags $ft_lflags $LDFLAGS ; then
- has_ft="system"
-fi
-
-if test "$has_ft" = "no" ; then
- ft_cflags="`pkg-config --cflags freetype2 2>>$logs`"
- ft_lflags="`pkg-config --libs freetype2 2>>$logs`"
- if docc $ft_cflags $ft_lflags $LDFLAGS ; then
- has_ft="system"
- fi
-fi
-
-if test "$has_ft" = "no" ; then
- ft_cflags="-I$local_inc/freetype"
- ft_lflags="-L$local_lib -lfreetype"
- if docc $ft_cflags $ft_lflags $LDFLAGS ; then
- has_ft="local"
- fi
-fi
-#end freetype test
-
-
-#look for OpenSSL support
-cat > $TMPC << EOF
-#include <openssl/ssl.h>
-#include <openssl/x509.h>
-#include <openssl/err.h>
-#include <openssl/rand.h>
-int main( void ) { return 0; }
-EOF
-
-if test "$mingw32" = "yes" ; then
- LINK_SSL="-lssl -lcrypto"
-elif test "$win32" = "yes" ; then
- LINK_SSL="-lssleay32 -leay32"
-else
- LINK_SSL="-lssl -lcrypto"
-fi
-
-if docc $CFLAGS_DIR $LINK_SSL $LDFLAGS ; then
- has_ssl="yes"
-fi
-
-
-#look for atomic.h
+#look for atomic.h support
 cat > $TMPC << EOF
 #include <pthread.h>
 #include <stdatomic.h>
@@ -954,13 +1019,14 @@
 EOF
 
 has_atomic="no"
-if docc $CFLAGS_DIR $LDFLAGS ; then
+if docc $LDFLAGS ; then
 has_atomic="yes"
 else
 CFLAGS="$CFLAGS -DGPAC_NO_STDATOMIC"
 fi
 
 
+#look for builtin atomic support
 cat > $TMPC << EOF
 #include <stdint.h>
 int main(void) {
@@ -989,374 +1055,352 @@
 fi
 fi
 
-#look for JPEG support
-cat > $TMPC << EOF
-#include <stdio.h>
-#include <jpeglib.h>
-int main( void ) { return 0; }
-EOF
 
-if docc $LDFLAGS -ljpeg ; then
-	has_jpeg="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_jpeg" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if cc -o $TMPO $TMPC -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -ljpeg 2>>$logs ; then
- has_jpeg="system"
- fi
- elif test "`which $prefix/bin/jpeg-config 2>>$logs`" != ""; then
- jpeg_cflags="`$prefix/bin/jpeg-config --cflags`"
- jpeg_lflags="`$prefix/bin/jpeg-config --libs`"
- if docc $jpeg_cflags $jpeg_lflags $LDFLAGS ; then
- has_jpeg="system"
- fi
- else
- jpeg_cflags="-I$prefix/include"
- jpeg_lflags="-L$prefix/$libdir -ljpeg"
- if docc $jpeg_cflags $jpeg_lflags $LDFLAGS ; then
- has_jpeg="system"
- fi
- fi
- fi
+#look for strlcpy support
+cat > $TMPC << EOF
+#include <string.h>
+int main( void ) {
+ char dest1;
+ strlcpy(dest, "1", 1);
+ return 0;
+}
+EOF
+has_strlcpy="no"
+if docc $LDFLAGS ; then
+ has_strlcpy="yes"
 fi
-if test "$has_jpeg" = "no" ; then
- jpeg_cflags="-I$local_inc/jpeg"
- jpeg_lflags="-L$local_lib -ljpeg"
- if docc $jpeg_cflags $jpeg_lflags $LDFLAGS ; then
- has_jpeg="local"
- fi
+
+#look for sys/un.h support
+cat > $TMPC << EOF
+#include <sys/un.h>
+int main( void ) { struct sockaddr_un serv_add; return 0; }
+EOF
+has_sock_un="no"
+if docc $LDFLAGS ; then
+ has_sock_un="yes"
 fi
 
 
+#package config helpers
 
-#look for OpenJPEG support
 
-if test "$cross_prefix" = "" -a "$pkg_config" != "no"; then
- if $pkg_config --exists libopenjp2 ; then
- has_openjpeg="system"
- openjpeg_cflags=`$pkg_config --cflags libopenjp2`
- openjpeg_ldflags=`$pkg_config --libs libopenjp2`
- elif $pkg_config --exists libopenjpeg ; then
- has_openjpeg="system"
- openjpeg_cflags=`$pkg_config --cflags libopenjpeg`
- openjpeg_ldflags=`$pkg_config --libs libopenjpeg`
- fi
-fi
+pck_cxx="no"
+config_package_test ()
+{
+ package_name=$1
+ pkg_cfg_name=$2
+ package_cflags=$3
+ package_ldflags=$4
+ local_inc_dir=$5
+ package_src="$6"
 
-if test "$has_openjpeg" = "no" ; then
-cat > $TMPC << EOF
-#include <stdio.h>
-#include <openjpeg.h>
-int main( void ) { return 0; }
-EOF
+ forced=""
+ custom="no"
+ optname="$package_name="
+ for opt in $lib_args ; do
+ case "$opt" in
+ $optname*) forced=`echo $opt | cut -d '=' -f 2`
+ ;;
+ esac
+ done
 
-if docc $LDFLAGS -lopenjpeg ; then
- has_openjpeg="system"
- openjpeg_ldflags="-lopenjpeg"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_openjpeg" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if cc -o $TMPO $TMPC -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lopenjpeg 2>>$logs ; then
- has_openjpeg="system"
-		openjpeg_ldflags="-lopenjpeg"
+ if test "$forced" != "" ; then
+ case "$forced" in
+ "no")
+ if test "$package_name" = "zlib" ; then
+ has_pck="force-no"
+ fi
+ return
+ ;;
+ "local") ;;
+ "system") ;;
+ "") ;;
+ *) if -d "$forced" ; then
+ custom="yes"
+ else
+ echo "Invalid value $forced for $optname"
+ exit 1
+ fi
+ ;;
+ esac
+ fi
+
+ #test pkgconfig
+ if test "$forced" != "local" -a "$custom" != "yes" ; then
+ if test "$cross_prefix" = "" -a "$pkg_config" != "no"; then
+ if $pkg_config --exists $pkg_cfg_name ; then
+ pck_cflags=`$pkg_config --cflags $pkg_cfg_name`
+ pck_ldflags=`$pkg_config --libs $pkg_cfg_name`
+ has_pck="system (pkgconfig)"
+ return
 fi
 fi
 fi
-fi
 
-if test "$has_openjpeg" = "no" ; then
- if docc -I$local_inc/openjpeg -L$local_lib -lopenjpeg $LDFLAGS ; then
- has_openjpeg="local"
-	openjpeg_ldflags="-lopenjpeg"
+ if -z "$package_src" ; then
+ return
 fi
-fi
 
-fi
+ #for now docc and docxx are the same, just using a different source
+ if test "$pck_cxx" = "yes" ; then
+ echo "$package_src" > $TMPCXX
 
+ if test "$forced" != "local" ; then
+ if docxx $package_cflags $LDFLAGS $package_ldflags ; then
+ pck_cflags="$package_cflags"
+ pck_ldflags="$package_ldflags"
+ has_pck="system"
+ return
+ fi
+ fi
 
-#look for PNG support
-cat > $TMPC << EOF
-#include <png.h>
-int main( void ) { return 0; }
-EOF
+ if test "$forced" = "system" ; then
+ return
+ fi
 
-png_cflags="-I$prefix/include"
-png_lflags="-L$prefix/$libdir -lpng -lz"
-if docc $png_cflags $png_lflags $LDFLAGS ; then
- has_png="system"
-elif docc $LDFLAGS -lpng -lz ; then
- has_png="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_png" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lpng 2>>$logs ; then
- has_png="system"
- fi
+ if docxx -I"$local_inc/$local_inc_dir" -L$local_lib $package_ldflags ; then
+ pck_cflags="-I$local_inc/$local_inc_dir $package_cflags"
+ pck_ldflags="-L$local_lib $package_ldflags"
+ has_pck="local"
+ return
 fi
+
+ if docxx -I"$local_inc/$local_inc_dir" -L$execdir $package_ldflags ; then
+ pck_cflags="-I$local_inc/$local_inc_dir $package_cflags"
+ pck_ldflags="-L$execdir $package_ldflags"
+ has_pck="local (bin dir)"
+ return
+ fi
+ return
 fi
-fi
-if test "$has_png" = "no" ; then
- if docc -I$local_inc/png -L$local_lib -lpng $LDFLAGS ; then
- has_png="local"
- fi
-fi
 
+ echo "$package_src" > $TMPC
 
+ if test "$custom" = "yes" ; then
+ if docc -I"$forced//include" -L$forced//lib $package_ldflags ; then
+ pck_cflags="-I$forced//include $package_cflags"
+ pck_ldflags="-L$forced//lib $package_ldflags"
+ has_pck="custom"
+ fi
+ return
+ fi
 
-#look for MAD support
-cat > $TMPC << EOF
-#include <mad.h>
-int main( void ) { return 0; }
-EOF
+ if test "$forced" != "local" ; then
+ if docc $package_cflags $LDFLAGS $package_ldflags ; then
+ pck_cflags="$package_cflags"
+ pck_ldflags="$package_ldflags"
+ has_pck="system"
+ return
+ fi
 
-if docc $LDFLAGS -lmad ; then
- has_mad="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_mad" = "no" ; then
 if test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lmad 2>>$logs ; then
- has_mad="system"
+ if docc -I$alt_macosx_dir/include $package_cflags -L$alt_macosx_dir/lib $LDFLAGS $package_ldflags 2>>$logs ; then
+ pck_cflags="$package_cflags"
+ pck_ldflags="$package_ldflags"
+ has_pck="system"
+ return
 fi
 fi
 fi
-fi
-if test "$has_mad" = "no" ; then
- if docc -I$local_inc -L$local_lib -lmad $LDFLAGS ; then
- has_mad="local"
- fi
-fi
-
 
-#look for A52DEC support
-cat > $TMPC << EOF
-#include <inttypes.h>
-#define uint32_t unsigned int
-#define uint8_t unsigned char
-#include <a52dec/mm_accel.h>
-#include <a52dec/a52.h>
-int main( void ) { return 0; }
-EOF
 
-if docc $LDFLAGS -la52 ; then
- has_a52="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_a52" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -la52 2>>$logs ; then
- has_a52="system"
- fi
- fi
+ if test "$forced" = "system" ; then
+ return
 fi
-fi
-if test "$has_a52" = "no" ; then
- if docc -I$local_inc -L$local_lib -la52 $LDFLAGS ; then
- has_a52="local"
+
+ if docc -I"$local_inc/$local_inc_dir" -L$local_lib $package_ldflags ; then
+ pck_cflags="-I$local_inc/$local_inc_dir $package_cflags"
+ pck_ldflags="-L$local_lib $package_ldflags"
+ has_pck="local"
+ return
 fi
-fi
 
+ if docc -I"$local_inc/$local_inc_dir" -L$execdir $package_ldflags ; then
+ pck_cflags="-I$local_inc/$local_inc_dir $package_cflags"
+ pck_ldflags="-L$execdir $package_ldflags"
+ has_pck="local"
+ return
+ fi
+}
 
-#look for XVID support
-cat > $TMPC << EOF
-#include <xvid.h>
-int main( void ) { return 0; }
-EOF
+config_package ()
+{
+ has_pck="no"
+ pck_cflags=""
+ pck_ldflags=""
+
+ pname="$1"
+ case "$disabled_packages" in
+ *"$pname "*) shift
+ eval "has_$pname=\"no\""
+ return
+ ;;
+ esac
 
-if docc -I$prefix/include -L$prefix/$libdir $LDFLAGS -lxvidcore -lpthread ; then
- has_xvid="system"
-elif docc $LDFLAGS -lxvidcore -lpthread ; then
- has_xvid="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_xvid" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lxvidcore -lpthread 2>>$logs ; then
- has_xvid="system"
- fi
- fi
- fi
-fi
-if test "$has_xvid" = "no" ; then
- if docc -I$local_inc -L$local_lib -lxvidcore -lpthread $LDFLAGS ; then
- has_xvid="local"
+ config_package_test "$1" "$2" "$3" "$4" "$5" "$6"
+ if test "$has_pck" != "no" ; then
+ eval "cflags_$pname=\"$pck_cflags\""
+ eval "ldflags_$pname=\"$pck_ldflags\""
 fi
-fi
 
+ eval "has_$pname=\"$has_pck\""
+ pck_cxx="no"
+}
 
-#look for FAAD support
-cat > $TMPC << EOF
-#include <faad.h>
-int main( void ) { return 0; }
-EOF
+check_has_lib ()
+{
+ has_pck="no"
 
-if docc $LDFLAGS -lfaad -lm ; then
- has_faad="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_faad" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lfaad 2>>$logs ; then
- has_faad="system"
- fi
- fi
- fi
-fi
-if test "$has_faad" = "no" ; then
- if docc -I$local_inc -L$local_lib -lfaad -lm $LDFLAGS ; then
- has_faad="local"
+ tmpv=$1
+ for pck in $disabled_packages ; do
+ case "$tmpv" in
+ $pck) shift
+ eval "has_$tmpv=\"no\""
+ return
+ ;;
+ esac
+ done
+
+ echo "$3" > $TMPC
+ if docc $LDFLAGS $2 ; then
+ has_pck="yes"
 fi
-fi
+
+ var=$1
+ shift
+ eval "has_$var=\"$has_pck\""
+}
+#end package config helpers
 
 
-#look for FFMPEG support
 
-ffmpeg_cflags=""
-ffmpeg_lflags="-lz -lavcodec -lavformat -lavutil -lavdevice -lswscale -lswresample -lavfilter $ffmpeg_extra_ldflags"
 
-if test "$cross_prefix" = "" -a "$pkg_config" != "no"; then
- if $pkg_config --exists libavcodec libavformat libswscale libavdevice libavutil libswresample libavfilter ; then
- ffmpeg_cflags=`$pkg_config --cflags libavcodec libavformat libavutil libavdevice libswscale libswresample libavfilter`
- ffmpeg_lflags=`$pkg_config --libs libavcodec libavformat libavutil libavdevice libswscale libswresample libavfilter`
- has_ffmpeg="system"
- fi
+if test "$disable_codecs" = "yes"; then
+ append disabled_packages "jpeg png mad a52 faad xvid opensvc openjpeg ffmpeg ogg theora vorbis openhevc"
 fi
 
-cat > $TMPC << EOF
-#include <libavcodec/avcodec.h>
-int main(void) {
- return 0;
-}
-EOF
+if test "$static_bin" = "yes"; then
+ static_modules="yes"
+ static_build="yes"
 
-if docc $ffmpeg_cflags $ffmpeg_lflags $LDFLAGS ; then
- old_ffmpeg_inc="no"
-else
- old_ffmpeg_inc="yes"
+ #we cannot use these to produce a static bin, no static lib on most distributions
+ append disabled_packages "openjpeg ffmpeg ogg theora vorbis openhevc freenect platinum"
 
-# this is immediatly overwritten below??
-cat > $TMPC << EOF
-#include <ffmpeg/avcodec.h>
-#include <stdio.h>
-int main(void) {
- AVFrame *f1, *f2;
- printf("ID %d", AV_CODEC_ID_H264);
- f2 = av_frame_clone(f1);
- return 0;
-}
-EOF
+ #we cannot use openssl vanilla since it is usually built with DSO and requires dlopen
+ append disabled_packages "ssl"
+ #we cannot use ipv6 due to getaddrinfo not being present
+ append disabled_packages "ipv6"
 
+ append disabled_packages "lzma vtb sdl oss alsa jack pulseaudio directfb x11 dvb4linux directx"
 fi
 
-cat > $TMPC << EOF
-#include <libavcodec/avcodec.h>
+if test "$disable_parsers" = "yes" ; then
+ append disabled_packages "jpeg png"
+fi
+
+
+
+#look for all packages
+
+#start with zlib to disable png and freetype if forced to no
+
+config_package zlib "zlib" "" "-lz" "zlib" '#include <string.h>
 #include <stdio.h>
-int main(void) {
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 25, 0 )
- printf("ID %d", AV_CODEC_ID_H264);
-#else
- printf("ID %d", CODEC_ID_H264);
-#endif
- return 0;
-}
-EOF
+#include <zlib.h>
+int main( void ) { if (strcmp(zlibVersion(), ZLIB_VERSION)) { puts("zlib version differs !!!"); return 1; } return 0; }'
 
-if docc -I$prefix/include -L$prefix/$libdir $ffmpeg_lflags $LDFLAGS ; then
- has_ffmpeg="system"
- ffmpeg_cflags="-I$prefix/include"
- ffmpeg_lflags="-L$prefix/$libdir $ffmpeg_lflags"
-elif docc $ffmpeg_lflags $LDFLAGS ; then
- has_ffmpeg="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_ffmpeg" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $ffmpeg_lflags $LDFLAGS 2>>$logs ; then
- has_ffmpeg="system"
- ffmpeg_cflags="-I$alt_macosx_dir/include"
- ffmpeg_lflags="-L$alt_macosx_dir/lib $ffmpeg_lflags"
- fi
- fi
- fi
-fi
-if test "$has_ffmpeg" = "no" ; then
- if docc -I$local_inc -L$local_lib $ffmpeg_lflags $LDFLAGS ; then
- has_ffmpeg="local"
- ffmpeg_cflags="-I$local_inc"
- ffmpeg_lflags="-L$local_lib $ffmpeg_lflags"
- fi
+if test "$has_zlib" = "force-no" ; then
+ # can't have libpng without zlib or freetype without libpng
+ append disabled_packages "png freetype"
 fi
 
+config_package opensvc "OpenSVC" "" "-lOpenSVCDec" "" '#include <OpenSVCDecoder/SVCDecoder_ietr_api.h>
+int main( void ) { return 0; }'
 
-#now that cflags has been correctly set, retest
-cat > $TMPC << EOF
-#include <libavcodec/avcodec.h>
-int main(void) {
- return 0;
-}
-EOF
 
-if docc $ffmpeg_cflags $ffmpeg_lflags $LDFLAGS ; then
- old_ffmpeg_inc="no"
+#look for openhevc support
+config_package openhevc "openhevc" "" "-lopenhevc -lm -lpthread" "" '#include <stdio.h>
+#include <libopenhevc/openhevc.h>
+int main( void ) { oh_init(1, 1); return 0; }
+'
+
+pck_cxx="yes"
+config_package platinum "platinum" "" "-lPlatinum -lPltMediaServer -lPltMediaConnect -lPltMediaRenderer -lNeptune -lZlib -lpthread" "platinum" '#include <Platinum.h>
+int main( void ) { return 0; }'
+
+
+config_package freetype "freetype2" "" "-lfreetype" "freetype" '#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+#include FT_OUTLINE_H
+int main( void ) { return 0; }
+'
+
+if test "$mingw32" = "yes" ; then
+ ssl_lflags="-lssl -lcrypto"
+elif test "$win32" = "yes" ; then
+ ssl_lflags="-lssleay32 -leay32"
 else
- old_ffmpeg_inc="yes"
+ ssl_lflags="-lssl -lcrypto"
 fi
 
+config_package ssl "openssl" "" "$ssl_lflags" "" '#include <openssl/ssl.h>
+#include <openssl/x509.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
+int main( void ) { return 0; }'
 
-cat > $TMPC << EOF
-#include <libavutil/frame.h>
-#include <libavcodec/avcodec.h>
-#include <stdio.h>
-int main(void) {
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 25, 0 )
- printf("ID %d", AV_CODEC_ID_H264);
-#else
- printf("ID %d", CODEC_ID_H264);
-#endif
- return 0;
-}
-EOF
-if docc $ffmpeg_cflags $ffmpeg_lflags ; then
- is_libav="no"
-else
 
-cat > $TMPC << EOF
-#include <libavcodec/avcodec.h>
-int main(void) {
- printf("ID %d", CODEC_ID_H264);
- return 0;
-}
-EOF
+config_package jpeg "libjpeg" "" "-ljpeg" "jpeg" '#include <stdio.h>
+#include <jpeglib.h>
+int main( void ) { return 0; }'
 
- if docc $ffmpeg_cflags $ffmpeg_lflags ; then
- is_libav="yes"
- else
- is_libav="new"
- fi
+
+
+config_package openjpeg "libopenjp2" "" "-lopenjp2" "openjp2" '#include <stdio.h>
+#include <openjpeg.h>
+int main( void ) { return 0; }'
+
+if test "has_openjpeg" = "no" ; then
+config_package openjpeg "libopenjpeg" "" "-lopenjpeg" "openjpeg" '#include <stdio.h>
+#include <openjpeg.h>
+int main( void ) { return 0; }'
 fi
 
-#detect libswresample for dashcast only
-cat > $TMPC << EOF
-#include "libswresample/swresample.h"
+
+config_package png "libpng" "" "-lpng -lz" "png" '#include <png.h>
+int main( void ) { return 0; }'
+
+
+config_package mad "mad" "" "-lmad" "" '#include <mad.h>
+int main( void ) { return 0; }'
+
+config_package a52 "liba52" "" "-la52" "" '#include <inttypes.h>
+#define uint32_t unsigned int
+#define uint8_t unsigned char
+#include <a52dec/mm_accel.h>
+#include <a52dec/a52.h>
+int main( void ) { return 0; }'
+
+
+
+config_package xvid "xvid" "" "-lxvidcore -lpthread" "" '#include <xvid.h>
+int main( void ) { return 0; }'
+
+config_package faad "faad2" "" "-lfaad" "" '#include <faad.h>
+int main( void ) { return 0; }'
+
+
+ffmpeg_lflags="-lz -lavcodec -lavformat -lavutil -lavdevice -lswscale -lavfilter $ffmpeg_extra_ldflags"
+
+config_package ffmpeg "libavcodec libavformat libswscale libavdevice libavutil libavfilter" "" "$ffmpeg_lflags" "" '#include <libavcodec/avcodec.h>
 int main(void) {
- SwrContext *aresampler = swr_alloc();
- free(aresampler);
 return 0;
-}
-EOF
-
-if docc $ffmpeg_cflags $ffmpeg_lflags_dashcast -lswresample ; then
- has_libswresample="yes"
- ffmpeg_lflags_dashcast="$ffmpeg_lflags_dashcast -lswresample"
-else
- has_libswresample="no"
-fi
+}'
 
+if test "$has_ffmpeg" != no ; then
 
-#detect vvc support in ffmpegf
+#detect vvc support in ffmpeg
 cat > $TMPC << EOF
 #include <libavcodec/avcodec.h>
 int main(void) {
@@ -1365,787 +1409,192 @@
 }
 EOF
 
-if docc $ffmpeg_cflags $ffmpeg_lflags ; then
+#compile file but do not link
+if $cc -o $TMPO -c $TMPC $ffmpeg_cflags 0>/dev/null 2>$TMPL ; then
 ffmpeg_vvc="yes"
+ dolog $ffmpeg_cflags
+else
+ dolog $ffmpeg_cflags
 fi
 
-#look for FREENECT support
-freenect_flags=""
-freenect_ld="-lfreenect"
-has_freenect="no"
-if test "$pkg_config" != "no"; then
- if $pkg_config --exists libfreenect ; then
- freenect_flags=`$pkg_config --cflags libfreenect`
- freenect_libs=`$pkg_config --libs libfreenect`
- has_freenect="system"
- freenect_flags="-DFREENECT_FLAT_HEADERS $freenect_flags"
- fi
 fi
+#end ffmpeg specific tests
 
-if test "$has_freenect" = "no"; then
 
-cat > $TMPC << EOF
-#include <libfreenect/libfreenect.h>
-int main( void ) { return 0; }
-EOF
+config_package freenect "libfreenect" "" "-lfreenect" "freenect" '#include <libfreenect/libfreenect.h>
+int main( void ) { return 0; }'
+
+
+config_package vorbis "vorbis" "" "-lvorbis" "" '#include <vorbis/codec.h>
+int main( void ) { return 0; }'
+
+
+config_package theora "theora" "" "-ltheora -logg" "" '#include <theora/theora.h>
+int main( void ) { return 0; }'
+
+
+config_package ogg "ogg" "" "-logg" "" '#include <ogg/ogg.h>
+int main( void ) { return 0; }'
+
+config_package nghttp2 "libnghttp2" "" "-lnghttp2" "" '#include <stdio.h>
+#include <nghttp2/nghttp2.h>
+int main( void ) { return 0; }'
+
+
+#look for VideoToolBox support
+if test "$darwin" = "yes" ; then
+ldflags_vtb="-framework CoreFoundation -framework CoreVideo -framework CoreMedia -framework VideoToolbox"
+check_has_lib vtb "$ldflags_vtb" '#include <VideoToolbox/VideoToolbox.h>
+int main( void ) { return 0; }'
+fi
+
+#look for OSS support
+if test "$darwin" = "yes" ; then
+
+cat > $TMPC << EOF
+#include <soundcard.h>
+int main( void ) { return 0; }
+EOF
+
+ if docc -DLIBOSS_INTERNAL -I$alt_macosx_dir/include/ -I$alt_macosx_dir/include/liboss -L$alt_macosx_dir/lib -loss $LDFLAGS 2>>$logs ; then
+ has_oss="yes"
+ oss_cflags="-DLIBOSS_INTERNAL -I$alt_macosx_dir/include/ -I$alt_macosx_dir/include/liboss"
+ oss_ldflags="-L$alt_macosx_dir/lib -loss"
+ fi
+
+else
+
+check_has_lib oss "" '#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+int main( void ) { return 0; }'
+
+if test "$has_oss" = "no" ; then
+check_has_lib oss "" '#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <soundcard.h>
+int main( void ) { return 0; }'
+fi
+
+fi
+
+#look for IPv6
+check_has_lib ipv6 "$extralibs" '#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+int main( void ) {
+struct sockaddr_storage saddr;
+struct ipv6_mreq mreq6;
+getaddrinfo(0,0,0,0);
+getnameinfo(0,0,0,0,0,0,0);
+memset(&saddr, 0, sizeof(saddr));
+memset(&mreq6, 0, sizeof(mreq6));
+IN6_IS_ADDR_MULTICAST( (struct in6_addr *) 0);
+return 0;
+}'
+
+#look for poll
+check_has_lib poll "$extralibs" '#include <poll.h>
+int main( void ) {
+struct pollfd fds;
+int res = poll(&fds, 1, 1);
+return 0;
+}'
+
+
+
+check_has_lib dvb4linux "" '#include <linux/dvb/dmx.h>
+#include <linux/dvb/frontend.h>
+int main( void ) {return 0;}'
+
+check_has_lib alsa "" '#include <alsa/asoundlib.h>
+int main( void ) {return 0;}'
+
+
+check_has_lib pulseaudio "" '#include <pulse/pulseaudio.h>
+int main( void ) {return 0;}'
+
+check_has_lib jack "" '#include <jack/jack.h>
+int main( void ) {return 0;}'
+
+
+directfb_lib="-ldirectfb -lfusion -ldirect"
+check_has_lib directfb "$directfb_lib" '#include <directfb.h>
+int main( void ) {return 0;}'
+
+
+#config X11
+check_has_lib x11 "-I$X11_PATH/include -L$X11_PATH/lib" '#include <X11/Xlib.h>
+int main( void ) { return 0; }'
+
+if test "$has_x11" = "yes" ; then
+ #look for X11 shared memory support
+ check_has_lib x11_shm "-I$X11_PATH/include -L$X11_PATH/lib" '#include <X11/Xlib.h>
+#include <X11/extensions/XShm.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+int main( void ) { return 0; }'
+
+ #look for XVideo support
+ check_has_lib x11_xv "-I$X11_PATH/include -L$X11_PATH/lib" '#include <X11/Xlib.h>
+#include <X11/extensions/Xv.h>
+#include <X11/extensions/Xvlib.h>
+int main( void ) { return 0; }'
+
+ #look for glx support
+ check_has_lib x11_glx "-I$X11_PATH/include -L$X11_PATH/lib" '#include <X11/Xlib.h>
+#include <GL/gl.h>
+#include <GL/glx.h>
+int main( void ) { return 0; }'
+
+fi
+#end x11 test
+
+#look for hid support
+hid_lib="-lhidapi-hidraw"
+check_has_lib hid "$hid_lib" '#include <hidapi/hidapi.h>
+int main( void ) { hid_init(); hid_exit(); return 0; }'
+
+#look for lzma support
+check_has_lib lzma "-llzma" '#include <lzma.h>
+int main( void ) { lzma_options_lzma opt_lzma2; lzma_lzma_preset(&opt_lzma2, 9); return 0; }'
+
+#look for joystick support
+#check_has_lib joystick "" '#include <linux/joystick.h>
+#int main( void ) { return 0; }'
+
 
-if docc $LDFLAGS -lfreenect ; then
- has_freenect="system"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_freenect" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lfreenect 2>>$logs ; then
- has_freenect="system"
- freenect_flags=-I$alt_macosx_dir/include
- freenect_ld=-L$alt_macosx_dir/lib -lfreenect
- fi
- fi
- fi
-fi
-if test "$has_freenect" = "no" ; then
- if docc -I$local_inc/freenect -L$local_lib -lfreenect ; then
- has_freenect="local"
- freenect_flags=-I$local_inc/freenect
- freenect_ld=-L$local_lib -lfreenect
- fi
-fi
-
-fi
-
-
-#look for vorbis support
-cat > $TMPC << EOF
-#include <vorbis/codec.h>
-int main( void ) { return 0; }
-EOF
-
-if docc $LDFLAGS -lvorbis ; then
- has_vorbis="system"
-elif test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lvorbis 2>>$logs ; then
- has_vorbis="system"
- fi
-elif docc -I$local_inc -L$local_lib -lvorbis -lm ; then
- has_vorbis="local"
-fi
-
-
-
-#look for theora support
-cat > $TMPC << EOF
-#include <theora/theora.h>
-int main( void ) { return 0; }
-EOF
-
-if docc $LDFLAGS -ltheora ; then
- has_theora="system"
-elif test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -ltheora -logg 2>>$logs ; then
- has_theora="system"
- fi
-elif docc -I$local_inc -L$local_lib -ltheora -logg -lm ; then
- has_theora="local"
-fi
-
-
-
-#look for OGG support
-cat > $TMPC << EOF
-#include <ogg/ogg.h>
-int main( void ) { return 0; }
-EOF
-
-if docc $LDFLAGS -logg ; then
- has_ogg="system"
-elif test "$alt_macosx_dir" != "" ; then
- if docc -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -logg 2>>$logs ; then
- has_ogg="system"
- fi
-elif docc -I$local_inc -L$local_lib -logg -lm ; then
- has_ogg="local"
-else
- has_vorbis=no
- has_theora=no
-fi
-
-
-#look for VideoToolBox support
-
-if test "$darwin" = "yes" ; then
-vtb_ldflags="-framework CoreFoundation -framework CoreVideo -framework CoreMedia -framework VideoToolBox"
-	cat > $TMPC << EOF
-#include <VideoToolbox/VideoToolbox.h>
-int main( void ) { return 0; }
-EOF
-
-if docc $LDFLAGS $vtb_ldflags ; then
- has_vtb="yes"
-fi
-
-fi
-
-
-
-#look for OSS support
-if test "$darwin" = "yes" ; then
-
- cat > $TMPC << EOF
-#include <soundcard.h>
-int main( void ) { return 0; }
-EOF
-
- if docc -DLIBOSS_INTERNAL -I$alt_macosx_dir/include/ -I$alt_macosx_dir/include/liboss -L$alt_macosx_dir/lib -loss $LDFLAGS 2>>$logs ; then
- has_oss_audio="yes"
- OSS_CFLAGS="-DLIBOSS_INTERNAL -I$alt_macosx_dir/include/ -I$alt_macosx_dir/include/liboss"
- OSS_LDFLAGS="-L$alt_macosx_dir/lib -loss"
- fi
-
-else
-
- cat > $TMPC << EOF
-#include <sys/ioctl.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/soundcard.h>
-int main( void ) { return 0; }
-EOF
-
- if docc ; then
- has_oss_audio="yes"
- else
- cat > $TMPC << EOF
-#include <sys/ioctl.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <soundcard.h>
-int main( void ) { return 0; }
-EOF
-
- if docc $LDFLAGS ; then
- has_oss_audio="yes"
- fi
- fi
-
-fi
-
-#look for IPv6
-cat > $TMPC << EOF
-#include <string.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
-int main( void ) {
-struct sockaddr_storage saddr;
-struct ipv6_mreq mreq6;
-getaddrinfo(0,0,0,0);
-getnameinfo(0,0,0,0,0,0,0);
-memset(&saddr, 0, sizeof(saddr));
-memset(&mreq6, 0, sizeof(mreq6));
-IN6_IS_ADDR_MULTICAST( (struct in6_addr *) 0);
-return 0;
-}
-EOF
-
-if docc $LDFLAGS $extralibs ; then
- has_ipv6="yes"
-fi
-
-
-
-#look for DVB4linux
-cat > $TMPC << EOF
-#include <linux/dvb/dmx.h>
-#include <linux/dvb/frontend.h>
-int main( void ) {
-}
-EOF
-
-if docc $LDFLAGS ; then
- has_dvb4linux="yes"
-fi
-
-
-#look for alsa
-cat > $TMPC << EOF
-#include <alsa/asoundlib.h>
-int main( void ) {
-return 0;
-}
-EOF
-
-if docc $LDFLAGS ; then
- has_alsa="yes"
-fi
-
-
-
-#look for pulseaudio
-cat > $TMPC << EOF
-#include <pulse/pulseaudio.h>
-int main( void ) {
-return 0;
-}
-EOF
-
-if docc $LDFLAGS ; then
- has_pulseaudio="yes"
-fi
-
-
-
-#look for jack
-cat > $TMPC << EOF
-#include <jack/jack.h>
-int main( void ) {
-return 0;
-}
-EOF
-if docc $LDFLAGS ; then
- has_jack="yes"
-fi
-
-
-
-#look for directfb support
-cat > $TMPC << EOF
-#include <directfb.h>
-int main( void ) { return 0; }
-EOF
-directfb_inc="/usr/include/directfb"
-directfb_lib="-ldirectfb -lfusion -ldirect"
-if docc -I$directfb_inc -L$directfb_lib $LDFLAGS ; then
- has_directfb="yes"
-fi
-
-
-
-#look for X11 shared memory support
-cat > $TMPC << EOF
-#include <X11/Xlib.h>
-int main( void ) { return 0; }
-EOF
-
-if docc -I$X11_PATH/include -L$X11_PATH/lib $LDFLAGS ; then
- has_x11="yes"
-
- #look for X11 shared memory support
- cat > $TMPC << EOF
-#include <X11/Xlib.h>
-#include <X11/extensions/XShm.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-int main( void ) { return 0; }
-EOF
-
- if docc -I$X11_PATH/include -L$X11_PATH/lib $LDFLAGS ; then
- has_x11_shm="yes"
- fi
-
- #look for XVideo support
- cat > $TMPC << EOF
-#include <X11/Xlib.h>
-#include <X11/extensions/Xv.h>
-#include <X11/extensions/Xvlib.h>
-int main( void ) { return 0; }
-EOF
-
- if docc -I$X11_PATH/include -L$X11_PATH/lib $LDFLAGS ; then
- has_x11_xv="yes"
- fi
-
-fi
-
-
-#look for hid support
-cat > $TMPC << EOF
-#include <hidapi/hidapi.h>
-int main( void ) { hid_init(); hid_exit(); return 0; }
-EOF
-
-if docc -lhidapi-hidraw $LDFLAGS ; then
- hid_lib="-lhidapi-hidraw"
- has_hid="yes"
-fi
-
-#look for sys/un.h support
-cat > $TMPC << EOF
-#include <sys/un.h>
-int main( void ) { struct sockaddr_un serv_add; return 0; }
-EOF
-
-if docc $LDFLAGS ; then
- has_sock_un="yes"
-fi
-
-
-#look for lzma support
-cat > $TMPC << EOF
-#include <lzma.h>
-int main( void ) { lzma_options_lzma opt_lzma2; lzma_lzma_preset(&opt_lzma2, 9); return 0; }
-EOF
-
-if docc $CFLAGS_DIR -llzma $LDFLAGS ; then
- has_lzma="yes"
-fi
-
-#look for strlcpy support
-cat > $TMPC << EOF
-#include <string.h>
-int main( void ) {
- char dest1;
- strlcpy(dest, "1", 1);
- return 0;
-}
-EOF
-
-if docc $LDFLAGS ; then
- has_strlcpy="yes"
-fi
-
-
-#look for nghttp2 support
-
-if test "$cross_prefix" = "" -a "$pkg_config" != "no"; then
- if $pkg_config --exists libnghttp2 ; then
- has_nghttp2="system"
- nghttp2_cflags=`$pkg_config --cflags libnghttp2`
- nghttp2_ldflags=`$pkg_config --libs libnghttp2`
- fi
-fi
-
-if test "$has_nghttp2" = "no" ; then
-cat > $TMPC << EOF
-#include <stdio.h>
-#include <nghttp2/nghttp2.h>
-int main( void ) { return 0; }
-EOF
-
-if docc $LDFLAGS -lnghttp2 ; then
- has_nghttp2="system"
- nghttp2_ldflags="-lnghttp2"
-fi
-if test "$cross_prefix" = "" ; then
- if test "$has_nghttp2" = "no" ; then
- if test "$alt_macosx_dir" != "" ; then
- if cc -o $TMPO $TMPC -I$alt_macosx_dir/include -L$alt_macosx_dir/lib $LDFLAGS -lnghttp2 2>>$logs ; then
- has_nghttp2="system"
- nghttp2_ldflags="-lnghttp2"
- fi
- fi
- fi
-fi
-
-if test "$has_nghttp2" = "no" ; then
- if docc -I$local_inc -L$local_lib -lnghttp2 $LDFLAGS ; then
- has_nghttp2="local"
- nghttp2_ldflags="-lnghttp2"
- fi
-fi
-
-fi
-
-
-#overwrite detection with manual settings
-for opt do
- case "$opt" in
- --static-modules) static_modules="yes"
- ;;
- --sdl-cfg=*) sdl_path=`echo $opt | cut -d '=' -f 2`; sdl_local="yes"
- ;;
- --enable-sdl-static=*) sdl_static="yes"
- ;;
- --enable-jack) has_jack="yes"
- ;;
- --X11-path=*) X11_PATH=`echo $opt | cut -d '=' -f 2`
- ;;
- --dxsdk-path=*) dxsdk_path=`echo $opt | cut -d '=' -f 2`
- ;;
- --xulsdk-path=*) xulsdk_path=`echo $opt | cut -d '=' -f 2`
- ;;
- --mozdir=*) moz_path=`echo $opt | cut -d '=' -f 2`
- ;;
- --enable-amr-nb-fixed) has_amr_nb_fixed="yes"
- ;;
- --disable-pulseaudio) has_pulseaudio="no"
- ;;
- --enable-amr-nb) has_amr_nb="yes"
- ;;
- --enable-amr-wb) has_amr_wb="yes"
- ;;
- --enable-amr) has_amr_wb="yes"; has_amr_nb="yes"
- ;;
- --disable-oggvorbis) has_oggvorbis="no"
- ;;
- --disable-jack) has_jack="no"
- ;;
- --disable-alsa) has_alsa="no"
- ;;
- --enable-gprof) gprof_build="yes";
- ;;
- --static-build) static_build="yes";
- ;;
- --enable-static-bin)
- echo "$opt deprecated, use --static-build instead"
- static_build="yes";
- ;;
- --disable-ipv6) has_ipv6="no"
- ;;
- --disable-platinum) has_platinum="no"
- ;;
- --disable-oss-audio) has_oss_audio="no"
- ;;
- --disable-x11) has_x11="no"
- ;;
- --disable-x11-shm) has_x11_shm="no"
- ;;
- --disable-x11-xv) has_x11_xv="no"
- ;;
- --enable-fixed-point) use_fixed_point="yes"
- ;;
- --strip) INSTFLAGS="-s $INSTFLAGS"
- ;;
- --enable-mem-track) use_memory_tracking="yes"
- ;;
- --enable-tinygl) enable_tinygl="yes"
- ;;
- --disable-ssl) has_ssl="no"
- ;;
- --disable-lzma) has_lzma="no"
- ;;
- --enable-depth) enable_depth_compositor="yes"
- ;;
- --enable-qjs-stack) enable_qjs_stack_check="yes"
- ;;
- --static-bin) static_bin="yes"
- ;;
- --static-mp4box)
- echo "$opt deprecated, use --static-bin instead"
- static_bin="yes"
- ;;
- --use-faad=*) has_faad=${opt#--use-faad=}
- ;;
- --use-js=*) has_js=${opt#--use-js=}
- ;;
- --use-ft=*) has_ft=${opt#--use-ft=}
- ;;
- --use-mad=*) has_mad=${opt#--use-mad=}
- ;;
- --use-a52=*) has_a52=${opt#--use-a52=}
- ;;
- --use-xvid=*) has_xvid=${opt#--use-xvid=}
- ;;
- --use-jpeg=*) has_jpeg=${opt#--use-jpeg=}
- ;;
- --use-ffmpeg=*) has_ffmpeg=${opt#--use-ffmpeg=}
- ;;
- --use-freenect=*) has_freenect=${opt#--use-freenect=}
- ;;
- --use-png=*) tmp_has_png=${opt#--use-png=}
- if test "$tmp_has_png" = "system" ; then
- if test "$has_png" != "system" ; then
- if test "$cross_prefix" != "" ; then
- echo
- echo "WARNING: PNG has been forced to system, but we are cross-compiling, it will have to be on target"
- echo
- else
- echo
- echo "WARNING!! : PNG has been forced to system even though it hasn't been found in this host"
- echo
- fi
- fi
- fi
- has_png=$tmp_has_png
- ;;
- --use-zlib=*) tmp_has_zlib=${opt#--use-zlib=}
- if test "$tmp_has_zlib" = "system" ; then
- if test "$has_zlib" != "system" ; then
- if test "$cross_prefix" != "" ; then
- echo
- echo "WARNING: ZLIB has been forced to system, but we are cross-compiling, it will have to be on target"
- echo
- else
- echo
- echo "WARNING!! : ZLIB has been forced to system even though it hasn't been found in this host"
- echo
- fi
- fi
- has_zlib=$tmp_has_zlib
- elif test "$tmp_has_zlib" = "no" ; then
- echo
- echo "WARNING!! : you have forced not to use ZLIB. This will disable some core functionalities of GPAC."
- echo
- has_zlib="force-no"
- elif test "$tmp_has_zlib" = "local" ; then
- echo
- echo "WARNING!! : zlib is forced to be local without check - make sure it is avaliable in $local_lib"
- echo
- has_zlib="local"
- fi
- ;;
- --use-ogg=*) has_ogg=${opt#--use-ogg=}
- ;;
- --use-vorbis=*) has_vorbis=${opt#--use-vorbis=}
- ;;
- --use-theora=*) has_theora=${opt#--use-theora=}
- ;;
- --use-openjpeg=*) has_openjpeg=${opt#--use-openjpeg=}
- ;;
- --enable-joystick) enable_joystick="yes"
- ;;
- --enable-pulseaudio) has_pulseaudio="yes"
- ;;
- --disable-all) has_pulseaudio="no"; has_alsa="no"; disable_core_tools="yes"; disable_3d="yes"; disable_svg="yes"; disable_vrml="yes"; disable_od="yes"; disable_bifs="yes"; disable_bifs_enc="yes"; disable_laser="yes"; disable_seng="yes"; disable_qtvr="yes"; disable_avi="yes"; disable_ogg="yes"; disable_m2ps="yes"; disable_m2ts="yes"; disable_m2ts_mux="yes"; disable_parsers="yes"; disable_import="yes"; disable_export="yes"; disable_swf="yes"; disable_scene_stats="yes"; disable_scene_dump="yes"; disable_scene_encode="yes"; disable_loader_isoff="yes"; disable_log="yes"; disable_od_dump="yes"; disable_od_parse="yes"; disable_isom_dump="yes"; disable_crypto="yes"; disable_isoff="yes"; disable_isoff_write="yes"; disable_isoff_hint="yes"; disable_isoff_frag="yes"; disable_streaming="yes"; disable_x3d="yes"; disable_loader_bt="yes"; disable_loader_xmt="yes"; has_dvb4linux="no"; disable_player="yes"; disable_vobsub="yes"; disable_scenegraph="yes"; disable_dvbx="yes"; disable_ttxt="yes"; disable_vtt="yes"; disable_ttml="yes"; disable_saf="yes"; disable_smgr="yes"; disable_mpd="yes"; disable_dash="yes"; disable_isoff_hds="yes"; disable_hevc="yes" ; disable_nvdec="yes" ; disable_route="yes" ; enable_qjs="no"
- ;;
- --isomedia-only) has_pulseaudio="no"; has_alsa="no"; disable_core_tools="yes"; disable_3d="yes"; disable_svg="yes"; disable_vrml="yes"; disable_od="yes"; disable_bifs="yes"; disable_bifs_enc="yes"; disable_laser="yes"; disable_seng="yes"; disable_qtvr="yes"; disable_avi="yes"; disable_ogg="yes"; disable_m2ps="yes"; disable_m2ts="yes"; disable_m2ts_mux="yes"; disable_parsers="yes"; disable_import="yes"; disable_export="yes"; disable_swf="yes"; disable_scene_stats="yes"; disable_scene_dump="yes"; disable_scene_encode="yes"; disable_loader_isoff="yes"; disable_od_dump="yes"; disable_od_parse="yes"; disable_isom_dump="yes"; disable_crypto="yes"; disable_streaming="yes"; disable_x3d="yes"; disable_loader_bt="yes"; disable_loader_xmt="yes"; has_dvb4linux="no"; disable_player="yes"; disable_vobsub="yes"; disable_scenegraph="yes"; disable_dvbx="yes"; disable_ttxt="yes"; disable_saf="yes"; disable_smgr="yes"; disable_mpd="yes"; disable_dash="yes"; disable_hevc="no"; disable_isoff="no"; disable_isoff_hds="no"; disable_isoff_write="no"; disable_isoff_hint="no"; disable_isoff_frag="no" ; disable_route="yes" ; disable_nvdec="yes" ; enable_qjs="no"
- ;;
- --disable-3d) disable_3d="yes"
- ;;
- --enable-3d) disable_3d="no"
- ;;
- --disable-svg) disable_svg="yes"
- ;;
- --enable-svg) disable_svg="no"
- ;;
- --disable-vrml) disable_vrml="yes"
- ;;
- --enable-vrml) disable_vrml="no"
- ;;
- --disable-x3d) disable_x3d="yes"
- ;;
- --enable-x3d) disable_x3d="no"
- ;;
- --disable-odf) disable_od="yes"
- ;;
- --enable-odf) disable_od="no"
- ;;
- --disable-bifs) disable_bifs="yes"
- ;;
- --enable-bifs) disable_bifs="no"
- ;;
- --disable-bifs-enc) disable_bifs_enc="yes"
- ;;
- --enable-bifs-enc) disable_bifs_enc="no"
- ;;
- --disable-laser) disable_laser="yes"
- ;;
- --enable-laser) disable_laser="no"
- ;;
- --disable-seng) disable_seng="yes"
- ;;
- --enable-seng) disable_seng="no"
- ;;
- --disable-qtvr) disable_qtvr="yes"
- ;;
- --enable-qtvr) disable_qtvr="no"
- ;;
- --disable-avi) disable_avi="yes"
- ;;
- --enable-avi) disable_avi="no"
- ;;
- --disable-ogg) disable_ogg="yes"
- ;;
- --enable-ogg) disable_ogg="no"
- ;;
- --disable-m2ps) disable_m2ps="yes"
- ;;
- --enable-m2ps) disable_m2ps="no"
- ;;
- --disable-m2ts) disable_m2ts="yes"
- ;;
- --enable-m2ts) disable_m2ts="no"
- ;;
- --disable-m2ts-mux) disable_m2ts_mux="yes"
- ;;
- --enable-m2ts-mux) disable_m2ts_mux="no"
- ;;
- --disable-dvb4linux) has_dvb4linux="no"
- ;;
- --disable-parsers) disable_parsers="yes"
- ;;
- --enable-parsers) disable_parsers="no"
- ;;
- --disable-import) disable_import="yes"
- ;;
- --enable-import) disable_import="no"
- ;;
- --disable-export) disable_export="yes"
- ;;
- --enable-export) disable_export="no"
- ;;
- --disable-swf) disable_swf="yes"
- ;;
- --enable-swf) disable_swf="no"
- ;;
- --disable-scene-stats) disable_scene_stats="yes"
- ;;
- --enable-scene-stats) disable_scene_stats="no"
- ;;
- --disable-scene-dump) disable_scene_dump="yes"
- ;;
- --enable-scene-dump) disable_scene_dump="no"
- ;;
- --disable-scene-encode) disable_scene_encode="yes"
- ;;
- --enable-scene-encode) disable_scene_encode="no"
- ;;
- --disable-loader-isoff) disable_loader_isoff="yes"
- ;;
- --enable-loader-isoff) disable_loader_isoff="no"
- ;;
- --disable-loader-bt) disable_loader_bt="yes"
- ;;
- --enable-loader-bt) disable_loader_bt="no"
- ;;
- --disable-loader-xmt) disable_loader_xmt="yes"
- ;;
- --enable-loader-xmt) disable_loader_xmt="no"
- ;;
- --disable-od-dump) disable_od_dump="yes"
- ;;
- --enable-od-dump) disable_od_dump="no"
- ;;
- --disable-od-parse) disable_od_parse="yes"
- ;;
- --enable-od-parse) disable_od_parse="no"
- ;;
- --disable-isom-dump) disable_isom_dump="yes"
- ;;
- --enable-isom-dump) disable_isom_dump="no"
- ;;
- --disable-crypto) disable_crypto="yes"
- ;;
- --enable-crypto) disable_crypto="no"
- ;;
- --disable-isoff) disable_isoff="yes"
- ;;
- --enable-isoff) disable_isoff="no"
- ;;
- --disable-isoff-write) disable_isoff_write="yes"
- ;;
- --enable-isoff-write) disable_isoff_write="no"
- ;;
- --disable-isoff-hint) disable_isoff_hint="yes"
- ;;
- --enable-isoff-hint) disable_isoff_hint="no"
- ;;
- --disable-isoff-frag) disable_isoff_frag="yes"
- ;;
- --enable-isoff-frag) disable_isoff_frag="no"
- ;;
- --disable-isoff-hds) disable_isoff_hds="yes"
- ;;
- --enable-isoff-hds) disable_isoff_hds="no"
- ;;
- --disable-streaming) disable_streaming="yes"
- ;;
- --enable-streaming) disable_streaming="no"
- ;;
- --disable-player) disable_player="yes"
- ;;
- --enable-player) disable_player="no"
- ;;
- --disable-scenegraph) disable_scenegraph="yes"
- ;;
- --enable-scenegraph) disable_scenegraph="no"
- ;;
- --disable-dvbx) disable_dvbx="yes"
- ;;
- --enable-dvbx) disable_dvbx="no"
- ;;
- --disable-vobsub) disable_vobsub="yes"
- ;;
- --enable-vobsub) disable_vobsub="no"
- ;;
- --disable-ttxt) disable_ttxt="yes"
- ;;
- --enable-ttxt) disable_ttxt="no"
- ;;
- --disable-ttml) disable_ttml="yes"
- ;;
- --enable-vtt) disable_vtt="no"
- ;;
- --disable-vtt) disable_vtt="yes"
- ;;
- --enable-ttml) disable_ttml="no"
- ;;
- --disable-saf) disable_saf="yes"
- ;;
- --enable-saf) disable_saf="no"
- ;;
- --disable-smgr) disable_smgr="yes"
- ;;
- --enable-smgr) disable_smgr="no"
- ;;
- --disable-mpd) disable_mpd="yes"
- ;;
- --enable-mpd) disable_mpd="no"
- ;;
- --disable-dash) disable_dash="yes"
- ;;
- --enable-dash) disable_dash="no"
- ;;
- --disable-core) disable_core_tools="yes"
- ;;
- --enable-core) disable_core_tools="no"
- ;;
- --disable-hevc) disable_hevc="yes"
- ;;
- --enable-hevc) disable_hevc="no"
- ;;
- --disable-route) disable_route="yes"
- ;;
- --enable-route) disable_route="no"
- ;;
- --disable-qjs) enable_qjs="no"
- ;;
- --enable-qjs) enable_qjs="yes"
- ;;
- --disable-qjs-libc) enable_qjs_libc="no"
- ;;
- --enable-qjs-libc) enable_qjs_libc="yes"
- ;;
- --disable-log) disable_log="yes"
- ;;
- --enable-log) disable_log="no"
- ;;
- --disable-nvdec) disable_nvdec="yes"
- ;;
- --disable-codecs) disable_codecs="yes"
- ;;
- esac
-done
 
 #always force static modules when static build is used, we cannot have one exe with libgpac_static using a module with libgpac dynamic, this would cause bugs with gf_sys_init()
 if test "$static_build" = "yes"; then
 static_modules="yes"
+
+if test "$has_openhevc" != "no" -a "$has_ffmpeg!=no"; then
+ #we cannot have both openhevc and ffmpeg in static build
+ has_openhevc="no"
+fi
+
 fi
 
 
-if test "$disable_core_tools" = "no"; then
- if test "$has_zlib" = "no" ; then
+if test "$has_zlib" = "no" ; then
 echo "error: zlib not found on system or in local libs"
 exit 1
- fi
- if test "$has_zlib" = "force-no" ; then
- # can't have libpng without zlib
- has_png="no"
- # can't have freetype without libpng
- has_ft="no"
- fi
- if test "$dlopen" = "no"; then
+fi
+
+if test "$has_dlopen" = "no"; then
 if test "$win32" = "no"; then
 echo "error: dlopen not found on system"
 exit 1
 fi
- fi
-else
-GPAC_SH_FLAGS=""
-has_ssl="no"
 fi
 
 #look for OpenGL support or for TinyGL support
+has_opengl="no"
 LINK3D=""
 INCL3D=""
 DarwinGL="no"
@@ -2166,7 +1615,8 @@
 
 fi
 
-if test "$disable_3d" = "no" ; then
+#we cannot use openGL to produce a static bin
+if test "$disable_3d" = "no" -a "$static_bin" = "no" ; then
 if test "$win32" = "yes" ; then
 if test "$cygwin" = "yes" ; then
 LINK3D="-lw32api/opengl32 -lw32api/glu32"
@@ -2191,56 +1641,44 @@
 fi
 fi
 
-cat > $TMPC << EOF
-#include <GL/gl.h>
-int main( void ) { int a ; a = TINYGL ; return 0;}
-EOF
 
-if test "$enable_tinygl" = "yes" ;then
- if docc $LDFLAGS -lTinyGL ; then
- has_tinygl="yes"
+#look for tinyGL only if desired
+has_tinygl=no
+if test "$disable_tinygl" = "no" ;then
+
+check_has_lib tinygl "-lTinyGL" '#include <GL/gl.h>
+int main( void ) { int a ; a = TINYGL ; return 0;}'
+
+ if test "$has_tinygl" = "yes" ;then
 has_opengl="yes"
 LINK3D="-lTinyGL"
 fi
 fi
 
 
-#look for joystick support
-cat > $TMPC << EOF
-#include <linux/joystick.h>
-int main( void ) { return 0; }
-EOF
-if test "$enable_joystick" = "yes" ;then
- if docc $LDFLAGS ; then
- has_joystick="yes"
- fi
-fi
-
 
 
 #look for DX support
 dx_path="system"
-has_mingw_directx="no"
+has_directx="no"
 if test "$win32" = "yes" ; then
 
- cat > $TMPC << EOF
-#include <ddraw.h>
-int main( void ) { return 0; }
-EOF
+check_has_lib directx "-lddraw" '#include <ddraw.h>
+int main( void ) { return 0; }'
 
- if docc $LDFLAGS ; then
- has_mingw_directx="yes"
- else
- dx_path="$dxsdk_path"
- if docc -I$dxsdk_path/include -L$dxsdk_path/lib -lddraw ; then
- has_mingw_directx="yes"
- fi
+if test "has_directx" = "no" ; then
+ dx_path="$dxsdk_path"
+ check_has_lib directx "-I$dxsdk_path/include -L$dxsdk_path/lib -lddraw" '#include <ddraw.h>
+int main( void ) { return 0; }'
 fi
-
 fi
 
-#look for SDL support
-sdl_too_old=no
+
+#look for SDL support - we don't use check_has_lib for the time being
+case "$disabled_packages" in
+*"sdl "*) has_sdl=no
+ ;;
+*) sdl_too_old=no
 has_sdl=no
 
 sdl_config="sdl2-config"
@@ -2249,33 +1687,30 @@
 sdl_static="yes"
 fi
 
+if type $sdl_config >/dev/null 2>>$logs; then
 
-#if test "$cross_prefix" = "" ; then
- if type $sdl_config >/dev/null 2>>$logs; then
-
- cat > $TMPC << EOF
+ cat > $TMPC << EOF
 #include <SDL.h>
 #undef main
 int main( void ) { return SDL_Init (SDL_INIT_VIDEO); }
 EOF
 
- if test "$sdl_static" = "yes"; then
- sdl_lib_flags=`$sdl_config --static-libs`
- else
- sdl_lib_flags=`$sdl_config --libs`
- fi
- sdl_cflags=`$sdl_config --cflags`
+ if test "$sdl_static" = "yes"; then
+ sdl_lib_flags=`$sdl_config --static-libs`
+ else
+ sdl_lib_flags=`$sdl_config --libs`
+ fi
+ sdl_cflags=`$sdl_config --cflags`
 
- if docc $sdl_cflags $LDFLAGS $sdl_lib_flags ; then
- _sdlversion=`$sdl_config --version | sed 's/^0-9//g'`
- if test "$_sdlversion" -lt 121 ; then
- sdl_too_old=yes
- else
- has_sdl=yes
- fi
+ if docc $sdl_cflags $LDFLAGS $sdl_lib_flags ; then
+ _sdlversion=`$sdl_config --version | sed 's/^0-9//g'`
+ if test "$_sdlversion" -lt 121 ; then
+ sdl_too_old=yes
+ else
+ has_sdl=yes
 fi
 fi
-#fi
+fi
 
 if test "$has_sdl" = "no" ; then
 
@@ -2312,8 +1747,11 @@
 fi
 fi
 fi
+;;
+esac
 #end SDL check
 
+
 #look at endianess
 if test -z "$cross_prefix" ; then
 
@@ -2345,93 +1783,16 @@
 CFLAGS="$CFLAGS -DNDEBUG"
 fi
 
-#man dir
-if test x"$mandir" = x""; then
- mandir="share/man"
-fi
-
-
-if test "$disable_codecs" = "yes"; then
- has_jpeg="no"
- has_png="no"
- has_mad="no"
- has_a52="no"
- has_mad="no"
- has_faad="no"
- has_xvid="no"
- has_opensvc="no"
- has_openjpeg="no"
- has_ffmpeg="no"
- has_ogg="no"
- has_theora="no"
- has_vorbis="no"
- has_openhevc="no"
-fi
-
-if test "$static_bin" = "yes"; then
- static_modules="yes"
- static_build="yes"
- #we cannot use openssl vanilla since it is usually built with DSO and requires dlopen
- has_ssl="no"
- #we cannot use ipv6 due to getaddrinfo not being present
- has_ipv6="no"
-
-# has_js="no"
-# has_ft="no"
-# has_jpeg="no"
-# has_png="no"
-# has_mad="no"
-# has_a52="no"
-# has_mad="no"
-# has_faad="no"
-# has_xvid="no"
-# has_opensvc="no"
 
- #we cannot use openjpeg to produce a static bin, no static lib on most distributions
- has_openjpeg="no"
-
- #we cannot use FFMPEG to produce a static bin, no static lib on most distributions. This could be done by building a local statoc only ffmpeg
-if test "$has_ffmpeg" = "system" ; then
- has_ffmpeg="no"
+#set gnu90 once all packages have been chcked, otherwise we will use it in docxx
+if docc $CFLAGS -std=gnu99 ; then
+ CFLAGS="$CFLAGS -std=gnu99"
 fi
 
- #we cannot use ogg/theora/vorbis to produce a static bin, no static lib on most distributions, issues with lm acosf_finite, log_finite, ...
- has_ogg="no"
- has_theora="no"
- has_vorbis="no"
- #we cannot use openhevc to produce a static bin, dependencies to avcodec/avformat. We need a static ffmpeg build with openhevc support
- has_openhevc="no"
- has_freenect="no"
- has_platinum="no"
- has_lzma="no"
- has_vtb="no"
-
-#we cannot use openGL nor audio/video output to produce a static bin
- has_opengl="no"
- has_sdl="no"
- has_oss_audio="no"
- has_alsa="no"
- has_jack="no"
- has_pulseaudio="no"
- has_directfb="no"
- has_x11="no"
- has_dvb4linux="no"
- has_mingw_directx="no"
-
-fi
-
-if test "$cpu" = "sh4"; then
- viren_dir="`ls \"$source_path/modules\" | grep viren_out`"
- if test "$viren_dir" = "viren_out"; then
- enable_depth_compositor="yes"
- fi
-fi
 
-if test "$has_lzma" = "yes"; then
- GPAC_SH_FLAGS="$GPAC_SH_FLAGS -llzma"
- if test "$win32" = "yes"; then
- extralibs="$extralibs -llzma"
- fi
+#man dir
+if test x"$mandir" = x""; then
+ mandir="share/man"
 fi
 
 
@@ -2460,7 +1821,6 @@
 disable_player="yes"
 disable_smgr="yes"
 disable_nvdec="yes"
- has_js="no"
 fi
 
 if test "$disable_mpd" = "yes"; then
@@ -2473,12 +1833,19 @@
 disable_loader_xmt="yes"
 fi
 
-if test "$disable_parsers" = "yes" ; then
- has_jpeg="no"
- has_png="no"
+
+
+if test "$has_lzma" = "yes"; then
+ GPAC_SH_FLAGS="$GPAC_SH_FLAGS -llzma"
+ if test "$win32" = "yes"; then
+ #add to extra lib for static mp4box build
+ extralibs="$extralibs -llzma"
+ fi
 fi
 
-#prepare for config.h writing
+
+
+#all done, prepare for config.h writing
 TMPH="${TMPDIR1}/gpac-conf-${RANDOM}-$$-${RANDOM}.h"
 echo "/* Automatically generated by configure */" > $TMPH
 echo "#ifndef GF_CONFIG_H" >> $TMPH
@@ -2525,7 +1892,19 @@
 echo "Sanitizer enabled: $enable_sanitizer"
 echo "Fixed-Point Version: $use_fixed_point"
 echo "IPV6 Support: $has_ipv6"
-echo "QuickJS Support: $enable_qjs (qjslibc $enable_qjs_libc)"
+
+if test $disable_qjs = "no" ; then
+enable_qjs="yes"
+if test $disable_qjs_libc = "no" ; then
+echo "QuickJS Support: yes (with qjs-libc)"
+else
+echo "QuickJS Support: yes (no qjs-libc)"
+fi
+else
+enable_qjs="no"
+echo "QuickJS Support: no"
+fi
+
 
 if test "$disable_player" = "yes" ; then
 echo "Player disabled"
@@ -2552,10 +1931,6 @@
 echo "Scene Manager disabled"
 echo "#define GPAC_DISABLE_SMGR" >> $TMPH
 fi
-if test "$disable_core_tools" = "yes" ; then
- echo "Core tools disabled"
- echo "#define GPAC_DISABLE_CORE_TOOLS" >> $TMPH
-fi
 if test "$disable_svg" = "yes" ; then
 echo "SVG disabled"
 echo "#define GPAC_DISABLE_SVG" >> $TMPH
@@ -2569,7 +1944,7 @@
 echo "X3D disabled"
 echo "#define GPAC_DISABLE_X3D" >> $TMPH
 fi
-if test "$disable_od" = "yes" ; then
+if test "$disable_odf" = "yes" ; then
 echo "OD Full support disabled"
 echo "#define GPAC_MINIMAL_ODF" >> $TMPH
 fi
@@ -2703,7 +2078,7 @@
 echo "#define GPAC_DISABLE_STREAMING" >> $TMPH
 fi
 if test "$disable_dvbx" = "no" ; then
- echo "DVB MPE and DSM-CC disabled"
+ echo "DVB MPE and DSM-CC enabled"
 echo "#define GPAC_ENABLE_MPE" >> $TMPH
 echo "#define GPAC_ENABLE_DSMCC" >> $TMPH
 fi
@@ -2726,12 +2101,12 @@
 echo "#define GPAC_DISABLE_VTT" >> $TMPH
 fi
 
-if test "$enable_depth_compositor" = "yes" ; then
+if test "$disable_depth_compositor" = "no" ; then
 echo "Depth Compositor enabled"
 echo "#define GF_SR_USE_DEPTH" >> $TMPH
 fi
 
-if test "$enable_qjs_stack_check" = "yes" ; then
+if test "$disable_qjs_stack" = "no" ; then
 echo "#define GPAC_QJS_STACK_CHECK" >> $TMPH
 fi
 
@@ -2770,18 +2145,28 @@
 echo "** Detected libraries **"
 echo "zlib: $has_zlib"
 echo "OpenGL support: $has_opengl"
+
+if test "$disable_tinygl" = "no" ; then
 echo "TinyGL support: $has_tinygl"
+fi
 echo "OpenSSL support: $has_ssl"
+echo "nghttp2: $has_nghttp2"
 
 if test "$win32" != "yes" ; then
- echo "OSS Audio: $has_oss_audio"
+ echo "OSS Audio: $has_oss"
 echo "ALSA Audio: $has_alsa"
 echo "Jack Audio: $has_jack"
 echo "Pulse Audio: $has_pulseaudio"
 echo "DirectFB: $has_directfb"
 
+ if -z $X11_PATH ; then
+ echo "X11: $has_x11"
+ else
+ echo "X11: $has_x11 (path: $X11_PATH)"
+ fi
+
 if test "$has_x11" != "no" ; then
- echo "X11 Shared Memory support: $has_x11_shm (path: $X11_PATH)"
+ echo "X11 Shared Memory support: $has_x11_shm"
 echo "X11 XVideo support: $has_x11_xv"
 fi
 fi
@@ -2791,25 +2176,34 @@
 fi
 
 if test "$win32" = "yes" ; then
- echo "DirectX: $has_mingw_directx"
+ echo "DirectX: $has_directx"
 fi
 if test "$linux" = "yes" ; then
 echo "DVB for Linux: $has_dvb4linux"
 fi
 
-echo "FreeType: $has_ft"
+echo "FreeType: $has_freetype"
 echo "JPEG: $has_jpeg"
 echo "OpenJPEG: $has_openjpeg"
 echo "PNG: $has_png"
 echo "MAD: $has_mad"
 echo "FAAD: $has_faad"
 echo "XVID: $has_xvid"
-echo "FFMPEG: $has_ffmpeg"
+
+ffopts=""
 if test "$has_ffmpeg" != "no" ; then
 if test "$ffmpeg_vvc" = "yes" ; then
-echo "FFMPG VVC Support: $ffmpeg_vvc"
+ ffopts="VVC $ffopts "
+fi
 fi
+
+if -z $ffopts ; then
+echo "FFMPEG: $has_ffmpeg"
+else
+echo "FFMPEG: $has_ffmpeg - "$ffopts"supported"
 fi
+
+
 echo "LZMA: $has_lzma"
 echo "Xiph OGG: $has_ogg"
 echo "Platinum UPnP: $has_platinum"
@@ -2824,39 +2218,7 @@
 echo "OpenSVCDecoder: $has_opensvc"
 echo "OpenHEVCDecoder: $has_openhevc"
 echo "Freenect: $has_freenect"
-echo "nghttp2: $has_nghttp2"
-
-
-if test "$has_amr_nb_fixed" = "yes" ; then
- echo ""
- echo "*** AMR NB FIXED-POINT NOTICE ***"
- echo "Make sure you have downloaded TS26.073 from:"
- echo "http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-*.zip"
- echo "or through gpac_extra_libs and extracted src to modules/amr_dec/amr_nb"
- echo "without overwriting typedefs.h file"
- echo ""
-fi
-
-if test "$has_amr_nb" = "yes" ; then
- echo ""
- echo "*** AMR NB NOTICE ***"
- echo "Make sure you have downloaded TS26.104 from:"
- echo "http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-*.zip"
- echo "or through gpac_extra_libs and extracted src to modules/amr_float_dec/amr_nb_ft"
- echo "without overwriting typedefs.h file"
- echo ""
-fi
-
 
-if test "$has_amr_wb" = "yes" ; then
- echo ""
- echo "*** AMR WB NOTICE ***"
- echo "Make sure you have downloaded TS26.204 from:"
- echo "http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-*.zip"
- echo "or through gpac_extra_libs and extracted src to modules/amr_float_dec/amr_wb_ft"
- echo "without overwriting typedefs.h file"
- echo ""
-fi
 
 echo ""
 
@@ -2869,7 +2231,7 @@
 
 #we add no deprecate by default on osx (due to opengl ...)
 if test "$darwin" = "yes" ; then
- CFLAGS="$CFLAGS_DIR $CFLAGS -Wno-deprecated -Wno-deprecated-declarations"
+ CFLAGS="$CFLAGS -Wno-deprecated -Wno-deprecated-declarations"
 else
 CFLAGS="$CFLAGS -Wno-deprecated -Wno-deprecated-declarations -Wno-int-in-bool-context"
 fi
@@ -2958,6 +2320,9 @@
 echo "#define GPAC_BIG_ENDIAN" >> $TMPH
 fi
 echo "EXTRALIBS=$extralibs" >> config.mak
+echo "LIBGPAC_CFLAGS=$libgpac_cflags" >> config.mak
+echo "LIBGPAC_LDFLAGS=$libgpac_extralibs" >> config.mak
+
 echo "VERSION=$version" >>config.mak
 echo "VERSION_MAJOR=$version_major" >>config.mak
 echo "VERSION_SONAME=$soname_version" >>config.mak
@@ -3044,7 +2409,7 @@
 echo "CONFIG_JS=$enable_qjs" >> config.mak
 if test "$enable_qjs" = "yes" ; then
 echo "#define GPAC_HAS_QJS" >> $TMPH
-if test "$enable_qjs_libc" = "no" ; then
+if test "$disable_qjs_libc" = "yes" ; then
 echo "#define GPAC_DISABLE_QJS_LIBC" >> $TMPH
 fi
 
@@ -3056,24 +2421,18 @@
 else
 echo "CONFIG_ZLIB=$has_zlib" >> config.mak
 fi
-echo "CONFIG_FT=$has_ft" >> config.mak
+echo "CONFIG_FT=$has_freetype" >> config.mak
 
-echo "CONFIG_JPEG=$has_jpeg" >> config.mak
 if test "$has_jpeg" != "no" ; then
 echo "#define GPAC_HAS_JPEG" >> $TMPH
- echo "jpeg_cflags=$jpeg_cflags" >> config.mak
- echo "jpeg_lflags=$jpeg_lflags" >> config.mak
 fi
 
-echo "CONFIG_PNG=$has_png" >> config.mak
 if test "$has_png" != "no" ; then
 echo "#define GPAC_HAS_PNG" >> $TMPH
 fi
 
-echo "CONFIG_VTB=$has_vtb" >> config.mak
 if test "$has_vtb" != "no" ; then
 echo "#define GPAC_HAS_VTB" >> $TMPH
- echo "vtb_ldflags=$vtb_ldflags" >> config.mak
 fi
 
 echo "CONFIG_STRLCPY=$has_strlcpy" >> config.mak
@@ -3086,56 +2445,47 @@
 fi
 
 echo "CONFIG_LZMA=$has_lzma" >> config.mak
-if test "$has_lzma" = "yes"; then
+if test "$has_lzma" != "no"; then
 echo "#define GPAC_HAS_LZMA" >> $TMPH
 fi
 
-echo "CONFIG_JP2=$has_openjpeg" >> config.mak
+
 if test "$has_openjpeg" != "no" ; then
- echo "JP2_CFLAGS=$openjpeg_cflags" >> config.mak
- echo "JP2_LDFLAGS=$openjpeg_ldflags" >> config.mak
 echo "#define GPAC_HAS_JP2" >> $TMPH
 fi
-echo "CONFIG_FAAD=$has_faad" >> config.mak
+
 if test "$has_faad" != "no" ; then
 echo "#define GPAC_HAS_FAAD" >> $TMPH
 fi
-echo "CONFIG_MAD=$has_mad" >> config.mak
+
 if test "$has_mad" != "no" ; then
 echo "#define GPAC_HAS_MAD" >> $TMPH
 fi
-echo "CONFIG_XVID=$has_xvid" >> config.mak
+
 if test "$has_xvid" != "no" ; then
 echo "#define GPAC_HAS_XVID" >> $TMPH
 fi
 echo "CONFIG_OGG=$has_ogg" >> config.mak
-echo "CONFIG_VORBIS=$has_vorbis" >> config.mak
+
 if test "$has_vorbis" != "no" ; then
 echo "#define GPAC_HAS_VORBIS" >> $TMPH
 fi
-echo "CONFIG_THEORA=$has_theora" >> config.mak
+
 if test "$has_theora" != "no" ; then
 echo "#define GPAC_HAS_THEORA" >> $TMPH
 fi
-echo "CONFIG_FFMPEG=$has_ffmpeg" >> config.mak
-if test "$has_ffmpeg" = "no"; then
-echo "DISABLE_DASHCAST=yes" >> config.mak
-else
- echo "ffmpeg_cflags=$ffmpeg_cflags" >> config.mak
- echo "ffmpeg_lflags=$ffmpeg_lflags" >> config.mak
- echo "CONFIG_LIBAV=$is_libav" >> config.mak
- echo "CONFIG_LIBSWRESAMPLE=$has_libswresample" >> config.mak
+
+if test "$has_ffmpeg" != "no"; then
 echo "#define GPAC_HAS_FFMPEG" >> $TMPH
 if test "$ffmpeg_vvc" = "yes"; then
 echo "#define FFMPEG_ENABLE_VVC" >> $TMPH
 fi
 fi
-echo "CONFIG_FFMPEG_OLD=$old_ffmpeg_inc" >> config.mak
 
-echo "CONFIG_OSS_AUDIO=$has_oss_audio" >> config.mak
+echo "CONFIG_OSS_AUDIO=$has_oss" >> config.mak
 echo "CONFIG_ALSA=$has_alsa" >> config.mak
 echo "CONFIG_JACK=$has_jack" >> config.mak
-echo "CONFIG_A52=$has_a52" >> config.mak
+
 if test "$has_a52" != "no" ; then
 echo "#define GPAC_HAS_LIBA52" >> $TMPH
 fi
@@ -3147,17 +2497,29 @@
 echo "FREENECT_LDLAGS=$freenect_ld" >> config.mak
 fi
 
-if test "$want_gcov" = "yes" ; then
+if test "$want_gcov" = "yes" ; then
 echo "#define GPAC_ENABLE_COVERAGE" >> $TMPH
 fi
 
-echo "CONFIG_NGHTTP2=$has_nghttp2" >> config.mak
 if test "$has_nghttp2" != "no" ; then
- echo "NGHTTP2_CFLAGS=$nghttp2_cflags" >> config.mak
- echo "NGHTTP2_LDFLAGS=$nghttp2_ldflags" >> config.mak
 echo "#define GPAC_HAS_HTTP2" >> $TMPH
 fi
 
+#dump all cflags
+for pcklib in $all_packages ; do
+ eval "has_pck=\$has_$pcklib"
+ if test "$has_pck" = "no" ; then
+ lib_cflags=""
+ lib_ldflags=""
+ else
+ eval "lib_cflags=\$cflags_$pcklib"
+ eval "lib_ldflags=\$ldflags_$pcklib"
+ fi
+ echo $pcklib"_cflags="$lib_cflags >> config.mak
+ echo $pcklib"_ldflags="$lib_ldflags >> config.mak
+done
+
+
 
 echo "DISABLE_PLAYER=$disable_player" >> config.mak
 echo "DISABLE_STREAMING=$disable_streaming" >> config.mak
@@ -3191,7 +2553,7 @@
 echo "DISABLE_MEDIA_EXPORT=$disable_export" >> config.mak
 echo "DISABLE_MPD=$disable_mpd" >> config.mak
 echo "DISABLE_DASH_CLIENT=$disable_dash" >> config.mak
-echo "DISABLE_CORE_TOOLS=$disable_core_tools" >> config.mak
+echo "DISABLE_CORE_TOOLS=$disable_core" >> config.mak
 echo "DISABLE_OD_DUMP=$disable_od_dump" >> config.mak
 echo "DISABLE_OD_PARSE=$disable_od_parse" >> config.mak
 echo "MINIMAL_OD=$disable_od" >> config.mak
@@ -3226,84 +2588,62 @@
 echo "#define GPAC_DISABLE_NVDEC" >> $TMPH
 fi
 
-echo "ENABLE_JOYSTICK=$has_joystick" >> config.mak
-
 echo "HAS_OPENSSL=$has_ssl" >> config.mak
-if test "$has_ssl" = "yes" ; then
- echo "SSL_LIBS=$LINK_SSL" >> config.mak
+if test "$has_ssl" != "no" ; then
 echo "#define GPAC_HAS_SSL" >> $TMPH
 fi
 
 echo "CONFIG_SDL=$has_sdl" >> config.mak
-if test "$has_sdl" = "yes" ; then
- echo "SDL_CFLAGS=$sdl_cflags" >> config.mak
- echo "SDL_LIBS=$sdl_lib_flags" >> config.mak
-fi
-if test "$has_ft" = "no" ; then
- has_ft="no"
-else
- echo "FT_CFLAGS=$ft_cflags" >> config.mak
- echo "FT_LIBS=$ft_lflags" >> config.mak
+if test "$has_sdl" != "no" ; then
+ echo "sdl_cflags=$sdl_cflags" >> config.mak
+ echo "sdl_ldflags=$sdl_lib_flags" >> config.mak
 fi
-echo "CONFIG_AMR_NB=$has_amr_nb_fixed" >> config.mak
-echo "CONFIG_AMR_NB_FT=$has_amr_nb" >> config.mak
-echo "CONFIG_AMR_WB_FT=$has_amr_wb" >> config.mak
+
+
 echo "DEBUGBUILD=$debuginfo" >> config.mak
 echo "GPROFBUILD=$gprof_build" >> config.mak
 echo "STATIC_BINARY=$static_bin" >> config.mak
-echo "STATICBUILD=$static_build" >> config.mak
+echo "STATIC_BUILD=$static_build" >> config.mak
 
 echo "CONFIG_IPV6=$has_ipv6" >> config.mak
 if test "$has_ipv6" = "yes" ; then
 echo "#define GPAC_HAS_IPV6" >> $TMPH
 fi
 
+if test "$has_poll" = "yes" ; then
+ echo "#define GPAC_HAS_POLL" >> $TMPH
+fi
+
 if test "$is_64" = "yes" ; then
 echo "#define GPAC_64_BITS" >> $TMPH
 fi
 
 if test "$win32" = "yes" ; then
- echo "CONFIG_DIRECTX=$has_mingw_directx" >> config.mak
- if test "$has_mingw_directx" = "yes" ; then
+ echo "CONFIG_DIRECTX=$has_directx" >> config.mak
+ if test "$has_directx" = "yes" ; then
 echo "DX_PATH=$dx_path" >> config.mak
 fi
 fi
 
 echo "CONFIG_PLATINUM=$has_platinum" >> config.mak
 
-echo "CONFIG_OPENSVC=$has_opensvc" >> config.mak
-if test "$has_opensvc" = "yes" ; then
- echo "OSVC_CFLAGS=$osvc_cflags" >> config.mak
- echo "OSVC_LDFLAGS=$osvc_ldflags" >> config.mak
+if test "$has_opensvc" != "no" ; then
 echo "#define GPAC_HAS_OPENSVC" >> $TMPH
 fi
 
 echo "CONFIG_OPENHEVC=$has_openhevc" >> config.mak
-if test "$has_openhevc" = "yes" ; then
- echo "OHEVC_CFLAGS=$ohevc_cflags" >> config.mak
- echo "OHEVC_LDFLAGS=$ohevc_ldflags" >> config.mak
+if test "$has_openhevc" != "no" ; then
 echo "#define GPAC_HAS_OPENHEVC" >> $TMPH
-
-
-if test "$static_modules" = "yes" ; then
- echo "#define GPAC_OPENHEVC_STATIC" >> $TMPH
-fi
-
+ if test "$static_modules" = "yes" ; then
+ echo "#define GPAC_OPENHEVC_STATIC" >> $TMPH
+ fi
 fi
 
-echo "MOZILLA_DIR=$moz_path" >> config.mak
-
 echo "LINUX_DVB=$has_dvb4linux" >> config.mak
-if test "$has_dvb4linux" = "yes"; then
+if test "$has_dvb4linux" != "no"; then
 echo "#define GPAC_HAS_LINUX_DVB" >> $TMPH
 fi
 
-if test "$has_oss_audio" != "no"; then
- echo "OSS_INC_TYPE=$has_oss_audio" >> config.mak
- echo "OSS_CFLAGS=$OSS_CFLAGS" >> config.mak
- echo "OSS_LDFLAGS=$OSS_LDFLAGS" >> config.mak
-fi
-
 echo "CONFIG_DIRECTFB=$has_directfb" >> config.mak
 echo "DIRECTFB_INC_PATH=$directfb_inc" >> config.mak
 echo "DIRECTFB_LIB=$directfb_lib" >> config.mak
@@ -3316,12 +2656,16 @@
 if test "$has_x11_xv" = "yes"; then
 echo "USE_X11_XV=$has_x11_xv" >> config.mak
 fi
+if test "$has_x11_glx" = "yes"; then
+ echo "USE_X11_GLX=$has_x11_glx" >> config.mak
+fi
 
 echo "CONFIG_HID=$has_hid" >> config.mak
 echo "HID_LDFLAGS=$hid_lib" >> config.mak
 
+echo "PKG_CONFIG=$pkg_config" >> config.mak
 
-
+if -n "$X11_PATH" ; then
 if test "$is_64" = "yes"; then
 #not on OSX ...
 if test "$darwin" = "yes"; then
@@ -3333,41 +2677,15 @@
 echo "X11_LIB_PATH=$X11_PATH/lib" >> config.mak
 fi
 echo "X11_INC_PATH=$X11_PATH/include" >> config.mak
-
-GPAC_ENST_INC=no
-GPAC_ENST=no
-enst_dir="`ls \"$source_path/src/\" | grep enst`"
-if test "$enst_dir" = "enst"; then
- echo "GPAC Proprietary Extensions enabled"
- GPAC_ENST_INC=yes
- #we need libiconv for eit & co
- cat > $TMPC << EOF
-#include <iconv.h>
-int main( void ) {
-return 0;
-}
-EOF
-
- if docc -L$local_lib -liconv ; then
- GPAC_ENST=yes
- echo "LIBGPAC_ENST=`cd src; ls enst/*.c | sed -e 's/\.c/.o/' | tr -s '\r\n' ' ' ; cd ..`" >> config.mak
- else
- echo "Couldn't find libiconv - disabling GPAC ENST extensions"
- GPAC_ENST="no"
- fi
 fi
-echo "GPAC_ENST=$GPAC_ENST" >> config.mak
-echo "GPAC_ENST_INC=$GPAC_ENST" >> config.mak
-
-
 
 #build tree in object directory if source path is different from current one
 if test "$source_path_used" = "yes" ; then
 
 echo "Creating compilation tree image"
- SRC_DIRS="src src/utils src/isomedia src/ietf src/odf src/bifs src/scenegraph src/filter_core src/filters src/terminal src/crypto src/media_tools src/scene_manager src/compositor src/laser src/evg src/quickjs src/jsmods"
+ SRC_DIRS="src src/utils src/isomedia src/ietf src/odf src/bifs src/scenegraph src/filter_core src/filters src/crypto src/media_tools src/scene_manager src/compositor src/laser src/evg src/quickjs src/jsmods"
 
- APP_DIRS="applications/gpac applications/mp4box applications/mp4client"
+ APP_DIRS="applications/gpac applications/mp4box"
 
 for dir in $SRC_DIRS ; do
 mkdir -p "$dir"
@@ -3387,20 +2705,19 @@
 
 
 cur_dir="`pwd`"
- cd "$source_path/"
- MOD_DIRS="`ls -d modules/*/`"
 cd "$cur_dir"
 
 mkdir -p modules
 ln -sf "$source_path/modules/Makefile" modules/Makefile
 
- for dir in $MOD_DIRS ; do
- if -f "$source_path/$dir/Makefile" ; then
+ for moddir in "$source_path/modules/"* ; do
+ if -d "$moddir" -a -f "$moddir/Makefile" ; then
+ dir="${moddir#"$source_path/"}"
 mkdir -p "$dir"
- ln -sf "$source_path/$dir/Makefile" "$dir/Makefile"
+ ln -sf "$moddir/Makefile" "$dir/Makefile"
 fi
 done
- if test "$has_mingw_directx" = "yes"; then
+ if test "$has_directx" = "yes"; then
 ln -sf "$source_path/modules/dx_hw/hand.cur" modules/dx_hw/hand.cur
 ln -sf "$source_path/modules/dx_hw/collide.cur" modules/dx_hw/collide.cur
 fi

gpac-2.0.0.tar.gz/debian/changelog -> gpac-2.2.0.tar.gz/debian/changelog Changed

gpac-2.0.0.tar.gz/debian/control -> gpac-2.2.0.tar.gz/debian/control Changed

gpac-2.0.0.tar.gz/debian/rules -> gpac-2.2.0.tar.gz/debian/rules Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavcodec/avcodec.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/avcodec.h Changed

@@ -27,20 +27,22 @@
 * Libavcodec external API header
 */
 
-#include <errno.h>
 #include "libavutil/samplefmt.h"
 #include "libavutil/attributes.h"
 #include "libavutil/avutil.h"
 #include "libavutil/buffer.h"
-#include "libavutil/cpu.h"
-#include "libavutil/channel_layout.h"
 #include "libavutil/dict.h"
 #include "libavutil/frame.h"
-#include "libavutil/hwcontext.h"
 #include "libavutil/log.h"
 #include "libavutil/pixfmt.h"
 #include "libavutil/rational.h"
 
+#include "codec.h"
+#include "codec_desc.h"
+#include "codec_par.h"
+#include "codec_id.h"
+#include "defs.h"
+#include "packet.h"
 #include "version.h"
 
 /**
@@ -92,6 +94,7 @@
 * compressed data in an AVPacket.
 * - For encoding, call avcodec_send_frame() to give the encoder an AVFrame
 * containing uncompressed audio or video.
+ *
 * In both cases, it is recommended that AVPackets and AVFrames are
 * refcounted, or libavcodec might have to copy the input data. (libavformat
 * always returns refcounted AVPackets, and av_frame_get_buffer() allocates
@@ -102,6 +105,7 @@
 * an AVFrame containing uncompressed audio or video data.
 * - For encoding, call avcodec_receive_packet(). On success, it will return
 * an AVPacket with a compressed frame.
+ *
 * Repeat this call until it returns AVERROR(EAGAIN) or an error. The
 * AVERROR(EAGAIN) return value means that new input data is required to
 * return new output. In this case, continue with sending input. For each
@@ -147,29 +151,6 @@
 * at least will not fail with AVERROR(EAGAIN). In general, no codec will
 * permit unlimited buffering of input or output.
 *
- * This API replaces the following legacy functions:
- * - avcodec_decode_video2() and avcodec_decode_audio4():
- * Use avcodec_send_packet() to feed input to the decoder, then use
- * avcodec_receive_frame() to receive decoded frames after each packet.
- * Unlike with the old video decoding API, multiple frames might result from
- * a packet. For audio, splitting the input packet into frames by partially
- * decoding packets becomes transparent to the API user. You never need to
- * feed an AVPacket to the API twice (unless it is rejected with AVERROR(EAGAIN) - then
- * no data was read from the packet).
- * Additionally, sending a flush/draining packet is required only once.
- * - avcodec_encode_video2()/avcodec_encode_audio2():
- * Use avcodec_send_frame() to feed input to the encoder, then use
- * avcodec_receive_packet() to receive encoded packets.
- * Providing user-allocated buffers for avcodec_receive_packet() is not
- * possible.
- * - The new API does not handle subtitles yet.
- *
- * Mixing new and old function calls on the same AVCodecContext is not allowed,
- * and will result in undefined behavior.
- *
- * Some codecs might require using the new API; using the old API will return
- * an error when calling it. All codecs support the new API.
- *
 * A codec is not allowed to return AVERROR(EAGAIN) for both sending and receiving. This
 * would be an invalid state, which could put the codec user into an endless
 * loop. The API has no concept of time either: it cannot happen that trying to
@@ -196,582 +177,6 @@
 * @{
 */
 
-
-/**
- * Identify the syntax and semantics of the bitstream.
- * The principle is roughly:
- * Two decoders with the same ID can decode the same streams.
- * Two encoders with the same ID can encode compatible streams.
- * There may be slight deviations from the principle due to implementation
- * details.
- *
- * If you add a codec ID to this list, add it so that
- * 1. no value of an existing codec ID changes (that would break ABI),
- * 2. it is as close as possible to similar codecs
- *
- * After adding new codec IDs, do not forget to add an entry to the codec
- * descriptor list and bump libavcodec minor version.
- */
-enum AVCodecID {
- AV_CODEC_ID_NONE,
-
- /* video codecs */
- AV_CODEC_ID_MPEG1VIDEO,
- AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
- AV_CODEC_ID_H261,
- AV_CODEC_ID_H263,
- AV_CODEC_ID_RV10,
- AV_CODEC_ID_RV20,
- AV_CODEC_ID_MJPEG,
- AV_CODEC_ID_MJPEGB,
- AV_CODEC_ID_LJPEG,
- AV_CODEC_ID_SP5X,
- AV_CODEC_ID_JPEGLS,
- AV_CODEC_ID_MPEG4,
- AV_CODEC_ID_RAWVIDEO,
- AV_CODEC_ID_MSMPEG4V1,
- AV_CODEC_ID_MSMPEG4V2,
- AV_CODEC_ID_MSMPEG4V3,
- AV_CODEC_ID_WMV1,
- AV_CODEC_ID_WMV2,
- AV_CODEC_ID_H263P,
- AV_CODEC_ID_H263I,
- AV_CODEC_ID_FLV1,
- AV_CODEC_ID_SVQ1,
- AV_CODEC_ID_SVQ3,
- AV_CODEC_ID_DVVIDEO,
- AV_CODEC_ID_HUFFYUV,
- AV_CODEC_ID_CYUV,
- AV_CODEC_ID_H264,
- AV_CODEC_ID_INDEO3,
- AV_CODEC_ID_VP3,
- AV_CODEC_ID_THEORA,
- AV_CODEC_ID_ASV1,
- AV_CODEC_ID_ASV2,
- AV_CODEC_ID_FFV1,
- AV_CODEC_ID_4XM,
- AV_CODEC_ID_VCR1,
- AV_CODEC_ID_CLJR,
- AV_CODEC_ID_MDEC,
- AV_CODEC_ID_ROQ,
- AV_CODEC_ID_INTERPLAY_VIDEO,
- AV_CODEC_ID_XAN_WC3,
- AV_CODEC_ID_XAN_WC4,
- AV_CODEC_ID_RPZA,
- AV_CODEC_ID_CINEPAK,
- AV_CODEC_ID_WS_VQA,
- AV_CODEC_ID_MSRLE,
- AV_CODEC_ID_MSVIDEO1,
- AV_CODEC_ID_IDCIN,
- AV_CODEC_ID_8BPS,
- AV_CODEC_ID_SMC,
- AV_CODEC_ID_FLIC,
- AV_CODEC_ID_TRUEMOTION1,
- AV_CODEC_ID_VMDVIDEO,
- AV_CODEC_ID_MSZH,
- AV_CODEC_ID_ZLIB,
- AV_CODEC_ID_QTRLE,
- AV_CODEC_ID_TSCC,
- AV_CODEC_ID_ULTI,
- AV_CODEC_ID_QDRAW,
- AV_CODEC_ID_VIXL,
- AV_CODEC_ID_QPEG,
- AV_CODEC_ID_PNG,
- AV_CODEC_ID_PPM,
- AV_CODEC_ID_PBM,
- AV_CODEC_ID_PGM,
- AV_CODEC_ID_PGMYUV,
- AV_CODEC_ID_PAM,
- AV_CODEC_ID_FFVHUFF,
- AV_CODEC_ID_RV30,
- AV_CODEC_ID_RV40,
- AV_CODEC_ID_VC1,
- AV_CODEC_ID_WMV3,
- AV_CODEC_ID_LOCO,
- AV_CODEC_ID_WNV1,
- AV_CODEC_ID_AASC,
- AV_CODEC_ID_INDEO2,
- AV_CODEC_ID_FRAPS,
- AV_CODEC_ID_TRUEMOTION2,
- AV_CODEC_ID_BMP,
- AV_CODEC_ID_CSCD,
- AV_CODEC_ID_MMVIDEO,
- AV_CODEC_ID_ZMBV,
- AV_CODEC_ID_AVS,
- AV_CODEC_ID_SMACKVIDEO,
- AV_CODEC_ID_NUV,
- AV_CODEC_ID_KMVC,
- AV_CODEC_ID_FLASHSV,
- AV_CODEC_ID_CAVS,
- AV_CODEC_ID_JPEG2000,
- AV_CODEC_ID_VMNC,
- AV_CODEC_ID_VP5,
- AV_CODEC_ID_VP6,
- AV_CODEC_ID_VP6F,
- AV_CODEC_ID_TARGA,
- AV_CODEC_ID_DSICINVIDEO,
- AV_CODEC_ID_TIERTEXSEQVIDEO,
- AV_CODEC_ID_TIFF,
- AV_CODEC_ID_GIF,
- AV_CODEC_ID_DXA,
- AV_CODEC_ID_DNXHD,
- AV_CODEC_ID_THP,
- AV_CODEC_ID_SGI,
- AV_CODEC_ID_C93,
- AV_CODEC_ID_BETHSOFTVID,
- AV_CODEC_ID_PTX,
- AV_CODEC_ID_TXD,
- AV_CODEC_ID_VP6A,
- AV_CODEC_ID_AMV,
- AV_CODEC_ID_VB,
- AV_CODEC_ID_PCX,
- AV_CODEC_ID_SUNRAST,
- AV_CODEC_ID_INDEO4,
- AV_CODEC_ID_INDEO5,
- AV_CODEC_ID_MIMIC,
- AV_CODEC_ID_RL2,
- AV_CODEC_ID_ESCAPE124,
- AV_CODEC_ID_DIRAC,
- AV_CODEC_ID_BFI,
- AV_CODEC_ID_CMV,
- AV_CODEC_ID_MOTIONPIXELS,
- AV_CODEC_ID_TGV,
- AV_CODEC_ID_TGQ,
- AV_CODEC_ID_TQI,
- AV_CODEC_ID_AURA,
- AV_CODEC_ID_AURA2,
- AV_CODEC_ID_V210X,
- AV_CODEC_ID_TMV,
- AV_CODEC_ID_V210,
- AV_CODEC_ID_DPX,
- AV_CODEC_ID_MAD,
- AV_CODEC_ID_FRWU,
- AV_CODEC_ID_FLASHSV2,
- AV_CODEC_ID_CDGRAPHICS,
- AV_CODEC_ID_R210,
- AV_CODEC_ID_ANM,
- AV_CODEC_ID_BINKVIDEO,
- AV_CODEC_ID_IFF_ILBM,
-#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
- AV_CODEC_ID_KGV1,
- AV_CODEC_ID_YOP,
- AV_CODEC_ID_VP8,
- AV_CODEC_ID_PICTOR,
- AV_CODEC_ID_ANSI,
- AV_CODEC_ID_A64_MULTI,
- AV_CODEC_ID_A64_MULTI5,
- AV_CODEC_ID_R10K,
- AV_CODEC_ID_MXPEG,
- AV_CODEC_ID_LAGARITH,
- AV_CODEC_ID_PRORES,
- AV_CODEC_ID_JV,
- AV_CODEC_ID_DFA,
- AV_CODEC_ID_WMV3IMAGE,
- AV_CODEC_ID_VC1IMAGE,
- AV_CODEC_ID_UTVIDEO,
- AV_CODEC_ID_BMV_VIDEO,
- AV_CODEC_ID_VBLE,
- AV_CODEC_ID_DXTORY,
- AV_CODEC_ID_V410,
- AV_CODEC_ID_XWD,
- AV_CODEC_ID_CDXL,
- AV_CODEC_ID_XBM,
- AV_CODEC_ID_ZEROCODEC,
- AV_CODEC_ID_MSS1,
- AV_CODEC_ID_MSA1,
- AV_CODEC_ID_TSCC2,
- AV_CODEC_ID_MTS2,
- AV_CODEC_ID_CLLC,
- AV_CODEC_ID_MSS2,
- AV_CODEC_ID_VP9,
- AV_CODEC_ID_AIC,
- AV_CODEC_ID_ESCAPE130,
- AV_CODEC_ID_G2M,
- AV_CODEC_ID_WEBP,
- AV_CODEC_ID_HNM4_VIDEO,
- AV_CODEC_ID_HEVC,
-#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
- AV_CODEC_ID_FIC,
- AV_CODEC_ID_ALIAS_PIX,
- AV_CODEC_ID_BRENDER_PIX,
- AV_CODEC_ID_PAF_VIDEO,
- AV_CODEC_ID_EXR,
- AV_CODEC_ID_VP7,
- AV_CODEC_ID_SANM,
- AV_CODEC_ID_SGIRLE,
- AV_CODEC_ID_MVC1,
- AV_CODEC_ID_MVC2,
- AV_CODEC_ID_HQX,
- AV_CODEC_ID_TDSC,
- AV_CODEC_ID_HQ_HQA,
- AV_CODEC_ID_HAP,
- AV_CODEC_ID_DDS,
- AV_CODEC_ID_DXV,
- AV_CODEC_ID_SCREENPRESSO,
- AV_CODEC_ID_RSCC,
-
- AV_CODEC_ID_Y41P = 0x8000,
- AV_CODEC_ID_AVRP,
- AV_CODEC_ID_012V,
- AV_CODEC_ID_AVUI,
- AV_CODEC_ID_AYUV,
- AV_CODEC_ID_TARGA_Y216,
- AV_CODEC_ID_V308,
- AV_CODEC_ID_V408,
- AV_CODEC_ID_YUV4,
- AV_CODEC_ID_AVRN,
- AV_CODEC_ID_CPIA,
- AV_CODEC_ID_XFACE,
- AV_CODEC_ID_SNOW,
- AV_CODEC_ID_SMVJPEG,
- AV_CODEC_ID_APNG,
- AV_CODEC_ID_DAALA,
- AV_CODEC_ID_CFHD,
- AV_CODEC_ID_TRUEMOTION2RT,
- AV_CODEC_ID_M101,
- AV_CODEC_ID_MAGICYUV,
- AV_CODEC_ID_SHEERVIDEO,
- AV_CODEC_ID_YLC,
- AV_CODEC_ID_PSD,
- AV_CODEC_ID_PIXLET,
- AV_CODEC_ID_SPEEDHQ,
- AV_CODEC_ID_FMVC,
- AV_CODEC_ID_SCPR,
- AV_CODEC_ID_CLEARVIDEO,
- AV_CODEC_ID_XPM,
- AV_CODEC_ID_AV1,
- AV_CODEC_ID_BITPACKED,
- AV_CODEC_ID_MSCC,
- AV_CODEC_ID_SRGC,
- AV_CODEC_ID_SVG,
- AV_CODEC_ID_GDV,
- AV_CODEC_ID_FITS,
-
- /* various PCM "codecs" */
- AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
- AV_CODEC_ID_PCM_S16LE = 0x10000,
- AV_CODEC_ID_PCM_S16BE,
- AV_CODEC_ID_PCM_U16LE,
- AV_CODEC_ID_PCM_U16BE,
- AV_CODEC_ID_PCM_S8,
- AV_CODEC_ID_PCM_U8,
- AV_CODEC_ID_PCM_MULAW,
- AV_CODEC_ID_PCM_ALAW,
- AV_CODEC_ID_PCM_S32LE,
- AV_CODEC_ID_PCM_S32BE,
- AV_CODEC_ID_PCM_U32LE,
- AV_CODEC_ID_PCM_U32BE,
- AV_CODEC_ID_PCM_S24LE,
- AV_CODEC_ID_PCM_S24BE,
- AV_CODEC_ID_PCM_U24LE,
- AV_CODEC_ID_PCM_U24BE,
- AV_CODEC_ID_PCM_S24DAUD,
- AV_CODEC_ID_PCM_ZORK,
- AV_CODEC_ID_PCM_S16LE_PLANAR,
- AV_CODEC_ID_PCM_DVD,
- AV_CODEC_ID_PCM_F32BE,
- AV_CODEC_ID_PCM_F32LE,
- AV_CODEC_ID_PCM_F64BE,
- AV_CODEC_ID_PCM_F64LE,
- AV_CODEC_ID_PCM_BLURAY,
- AV_CODEC_ID_PCM_LXF,
- AV_CODEC_ID_S302M,
- AV_CODEC_ID_PCM_S8_PLANAR,
- AV_CODEC_ID_PCM_S24LE_PLANAR,
- AV_CODEC_ID_PCM_S32LE_PLANAR,
- AV_CODEC_ID_PCM_S16BE_PLANAR,
-
- AV_CODEC_ID_PCM_S64LE = 0x10800,
- AV_CODEC_ID_PCM_S64BE,
- AV_CODEC_ID_PCM_F16LE,
- AV_CODEC_ID_PCM_F24LE,
-
- /* various ADPCM codecs */
- AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
- AV_CODEC_ID_ADPCM_IMA_WAV,
- AV_CODEC_ID_ADPCM_IMA_DK3,
- AV_CODEC_ID_ADPCM_IMA_DK4,
- AV_CODEC_ID_ADPCM_IMA_WS,
- AV_CODEC_ID_ADPCM_IMA_SMJPEG,
- AV_CODEC_ID_ADPCM_MS,
- AV_CODEC_ID_ADPCM_4XM,
- AV_CODEC_ID_ADPCM_XA,
- AV_CODEC_ID_ADPCM_ADX,
- AV_CODEC_ID_ADPCM_EA,
- AV_CODEC_ID_ADPCM_G726,
- AV_CODEC_ID_ADPCM_CT,
- AV_CODEC_ID_ADPCM_SWF,
- AV_CODEC_ID_ADPCM_YAMAHA,
- AV_CODEC_ID_ADPCM_SBPRO_4,
- AV_CODEC_ID_ADPCM_SBPRO_3,
- AV_CODEC_ID_ADPCM_SBPRO_2,
- AV_CODEC_ID_ADPCM_THP,
- AV_CODEC_ID_ADPCM_IMA_AMV,
- AV_CODEC_ID_ADPCM_EA_R1,
- AV_CODEC_ID_ADPCM_EA_R3,
- AV_CODEC_ID_ADPCM_EA_R2,
- AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
- AV_CODEC_ID_ADPCM_IMA_EA_EACS,
- AV_CODEC_ID_ADPCM_EA_XAS,
- AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
- AV_CODEC_ID_ADPCM_IMA_ISS,
- AV_CODEC_ID_ADPCM_G722,
- AV_CODEC_ID_ADPCM_IMA_APC,
- AV_CODEC_ID_ADPCM_VIMA,
-
- AV_CODEC_ID_ADPCM_AFC = 0x11800,
- AV_CODEC_ID_ADPCM_IMA_OKI,
- AV_CODEC_ID_ADPCM_DTK,
- AV_CODEC_ID_ADPCM_IMA_RAD,
- AV_CODEC_ID_ADPCM_G726LE,
- AV_CODEC_ID_ADPCM_THP_LE,
- AV_CODEC_ID_ADPCM_PSX,
- AV_CODEC_ID_ADPCM_AICA,
- AV_CODEC_ID_ADPCM_IMA_DAT4,
- AV_CODEC_ID_ADPCM_MTAF,
-
- /* AMR */
- AV_CODEC_ID_AMR_NB = 0x12000,
- AV_CODEC_ID_AMR_WB,
-
- /* RealAudio codecs*/
- AV_CODEC_ID_RA_144 = 0x13000,
- AV_CODEC_ID_RA_288,
-
- /* various DPCM codecs */
- AV_CODEC_ID_ROQ_DPCM = 0x14000,
- AV_CODEC_ID_INTERPLAY_DPCM,
- AV_CODEC_ID_XAN_DPCM,
- AV_CODEC_ID_SOL_DPCM,
-
- AV_CODEC_ID_SDX2_DPCM = 0x14800,
- AV_CODEC_ID_GREMLIN_DPCM,
-
- /* audio codecs */
- AV_CODEC_ID_MP2 = 0x15000,
- AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
- AV_CODEC_ID_AAC,
- AV_CODEC_ID_AC3,
- AV_CODEC_ID_DTS,
- AV_CODEC_ID_VORBIS,
- AV_CODEC_ID_DVAUDIO,
- AV_CODEC_ID_WMAV1,
- AV_CODEC_ID_WMAV2,
- AV_CODEC_ID_MACE3,
- AV_CODEC_ID_MACE6,
- AV_CODEC_ID_VMDAUDIO,
- AV_CODEC_ID_FLAC,
- AV_CODEC_ID_MP3ADU,
- AV_CODEC_ID_MP3ON4,
- AV_CODEC_ID_SHORTEN,
- AV_CODEC_ID_ALAC,
- AV_CODEC_ID_WESTWOOD_SND1,
- AV_CODEC_ID_GSM, ///< as in Berlin toast format
- AV_CODEC_ID_QDM2,
- AV_CODEC_ID_COOK,
- AV_CODEC_ID_TRUESPEECH,
- AV_CODEC_ID_TTA,
- AV_CODEC_ID_SMACKAUDIO,
- AV_CODEC_ID_QCELP,
- AV_CODEC_ID_WAVPACK,
- AV_CODEC_ID_DSICINAUDIO,
- AV_CODEC_ID_IMC,
- AV_CODEC_ID_MUSEPACK7,
- AV_CODEC_ID_MLP,
- AV_CODEC_ID_GSM_MS, /* as found in WAV */
- AV_CODEC_ID_ATRAC3,
- AV_CODEC_ID_APE,
- AV_CODEC_ID_NELLYMOSER,
- AV_CODEC_ID_MUSEPACK8,
- AV_CODEC_ID_SPEEX,
- AV_CODEC_ID_WMAVOICE,
- AV_CODEC_ID_WMAPRO,
- AV_CODEC_ID_WMALOSSLESS,
- AV_CODEC_ID_ATRAC3P,
- AV_CODEC_ID_EAC3,
- AV_CODEC_ID_SIPR,
- AV_CODEC_ID_MP1,
- AV_CODEC_ID_TWINVQ,
- AV_CODEC_ID_TRUEHD,
- AV_CODEC_ID_MP4ALS,
- AV_CODEC_ID_ATRAC1,
- AV_CODEC_ID_BINKAUDIO_RDFT,
- AV_CODEC_ID_BINKAUDIO_DCT,
- AV_CODEC_ID_AAC_LATM,
- AV_CODEC_ID_QDMC,
- AV_CODEC_ID_CELT,
- AV_CODEC_ID_G723_1,
- AV_CODEC_ID_G729,
- AV_CODEC_ID_8SVX_EXP,
- AV_CODEC_ID_8SVX_FIB,
- AV_CODEC_ID_BMV_AUDIO,
- AV_CODEC_ID_RALF,
- AV_CODEC_ID_IAC,
- AV_CODEC_ID_ILBC,
- AV_CODEC_ID_OPUS,
- AV_CODEC_ID_COMFORT_NOISE,
- AV_CODEC_ID_TAK,
- AV_CODEC_ID_METASOUND,
- AV_CODEC_ID_PAF_AUDIO,
- AV_CODEC_ID_ON2AVC,
- AV_CODEC_ID_DSS_SP,
- AV_CODEC_ID_CODEC2,
-
- AV_CODEC_ID_FFWAVESYNTH = 0x15800,
- AV_CODEC_ID_SONIC,
- AV_CODEC_ID_SONIC_LS,
- AV_CODEC_ID_EVRC,
- AV_CODEC_ID_SMV,
- AV_CODEC_ID_DSD_LSBF,
- AV_CODEC_ID_DSD_MSBF,
- AV_CODEC_ID_DSD_LSBF_PLANAR,
- AV_CODEC_ID_DSD_MSBF_PLANAR,
- AV_CODEC_ID_4GV,
- AV_CODEC_ID_INTERPLAY_ACM,
- AV_CODEC_ID_XMA1,
- AV_CODEC_ID_XMA2,
- AV_CODEC_ID_DST,
- AV_CODEC_ID_ATRAC3AL,
- AV_CODEC_ID_ATRAC3PAL,
- AV_CODEC_ID_DOLBY_E,
- AV_CODEC_ID_APTX,
- AV_CODEC_ID_APTX_HD,
- AV_CODEC_ID_SBC,
-
- /* subtitle codecs */
- AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
- AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
- AV_CODEC_ID_DVB_SUBTITLE,
- AV_CODEC_ID_TEXT, ///< raw UTF-8 text
- AV_CODEC_ID_XSUB,
- AV_CODEC_ID_SSA,
- AV_CODEC_ID_MOV_TEXT,
- AV_CODEC_ID_HDMV_PGS_SUBTITLE,
- AV_CODEC_ID_DVB_TELETEXT,
- AV_CODEC_ID_SRT,
-
- AV_CODEC_ID_MICRODVD = 0x17800,
- AV_CODEC_ID_EIA_608,
- AV_CODEC_ID_JACOSUB,
- AV_CODEC_ID_SAMI,
- AV_CODEC_ID_REALTEXT,
- AV_CODEC_ID_STL,
- AV_CODEC_ID_SUBVIEWER1,
- AV_CODEC_ID_SUBVIEWER,
- AV_CODEC_ID_SUBRIP,
- AV_CODEC_ID_WEBVTT,
- AV_CODEC_ID_MPL2,
- AV_CODEC_ID_VPLAYER,
- AV_CODEC_ID_PJS,
- AV_CODEC_ID_ASS,
- AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
-
- /* other specific kind of codecs (generally used for attachments) */
- AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs.
- AV_CODEC_ID_TTF = 0x18000,
-
- AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
- AV_CODEC_ID_BINTEXT = 0x18800,
- AV_CODEC_ID_XBIN,
- AV_CODEC_ID_IDF,
- AV_CODEC_ID_OTF,
- AV_CODEC_ID_SMPTE_KLV,
- AV_CODEC_ID_DVD_NAV,
- AV_CODEC_ID_TIMED_ID3,
- AV_CODEC_ID_BIN_DATA,
-
-
- AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
-
- AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
- * stream (only used by libavformat) */
- AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
- * stream (only used by libavformat) */
- AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
- AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
-};
-
-/**
- * This struct describes the properties of a single codec described by an
- * AVCodecID.
- * @see avcodec_descriptor_get()
- */
-typedef struct AVCodecDescriptor {
- enum AVCodecID id;
- enum AVMediaType type;
- /**
- * Name of the codec described by this descriptor. It is non-empty and
- * unique for each codec descriptor. It should contain alphanumeric
- * characters and '_' only.
- */
- const char *name;
- /**
- * A more descriptive name for this codec. May be NULL.
- */
- const char *long_name;
- /**
- * Codec properties, a combination of AV_CODEC_PROP_* flags.
- */
- int props;
- /**
- * MIME type(s) associated with the codec.
- * May be NULL; if not, a NULL-terminated array of MIME types.
- * The first item is always non-NULL and is the preferred MIME type.
- */
- const char *const *mime_types;
- /**
- * If non-NULL, an array of profiles recognized for this codec.
- * Terminated with FF_PROFILE_UNKNOWN.
- */
- const struct AVProfile *profiles;
-} AVCodecDescriptor;
-
-/**
- * Codec uses only intra compression.
- * Video and audio codecs only.
- */
-#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
-/**
- * Codec supports lossy compression. Audio and video codecs only.
- * @note a codec may support both lossy and lossless
- * compression modes
- */
-#define AV_CODEC_PROP_LOSSY (1 << 1)
-/**
- * Codec supports lossless compression. Audio and video codecs only.
- */
-#define AV_CODEC_PROP_LOSSLESS (1 << 2)
-/**
- * Codec supports frame reordering. That is, the coded order (the order in which
- * the encoded packets are output by the encoders / stored / input to the
- * decoders) may be different from the presentation order of the corresponding
- * frames.
- *
- * For codecs that do not have this property set, PTS and DTS should always be
- * equal.
- */
-#define AV_CODEC_PROP_REORDER (1 << 3)
-/**
- * Subtitle codec is bitmap based
- * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
- */
-#define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
-/**
- * Subtitle codec is text based.
- * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
- */
-#define AV_CODEC_PROP_TEXT_SUB (1 << 17)
-
-/**
- * @ingroup lavc_decoding
- * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
- * This is mainly needed because some optimized bitstream readers read
- * 32 or 64 bit at once and could read over the end. 
- * Note: If the first 23 bits of the additional bytes are not 0, then damaged
- * MPEG bitstreams could cause overread and segfault.
- */
-#define AV_INPUT_BUFFER_PADDING_SIZE 64
-
 /**
 * @ingroup lavc_encoding
 * minimum encoding buffer size
@@ -780,34 +185,6 @@
 #define AV_INPUT_BUFFER_MIN_SIZE 16384
 
 /**
- * @ingroup lavc_decoding
- */
-enum AVDiscard{
- /* We leave some space between them for extensions (drop some
- * keyframes for intra-only or drop just some bidir frames). */
- AVDISCARD_NONE =-16, ///< discard nothing
- AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi
- AVDISCARD_NONREF = 8, ///< discard all non reference
- AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames
- AVDISCARD_NONINTRA= 24, ///< discard all non intra frames
- AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
- AVDISCARD_ALL = 48, ///< discard all
-};
-
-enum AVAudioServiceType {
- AV_AUDIO_SERVICE_TYPE_MAIN = 0,
- AV_AUDIO_SERVICE_TYPE_EFFECTS = 1,
- AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
- AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3,
- AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4,
- AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5,
- AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6,
- AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7,
- AV_AUDIO_SERVICE_TYPE_KARAOKE = 8,
- AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI
-};
-
-/**
 * @ingroup lavc_encoding
 */
 typedef struct RcOverride{
@@ -844,6 +221,11 @@
 */
 #define AV_CODEC_FLAG_QPEL (1 << 4)
 /**
+ * Don't output frames whose parameters differ from first
+ * decoded frame in stream.
+ */
+#define AV_CODEC_FLAG_DROPCHANGED (1 << 5)
+/**
 * Use internal 2pass ratecontrol in first pass mode.
 */
 #define AV_CODEC_FLAG_PASS1 (1 << 9)
@@ -863,11 +245,15 @@
 * error? variables will be set during encoding.
 */
 #define AV_CODEC_FLAG_PSNR (1 << 15)
+#if FF_API_FLAG_TRUNCATED
 /**
 * Input bitstream might be truncated at a random location
 * instead of only at frame boundaries.
+ *
+ * @deprecated use codec parsers for packetizing input
 */
 #define AV_CODEC_FLAG_TRUNCATED (1 << 16)
+#endif
 /**
 * Use interlaced DCT.
 */
@@ -947,187 +333,27 @@
 /* /Fx */
 /* codec capabilities */
 
+/* Exported side data.
+ These flags can be passed in AVCodecContext.export_side_data before initialization.
+*/
 /**
- * Decoder can use draw_horiz_band callback.
- */
-#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
-/**
- * Codec uses get_buffer() for allocating buffers and supports custom allocators.
- * If not set, it might not use get_buffer() at all or use operations that
- * assume the buffer was allocated by avcodec_default_get_buffer.
- */
-#define AV_CODEC_CAP_DR1 (1 << 1)
-#define AV_CODEC_CAP_TRUNCATED (1 << 3)
-/**
- * Encoder or decoder requires flushing with NULL input at the end in order to
- * give the complete and correct output.
- *
- * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
- * with NULL data. The user can still send NULL data to the public encode
- * or decode function, but libavcodec will not pass it along to the codec
- * unless this flag is set.
- *
- * Decoders:
- * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
- * avpkt->size=0 at the end to get the delayed data until the decoder no longer
- * returns frames.
- *
- * Encoders:
- * The encoder needs to be fed with NULL data at the end of encoding until the
- * encoder no longer returns data.
- *
- * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
- * flag also means that the encoder must set the pts and duration for
- * each output packet. If this flag is not set, the pts and duration will
- * be determined by libavcodec from the input frame.
- */
-#define AV_CODEC_CAP_DELAY (1 << 5)
-/**
- * Codec can be fed a final frame with a smaller size.
- * This can be used to prevent truncation of the last audio samples.
- */
-#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
-
-/**
- * Codec can output multiple frames per AVPacket
- * Normally demuxers return one frame at a time, demuxers which do not do
- * are connected to a parser to split what they return into proper frames.
- * This flag is reserved to the very rare category of codecs which have a
- * bitstream that cannot be split into frames without timeconsuming
- * operations like full decoding. Demuxers carrying such bitstreams thus
- * may return multiple frames in a packet. This has many disadvantages like
- * prohibiting stream copy in many cases thus it should only be considered
- * as a last resort.
- */
-#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
-/**
- * Codec is experimental and is thus avoided in favor of non experimental
- * encoders
- */
-#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
-/**
- * Codec should fill in channel configuration and samplerate instead of container
- */
-#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
-/**
- * Codec supports frame-level multithreading.
- */
-#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
-/**
- * Codec supports slice-based (or partition-based) multithreading.
- */
-#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
-/**
- * Codec supports changed parameters at any point.
- */
-#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
-/**
- * Codec supports avctx->thread_count == 0 (auto).
- */
-#define AV_CODEC_CAP_AUTO_THREADS (1 << 15)
-/**
- * Audio encoder supports receiving a different number of samples in each call.
- */
-#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
-/**
- * Decoder is not a preferred choice for probing.
- * This indicates that the decoder is not a good choice for probing.
- * It could for example be an expensive to spin up hardware decoder,
- * or it could simply not provide a lot of useful information about
- * the stream.
- * A decoder marked with this flag should only be used as last resort
- * choice for probing.
- */
-#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
-/**
- * Codec is intra only.
- */
-#define AV_CODEC_CAP_INTRA_ONLY 0x40000000
-/**
- * Codec is lossless.
- */
-#define AV_CODEC_CAP_LOSSLESS 0x80000000
-
-/**
- * Codec is backed by a hardware implementation. Typically used to
- * identify a non-hwaccel hardware decoder. For information about hwaccels, use
- * avcodec_get_hw_config() instead.
+ * Export motion vectors through frame side data
 */
-#define AV_CODEC_CAP_HARDWARE (1 << 18)
-
+#define AV_CODEC_EXPORT_DATA_MVS (1 << 0)
 /**
- * Codec is potentially backed by a hardware implementation, but not
- * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
- * implementation provides some sort of internal fallback.
+ * Export encoder Producer Reference Time through packet side data
 */
-#define AV_CODEC_CAP_HYBRID (1 << 19)
-
+#define AV_CODEC_EXPORT_DATA_PRFT (1 << 1)
 /**
- * Pan Scan area.
- * This specifies the area which should be displayed.
- * Note there may be multiple such areas for one frame.
+ * Decoding only.
+ * Export the AVVideoEncParams structure through frame side data.
 */
-typedef struct AVPanScan {
- /**
- * id
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int id;
-
- /**
- * width and height in 1/16 pel
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int width;
- int height;
-
- /**
- * position of the top left corner in 1/16 pel for up to 3 fields/frames
- * - encoding: Set by user.
- * - decoding: Set by libavcodec.
- */
- int16_t position32;
-} AVPanScan;
-
+#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS (1 << 2)
 /**
- * This structure describes the bitrate properties of an encoded bitstream. It
- * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD
- * parameters for H.264/HEVC.
+ * Decoding only.
+ * Do not apply film grain, export it instead.
 */
-typedef struct AVCPBProperties {
- /**
- * Maximum bitrate of the stream, in bits per second.
- * Zero if unknown or unspecified.
- */
- int max_bitrate;
- /**
- * Minimum bitrate of the stream, in bits per second.
- * Zero if unknown or unspecified.
- */
- int min_bitrate;
- /**
- * Average bitrate of the stream, in bits per second.
- * Zero if unknown or unspecified.
- */
- int avg_bitrate;
-
- /**
- * The size of the buffer to which the ratecontrol is applied, in bits.
- * Zero if unknown or unspecified.
- */
- int buffer_size;
-
- /**
- * The delay between the time the packet this structure is associated with
- * is received and the time when it should be decoded, in periods of a 27MHz
- * clock.
- *
- * UINT64_MAX when unknown or unspecified.
- */
- uint64_t vbv_delay;
-} AVCPBProperties;
+#define AV_CODEC_EXPORT_DATA_FILM_GRAIN (1 << 3)
 
 /**
 * The decoder will keep a reference to the frame and may reuse it later.
@@ -1135,373 +361,12 @@
 #define AV_GET_BUFFER_FLAG_REF (1 << 0)
 
 /**
- * @defgroup lavc_packet AVPacket
- *
- * Types and functions for working with AVPacket.
- * @{
- */
-enum AVPacketSideDataType {
- /**
- * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
- * bytes worth of palette. This side data signals that a new palette is
- * present.
- */
- AV_PKT_DATA_PALETTE,
-
- /**
- * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
- * that the extradata buffer was changed and the receiving side should
- * act upon it appropriately. The new extradata is embedded in the side
- * data buffer and should be immediately used for processing the current
- * frame or packet.
- */
- AV_PKT_DATA_NEW_EXTRADATA,
-
- /**
- * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
- * @code
- * u32le param_flags
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
- * s32le channel_count
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
- * u64le channel_layout
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
- * s32le sample_rate
- * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
- * s32le width
- * s32le height
- * @endcode
- */
- AV_PKT_DATA_PARAM_CHANGE,
-
- /**
- * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
- * structures with info about macroblocks relevant to splitting the
- * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
- * That is, it does not necessarily contain info about all macroblocks,
- * as long as the distance between macroblocks in the info is smaller
- * than the target payload size.
- * Each MB info structure is 12 bytes, and is laid out as follows:
- * @code
- * u32le bit offset from the start of the packet
- * u8 current quantizer at the start of the macroblock
- * u8 GOB number
- * u16le macroblock address within the GOB
- * u8 horizontal MV predictor
- * u8 vertical MV predictor
- * u8 horizontal MV predictor for block number 3
- * u8 vertical MV predictor for block number 3
- * @endcode
- */
- AV_PKT_DATA_H263_MB_INFO,
-
- /**
- * This side data should be associated with an audio stream and contains
- * ReplayGain information in form of the AVReplayGain struct.
- */
- AV_PKT_DATA_REPLAYGAIN,
-
- /**
- * This side data contains a 3x3 transformation matrix describing an affine
- * transformation that needs to be applied to the decoded video frames for
- * correct presentation.
- *
- * See libavutil/display.h for a detailed description of the data.
- */
- AV_PKT_DATA_DISPLAYMATRIX,
-
- /**
- * This side data should be associated with a video stream and contains
- * Stereoscopic 3D information in form of the AVStereo3D struct.
- */
- AV_PKT_DATA_STEREO3D,
-
- /**
- * This side data should be associated with an audio stream and corresponds
- * to enum AVAudioServiceType.
- */
- AV_PKT_DATA_AUDIO_SERVICE_TYPE,
-
- /**
- * This side data contains quality related information from the encoder.
- * @code
- * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
- * u8 picture type
- * u8 error count
- * u16 reserved
- * u64leerror count sum of squared differences between encoder in and output
- * @endcode
- */
- AV_PKT_DATA_QUALITY_STATS,
-
- /**
- * This side data contains an integer value representing the stream index
- * of a "fallback" track. A fallback track indicates an alternate
- * track to use when the current track can not be decoded for some reason.
- * e.g. no decoder available for codec.
- */
- AV_PKT_DATA_FALLBACK_TRACK,
-
- /**
- * This side data corresponds to the AVCPBProperties struct.
- */
- AV_PKT_DATA_CPB_PROPERTIES,
-
- /**
- * Recommmends skipping the specified number of samples
- * @code
- * u32le number of samples to skip from start of this packet
- * u32le number of samples to skip from end of this packet
- * u8 reason for start skip
- * u8 reason for end skip (0=padding silence, 1=convergence)
- * @endcode
- */
- AV_PKT_DATA_SKIP_SAMPLES,
-
- /**
- * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
- * the packet may contain "dual mono" audio specific to Japanese DTV
- * and if it is true, recommends only the selected channel to be used.
- * @code
- * u8 selected channels (0=mail/left, 1=sub/right, 2=both)
- * @endcode
- */
- AV_PKT_DATA_JP_DUALMONO,
-
- /**
- * A list of zero terminated key/value strings. There is no end marker for
- * the list, so it is required to rely on the side data size to stop.
- */
- AV_PKT_DATA_STRINGS_METADATA,
-
- /**
- * Subtitle event position
- * @code
- * u32le x1
- * u32le y1
- * u32le x2
- * u32le y2
- * @endcode
- */
- AV_PKT_DATA_SUBTITLE_POSITION,
-
- /**
- * Data found in BlockAdditional element of matroska container. There is
- * no end marker for the data, so it is required to rely on the side data
- * size to recognize the end. 8 byte id (as found in BlockAddId) followed
- * by data.
- */
- AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
-
- /**
- * The optional first identifier line of a WebVTT cue.
- */
- AV_PKT_DATA_WEBVTT_IDENTIFIER,
-
- /**
- * The optional settings (rendering instructions) that immediately
- * follow the timestamp specifier of a WebVTT cue.
- */
- AV_PKT_DATA_WEBVTT_SETTINGS,
-
- /**
- * A list of zero terminated key/value strings. There is no end marker for
- * the list, so it is required to rely on the side data size to stop. This
- * side data includes updated metadata which appeared in the stream.
- */
- AV_PKT_DATA_METADATA_UPDATE,
-
- /**
- * MPEGTS stream ID, this is required to pass the stream ID
- * information from the demuxer to the corresponding muxer.
- */
- AV_PKT_DATA_MPEGTS_STREAM_ID,
-
- /**
- * Mastering display metadata (based on SMPTE-2086:2014). This metadata
- * should be associated with a video stream and contains data in the form
- * of the AVMasteringDisplayMetadata struct.
- */
- AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
-
- /**
- * This side data should be associated with a video stream and corresponds
- * to the AVSphericalMapping structure.
- */
- AV_PKT_DATA_SPHERICAL,
-
- /**
- * Content light level (based on CTA-861.3). This metadata should be
- * associated with a video stream and contains data in the form of the
- * AVContentLightMetadata struct.
- */
- AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
-
- /**
- * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
- * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
- * The number of bytes of CC data is AVPacketSideData.size.
- */
- AV_PKT_DATA_A53_CC,
-
- /**
- * This side data is encryption initialization data.
- * The format is not part of ABI, use av_encryption_init_info_* methods to
- * access.
- */
- AV_PKT_DATA_ENCRYPTION_INIT_INFO,
-
- /**
- * This side data contains encryption info for how to decrypt the packet.
- * The format is not part of ABI, use av_encryption_info_* methods to access.
- */
- AV_PKT_DATA_ENCRYPTION_INFO,
-
- /**
- * The number of side data types.
- * This is not part of the public API/ABI in the sense that it may
- * change when new side data types are added.
- * This must stay the last enum value.
- * If its value becomes huge, some code using it
- * needs to be updated as it assumes it to be smaller than other limits.
- */
- AV_PKT_DATA_NB
-};
-
-#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
-
-typedef struct AVPacketSideData {
- uint8_t *data;
- int size;
- enum AVPacketSideDataType type;
-} AVPacketSideData;
-
-/**
- * This structure stores compressed data. It is typically exported by demuxers
- * and then passed as input to decoders, or received as output from encoders and
- * then passed to muxers.
- *
- * For video, it should typically contain one compressed frame. For audio it may
- * contain several compressed frames. Encoders are allowed to output empty
- * packets, with no compressed data, containing only side data
- * (e.g. to update some stream parameters at the end of encoding).
- *
- * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
- * ABI. Thus it may be allocated on stack and no new fields can be added to it
- * without libavcodec and libavformat major bump.
- *
- * The semantics of data ownership depends on the buf field.
- * If it is set, the packet data is dynamically allocated and is
- * valid indefinitely until a call to av_packet_unref() reduces the
- * reference count to 0.
- *
- * If the buf field is not set av_packet_ref() would make a copy instead
- * of increasing the reference count.
- *
- * The side data is always allocated with av_malloc(), copied by
- * av_packet_ref() and freed by av_packet_unref().
- *
- * @see av_packet_ref
- * @see av_packet_unref
- */
-typedef struct AVPacket {
- /**
- * A reference to the reference-counted buffer where the packet data is
- * stored.
- * May be NULL, then the packet data is not reference-counted.
- */
- AVBufferRef *buf;
- /**
- * Presentation timestamp in AVStream->time_base units; the time at which
- * the decompressed packet will be presented to the user.
- * Can be AV_NOPTS_VALUE if it is not stored in the file.
- * pts MUST be larger or equal to dts as presentation cannot happen before
- * decompression, unless one wants to view hex dumps. Some formats misuse
- * the terms dts and pts/cts to mean something different. Such timestamps
- * must be converted to true pts/dts before they are stored in AVPacket.
- */
- int64_t pts;
- /**
- * Decompression timestamp in AVStream->time_base units; the time at which
- * the packet is decompressed.
- * Can be AV_NOPTS_VALUE if it is not stored in the file.
- */
- int64_t dts;
- uint8_t *data;
- int size;
- int stream_index;
- /**
- * A combination of AV_PKT_FLAG values
- */
- int flags;
- /**
- * Additional packet data that can be provided by the container.
- * Packet can contain several types of side information.
- */
- AVPacketSideData *side_data;
- int side_data_elems;
-
- /**
- * Duration of this packet in AVStream->time_base units, 0 if unknown.
- * Equals next_pts - this_pts in presentation order.
- */
- int64_t duration;
-
- int64_t pos; ///< byte position in stream, -1 if unknown
-
-#if FF_API_CONVERGENCE_DURATION
- /**
- * @deprecated Same as the duration field, but as int64_t. This was required
- * for Matroska subtitles, whose duration values could overflow when the
- * duration field was still an int.
- */
- attribute_deprecated
- int64_t convergence_duration;
-#endif
-} AVPacket;
-#define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
-#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
-/**
- * Flag is used to discard packets which are required to maintain valid
- * decoder state but are not required for output and should be dropped
- * after decoding.
- **/
-#define AV_PKT_FLAG_DISCARD 0x0004
-/**
- * The packet comes from a trusted source.
- *
- * Otherwise-unsafe constructs such as arbitrary pointers to data
- * outside the packet may be followed.
- */
-#define AV_PKT_FLAG_TRUSTED 0x0008
-/**
- * Flag is used to indicate packets that contain frames that can
- * be discarded by the decoder. I.e. Non-reference frames.
- */
-#define AV_PKT_FLAG_DISPOSABLE 0x0010
-
-
-enum AVSideDataParamChangeFlags {
- AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
- AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
- AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
- AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
-};
-/**
- * @}
+ * The encoder will keep a reference to the packet and may reuse it later.
 */
+#define AV_GET_ENCODE_BUFFER_FLAG_REF (1 << 0)
 
 struct AVCodecInternal;
 
-enum AVFieldOrder {
- AV_FIELD_UNKNOWN,
- AV_FIELD_PROGRESSIVE,
- AV_FIELD_TT, //< Top coded_first, top displayed first
- AV_FIELD_BB, //< Bottom coded first, bottom displayed first
- AV_FIELD_TB, //< Top coded first, bottom displayed first
- AV_FIELD_BT, //< Bottom coded first, top displayed first
-};
-
 /**
 * main external API structure.
 * New fields can be added to the end with minor version bumps.
@@ -1612,6 +477,7 @@
 * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger
 * than extradata_size to avoid problems if it is read with the bitstream reader.
 * The bytewise contents of extradata must not depend on the architecture or CPU endianness.
+ * Must be allocated with the av_malloc() family of functions.
 * - encoding: Set/allocated/freed by libavcodec.
 * - decoding: Set/allocated/freed by user.
 */
@@ -1678,7 +544,7 @@
 * picture width / height.
 *
 * @note Those fields may not match the values of the last
- * AVFrame output by avcodec_decode_video2 due frame
+ * AVFrame output by avcodec_receive_frame() due frame
 * reordering.
 *
 * - encoding: MUST be set by user.
@@ -1754,17 +620,29 @@
 int y, int type, int height);
 
 /**
- * callback to negotiate the pixelFormat
- * @param fmt is the list of formats which are supported by the codec,
- * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality.
- * The first is always the native one.
- * @note The callback may be called again immediately if initialization for
- * the selected (hardware-accelerated) pixel format failed.
- * @warning Behavior is undefined if the callback returns a value not
- * in the fmt list of formats.
- * @return the chosen format
- * - encoding: unused
- * - decoding: Set by user, if not set the native format will be chosen.
+ * Callback to negotiate the pixel format. Decoding only, may be set by the
+ * caller before avcodec_open2().
+ *
+ * Called by some decoders to select the pixel format that will be used for
+ * the output frames. This is mainly used to set up hardware acceleration,
+ * then the provided format list contains the corresponding hwaccel pixel
+ * formats alongside the "software" one. The software pixel format may also
+ * be retrieved from \ref sw_pix_fmt.
+ *
+ * This callback will be called when the coded frame properties (such as
+ * resolution, pixel format, etc.) change and more than one output format is
+ * supported for those new properties. If a hardware pixel format is chosen
+ * and initialization for it fails, the callback may be called again
+ * immediately.
+ *
+ * This callback may be called from different threads if the decoder is
+ * multi-threaded, but not from more than one thread simultaneously.
+ *
+ * @param fmt list of formats which may be used in the current
+ * configuration, terminated by AV_PIX_FMT_NONE.
+ * @warning Behavior is undefined if the callback returns a value other
+ * than one of the formats in fmt or AV_PIX_FMT_NONE.
+ * @return the chosen format or AV_PIX_FMT_NONE
 */
 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
 
@@ -1785,12 +663,6 @@
 */
 float b_quant_factor;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int b_frame_strategy;
-#endif
-
 /**
 * qscale offset between IP and B-frames
 * - encoding: Set by user.
@@ -1806,12 +678,6 @@
 */
 int has_b_frames;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int mpeg_quant;
-#endif
-
 /**
 * qscale factor between P- and I-frames
 * If > 0 then the last P-frame quantizer will be used (q = lastp_q * factor + offset).
@@ -1870,15 +736,6 @@
 */
 int slice_count;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int prediction_method;
-#define FF_PRED_LEFT 0
-#define FF_PRED_PLANE 1
-#define FF_PRED_MEDIAN 2
-#endif
-
 /**
 * slice offsets in the frame in bytes
 * - encoding: Set/allocated by libavcodec.
@@ -1951,12 +808,6 @@
 */
 int last_predictor_count;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int pre_me;
-#endif
-
 /**
 * motion estimation prepass comparison function
 * - encoding: Set by user.
@@ -2009,28 +860,22 @@
 
 /**
 * custom intra quantization matrix
- * - encoding: Set by user, can be NULL.
- * - decoding: Set by libavcodec.
+ * Must be allocated with the av_malloc() family of functions, and will be freed in
+ * avcodec_free_context().
+ * - encoding: Set/allocated by user, freed by libavcodec. Can be NULL.
+ * - decoding: Set/allocated/freed by libavcodec.
 */
 uint16_t *intra_matrix;
 
 /**
 * custom inter quantization matrix
- * - encoding: Set by user, can be NULL.
- * - decoding: Set by libavcodec.
+ * Must be allocated with the av_malloc() family of functions, and will be freed in
+ * avcodec_free_context().
+ * - encoding: Set/allocated by user, freed by libavcodec. Can be NULL.
+ * - decoding: Set/allocated/freed by libavcodec.
 */
 uint16_t *inter_matrix;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int scenechange_threshold;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int noise_reduction;
-#endif
-
 /**
 * precision of the intra DC coefficient - 8
 * - encoding: Set by user.
@@ -2066,26 +911,12 @@
 */
 int mb_lmax;
 
-#if FF_API_PRIVATE_OPT
- /**
- * @deprecated use encoder private options instead
- */
- attribute_deprecated
- int me_penalty_compensation;
-#endif
-
 /**
 * - encoding: Set by user.
 * - decoding: unused
 */
 int bidir_refine;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int brd_scale;
-#endif
-
 /**
 * minimum GOP size
 * - encoding: Set by user.
@@ -2100,12 +931,6 @@
 */
 int refs;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int chromaoffset;
-#endif
-
 /**
 * Note: Value depends upon the compare function used for fullpel ME.
 * - encoding: Set by user.
@@ -2113,12 +938,6 @@
 */
 int mv0_threshold;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int b_sensitivity;
-#endif
-
 /**
 * Chromaticity coordinates of the source primaries.
 * - encoding: Set by user
@@ -2301,9 +1120,9 @@
 *
 * Some decoders do not support linesizes changing between frames.
 *
- * If frame multithreading is used and thread_safe_callbacks is set,
- * this callback may be called from a different thread, but not from more
- * than one at once. Does not need to be reentrant.
+ * If frame multithreading is used, this callback may be called from a
+ * different thread, but not from more than one at once. Does not need to be
+ * reentrant.
 *
 * @see avcodec_align_dimensions2()
 *
@@ -2327,22 +1146,6 @@
 */
 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
 
- /**
- * If non-zero, the decoded audio and video frames returned from
- * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted
- * and are valid indefinitely. The caller must free them with
- * av_frame_unref() when they are not needed anymore.
- * Otherwise, the decoded frames must not be freed by the caller and are
- * only valid until the next decode call.
- *
- * This is always automatically enabled if avcodec_receive_frame() is used.
- *
- * - encoding: unused
- * - decoding: set by the caller before avcodec_open2().
- */
- attribute_deprecated
- int refcounted_frames;
-
 /* - encoding parameters */
 float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0)
 float qblur; ///< amount of qscale smoothing over time (0.0-1.0)
@@ -2418,42 +1221,6 @@
 */
 int rc_initial_buffer_occupancy;
 
-#if FF_API_CODER_TYPE
-#define FF_CODER_TYPE_VLC 0
-#define FF_CODER_TYPE_AC 1
-#define FF_CODER_TYPE_RAW 2
-#define FF_CODER_TYPE_RLE 3
- /**
- * @deprecated use encoder private options instead
- */
- attribute_deprecated
- int coder_type;
-#endif /* FF_API_CODER_TYPE */
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int context_model;
-#endif
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_threshold;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_factor;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_exp;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int frame_skip_cmp;
-#endif /* FF_API_PRIVATE_OPT */
-
 /**
 * trellis RD quantization
 * - encoding: Set by user.
@@ -2461,69 +1228,6 @@
 */
 int trellis;
 
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int min_prediction_order;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int max_prediction_order;
-
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int64_t timecode_frame_start;
-#endif
-
-#if FF_API_RTP_CALLBACK
- /**
- * @deprecated unused
- */
- /* The RTP callback: This function is called */
- /* every time the encoder has a packet to send. */
- /* It depends on the encoder if the data starts */
- /* with a Start Code (it should). H.263 does. */
- /* mb_nb contains the number of macroblocks */
- /* encoded in the RTP payload. */
- attribute_deprecated
- void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
-#endif
-
-#if FF_API_PRIVATE_OPT
- /** @deprecated use encoder private options instead */
- attribute_deprecated
- int rtp_payload_size; /* The size of the RTP payload: the coder will */
- /* do its best to deliver a chunk with size */
- /* below rtp_payload_size, the chunk will start */
- /* with a start code on some codecs like H.263. */
- /* This doesn't take account of any particular */
- /* headers inside the transmitted RTP payload. */
-#endif
-
-#if FF_API_STAT_BITS
- /* statistics, used for 2-pass encoding */
- attribute_deprecated
- int mv_bits;
- attribute_deprecated
- int header_bits;
- attribute_deprecated
- int i_tex_bits;
- attribute_deprecated
- int p_tex_bits;
- attribute_deprecated
- int i_count;
- attribute_deprecated
- int p_count;
- attribute_deprecated
- int skip_count;
- attribute_deprecated
- int misc_bits;
-
- /** @deprecated this field is unused */
- attribute_deprecated
- int frame_bits;
-#endif
-
 /**
 * pass1 encoding statistics output buffer
 * - encoding: Set by libavcodec.
@@ -2601,42 +1305,20 @@
 #define FF_DEBUG_BITSTREAM 4
 #define FF_DEBUG_MB_TYPE 8
 #define FF_DEBUG_QP 16
-#if FF_API_DEBUG_MV
-/**
- * @deprecated this option does nothing
- */
-#define FF_DEBUG_MV 32
-#endif
 #define FF_DEBUG_DCT_COEFF 0x00000040
 #define FF_DEBUG_SKIP 0x00000080
 #define FF_DEBUG_STARTCODE 0x00000100
 #define FF_DEBUG_ER 0x00000400
 #define FF_DEBUG_MMCO 0x00000800
 #define FF_DEBUG_BUGS 0x00001000
-#if FF_API_DEBUG_MV
-#define FF_DEBUG_VIS_QP 0x00002000
-#define FF_DEBUG_VIS_MB_TYPE 0x00004000
-#endif
 #define FF_DEBUG_BUFFERS 0x00008000
 #define FF_DEBUG_THREADS 0x00010000
 #define FF_DEBUG_GREEN_MD 0x00800000
 #define FF_DEBUG_NOMC 0x01000000
 
-#if FF_API_DEBUG_MV
- /**
- * debug
- * - encoding: Set by user.
- * - decoding: Set by user.
- */
- int debug_mv;
-#define FF_DEBUG_VIS_MV_P_FOR 0x00000001 // visualize forward predicted MVs of P-frames
-#define FF_DEBUG_VIS_MV_B_FOR 0x00000002 // visualize forward predicted MVs of B-frames
-#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 // visualize backward predicted MVs of B-frames
-#endif
-
 /**
 * Error recognition; may misdetect some more or less valid parts as errors.
- * - encoding: unused
+ * - encoding: Set by user.
 * - decoding: Set by user.
 */
 int err_recognition;
@@ -2661,7 +1343,10 @@
 /**
 * opaque 64-bit number (generally a PTS) that will be reordered and
 * output in AVFrame.reordered_opaque
- * - encoding: unused
+ * - encoding: Set by libavcodec to the reordered_opaque of the input
+ * frame corresponding to the last returned packet. Only
+ * supported by encoders with the
+ * AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE capability.
 * - decoding: Set by user.
 */
 int64_t reordered_opaque;
@@ -2678,8 +1363,7 @@
 * For some hardware accelerators, a global context needs to be
 * provided by the user. In that case, this holds display-dependent
 * data FFmpeg cannot instantiate itself. Please refer to the
- * FFmpeg HW accelerator documentation to know how to fill this
- * is. e.g. for VA API, this is a struct vaapi_context.
+ * FFmpeg HW accelerator documentation to know how to fill this.
 * - encoding: unused
 * - decoding: Set by user
 */
@@ -2740,25 +1424,12 @@
 */
 int bits_per_raw_sample;
 
-#if FF_API_LOWRES
 /**
 * low resolution decoding, 1-> 1/2 size, 2->1/4 size
 * - encoding: unused
 * - decoding: Set by user.
 */
 int lowres;
-#endif
-
-#if FF_API_CODED_FRAME
- /**
- * the picture in the bitstream
- * - encoding: Set by libavcodec.
- * - decoding: unused
- *
- * @deprecated use the quality factor packet side data instead
- */
- attribute_deprecated AVFrame *coded_frame;
-#endif
 
 /**
 * thread count
@@ -2787,6 +1458,7 @@
 */
 int active_thread_type;
 
+#if FF_API_THREAD_SAFE_CALLBACKS
 /**
 * Set by the client if its custom get_buffer() callback can be called
 * synchronously from another thread, which allows faster multithreaded decoding.
@@ -2794,8 +1466,18 @@
 * Ignored if the default get_buffer() is used.
 * - encoding: Set by user.
 * - decoding: Set by user.
+ *
+ * @deprecated the custom get_buffer2() callback should always be
+ * thread-safe. Thread-unsafe get_buffer2() implementations will be
+ * invalid starting with LIBAVCODEC_VERSION_MAJOR=60; in other words,
+ * libavcodec will behave as if this field was always set to 1.
+ * Callers that want to be forward compatible with future libavcodec
+ * versions should wrap access to this field in
+ * #if LIBAVCODEC_VERSION_MAJOR < 60
 */
+ attribute_deprecated
 int thread_safe_callbacks;
+#endif
 
 /**
 * The codec may call this to execute several independent things.
@@ -2933,6 +1615,9 @@
 #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
 #define FF_PROFILE_HEVC_REXT 4
 
+#define FF_PROFILE_VVC_MAIN_10 1
+#define FF_PROFILE_VVC_MAIN_10_444 33
+
 #define FF_PROFILE_AV1_MAIN 0
 #define FF_PROFILE_AV1_HIGH 1
 #define FF_PROFILE_AV1_PROFESSIONAL 2
@@ -2945,6 +1630,19 @@
 
 #define FF_PROFILE_SBC_MSBC 1
 
+#define FF_PROFILE_PRORES_PROXY 0
+#define FF_PROFILE_PRORES_LT 1
+#define FF_PROFILE_PRORES_STANDARD 2
+#define FF_PROFILE_PRORES_HQ 3
+#define FF_PROFILE_PRORES_4444 4
+#define FF_PROFILE_PRORES_XQ 5
+
+#define FF_PROFILE_ARIB_PROFILE_A 0
+#define FF_PROFILE_ARIB_PROFILE_C 1
+
+#define FF_PROFILE_KLVA_SYNC 0
+#define FF_PROFILE_KLVA_ASYNC 1
+
 /**
 * level
 * - encoding: Set by user.
@@ -2985,34 +1683,6 @@
 uint8_t *subtitle_header;
 int subtitle_header_size;
 
-#if FF_API_VBV_DELAY
- /**
- * VBV delay coded in the last frame (in periods of a 27 MHz clock).
- * Used for compliant TS muxing.
- * - encoding: Set by libavcodec.
- * - decoding: unused.
- * @deprecated this value is now exported as a part of
- * AV_PKT_DATA_CPB_PROPERTIES packet side data
- */
- attribute_deprecated
- uint64_t vbv_delay;
-#endif
-
-#if FF_API_SIDEDATA_ONLY_PKT
- /**
- * Encoding only and set by default. Allow encoders to output packets
- * that do not contain any encoded data, only side data.
- *
- * Some encoders need to output such packets, e.g. to update some stream
- * parameters at the end of encoding.
- *
- * @deprecated this field disables the default behaviour and
- * it is kept only for compatibility.
- */
- attribute_deprecated
- int side_data_only_packets;
-#endif
-
 /**
 * Audio only. The number of "priming" samples (padding) inserted by the
 * encoder at the beginning of the audio. I.e. this number of leading
@@ -3060,15 +1730,6 @@
 */
 const AVCodecDescriptor *codec_descriptor;
 
-#if !FF_API_LOWRES
- /**
- * low resolution decoding, 1-> 1/2 size, 2->1/4 size
- * - encoding: unused
- * - decoding: Set by user.
- */
- int lowres;
-#endif
-
 /**
 * Current statistics for PTS correction.
 * - decoding: maintained and used by libavcodec, not intended to be used by user apps
@@ -3119,12 +1780,11 @@
 */
 int seek_preroll;
 
-#if !FF_API_DEBUG_MV
+#if FF_API_DEBUG_MV
 /**
- * debug motion vectors
- * - encoding: Set by user.
- * - decoding: Set by user.
+ * @deprecated unused
 */
+ attribute_deprecated
 int debug_mv;
 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames
 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames
@@ -3162,6 +1822,7 @@
 unsigned properties;
 #define FF_CODEC_PROPERTY_LOSSLESS 0x00000001
 #define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002
+#define FF_CODEC_PROPERTY_FILM_GRAIN 0x00000004
 
 /**
 * Additional data associated with the entire coded stream.
@@ -3196,15 +1857,13 @@
 */
 AVBufferRef *hw_frames_ctx;
 
+#if FF_API_SUB_TEXT_FORMAT
 /**
- * Control the form of AVSubtitle.rectsN->ass
- * - decoding: set by user
- * - encoding: unused
+ * @deprecated unused
 */
+ attribute_deprecated
 int sub_text_format;
 #define FF_SUB_TEXT_FMT_ASS 0
-#if FF_API_ASS_TIMING
-#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS 1
 #endif
 
 /**
@@ -3297,275 +1956,79 @@
 * used as reference pictures).
 */
 int extra_hw_frames;
-} AVCodecContext;
 
-#if FF_API_CODEC_GET_SET
-/**
- * Accessors for some AVCodecContext fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-AVRational av_codec_get_pkt_timebase (const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_pkt_timebase (AVCodecContext *avctx, AVRational val);
-
-attribute_deprecated
-const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
-
-attribute_deprecated
-unsigned av_codec_get_codec_properties(const AVCodecContext *avctx);
-
-#if FF_API_LOWRES
-attribute_deprecated
-int av_codec_get_lowres(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_lowres(AVCodecContext *avctx, int val);
-#endif
-
-attribute_deprecated
-int av_codec_get_seek_preroll(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);
-
-attribute_deprecated
-uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
-attribute_deprecated
-void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);
-#endif
-
-/**
- * AVProfile.
- */
-typedef struct AVProfile {
- int profile;
- const char *name; ///< short name for the profile
-} AVProfile;
-
-enum {
- /**
- * The codec supports this format via the hw_device_ctx interface.
- *
- * When selecting this format, AVCodecContext.hw_device_ctx should
- * have been set to a device of the specified type before calling
- * avcodec_open2().
- */
- AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
 /**
- * The codec supports this format via the hw_frames_ctx interface.
+ * The percentage of damaged samples to discard a frame.
 *
- * When selecting this format for a decoder,
- * AVCodecContext.hw_frames_ctx should be set to a suitable frames
- * context inside the get_format() callback. The frames context
- * must have been created on a device of the specified type.
- */
- AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
- /**
- * The codec supports this format by some internal method.
- *
- * This format can be selected without any additional configuration -
- * no device or frames context is required.
- */
- AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
- /**
- * The codec supports this format by some ad-hoc method.
- *
- * Additional settings and/or function calls are required. See the
- * codec-specific documentation for details. (Methods requiring
- * this sort of configuration are deprecated and others should be
- * used in preference.)
+ * - decoding: set by user
+ * - encoding: unused
 */
- AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
-};
+ int discard_damaged_percentage;
 
-typedef struct AVCodecHWConfig {
- /**
- * A hardware pixel format which the codec can use.
- */
- enum AVPixelFormat pix_fmt;
- /**
- * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
- * setup methods which can be used with this configuration.
- */
- int methods;
 /**
- * The device type associated with the configuration.
+ * The number of samples per frame to maximally accept.
 *
- * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
- * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
- */
- enum AVHWDeviceType device_type;
-} AVCodecHWConfig;
-
-typedef struct AVCodecDefault AVCodecDefault;
-
-struct AVSubtitle;
-
-/**
- * AVCodec.
- */
-typedef struct AVCodec {
- /**
- * Name of the codec implementation.
- * The name is globally unique among encoders and among decoders (but an
- * encoder and a decoder can share the same name).
- * This is the primary way to find a codec from the user perspective.
- */
- const char *name;
- /**
- * Descriptive name for the codec, meant to be more human readable than name.
- * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
- */
- const char *long_name;
- enum AVMediaType type;
- enum AVCodecID id;
- /**
- * Codec capabilities.
- * see AV_CODEC_CAP_*
- */
- int capabilities;
- const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
- const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
- const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
- const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
- const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
- uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
- const AVClass *priv_class; ///< AVClass for the private context
- const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
-
- /**
- * Group name of the codec implementation.
- * This is a short symbolic name of the wrapper backing this codec. A
- * wrapper uses some kind of external implementation for the codec, such
- * as an external library, or a codec implementation provided by the OS or
- * the hardware.
- * If this field is NULL, this is a builtin, libavcodec native codec.
- * If non-NULL, this will be the suffix in AVCodec.name in most cases
- * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
+ * - decoding: set by user
+ * - encoding: set by user
 */
- const char *wrapper_name;
+ int64_t max_samples;
 
- /*****************************************************************
- * No fields below this line are part of the public API. They
- * may not be used outside of libavcodec and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
- int priv_data_size;
- struct AVCodec *next;
- /**
- * @name Frame-level threading support functions
- * @{
- */
- /**
- * If defined, called on thread contexts when they are created.
- * If the codec allocates writable tables in init(), re-allocate them here.
- * priv_data will be set to a copy of the original.
- */
- int (*init_thread_copy)(AVCodecContext *);
 /**
- * Copy necessary context variables from a previous thread context to the current one.
- * If not defined, the next thread will start automatically; otherwise, the codec
- * must call ff_thread_finish_setup().
+ * Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of
+ * metadata exported in frame, packet, or coded stream side data by
+ * decoders and encoders.
 *
- * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
- */
- int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);
- /** @} */
-
- /**
- * Private codec-specific defaults.
+ * - decoding: set by user
+ * - encoding: set by user
 */
- const AVCodecDefault *defaults;
+ int export_side_data;
 
 /**
- * Initialize codec static data, called from avcodec_register().
+ * This callback is called at the beginning of each packet to get a data
+ * buffer for it.
 *
- * This is not intended for time consuming operations as it is
- * run for every codec regardless of that codec being used.
- */
- void (*init_static_data)(struct AVCodec *codec);
-
- int (*init)(AVCodecContext *);
- int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
- const struct AVSubtitle *sub);
- /**
- * Encode data to an AVPacket.
+ * The following field will be set in the packet before this callback is
+ * called:
+ * - size
+ * This callback must use the above value to calculate the required buffer size,
+ * which must padded by at least AV_INPUT_BUFFER_PADDING_SIZE bytes.
+ *
+ * In some specific cases, the encoder may not use the entire buffer allocated by this
+ * callback. This will be reflected in the size value in the packet once returned by
+ * avcodec_receive_packet().
+ *
+ * This callback must fill the following fields in the packet:
+ * - data: alignment requirements for AVPacket apply, if any. Some architectures and
+ * encoders may benefit from having aligned data.
+ * - buf: must contain a pointer to an AVBufferRef structure. The packet's
+ * data pointer must be contained in it. See: av_buffer_create(), av_buffer_alloc(),
+ * and av_buffer_ref().
 *
- * @param avctx codec context
- * @param avpkt output AVPacket (may contain a user-provided buffer)
- * @paramin frame AVFrame containing the raw data to be encoded
- * @paramout got_packet_ptr encoder sets to 0 or 1 to indicate that a
- * non-empty packet was returned in avpkt.
- * @return 0 on success, negative error code on failure
- */
- int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
- int *got_packet_ptr);
- int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
- int (*close)(AVCodecContext *);
- /**
- * Encode API with decoupled packet/frame dataflow. The API is the
- * same as the avcodec_ prefixed APIs (avcodec_send_frame() etc.), except
- * that:
- * - never called if the codec is closed or the wrong type,
- * - if AV_CODEC_CAP_DELAY is not set, drain frames are never sent,
- * - only one drain frame is ever passed down,
- */
- int (*send_frame)(AVCodecContext *avctx, const AVFrame *frame);
- int (*receive_packet)(AVCodecContext *avctx, AVPacket *avpkt);
-
- /**
- * Decode API with decoupled packet/frame dataflow. This function is called
- * to get one output frame. It should call ff_decode_get_packet() to obtain
- * input data.
- */
- int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame);
- /**
- * Flush buffers.
- * Will be called when seeking
- */
- void (*flush)(AVCodecContext *);
- /**
- * Internal codec capabilities.
- * See FF_CODEC_CAP_* in internal.h
- */
- int caps_internal;
-
- /**
- * Decoding only, a comma-separated list of bitstream filters to apply to
- * packets before decoding.
- */
- const char *bsfs;
-
- /**
- * Array of pointers to hardware configurations supported by the codec,
- * or NULL if no hardware supported. The array is terminated by a NULL
- * pointer.
+ * If AV_CODEC_CAP_DR1 is not set then get_encode_buffer() must call
+ * avcodec_default_get_encode_buffer() instead of providing a buffer allocated by
+ * some other means.
+ *
+ * The flags field may contain a combination of AV_GET_ENCODE_BUFFER_FLAG_ flags.
+ * They may be used for example to hint what use the buffer may get after being
+ * created.
+ * Implementations of this callback may ignore flags they don't understand.
+ * If AV_GET_ENCODE_BUFFER_FLAG_REF is set in flags then the packet may be reused
+ * (read and/or written to if it is writable) later by libavcodec.
 *
- * The user can only access this field via avcodec_get_hw_config().
+ * This callback must be thread-safe, as when frame threading is used, it may
+ * be called from multiple threads simultaneously.
+ *
+ * @see avcodec_default_get_encode_buffer()
+ *
+ * - encoding: Set by libavcodec, user can override.
+ * - decoding: unused
 */
- const struct AVCodecHWConfigInternal **hw_configs;
-} AVCodec;
-
-#if FF_API_CODEC_GET_SET
-attribute_deprecated
-int av_codec_get_max_lowres(const AVCodec *codec);
-#endif
+ int (*get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags);
+} AVCodecContext;
 
 struct MpegEncContext;
 
 /**
- * Retrieve supported hardware configurations for a codec.
- *
- * Values of index from zero to some maximum return the indexed configuration
- * descriptor; all other values return NULL. If the codec does not support
- * any hardware configurations then it will always return NULL.
- */
-const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
-
-/**
 * @defgroup lavc_hwaccel AVHWAccel
 *
 * @note Nothing in this structure should be accessed by the user. At some
@@ -3775,33 +2238,6 @@
 * @}
 */
 
-#if FF_API_AVPICTURE
-/**
- * @defgroup lavc_picture AVPicture
- *
- * Functions for working with AVPicture
- * @{
- */
-
-/**
- * Picture data structure.
- *
- * Up to four components can be stored into it, the last component is
- * alpha.
- * @deprecated use AVFrame or imgutils functions instead
- */
-typedef struct AVPicture {
- attribute_deprecated
- uint8_t *dataAV_NUM_DATA_POINTERS; ///< pointers to the image data planes
- attribute_deprecated
- int linesizeAV_NUM_DATA_POINTERS; ///< number of bytes per line
-} AVPicture;
-
-/**
- * @}
- */
-#endif
-
 enum AVSubtitleType {
 SUBTITLE_NONE,
 
@@ -3829,13 +2265,6 @@
 int h; ///< height of pict, undefined when pict is not set
 int nb_colors; ///< number of colors in pict, undefined when pict is not set
 
-#if FF_API_AVPICTURE
- /**
- * @deprecated unused
- */
- attribute_deprecated
- AVPicture pict;
-#endif
 /**
 * data+linesize for the bitmap of this subtitle.
 * Can be set for text/ass as well once they are rendered.
@@ -3867,185 +2296,6 @@
 } AVSubtitle;
 
 /**
- * This struct describes the properties of an encoded stream.
- *
- * sizeof(AVCodecParameters) is not a part of the public ABI, this struct must
- * be allocated with avcodec_parameters_alloc() and freed with
- * avcodec_parameters_free().
- */
-typedef struct AVCodecParameters {
- /**
- * General type of the encoded data.
- */
- enum AVMediaType codec_type;
- /**
- * Specific type of the encoded data (the codec used).
- */
- enum AVCodecID codec_id;
- /**
- * Additional information about the codec (corresponds to the AVI FOURCC).
- */
- uint32_t codec_tag;
-
- /**
- * Extra binary data needed for initializing the decoder, codec-dependent.
- *
- * Must be allocated with av_malloc() and will be freed by
- * avcodec_parameters_free(). The allocated size of extradata must be at
- * least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
- * bytes zeroed.
- */
- uint8_t *extradata;
- /**
- * Size of the extradata content in bytes.
- */
- int extradata_size;
-
- /**
- * - video: the pixel format, the value corresponds to enum AVPixelFormat.
- * - audio: the sample format, the value corresponds to enum AVSampleFormat.
- */
- int format;
-
- /**
- * The average bitrate of the encoded data (in bits per second).
- */
- int64_t bit_rate;
-
- /**
- * The number of bits per sample in the codedwords.
- *
- * This is basically the bitrate per sample. It is mandatory for a bunch of
- * formats to actually decode them. It's the number of bits for one sample in
- * the actual coded bitstream.
- *
- * This could be for example 4 for ADPCM
- * For PCM formats this matches bits_per_raw_sample
- * Can be 0
- */
- int bits_per_coded_sample;
-
- /**
- * This is the number of valid bits in each output sample. If the
- * sample format has more bits, the least significant bits are additional
- * padding bits, which are always 0. Use right shifts to reduce the sample
- * to its actual size. For example, audio formats with 24 bit samples will
- * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
- * To get the original sample use "(int32_t)sample >> 8"."
- *
- * For ADPCM this might be 12 or 16 or similar
- * Can be 0
- */
- int bits_per_raw_sample;
-
- /**
- * Codec-specific bitstream restrictions that the stream conforms to.
- */
- int profile;
- int level;
-
- /**
- * Video only. The dimensions of the video frame in pixels.
- */
- int width;
- int height;
-
- /**
- * Video only. The aspect ratio (width / height) which a single pixel
- * should have when displayed.
- *
- * When the aspect ratio is unknown / undefined, the numerator should be
- * set to 0 (the denominator may have any value).
- */
- AVRational sample_aspect_ratio;
-
- /**
- * Video only. The order of the fields in interlaced video.
- */
- enum AVFieldOrder field_order;
-
- /**
- * Video only. Additional colorspace characteristics.
- */
- enum AVColorRange color_range;
- enum AVColorPrimaries color_primaries;
- enum AVColorTransferCharacteristic color_trc;
- enum AVColorSpace color_space;
- enum AVChromaLocation chroma_location;
-
- /**
- * Video only. Number of delayed frames.
- */
- int video_delay;
-
- /**
- * Audio only. The channel layout bitmask. May be 0 if the channel layout is
- * unknown or unspecified, otherwise the number of bits set must be equal to
- * the channels field.
- */
- uint64_t channel_layout;
- /**
- * Audio only. The number of audio channels.
- */
- int channels;
- /**
- * Audio only. The number of audio samples per second.
- */
- int sample_rate;
- /**
- * Audio only. The number of bytes per coded audio frame, required by some
- * formats.
- *
- * Corresponds to nBlockAlign in WAVEFORMATEX.
- */
- int block_align;
- /**
- * Audio only. Audio frame size, if known. Required by some formats to be static.
- */
- int frame_size;
-
- /**
- * Audio only. The amount of padding (in samples) inserted by the encoder at
- * the beginning of the audio. I.e. this number of leading decoded samples
- * must be discarded by the caller to get the original audio without leading
- * padding.
- */
- int initial_padding;
- /**
- * Audio only. The amount of padding (in samples) appended by the encoder to
- * the end of the audio. I.e. this number of decoded samples must be
- * discarded by the caller from the end of the stream to get the original
- * audio without any trailing padding.
- */
- int trailing_padding;
- /**
- * Audio only. Number of samples to skip after a discontinuity.
- */
- int seek_preroll;
-} AVCodecParameters;
-
-/**
- * Iterate over all registered codecs.
- *
- * @param opaque a pointer where libavcodec will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered codec or NULL when the iteration is
- * finished
- */
-const AVCodec *av_codec_iterate(void **opaque);
-
-#if FF_API_NEXT
-/**
- * If c is NULL, returns the first registered codec,
- * if c is non-NULL, returns the next registered codec after c,
- * or NULL if c is the last one.
- */
-attribute_deprecated
-AVCodec *av_codec_next(const AVCodec *c);
-#endif
-
-/**
 * Return the LIBAVCODEC_VERSION_INT constant.
 */
 unsigned avcodec_version(void);
@@ -4060,32 +2310,6 @@
 */
 const char *avcodec_license(void);
 
-#if FF_API_NEXT
-/**
- * Register the codec codec and initialize libavcodec.
- *
- * @warning either this function or avcodec_register_all() must be called
- * before any other libavcodec functions.
- *
- * @see avcodec_register_all()
- */
-attribute_deprecated
-void avcodec_register(AVCodec *codec);
-
-/**
- * Register all the codecs, parsers and bitstream filters which were enabled at
- * configuration time. If you do not call this function you can select exactly
- * which formats you want to support, by using the individual registration
- * functions.
- *
- * @see avcodec_register
- * @see av_register_codec_parser
- * @see av_register_bitstream_filter
- */
-attribute_deprecated
-void avcodec_register_all(void);
-#endif
-
 /**
 * Allocate an AVCodecContext and set its fields to default values. The
 * resulting struct should be freed with avcodec_free_context().
@@ -4107,15 +2331,6 @@
 */
 void avcodec_free_context(AVCodecContext **avctx);
 
-#if FF_API_GET_CONTEXT_DEFAULTS
-/**
- * @deprecated This function should not be used, as closing and opening a codec
- * context multiple time is not supported. A new codec context should be
- * allocated for each new use.
- */
-int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec);
-#endif
-
 /**
 * Get the AVClass for AVCodecContext. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
@@ -4124,14 +2339,13 @@
 */
 const AVClass *avcodec_get_class(void);
 
-#if FF_API_COPY_CONTEXT
+#if FF_API_GET_FRAME_CLASS
 /**
- * Get the AVClass for AVFrame. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
+ * @deprecated This function should not be used.
 */
+attribute_deprecated
 const AVClass *avcodec_get_frame_class(void);
+#endif
 
 /**
 * Get the AVClass for AVSubtitleRect. It can be used in combination with
@@ -4142,48 +2356,6 @@
 const AVClass *avcodec_get_subtitle_rect_class(void);
 
 /**
- * Copy the settings of the source AVCodecContext into the destination
- * AVCodecContext. The resulting destination codec context will be
- * unopened, i.e. you are required to call avcodec_open2() before you
- * can use this AVCodecContext to decode/encode video/audio data.
- *
- * @param dest target codec context, should be initialized with
- * avcodec_alloc_context3(NULL), but otherwise uninitialized
- * @param src source codec context
- * @return AVERROR() on error (e.g. memory allocation error), 0 on success
- *
- * @deprecated The semantics of this function are ill-defined and it should not
- * be used. If you need to transfer the stream parameters from one codec context
- * to another, use an intermediate AVCodecParameters instance and the
- * avcodec_parameters_from_context() / avcodec_parameters_to_context()
- * functions.
- */
-attribute_deprecated
-int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src);
-#endif
-
-/**
- * Allocate a new AVCodecParameters and set its fields to default values
- * (unknown/invalid/0). The returned struct must be freed with
- * avcodec_parameters_free().
- */
-AVCodecParameters *avcodec_parameters_alloc(void);
-
-/**
- * Free an AVCodecParameters instance and everything associated with it and
- * write NULL to the supplied pointer.
- */
-void avcodec_parameters_free(AVCodecParameters **par);
-
-/**
- * Copy the contents of src to dst. Any allocated fields in dst are freed and
- * replaced with newly allocated duplicates of the corresponding fields in src.
- *
- * @return >= 0 on success, a negative AVERROR code on failure.
- */
-int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
-
-/**
 * Fill the parameters struct based on the values from the supplied codec
 * context. Any allocated fields in par are freed and replaced with duplicates
 * of the corresponding fields in codec.
@@ -4218,7 +2390,6 @@
 * @ref avcodec_receive_frame()).
 *
 * @code
- * avcodec_register_all();
 * av_dict_set(&opts, "b", "2.5M", 0);
 * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
 * if (!codec)
@@ -4271,337 +2442,11 @@
 */
 
 /**
- * @addtogroup lavc_packet
- * @{
- */
-
-/**
- * Allocate an AVPacket and set its fields to default values. The resulting
- * struct must be freed using av_packet_free().
- *
- * @return An AVPacket filled with default values or NULL on failure.
- *
- * @note this only allocates the AVPacket itself, not the data buffers. Those
- * must be allocated through other means such as av_new_packet.
- *
- * @see av_new_packet
- */
-AVPacket *av_packet_alloc(void);
-
-/**
- * Create a new packet that references the same data as src.
- *
- * This is a shortcut for av_packet_alloc()+av_packet_ref().
- *
- * @return newly created AVPacket on success, NULL on error.
- *
- * @see av_packet_alloc
- * @see av_packet_ref
- */
-AVPacket *av_packet_clone(const AVPacket *src);
-
-/**
- * Free the packet, if the packet is reference counted, it will be
- * unreferenced first.
- *
- * @param pkt packet to be freed. The pointer will be set to NULL.
- * @note passing NULL is a no-op.
- */
-void av_packet_free(AVPacket **pkt);
-
-/**
- * Initialize optional fields of a packet with default values.
- *
- * Note, this does not touch the data and size members, which have to be
- * initialized separately.
- *
- * @param pkt packet
- */
-void av_init_packet(AVPacket *pkt);
-
-/**
- * Allocate the payload of a packet and initialize its fields with
- * default values.
- *
- * @param pkt packet
- * @param size wanted payload size
- * @return 0 if OK, AVERROR_xxx otherwise
- */
-int av_new_packet(AVPacket *pkt, int size);
-
-/**
- * Reduce packet size, correctly zeroing padding
- *
- * @param pkt packet
- * @param size new size
- */
-void av_shrink_packet(AVPacket *pkt, int size);
-
-/**
- * Increase packet size, correctly zeroing padding
- *
- * @param pkt packet
- * @param grow_by number of bytes by which to increase the size of the packet
- */
-int av_grow_packet(AVPacket *pkt, int grow_by);
-
-/**
- * Initialize a reference-counted packet from av_malloc()ed data.
- *
- * @param pkt packet to be initialized. This function will set the data, size,
- * buf and destruct fields, all others are left untouched.
- * @param data Data allocated by av_malloc() to be used as packet data. If this
- * function returns successfully, the data is owned by the underlying AVBuffer.
- * The caller may not access the data through other means.
- * @param size size of data in bytes, without the padding. I.e. the full buffer
- * size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
- *
- * @return 0 on success, a negative AVERROR on error
- */
-int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
-
-#if FF_API_AVPACKET_OLD_API
-/**
- * @warning This is a hack - the packet memory allocation stuff is broken. The
- * packet is allocated if it was not really allocated.
- *
- * @deprecated Use av_packet_ref or av_packet_make_refcounted
- */
-attribute_deprecated
-int av_dup_packet(AVPacket *pkt);
-/**
- * Copy packet, including contents
- *
- * @return 0 on success, negative AVERROR on fail
- *
- * @deprecated Use av_packet_ref
- */
-attribute_deprecated
-int av_copy_packet(AVPacket *dst, const AVPacket *src);
-
-/**
- * Copy packet side data
- *
- * @return 0 on success, negative AVERROR on fail
- *
- * @deprecated Use av_packet_copy_props
- */
-attribute_deprecated
-int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
-
-/**
- * Free a packet.
- *
- * @deprecated Use av_packet_unref
- *
- * @param pkt packet to free
- */
-attribute_deprecated
-void av_free_packet(AVPacket *pkt);
-#endif
-/**
- * Allocate new information of a packet.
- *
- * @param pkt packet
- * @param type side information type
- * @param size side information size
- * @return pointer to fresh allocated data or NULL otherwise
- */
-uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
- int size);
-
-/**
- * Wrap an existing array as a packet side data.
- *
- * @param pkt packet
- * @param type side information type
- * @param data the side data array. It must be allocated with the av_malloc()
- * family of functions. The ownership of the data is transferred to
- * pkt.
- * @param size side information size
- * @return a non-negative number on success, a negative AVERROR code on
- * failure. On failure, the packet is unchanged and the data remains
- * owned by the caller.
- */
-int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
- uint8_t *data, size_t size);
-
-/**
- * Shrink the already allocated side data buffer
- *
- * @param pkt packet
- * @param type side information type
- * @param size new side information size
- * @return 0 on success, < 0 on failure
- */
-int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
- int size);
-
-/**
- * Get side information from packet.
- *
- * @param pkt packet
- * @param type desired side information type
- * @param size pointer for side information size to store (optional)
- * @return pointer to data if present or NULL otherwise
- */
-uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
- int *size);
-
-#if FF_API_MERGE_SD_API
-attribute_deprecated
-int av_packet_merge_side_data(AVPacket *pkt);
-
-attribute_deprecated
-int av_packet_split_side_data(AVPacket *pkt);
-#endif
-
-const char *av_packet_side_data_name(enum AVPacketSideDataType type);
-
-/**
- * Pack a dictionary for use in side_data.
- *
- * @param dict The dictionary to pack.
- * @param size pointer to store the size of the returned data
- * @return pointer to data if successful, NULL otherwise
- */
-uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
-/**
- * Unpack a dictionary from side_data.
- *
- * @param data data from side_data
- * @param size size of the data
- * @param dict the metadata storage dictionary
- * @return 0 on success, < 0 on failure
- */
-int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
-
-
-/**
- * Convenience function to free all the side data stored.
- * All the other fields stay untouched.
- *
- * @param pkt packet
- */
-void av_packet_free_side_data(AVPacket *pkt);
-
-/**
- * Setup a new reference to the data described by a given packet
- *
- * If src is reference-counted, setup dst as a new reference to the
- * buffer in src. Otherwise allocate a new buffer in dst and copy the
- * data from src into it.
- *
- * All the other fields are copied from src.
- *
- * @see av_packet_unref
- *
- * @param dst Destination packet
- * @param src Source packet
- *
- * @return 0 on success, a negative AVERROR on error.
- */
-int av_packet_ref(AVPacket *dst, const AVPacket *src);
-
-/**
- * Wipe the packet.
- *
- * Unreference the buffer referenced by the packet and reset the
- * remaining packet fields to their default values.
- *
- * @param pkt The packet to be unreferenced.
- */
-void av_packet_unref(AVPacket *pkt);
-
-/**
- * Move every field in src to dst and reset src.
- *
- * @see av_packet_unref
- *
- * @param src Source packet, will be reset
- * @param dst Destination packet
- */
-void av_packet_move_ref(AVPacket *dst, AVPacket *src);
-
-/**
- * Copy only "properties" fields from src to dst.
- *
- * Properties for the purpose of this function are all the fields
- * beside those related to the packet data (buf, data, size)
- *
- * @param dst Destination packet
- * @param src Source packet
- *
- * @return 0 on success AVERROR on failure.
- */
-int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
-
-/**
- * Ensure the data described by a given packet is reference counted.
- *
- * @note This function does not ensure that the reference will be writable.
- * Use av_packet_make_writable instead for that purpose.
- *
- * @see av_packet_ref
- * @see av_packet_make_writable
- *
- * @param pkt packet whose data should be made reference counted.
- *
- * @return 0 on success, a negative AVERROR on error. On failure, the
- * packet is unchanged.
- */
-int av_packet_make_refcounted(AVPacket *pkt);
-
-/**
- * Create a writable reference for the data described by a given packet,
- * avoiding data copy if possible.
- *
- * @param pkt Packet whose data should be made writable.
- *
- * @return 0 on success, a negative AVERROR on failure. On failure, the
- * packet is unchanged.
- */
-int av_packet_make_writable(AVPacket *pkt);
-
-/**
- * Convert valid timing fields (timestamps / durations) in a packet from one
- * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
- * ignored.
- *
- * @param pkt packet on which the conversion will be performed
- * @param tb_src source timebase, in which the timing fields in pkt are
- * expressed
- * @param tb_dst destination timebase, to which the timing fields will be
- * converted
- */
-void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
-
-/**
- * @}
- */
-
-/**
 * @addtogroup lavc_decoding
 * @{
 */
 
 /**
- * Find a registered decoder with a matching codec ID.
- *
- * @param id AVCodecID of the requested decoder
- * @return A decoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_decoder(enum AVCodecID id);
-
-/**
- * Find a registered decoder with the specified name.
- *
- * @param name name of the requested decoder
- * @return A decoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_decoder_by_name(const char *name);
-
-/**
 * The default callback for AVCodecContext.get_buffer2(). It is made public so
 * it can be called by custom get_buffer2() implementations for decoders without
 * AV_CODEC_CAP_DR1 set.
@@ -4609,6 +2454,13 @@
 int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags);
 
 /**
+ * The default callback for AVCodecContext.get_encode_buffer(). It is made public so
+ * it can be called by custom get_encode_buffer() implementations for encoders without
+ * AV_CODEC_CAP_DR1 set.
+ */
+int avcodec_default_get_encode_buffer(AVCodecContext *s, AVPacket *pkt, int flags);
+
+/**
 * Modify width and height values so that they will result in a memory
 * buffer that is acceptable for the codec if you do not use any horizontal
 * padding.
@@ -4650,119 +2502,12 @@
 enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
 
 /**
- * Decode the audio frame of size avpkt->size from avpkt->data into frame.
- *
- * Some decoders may support multiple frames in a single AVPacket. Such
- * decoders would then just decode the first frame and the return value would be
- * less than the packet size. In this case, avcodec_decode_audio4 has to be
- * called again with an AVPacket containing the remaining data in order to
- * decode the second frame, etc... Even if no frames are returned, the packet
- * needs to be fed to the decoder with remaining data until it is completely
- * consumed or an error occurs.
- *
- * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input
- * and output. This means that for some packets they will not immediately
- * produce decoded output and need to be flushed at the end of decoding to get
- * all the decoded data. Flushing is done by calling this function with packets
- * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
- * returning samples. It is safe to flush even those decoders that are not
- * marked with AV_CODEC_CAP_DELAY, then no samples will be returned.
- *
- * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE
- * larger than the actual read bytes because some optimized bitstream
- * readers read 32 or 64 bits at once and could read over the end.
- *
- * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
- * before packets may be fed to the decoder.
- *
- * @param avctx the codec context
- * @paramout frame The AVFrame in which to store decoded audio samples.
- * The decoder will allocate a buffer for the decoded frame by
- * calling the AVCodecContext.get_buffer2() callback.
- * When AVCodecContext.refcounted_frames is set to 1, the frame is
- * reference counted and the returned reference belongs to the
- * caller. The caller must release the frame using av_frame_unref()
- * when the frame is no longer needed. The caller may safely write
- * to the frame if av_frame_is_writable() returns 1.
- * When AVCodecContext.refcounted_frames is set to 0, the returned
- * reference belongs to the decoder and is valid only until the
- * next call to this function or until closing or flushing the
- * decoder. The caller may not write to it.
- * @paramout got_frame_ptr Zero if no frame could be decoded, otherwise it is
- * non-zero. Note that this field being set to zero
- * does not mean that an error has occurred. For
- * decoders with AV_CODEC_CAP_DELAY set, no given decode
- * call is guaranteed to produce a frame.
- * @paramin avpkt The input AVPacket containing the input buffer.
- * At least avpkt->data and avpkt->size should be set. Some
- * decoders might also require additional fields to be set.
- * @return A negative error code is returned if an error occurred during
- * decoding, otherwise the number of bytes consumed from the input
- * AVPacket is returned.
- *
-* @deprecated Use avcodec_send_packet() and avcodec_receive_frame().
- */
-attribute_deprecated
-int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
- int *got_frame_ptr, const AVPacket *avpkt);
-
-/**
- * Decode the video frame of size avpkt->size from avpkt->data into picture.
- * Some decoders may support multiple frames in a single AVPacket, such
- * decoders would then just decode the first frame.
- *
- * @warning The input buffer must be AV_INPUT_BUFFER_PADDING_SIZE larger than
- * the actual read bytes because some optimized bitstream readers read 32 or 64
- * bits at once and could read over the end.
- *
- * @warning The end of the input buffer buf should be set to 0 to ensure that
- * no overreading happens for damaged MPEG streams.
- *
- * @note Codecs which have the AV_CODEC_CAP_DELAY capability set have a delay
- * between input and output, these need to be fed with avpkt->data=NULL,
- * avpkt->size=0 at the end to return the remaining frames.
- *
- * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
- * before packets may be fed to the decoder.
- *
- * @param avctx the codec context
- * @paramout picture The AVFrame in which the decoded video frame will be stored.
- * Use av_frame_alloc() to get an AVFrame. The codec will
- * allocate memory for the actual bitmap by calling the
- * AVCodecContext.get_buffer2() callback.
- * When AVCodecContext.refcounted_frames is set to 1, the frame is
- * reference counted and the returned reference belongs to the
- * caller. The caller must release the frame using av_frame_unref()
- * when the frame is no longer needed. The caller may safely write
- * to the frame if av_frame_is_writable() returns 1.
- * When AVCodecContext.refcounted_frames is set to 0, the returned
- * reference belongs to the decoder and is valid only until the
- * next call to this function or until closing or flushing the
- * decoder. The caller may not write to it.
- *
- * @paramin avpkt The input AVPacket containing the input buffer.
- * You can create such packet with av_init_packet() and by then setting
- * data and size, some decoders might in addition need other fields like
- * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least
- * fields possible.
- * @paramin,out got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
- * @return On error a negative value is returned, otherwise the number of bytes
- * used or zero if no frame could be decompressed.
- *
- * @deprecated Use avcodec_send_packet() and avcodec_receive_frame().
- */
-attribute_deprecated
-int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
- int *got_picture_ptr,
- const AVPacket *avpkt);
-
-/**
 * Decode a subtitle message.
 * Return a negative value on error, otherwise return the number of bytes used.
 * If no subtitle could be decompressed, got_sub_ptr is zero.
 * Otherwise, the subtitle is stored in *sub.
 * Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for
- * simplicity, because the performance difference is expect to be negligible
+ * simplicity, because the performance difference is expected to be negligible
 * and reusing a get_buffer written for video codecs would probably perform badly
 * due to a potentially very different allocation pattern.
 *
@@ -4778,7 +2523,7 @@
 * before packets may be fed to the decoder.
 *
 * @param avctx the codec context
- * @paramout sub The Preallocated AVSubtitle in which the decoded subtitle will be stored,
+ * @paramout sub The preallocated AVSubtitle in which the decoded subtitle will be stored,
 * must be freed with avsubtitle_free if *got_sub_ptr is set.
 * @paramin,out got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
 * @paramin avpkt The input AVPacket containing the input buffer.
@@ -4799,10 +2544,6 @@
 * larger than the actual read bytes because some optimized bitstream
 * readers read 32 or 64 bits at once and could read over the end.
 *
- * @warning Do not mix this API with the legacy API (like avcodec_decode_video2())
- * on the same AVCodecContext. It will return unexpected results now
- * or in future libavcodec versions.
- *
 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
 * before packets may be fed to the decoder.
 *
@@ -4855,6 +2596,9 @@
 * AVERROR_EOF: the decoder has been fully flushed, and there will be
 * no more output frames
 * AVERROR(EINVAL): codec not opened, or it is an encoder
+ * AVERROR_INPUT_CHANGED: current decoded frame has changed parameters
+ * with respect to first decoded frame. Applicable
+ * when flag AV_CODEC_FLAG_DROPCHANGED is set.
 * other negative values: legitimate decoding errors
 */
 int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);
@@ -4889,10 +2633,9 @@
 * the call will not fail with EAGAIN).
 * AVERROR_EOF: the encoder has been flushed, and no new frames can
 * be sent to it
- * AVERROR(EINVAL): codec not opened, refcounted_frames not set, it is a
- * decoder, or requires flush
+ * AVERROR(EINVAL): codec not opened, it is a decoder, or requires flush
 * AVERROR(ENOMEM): failed to add packet to internal queue, or similar
- * other errors: legitimate decoding errors
+ * other errors: legitimate encoding errors
 */
 int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);
 
@@ -4902,14 +2645,14 @@
 * @param avctx codec context
 * @param avpkt This will be set to a reference-counted packet allocated by the
 * encoder. Note that the function will always call
- * av_frame_unref(frame) before doing anything else.
+ * av_packet_unref(avpkt) before doing anything else.
 * @return 0 on success, otherwise negative error code:
 * AVERROR(EAGAIN): output is not available in the current state - user
 * must try to send input
 * AVERROR_EOF: the encoder has been fully flushed, and there will be
 * no more output packets
- * AVERROR(EINVAL): codec not opened, or it is an encoder
- * other errors: legitimate decoding errors
+ * AVERROR(EINVAL): codec not opened, or it is a decoder
+ * other errors: legitimate encoding errors
 */
 int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt);
 
@@ -5031,7 +2774,7 @@
 
 typedef struct AVCodecParserContext {
 void *priv_data;
- struct AVCodecParser *parser;
+ const struct AVCodecParser *parser;
 int64_t frame_offset; /* offset of the current frame */
 int64_t cur_offset; /* current offset
 (incremented by each av_parser_parse()) */
@@ -5080,14 +2823,6 @@
 */
 int key_frame;
 
-#if FF_API_CONVERGENCE_DURATION
- /**
- * @deprecated unused
- */
- attribute_deprecated
- int64_t convergence_duration;
-#endif
-
 // Timestamp generation support:
 /**
 * Synchronization point for start of timestamp generation.
@@ -5197,7 +2932,7 @@
 } AVCodecParserContext;
 
 typedef struct AVCodecParser {
- int codec_ids5; /* several codec IDs are permitted */
+ int codec_ids7; /* several codec IDs are permitted */
 int priv_data_size;
 int (*parser_init)(AVCodecParserContext *s);
 /* This callback never returns an error, a negative value means that
@@ -5208,7 +2943,6 @@
 const uint8_t *buf, int buf_size);
 void (*parser_close)(AVCodecParserContext *s);
 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
- struct AVCodecParser *next;
 } AVCodecParser;
 
 /**
@@ -5222,11 +2956,6 @@
 */
 const AVCodecParser *av_parser_iterate(void **opaque);
 
-attribute_deprecated
-AVCodecParser *av_parser_next(const AVCodecParser *c);
-
-attribute_deprecated
-void av_register_codec_parser(AVCodecParser *parser);
 AVCodecParserContext *av_parser_init(int codec_id);
 
 /**
@@ -5267,14 +2996,6 @@
 int64_t pts, int64_t dts,
 int64_t pos);
 
-/**
- * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
- * @deprecated use AVBitStreamFilter
- */
-int av_parser_change(AVCodecParserContext *s,
- AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
- const uint8_t *buf, int buf_size, int keyframe);
 void av_parser_close(AVCodecParserContext *s);
 
 /**
@@ -5287,105 +3008,6 @@
 * @{
 */
 
-/**
- * Find a registered encoder with a matching codec ID.
- *
- * @param id AVCodecID of the requested encoder
- * @return An encoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_encoder(enum AVCodecID id);
-
-/**
- * Find a registered encoder with the specified name.
- *
- * @param name name of the requested encoder
- * @return An encoder if one was found, NULL otherwise.
- */
-AVCodec *avcodec_find_encoder_by_name(const char *name);
-
-/**
- * Encode a frame of audio.
- *
- * Takes input samples from frame and writes the next output packet, if
- * available, to avpkt. The output packet does not necessarily contain data for
- * the most recent frame, as encoders can delay, split, and combine input frames
- * internally as needed.
- *
- * @param avctx codec context
- * @param avpkt output AVPacket.
- * The user can supply an output buffer by setting
- * avpkt->data and avpkt->size prior to calling the
- * function, but if the size of the user-provided data is not
- * large enough, encoding will fail. If avpkt->data and
- * avpkt->size are set, avpkt->destruct must also be set. All
- * other AVPacket fields will be reset by the encoder using
- * av_init_packet(). If avpkt->data is NULL, the encoder will
- * allocate it. The encoder will set avpkt->size to the size
- * of the output packet.
- *
- * If this function fails or produces no output, avpkt will be
- * freed using av_packet_unref().
- * @paramin frame AVFrame containing the raw audio data to be encoded.
- * May be NULL when flushing an encoder that has the
- * AV_CODEC_CAP_DELAY capability set.
- * If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
- * can have any number of samples.
- * If it is not set, frame->nb_samples must be equal to
- * avctx->frame_size for all frames except the last.
- * The final frame may be smaller than avctx->frame_size.
- * @paramout got_packet_ptr This field is set to 1 by libavcodec if the
- * output packet is non-empty, and to 0 if it is
- * empty. If the function returns an error, the
- * packet can be assumed to be invalid, and the
- * value of got_packet_ptr is undefined and should
- * not be used.
- * @return 0 on success, negative error code on failure
- *
- * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead
- */
-attribute_deprecated
-int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
- const AVFrame *frame, int *got_packet_ptr);
-
-/**
- * Encode a frame of video.
- *
- * Takes input raw video data from frame and writes the next output packet, if
- * available, to avpkt. The output packet does not necessarily contain data for
- * the most recent frame, as encoders can delay and reorder input frames
- * internally as needed.
- *
- * @param avctx codec context
- * @param avpkt output AVPacket.
- * The user can supply an output buffer by setting
- * avpkt->data and avpkt->size prior to calling the
- * function, but if the size of the user-provided data is not
- * large enough, encoding will fail. All other AVPacket fields
- * will be reset by the encoder using av_init_packet(). If
- * avpkt->data is NULL, the encoder will allocate it.
- * The encoder will set avpkt->size to the size of the
- * output packet. The returned data (if any) belongs to the
- * caller, he is responsible for freeing it.
- *
- * If this function fails or produces no output, avpkt will be
- * freed using av_packet_unref().
- * @paramin frame AVFrame containing the raw video data to be encoded.
- * May be NULL when flushing an encoder that has the
- * AV_CODEC_CAP_DELAY capability set.
- * @paramout got_packet_ptr This field is set to 1 by libavcodec if the
- * output packet is non-empty, and to 0 if it is
- * empty. If the function returns an error, the
- * packet can be assumed to be invalid, and the
- * value of got_packet_ptr is undefined and should
- * not be used.
- * @return 0 on success, negative error code on failure
- *
- * @deprecated use avcodec_send_frame()/avcodec_receive_packet() instead
- */
-attribute_deprecated
-int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,
- const AVFrame *frame, int *got_packet_ptr);
-
 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 const AVSubtitle *sub);
 
@@ -5394,71 +3016,6 @@
 * @}
 */
 
-#if FF_API_AVPICTURE
-/**
- * @addtogroup lavc_picture
- * @{
- */
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-void avpicture_free(AVPicture *picture);
-
-/**
- * @deprecated use av_image_fill_arrays() instead.
- */
-attribute_deprecated
-int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
- enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated use av_image_copy_to_buffer() instead.
- */
-attribute_deprecated
-int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt,
- int width, int height,
- unsigned char *dest, int dest_size);
-
-/**
- * @deprecated use av_image_get_buffer_size() instead.
- */
-attribute_deprecated
-int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated av_image_copy() instead.
- */
-attribute_deprecated
-void av_picture_copy(AVPicture *dst, const AVPicture *src,
- enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-int av_picture_crop(AVPicture *dst, const AVPicture *src,
- enum AVPixelFormat pix_fmt, int top_band, int left_band);
-
-/**
- * @deprecated unused
- */
-attribute_deprecated
-int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt,
- int padtop, int padbottom, int padleft, int padright, int *color);
-
-/**
- * @}
- */
-#endif
-
 /**
 * @defgroup lavc_misc Utility functions
 * @ingroup libavc
@@ -5475,15 +3032,6 @@
 * @{
 */
 
-#if FF_API_GETCHROMA
-/**
- * @deprecated Use av_pix_fmt_get_chroma_sub_sample
- */
-
-attribute_deprecated
-void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
-#endif
-
 /**
 * Return a value representing the fourCC code associated to the
 * pixel format pix_fmt, or 0 if no associated fourCC code can be
@@ -5492,12 +3040,6 @@
 unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt);
 
 /**
- * @deprecated see av_get_pix_fmt_loss()
- */
-int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
- int has_alpha);
-
-/**
 * Find the best pixel format to convert to given a certain source pixel
 * format. When converting from one pixel format to another, information loss
 * may occur. For example, when converting from RGB24 to GRAY, the color
@@ -5518,62 +3060,14 @@
 enum AVPixelFormat src_pix_fmt,
 int has_alpha, int *loss_ptr);
 
-/**
- * @deprecated see av_find_best_pix_fmt_of_2()
- */
-enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
- enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
-
-attribute_deprecated
-enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
- enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
-
 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
 
 /**
 * @}
 */
 
-#if FF_API_TAG_STRING
-/**
- * Put a string representing the codec tag codec_tag in buf.
- *
- * @param buf buffer to place codec tag in
- * @param buf_size size in bytes of buf
- * @param codec_tag codec tag to assign
- * @return the length of the string that would have been generated if
- * enough space had been available, excluding the trailing null
- *
- * @deprecated see av_fourcc_make_string() and av_fourcc2str().
- */
-attribute_deprecated
-size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
-#endif
-
 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
 
-/**
- * Return a name for the specified profile, if available.
- *
- * @param codec the codec that is searched for the given profile
- * @param profile the profile value for which a name is requested
- * @return A name for the profile if found, NULL otherwise.
- */
-const char *av_get_profile_name(const AVCodec *codec, int profile);
-
-/**
- * Return a name for the specified profile, if available.
- *
- * @param codec_id the ID of the codec to which the requested profile belongs
- * @param profile the profile value for which a name is requested
- * @return A name for the profile if found, NULL otherwise.
- *
- * @note unlike av_get_profile_name(), which searches a list of profiles
- * supported by a specific decoder or encoder implementation, this
- * function searches the list of profiles from the AVCodecDescriptor
- */
-const char *avcodec_profile_name(enum AVCodecID codec_id, int profile);
-
 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
 //FIXME func typedef
@@ -5606,41 +3100,20 @@
 int buf_size, int align);
 
 /**
- * Reset the internal decoder state / flush internal buffers. Should be called
+ * Reset the internal codec state / flush internal buffers. Should be called
 * e.g. when seeking or when switching to a different stream.
 *
- * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0),
- * this invalidates the frames previously returned from the decoder. When
- * refcounted frames are used, the decoder just releases any references it might
- * keep internally, but the caller's reference remains valid.
- */
-void avcodec_flush_buffers(AVCodecContext *avctx);
-
-/**
- * Return codec bits per sample.
+ * @note for decoders, this function just releases any references the decoder
+ * might keep internally, but the caller's references remain valid.
 *
- * @paramin codec_id the codec
- * @return Number of bits per sample or zero if unknown for the given codec.
+ * @note for encoders, this function will only do something if the encoder
+ * declares support for AV_CODEC_CAP_ENCODER_FLUSH. When called, the encoder
+ * will drain any remaining packets, and can then be re-used for a different
+ * stream (as opposed to sending a null frame which will leave the encoder
+ * in a permanent EOF state after draining). This can be desirable if the
+ * cost of tearing down and replacing the encoder instance is high.
 */
-int av_get_bits_per_sample(enum AVCodecID codec_id);
-
-/**
- * Return the PCM codec associated with a sample format.
- * @param be endianness, 0 for little, 1 for big,
- * -1 (or anything else) for native
- * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
- */
-enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
-
-/**
- * Return codec bits per sample.
- * Only return non-zero if the bits per sample is exactly correct, not an
- * approximation.
- *
- * @paramin codec_id the codec
- * @return Number of bits per sample or zero if unknown for the given codec.
- */
-int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
+void avcodec_flush_buffers(AVCodecContext *avctx);
 
 /**
 * Return audio frame duration.
@@ -5652,345 +3125,6 @@
 */
 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes);
 
-/**
- * This function is the same as av_get_audio_frame_duration(), except it works
- * with AVCodecParameters instead of an AVCodecContext.
- */
-int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);
-
-#if FF_API_OLD_BSF
-typedef struct AVBitStreamFilterContext {
- void *priv_data;
- const struct AVBitStreamFilter *filter;
- AVCodecParserContext *parser;
- struct AVBitStreamFilterContext *next;
- /**
- * Internal default arguments, used if NULL is passed to av_bitstream_filter_filter().
- * Not for access by library users.
- */
- char *args;
-} AVBitStreamFilterContext;
-#endif
-
-typedef struct AVBSFInternal AVBSFInternal;
-
-/**
- * The bitstream filter state.
- *
- * This struct must be allocated with av_bsf_alloc() and freed with
- * av_bsf_free().
- *
- * The fields in the struct will only be changed (by the caller or by the
- * filter) as described in their documentation, and are to be considered
- * immutable otherwise.
- */
-typedef struct AVBSFContext {
- /**
- * A class for logging and AVOptions
- */
- const AVClass *av_class;
-
- /**
- * The bitstream filter this context is an instance of.
- */
- const struct AVBitStreamFilter *filter;
-
- /**
- * Opaque libavcodec internal data. Must not be touched by the caller in any
- * way.
- */
- AVBSFInternal *internal;
-
- /**
- * Opaque filter-specific private data. If filter->priv_class is non-NULL,
- * this is an AVOptions-enabled struct.
- */
- void *priv_data;
-
- /**
- * Parameters of the input stream. This field is allocated in
- * av_bsf_alloc(), it needs to be filled by the caller before
- * av_bsf_init().
- */
- AVCodecParameters *par_in;
-
- /**
- * Parameters of the output stream. This field is allocated in
- * av_bsf_alloc(), it is set by the filter in av_bsf_init().
- */
- AVCodecParameters *par_out;
-
- /**
- * The timebase used for the timestamps of the input packets. Set by the
- * caller before av_bsf_init().
- */
- AVRational time_base_in;
-
- /**
- * The timebase used for the timestamps of the output packets. Set by the
- * filter in av_bsf_init().
- */
- AVRational time_base_out;
-} AVBSFContext;
-
-typedef struct AVBitStreamFilter {
- const char *name;
-
- /**
- * A list of codec ids supported by the filter, terminated by
- * AV_CODEC_ID_NONE.
- * May be NULL, in that case the bitstream filter works with any codec id.
- */
- const enum AVCodecID *codec_ids;
-
- /**
- * A class for the private data, used to declare bitstream filter private
- * AVOptions. This field is NULL for bitstream filters that do not declare
- * any options.
- *
- * If this field is non-NULL, the first member of the filter private data
- * must be a pointer to AVClass, which will be set by libavcodec generic
- * code to this class.
- */
- const AVClass *priv_class;
-
- /*****************************************************************
- * No fields below this line are part of the public API. They
- * may not be used outside of libavcodec and can be changed and
- * removed at will.
- * New public fields should be added right above.
- *****************************************************************
- */
-
- int priv_data_size;
- int (*init)(AVBSFContext *ctx);
- int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
- void (*close)(AVBSFContext *ctx);
-} AVBitStreamFilter;
-
-#if FF_API_OLD_BSF
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use the new bitstream filtering API (using AVBSFContext).
- */
-attribute_deprecated
-void av_register_bitstream_filter(AVBitStreamFilter *bsf);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_get_by_name(), av_bsf_alloc(), and av_bsf_init()
- * from the new bitstream filtering API (using AVBSFContext).
- */
-attribute_deprecated
-AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_send_packet() and av_bsf_receive_packet() from the
- * new bitstream filtering API (using AVBSFContext).
- */
-attribute_deprecated
-int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
- AVCodecContext *avctx, const char *args,
- uint8_t **poutbuf, int *poutbuf_size,
- const uint8_t *buf, int buf_size, int keyframe);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_free() from the new bitstream filtering API (using
- * AVBSFContext).
- */
-attribute_deprecated
-void av_bitstream_filter_close(AVBitStreamFilterContext *bsf);
-/**
- * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
- * is deprecated. Use av_bsf_iterate() from the new bitstream filtering API (using
- * AVBSFContext).
- */
-attribute_deprecated
-const AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f);
-#endif
-
-/**
- * @return a bitstream filter with the specified name or NULL if no such
- * bitstream filter exists.
- */
-const AVBitStreamFilter *av_bsf_get_by_name(const char *name);
-
-/**
- * Iterate over all registered bitstream filters.
- *
- * @param opaque a pointer where libavcodec will store the iteration state. Must
- * point to NULL to start the iteration.
- *
- * @return the next registered bitstream filter or NULL when the iteration is
- * finished
- */
-const AVBitStreamFilter *av_bsf_iterate(void **opaque);
-#if FF_API_NEXT
-attribute_deprecated
-const AVBitStreamFilter *av_bsf_next(void **opaque);
-#endif
-
-/**
- * Allocate a context for a given bitstream filter. The caller must fill in the
- * context parameters as described in the documentation and then call
- * av_bsf_init() before sending any data to the filter.
- *
- * @param filter the filter for which to allocate an instance.
- * @param ctx a pointer into which the pointer to the newly-allocated context
- * will be written. It must be freed with av_bsf_free() after the
- * filtering is done.
- *
- * @return 0 on success, a negative AVERROR code on failure
- */
-int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
-
-/**
- * Prepare the filter for use, after all the parameters and options have been
- * set.
- */
-int av_bsf_init(AVBSFContext *ctx);
-
-/**
- * Submit a packet for filtering.
- *
- * After sending each packet, the filter must be completely drained by calling
- * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
- * AVERROR_EOF.
- *
- * @param pkt the packet to filter. The bitstream filter will take ownership of
- * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
- * This parameter may be NULL, which signals the end of the stream (i.e. no more
- * packets will be sent). That will cause the filter to output any packets it
- * may have buffered internally.
- *
- * @return 0 on success, a negative AVERROR on error.
- */
-int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
-
-/**
- * Retrieve a filtered packet.
- *
- * @paramout pkt this struct will be filled with the contents of the filtered
- * packet. It is owned by the caller and must be freed using
- * av_packet_unref() when it is no longer needed.
- * This parameter should be "clean" (i.e. freshly allocated
- * with av_packet_alloc() or unreffed with av_packet_unref())
- * when this function is called. If this function returns
- * successfully, the contents of pkt will be completely
- * overwritten by the returned data. On failure, pkt is not
- * touched.
- *
- * @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the
- * filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there
- * will be no further output from the filter. Another negative AVERROR value if
- * an error occurs.
- *
- * @note one input packet may result in several output packets, so after sending
- * a packet with av_bsf_send_packet(), this function needs to be called
- * repeatedly until it stops returning 0. It is also possible for a filter to
- * output fewer packets than were sent to it, so this function may return
- * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
- */
-int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);
-
-/**
- * Free a bitstream filter context and everything associated with it; write NULL
- * into the supplied pointer.
- */
-void av_bsf_free(AVBSFContext **ctx);
-
-/**
- * Get the AVClass for AVBSFContext. It can be used in combination with
- * AV_OPT_SEARCH_FAKE_OBJ for examining options.
- *
- * @see av_opt_find().
- */
-const AVClass *av_bsf_get_class(void);
-
-/**
- * Structure for chain/list of bitstream filters.
- * Empty list can be allocated by av_bsf_list_alloc().
- */
-typedef struct AVBSFList AVBSFList;
-
-/**
- * Allocate empty list of bitstream filters.
- * The list must be later freed by av_bsf_list_free()
- * or finalized by av_bsf_list_finalize().
- *
- * @return Pointer to @ref AVBSFList on success, NULL in case of failure
- */
-AVBSFList *av_bsf_list_alloc(void);
-
-/**
- * Free list of bitstream filters.
- *
- * @param lst Pointer to pointer returned by av_bsf_list_alloc()
- */
-void av_bsf_list_free(AVBSFList **lst);
-
-/**
- * Append bitstream filter to the list of bitstream filters.
- *
- * @param lst List to append to
- * @param bsf Filter context to be appended
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);
-
-/**
- * Construct new bitstream filter context given it's name and options
- * and append it to the list of bitstream filters.
- *
- * @param lst List to append to
- * @param bsf_name Name of the bitstream filter
- * @param options Options for the bitstream filter, can be set to NULL
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
-/**
- * Finalize list of bitstream filters.
- *
- * This function will transform @ref AVBSFList to single @ref AVBSFContext,
- * so the whole chain of bitstream filters can be treated as single filter
- * freshly allocated by av_bsf_alloc().
- * If the call is successful, @ref AVBSFList structure is freed and lst
- * will be set to NULL. In case of failure, caller is responsible for
- * freeing the structure by av_bsf_list_free()
- *
- * @param lst Filter list structure to be transformed
- * @paramout bsf Pointer to be set to newly created @ref AVBSFContext structure
- * representing the chain of bitstream filters
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);
-
-/**
- * Parse string describing list of bitstream filters and create single
- * @ref AVBSFContext describing the whole chain of bitstream filters.
- * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
- * allocated by av_bsf_alloc().
- *
- * @param str String describing chain of bitstream filters in format
- * `bsf1=opt1=val1:opt2=val2,bsf2`
- * @paramout bsf Pointer to be set to newly created @ref AVBSFContext structure
- * representing the chain of bitstream filters
- *
- * @return >=0 on success, negative AVERROR in case of failure
- */
-int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);
-
-/**
- * Get null/pass-through bitstream filter.
- *
- * @paramout bsf Pointer to be set to new instance of pass-through bitstream filter
- *
- * @return
- */
-int av_bsf_get_null_filter(AVBSFContext **bsf);
-
 /* memory */
 
 /**
@@ -6009,137 +3143,12 @@
 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size);
 
 /**
- * Encode extradata length to a buffer. Used by xiph codecs.
- *
- * @param s buffer to write to; must be at least (v/255+1) bytes long
- * @param v size of extradata in bytes
- * @return number of bytes written to the buffer.
- */
-unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
-
-#if FF_API_USER_VISIBLE_AVHWACCEL
-/**
- * Register the hardware accelerator hwaccel.
- *
- * @deprecated This function doesn't do anything.
- */
-attribute_deprecated
-void av_register_hwaccel(AVHWAccel *hwaccel);
-
-/**
- * If hwaccel is NULL, returns the first registered hardware accelerator,
- * if hwaccel is non-NULL, returns the next registered hardware accelerator
- * after hwaccel, or NULL if hwaccel is the last one.
- *
- * @deprecated AVHWaccel structures contain no user-serviceable parts, so
- * this function should not be used.
- */
-attribute_deprecated
-AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel);
-#endif
-
-#if FF_API_LOCKMGR
-/**
- * Lock operation used by lockmgr
- *
- * @deprecated Deprecated together with av_lockmgr_register().
- */
-enum AVLockOp {
- AV_LOCK_CREATE, ///< Create a mutex
- AV_LOCK_OBTAIN, ///< Lock the mutex
- AV_LOCK_RELEASE, ///< Unlock the mutex
- AV_LOCK_DESTROY, ///< Free mutex resources
-};
-
-/**
- * Register a user provided lock manager supporting the operations
- * specified by AVLockOp. The "mutex" argument to the function points
- * to a (void *) where the lockmgr should store/get a pointer to a user
- * allocated mutex. It is NULL upon AV_LOCK_CREATE and equal to the
- * value left by the last call for all other ops. If the lock manager is
- * unable to perform the op then it should leave the mutex in the same
- * state as when it was called and return a non-zero value. However,
- * when called with AV_LOCK_DESTROY the mutex will always be assumed to
- * have been successfully destroyed. If av_lockmgr_register succeeds
- * it will return a non-negative value, if it fails it will return a
- * negative value and destroy all mutex and unregister all callbacks.
- * av_lockmgr_register is not thread-safe, it must be called from a
- * single thread before any calls which make use of locking are used.
- *
- * @param cb User defined callback. av_lockmgr_register invokes calls
- * to this callback and the previously registered callback.
- * The callback will be used to create more than one mutex
- * each of which must be backed by its own underlying locking
- * mechanism (i.e. do not use a single static object to
- * implement your lock manager). If cb is set to NULL the
- * lockmgr will be unregistered.
- *
- * @deprecated This function does nothing, and always returns 0. Be sure to
- * build with thread support to get basic thread safety.
- */
-attribute_deprecated
-int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op));
-#endif
-
-/**
- * Get the type of the given codec.
- */
-enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
-
-/**
- * Get the name of a codec.
- * @return a static string identifying the codec; never NULL
- */
-const char *avcodec_get_name(enum AVCodecID id);
-
-/**
 * @return a positive value if s is open (i.e. avcodec_open2() was called on it
 * with no corresponding avcodec_close()), 0 otherwise.
 */
 int avcodec_is_open(AVCodecContext *s);
 
 /**
- * @return a non-zero number if codec is an encoder, zero otherwise
- */
-int av_codec_is_encoder(const AVCodec *codec);
-
-/**
- * @return a non-zero number if codec is a decoder, zero otherwise
- */
-int av_codec_is_decoder(const AVCodec *codec);
-
-/**
- * @return descriptor for given codec ID or NULL if no descriptor exists.
- */
-const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
-
-/**
- * Iterate over all codec descriptors known to libavcodec.
- *
- * @param prev previous descriptor. NULL to get the first descriptor.
- *
- * @return next descriptor or NULL after the last descriptor
- */
-const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
-
-/**
- * @return codec descriptor with the given name or NULL if no such descriptor
- * exists.
- */
-const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
-
-/**
- * Allocate a CPB properties structure and initialize its fields to default
- * values.
- *
- * @param size if non-NULL, the size of the allocated struct will be written
- * here. This is useful for embedding it in side data.
- *
- * @return the newly allocated struct or NULL on failure
- */
-AVCPBProperties *av_cpb_properties_alloc(size_t *size);
-
-/**
 * @}
 */

gpac-2.0.0.tar.gz/extra_lib/include/libavcodec/avdct.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/avdct.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/bsf.h Added

@@ -0,0 +1,317 @@
+/*
+ * Bitstream filters public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_BSF_H
+#define AVCODEC_BSF_H
+
+#include "libavutil/dict.h"
+#include "libavutil/log.h"
+#include "libavutil/rational.h"
+
+#include "codec_id.h"
+#include "codec_par.h"
+#include "packet.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+/**
+ * The bitstream filter state.
+ *
+ * This struct must be allocated with av_bsf_alloc() and freed with
+ * av_bsf_free().
+ *
+ * The fields in the struct will only be changed (by the caller or by the
+ * filter) as described in their documentation, and are to be considered
+ * immutable otherwise.
+ */
+typedef struct AVBSFContext {
+    /**
+     * A class for logging and AVOptions
+     */
+    const AVClass *av_class;
+
+    /**
+     * The bitstream filter this context is an instance of.
+     */
+    const struct AVBitStreamFilter *filter;
+
+    /**
+     * Opaque filter-specific private data. If filter->priv_class is non-NULL,
+     * this is an AVOptions-enabled struct.
+     */
+    void *priv_data;
+
+    /**
+     * Parameters of the input stream. This field is allocated in
+     * av_bsf_alloc(), it needs to be filled by the caller before
+     * av_bsf_init().
+     */
+    AVCodecParameters *par_in;
+
+    /**
+     * Parameters of the output stream. This field is allocated in
+     * av_bsf_alloc(), it is set by the filter in av_bsf_init().
+     */
+    AVCodecParameters *par_out;
+
+    /**
+     * The timebase used for the timestamps of the input packets. Set by the
+     * caller before av_bsf_init().
+     */
+    AVRational time_base_in;
+
+    /**
+     * The timebase used for the timestamps of the output packets. Set by the
+     * filter in av_bsf_init().
+     */
+    AVRational time_base_out;
+} AVBSFContext;
+
+typedef struct AVBitStreamFilter {
+    const char *name;
+
+    /**
+     * A list of codec ids supported by the filter, terminated by
+     * AV_CODEC_ID_NONE.
+     * May be NULL, in that case the bitstream filter works with any codec id.
+     */
+    const enum AVCodecID *codec_ids;
+
+    /**
+     * A class for the private data, used to declare bitstream filter private
+     * AVOptions. This field is NULL for bitstream filters that do not declare
+     * any options.
+     *
+     * If this field is non-NULL, the first member of the filter private data
+     * must be a pointer to AVClass, which will be set by libavcodec generic
+     * code to this class.
+     */
+    const AVClass *priv_class;
+
+    /*****************************************************************
+     * No fields below this line are part of the public API. They
+     * may not be used outside of libavcodec and can be changed and
+     * removed at will.
+     * New public fields should be added right above.
+     *****************************************************************
+     */
+
+    int priv_data_size;
+    int (*init)(AVBSFContext *ctx);
+    int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
+    void (*close)(AVBSFContext *ctx);
+    void (*flush)(AVBSFContext *ctx);
+} AVBitStreamFilter;
+
+/**
+ * @return a bitstream filter with the specified name or NULL if no such
+ *         bitstream filter exists.
+ */
+const AVBitStreamFilter *av_bsf_get_by_name(const char *name);
+
+/**
+ * Iterate over all registered bitstream filters.
+ *
+ * @param opaque a pointer where libavcodec will store the iteration state. Must
+ *               point to NULL to start the iteration.
+ *
+ * @return the next registered bitstream filter or NULL when the iteration is
+ *         finished
+ */
+const AVBitStreamFilter *av_bsf_iterate(void **opaque);
+
+/**
+ * Allocate a context for a given bitstream filter. The caller must fill in the
+ * context parameters as described in the documentation and then call
+ * av_bsf_init() before sending any data to the filter.
+ *
+ * @param filter the filter for which to allocate an instance.
+ * @param ctx a pointer into which the pointer to the newly-allocated context
+ *            will be written. It must be freed with av_bsf_free() after the
+ *            filtering is done.
+ *
+ * @return 0 on success, a negative AVERROR code on failure
+ */
+int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
+
+/**
+ * Prepare the filter for use, after all the parameters and options have been
+ * set.
+ */
+int av_bsf_init(AVBSFContext *ctx);
+
+/**
+ * Submit a packet for filtering.
+ *
+ * After sending each packet, the filter must be completely drained by calling
+ * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
+ * AVERROR_EOF.
+ *
+ * @param pkt the packet to filter. The bitstream filter will take ownership of
+ * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
+ * If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero),
+ * it signals the end of the stream (i.e. no more non-empty packets will be sent;
+ * sending more empty packets does nothing) and will cause the filter to output
+ * any packets it may have buffered internally.
+ *
+ * @return 0 on success. AVERROR(EAGAIN) if packets need to be retrieved from the
+ * filter (using av_bsf_receive_packet()) before new input can be consumed. Another
+ * negative AVERROR value if an error occurs.
+ */
+int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
+
+/**
+ * Retrieve a filtered packet.
+ *
+ * @paramout pkt this struct will be filled with the contents of the filtered
+ *                 packet. It is owned by the caller and must be freed using
+ *                 av_packet_unref() when it is no longer needed.
+ *                 This parameter should be "clean" (i.e. freshly allocated
+ *                 with av_packet_alloc() or unreffed with av_packet_unref())
+ *                 when this function is called. If this function returns
+ *                 successfully, the contents of pkt will be completely
+ *                 overwritten by the returned data. On failure, pkt is not
+ *                 touched.
+ *
+ * @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the
+ * filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there
+ * will be no further output from the filter. Another negative AVERROR value if
+ * an error occurs.
+ *
+ * @note one input packet may result in several output packets, so after sending
+ * a packet with av_bsf_send_packet(), this function needs to be called
+ * repeatedly until it stops returning 0. It is also possible for a filter to
+ * output fewer packets than were sent to it, so this function may return
+ * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
+ */
+int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);
+
+/**
+ * Reset the internal bitstream filter state. Should be called e.g. when seeking.
+ */
+void av_bsf_flush(AVBSFContext *ctx);
+
+/**
+ * Free a bitstream filter context and everything associated with it; write NULL
+ * into the supplied pointer.
+ */
+void av_bsf_free(AVBSFContext **ctx);
+
+/**
+ * Get the AVClass for AVBSFContext. It can be used in combination with
+ * AV_OPT_SEARCH_FAKE_OBJ for examining options.
+ *
+ * @see av_opt_find().
+ */
+const AVClass *av_bsf_get_class(void);
+
+/**
+ * Structure for chain/list of bitstream filters.
+ * Empty list can be allocated by av_bsf_list_alloc().
+ */
+typedef struct AVBSFList AVBSFList;
+
+/**
+ * Allocate empty list of bitstream filters.
+ * The list must be later freed by av_bsf_list_free()
+ * or finalized by av_bsf_list_finalize().
+ *
+ * @return Pointer to @ref AVBSFList on success, NULL in case of failure
+ */
+AVBSFList *av_bsf_list_alloc(void);
+
+/**
+ * Free list of bitstream filters.
+ *
+ * @param lst Pointer to pointer returned by av_bsf_list_alloc()
+ */
+void av_bsf_list_free(AVBSFList **lst);
+
+/**
+ * Append bitstream filter to the list of bitstream filters.
+ *
+ * @param lst List to append to
+ * @param bsf Filter context to be appended
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);
+
+/**
+ * Construct new bitstream filter context given it's name and options
+ * and append it to the list of bitstream filters.
+ *
+ * @param lst      List to append to
+ * @param bsf_name Name of the bitstream filter
+ * @param options  Options for the bitstream filter, can be set to NULL
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
+/**
+ * Finalize list of bitstream filters.
+ *
+ * This function will transform @ref AVBSFList to single @ref AVBSFContext,
+ * so the whole chain of bitstream filters can be treated as single filter
+ * freshly allocated by av_bsf_alloc().
+ * If the call is successful, @ref AVBSFList structure is freed and lst
+ * will be set to NULL. In case of failure, caller is responsible for
+ * freeing the structure by av_bsf_list_free()
+ *
+ * @param      lst Filter list structure to be transformed
+ * @paramout bsf Pointer to be set to newly created @ref AVBSFContext structure
+ *                 representing the chain of bitstream filters
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);
+
+/**
+ * Parse string describing list of bitstream filters and create single
+ * @ref AVBSFContext describing the whole chain of bitstream filters.
+ * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
+ * allocated by av_bsf_alloc().
+ *
+ * @param      str String describing chain of bitstream filters in format
+ *                 `bsf1=opt1=val1:opt2=val2,bsf2`
+ * @paramout bsf Pointer to be set to newly created @ref AVBSFContext structure
+ *                 representing the chain of bitstream filters
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);
+
+/**
+ * Get null/pass-through bitstream filter.
+ *
+ * @paramout bsf Pointer to be set to new instance of pass-through bitstream filter
+ *
+ * @return
+ */
+int av_bsf_get_null_filter(AVBSFContext **bsf);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_BSF_H

gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/codec.h Added

@@ -0,0 +1,497 @@
+/*
+ * AVCodec public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_H
+#define AVCODEC_CODEC_H
+
+#include <stdint.h>
+
+#include "libavutil/avutil.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/log.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/rational.h"
+#include "libavutil/samplefmt.h"
+
+#include "libavcodec/codec_id.h"
+#include "libavcodec/version.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+/**
+ * Decoder can use draw_horiz_band callback.
+ */
+#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
+/**
+ * Codec uses get_buffer() or get_encode_buffer() for allocating buffers and
+ * supports custom allocators.
+ * If not set, it might not use get_buffer() or get_encode_buffer() at all, or
+ * use operations that assume the buffer was allocated by
+ * avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
+ */
+#define AV_CODEC_CAP_DR1 (1 << 1)
+#if FF_API_FLAG_TRUNCATED
+/**
+ * @deprecated Use parsers to always send proper frames.
+ */
+#define AV_CODEC_CAP_TRUNCATED (1 << 3)
+#endif
+/**
+ * Encoder or decoder requires flushing with NULL input at the end in order to
+ * give the complete and correct output.
+ *
+ * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
+ * with NULL data. The user can still send NULL data to the public encode
+ * or decode function, but libavcodec will not pass it along to the codec
+ * unless this flag is set.
+ *
+ * Decoders:
+ * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
+ * avpkt->size=0 at the end to get the delayed data until the decoder no longer
+ * returns frames.
+ *
+ * Encoders:
+ * The encoder needs to be fed with NULL data at the end of encoding until the
+ * encoder no longer returns data.
+ *
+ * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
+ * flag also means that the encoder must set the pts and duration for
+ * each output packet. If this flag is not set, the pts and duration will
+ * be determined by libavcodec from the input frame.
+ */
+#define AV_CODEC_CAP_DELAY (1 << 5)
+/**
+ * Codec can be fed a final frame with a smaller size.
+ * This can be used to prevent truncation of the last audio samples.
+ */
+#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
+
+/**
+ * Codec can output multiple frames per AVPacket
+ * Normally demuxers return one frame at a time, demuxers which do not do
+ * are connected to a parser to split what they return into proper frames.
+ * This flag is reserved to the very rare category of codecs which have a
+ * bitstream that cannot be split into frames without timeconsuming
+ * operations like full decoding. Demuxers carrying such bitstreams thus
+ * may return multiple frames in a packet. This has many disadvantages like
+ * prohibiting stream copy in many cases thus it should only be considered
+ * as a last resort.
+ */
+#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
+/**
+ * Codec is experimental and is thus avoided in favor of non experimental
+ * encoders
+ */
+#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
+/**
+ * Codec should fill in channel configuration and samplerate instead of container
+ */
+#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
+/**
+ * Codec supports frame-level multithreading.
+ */
+#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
+/**
+ * Codec supports slice-based (or partition-based) multithreading.
+ */
+#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
+/**
+ * Codec supports changed parameters at any point.
+ */
+#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
+/**
+ * Codec supports multithreading through a method other than slice- or
+ * frame-level multithreading. Typically this marks wrappers around
+ * multithreading-capable external libraries.
+ */
+#define AV_CODEC_CAP_OTHER_THREADS (1 << 15)
+#if FF_API_AUTO_THREADS
+#define AV_CODEC_CAP_AUTO_THREADS AV_CODEC_CAP_OTHER_THREADS
+#endif
+/**
+ * Audio encoder supports receiving a different number of samples in each call.
+ */
+#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
+/**
+ * Decoder is not a preferred choice for probing.
+ * This indicates that the decoder is not a good choice for probing.
+ * It could for example be an expensive to spin up hardware decoder,
+ * or it could simply not provide a lot of useful information about
+ * the stream.
+ * A decoder marked with this flag should only be used as last resort
+ * choice for probing.
+ */
+#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
+
+#if FF_API_UNUSED_CODEC_CAPS
+/**
+ * Deprecated and unused. Use AVCodecDescriptor.props instead
+ */
+#define AV_CODEC_CAP_INTRA_ONLY 0x40000000
+/**
+ * Deprecated and unused. Use AVCodecDescriptor.props instead
+ */
+#define AV_CODEC_CAP_LOSSLESS 0x80000000
+#endif
+
+/**
+ * Codec is backed by a hardware implementation. Typically used to
+ * identify a non-hwaccel hardware decoder. For information about hwaccels, use
+ * avcodec_get_hw_config() instead.
+ */
+#define AV_CODEC_CAP_HARDWARE (1 << 18)
+
+/**
+ * Codec is potentially backed by a hardware implementation, but not
+ * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
+ * implementation provides some sort of internal fallback.
+ */
+#define AV_CODEC_CAP_HYBRID (1 << 19)
+
+/**
+ * This codec takes the reordered_opaque field from input AVFrames
+ * and returns it in the corresponding field in AVCodecContext after
+ * encoding.
+ */
+#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
+
+/**
+ * This encoder can be flushed using avcodec_flush_buffers(). If this flag is
+ * not set, the encoder must be closed and reopened to ensure that no frames
+ * remain pending.
+ */
+#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)
+
+/**
+ * AVProfile.
+ */
+typedef struct AVProfile {
+ int profile;
+ const char *name; ///< short name for the profile
+} AVProfile;
+
+typedef struct AVCodecDefault AVCodecDefault;
+
+struct AVCodecContext;
+struct AVSubtitle;
+struct AVPacket;
+
+/**
+ * AVCodec.
+ */
+typedef struct AVCodec {
+ /**
+ * Name of the codec implementation.
+ * The name is globally unique among encoders and among decoders (but an
+ * encoder and a decoder can share the same name).
+ * This is the primary way to find a codec from the user perspective.
+ */
+ const char *name;
+ /**
+ * Descriptive name for the codec, meant to be more human readable than name.
+ * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
+ */
+ const char *long_name;
+ enum AVMediaType type;
+ enum AVCodecID id;
+ /**
+ * Codec capabilities.
+ * see AV_CODEC_CAP_*
+ */
+ int capabilities;
+ uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
+ const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
+ const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
+ const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
+ const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
+ const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
+ const AVClass *priv_class; ///< AVClass for the private context
+ const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
+
+ /**
+ * Group name of the codec implementation.
+ * This is a short symbolic name of the wrapper backing this codec. A
+ * wrapper uses some kind of external implementation for the codec, such
+ * as an external library, or a codec implementation provided by the OS or
+ * the hardware.
+ * If this field is NULL, this is a builtin, libavcodec native codec.
+ * If non-NULL, this will be the suffix in AVCodec.name in most cases
+ * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
+ */
+ const char *wrapper_name;
+
+ /*****************************************************************
+ * No fields below this line are part of the public API. They
+ * may not be used outside of libavcodec and can be changed and
+ * removed at will.
+ * New public fields should be added right above.
+ *****************************************************************
+ */
+ /**
+ * Internal codec capabilities.
+ * See FF_CODEC_CAP_* in internal.h
+ */
+ int caps_internal;
+
+ int priv_data_size;
+ /**
+ * @name Frame-level threading support functions
+ * @{
+ */
+ /**
+ * Copy necessary context variables from a previous thread context to the current one.
+ * If not defined, the next thread will start automatically; otherwise, the codec
+ * must call ff_thread_finish_setup().
+ *
+ * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
+ */
+ int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src);
+
+ /**
+ * Copy variables back to the user-facing context
+ */
+ int (*update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src);
+ /** @} */
+
+ /**
+ * Private codec-specific defaults.
+ */
+ const AVCodecDefault *defaults;
+
+ /**
+ * Initialize codec static data, called from av_codec_iterate().
+ *
+ * This is not intended for time consuming operations as it is
+ * run for every codec regardless of that codec being used.
+ */
+ void (*init_static_data)(struct AVCodec *codec);
+
+ int (*init)(struct AVCodecContext *);
+ int (*encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size,
+ const struct AVSubtitle *sub);
+ /**
+ * Encode data to an AVPacket.
+ *
+ * @param avctx codec context
+ * @param avpkt output AVPacket
+ * @paramin frame AVFrame containing the raw data to be encoded
+ * @paramout got_packet_ptr encoder sets to 0 or 1 to indicate that a
+ * non-empty packet was returned in avpkt.
+ * @return 0 on success, negative error code on failure
+ */
+ int (*encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt,
+ const struct AVFrame *frame, int *got_packet_ptr);
+ /**
+ * Decode picture or subtitle data.
+ *
+ * @param avctx codec context
+ * @param outdata codec type dependent output struct
+ * @paramout got_frame_ptr decoder sets to 0 or 1 to indicate that a
+ * non-empty frame or subtitle was returned in
+ * outdata.
+ * @paramin avpkt AVPacket containing the data to be decoded
+ * @return amount of bytes read from the packet on success, negative error
+ * code on failure
+ */
+ int (*decode)(struct AVCodecContext *avctx, void *outdata,
+ int *got_frame_ptr, struct AVPacket *avpkt);
+ int (*close)(struct AVCodecContext *);
+ /**
+ * Encode API with decoupled frame/packet dataflow. This function is called
+ * to get one output packet. It should call ff_encode_get_frame() to obtain
+ * input data.
+ */
+ int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt);
+
+ /**
+ * Decode API with decoupled packet/frame dataflow. This function is called
+ * to get one output frame. It should call ff_decode_get_packet() to obtain
+ * input data.
+ */
+ int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame);
+ /**
+ * Flush buffers.
+ * Will be called when seeking
+ */
+ void (*flush)(struct AVCodecContext *);
+
+ /**
+ * Decoding only, a comma-separated list of bitstream filters to apply to
+ * packets before decoding.
+ */
+ const char *bsfs;
+
+ /**
+ * Array of pointers to hardware configurations supported by the codec,
+ * or NULL if no hardware supported. The array is terminated by a NULL
+ * pointer.
+ *
+ * The user can only access this field via avcodec_get_hw_config().
+ */
+ const struct AVCodecHWConfigInternal *const *hw_configs;
+
+ /**
+ * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
+ */
+ const uint32_t *codec_tags;
+} AVCodec;
+
+/**
+ * Iterate over all registered codecs.
+ *
+ * @param opaque a pointer where libavcodec will store the iteration state. Must
+ * point to NULL to start the iteration.
+ *
+ * @return the next registered codec or NULL when the iteration is
+ * finished
+ */
+const AVCodec *av_codec_iterate(void **opaque);
+
+/**
+ * Find a registered decoder with a matching codec ID.
+ *
+ * @param id AVCodecID of the requested decoder
+ * @return A decoder if one was found, NULL otherwise.
+ */
+const AVCodec *avcodec_find_decoder(enum AVCodecID id);
+
+/**
+ * Find a registered decoder with the specified name.
+ *
+ * @param name name of the requested decoder
+ * @return A decoder if one was found, NULL otherwise.
+ */
+const AVCodec *avcodec_find_decoder_by_name(const char *name);
+
+/**
+ * Find a registered encoder with a matching codec ID.
+ *
+ * @param id AVCodecID of the requested encoder
+ * @return An encoder if one was found, NULL otherwise.
+ */
+const AVCodec *avcodec_find_encoder(enum AVCodecID id);
+
+/**
+ * Find a registered encoder with the specified name.
+ *
+ * @param name name of the requested encoder
+ * @return An encoder if one was found, NULL otherwise.
+ */
+const AVCodec *avcodec_find_encoder_by_name(const char *name);
+/**
+ * @return a non-zero number if codec is an encoder, zero otherwise
+ */
+int av_codec_is_encoder(const AVCodec *codec);
+
+/**
+ * @return a non-zero number if codec is a decoder, zero otherwise
+ */
+int av_codec_is_decoder(const AVCodec *codec);
+
+/**
+ * Return a name for the specified profile, if available.
+ *
+ * @param codec the codec that is searched for the given profile
+ * @param profile the profile value for which a name is requested
+ * @return A name for the profile if found, NULL otherwise.
+ */
+const char *av_get_profile_name(const AVCodec *codec, int profile);
+
+enum {
+ /**
+ * The codec supports this format via the hw_device_ctx interface.
+ *
+ * When selecting this format, AVCodecContext.hw_device_ctx should
+ * have been set to a device of the specified type before calling
+ * avcodec_open2().
+ */
+ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
+ /**
+ * The codec supports this format via the hw_frames_ctx interface.
+ *
+ * When selecting this format for a decoder,
+ * AVCodecContext.hw_frames_ctx should be set to a suitable frames
+ * context inside the get_format() callback. The frames context
+ * must have been created on a device of the specified type.
+ *
+ * When selecting this format for an encoder,
+ * AVCodecContext.hw_frames_ctx should be set to the context which
+ * will be used for the input frames before calling avcodec_open2().
+ */
+ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
+ /**
+ * The codec supports this format by some internal method.
+ *
+ * This format can be selected without any additional configuration -
+ * no device or frames context is required.
+ */
+ AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
+ /**
+ * The codec supports this format by some ad-hoc method.
+ *
+ * Additional settings and/or function calls are required. See the
+ * codec-specific documentation for details. (Methods requiring
+ * this sort of configuration are deprecated and others should be
+ * used in preference.)
+ */
+ AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
+};
+
+typedef struct AVCodecHWConfig {
+ /**
+ * For decoders, a hardware pixel format which that decoder may be
+ * able to decode to if suitable hardware is available.
+ *
+ * For encoders, a pixel format which the encoder may be able to
+ * accept. If set to AV_PIX_FMT_NONE, this applies to all pixel
+ * formats supported by the codec.
+ */
+ enum AVPixelFormat pix_fmt;
+ /**
+ * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
+ * setup methods which can be used with this configuration.
+ */
+ int methods;
+ /**
+ * The device type associated with the configuration.
+ *
+ * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
+ * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
+ */
+ enum AVHWDeviceType device_type;
+} AVCodecHWConfig;
+
+/**
+ * Retrieve supported hardware configurations for a codec.
+ *
+ * Values of index from zero to some maximum return the indexed configuration
+ * descriptor; all other values return NULL. If the codec does not support
+ * any hardware configurations then it will always return NULL.
+ */
+const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
+
+/**
+ * @}
+ */
+
+#endif /* AVCODEC_CODEC_H */

gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/codec_desc.h Added

@@ -0,0 +1,128 @@
+/*
+ * Codec descriptors public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_DESC_H
+#define AVCODEC_CODEC_DESC_H
+
+#include "libavutil/avutil.h"
+
+#include "codec_id.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+/**
+ * This struct describes the properties of a single codec described by an
+ * AVCodecID.
+ * @see avcodec_descriptor_get()
+ */
+typedef struct AVCodecDescriptor {
+ enum AVCodecID id;
+ enum AVMediaType type;
+ /**
+ * Name of the codec described by this descriptor. It is non-empty and
+ * unique for each codec descriptor. It should contain alphanumeric
+ * characters and '_' only.
+ */
+ const char *name;
+ /**
+ * A more descriptive name for this codec. May be NULL.
+ */
+ const char *long_name;
+ /**
+ * Codec properties, a combination of AV_CODEC_PROP_* flags.
+ */
+ int props;
+ /**
+ * MIME type(s) associated with the codec.
+ * May be NULL; if not, a NULL-terminated array of MIME types.
+ * The first item is always non-NULL and is the preferred MIME type.
+ */
+ const char *const *mime_types;
+ /**
+ * If non-NULL, an array of profiles recognized for this codec.
+ * Terminated with FF_PROFILE_UNKNOWN.
+ */
+ const struct AVProfile *profiles;
+} AVCodecDescriptor;
+
+/**
+ * Codec uses only intra compression.
+ * Video and audio codecs only.
+ */
+#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
+/**
+ * Codec supports lossy compression. Audio and video codecs only.
+ * @note a codec may support both lossy and lossless
+ * compression modes
+ */
+#define AV_CODEC_PROP_LOSSY (1 << 1)
+/**
+ * Codec supports lossless compression. Audio and video codecs only.
+ */
+#define AV_CODEC_PROP_LOSSLESS (1 << 2)
+/**
+ * Codec supports frame reordering. That is, the coded order (the order in which
+ * the encoded packets are output by the encoders / stored / input to the
+ * decoders) may be different from the presentation order of the corresponding
+ * frames.
+ *
+ * For codecs that do not have this property set, PTS and DTS should always be
+ * equal.
+ */
+#define AV_CODEC_PROP_REORDER (1 << 3)
+/**
+ * Subtitle codec is bitmap based
+ * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
+ */
+#define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
+/**
+ * Subtitle codec is text based.
+ * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
+ */
+#define AV_CODEC_PROP_TEXT_SUB (1 << 17)
+
+/**
+ * @return descriptor for given codec ID or NULL if no descriptor exists.
+ */
+const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
+
+/**
+ * Iterate over all codec descriptors known to libavcodec.
+ *
+ * @param prev previous descriptor. NULL to get the first descriptor.
+ *
+ * @return next descriptor or NULL after the last descriptor
+ */
+const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
+
+/**
+ * @return codec descriptor with the given name or NULL if no such descriptor
+ * exists.
+ */
+const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_CODEC_DESC_H

gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/codec_id.h Added

@@ -0,0 +1,629 @@
+/*
+ * Codec IDs
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_ID_H
+#define AVCODEC_CODEC_ID_H
+
+#include "libavutil/avutil.h"
+#include "libavutil/samplefmt.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+/**
+ * Identify the syntax and semantics of the bitstream.
+ * The principle is roughly:
+ * Two decoders with the same ID can decode the same streams.
+ * Two encoders with the same ID can encode compatible streams.
+ * There may be slight deviations from the principle due to implementation
+ * details.
+ *
+ * If you add a codec ID to this list, add it so that
+ * 1. no value of an existing codec ID changes (that would break ABI),
+ * 2. it is as close as possible to similar codecs
+ *
+ * After adding new codec IDs, do not forget to add an entry to the codec
+ * descriptor list and bump libavcodec minor version.
+ */
+enum AVCodecID {
+ AV_CODEC_ID_NONE,
+
+ /* video codecs */
+ AV_CODEC_ID_MPEG1VIDEO,
+ AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
+ AV_CODEC_ID_H261,
+ AV_CODEC_ID_H263,
+ AV_CODEC_ID_RV10,
+ AV_CODEC_ID_RV20,
+ AV_CODEC_ID_MJPEG,
+ AV_CODEC_ID_MJPEGB,
+ AV_CODEC_ID_LJPEG,
+ AV_CODEC_ID_SP5X,
+ AV_CODEC_ID_JPEGLS,
+ AV_CODEC_ID_MPEG4,
+ AV_CODEC_ID_RAWVIDEO,
+ AV_CODEC_ID_MSMPEG4V1,
+ AV_CODEC_ID_MSMPEG4V2,
+ AV_CODEC_ID_MSMPEG4V3,
+ AV_CODEC_ID_WMV1,
+ AV_CODEC_ID_WMV2,
+ AV_CODEC_ID_H263P,
+ AV_CODEC_ID_H263I,
+ AV_CODEC_ID_FLV1,
+ AV_CODEC_ID_SVQ1,
+ AV_CODEC_ID_SVQ3,
+ AV_CODEC_ID_DVVIDEO,
+ AV_CODEC_ID_HUFFYUV,
+ AV_CODEC_ID_CYUV,
+ AV_CODEC_ID_H264,
+ AV_CODEC_ID_INDEO3,
+ AV_CODEC_ID_VP3,
+ AV_CODEC_ID_THEORA,
+ AV_CODEC_ID_ASV1,
+ AV_CODEC_ID_ASV2,
+ AV_CODEC_ID_FFV1,
+ AV_CODEC_ID_4XM,
+ AV_CODEC_ID_VCR1,
+ AV_CODEC_ID_CLJR,
+ AV_CODEC_ID_MDEC,
+ AV_CODEC_ID_ROQ,
+ AV_CODEC_ID_INTERPLAY_VIDEO,
+ AV_CODEC_ID_XAN_WC3,
+ AV_CODEC_ID_XAN_WC4,
+ AV_CODEC_ID_RPZA,
+ AV_CODEC_ID_CINEPAK,
+ AV_CODEC_ID_WS_VQA,
+ AV_CODEC_ID_MSRLE,
+ AV_CODEC_ID_MSVIDEO1,
+ AV_CODEC_ID_IDCIN,
+ AV_CODEC_ID_8BPS,
+ AV_CODEC_ID_SMC,
+ AV_CODEC_ID_FLIC,
+ AV_CODEC_ID_TRUEMOTION1,
+ AV_CODEC_ID_VMDVIDEO,
+ AV_CODEC_ID_MSZH,
+ AV_CODEC_ID_ZLIB,
+ AV_CODEC_ID_QTRLE,
+ AV_CODEC_ID_TSCC,
+ AV_CODEC_ID_ULTI,
+ AV_CODEC_ID_QDRAW,
+ AV_CODEC_ID_VIXL,
+ AV_CODEC_ID_QPEG,
+ AV_CODEC_ID_PNG,
+ AV_CODEC_ID_PPM,
+ AV_CODEC_ID_PBM,
+ AV_CODEC_ID_PGM,
+ AV_CODEC_ID_PGMYUV,
+ AV_CODEC_ID_PAM,
+ AV_CODEC_ID_FFVHUFF,
+ AV_CODEC_ID_RV30,
+ AV_CODEC_ID_RV40,
+ AV_CODEC_ID_VC1,
+ AV_CODEC_ID_WMV3,
+ AV_CODEC_ID_LOCO,
+ AV_CODEC_ID_WNV1,
+ AV_CODEC_ID_AASC,
+ AV_CODEC_ID_INDEO2,
+ AV_CODEC_ID_FRAPS,
+ AV_CODEC_ID_TRUEMOTION2,
+ AV_CODEC_ID_BMP,
+ AV_CODEC_ID_CSCD,
+ AV_CODEC_ID_MMVIDEO,
+ AV_CODEC_ID_ZMBV,
+ AV_CODEC_ID_AVS,
+ AV_CODEC_ID_SMACKVIDEO,
+ AV_CODEC_ID_NUV,
+ AV_CODEC_ID_KMVC,
+ AV_CODEC_ID_FLASHSV,
+ AV_CODEC_ID_CAVS,
+ AV_CODEC_ID_JPEG2000,
+ AV_CODEC_ID_VMNC,
+ AV_CODEC_ID_VP5,
+ AV_CODEC_ID_VP6,
+ AV_CODEC_ID_VP6F,
+ AV_CODEC_ID_TARGA,
+ AV_CODEC_ID_DSICINVIDEO,
+ AV_CODEC_ID_TIERTEXSEQVIDEO,
+ AV_CODEC_ID_TIFF,
+ AV_CODEC_ID_GIF,
+ AV_CODEC_ID_DXA,
+ AV_CODEC_ID_DNXHD,
+ AV_CODEC_ID_THP,
+ AV_CODEC_ID_SGI,
+ AV_CODEC_ID_C93,
+ AV_CODEC_ID_BETHSOFTVID,
+ AV_CODEC_ID_PTX,
+ AV_CODEC_ID_TXD,
+ AV_CODEC_ID_VP6A,
+ AV_CODEC_ID_AMV,
+ AV_CODEC_ID_VB,
+ AV_CODEC_ID_PCX,
+ AV_CODEC_ID_SUNRAST,
+ AV_CODEC_ID_INDEO4,
+ AV_CODEC_ID_INDEO5,
+ AV_CODEC_ID_MIMIC,
+ AV_CODEC_ID_RL2,
+ AV_CODEC_ID_ESCAPE124,
+ AV_CODEC_ID_DIRAC,
+ AV_CODEC_ID_BFI,
+ AV_CODEC_ID_CMV,
+ AV_CODEC_ID_MOTIONPIXELS,
+ AV_CODEC_ID_TGV,
+ AV_CODEC_ID_TGQ,
+ AV_CODEC_ID_TQI,
+ AV_CODEC_ID_AURA,
+ AV_CODEC_ID_AURA2,
+ AV_CODEC_ID_V210X,
+ AV_CODEC_ID_TMV,
+ AV_CODEC_ID_V210,
+ AV_CODEC_ID_DPX,
+ AV_CODEC_ID_MAD,
+ AV_CODEC_ID_FRWU,
+ AV_CODEC_ID_FLASHSV2,
+ AV_CODEC_ID_CDGRAPHICS,
+ AV_CODEC_ID_R210,
+ AV_CODEC_ID_ANM,
+ AV_CODEC_ID_BINKVIDEO,
+ AV_CODEC_ID_IFF_ILBM,
+#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
+ AV_CODEC_ID_KGV1,
+ AV_CODEC_ID_YOP,
+ AV_CODEC_ID_VP8,
+ AV_CODEC_ID_PICTOR,
+ AV_CODEC_ID_ANSI,
+ AV_CODEC_ID_A64_MULTI,
+ AV_CODEC_ID_A64_MULTI5,
+ AV_CODEC_ID_R10K,
+ AV_CODEC_ID_MXPEG,
+ AV_CODEC_ID_LAGARITH,
+ AV_CODEC_ID_PRORES,
+ AV_CODEC_ID_JV,
+ AV_CODEC_ID_DFA,
+ AV_CODEC_ID_WMV3IMAGE,
+ AV_CODEC_ID_VC1IMAGE,
+ AV_CODEC_ID_UTVIDEO,
+ AV_CODEC_ID_BMV_VIDEO,
+ AV_CODEC_ID_VBLE,
+ AV_CODEC_ID_DXTORY,
+ AV_CODEC_ID_V410,
+ AV_CODEC_ID_XWD,
+ AV_CODEC_ID_CDXL,
+ AV_CODEC_ID_XBM,
+ AV_CODEC_ID_ZEROCODEC,
+ AV_CODEC_ID_MSS1,
+ AV_CODEC_ID_MSA1,
+ AV_CODEC_ID_TSCC2,
+ AV_CODEC_ID_MTS2,
+ AV_CODEC_ID_CLLC,
+ AV_CODEC_ID_MSS2,
+ AV_CODEC_ID_VP9,
+ AV_CODEC_ID_AIC,
+ AV_CODEC_ID_ESCAPE130,
+ AV_CODEC_ID_G2M,
+ AV_CODEC_ID_WEBP,
+ AV_CODEC_ID_HNM4_VIDEO,
+ AV_CODEC_ID_HEVC,
+#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
+ AV_CODEC_ID_FIC,
+ AV_CODEC_ID_ALIAS_PIX,
+ AV_CODEC_ID_BRENDER_PIX,
+ AV_CODEC_ID_PAF_VIDEO,
+ AV_CODEC_ID_EXR,
+ AV_CODEC_ID_VP7,
+ AV_CODEC_ID_SANM,
+ AV_CODEC_ID_SGIRLE,
+ AV_CODEC_ID_MVC1,
+ AV_CODEC_ID_MVC2,
+ AV_CODEC_ID_HQX,
+ AV_CODEC_ID_TDSC,
+ AV_CODEC_ID_HQ_HQA,
+ AV_CODEC_ID_HAP,
+ AV_CODEC_ID_DDS,
+ AV_CODEC_ID_DXV,
+ AV_CODEC_ID_SCREENPRESSO,
+ AV_CODEC_ID_RSCC,
+ AV_CODEC_ID_AVS2,
+ AV_CODEC_ID_PGX,
+ AV_CODEC_ID_AVS3,
+ AV_CODEC_ID_MSP2,
+ AV_CODEC_ID_VVC,
+#define AV_CODEC_ID_H266 AV_CODEC_ID_VVC
+ AV_CODEC_ID_Y41P,
+ AV_CODEC_ID_AVRP,
+ AV_CODEC_ID_012V,
+ AV_CODEC_ID_AVUI,
+ AV_CODEC_ID_AYUV,
+ AV_CODEC_ID_TARGA_Y216,
+ AV_CODEC_ID_V308,
+ AV_CODEC_ID_V408,
+ AV_CODEC_ID_YUV4,
+ AV_CODEC_ID_AVRN,
+ AV_CODEC_ID_CPIA,
+ AV_CODEC_ID_XFACE,
+ AV_CODEC_ID_SNOW,
+ AV_CODEC_ID_SMVJPEG,
+ AV_CODEC_ID_APNG,
+ AV_CODEC_ID_DAALA,
+ AV_CODEC_ID_CFHD,
+ AV_CODEC_ID_TRUEMOTION2RT,
+ AV_CODEC_ID_M101,
+ AV_CODEC_ID_MAGICYUV,
+ AV_CODEC_ID_SHEERVIDEO,
+ AV_CODEC_ID_YLC,
+ AV_CODEC_ID_PSD,
+ AV_CODEC_ID_PIXLET,
+ AV_CODEC_ID_SPEEDHQ,
+ AV_CODEC_ID_FMVC,
+ AV_CODEC_ID_SCPR,
+ AV_CODEC_ID_CLEARVIDEO,
+ AV_CODEC_ID_XPM,
+ AV_CODEC_ID_AV1,
+ AV_CODEC_ID_BITPACKED,
+ AV_CODEC_ID_MSCC,
+ AV_CODEC_ID_SRGC,
+ AV_CODEC_ID_SVG,
+ AV_CODEC_ID_GDV,
+ AV_CODEC_ID_FITS,
+ AV_CODEC_ID_IMM4,
+ AV_CODEC_ID_PROSUMER,
+ AV_CODEC_ID_MWSC,
+ AV_CODEC_ID_WCMV,
+ AV_CODEC_ID_RASC,
+ AV_CODEC_ID_HYMT,
+ AV_CODEC_ID_ARBC,
+ AV_CODEC_ID_AGM,
+ AV_CODEC_ID_LSCR,
+ AV_CODEC_ID_VP4,
+ AV_CODEC_ID_IMM5,
+ AV_CODEC_ID_MVDV,
+ AV_CODEC_ID_MVHA,
+ AV_CODEC_ID_CDTOONS,
+ AV_CODEC_ID_MV30,
+ AV_CODEC_ID_NOTCHLC,
+ AV_CODEC_ID_PFM,
+ AV_CODEC_ID_MOBICLIP,
+ AV_CODEC_ID_PHOTOCD,
+ AV_CODEC_ID_IPU,
+ AV_CODEC_ID_ARGO,
+ AV_CODEC_ID_CRI,
+ AV_CODEC_ID_SIMBIOSIS_IMX,
+ AV_CODEC_ID_SGA_VIDEO,
+ AV_CODEC_ID_GEM,
+
+ /* various PCM "codecs" */
+ AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
+ AV_CODEC_ID_PCM_S16LE = 0x10000,
+ AV_CODEC_ID_PCM_S16BE,
+ AV_CODEC_ID_PCM_U16LE,
+ AV_CODEC_ID_PCM_U16BE,
+ AV_CODEC_ID_PCM_S8,
+ AV_CODEC_ID_PCM_U8,
+ AV_CODEC_ID_PCM_MULAW,
+ AV_CODEC_ID_PCM_ALAW,
+ AV_CODEC_ID_PCM_S32LE,
+ AV_CODEC_ID_PCM_S32BE,
+ AV_CODEC_ID_PCM_U32LE,
+ AV_CODEC_ID_PCM_U32BE,
+ AV_CODEC_ID_PCM_S24LE,
+ AV_CODEC_ID_PCM_S24BE,
+ AV_CODEC_ID_PCM_U24LE,
+ AV_CODEC_ID_PCM_U24BE,
+ AV_CODEC_ID_PCM_S24DAUD,
+ AV_CODEC_ID_PCM_ZORK,
+ AV_CODEC_ID_PCM_S16LE_PLANAR,
+ AV_CODEC_ID_PCM_DVD,
+ AV_CODEC_ID_PCM_F32BE,
+ AV_CODEC_ID_PCM_F32LE,
+ AV_CODEC_ID_PCM_F64BE,
+ AV_CODEC_ID_PCM_F64LE,
+ AV_CODEC_ID_PCM_BLURAY,
+ AV_CODEC_ID_PCM_LXF,
+ AV_CODEC_ID_S302M,
+ AV_CODEC_ID_PCM_S8_PLANAR,
+ AV_CODEC_ID_PCM_S24LE_PLANAR,
+ AV_CODEC_ID_PCM_S32LE_PLANAR,
+ AV_CODEC_ID_PCM_S16BE_PLANAR,
+ AV_CODEC_ID_PCM_S64LE,
+ AV_CODEC_ID_PCM_S64BE,
+ AV_CODEC_ID_PCM_F16LE,
+ AV_CODEC_ID_PCM_F24LE,
+ AV_CODEC_ID_PCM_VIDC,
+ AV_CODEC_ID_PCM_SGA,
+
+ /* various ADPCM codecs */
+ AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
+ AV_CODEC_ID_ADPCM_IMA_WAV,
+ AV_CODEC_ID_ADPCM_IMA_DK3,
+ AV_CODEC_ID_ADPCM_IMA_DK4,
+ AV_CODEC_ID_ADPCM_IMA_WS,
+ AV_CODEC_ID_ADPCM_IMA_SMJPEG,
+ AV_CODEC_ID_ADPCM_MS,
+ AV_CODEC_ID_ADPCM_4XM,
+ AV_CODEC_ID_ADPCM_XA,
+ AV_CODEC_ID_ADPCM_ADX,
+ AV_CODEC_ID_ADPCM_EA,
+ AV_CODEC_ID_ADPCM_G726,
+ AV_CODEC_ID_ADPCM_CT,
+ AV_CODEC_ID_ADPCM_SWF,
+ AV_CODEC_ID_ADPCM_YAMAHA,
+ AV_CODEC_ID_ADPCM_SBPRO_4,
+ AV_CODEC_ID_ADPCM_SBPRO_3,
+ AV_CODEC_ID_ADPCM_SBPRO_2,
+ AV_CODEC_ID_ADPCM_THP,
+ AV_CODEC_ID_ADPCM_IMA_AMV,
+ AV_CODEC_ID_ADPCM_EA_R1,
+ AV_CODEC_ID_ADPCM_EA_R3,
+ AV_CODEC_ID_ADPCM_EA_R2,
+ AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
+ AV_CODEC_ID_ADPCM_IMA_EA_EACS,
+ AV_CODEC_ID_ADPCM_EA_XAS,
+ AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
+ AV_CODEC_ID_ADPCM_IMA_ISS,
+ AV_CODEC_ID_ADPCM_G722,
+ AV_CODEC_ID_ADPCM_IMA_APC,
+ AV_CODEC_ID_ADPCM_VIMA,
+ AV_CODEC_ID_ADPCM_AFC,
+ AV_CODEC_ID_ADPCM_IMA_OKI,
+ AV_CODEC_ID_ADPCM_DTK,
+ AV_CODEC_ID_ADPCM_IMA_RAD,
+ AV_CODEC_ID_ADPCM_G726LE,
+ AV_CODEC_ID_ADPCM_THP_LE,
+ AV_CODEC_ID_ADPCM_PSX,
+ AV_CODEC_ID_ADPCM_AICA,
+ AV_CODEC_ID_ADPCM_IMA_DAT4,
+ AV_CODEC_ID_ADPCM_MTAF,
+ AV_CODEC_ID_ADPCM_AGM,
+ AV_CODEC_ID_ADPCM_ARGO,
+ AV_CODEC_ID_ADPCM_IMA_SSI,
+ AV_CODEC_ID_ADPCM_ZORK,
+ AV_CODEC_ID_ADPCM_IMA_APM,
+ AV_CODEC_ID_ADPCM_IMA_ALP,
+ AV_CODEC_ID_ADPCM_IMA_MTF,
+ AV_CODEC_ID_ADPCM_IMA_CUNNING,
+ AV_CODEC_ID_ADPCM_IMA_MOFLEX,
+ AV_CODEC_ID_ADPCM_IMA_ACORN,
+
+ /* AMR */
+ AV_CODEC_ID_AMR_NB = 0x12000,
+ AV_CODEC_ID_AMR_WB,
+
+ /* RealAudio codecs*/
+ AV_CODEC_ID_RA_144 = 0x13000,
+ AV_CODEC_ID_RA_288,
+
+ /* various DPCM codecs */
+ AV_CODEC_ID_ROQ_DPCM = 0x14000,
+ AV_CODEC_ID_INTERPLAY_DPCM,
+ AV_CODEC_ID_XAN_DPCM,
+ AV_CODEC_ID_SOL_DPCM,
+ AV_CODEC_ID_SDX2_DPCM,
+ AV_CODEC_ID_GREMLIN_DPCM,
+ AV_CODEC_ID_DERF_DPCM,
+
+ /* audio codecs */
+ AV_CODEC_ID_MP2 = 0x15000,
+ AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
+ AV_CODEC_ID_AAC,
+ AV_CODEC_ID_AC3,
+ AV_CODEC_ID_DTS,
+ AV_CODEC_ID_VORBIS,
+ AV_CODEC_ID_DVAUDIO,
+ AV_CODEC_ID_WMAV1,
+ AV_CODEC_ID_WMAV2,
+ AV_CODEC_ID_MACE3,
+ AV_CODEC_ID_MACE6,
+ AV_CODEC_ID_VMDAUDIO,
+ AV_CODEC_ID_FLAC,
+ AV_CODEC_ID_MP3ADU,
+ AV_CODEC_ID_MP3ON4,
+ AV_CODEC_ID_SHORTEN,
+ AV_CODEC_ID_ALAC,
+ AV_CODEC_ID_WESTWOOD_SND1,
+ AV_CODEC_ID_GSM, ///< as in Berlin toast format
+ AV_CODEC_ID_QDM2,
+ AV_CODEC_ID_COOK,
+ AV_CODEC_ID_TRUESPEECH,
+ AV_CODEC_ID_TTA,
+ AV_CODEC_ID_SMACKAUDIO,
+ AV_CODEC_ID_QCELP,
+ AV_CODEC_ID_WAVPACK,
+ AV_CODEC_ID_DSICINAUDIO,
+ AV_CODEC_ID_IMC,
+ AV_CODEC_ID_MUSEPACK7,
+ AV_CODEC_ID_MLP,
+ AV_CODEC_ID_GSM_MS, /* as found in WAV */
+ AV_CODEC_ID_ATRAC3,
+ AV_CODEC_ID_APE,
+ AV_CODEC_ID_NELLYMOSER,
+ AV_CODEC_ID_MUSEPACK8,
+ AV_CODEC_ID_SPEEX,
+ AV_CODEC_ID_WMAVOICE,
+ AV_CODEC_ID_WMAPRO,
+ AV_CODEC_ID_WMALOSSLESS,
+ AV_CODEC_ID_ATRAC3P,
+ AV_CODEC_ID_EAC3,
+ AV_CODEC_ID_SIPR,
+ AV_CODEC_ID_MP1,
+ AV_CODEC_ID_TWINVQ,
+ AV_CODEC_ID_TRUEHD,
+ AV_CODEC_ID_MP4ALS,
+ AV_CODEC_ID_ATRAC1,
+ AV_CODEC_ID_BINKAUDIO_RDFT,
+ AV_CODEC_ID_BINKAUDIO_DCT,
+ AV_CODEC_ID_AAC_LATM,
+ AV_CODEC_ID_QDMC,
+ AV_CODEC_ID_CELT,
+ AV_CODEC_ID_G723_1,
+ AV_CODEC_ID_G729,
+ AV_CODEC_ID_8SVX_EXP,
+ AV_CODEC_ID_8SVX_FIB,
+ AV_CODEC_ID_BMV_AUDIO,
+ AV_CODEC_ID_RALF,
+ AV_CODEC_ID_IAC,
+ AV_CODEC_ID_ILBC,
+ AV_CODEC_ID_OPUS,
+ AV_CODEC_ID_COMFORT_NOISE,
+ AV_CODEC_ID_TAK,
+ AV_CODEC_ID_METASOUND,
+ AV_CODEC_ID_PAF_AUDIO,
+ AV_CODEC_ID_ON2AVC,
+ AV_CODEC_ID_DSS_SP,
+ AV_CODEC_ID_CODEC2,
+ AV_CODEC_ID_FFWAVESYNTH,
+ AV_CODEC_ID_SONIC,
+ AV_CODEC_ID_SONIC_LS,
+ AV_CODEC_ID_EVRC,
+ AV_CODEC_ID_SMV,
+ AV_CODEC_ID_DSD_LSBF,
+ AV_CODEC_ID_DSD_MSBF,
+ AV_CODEC_ID_DSD_LSBF_PLANAR,
+ AV_CODEC_ID_DSD_MSBF_PLANAR,
+ AV_CODEC_ID_4GV,
+ AV_CODEC_ID_INTERPLAY_ACM,
+ AV_CODEC_ID_XMA1,
+ AV_CODEC_ID_XMA2,
+ AV_CODEC_ID_DST,
+ AV_CODEC_ID_ATRAC3AL,
+ AV_CODEC_ID_ATRAC3PAL,
+ AV_CODEC_ID_DOLBY_E,
+ AV_CODEC_ID_APTX,
+ AV_CODEC_ID_APTX_HD,
+ AV_CODEC_ID_SBC,
+ AV_CODEC_ID_ATRAC9,
+ AV_CODEC_ID_HCOM,
+ AV_CODEC_ID_ACELP_KELVIN,
+ AV_CODEC_ID_MPEGH_3D_AUDIO,
+ AV_CODEC_ID_SIREN,
+ AV_CODEC_ID_HCA,
+ AV_CODEC_ID_FASTAUDIO,
+ AV_CODEC_ID_MSNSIREN,
+
+ /* subtitle codecs */
+ AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
+ AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
+ AV_CODEC_ID_DVB_SUBTITLE,
+ AV_CODEC_ID_TEXT, ///< raw UTF-8 text
+ AV_CODEC_ID_XSUB,
+ AV_CODEC_ID_SSA,
+ AV_CODEC_ID_MOV_TEXT,
+ AV_CODEC_ID_HDMV_PGS_SUBTITLE,
+ AV_CODEC_ID_DVB_TELETEXT,
+ AV_CODEC_ID_SRT,
+ AV_CODEC_ID_MICRODVD,
+ AV_CODEC_ID_EIA_608,
+ AV_CODEC_ID_JACOSUB,
+ AV_CODEC_ID_SAMI,
+ AV_CODEC_ID_REALTEXT,
+ AV_CODEC_ID_STL,
+ AV_CODEC_ID_SUBVIEWER1,
+ AV_CODEC_ID_SUBVIEWER,
+ AV_CODEC_ID_SUBRIP,
+ AV_CODEC_ID_WEBVTT,
+ AV_CODEC_ID_MPL2,
+ AV_CODEC_ID_VPLAYER,
+ AV_CODEC_ID_PJS,
+ AV_CODEC_ID_ASS,
+ AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
+ AV_CODEC_ID_TTML,
+ AV_CODEC_ID_ARIB_CAPTION,
+
+ /* other specific kind of codecs (generally used for attachments) */
+ AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs.
+ AV_CODEC_ID_TTF = 0x18000,
+
+ AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
+ AV_CODEC_ID_EPG,
+ AV_CODEC_ID_BINTEXT,
+ AV_CODEC_ID_XBIN,
+ AV_CODEC_ID_IDF,
+ AV_CODEC_ID_OTF,
+ AV_CODEC_ID_SMPTE_KLV,
+ AV_CODEC_ID_DVD_NAV,
+ AV_CODEC_ID_TIMED_ID3,
+ AV_CODEC_ID_BIN_DATA,
+
+
+ AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
+
+ AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
+ * stream (only used by libavformat) */
+ AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
+ * stream (only used by libavformat) */
+ AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
+ AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
+};
+
+/**
+ * Get the type of the given codec.
+ */
+enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
+
+/**
+ * Get the name of a codec.
+ * @return a static string identifying the codec; never NULL
+ */
+const char *avcodec_get_name(enum AVCodecID id);
+
+/**
+ * Return codec bits per sample.
+ *
+ * @paramin codec_id the codec
+ * @return Number of bits per sample or zero if unknown for the given codec.
+ */
+int av_get_bits_per_sample(enum AVCodecID codec_id);
+
+/**
+ * Return codec bits per sample.
+ * Only return non-zero if the bits per sample is exactly correct, not an
+ * approximation.
+ *
+ * @paramin codec_id the codec
+ * @return Number of bits per sample or zero if unknown for the given codec.
+ */
+int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
+
+/**
+ * Return a name for the specified profile, if available.
+ *
+ * @param codec_id the ID of the codec to which the requested profile belongs
+ * @param profile the profile value for which a name is requested
+ * @return A name for the profile if found, NULL otherwise.
+ *
+ * @note unlike av_get_profile_name(), which searches a list of profiles
+ * supported by a specific decoder or encoder implementation, this
+ * function searches the list of profiles from the AVCodecDescriptor
+ */
+const char *avcodec_profile_name(enum AVCodecID codec_id, int profile);
+
+/**
+ * Return the PCM codec associated with a sample format.
+ * @param be endianness, 0 for little, 1 for big,
+ * -1 (or anything else) for native
+ * @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
+ */
+enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_CODEC_ID_H

gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/codec_par.h Added

@@ -0,0 +1,234 @@
+/*
+ * Codec parameters public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_PAR_H
+#define AVCODEC_CODEC_PAR_H
+
+#include <stdint.h>
+
+#include "libavutil/avutil.h"
+#include "libavutil/rational.h"
+#include "libavutil/pixfmt.h"
+
+#include "codec_id.h"
+
+/**
+ * @addtogroup lavc_core
+ */
+
+enum AVFieldOrder {
+ AV_FIELD_UNKNOWN,
+ AV_FIELD_PROGRESSIVE,
+ AV_FIELD_TT, //< Top coded_first, top displayed first
+ AV_FIELD_BB, //< Bottom coded first, bottom displayed first
+ AV_FIELD_TB, //< Top coded first, bottom displayed first
+ AV_FIELD_BT, //< Bottom coded first, top displayed first
+};
+
+/**
+ * This struct describes the properties of an encoded stream.
+ *
+ * sizeof(AVCodecParameters) is not a part of the public ABI, this struct must
+ * be allocated with avcodec_parameters_alloc() and freed with
+ * avcodec_parameters_free().
+ */
+typedef struct AVCodecParameters {
+ /**
+ * General type of the encoded data.
+ */
+ enum AVMediaType codec_type;
+ /**
+ * Specific type of the encoded data (the codec used).
+ */
+ enum AVCodecID codec_id;
+ /**
+ * Additional information about the codec (corresponds to the AVI FOURCC).
+ */
+ uint32_t codec_tag;
+
+ /**
+ * Extra binary data needed for initializing the decoder, codec-dependent.
+ *
+ * Must be allocated with av_malloc() and will be freed by
+ * avcodec_parameters_free(). The allocated size of extradata must be at
+ * least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
+ * bytes zeroed.
+ */
+ uint8_t *extradata;
+ /**
+ * Size of the extradata content in bytes.
+ */
+ int extradata_size;
+
+ /**
+ * - video: the pixel format, the value corresponds to enum AVPixelFormat.
+ * - audio: the sample format, the value corresponds to enum AVSampleFormat.
+ */
+ int format;
+
+ /**
+ * The average bitrate of the encoded data (in bits per second).
+ */
+ int64_t bit_rate;
+
+ /**
+ * The number of bits per sample in the codedwords.
+ *
+ * This is basically the bitrate per sample. It is mandatory for a bunch of
+ * formats to actually decode them. It's the number of bits for one sample in
+ * the actual coded bitstream.
+ *
+ * This could be for example 4 for ADPCM
+ * For PCM formats this matches bits_per_raw_sample
+ * Can be 0
+ */
+ int bits_per_coded_sample;
+
+ /**
+ * This is the number of valid bits in each output sample. If the
+ * sample format has more bits, the least significant bits are additional
+ * padding bits, which are always 0. Use right shifts to reduce the sample
+ * to its actual size. For example, audio formats with 24 bit samples will
+ * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
+ * To get the original sample use "(int32_t)sample >> 8"."
+ *
+ * For ADPCM this might be 12 or 16 or similar
+ * Can be 0
+ */
+ int bits_per_raw_sample;
+
+ /**
+ * Codec-specific bitstream restrictions that the stream conforms to.
+ */
+ int profile;
+ int level;
+
+ /**
+ * Video only. The dimensions of the video frame in pixels.
+ */
+ int width;
+ int height;
+
+ /**
+ * Video only. The aspect ratio (width / height) which a single pixel
+ * should have when displayed.
+ *
+ * When the aspect ratio is unknown / undefined, the numerator should be
+ * set to 0 (the denominator may have any value).
+ */
+ AVRational sample_aspect_ratio;
+
+ /**
+ * Video only. The order of the fields in interlaced video.
+ */
+ enum AVFieldOrder field_order;
+
+ /**
+ * Video only. Additional colorspace characteristics.
+ */
+ enum AVColorRange color_range;
+ enum AVColorPrimaries color_primaries;
+ enum AVColorTransferCharacteristic color_trc;
+ enum AVColorSpace color_space;
+ enum AVChromaLocation chroma_location;
+
+ /**
+ * Video only. Number of delayed frames.
+ */
+ int video_delay;
+
+ /**
+ * Audio only. The channel layout bitmask. May be 0 if the channel layout is
+ * unknown or unspecified, otherwise the number of bits set must be equal to
+ * the channels field.
+ */
+ uint64_t channel_layout;
+ /**
+ * Audio only. The number of audio channels.
+ */
+ int channels;
+ /**
+ * Audio only. The number of audio samples per second.
+ */
+ int sample_rate;
+ /**
+ * Audio only. The number of bytes per coded audio frame, required by some
+ * formats.
+ *
+ * Corresponds to nBlockAlign in WAVEFORMATEX.
+ */
+ int block_align;
+ /**
+ * Audio only. Audio frame size, if known. Required by some formats to be static.
+ */
+ int frame_size;
+
+ /**
+ * Audio only. The amount of padding (in samples) inserted by the encoder at
+ * the beginning of the audio. I.e. this number of leading decoded samples
+ * must be discarded by the caller to get the original audio without leading
+ * padding.
+ */
+ int initial_padding;
+ /**
+ * Audio only. The amount of padding (in samples) appended by the encoder to
+ * the end of the audio. I.e. this number of decoded samples must be
+ * discarded by the caller from the end of the stream to get the original
+ * audio without any trailing padding.
+ */
+ int trailing_padding;
+ /**
+ * Audio only. Number of samples to skip after a discontinuity.
+ */
+ int seek_preroll;
+} AVCodecParameters;
+
+/**
+ * Allocate a new AVCodecParameters and set its fields to default values
+ * (unknown/invalid/0). The returned struct must be freed with
+ * avcodec_parameters_free().
+ */
+AVCodecParameters *avcodec_parameters_alloc(void);
+
+/**
+ * Free an AVCodecParameters instance and everything associated with it and
+ * write NULL to the supplied pointer.
+ */
+void avcodec_parameters_free(AVCodecParameters **par);
+
+/**
+ * Copy the contents of src to dst. Any allocated fields in dst are freed and
+ * replaced with newly allocated duplicates of the corresponding fields in src.
+ *
+ * @return >= 0 on success, a negative AVERROR code on failure.
+ */
+int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
+
+/**
+ * This function is the same as av_get_audio_frame_duration(), except it works
+ * with AVCodecParameters instead of an AVCodecContext.
+ */
+int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_CODEC_PAR_H

gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/defs.h Added

@@ -0,0 +1,170 @@
+/*
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_DEFS_H
+#define AVCODEC_DEFS_H
+
+/**
+ * @file
+ * @ingroup libavc
+ * Misc types and constants that do not belong anywhere else.
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * @ingroup lavc_decoding
+ * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
+ * This is mainly needed because some optimized bitstream readers read
+ * 32 or 64 bit at once and could read over the end. 
+ * Note: If the first 23 bits of the additional bytes are not 0, then damaged
+ * MPEG bitstreams could cause overread and segfault.
+ */
+#define AV_INPUT_BUFFER_PADDING_SIZE 64
+
+/**
+ * @ingroup lavc_decoding
+ */
+enum AVDiscard{
+ /* We leave some space between them for extensions (drop some
+ * keyframes for intra-only or drop just some bidir frames). */
+ AVDISCARD_NONE =-16, ///< discard nothing
+ AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi
+ AVDISCARD_NONREF = 8, ///< discard all non reference
+ AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames
+ AVDISCARD_NONINTRA= 24, ///< discard all non intra frames
+ AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
+ AVDISCARD_ALL = 48, ///< discard all
+};
+
+enum AVAudioServiceType {
+ AV_AUDIO_SERVICE_TYPE_MAIN = 0,
+ AV_AUDIO_SERVICE_TYPE_EFFECTS = 1,
+ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
+ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3,
+ AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4,
+ AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5,
+ AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6,
+ AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7,
+ AV_AUDIO_SERVICE_TYPE_KARAOKE = 8,
+ AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI
+};
+
+/**
+ * Pan Scan area.
+ * This specifies the area which should be displayed.
+ * Note there may be multiple such areas for one frame.
+ */
+typedef struct AVPanScan {
+ /**
+ * id
+ * - encoding: Set by user.
+ * - decoding: Set by libavcodec.
+ */
+ int id;
+
+ /**
+ * width and height in 1/16 pel
+ * - encoding: Set by user.
+ * - decoding: Set by libavcodec.
+ */
+ int width;
+ int height;
+
+ /**
+ * position of the top left corner in 1/16 pel for up to 3 fields/frames
+ * - encoding: Set by user.
+ * - decoding: Set by libavcodec.
+ */
+ int16_t position32;
+} AVPanScan;
+
+/**
+ * This structure describes the bitrate properties of an encoded bitstream. It
+ * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD
+ * parameters for H.264/HEVC.
+ */
+typedef struct AVCPBProperties {
+ /**
+ * Maximum bitrate of the stream, in bits per second.
+ * Zero if unknown or unspecified.
+ */
+ int64_t max_bitrate;
+ /**
+ * Minimum bitrate of the stream, in bits per second.
+ * Zero if unknown or unspecified.
+ */
+ int64_t min_bitrate;
+ /**
+ * Average bitrate of the stream, in bits per second.
+ * Zero if unknown or unspecified.
+ */
+ int64_t avg_bitrate;
+
+ /**
+ * The size of the buffer to which the ratecontrol is applied, in bits.
+ * Zero if unknown or unspecified.
+ */
+ int64_t buffer_size;
+
+ /**
+ * The delay between the time the packet this structure is associated with
+ * is received and the time when it should be decoded, in periods of a 27MHz
+ * clock.
+ *
+ * UINT64_MAX when unknown or unspecified.
+ */
+ uint64_t vbv_delay;
+} AVCPBProperties;
+
+/**
+ * Allocate a CPB properties structure and initialize its fields to default
+ * values.
+ *
+ * @param size if non-NULL, the size of the allocated struct will be written
+ * here. This is useful for embedding it in side data.
+ *
+ * @return the newly allocated struct or NULL on failure
+ */
+AVCPBProperties *av_cpb_properties_alloc(size_t *size);
+
+/**
+ * This structure supplies correlation between a packet timestamp and a wall clock
+ * production time. The definition follows the Producer Reference Time ('prft')
+ * as defined in ISO/IEC 14496-12
+ */
+typedef struct AVProducerReferenceTime {
+ /**
+ * A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
+ */
+ int64_t wallclock;
+ int flags;
+} AVProducerReferenceTime;
+
+/**
+ * Encode extradata length to a buffer. Used by xiph codecs.
+ *
+ * @param s buffer to write to; must be at least (v/255+1) bytes long
+ * @param v size of extradata in bytes
+ * @return number of bytes written to the buffer.
+ */
+unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
+
+#endif // AVCODEC_DEFS_H

gpac-2.0.0.tar.gz/extra_lib/include/libavcodec/dv_profile.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/dv_profile.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavcodec/mediacodec.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/mediacodec.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/packet.h Added

@@ -0,0 +1,725 @@
+/*
+ * AVPacket public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_PACKET_H
+#define AVCODEC_PACKET_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/buffer.h"
+#include "libavutil/dict.h"
+#include "libavutil/rational.h"
+
+#include "libavcodec/version.h"
+
+/**
+ * @defgroup lavc_packet AVPacket
+ *
+ * Types and functions for working with AVPacket.
+ * @{
+ */
+enum AVPacketSideDataType {
+ /**
+ * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
+ * bytes worth of palette. This side data signals that a new palette is
+ * present.
+ */
+ AV_PKT_DATA_PALETTE,
+
+ /**
+ * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
+ * that the extradata buffer was changed and the receiving side should
+ * act upon it appropriately. The new extradata is embedded in the side
+ * data buffer and should be immediately used for processing the current
+ * frame or packet.
+ */
+ AV_PKT_DATA_NEW_EXTRADATA,
+
+ /**
+ * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
+ * @code
+ * u32le param_flags
+ * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
+ * s32le channel_count
+ * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
+ * u64le channel_layout
+ * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
+ * s32le sample_rate
+ * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
+ * s32le width
+ * s32le height
+ * @endcode
+ */
+ AV_PKT_DATA_PARAM_CHANGE,
+
+ /**
+ * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
+ * structures with info about macroblocks relevant to splitting the
+ * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
+ * That is, it does not necessarily contain info about all macroblocks,
+ * as long as the distance between macroblocks in the info is smaller
+ * than the target payload size.
+ * Each MB info structure is 12 bytes, and is laid out as follows:
+ * @code
+ * u32le bit offset from the start of the packet
+ * u8 current quantizer at the start of the macroblock
+ * u8 GOB number
+ * u16le macroblock address within the GOB
+ * u8 horizontal MV predictor
+ * u8 vertical MV predictor
+ * u8 horizontal MV predictor for block number 3
+ * u8 vertical MV predictor for block number 3
+ * @endcode
+ */
+ AV_PKT_DATA_H263_MB_INFO,
+
+ /**
+ * This side data should be associated with an audio stream and contains
+ * ReplayGain information in form of the AVReplayGain struct.
+ */
+ AV_PKT_DATA_REPLAYGAIN,
+
+ /**
+ * This side data contains a 3x3 transformation matrix describing an affine
+ * transformation that needs to be applied to the decoded video frames for
+ * correct presentation.
+ *
+ * See libavutil/display.h for a detailed description of the data.
+ */
+ AV_PKT_DATA_DISPLAYMATRIX,
+
+ /**
+ * This side data should be associated with a video stream and contains
+ * Stereoscopic 3D information in form of the AVStereo3D struct.
+ */
+ AV_PKT_DATA_STEREO3D,
+
+ /**
+ * This side data should be associated with an audio stream and corresponds
+ * to enum AVAudioServiceType.
+ */
+ AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+
+ /**
+ * This side data contains quality related information from the encoder.
+ * @code
+ * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
+ * u8 picture type
+ * u8 error count
+ * u16 reserved
+ * u64leerror count sum of squared differences between encoder in and output
+ * @endcode
+ */
+ AV_PKT_DATA_QUALITY_STATS,
+
+ /**
+ * This side data contains an integer value representing the stream index
+ * of a "fallback" track. A fallback track indicates an alternate
+ * track to use when the current track can not be decoded for some reason.
+ * e.g. no decoder available for codec.
+ */
+ AV_PKT_DATA_FALLBACK_TRACK,
+
+ /**
+ * This side data corresponds to the AVCPBProperties struct.
+ */
+ AV_PKT_DATA_CPB_PROPERTIES,
+
+ /**
+ * Recommmends skipping the specified number of samples
+ * @code
+ * u32le number of samples to skip from start of this packet
+ * u32le number of samples to skip from end of this packet
+ * u8 reason for start skip
+ * u8 reason for end skip (0=padding silence, 1=convergence)
+ * @endcode
+ */
+ AV_PKT_DATA_SKIP_SAMPLES,
+
+ /**
+ * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
+ * the packet may contain "dual mono" audio specific to Japanese DTV
+ * and if it is true, recommends only the selected channel to be used.
+ * @code
+ * u8 selected channels (0=mail/left, 1=sub/right, 2=both)
+ * @endcode
+ */
+ AV_PKT_DATA_JP_DUALMONO,
+
+ /**
+ * A list of zero terminated key/value strings. There is no end marker for
+ * the list, so it is required to rely on the side data size to stop.
+ */
+ AV_PKT_DATA_STRINGS_METADATA,
+
+ /**
+ * Subtitle event position
+ * @code
+ * u32le x1
+ * u32le y1
+ * u32le x2
+ * u32le y2
+ * @endcode
+ */
+ AV_PKT_DATA_SUBTITLE_POSITION,
+
+ /**
+ * Data found in BlockAdditional element of matroska container. There is
+ * no end marker for the data, so it is required to rely on the side data
+ * size to recognize the end. 8 byte id (as found in BlockAddId) followed
+ * by data.
+ */
+ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
+
+ /**
+ * The optional first identifier line of a WebVTT cue.
+ */
+ AV_PKT_DATA_WEBVTT_IDENTIFIER,
+
+ /**
+ * The optional settings (rendering instructions) that immediately
+ * follow the timestamp specifier of a WebVTT cue.
+ */
+ AV_PKT_DATA_WEBVTT_SETTINGS,
+
+ /**
+ * A list of zero terminated key/value strings. There is no end marker for
+ * the list, so it is required to rely on the side data size to stop. This
+ * side data includes updated metadata which appeared in the stream.
+ */
+ AV_PKT_DATA_METADATA_UPDATE,
+
+ /**
+ * MPEGTS stream ID as uint8_t, this is required to pass the stream ID
+ * information from the demuxer to the corresponding muxer.
+ */
+ AV_PKT_DATA_MPEGTS_STREAM_ID,
+
+ /**
+ * Mastering display metadata (based on SMPTE-2086:2014). This metadata
+ * should be associated with a video stream and contains data in the form
+ * of the AVMasteringDisplayMetadata struct.
+ */
+ AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+
+ /**
+ * This side data should be associated with a video stream and corresponds
+ * to the AVSphericalMapping structure.
+ */
+ AV_PKT_DATA_SPHERICAL,
+
+ /**
+ * Content light level (based on CTA-861.3). This metadata should be
+ * associated with a video stream and contains data in the form of the
+ * AVContentLightMetadata struct.
+ */
+ AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+
+ /**
+ * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
+ * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
+ * The number of bytes of CC data is AVPacketSideData.size.
+ */
+ AV_PKT_DATA_A53_CC,
+
+ /**
+ * This side data is encryption initialization data.
+ * The format is not part of ABI, use av_encryption_init_info_* methods to
+ * access.
+ */
+ AV_PKT_DATA_ENCRYPTION_INIT_INFO,
+
+ /**
+ * This side data contains encryption info for how to decrypt the packet.
+ * The format is not part of ABI, use av_encryption_info_* methods to access.
+ */
+ AV_PKT_DATA_ENCRYPTION_INFO,
+
+ /**
+ * Active Format Description data consisting of a single byte as specified
+ * in ETSI TS 101 154 using AVActiveFormatDescription enum.
+ */
+ AV_PKT_DATA_AFD,
+
+ /**
+ * Producer Reference Time data corresponding to the AVProducerReferenceTime struct,
+ * usually exported by some encoders (on demand through the prft flag set in the
+ * AVCodecContext export_side_data field).
+ */
+ AV_PKT_DATA_PRFT,
+
+ /**
+ * ICC profile data consisting of an opaque octet buffer following the
+ * format described by ISO 15076-1.
+ */
+ AV_PKT_DATA_ICC_PROFILE,
+
+ /**
+ * DOVI configuration
+ * ref:
+ * dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2
+ * dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3
+ * Tags are stored in struct AVDOVIDecoderConfigurationRecord.
+ */
+ AV_PKT_DATA_DOVI_CONF,
+
+ /**
+ * Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t
+ * where the first uint32_t describes how many (1-3) of the other timecodes are used.
+ * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
+ * function in libavutil/timecode.h.
+ */
+ AV_PKT_DATA_S12M_TIMECODE,
+
+ /**
+ * HDR10+ dynamic metadata associated with a video frame. The metadata is in
+ * the form of the AVDynamicHDRPlus struct and contains
+ * information for color volume transform - application 4 of
+ * SMPTE 2094-40:2016 standard.
+ */
+ AV_PKT_DATA_DYNAMIC_HDR10_PLUS,
+
+ /**
+ * The number of side data types.
+ * This is not part of the public API/ABI in the sense that it may
+ * change when new side data types are added.
+ * This must stay the last enum value.
+ * If its value becomes huge, some code using it
+ * needs to be updated as it assumes it to be smaller than other limits.
+ */
+ AV_PKT_DATA_NB
+};
+
+#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
+
+typedef struct AVPacketSideData {
+ uint8_t *data;
+ size_t size;
+ enum AVPacketSideDataType type;
+} AVPacketSideData;
+
+/**
+ * This structure stores compressed data. It is typically exported by demuxers
+ * and then passed as input to decoders, or received as output from encoders and
+ * then passed to muxers.
+ *
+ * For video, it should typically contain one compressed frame. For audio it may
+ * contain several compressed frames. Encoders are allowed to output empty
+ * packets, with no compressed data, containing only side data
+ * (e.g. to update some stream parameters at the end of encoding).
+ *
+ * The semantics of data ownership depends on the buf field.
+ * If it is set, the packet data is dynamically allocated and is
+ * valid indefinitely until a call to av_packet_unref() reduces the
+ * reference count to 0.
+ *
+ * If the buf field is not set av_packet_ref() would make a copy instead
+ * of increasing the reference count.
+ *
+ * The side data is always allocated with av_malloc(), copied by
+ * av_packet_ref() and freed by av_packet_unref().
+ *
+ * sizeof(AVPacket) being a part of the public ABI is deprecated. once
+ * av_init_packet() is removed, new packets will only be able to be allocated
+ * with av_packet_alloc(), and new fields may be added to the end of the struct
+ * with a minor bump.
+ *
+ * @see av_packet_alloc
+ * @see av_packet_ref
+ * @see av_packet_unref
+ */
+typedef struct AVPacket {
+ /**
+ * A reference to the reference-counted buffer where the packet data is
+ * stored.
+ * May be NULL, then the packet data is not reference-counted.
+ */
+ AVBufferRef *buf;
+ /**
+ * Presentation timestamp in AVStream->time_base units; the time at which
+ * the decompressed packet will be presented to the user.
+ * Can be AV_NOPTS_VALUE if it is not stored in the file.
+ * pts MUST be larger or equal to dts as presentation cannot happen before
+ * decompression, unless one wants to view hex dumps. Some formats misuse
+ * the terms dts and pts/cts to mean something different. Such timestamps
+ * must be converted to true pts/dts before they are stored in AVPacket.
+ */
+ int64_t pts;
+ /**
+ * Decompression timestamp in AVStream->time_base units; the time at which
+ * the packet is decompressed.
+ * Can be AV_NOPTS_VALUE if it is not stored in the file.
+ */
+ int64_t dts;
+ uint8_t *data;
+ int size;
+ int stream_index;
+ /**
+ * A combination of AV_PKT_FLAG values
+ */
+ int flags;
+ /**
+ * Additional packet data that can be provided by the container.
+ * Packet can contain several types of side information.
+ */
+ AVPacketSideData *side_data;
+ int side_data_elems;
+
+ /**
+ * Duration of this packet in AVStream->time_base units, 0 if unknown.
+ * Equals next_pts - this_pts in presentation order.
+ */
+ int64_t duration;
+
+ int64_t pos; ///< byte position in stream, -1 if unknown
+
+ /**
+ * for some private data of the user
+ */
+ void *opaque;
+
+ /**
+ * AVBufferRef for free use by the API user. FFmpeg will never check the
+ * contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when
+ * the packet is unreferenced. av_packet_copy_props() calls create a new
+ * reference with av_buffer_ref() for the target packet's opaque_ref field.
+ *
+ * This is unrelated to the opaque field, although it serves a similar
+ * purpose.
+ */
+ AVBufferRef *opaque_ref;
+
+ /**
+ * Time base of the packet's timestamps.
+ * In the future, this field may be set on packets output by encoders or
+ * demuxers, but its value will be by default ignored on input to decoders
+ * or muxers.
+ */
+ AVRational time_base;
+} AVPacket;
+
+#if FF_API_INIT_PACKET
+attribute_deprecated
+typedef struct AVPacketList {
+ AVPacket pkt;
+ struct AVPacketList *next;
+} AVPacketList;
+#endif
+
+#define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
+#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
+/**
+ * Flag is used to discard packets which are required to maintain valid
+ * decoder state but are not required for output and should be dropped
+ * after decoding.
+ **/
+#define AV_PKT_FLAG_DISCARD 0x0004
+/**
+ * The packet comes from a trusted source.
+ *
+ * Otherwise-unsafe constructs such as arbitrary pointers to data
+ * outside the packet may be followed.
+ */
+#define AV_PKT_FLAG_TRUSTED 0x0008
+/**
+ * Flag is used to indicate packets that contain frames that can
+ * be discarded by the decoder. I.e. Non-reference frames.
+ */
+#define AV_PKT_FLAG_DISPOSABLE 0x0010
+
+enum AVSideDataParamChangeFlags {
+ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
+ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
+ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
+ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
+};
+
+/**
+ * Allocate an AVPacket and set its fields to default values. The resulting
+ * struct must be freed using av_packet_free().
+ *
+ * @return An AVPacket filled with default values or NULL on failure.
+ *
+ * @note this only allocates the AVPacket itself, not the data buffers. Those
+ * must be allocated through other means such as av_new_packet.
+ *
+ * @see av_new_packet
+ */
+AVPacket *av_packet_alloc(void);
+
+/**
+ * Create a new packet that references the same data as src.
+ *
+ * This is a shortcut for av_packet_alloc()+av_packet_ref().
+ *
+ * @return newly created AVPacket on success, NULL on error.
+ *
+ * @see av_packet_alloc
+ * @see av_packet_ref
+ */
+AVPacket *av_packet_clone(const AVPacket *src);
+
+/**
+ * Free the packet, if the packet is reference counted, it will be
+ * unreferenced first.
+ *
+ * @param pkt packet to be freed. The pointer will be set to NULL.
+ * @note passing NULL is a no-op.
+ */
+void av_packet_free(AVPacket **pkt);
+
+#if FF_API_INIT_PACKET
+/**
+ * Initialize optional fields of a packet with default values.
+ *
+ * Note, this does not touch the data and size members, which have to be
+ * initialized separately.
+ *
+ * @param pkt packet
+ *
+ * @see av_packet_alloc
+ * @see av_packet_unref
+ *
+ * @deprecated This function is deprecated. Once it's removed,
+ sizeof(AVPacket) will not be a part of the ABI anymore.
+ */
+attribute_deprecated
+void av_init_packet(AVPacket *pkt);
+#endif
+
+/**
+ * Allocate the payload of a packet and initialize its fields with
+ * default values.
+ *
+ * @param pkt packet
+ * @param size wanted payload size
+ * @return 0 if OK, AVERROR_xxx otherwise
+ */
+int av_new_packet(AVPacket *pkt, int size);
+
+/**
+ * Reduce packet size, correctly zeroing padding
+ *
+ * @param pkt packet
+ * @param size new size
+ */
+void av_shrink_packet(AVPacket *pkt, int size);
+
+/**
+ * Increase packet size, correctly zeroing padding
+ *
+ * @param pkt packet
+ * @param grow_by number of bytes by which to increase the size of the packet
+ */
+int av_grow_packet(AVPacket *pkt, int grow_by);
+
+/**
+ * Initialize a reference-counted packet from av_malloc()ed data.
+ *
+ * @param pkt packet to be initialized. This function will set the data, size,
+ * and buf fields, all others are left untouched.
+ * @param data Data allocated by av_malloc() to be used as packet data. If this
+ * function returns successfully, the data is owned by the underlying AVBuffer.
+ * The caller may not access the data through other means.
+ * @param size size of data in bytes, without the padding. I.e. the full buffer
+ * size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
+ *
+ * @return 0 on success, a negative AVERROR on error
+ */
+int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
+
+/**
+ * Allocate new information of a packet.
+ *
+ * @param pkt packet
+ * @param type side information type
+ * @param size side information size
+ * @return pointer to fresh allocated data or NULL otherwise
+ */
+uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+ size_t size);
+
+/**
+ * Wrap an existing array as a packet side data.
+ *
+ * @param pkt packet
+ * @param type side information type
+ * @param data the side data array. It must be allocated with the av_malloc()
+ * family of functions. The ownership of the data is transferred to
+ * pkt.
+ * @param size side information size
+ * @return a non-negative number on success, a negative AVERROR code on
+ * failure. On failure, the packet is unchanged and the data remains
+ * owned by the caller.
+ */
+int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+ uint8_t *data, size_t size);
+
+/**
+ * Shrink the already allocated side data buffer
+ *
+ * @param pkt packet
+ * @param type side information type
+ * @param size new side information size
+ * @return 0 on success, < 0 on failure
+ */
+int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+ size_t size);
+
+/**
+ * Get side information from packet.
+ *
+ * @param pkt packet
+ * @param type desired side information type
+ * @param size If supplied, *size will be set to the size of the side data
+ * or to zero if the desired side data is not present.
+ * @return pointer to data if present or NULL otherwise
+ */
+uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
+ size_t *size);
+
+const char *av_packet_side_data_name(enum AVPacketSideDataType type);
+
+/**
+ * Pack a dictionary for use in side_data.
+ *
+ * @param dict The dictionary to pack.
+ * @param size pointer to store the size of the returned data
+ * @return pointer to data if successful, NULL otherwise
+ */
+uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size);
+/**
+ * Unpack a dictionary from side_data.
+ *
+ * @param data data from side_data
+ * @param size size of the data
+ * @param dict the metadata storage dictionary
+ * @return 0 on success, < 0 on failure
+ */
+int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
+ AVDictionary **dict);
+
+/**
+ * Convenience function to free all the side data stored.
+ * All the other fields stay untouched.
+ *
+ * @param pkt packet
+ */
+void av_packet_free_side_data(AVPacket *pkt);
+
+/**
+ * Setup a new reference to the data described by a given packet
+ *
+ * If src is reference-counted, setup dst as a new reference to the
+ * buffer in src. Otherwise allocate a new buffer in dst and copy the
+ * data from src into it.
+ *
+ * All the other fields are copied from src.
+ *
+ * @see av_packet_unref
+ *
+ * @param dst Destination packet. Will be completely overwritten.
+ * @param src Source packet
+ *
+ * @return 0 on success, a negative AVERROR on error. On error, dst
+ * will be blank (as if returned by av_packet_alloc()).
+ */
+int av_packet_ref(AVPacket *dst, const AVPacket *src);
+
+/**
+ * Wipe the packet.
+ *
+ * Unreference the buffer referenced by the packet and reset the
+ * remaining packet fields to their default values.
+ *
+ * @param pkt The packet to be unreferenced.
+ */
+void av_packet_unref(AVPacket *pkt);
+
+/**
+ * Move every field in src to dst and reset src.
+ *
+ * @see av_packet_unref
+ *
+ * @param src Source packet, will be reset
+ * @param dst Destination packet
+ */
+void av_packet_move_ref(AVPacket *dst, AVPacket *src);
+
+/**
+ * Copy only "properties" fields from src to dst.
+ *
+ * Properties for the purpose of this function are all the fields
+ * beside those related to the packet data (buf, data, size)
+ *
+ * @param dst Destination packet
+ * @param src Source packet
+ *
+ * @return 0 on success AVERROR on failure.
+ */
+int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
+
+/**
+ * Ensure the data described by a given packet is reference counted.
+ *
+ * @note This function does not ensure that the reference will be writable.
+ * Use av_packet_make_writable instead for that purpose.
+ *
+ * @see av_packet_ref
+ * @see av_packet_make_writable
+ *
+ * @param pkt packet whose data should be made reference counted.
+ *
+ * @return 0 on success, a negative AVERROR on error. On failure, the
+ * packet is unchanged.
+ */
+int av_packet_make_refcounted(AVPacket *pkt);
+
+/**
+ * Create a writable reference for the data described by a given packet,
+ * avoiding data copy if possible.
+ *
+ * @param pkt Packet whose data should be made writable.
+ *
+ * @return 0 on success, a negative AVERROR on failure. On failure, the
+ * packet is unchanged.
+ */
+int av_packet_make_writable(AVPacket *pkt);
+
+/**
+ * Convert valid timing fields (timestamps / durations) in a packet from one
+ * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
+ * ignored.
+ *
+ * @param pkt packet on which the conversion will be performed
+ * @param tb_src source timebase, in which the timing fields in pkt are
+ * expressed
+ * @param tb_dst destination timebase, to which the timing fields will be
+ * converted
+ */
+void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_PACKET_H

gpac-2.0.0.tar.gz/extra_lib/include/libavcodec/vdpau.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/vdpau.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavcodec/version.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavcodec/version.h Changed

@@ -27,7 +27,7 @@
 
 #include "libavutil/version.h"
 
-#define LIBAVCODEC_VERSION_MAJOR 58
+#define LIBAVCODEC_VERSION_MAJOR 59
 #define LIBAVCODEC_VERSION_MINOR 18
 #define LIBAVCODEC_VERSION_MICRO 100
 
@@ -51,87 +51,17 @@
 * at once through the bump. This improves the git bisect-ability of the change.
 */
 
-#ifndef FF_API_LOWRES
-#define FF_API_LOWRES (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_DEBUG_MV
-#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 58)
-#endif
-#ifndef FF_API_AVCTX_TIMEBASE
-#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CODED_FRAME
-#define FF_API_CODED_FRAME (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_SIDEDATA_ONLY_PKT
-#define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_VDPAU_PROFILE
-#define FF_API_VDPAU_PROFILE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CONVERGENCE_DURATION
-#define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_AVPICTURE
-#define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_AVPACKET_OLD_API
-#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_RTP_CALLBACK
-#define FF_API_RTP_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_VBV_DELAY
-#define FF_API_VBV_DELAY (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CODER_TYPE
-#define FF_API_CODER_TYPE (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_STAT_BITS
-#define FF_API_STAT_BITS (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_PRIVATE_OPT
-#define FF_API_PRIVATE_OPT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_ASS_TIMING
-#define FF_API_ASS_TIMING (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_BSF
-#define FF_API_OLD_BSF (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_COPY_CONTEXT
-#define FF_API_COPY_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_GET_CONTEXT_DEFAULTS
-#define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_NVENC_OLD_NAME
-#define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_STRUCT_VAAPI_CONTEXT
-#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_MERGE_SD_API
-#define FF_API_MERGE_SD_API (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_TAG_STRING
-#define FF_API_TAG_STRING (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_GETCHROMA
-#define FF_API_GETCHROMA (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_CODEC_GET_SET
-#define FF_API_CODEC_GET_SET (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_USER_VISIBLE_AVHWACCEL
-#define FF_API_USER_VISIBLE_AVHWACCEL (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LOCKMGR
-#define FF_API_LOCKMGR (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_NEXT
-#define FF_API_NEXT (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-
+#define FF_API_OPENH264_SLICE_MODE (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_OPENH264_CABAC (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_UNUSED_CODEC_CAPS (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_THREAD_SAFE_CALLBACKS (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_GET_FRAME_CLASS (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_AUTO_THREADS (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_MPEGVIDEO_OPTS (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_FLAG_TRUNCATED (LIBAVCODEC_VERSION_MAJOR < 60)
+#define FF_API_SUB_TEXT_FORMAT (LIBAVCODEC_VERSION_MAJOR < 60)
 
 #endif /* AVCODEC_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavdevice/avdevice.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavdevice/avdevice.h Changed

@@ -77,7 +77,7 @@
 * if d is non-NULL, returns the next registered input audio/video device after d
 * or NULL if d is the last one.
 */
-AVInputFormat *av_input_audio_device_next(AVInputFormat *d);
+const AVInputFormat *av_input_audio_device_next(const AVInputFormat *d);
 
 /**
 * Video input devices iterator.
@@ -86,7 +86,7 @@
 * if d is non-NULL, returns the next registered input audio/video device after d
 * or NULL if d is the last one.
 */
-AVInputFormat *av_input_video_device_next(AVInputFormat *d);
+const AVInputFormat *av_input_video_device_next(const AVInputFormat *d);
 
 /**
 * Audio output devices iterator.
@@ -95,7 +95,7 @@
 * if d is non-NULL, returns the next registered output audio/video device after d
 * or NULL if d is the last one.
 */
-AVOutputFormat *av_output_audio_device_next(AVOutputFormat *d);
+const AVOutputFormat *av_output_audio_device_next(const AVOutputFormat *d);
 
 /**
 * Video output devices iterator.
@@ -104,7 +104,7 @@
 * if d is non-NULL, returns the next registered output audio/video device after d
 * or NULL if d is the last one.
 */
-AVOutputFormat *av_output_video_device_next(AVOutputFormat *d);
+const AVOutputFormat *av_output_video_device_next(const AVOutputFormat *d);
 
 typedef struct AVDeviceRect {
 int x; /**< x coordinate of top left corner */
@@ -321,6 +321,7 @@
 enum AVDevToAppMessageType type,
 void *data, size_t data_size);
 
+#if FF_API_DEVICE_CAPABILITIES
 /**
 * Following API allows user to probe device capabilities (supported codecs,
 * pixel formats, sample formats, resolutions, channel counts, etc).
@@ -416,6 +417,7 @@
 /**
 * AVOption table used by devices to implement device capabilities API. Should not be used by a user.
 */
+attribute_deprecated
 extern const AVOption av_device_capabilities;
 
 /**
@@ -435,6 +437,7 @@
 *
 * @return >= 0 on success, negative otherwise.
 */
+attribute_deprecated
 int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
 AVDictionary **device_options);
 
@@ -444,7 +447,9 @@
 * @param caps Device capabilities data to be freed.
 * @param s Context of the device.
 */
+attribute_deprecated
 void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s);
+#endif
 
 /**
 * Structure describes basic parameters of the device.
@@ -452,6 +457,8 @@
 typedef struct AVDeviceInfo {
 char *device_name; /**< device name, format depends on device */
 char *device_description; /**< human friendly name */
+ enum AVMediaType *media_types; /**< array indicating what media types(s), if any, a device can provide. If null, cannot provide any */
+ int nb_media_types; /**< length of media_types array, 0 if device cannot provide any media types */
 } AVDeviceInfo;
 
 /**
@@ -502,9 +509,9 @@
 * @return count of autodetected devices, negative on error.
 * @note device argument takes precedence over device_name when both are set.
 */
-int avdevice_list_input_sources(struct AVInputFormat *device, const char *device_name,
+int avdevice_list_input_sources(const AVInputFormat *device, const char *device_name,
 AVDictionary *device_options, AVDeviceInfoList **device_list);
-int avdevice_list_output_sinks(struct AVOutputFormat *device, const char *device_name,
+int avdevice_list_output_sinks(const AVOutputFormat *device, const char *device_name,
 AVDictionary *device_options, AVDeviceInfoList **device_list);
 
 /**

gpac-2.0.0.tar.gz/extra_lib/include/libavdevice/version.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavdevice/version.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavfilter/avfilter.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavfilter/avfilter.h Changed

@@ -68,18 +68,23 @@
 typedef struct AVFilterLink AVFilterLink;
 typedef struct AVFilterPad AVFilterPad;
 typedef struct AVFilterFormats AVFilterFormats;
+typedef struct AVFilterChannelLayouts AVFilterChannelLayouts;
 
+#if FF_API_PAD_COUNT
 /**
- * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
- * AVFilter.inputs/outputs).
+ * Get the number of elements in an AVFilter's inputs or outputs array.
+ *
+ * @deprecated Use avfilter_filter_pad_count() instead.
 */
+attribute_deprecated
 int avfilter_pad_count(const AVFilterPad *pads);
+#endif
 
 /**
 * Get the name of an AVFilterPad.
 *
 * @param pads an array of AVFilterPads
- * @param pad_idx index of the pad in the array it; is the caller's
+ * @param pad_idx index of the pad in the array; it is the caller's
 * responsibility to ensure the index is valid
 *
 * @return name of the pad_idx'th pad in pads
@@ -115,6 +120,22 @@
 */
 #define AVFILTER_FLAG_SLICE_THREADS (1 << 2)
 /**
+ * The filter is a "metadata" filter - it does not modify the frame data in any
+ * way. It may only affect the metadata (i.e. those fields copied by
+ * av_frame_copy_props()).
+ *
+ * More precisely, this means:
+ * - video: the data of any frame output by the filter must be exactly equal to
+ * some frame that is received on one of its inputs. Furthermore, all frames
+ * produced on a given output must correspond to frames received on the same
+ * input and their order must be unchanged. Note that the filter may still
+ * drop or duplicate the frames.
+ * - audio: the data produced by the filter on any of its outputs (viewed e.g.
+ * as an array of interleaved samples) must be exactly equal to the data
+ * received by the filter on one of its inputs.
+ */
+#define AVFILTER_FLAG_METADATA_ONLY (1 << 3)
+/**
 * Some filters support a generic "enable" expression option that can be used
 * to enable or disable a filter in the timeline. Filters supporting this
 * option have this flag set. When the enable expression is false, the default
@@ -155,15 +176,16 @@
 const char *description;
 
 /**
- * List of inputs, terminated by a zeroed element.
+ * List of static inputs.
 *
 * NULL if there are no (static) inputs. Instances of filters with
 * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
 * this list.
 */
 const AVFilterPad *inputs;
+
 /**
- * List of outputs, terminated by a zeroed element.
+ * List of static outputs.
 *
 * NULL if there are no (static) outputs. Instances of filters with
 * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
@@ -195,6 +217,22 @@
 */
 
 /**
+ * The number of entries in the list of inputs.
+ */
+ uint8_t nb_inputs;
+
+ /**
+ * The number of entries in the list of outputs.
+ */
+ uint8_t nb_outputs;
+
+ /**
+ * This field determines the state of the formats union.
+ * It is an enum FilterFormatsState value.
+ */
+ uint8_t formats_state;
+
+ /**
 * Filter pre-initialization function
 *
 * This callback will be called immediately after the filter context is
@@ -258,40 +296,68 @@
 void (*uninit)(AVFilterContext *ctx);
 
 /**
- * Query formats supported by the filter on its inputs and outputs.
- *
- * This callback is called after the filter is initialized (so the inputs
- * and outputs are fixed), shortly before the format negotiation. This
- * callback may be called more than once.
- *
- * This callback must set AVFilterLink.out_formats on every input link and
- * AVFilterLink.in_formats on every output link to a list of pixel/sample
- * formats that the filter supports on that link. For audio links, this
- * filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" /
- * @ref AVFilterLink.out_samplerates "out_samplerates" and
- * @ref AVFilterLink.in_channel_layouts "in_channel_layouts" /
- * @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously.
- *
- * This callback may be NULL for filters with one input, in which case
- * libavfilter assumes that it supports all input formats and preserves
- * them on output.
- *
- * @return zero on success, a negative value corresponding to an
- * AVERROR code otherwise
+ * The state of the following union is determined by formats_state.
+ * See the documentation of enum FilterFormatsState in internal.h.
 */
- int (*query_formats)(AVFilterContext *);
+ union {
+ /**
+ * Query formats supported by the filter on its inputs and outputs.
+ *
+ * This callback is called after the filter is initialized (so the inputs
+ * and outputs are fixed), shortly before the format negotiation. This
+ * callback may be called more than once.
+ *
+ * This callback must set AVFilterLink.outcfg.formats on every input link
+ * and AVFilterLink.incfg.formats on every output link to a list of
+ * pixel/sample formats that the filter supports on that link. For audio
+ * links, this filter must also set @ref AVFilterLink.incfg.samplerates
+ * "in_samplerates" / @ref AVFilterLink.outcfg.samplerates "out_samplerates"
+ * and @ref AVFilterLink.incfg.channel_layouts "in_channel_layouts" /
+ * @ref AVFilterLink.outcfg.channel_layouts "out_channel_layouts" analogously.
+ *
+ * This callback must never be NULL if the union is in this state.
+ *
+ * @return zero on success, a negative value corresponding to an
+ * AVERROR code otherwise
+ */
+ int (*query_func)(AVFilterContext *);
+ /**
+ * A pointer to an array of admissible pixel formats delimited
+ * by AV_PIX_FMT_NONE. The generic code will use this list
+ * to indicate that this filter supports each of these pixel formats,
+ * provided that all inputs and outputs use the same pixel format.
+ *
+ * This list must never be NULL if the union is in this state.
+ * The type of all inputs and outputs of filters using this must
+ * be AVMEDIA_TYPE_VIDEO.
+ */
+ const enum AVPixelFormat *pixels_list;
+ /**
+ * Analogous to pixels, but delimited by AV_SAMPLE_FMT_NONE
+ * and restricted to filters that only have AVMEDIA_TYPE_AUDIO
+ * inputs and outputs.
+ *
+ * In addition to that the generic code will mark all inputs
+ * and all outputs as supporting all sample rates and every
+ * channel count and channel layout, as long as all inputs
+ * and outputs use the same sample rate and channel count/layout.
+ */
+ const enum AVSampleFormat *samples_list;
+ /**
+ * Equivalent to { pix_fmt, AV_PIX_FMT_NONE } as pixels_list.
+ */
+ enum AVPixelFormat pix_fmt;
+ /**
+ * Equivalent to { sample_fmt, AV_SAMPLE_FMT_NONE } as samples_list.
+ */
+ enum AVSampleFormat sample_fmt;
+ } formats;
 
 int priv_size; ///< size of private data to allocate for the filter
 
 int flags_internal; ///< Additional flags for avfilter internal use only.
 
 /**
- * Used by the filter registration system. Must not be touched by any other
- * code.
- */
- struct AVFilter *next;
-
- /**
 * Make the filter instance process a command.
 *
 * @param cmd the command to process, for handling simplicity all commands must be alphanumeric only
@@ -306,13 +372,6 @@
 int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
 
 /**
- * Filter initialization function, alternative to the init()
- * callback. Args contains the user-supplied parameters, opaque is
- * used for providing binary data.
- */
- int (*init_opaque)(AVFilterContext *ctx, void *opaque);
-
- /**
 * Filter activation function.
 *
 * Called when any processing is needed from the filter, instead of any
@@ -328,6 +387,11 @@
 } AVFilter;
 
 /**
+ * Get the number of elements in an AVFilter's inputs or outputs array.
+ */
+unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output);
+
+/**
 * Process multiple parts of the frame concurrently.
 */
 #define AVFILTER_THREAD_SLICE (1 << 0)
@@ -425,6 +489,35 @@
 };
 
 /**
+ * Lists of formats / etc. supported by an end of a link.
+ *
+ * This structure is directly part of AVFilterLink, in two copies:
+ * one for the source filter, one for the destination filter.
+
+ * These lists are used for negotiating the format to actually be used,
+ * which will be loaded into the format and channel_layout members of
+ * AVFilterLink, when chosen.
+ */
+typedef struct AVFilterFormatsConfig {
+
+ /**
+ * List of supported formats (pixel or sample).
+ */
+ AVFilterFormats *formats;
+
+ /**
+ * Lists of supported sample rates, only for audio.
+ */
+ AVFilterFormats *samplerates;
+
+ /**
+ * Lists of supported channel layouts, only for audio.
+ */
+ AVFilterChannelLayouts *channel_layouts;
+
+} AVFilterFormatsConfig;
+
+/**
 * A link between two filters. This contains pointers to the source and
 * destination filters between which this link exists, and the indexes of
 * the pads involved. In addition, this link also contains the parameters
@@ -471,33 +564,16 @@
 * New public fields should be added right above.
 *****************************************************************
 */
- /**
- * Lists of formats and channel layouts supported by the input and output
- * filters respectively. These lists are used for negotiating the format
- * to actually be used, which will be loaded into the format and
- * channel_layout members, above, when chosen.
- *
- */
- AVFilterFormats *in_formats;
- AVFilterFormats *out_formats;
 
 /**
- * Lists of channel layouts and sample rates used for automatic
- * negotiation.
+ * Lists of supported formats / etc. supported by the input filter.
 */
- AVFilterFormats *in_samplerates;
- AVFilterFormats *out_samplerates;
- struct AVFilterChannelLayouts *in_channel_layouts;
- struct AVFilterChannelLayouts *out_channel_layouts;
+ AVFilterFormatsConfig incfg;
 
 /**
- * Audio only, the destination filter sets this to a non-zero value to
- * request that buffers with the given number of samples should be sent to
- * it. AVFilterPad.needs_fifo must also be set on the corresponding input
- * pad.
- * Last buffer before EOF will be padded with silence.
+ * Lists of supported formats / etc. supported by the output filter.
 */
- int request_samples;
+ AVFilterFormatsConfig outcfg;
 
 /** stage of the initialization of the link properties (dimensions, etc) */
 enum {
@@ -542,19 +618,8 @@
 AVRational frame_rate;
 
 /**
- * Buffer partially filled with samples to achieve a fixed/minimum size.
- */
- AVFrame *partial_buf;
-
- /**
- * Size of the partial buffer to allocate.
- * Must be between min_samples and max_samples.
- */
- int partial_buf_size;
-
- /**
 * Minimum number of samples to filter at once. If filter_frame() is
- * called with fewer samples, it will accumulate them in partial_buf.
+ * called with fewer samples, it will accumulate them in fifo.
 * This field and the related ones must not be changed after filtering
 * has started.
 * If 0, all related fields are ignored.
@@ -573,14 +638,14 @@
 int channels;
 
 /**
- * Link processing flags.
+ * Number of past frames sent through the link.
 */
- unsigned flags;
+ int64_t frame_count_in, frame_count_out;
 
 /**
- * Number of past frames sent through the link.
+ * Number of past samples sent through the link.
 */
- int64_t frame_count_in, frame_count_out;
+ int64_t sample_count_in, sample_count_out;
 
 /**
 * A pointer to a FFFramePool struct.
@@ -663,23 +728,6 @@
 */
 void avfilter_link_free(AVFilterLink **link);
 
-#if FF_API_FILTER_GET_SET
-/**
- * Get the number of channels of a link.
- * @deprecated Use av_buffersink_get_channels()
- */
-attribute_deprecated
-int avfilter_link_get_channels(AVFilterLink *link);
-#endif
-
-/**
- * Set the closed field of a link.
- * @deprecated applications are not supposed to mess with links, they should
- * close the sinks.
- */
-attribute_deprecated
-void avfilter_link_set_closed(AVFilterLink *link, int closed);
-
 /**
 * Negotiate the media format, dimensions, etc of all inputs to a filter.
 *
@@ -708,33 +756,6 @@
 */
 const AVFilter *av_filter_iterate(void **opaque);
 
-#if FF_API_NEXT
-/** Initialize the filter system. Register all builtin filters. */
-attribute_deprecated
-void avfilter_register_all(void);
-
-/**
- * Register a filter. This is only needed if you plan to use
- * avfilter_get_by_name later to lookup the AVFilter structure by name. A
- * filter can still by instantiated with avfilter_graph_alloc_filter even if it
- * is not registered.
- *
- * @param filter the filter to register
- * @return 0 if the registration was successful, a negative value
- * otherwise
- */
-attribute_deprecated
-int avfilter_register(AVFilter *filter);
-
-/**
- * Iterate over all registered filters.
- * @return If prev is non-NULL, next registered filter after prev or NULL if
- * prev is the last filter. If prev is NULL, return the first registered filter.
- */
-attribute_deprecated
-const AVFilter *avfilter_next(const AVFilter *prev);
-#endif
-
 /**
 * Get a filter definition matching the given name.
 *
@@ -843,9 +864,6 @@
 unsigned nb_filters;
 
 char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters
-#if FF_API_LAVR_OPTS
- attribute_deprecated char *resample_lavr_opts; ///< libavresample options to use for the auto-inserted resample filters
-#endif
 
 /**
 * Type of multithreading allowed for filters in this graph. A combination
@@ -947,7 +965,7 @@
 /**
 * Create and add a filter instance into an existing graph.
 * The filter instance is created from the filter filt and inited
- * with the parameters args and opaque.
+ * with the parameter args. opaque is currently ignored.
 *
 * In case of success put in *filt_ctx the pointer to the created
 * filter instance, otherwise set *filt_ctx to NULL.

gpac-2.0.0.tar.gz/extra_lib/include/libavfilter/buffersink.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavfilter/buffersink.h Changed

@@ -31,6 +31,42 @@
 * @defgroup lavfi_buffersink Buffer sink API
 * @ingroup lavfi
 * @{
+ *
+ * The buffersink and abuffersink filters are there to connect filter graphs
+ * to applications. They have a single input, connected to the graph, and no
+ * output. Frames must be extracted using av_buffersink_get_frame() or
+ * av_buffersink_get_samples().
+ *
+ * The format negotiated by the graph during configuration can be obtained
+ * using the accessor functions:
+ * - av_buffersink_get_time_base(),
+ * - av_buffersink_get_format(),
+ * - av_buffersink_get_frame_rate(),
+ * - av_buffersink_get_w(),
+ * - av_buffersink_get_h(),
+ * - av_buffersink_get_sample_aspect_ratio(),
+ * - av_buffersink_get_channels(),
+ * - av_buffersink_get_channel_layout(),
+ * - av_buffersink_get_sample_rate().
+ *
+ * The format can be constrained by setting options, using av_opt_set() and
+ * related functions with the AV_OPT_SEARCH_CHILDREN flag.
+ * - pix_fmts (int list),
+ * - sample_fmts (int list),
+ * - sample_rates (int list),
+ * - channel_layouts (int64_t),
+ * - channel_counts (int list),
+ * - all_channel_counts (bool).
+ * Most of these options are of type binary, and should be set using
+ * av_opt_set_int_list() or av_opt_set_bin(). If they are not set, all
+ * corresponding formats are accepted.
+ *
+ * As a special case, if neither channel_layouts nor channel_counts is set,
+ * all valid channel layouts are accepted, but channel counts without a
+ * layout are not, unless all_channel_counts is set.
+ * Also, channel_layouts must not contain a channel layout already accepted
+ * by a value in channel_counts; for example, if channel_counts contains 2,
+ * then channel_layouts must not contain stereo.
 */
 
 /**
@@ -59,8 +95,9 @@
 */
 #define AV_BUFFERSINK_FLAG_NO_REQUEST 2
 
+#if FF_API_BUFFERSINK_ALLOC
 /**
- * Struct to use for initializing a buffersink context.
+ * Deprecated and unused struct to use for initializing a buffersink context.
 */
 typedef struct AVBufferSinkParams {
 const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE
@@ -71,10 +108,11 @@
 *
 * Must be freed with av_free().
 */
+attribute_deprecated
 AVBufferSinkParams *av_buffersink_params_alloc(void);
 
 /**
- * Struct to use for initializing an abuffersink context.
+ * Deprecated and unused struct to use for initializing an abuffersink context.
 */
 typedef struct AVABufferSinkParams {
 const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
@@ -89,7 +127,9 @@
 *
 * Must be freed with av_free().
 */
+attribute_deprecated
 AVABufferSinkParams *av_abuffersink_params_alloc(void);
+#endif
 
 /**
 * Set the frame size for an audio buffer sink.
@@ -151,7 +191,7 @@
 * the end of stream, when it can contain less than nb_samples.
 *
 * @return The return codes have the same meaning as for
- * av_buffersink_get_samples().
+ * av_buffersink_get_frame().
 *
 * @warning do not mix this function with av_buffersink_get_frame(). Use only one or
 * the other with a single sink, not both.

gpac-2.0.0.tar.gz/extra_lib/include/libavfilter/buffersrc.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavfilter/buffersrc.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavfilter/version.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavfilter/version.h Changed

@@ -29,10 +29,11 @@
 
 #include "libavutil/version.h"
 
-#define LIBAVFILTER_VERSION_MAJOR 7
-#define LIBAVFILTER_VERSION_MINOR 16
+#define LIBAVFILTER_VERSION_MAJOR 8
+#define LIBAVFILTER_VERSION_MINOR 24
 #define LIBAVFILTER_VERSION_MICRO 100
 
+
 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
 LIBAVFILTER_VERSION_MINOR, \
 LIBAVFILTER_VERSION_MICRO)
@@ -49,17 +50,8 @@
 * the public API and may change, break or disappear at any time.
 */
 
-#ifndef FF_API_OLD_FILTER_OPTS_ERROR
-#define FF_API_OLD_FILTER_OPTS_ERROR (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
-#ifndef FF_API_LAVR_OPTS
-#define FF_API_LAVR_OPTS (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
-#ifndef FF_API_FILTER_GET_SET
-#define FF_API_FILTER_GET_SET (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
-#ifndef FF_API_NEXT
-#define FF_API_NEXT (LIBAVFILTER_VERSION_MAJOR < 8)
-#endif
+#define FF_API_SWS_PARAM_OPTION (LIBAVFILTER_VERSION_MAJOR < 9)
+#define FF_API_BUFFERSINK_ALLOC (LIBAVFILTER_VERSION_MAJOR < 9)
+#define FF_API_PAD_COUNT (LIBAVFILTER_VERSION_MAJOR < 9)
 
 #endif /* AVFILTER_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavformat/avformat.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavformat/avformat.h Changed

@@ -36,17 +36,15 @@
 * into component streams, and the reverse process of muxing - writing supplied
 * data in a specified container format. It also has an @ref lavf_io
 * "I/O module" which supports a number of protocols for accessing the data (e.g.
- * file, tcp, http and others). Before using lavf, you need to call
- * av_register_all() to register all compiled muxers, demuxers and protocols.
+ * file, tcp, http and others).
 * Unless you are absolutely sure you won't use libavformat's network
 * capabilities, you should also call avformat_network_init().
 *
 * A supported input format is described by an AVInputFormat struct, conversely
 * an output format is described by AVOutputFormat. You can iterate over all
- * registered input/output formats using the av_iformat_next() /
- * av_oformat_next() functions. The protocols layer is not part of the public
- * API, so you can only get the names of supported protocols with the
- * avio_enum_protocols() function.
+ * input/output formats using the av_demuxer_iterate / av_muxer_iterate() functions.
+ * The protocols layer is not part of the public API, so you can only get the names
+ * of supported protocols with the avio_enum_protocols() function.
 *
 * Main lavf structure used for both muxing and demuxing is AVFormatContext,
 * which exports all information about the file being read or written. As with
@@ -172,14 +170,9 @@
 * information will be in AVStream.time_base units, i.e. it has to be
 * multiplied by the timebase to convert them to seconds.
 *
- * If AVPacket.buf is set on the returned packet, then the packet is
- * allocated dynamically and the user may keep it indefinitely.
- * Otherwise, if AVPacket.buf is NULL, the packet data is backed by a
- * static storage somewhere inside the demuxer and the packet is only valid
- * until the next av_read_frame() call or closing the file. If the caller
- * requires a longer lifetime, av_dup_packet() will make an av_malloc()ed copy
- * of it.
- * In both cases, the packet must be freed with av_packet_unref() when it is no
+ * A packet returned by av_read_frame() is always reference-counted,
+ * i.e. AVPacket.buf is set and the user may keep it indefinitely.
+ * The packet must be freed with av_packet_unref() when it is no
 * longer needed.
 *
 * @section lavf_decoding_seek Seeking
@@ -316,7 +309,12 @@
 
 #include <time.h>
 #include <stdio.h> /* FILE */
-#include "libavcodec/avcodec.h"
+
+#include "libavcodec/codec.h"
+#include "libavcodec/codec_par.h"
+#include "libavcodec/defs.h"
+#include "libavcodec/packet.h"
+
 #include "libavutil/dict.h"
 #include "libavutil/log.h"
 
@@ -324,6 +322,7 @@
 #include "libavformat/version.h"
 
 struct AVFormatContext;
+struct AVStream;
 
 struct AVDeviceInfoList;
 struct AVDeviceCapabilitiesQuery;
@@ -363,7 +362,7 @@
 * sorting will have '-sort' appended. E.g. artist="The Beatles",
 * artist-sort="Beatles, The".
 * - Some protocols and demuxers support metadata updates. After a successful
- * call to av_read_packet(), AVFormatContext.event_flags or AVStream.event_flags
+ * call to av_read_frame(), AVFormatContext.event_flags or AVStream.event_flags
 * will be updated to indicate if metadata changed. In order to detect metadata
 * changes on a stream, you need to loop through all streams in the AVFormatContext
 * and check their individual event_flags.
@@ -464,6 +463,13 @@
 /// Demuxer will use avio_open, no opened file should be provided by the caller.
 #define AVFMT_NOFILE 0x0001
 #define AVFMT_NEEDNUMBER 0x0002 /**< Needs '%d' in filename. */
+/**
+ * The muxer/demuxer is experimental and should be used with caution.
+ *
+ * - demuxers: will not be selected automatically by probing, must be specified
+ * explicitly.
+ */
+#define AVFMT_EXPERIMENTAL 0x0004
 #define AVFMT_SHOW_IDS 0x0008 /**< Show format stream IDs numbers. */
 #define AVFMT_GLOBALHEADER 0x0040 /**< Format wants global header. */
 #define AVFMT_NOTIMESTAMPS 0x0080 /**< Format does not need / have any timestamps. */
@@ -532,12 +538,16 @@
 * New public fields should be added right above.
 *****************************************************************
 */
- struct AVOutputFormat *next;
 /**
 * size of private data so that it can be allocated in the wrapper
 */
 int priv_data_size;
 
+ /**
+ * Internal flags. See FF_FMT_FLAG_* in internal.h.
+ */
+ int flags_internal;
+
 int (*write_header)(struct AVFormatContext *);
 /**
 * Write a packet. If AVFMT_ALLOW_FLUSH is set in flags,
@@ -549,10 +559,23 @@
 int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);
 int (*write_trailer)(struct AVFormatContext *);
 /**
- * Currently only used to set pixel format if not YUV420P.
+ * A format-specific function for interleavement.
+ * If unset, packets will be interleaved by dts.
+ *
+ * @param s An AVFormatContext for output. pkt will be added to
+ * resp. taken from its packet buffer.
+ * @paramin,out pkt A packet to be interleaved if has_packet is set;
+ * also used to return packets. If no packet is returned
+ * (e.g. on error), pkt is blank on return.
+ * @param flush 1 if no further packets are available as input and
+ * all remaining packets should be output.
+ * @param has_packet If set, pkt contains a packet to be interleaved
+ * on input; otherwise pkt is blank on input.
+ * @return 1 if a packet was output, 0 if no packet could be output,
+ * < 0 if an error occurred
 */
- int (*interleave_packet)(struct AVFormatContext *, AVPacket *out,
- AVPacket *in, int flush);
+ int (*interleave_packet)(struct AVFormatContext *s, AVPacket *pkt,
+ int flush, int has_packet);
 /**
 * Test if the given codec can be stored in this container.
 *
@@ -585,16 +608,6 @@
 * @see avdevice_list_devices() for more details.
 */
 int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
- /**
- * Initialize device capabilities submodule.
- * @see avdevice_capabilities_create() for more details.
- */
- int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
- /**
- * Free device capabilities submodule.
- * @see avdevice_capabilities_free() for more details.
- */
- int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
 enum AVCodecID data_codec; /**< default data codec */
 /**
 * Initialize format. May allocate data here, and set any AVFormatContext or
@@ -618,9 +631,13 @@
 /**
 * Set up any necessary bitstream filtering and extract any extra data needed
 * for the global header.
+ *
+ * @note pkt might have been directly forwarded by a meta-muxer; therefore
+ * pkt->stream_index as well as the pkt's timebase might be invalid.
 * Return 0 if more packets from this stream must be checked; 1 if not.
 */
- int (*check_bitstream)(struct AVFormatContext *, const AVPacket *pkt);
+ int (*check_bitstream)(struct AVFormatContext *s, struct AVStream *st,
+ const AVPacket *pkt);
 } AVOutputFormat;
 /**
 * @}
@@ -646,7 +663,7 @@
 
 /**
 * Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS,
- * AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH,
+ * AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH,
 * AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
 */
 int flags;
@@ -676,8 +693,6 @@
 * New public fields should be added right above.
 *****************************************************************
 */
- struct AVInputFormat *next;
-
 /**
 * Raw demuxers store their codec ID here.
 */
@@ -689,11 +704,16 @@
 int priv_data_size;
 
 /**
+ * Internal flags. See FF_FMT_FLAG_* in internal.h.
+ */
+ int flags_internal;
+
+ /**
 * Tell if a given file has a chance of being parsed as this format.
 * The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes
 * big so you do not have to check for that unless you need more.
 */
- int (*read_probe)(AVProbeData *);
+ int (*read_probe)(const AVProbeData *);
 
 /**
 * Read the format header and initialize the AVFormatContext
@@ -708,8 +728,7 @@
 * AVFMTCTX_NOHEADER is used and only in the calling thread (not in a
 * background thread).
 * @return 0 on success, < 0 on error.
- * When returning an error, pkt must not have been allocated
- * or must be freed before returning
+ * Upon returning an error, pkt must be unreferenced by the caller.
 */
 int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
 
@@ -763,17 +782,6 @@
 */
 int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
 
- /**
- * Initialize device capabilities submodule.
- * @see avdevice_capabilities_create() for more details.
- */
- int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
-
- /**
- * Free device capabilities submodule.
- * @see avdevice_capabilities_free() for more details.
- */
- int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
 } AVInputFormat;
 /**
 * @}
@@ -807,22 +815,56 @@
 int min_distance; /**< Minimum distance between this and the previous keyframe, used to avoid unneeded searching. */
 } AVIndexEntry;
 
-#define AV_DISPOSITION_DEFAULT 0x0001
-#define AV_DISPOSITION_DUB 0x0002
-#define AV_DISPOSITION_ORIGINAL 0x0004
-#define AV_DISPOSITION_COMMENT 0x0008
-#define AV_DISPOSITION_LYRICS 0x0010
-#define AV_DISPOSITION_KARAOKE 0x0020
+/**
+ * The stream should be chosen by default among other streams of the same type,
+ * unless the user has explicitly specified otherwise.
+ */
+#define AV_DISPOSITION_DEFAULT (1 << 0)
+/**
+ * The stream is not in original language.
+ *
+ * @note AV_DISPOSITION_ORIGINAL is the inverse of this disposition. At most
+ * one of them should be set in properly tagged streams.
+ * @note This disposition may apply to any stream type, not just audio.
+ */
+#define AV_DISPOSITION_DUB (1 << 1)
+/**
+ * The stream is in original language.
+ *
+ * @see the notes for AV_DISPOSITION_DUB
+ */
+#define AV_DISPOSITION_ORIGINAL (1 << 2)
+/**
+ * The stream is a commentary track.
+ */
+#define AV_DISPOSITION_COMMENT (1 << 3)
+/**
+ * The stream contains song lyrics.
+ */
+#define AV_DISPOSITION_LYRICS (1 << 4)
+/**
+ * The stream contains karaoke audio.
+ */
+#define AV_DISPOSITION_KARAOKE (1 << 5)
 
 /**
 * Track should be used during playback by default.
 * Useful for subtitle track that should be displayed
 * even when user did not explicitly ask for subtitles.
 */
-#define AV_DISPOSITION_FORCED 0x0040
-#define AV_DISPOSITION_HEARING_IMPAIRED 0x0080 /**< stream for hearing impaired audiences */
-#define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100 /**< stream for visual impaired audiences */
-#define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /**< stream without voice */
+#define AV_DISPOSITION_FORCED (1 << 6)
+/**
+ * The stream is intended for hearing impaired audiences.
+ */
+#define AV_DISPOSITION_HEARING_IMPAIRED (1 << 7)
+/**
+ * The stream is intended for visually impaired audiences.
+ */
+#define AV_DISPOSITION_VISUAL_IMPAIRED (1 << 8)
+/**
+ * The audio stream contains music and sound effects without voice.
+ */
+#define AV_DISPOSITION_CLEAN_EFFECTS (1 << 9)
 /**
 * The stream is stored in the file as an attached picture/"cover art" (e.g.
 * APIC frame in ID3v2). The first (usually only) packet associated with it
@@ -830,22 +872,53 @@
 * seeking takes place. It can also be accessed at any time in
 * AVStream.attached_pic.
 */
-#define AV_DISPOSITION_ATTACHED_PIC 0x0400
+#define AV_DISPOSITION_ATTACHED_PIC (1 << 10)
 /**
 * The stream is sparse, and contains thumbnail images, often corresponding
 * to chapter markers. Only ever used with AV_DISPOSITION_ATTACHED_PIC.
 */
-#define AV_DISPOSITION_TIMED_THUMBNAILS 0x0800
+#define AV_DISPOSITION_TIMED_THUMBNAILS (1 << 11)
+
+/**
+ * The subtitle stream contains captions, providing a transcription and possibly
+ * a translation of audio. Typically intended for hearing-impaired audiences.
+ */
+#define AV_DISPOSITION_CAPTIONS (1 << 16)
+/**
+ * The subtitle stream contains a textual description of the video content.
+ * Typically intended for visually-impaired audiences or for the cases where the
+ * video cannot be seen.
+ */
+#define AV_DISPOSITION_DESCRIPTIONS (1 << 17)
+/**
+ * The subtitle stream contains time-aligned metadata that is not intended to be
+ * directly presented to the user.
+ */
+#define AV_DISPOSITION_METADATA (1 << 18)
+/**
+ * The audio stream is intended to be mixed with another stream before
+ * presentation.
+ * Corresponds to mix_type=0 in mpegts.
+ */
+#define AV_DISPOSITION_DEPENDENT (1 << 19)
+/**
+ * The video stream contains still images.
+ */
+#define AV_DISPOSITION_STILL_IMAGE (1 << 20)
 
-typedef struct AVStreamInternal AVStreamInternal;
+/**
+ * @return The AV_DISPOSITION_* flag corresponding to disp or a negative error
+ * code if disp does not correspond to a known stream disposition.
+ */
+int av_disposition_from_string(const char *disp);
 
 /**
- * To specify text track kind (different from subtitles default).
+ * @param disposition a combination of AV_DISPOSITION_* values
+ * @return The string description corresponding to the lowest set bit in
+ * disposition. NULL when the lowest set bit does not correspond
+ * to a known disposition or when disposition is 0.
 */
-#define AV_DISPOSITION_CAPTIONS 0x10000
-#define AV_DISPOSITION_DESCRIPTIONS 0x20000
-#define AV_DISPOSITION_METADATA 0x40000
-#define AV_DISPOSITION_DEPENDENT 0x80000 ///< dependent audio stream (mix_type=0 in mpegts)
+const char *av_disposition_to_string(int disposition);
 
 /**
 * Options for behavior on timestamp wrap detection.
@@ -862,6 +935,13 @@
 * sizeof(AVStream) must not be used outside libav*.
 */
 typedef struct AVStream {
+#if FF_API_AVSTREAM_CLASS
+ /**
+ * A class for @ref avoptions. Set on stream creation.
+ */
+ const AVClass *av_class;
+#endif
+
 int index; /**< stream index in AVFormatContext */
 /**
 * Format-specific stream ID.
@@ -869,13 +949,7 @@
 * encoding: set by the user, replaced by libavformat if left unset
 */
 int id;
-#if FF_API_LAVF_AVCTX
- /**
- * @deprecated use the codecpar struct instead
- */
- attribute_deprecated
- AVCodecContext *codec;
-#endif
+
 void *priv_data;
 
 /**
@@ -914,7 +988,13 @@
 
 int64_t nb_frames; ///< number of frames in this stream if known or 0
 
- int disposition; /**< AV_DISPOSITION_* bit field */
+ /**
+ * Stream disposition - a combination of AV_DISPOSITION_* flags.
+ * - demuxing: set by libavformat when creating the stream or in
+ * avformat_find_stream_info().
+ * - muxing: may be set by the caller before avformat_write_header().
+ */
+ int disposition;
 
 enum AVDiscard discard; ///< Selects which packets can be discarded at will and do not need to be demuxed.
 
@@ -970,12 +1050,30 @@
 int nb_side_data;
 
 /**
- * Flags for the user to detect events happening on the stream. Flags must
- * be cleared by the user once the event has been handled.
- * A combination of AVSTREAM_EVENT_FLAG_*.
+ * Flags indicating events happening on the stream, a combination of
+ * AVSTREAM_EVENT_FLAG_*.
+ *
+ * - demuxing: may be set by the demuxer in avformat_open_input(),
+ * avformat_find_stream_info() and av_read_frame(). Flags must be cleared
+ * by the user once the event has been handled.
+ * - muxing: may be set by the user after avformat_write_header(). to
+ * indicate a user-triggered event. The muxer will clear the flags for
+ * events it has handled in av_interleaved_write_frame().
 */
 int event_flags;
-#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001 ///< The call resulted in updated metadata.
+/**
+ * - demuxing: the demuxer read new metadata from the file and updated
+ * AVStream.metadata accordingly
+ * - muxing: the user updated AVStream.metadata and wishes the muxer to write
+ * it into the file
+ */
+#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001
+/**
+ * - demuxing: new packets for this stream were read from the file. This
+ * event is informational only and does not guarantee that new packets
+ * for this stream will necessarily be returned from av_read_frame().
+ */
+#define AVSTREAM_EVENT_FLAG_NEW_PACKETS (1 << 1)
 
 /**
 * Real base framerate of the stream.
@@ -987,18 +1085,6 @@
 */
 AVRational r_frame_rate;
 
-#if FF_API_LAVF_FFSERVER
- /**
- * String containing pairs of key and values describing recommended encoder configuration.
- * Pairs are separated by ','.
- * Keys are separated from values by '='.
- *
- * @deprecated unused
- */
- attribute_deprecated
- char *recommended_encoder_configuration;
-#endif
-
 /**
 * Codec parameters associated with this stream. Allocated and freed by
 * libavformat in avformat_new_stream() and avformat_free_context()
@@ -1010,227 +1096,16 @@
 */
 AVCodecParameters *codecpar;
 
- /*****************************************************************
- * All fields below this line are not part of the public API. They
- * may not be used outside of libavformat and can be changed and
- * removed at will.
- * Internal note: be aware that physically removing these fields
- * will break ABI. Replace removed fields with dummy fields, and
- * add new fields to AVStreamInternal.
- *****************************************************************
- */
-
-#define MAX_STD_TIMEBASES (30*12+30+3+6)
- /**
- * Stream information used internally by avformat_find_stream_info()
- */
- struct {
- int64_t last_dts;
- int64_t duration_gcd;
- int duration_count;
- int64_t rfps_duration_sum;
- double (*duration_error)2MAX_STD_TIMEBASES;
- int64_t codec_info_duration;
- int64_t codec_info_duration_fields;
- int frame_delay_evidence;
-
- /**
- * 0 -> decoder has not been searched for yet.
- * >0 -> decoder found
- * <0 -> decoder with codec_id == -found_decoder has not been found
- */
- int found_decoder;
-
- int64_t last_duration;
-
- /**
- * Those are used for average framerate estimation.
- */
- int64_t fps_first_dts;
- int fps_first_dts_idx;
- int64_t fps_last_dts;
- int fps_last_dts_idx;
-
- } *info;
-
- int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
-
- // Timestamp generation support:
 /**
- * Timestamp corresponding to the last dts sync point.
+ * Number of bits in timestamps. Used for wrapping control.
 *
- * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
- * a DTS is received from the underlying container. Otherwise set to
- * AV_NOPTS_VALUE by default.
- */
- int64_t first_dts;
- int64_t cur_dts;
- int64_t last_IP_pts;
- int last_IP_duration;
-
- /**
- * Number of packets to buffer for codec probing
- */
- int probe_packets;
-
- /**
- * Number of frames that have been demuxed during avformat_find_stream_info()
- */
- int codec_info_nb_frames;
-
- /* av_read_frame() support */
- enum AVStreamParseType need_parsing;
- struct AVCodecParserContext *parser;
-
- /**
- * last packet in packet_buffer for this stream when muxing.
- */
- struct AVPacketList *last_in_packet_buffer;
- AVProbeData probe_data;
-#define MAX_REORDER_DELAY 16
- int64_t pts_bufferMAX_REORDER_DELAY+1;
-
- AVIndexEntry *index_entries; /**< Only used if the format does not
- support seeking natively. */
- int nb_index_entries;
- unsigned int index_entries_allocated_size;
-
- /**
- * Stream Identifier
- * This is the MPEG-TS stream identifier +1
- * 0 means unknown
- */
- int stream_identifier;
-
- int64_t interleaver_chunk_size;
- int64_t interleaver_chunk_duration;
-
- /**
- * stream probing state
- * -1 -> probing finished
- * 0 -> no probing requested
- * rest -> perform probing with request_probe being the minimum score to accept.
- * NOT PART OF PUBLIC API
- */
- int request_probe;
- /**
- * Indicates that everything up to the next keyframe
- * should be discarded.
- */
- int skip_to_keyframe;
-
- /**
- * Number of samples to skip at the start of the frame decoded from the next packet.
- */
- int skip_samples;
-
- /**
- * If not 0, the number of samples that should be skipped from the start of
- * the stream (the samples are removed from packets with pts==0, which also
- * assumes negative timestamps do not happen).
- * Intended for use with formats such as mp3 with ad-hoc gapless audio
- * support.
- */
- int64_t start_skip_samples;
-
- /**
- * If not 0, the first audio sample that should be discarded from the stream.
- * This is broken by design (needs global sample count), but can't be
- * avoided for broken by design formats such as mp3 with ad-hoc gapless
- * audio support.
- */
- int64_t first_discard_sample;
-
- /**
- * The sample after last sample that is intended to be discarded after
- * first_discard_sample. Works on frame boundaries only. Used to prevent
- * early EOF if the gapless info is broken (considered concatenated mp3s).
- */
- int64_t last_discard_sample;
-
- /**
- * Number of internally decoded frames, used internally in libavformat, do not access
- * its lifetime differs from info which is why it is not in that structure.
- */
- int nb_decoded_frames;
-
- /**
- * Timestamp offset added to timestamps before muxing
- * NOT PART OF PUBLIC API
- */
- int64_t mux_ts_offset;
-
- /**
- * Internal data to check for wrapping of the time stamp
- */
- int64_t pts_wrap_reference;
-
- /**
- * Options for behavior, when a wrap is detected.
- *
- * Defined by AV_PTS_WRAP_ values.
+ * - demuxing: set by libavformat
+ * - muxing: set by libavformat
 *
- * If correction is enabled, there are two possibilities:
- * If the first time stamp is near the wrap point, the wrap offset
- * will be subtracted, which will create negative time stamps.
- * Otherwise the offset will be added.
- */
- int pts_wrap_behavior;
-
- /**
- * Internal data to prevent doing update_initial_durations() twice
- */
- int update_initial_durations_done;
-
- /**
- * Internal data to generate dts from pts
- */
- int64_t pts_reorder_errorMAX_REORDER_DELAY+1;
- uint8_t pts_reorder_error_countMAX_REORDER_DELAY+1;
-
- /**
- * Internal data to analyze DTS and detect faulty mpeg streams
- */
- int64_t last_dts_for_order_check;
- uint8_t dts_ordered;
- uint8_t dts_misordered;
-
- /**
- * Internal data to inject global side data
- */
- int inject_global_side_data;
-
- /**
- * display aspect ratio (0 if unknown)
- * - encoding: unused
- * - decoding: Set by libavformat to calculate sample_aspect_ratio internally
- */
- AVRational display_aspect_ratio;
-
- /**
- * An opaque field for libavformat internal usage.
- * Must not be accessed in any way by callers.
 */
- AVStreamInternal *internal;
+ int pts_wrap_bits;
 } AVStream;
 
-#if FF_API_FORMAT_GET_SET
-/**
- * Accessors for some AVStream fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-AVRational av_stream_get_r_frame_rate(const AVStream *s);
-attribute_deprecated
-void av_stream_set_r_frame_rate(AVStream *s, AVRational r);
-#if FF_API_LAVF_FFSERVER
-attribute_deprecated
-char* av_stream_get_recommended_encoder_configuration(const AVStream *s);
-attribute_deprecated
-void av_stream_set_recommended_encoder_configuration(AVStream *s, char *configuration);
-#endif
-#endif
-
 struct AVCodecParserContext *av_stream_get_parser(const AVStream *s);
 
 /**
@@ -1259,6 +1134,7 @@
 int program_num;
 int pmt_pid;
 int pcr_pid;
+ int pmt_version;
 
 /*****************************************************************
 * All fields below this line are not part of the public API. They
@@ -1283,7 +1159,7 @@
 change dynamically at runtime. */
 
 typedef struct AVChapter {
- int id; ///< unique ID to identify the chapter
+ int64_t id; ///< unique ID to identify the chapter
 AVRational time_base; ///< time base in which the start/end timestamps are specified
 int64_t start, end; ///< chapter start/end time in time_base units
 AVDictionary *metadata;
@@ -1309,8 +1185,6 @@
 AVFMT_DURATION_FROM_BITRATE ///< Duration estimated from bitrate (less accurate)
 };
 
-typedef struct AVFormatInternal AVFormatInternal;
-
 /**
 * Format I/O context.
 * New fields can be added to the end with minor version bumps.
@@ -1337,14 +1211,14 @@
 *
 * Demuxing only, set by avformat_open_input().
 */
- struct AVInputFormat *iformat;
+ const struct AVInputFormat *iformat;
 
 /**
 * The output container format.
 *
 * Muxing only, must be set by the caller before avformat_write_header().
 */
- struct AVOutputFormat *oformat;
+ const struct AVOutputFormat *oformat;
 
 /**
 * Format private data. This is an AVOptions-enabled struct
@@ -1395,19 +1269,6 @@
 */
 AVStream **streams;
 
-#if FF_API_FORMAT_FILENAME
- /**
- * input or output filename
- *
- * - demuxing: set by avformat_open_input()
- * - muxing: may be set by the caller before avformat_write_header()
- *
- * @deprecated Use url instead.
- */
- attribute_deprecated
- char filename1024;
-#endif
-
 /**
 * input or output URL. Unlike the old filename field, this field has no
 * length restriction.
@@ -1474,20 +1335,24 @@
 * This flag is mainly intended for testing.
 */
 #define AVFMT_FLAG_BITEXACT 0x0400
-#define AVFMT_FLAG_MP4A_LATM 0x8000 ///< Enable RTP MP4A-LATM payload
 #define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
-#define AVFMT_FLAG_PRIV_OPT 0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
-#if FF_API_LAVF_KEEPSIDE_FLAG
-#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Deprecated, does nothing.
+#if FF_API_LAVF_PRIV_OPT
+#define AVFMT_FLAG_PRIV_OPT 0x20000 ///< Enable use of private options by delaying codec open (deprecated, does nothing)
 #endif
 #define AVFMT_FLAG_FAST_SEEK 0x80000 ///< Enable fast, but inaccurate seeks for some formats
 #define AVFMT_FLAG_SHORTEST 0x100000 ///< Stop muxing when the shortest stream stops.
 #define AVFMT_FLAG_AUTO_BSF 0x200000 ///< Add bitstream filters as requested by the muxer
 
 /**
- * Maximum size of the data read from input for determining
- * the input container format.
+ * Maximum number of bytes read from input in order to determine stream
+ * properties. Used when reading the global header and in
+ * avformat_find_stream_info().
+ *
 * Demuxing only, set by the caller before avformat_open_input().
+ *
+ * @note this is \e not used for determining the \ref AVInputFormat
+ * "input format"
+ * @sa format_probesize
 */
 int64_t probesize;
 
@@ -1634,12 +1499,24 @@
 int strict_std_compliance;
 
 /**
- * Flags for the user to detect events happening on the file. Flags must
- * be cleared by the user once the event has been handled.
- * A combination of AVFMT_EVENT_FLAG_*.
+ * Flags indicating events happening on the file, a combination of
+ * AVFMT_EVENT_FLAG_*.
+ *
+ * - demuxing: may be set by the demuxer in avformat_open_input(),
+ * avformat_find_stream_info() and av_read_frame(). Flags must be cleared
+ * by the user once the event has been handled.
+ * - muxing: may be set by the user after avformat_write_header() to
+ * indicate a user-triggered event. The muxer will clear the flags for
+ * events it has handled in av_interleaved_write_frame().
 */
 int event_flags;
-#define AVFMT_EVENT_FLAG_METADATA_UPDATED 0x0001 ///< The call resulted in updated metadata.
+/**
+ * - demuxing: the demuxer read new metadata from the file and updated
+ * AVFormatContext.metadata accordingly
+ * - muxing: the user updated AVFormatContext.metadata and wishes the muxer to
+ * write it into the file
+ */
+#define AVFMT_EVENT_FLAG_METADATA_UPDATED 0x0001
 
 /**
 * Maximum number of packets to read while waiting for the first timestamp.
@@ -1750,9 +1627,13 @@
 int probe_score;
 
 /**
- * number of bytes to read maximally to identify format.
- * - encoding: unused
- * - decoding: set by user
+ * Maximum number of bytes read from input in order to identify the
+ * \ref AVInputFormat "input format". Only used when the format is not set
+ * explicitly by the caller.
+ *
+ * Demuxing only, set by the caller before avformat_open_input().
+ *
+ * @sa probesize
 */
 int format_probesize;
 
@@ -1773,12 +1654,6 @@
 char *format_whitelist;
 
 /**
- * An opaque field for libavformat internal usage.
- * Must not be accessed in any way by callers.
- */
- AVFormatInternal *internal;
-
- /**
 * IO repositioned flag.
 * This is set by avformat when the underlaying IO context read pointer
 * is repositioned, for example when doing byte based seeking.
@@ -1792,7 +1667,7 @@
 * the same codec_id.
 * Demuxing: Set by user
 */
- AVCodec *video_codec;
+ const AVCodec *video_codec;
 
 /**
 * Forced audio codec.
@@ -1800,7 +1675,7 @@
 * the same codec_id.
 * Demuxing: Set by user
 */
- AVCodec *audio_codec;
+ const AVCodec *audio_codec;
 
 /**
 * Forced subtitle codec.
@@ -1808,7 +1683,7 @@
 * the same codec_id.
 * Demuxing: Set by user
 */
- AVCodec *subtitle_codec;
+ const AVCodec *subtitle_codec;
 
 /**
 * Forced data codec.
@@ -1816,7 +1691,7 @@
 * the same codec_id.
 * Demuxing: Set by user
 */
- AVCodec *data_codec;
+ const AVCodec *data_codec;
 
 /**
 * Number of bytes to be written as padding in a metadata header.
@@ -1856,28 +1731,6 @@
 */
 enum AVCodecID data_codec_id;
 
-#if FF_API_OLD_OPEN_CALLBACKS
- /**
- * Called to open further IO contexts when needed for demuxing.
- *
- * This can be set by the user application to perform security checks on
- * the URLs before opening them.
- * The function should behave like avio_open2(), AVFormatContext is provided
- * as contextual information and to reach AVFormatContext.opaque.
- *
- * If NULL then some simple checks are used together with avio_open2().
- *
- * Must not be accessed directly from outside avformat.
- * @See av_format_set_open_cb()
- *
- * Demuxing: Set by user.
- *
- * @deprecated Use io_open and io_close.
- */
- attribute_deprecated
- int (*open_cb)(struct AVFormatContext *s, AVIOContext **p, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options);
-#endif
-
 /**
 * ',' separated list of allowed protocols.
 * - encoding: unused
@@ -1926,48 +1779,34 @@
 * - decoding: set by user
 */
 int max_streams;
-} AVFormatContext;
 
-#if FF_API_FORMAT_GET_SET
-/**
- * Accessors for some AVFormatContext fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-int av_format_get_probe_score(const AVFormatContext *s);
-attribute_deprecated
-AVCodec * av_format_get_video_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_video_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-AVCodec * av_format_get_audio_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_audio_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-AVCodec * av_format_get_subtitle_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-AVCodec * av_format_get_data_codec(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_data_codec(AVFormatContext *s, AVCodec *c);
-attribute_deprecated
-int av_format_get_metadata_header_padding(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_metadata_header_padding(AVFormatContext *s, int c);
-attribute_deprecated
-void * av_format_get_opaque(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_opaque(AVFormatContext *s, void *opaque);
-attribute_deprecated
-av_format_control_message av_format_get_control_message_cb(const AVFormatContext *s);
-attribute_deprecated
-void av_format_set_control_message_cb(AVFormatContext *s, av_format_control_message callback);
-#if FF_API_OLD_OPEN_CALLBACKS
-attribute_deprecated AVOpenCallback av_format_get_open_cb(const AVFormatContext *s);
-attribute_deprecated void av_format_set_open_cb(AVFormatContext *s, AVOpenCallback callback);
-#endif
-#endif
+ /**
+ * Skip duration calcuation in estimate_timings_from_pts.
+ * - encoding: unused
+ * - decoding: set by user
+ */
+ int skip_estimate_duration_from_pts;
+
+ /**
+ * Maximum number of packets that can be probed
+ * - encoding: unused
+ * - decoding: set by user
+ */
+ int max_probe_packets;
+
+ /**
+ * A callback for closing the streams opened with AVFormatContext.io_open().
+ *
+ * Using this is preferred over io_close, because this can return an error.
+ * Therefore this callback is used instead of io_close by the generic
+ * libavformat code if io_close is NULL or the default.
+ *
+ * @param s the format context
+ * @param pb IO context to be closed and freed
+ * @return 0 on success, a negative AVERROR code on failure
+ */
+ int (*io_close2)(struct AVFormatContext *s, AVIOContext *pb);
+} AVFormatContext;
 
 /**
 * This function will cause global side data to be injected in the next packet
@@ -1982,12 +1821,6 @@
 */
 enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method(const AVFormatContext* ctx);
 
-typedef struct AVPacketList {
- AVPacket pkt;
- struct AVPacketList *next;
-} AVPacketList;
-
-
 /**
 * @defgroup lavf_core Core functions
 * @ingroup libavf
@@ -2012,24 +1845,6 @@
 */
 const char *avformat_license(void);
 
-#if FF_API_NEXT
-/**
- * Initialize libavformat and register all the muxers, demuxers and
- * protocols. If you do not call this function, then you can select
- * exactly which formats you want to support.
- *
- * @see av_register_input_format()
- * @see av_register_output_format()
- */
-attribute_deprecated
-void av_register_all(void);
-
-attribute_deprecated
-void av_register_input_format(AVInputFormat *format);
-attribute_deprecated
-void av_register_output_format(AVOutputFormat *format);
-#endif
-
 /**
 * Do global initialization of network libraries. This is optional,
 * and not recommended anymore.
@@ -2052,24 +1867,6 @@
 */
 int avformat_network_deinit(void);
 
-#if FF_API_NEXT
-/**
- * If f is NULL, returns the first registered input format,
- * if f is non-NULL, returns the next registered input format after f
- * or NULL if f is the last one.
- */
-attribute_deprecated
-AVInputFormat *av_iformat_next(const AVInputFormat *f);
-
-/**
- * If f is NULL, returns the first registered output format,
- * if f is non-NULL, returns the next registered output format after f
- * or NULL if f is the last one.
- */
-attribute_deprecated
-AVOutputFormat *av_oformat_next(const AVOutputFormat *f);
-#endif
-
 /**
 * Iterate over all registered muxers.
 *
@@ -2114,6 +1911,14 @@
 const AVClass *avformat_get_class(void);
 
 /**
+ * Get the AVClass for AVStream. It can be used in combination with
+ * AV_OPT_SEARCH_FAKE_OBJ for examining options.
+ *
+ * @see av_opt_find().
+ */
+const AVClass *av_stream_get_class(void);
+
+/**
 * Add a new stream to a media file.
 *
 * When demuxing, it is called by the demuxer in read_header(). If the
@@ -2122,13 +1927,11 @@
 *
 * When muxing, should be called by the user before avformat_write_header().
 *
- * User is required to call avcodec_close() and avformat_free_context() to
- * clean up the allocation by avformat_new_stream().
+ * User is required to call avformat_free_context() to clean up the allocation
+ * by avformat_new_stream().
 *
 * @param s media file handle
- * @param c If non-NULL, the AVCodecContext corresponding to the new stream
- * will be initialized to use this codec. This is needed for e.g. codec-specific
- * defaults to be set, so codec should be provided if it is known.
+ * @param c unused, does nothing
 *
 * @return newly created stream or NULL on error.
 */
@@ -2158,17 +1961,18 @@
 * @return pointer to fresh allocated data or NULL otherwise
 */
 uint8_t *av_stream_new_side_data(AVStream *stream,
- enum AVPacketSideDataType type, int size);
+ enum AVPacketSideDataType type, size_t size);
 /**
 * Get side information from stream.
 *
 * @param stream stream
 * @param type desired side information type
- * @param size pointer for side information size to store (optional)
+ * @param size If supplied, *size will be set to the size of the side data
+ * or to zero if the desired side data is not present.
 * @return pointer to data if present or NULL otherwise
 */
 uint8_t *av_stream_get_side_data(const AVStream *stream,
- enum AVPacketSideDataType type, int *size);
+ enum AVPacketSideDataType type, size_t *size);
 
 AVProgram *av_new_program(AVFormatContext *s, int id);
 
@@ -2193,7 +1997,7 @@
 * @return >= 0 in case of success, a negative AVERROR code in case of
 * failure
 */
-int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat,
+int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat,
 const char *format_name, const char *filename);
 
 /**
@@ -2204,7 +2008,7 @@
 /**
 * Find AVInputFormat based on the short name of the input format.
 */
-AVInputFormat *av_find_input_format(const char *short_name);
+const AVInputFormat *av_find_input_format(const char *short_name);
 
 /**
 * Guess the file format.
@@ -2213,7 +2017,7 @@
 * @param is_opened Whether the file is already opened; determines whether
 * demuxers with or without AVFMT_NOFILE are probed.
 */
-AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);
+const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened);
 
 /**
 * Guess the file format.
@@ -2227,7 +2031,8 @@
 * If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended
 * to retry with a larger probe buffer.
 */
-AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max);
+const AVInputFormat *av_probe_input_format2(const AVProbeData *pd,
+ int is_opened, int *score_max);
 
 /**
 * Guess the file format.
@@ -2236,7 +2041,8 @@
 * demuxers with or without AVFMT_NOFILE are probed.
 * @param score_ret The score of the best detection.
 */
-AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret);
+const AVInputFormat *av_probe_input_format3(const AVProbeData *pd,
+ int is_opened, int *score_ret);
 
 /**
 * Probe a bytestream to determine the input format. Each time a probe returns
@@ -2254,14 +2060,14 @@
 * the maximal score is AVPROBE_SCORE_MAX
 * AVERROR code otherwise
 */
-int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
+int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt,
 const char *url, void *logctx,
 unsigned int offset, unsigned int max_probe_size);
 
 /**
 * Like av_probe_input_buffer2() but returns 0 on success
 */
-int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
+int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt,
 const char *url, void *logctx,
 unsigned int offset, unsigned int max_probe_size);
 
@@ -2284,10 +2090,8 @@
 *
 * @note If you want to use custom IO, preallocate the format context and set its pb field.
 */
-int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options);
-
-attribute_deprecated
-int av_demuxer_open(AVFormatContext *ic);
+int avformat_open_input(AVFormatContext **ps, const char *url,
+ const AVInputFormat *fmt, AVDictionary **options);
 
 /**
 * Read packets of a media file to get stream information. This
@@ -2354,7 +2158,7 @@
 enum AVMediaType type,
 int wanted_stream_nb,
 int related_stream,
- AVCodec **decoder_ret,
+ const AVCodec **decoder_ret,
 int flags);
 
 /**
@@ -2365,13 +2169,12 @@
 * omit invalid data between valid frames so as to give the decoder the maximum
 * information possible for decoding.
 *
- * If pkt->buf is NULL, then the packet is valid until the next
- * av_read_frame() or until avformat_close_input(). Otherwise the packet
- * is valid indefinitely. In both cases the packet must be freed with
- * av_packet_unref when it is no longer needed. For video, the packet contains
- * exactly one frame. For audio, it contains an integer number of frames if each
- * frame has a known fixed size (e.g. PCM or ADPCM data). If the audio frames
- * have a variable size (e.g. MPEG audio), then it contains one frame.
+ * On success, the returned packet is reference-counted (pkt->buf is set) and
+ * valid indefinitely. The packet must be freed with av_packet_unref() when
+ * it is no longer needed. For video, the packet contains exactly one frame.
+ * For audio, it contains an integer number of frames if each frame has
+ * a known fixed size (e.g. PCM or ADPCM data). If the audio frames have
+ * a variable size (e.g. MPEG audio), then it contains one frame.
 *
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
 * values in AVStream.time_base units (and guessed if the format cannot
@@ -2379,7 +2182,11 @@
 * has B-frames, so it is better to rely on pkt->dts if you do not
 * decompress the payload.
 *
- * @return 0 if OK, < 0 on error or end of file
+ * @return 0 if OK, < 0 on error or end of file. On error, pkt will be blank
+ * (as if it came from av_packet_alloc()).
+ *
+ * @note pkt will be initialized, so it may be uninitialized, but it must not
+ * contain data that needs to be freed.
 */
 int av_read_frame(AVFormatContext *s, AVPacket *pkt);
 
@@ -2424,8 +2231,6 @@
 * @return >=0 on success, error code otherwise
 *
 * @note This is part of the new seek API which is still under construction.
- * Thus do not use this yet. It may change at any time, do not expect
- * ABI compatibility yet!
 */
 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
 
@@ -2567,7 +2372,7 @@
 * Write a packet to an output media file ensuring correct interleaving.
 *
 * This function will buffer the packets internally as needed to make sure the
- * packets in the output file are properly interleaved in the order of
+ * packets in the output file are properly interleaved, usually ordered by
 * increasing dts. Callers doing their own interleaving should call
 * av_write_frame() instead of this function.
 *
@@ -2580,10 +2385,10 @@
 * 
 * If the packet is reference-counted, this function will take
 * ownership of this reference and unreference it later when it sees
- * fit.
- * The caller must not access the data through this reference after
- * this function returns. If the packet is not reference-counted,
- * libavformat will make a copy.
+ * fit. If the packet is not reference-counted, libavformat will
+ * make a copy.
+ * The returned packet will be blank (as if returned from
+ * av_packet_alloc()), even on error.
 * 
 * This parameter can be NULL (at any time, not just at the end), to
 * flush the interleaving queues.
@@ -2599,10 +2404,9 @@
 * The dts for subsequent packets in one stream must be strictly
 * increasing (unless the output format is flagged with the
 * AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing).
- * @ref AVPacket.duration "duration") should also be set if known.
+ * @ref AVPacket.duration "duration" should also be set if known.
 *
- * @return 0 on success, a negative AVERROR on error. Libavformat will always
- * take care of freeing the packet, even if this function fails.
+ * @return 0 on success, a negative AVERROR on error.
 *
 * @see av_write_frame(), AVFormatContext.max_interleave_delta
 */
@@ -2612,9 +2416,9 @@
 * Write an uncoded frame to an output media file.
 *
 * The frame must be correctly interleaved according to the container
- * specification; if not, then av_interleaved_write_frame() must be used.
+ * specification; if not, av_interleaved_write_uncoded_frame() must be used.
 *
- * See av_interleaved_write_frame() for details.
+ * See av_interleaved_write_uncoded_frame() for details.
 */
 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
 AVFrame *frame);
@@ -2669,16 +2473,16 @@
 * @param mime_type if non-NULL checks if mime_type matches with the
 * MIME type of the registered formats
 */
-AVOutputFormat *av_guess_format(const char *short_name,
- const char *filename,
- const char *mime_type);
+const AVOutputFormat *av_guess_format(const char *short_name,
+ const char *filename,
+ const char *mime_type);
 
 /**
 * Guess the codec ID based upon muxer and filename.
 */
-enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
- const char *filename, const char *mime_type,
- enum AVMediaType type);
+enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
+ const char *filename, const char *mime_type,
+ enum AVMediaType type);
 
 /**
 * Get timing information for the data currently output.
@@ -2811,6 +2615,45 @@
 int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
 
 /**
+ * Get the index entry count for the given AVStream.
+ *
+ * @param st stream
+ * @return the number of index entries in the stream
+ */
+int avformat_index_get_entries_count(const AVStream *st);
+
+/**
+ * Get the AVIndexEntry corresponding to the given index.
+ *
+ * @param st Stream containing the requested AVIndexEntry.
+ * @param idx The desired index.
+ * @return A pointer to the requested AVIndexEntry if it exists, NULL otherwise.
+ *
+ * @note The pointer returned by this function is only guaranteed to be valid
+ * until any function that takes the stream or the parent AVFormatContext
+ * as input argument is called.
+ */
+const AVIndexEntry *avformat_index_get_entry(AVStream *st, int idx);
+
+/**
+ * Get the AVIndexEntry corresponding to the given timestamp.
+ *
+ * @param st Stream containing the requested AVIndexEntry.
+ * @param timestamp Timestamp to retrieve the index entry for.
+ * @param flags If AVSEEK_FLAG_BACKWARD then the returned entry will correspond
+ * to the timestamp which is <= the requested one, if backward
+ * is 0, then it will be >=
+ * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise.
+ * @return A pointer to the requested AVIndexEntry if it exists, NULL otherwise.
+ *
+ * @note The pointer returned by this function is only guaranteed to be valid
+ * until any function that takes the stream or the parent AVFormatContext
+ * as input argument is called.
+ */
+const AVIndexEntry *avformat_index_get_entry_from_timestamp(AVStream *st,
+ int64_t wanted_timestamp,
+ int flags);
+/**
 * Add an index entry into a sorted list. Update the entry if the list
 * already contains it.
 *
@@ -3013,23 +2856,6 @@
 
 int avformat_queue_attached_pictures(AVFormatContext *s);
 
-#if FF_API_OLD_BSF
-/**
- * Apply a list of bitstream filters to a packet.
- *
- * @param codec AVCodecContext, usually from an AVStream
- * @param pkt the packet to apply filters to. If, on success, the returned
- * packet has size == 0 and side_data_elems == 0, it indicates that
- * the packet should be dropped
- * @param bsfc a NULL-terminated list of filters to apply
- * @return >=0 on success;
- * AVERROR code on failure
- */
-attribute_deprecated
-int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
- AVBitStreamFilterContext *bsfc);
-#endif
-
 enum AVTimebaseSource {
 AVFMT_TBCF_AUTO = -1,
 AVFMT_TBCF_DECODER,

gpac-2.0.0.tar.gz/extra_lib/include/libavformat/avio.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavformat/avio.h Changed

@@ -148,9 +148,9 @@
 
 /**
 * Bytestream IO Context.
- * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing fields require a major
- * version bump.
+ * New public fields can be added with minor version bumps.
+ * Removal, reordering and changes to existing public fields require
+ * a major version bump.
 * sizeof(AVIOContext) must not be used outside libav*.
 *
 * @note None of the function pointers in AVIOContext should be called
@@ -236,13 +236,15 @@
 int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
 int64_t (*seek)(void *opaque, int64_t offset, int whence);
 int64_t pos; /**< position in the file of the current buffer */
- int eof_reached; /**< true if eof reached */
+ int eof_reached; /**< true if was unable to read due to error or eof */
+ int error; /**< contains the error code or 0 if no error happened */
 int write_flag; /**< true if open for writing */
 int max_packet_size;
+ int min_packet_size; /**< Try to buffer at least this amount of data
+ before flushing it. */
 unsigned long checksum;
 unsigned char *checksum_ptr;
 unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
- int error; /**< contains the error code or 0 if no error happened */
 /**
 * Pause or resume playback for network streaming protocols - e.g. MMS.
 */
@@ -260,12 +262,6 @@
 int seekable;
 
 /**
- * max filesize, used to limit allocations
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int64_t maxsize;
-
- /**
 * avio_read and avio_write should if possible be satisfied directly
 * instead of going through a buffer, and avio_seek will always
 * call the underlying seek function directly.
@@ -273,37 +269,6 @@
 int direct;
 
 /**
- * Bytes read statistic
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int64_t bytes_read;
-
- /**
- * seek statistic
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int seek_count;
-
- /**
- * writeout statistic
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int writeout_count;
-
- /**
- * Original buffer size
- * used internally after probing and ensure seekback to reset the buffer size
- * This field is internal to libavformat and access from outside is not allowed.
- */
- int orig_buffer_size;
-
- /**
- * Threshold to favor readahead over seek.
- * This is current internal only, do not use from outside.
- */
- int short_seek_threshold;
-
- /**
 * ',' separated list of allowed protocols.
 */
 const char *protocol_whitelist;
@@ -325,19 +290,15 @@
 */
 int ignore_boundary_point;
 
+#if FF_API_AVIOCONTEXT_WRITTEN
 /**
- * Internal, not meant to be used from outside of AVIOContext.
- */
- enum AVIODataMarkerType current_type;
- int64_t last_time;
-
- /**
- * A callback that is used instead of short_seek_threshold.
- * This is current internal only, do not use from outside.
+ * @deprecated field utilized privately by libavformat. For a public
+ * statistic of how many bytes were written out, see
+ * AVIOContext::bytes_written.
 */
- int (*short_seek_get)(void *opaque);
-
+ attribute_deprecated
 int64_t written;
+#endif
 
 /**
 * Maximum reached position before a backward seek in the write buffer,
@@ -346,9 +307,14 @@
 unsigned char *buf_ptr_max;
 
 /**
- * Try to buffer at least this amount of data before flushing it
+ * Read-only statistic of bytes read for this AVIOContext.
+ */
+ int64_t bytes_read;
+
+ /**
+ * Read-only statistic of bytes written for this AVIOContext.
 */
- int min_packet_size;
+ int64_t bytes_written;
 } AVIOContext;
 
 /**
@@ -375,25 +341,6 @@
 int avio_check(const char *url, int flags);
 
 /**
- * Move or rename a resource.
- *
- * @note url_src and url_dst should share the same protocol and authority.
- *
- * @param url_src url to resource to be moved
- * @param url_dst new url to resource if the operation succeeded
- * @return >=0 on success or negative on error.
- */
-int avpriv_io_move(const char *url_src, const char *url_dst);
-
-/**
- * Delete a resource.
- *
- * @param url resource to be deleted.
- * @return >=0 on success or negative on error.
- */
-int avpriv_io_delete(const char *url);
-
-/**
 * Open directory for reading.
 *
 * @param s directory read context. Pointer to a NULL pointer must be passed.
@@ -566,15 +513,35 @@
 int64_t avio_size(AVIOContext *s);
 
 /**
- * feof() equivalent for AVIOContext.
- * @return non zero if and only if end of file
+ * Similar to feof() but also returns nonzero on read errors.
+ * @return non zero if and only if at end of file or a read error happened when reading.
 */
 int avio_feof(AVIOContext *s);
 
-/** @warning Writes up to 4 KiB per call */
+/**
+ * Writes a formatted string to the context.
+ * @return number of bytes written, < 0 on error.
+ */
 int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
 
 /**
+ * Write a NULL terminated array of strings to the context.
+ * Usually you don't need to use this function directly but its macro wrapper,
+ * avio_print.
+ */
+void avio_print_string_array(AVIOContext *s, const char *strings);
+
+/**
+ * Write strings (const char *) to the context.
+ * This is a convenience macro around avio_print_string_array and it
+ * automatically creates the string array from the variable argument list.
+ * For simple string concatenations this function is more performant than using
+ * avio_printf since it does not need a temporary buffer.
+ */
+#define avio_print(s, ...) \
+ avio_print_string_array(s, (const char*){__VA_ARGS__, NULL})
+
+/**
 * Force flushing of buffered data.
 *
 * For write streams, force the buffered data to be immediately written to the output,
@@ -788,6 +755,13 @@
 const char *avio_enum_protocols(void **opaque, int output);
 
 /**
+ * Get AVClass by names of available protocols.
+ *
+ * @return A AVClass of input protocol name or NULL
+ */
+const AVClass *avio_protocol_get_class(const char *name);
+
+/**
 * Pause and resume playing - only meaningful if using a network streaming
 * protocol (e.g. MMS).
 *

gpac-2.0.0.tar.gz/extra_lib/include/libavformat/version.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavformat/version.h Changed

@@ -31,8 +31,8 @@
 
 // Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
 // Also please add any ticket numbers that you believe might be affected here
-#define LIBAVFORMAT_VERSION_MAJOR 58
-#define LIBAVFORMAT_VERSION_MINOR 12
+#define LIBAVFORMAT_VERSION_MAJOR 59
+#define LIBAVFORMAT_VERSION_MINOR 16
 #define LIBAVFORMAT_VERSION_MICRO 100
 
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
@@ -55,48 +55,13 @@
 * at once through the bump. This improves the git bisect-ability of the change.
 *
 */
-#ifndef FF_API_COMPUTE_PKT_FIELDS2
-#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_OPEN_CALLBACKS
-#define FF_API_OLD_OPEN_CALLBACKS (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LAVF_AVCTX
-#define FF_API_LAVF_AVCTX (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_HTTP_USER_AGENT
-#define FF_API_HTTP_USER_AGENT (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_HLS_WRAP
-#define FF_API_HLS_WRAP (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LAVF_KEEPSIDE_FLAG
-#define FF_API_LAVF_KEEPSIDE_FLAG (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_ROTATE_API
-#define FF_API_OLD_ROTATE_API (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_FORMAT_GET_SET
-#define FF_API_FORMAT_GET_SET (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_AVIO_EOF_0
-#define FF_API_OLD_AVIO_EOF_0 (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_LAVF_FFSERVER
-#define FF_API_LAVF_FFSERVER (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_FORMAT_FILENAME
-#define FF_API_FORMAT_FILENAME (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_OLD_RTSP_OPTIONS
-#define FF_API_OLD_RTSP_OPTIONS (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_NEXT
-#define FF_API_NEXT (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
+#define FF_API_LAVF_PRIV_OPT (LIBAVFORMAT_VERSION_MAJOR < 60)
+#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 60)
+#define FF_API_AVIOCONTEXT_WRITTEN (LIBAVFORMAT_VERSION_MAJOR < 60)
+#define FF_HLS_TS_OPTIONS (LIBAVFORMAT_VERSION_MAJOR < 60)
+#define FF_API_AVSTREAM_CLASS (LIBAVFORMAT_VERSION_MAJOR > 59)
+#define FF_HTTP_CACHE_REDIRECT_DEFAULT (LIBAVFORMAT_VERSION_MAJOR < 60)
 
 
-#ifndef FF_API_R_FRAME_RATE
 #define FF_API_R_FRAME_RATE 1
-#endif
 #endif /* AVFORMAT_VERSION_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/adler32.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/adler32.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/aes.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/aes.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/aes_ctr.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/aes_ctr.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/attributes.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/attributes.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/avassert.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/avassert.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/avstring.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/avstring.h Changed

@@ -24,6 +24,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include "attributes.h"
+#include "version.h"
 
 /**
 * @addtogroup lavu_string
@@ -155,10 +156,14 @@
 */
 char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2);
 
+#if FF_API_D2STR
 /**
 * Convert a number to an av_malloced string.
+ * @deprecated use av_asprintf() with "%f" or a more specific format
 */
+attribute_deprecated
 char *av_d2str(double d);
+#endif
 
 /**
 * Unescape the given string until a non escaped terminating char,
@@ -274,16 +279,21 @@
 
 /**
 * Thread safe basename.
- * @param path the path, on DOS both \ and / are considered separators.
+ * @param path the string to parse, on DOS both \ and / are considered separators.
 * @return pointer to the basename substring.
+ * If path does not contain a slash, the function returns a copy of path.
+ * If path is a NULL pointer or points to an empty string, a pointer
+ * to a string "." is returned.
 */
 const char *av_basename(const char *path);
 
 /**
 * Thread safe dirname.
- * @param path the path, on DOS both \ and / are considered separators.
- * @return the path with the separator replaced by the string terminator or ".".
- * @note the function may change the input string.
+ * @param path the string to parse, on DOS both \ and / are considered separators.
+ * @return A pointer to a string that's the parent directory of path.
+ * If path is a NULL pointer or points to an empty string, a pointer
+ * to a string "." is returned.
+ * @note the function may modify the contents of the path, so copies should be passed.
 */
 const char *av_dirname(char *path);
 
@@ -314,6 +324,7 @@
 AV_ESCAPE_MODE_AUTO, ///< Use auto-selected escaping mode.
 AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping.
 AV_ESCAPE_MODE_QUOTE, ///< Use single-quote escaping.
+ AV_ESCAPE_MODE_XML, ///< Use XML non-markup character data escaping.
 };
 
 /**
@@ -334,6 +345,19 @@
 #define AV_ESCAPE_FLAG_STRICT (1 << 1)
 
 /**
+ * Within AV_ESCAPE_MODE_XML, additionally escape single quotes for single
+ * quoted attributes.
+ */
+#define AV_ESCAPE_FLAG_XML_SINGLE_QUOTES (1 << 2)
+
+/**
+ * Within AV_ESCAPE_MODE_XML, additionally escape double quotes for double
+ * quoted attributes.
+ */
+#define AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES (1 << 3)
+
+
+/**
 * Escape string in src, and put the escaped string in an allocated
 * string in *dst, which must be freed with av_free().
 *
@@ -401,6 +425,12 @@
 int av_match_list(const char *name, const char *list, char separator);
 
 /**
+ * See libc sscanf manual for more information.
+ * Locale-independent sscanf implementation.
+ */
+int av_sscanf(const char *string, const char *format, ...);
+
+/**
 * @}
 */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/bswap.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/bswap.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/buffer.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/buffer.h Changed

@@ -25,6 +25,7 @@
 #ifndef AVUTIL_BUFFER_H
 #define AVUTIL_BUFFER_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 /**
@@ -90,7 +91,7 @@
 /**
 * Size of data in bytes.
 */
- int size;
+ size_t size;
 } AVBufferRef;
 
 /**
@@ -98,13 +99,13 @@
 *
 * @return an AVBufferRef of given size or NULL when out of memory
 */
-AVBufferRef *av_buffer_alloc(int size);
+AVBufferRef *av_buffer_alloc(size_t size);
 
 /**
 * Same as av_buffer_alloc(), except the returned buffer will be initialized
 * to zero.
 */
-AVBufferRef *av_buffer_allocz(int size);
+AVBufferRef *av_buffer_allocz(size_t size);
 
 /**
 * Always treat the buffer as read-only, even when it has only one
@@ -127,7 +128,7 @@
 *
 * @return an AVBufferRef referring to data on success, NULL on failure.
 */
-AVBufferRef *av_buffer_create(uint8_t *data, int size,
+AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
 void (*free)(void *opaque, uint8_t *data),
 void *opaque, int flags);
 
@@ -144,7 +145,7 @@
 * @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on
 * failure.
 */
-AVBufferRef *av_buffer_ref(AVBufferRef *buf);
+AVBufferRef *av_buffer_ref(const AVBufferRef *buf);
 
 /**
 * Free a given reference and automatically free the buffer if there are no more
@@ -195,7 +196,23 @@
 * reference to it (i.e. the one passed to this function). In all other cases
 * a new buffer is allocated and the data is copied.
 */
-int av_buffer_realloc(AVBufferRef **buf, int size);
+int av_buffer_realloc(AVBufferRef **buf, size_t size);
+
+/**
+ * Ensure dst refers to the same data as src.
+ *
+ * When *dst is already equivalent to src, do nothing. Otherwise unreference dst
+ * and replace it with a new reference to src.
+ *
+ * @param dst Pointer to either a valid buffer reference or NULL. On success,
+ * this will point to a buffer reference equivalent to src. On
+ * failure, dst will be left untouched.
+ * @param src A buffer reference to replace dst with. May be NULL, then this
+ * function is equivalent to av_buffer_unref(dst).
+ * @return 0 on success
+ * AVERROR(ENOMEM) on memory allocation failure.
+ */
+int av_buffer_replace(AVBufferRef **dst, const AVBufferRef *src);
 
 /**
 * @}
@@ -246,7 +263,7 @@
 * (av_buffer_alloc()).
 * @return newly created buffer pool on success, NULL on error.
 */
-AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
+AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size));
 
 /**
 * Allocate and initialize a buffer pool with a more complex allocator.
@@ -254,16 +271,17 @@
 * @param size size of each buffer in this pool
 * @param opaque arbitrary user data used by the allocator
 * @param alloc a function that will be used to allocate new buffers when the
- * pool is empty.
+ * pool is empty. May be NULL, then the default allocator will be
+ * used (av_buffer_alloc()).
 * @param pool_free a function that will be called immediately before the pool
 * is freed. I.e. after av_buffer_pool_uninit() is called
 * by the caller and all the frames are returned to the pool
 * and freed. It is intended to uninitialize the user opaque
- * data.
+ * data. May be NULL.
 * @return newly created buffer pool on success, NULL on error.
 */
-AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
- AVBufferRef* (*alloc)(void *opaque, int size),
+AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque,
+ AVBufferRef* (*alloc)(void *opaque, size_t size),
 void (*pool_free)(void *opaque));
 
 /**
@@ -285,6 +303,19 @@
 AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
 
 /**
+ * Query the original opaque parameter of an allocated buffer in the pool.
+ *
+ * @param ref a buffer reference to a buffer returned by av_buffer_pool_get.
+ * @return the opaque parameter set by the buffer allocator function of the
+ * buffer pool.
+ *
+ * @note the opaque parameter of ref is used by the buffer pool implementation,
+ * therefore you have to use this function to access the original opaque
+ * parameter of an allocated buffer.
+ */
+void *av_buffer_pool_buffer_get_opaque(const AVBufferRef *ref);
+
+/**
 * @}
 */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/channel_layout.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/channel_layout.h Changed

@@ -71,6 +71,11 @@
 #define AV_CH_SURROUND_DIRECT_LEFT   0x0000000200000000ULL
 #define AV_CH_SURROUND_DIRECT_RIGHT  0x0000000400000000ULL
 #define AV_CH_LOW_FREQUENCY_2        0x0000000800000000ULL
+#define AV_CH_TOP_SIDE_LEFT          0x0000001000000000ULL
+#define AV_CH_TOP_SIDE_RIGHT         0x0000002000000000ULL
+#define AV_CH_BOTTOM_FRONT_CENTER    0x0000004000000000ULL
+#define AV_CH_BOTTOM_FRONT_LEFT      0x0000008000000000ULL
+#define AV_CH_BOTTOM_FRONT_RIGHT     0x0000010000000000ULL
 
 /** Channel mask value used for AVCodecContext.request_channel_layout
     to indicate that the user requests the channel order of the decoder output
@@ -110,6 +115,7 @@
 #define AV_CH_LAYOUT_OCTAGONAL         (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
 #define AV_CH_LAYOUT_HEXADECAGONAL     (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
 #define AV_CH_LAYOUT_STEREO_DOWNMIX    (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
+#define AV_CH_LAYOUT_22POINT2          (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_LOW_FREQUENCY_2|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_CENTER|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_SIDE_LEFT|AV_CH_TOP_SIDE_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_BOTTOM_FRONT_CENTER|AV_CH_BOTTOM_FRONT_LEFT|AV_CH_BOTTOM_FRONT_RIGHT)
 
 enum AVMatrixEncoding {
     AV_MATRIX_ENCODING_NONE,

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/common.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/common.h Changed

@@ -42,18 +42,11 @@
 #include "attributes.h"
 #include "macros.h"
 #include "version.h"
-#include "libavutil/avconfig.h"
-
-#if AV_HAVE_BIGENDIAN
-# define AV_NE(be, le) (be)
-#else
-# define AV_NE(be, le) (le)
-#endif
 
 //rounded division & shift
 #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
 /* assume b>0 */
-#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
+#define ROUNDED_DIV(a,b) (((a)>=0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
 /* Fast a/(1<<b) rounded toward +inf. Assume a>=0 and b>=0 */
 #define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
 : ((a) + (1<<(b)) - 1) >> (b))
@@ -81,23 +74,13 @@
 #define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
 
 /**
- * Comparator.
- * For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0
- * if x == y. This is useful for instance in a qsort comparator callback.
- * Furthermore, compilers are able to optimize this to branchless code, and
- * there is no risk of overflow with signed types.
- * As with many macros, this evaluates its argument multiple times, it thus
- * must not have a side-effect.
+ * Unsigned Absolute value.
+ * This takes the absolute value of a signed int and returns it as a unsigned.
+ * This also works with INT_MIN which would otherwise not be representable
+ * As with many macros, this evaluates its argument twice.
 */
-#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
-
-#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
-#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
-#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
-#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
-
-#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
-#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)0))
+#define FFABSU(a) ((a) <= 0 ? -(unsigned)(a) : (unsigned)(a))
+#define FFABS64U(a) ((a) <= 0 ? -(uint64_t)(a) : (uint64_t)(a))
 
 /* misc math functions */
 
@@ -106,8 +89,72 @@
 # include "intmath.h"
 #endif
 
-/* Pull in unguarded fallback defines at the end of this file. */
-#include "common.h"
+#ifndef av_ceil_log2
+# define av_ceil_log2 av_ceil_log2_c
+#endif
+#ifndef av_clip
+# define av_clip av_clip_c
+#endif
+#ifndef av_clip64
+# define av_clip64 av_clip64_c
+#endif
+#ifndef av_clip_uint8
+# define av_clip_uint8 av_clip_uint8_c
+#endif
+#ifndef av_clip_int8
+# define av_clip_int8 av_clip_int8_c
+#endif
+#ifndef av_clip_uint16
+# define av_clip_uint16 av_clip_uint16_c
+#endif
+#ifndef av_clip_int16
+# define av_clip_int16 av_clip_int16_c
+#endif
+#ifndef av_clipl_int32
+# define av_clipl_int32 av_clipl_int32_c
+#endif
+#ifndef av_clip_intp2
+# define av_clip_intp2 av_clip_intp2_c
+#endif
+#ifndef av_clip_uintp2
+# define av_clip_uintp2 av_clip_uintp2_c
+#endif
+#ifndef av_mod_uintp2
+# define av_mod_uintp2 av_mod_uintp2_c
+#endif
+#ifndef av_sat_add32
+# define av_sat_add32 av_sat_add32_c
+#endif
+#ifndef av_sat_dadd32
+# define av_sat_dadd32 av_sat_dadd32_c
+#endif
+#ifndef av_sat_sub32
+# define av_sat_sub32 av_sat_sub32_c
+#endif
+#ifndef av_sat_dsub32
+# define av_sat_dsub32 av_sat_dsub32_c
+#endif
+#ifndef av_sat_add64
+# define av_sat_add64 av_sat_add64_c
+#endif
+#ifndef av_sat_sub64
+# define av_sat_sub64 av_sat_sub64_c
+#endif
+#ifndef av_clipf
+# define av_clipf av_clipf_c
+#endif
+#ifndef av_clipd
+# define av_clipd av_clipd_c
+#endif
+#ifndef av_popcount
+# define av_popcount av_popcount_c
+#endif
+#ifndef av_popcount64
+# define av_popcount64 av_popcount64_c
+#endif
+#ifndef av_parity
+# define av_parity av_parity_c
+#endif
 
 #ifndef av_log2
 av_const int av_log2(unsigned v);
@@ -240,7 +287,7 @@
 */
 static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
 {
- return a & ((1 << p) - 1);
+ return a & ((1U << p) - 1);
 }
 
 /**
@@ -292,7 +339,48 @@
 }
 
 /**
+ * Add two signed 64-bit values with saturation.
+ *
+ * @param a one value
+ * @param b another value
+ * @return sum with signed saturation
+ */
+static av_always_inline int64_t av_sat_add64_c(int64_t a, int64_t b) {
+#if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_add_overflow)
+ int64_t tmp;
+ return !__builtin_add_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN);
+#else
+ int64_t s = a+(uint64_t)b;
+ if ((int64_t)(a^b | ~s^b) >= 0)
+ return INT64_MAX ^ (b >> 63);
+ return s;
+#endif
+}
+
+/**
+ * Subtract two signed 64-bit values with saturation.
+ *
+ * @param a one value
+ * @param b another value
+ * @return difference with signed saturation
+ */
+static av_always_inline int64_t av_sat_sub64_c(int64_t a, int64_t b) {
+#if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_sub_overflow)
+ int64_t tmp;
+ return !__builtin_sub_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN);
+#else
+ if (b <= 0 && a >= INT64_MAX + b)
+ return INT64_MAX;
+ if (b >= 0 && a <= INT64_MIN + b)
+ return INT64_MIN;
+ return a - b;
+#endif
+}
+
+/**
 * Clip a float value into the amin-amax range.
+ * If a is nan or -inf amin will be returned.
+ * If a is +inf amax will be returned.
 * @param a value to clip
 * @param amin minimum value of the clip range
 * @param amax maximum value of the clip range
@@ -303,13 +391,13 @@
 #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
 if (amin > amax) abort();
 #endif
- if (a < amin) return amin;
- else if (a > amax) return amax;
- else return a;
+ return FFMIN(FFMAX(a, amin), amax);
 }
 
 /**
 * Clip a double value into the amin-amax range.
+ * If a is nan or -inf amin will be returned.
+ * If a is +inf amax will be returned.
 * @param a value to clip
 * @param amin minimum value of the clip range
 * @param amax maximum value of the clip range
@@ -320,9 +408,7 @@
 #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
 if (amin > amax) abort();
 #endif
- if (a < amin) return amin;
- else if (a > amax) return amax;
- else return a;
+ return FFMIN(FFMAX(a, amin), amax);
 }
 
 /** Compute ceil(log2(x)).
@@ -331,7 +417,7 @@
 */
 static av_always_inline av_const int av_ceil_log2_c(int x)
 {
- return av_log2((x - 1) << 1);
+ return av_log2((x - 1U) << 1);
 }
 
 /**
@@ -363,9 +449,6 @@
 return av_popcount(v) & 1;
 }
 
-#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
-#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
-
 /**
 * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
 *
@@ -373,7 +456,9 @@
 * @param GET_BYTE Expression reading one byte from the input.
 * Evaluated up to 7 times (4 for the currently
 * assigned Unicode range). With a memory buffer
- * input, this could be *ptr++.
+ * input, this could be *ptr++, or if you want to make sure
+ * that *ptr stops at the end of a NULL terminated string then
+ * *ptr ? *ptr++ : 0
 * @param ERROR Expression to be evaluated on invalid input,
 * typically a goto statement.
 *
@@ -387,11 +472,11 @@
 {\
 uint32_t top = (val & 128) >> 1;\
 if ((val & 0xc0) == 0x80 || val >= 0xFE)\
- ERROR\
+ {ERROR}\
 while (val & top) {\
- int tmp= (GET_BYTE) - 128;\
+ unsigned int tmp = (GET_BYTE) - 128;\
 if(tmp>>6)\
- ERROR\
+ {ERROR}\
 val= (val<<6) + tmp;\
 top <<= 5;\
 }\
@@ -408,13 +493,13 @@
 * typically a goto statement.
 */
 #define GET_UTF16(val, GET_16BIT, ERROR)\
- val = GET_16BIT;\
+ val = (GET_16BIT);\
 {\
 unsigned int hi = val - 0xD800;\
 if (hi < 0x800) {\
- val = GET_16BIT - 0xDC00;\
+ val = (GET_16BIT) - 0xDC00;\
 if (val > 0x3FFU || hi > 0x3FFU)\
- ERROR\
+ {ERROR}\
 val += (hi<<10) + 0x10000;\
 }\
 }\
@@ -492,69 +577,3 @@
 #endif /* HAVE_AV_CONFIG_H */
 
 #endif /* AVUTIL_COMMON_H */
-
-/*
- * The following definitions are outside the multiple inclusion guard
- * to ensure they are immediately available in intmath.h.
- */
-
-#ifndef av_ceil_log2
-# define av_ceil_log2 av_ceil_log2_c
-#endif
-#ifndef av_clip
-# define av_clip av_clip_c
-#endif
-#ifndef av_clip64
-# define av_clip64 av_clip64_c
-#endif
-#ifndef av_clip_uint8
-# define av_clip_uint8 av_clip_uint8_c
-#endif
-#ifndef av_clip_int8
-# define av_clip_int8 av_clip_int8_c
-#endif
-#ifndef av_clip_uint16
-# define av_clip_uint16 av_clip_uint16_c
-#endif
-#ifndef av_clip_int16
-# define av_clip_int16 av_clip_int16_c
-#endif
-#ifndef av_clipl_int32
-# define av_clipl_int32 av_clipl_int32_c
-#endif
-#ifndef av_clip_intp2
-# define av_clip_intp2 av_clip_intp2_c
-#endif
-#ifndef av_clip_uintp2
-# define av_clip_uintp2 av_clip_uintp2_c
-#endif
-#ifndef av_mod_uintp2
-# define av_mod_uintp2 av_mod_uintp2_c
-#endif
-#ifndef av_sat_add32
-# define av_sat_add32 av_sat_add32_c
-#endif
-#ifndef av_sat_dadd32
-# define av_sat_dadd32 av_sat_dadd32_c
-#endif
-#ifndef av_sat_sub32
-# define av_sat_sub32 av_sat_sub32_c
-#endif
-#ifndef av_sat_dsub32
-# define av_sat_dsub32 av_sat_dsub32_c
-#endif
-#ifndef av_clipf
-# define av_clipf av_clipf_c
-#endif
-#ifndef av_clipd
-# define av_clipd av_clipd_c
-#endif
-#ifndef av_popcount
-# define av_popcount av_popcount_c
-#endif
-#ifndef av_popcount64
-# define av_popcount64 av_popcount64_c
-#endif
-#ifndef av_parity
-# define av_parity av_parity_c
-#endif

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/cpu.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/cpu.h Changed

@@ -23,8 +23,6 @@
 
 #include <stddef.h>
 
-#include "attributes.h"
-
 #define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */
 
 /* lower 16 bits - CPU features */
@@ -56,6 +54,7 @@
 #define AV_CPU_FLAG_BMI1 0x20000 ///< Bit Manipulation Instruction Set 1
 #define AV_CPU_FLAG_BMI2 0x40000 ///< Bit Manipulation Instruction Set 2
 #define AV_CPU_FLAG_AVX512 0x100000 ///< AVX-512 functions: requires OS support even if YMM/ZMM registers aren't used
+#define AV_CPU_FLAG_SLOW_GATHER 0x2000000 ///< CPU has slow gathers.
 
 #define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard
 #define AV_CPU_FLAG_VSX 0x0002 ///< ISA 2.06
@@ -71,6 +70,13 @@
 #define AV_CPU_FLAG_VFP_VM (1 << 7) ///< VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations
 #define AV_CPU_FLAG_SETEND (1 <<16)
 
+#define AV_CPU_FLAG_MMI (1 << 0)
+#define AV_CPU_FLAG_MSA (1 << 1)
+
+//Loongarch SIMD extension.
+#define AV_CPU_FLAG_LSX (1 << 0)
+#define AV_CPU_FLAG_LASX (1 << 1)
+
 /**
 * Return the flags which specify extensions supported by the CPU.
 * The returned value is affected by av_force_cpu_flags() if that was used
@@ -86,25 +92,6 @@
 void av_force_cpu_flags(int flags);
 
 /**
- * Set a mask on flags returned by av_get_cpu_flags().
- * This function is mainly useful for testing.
- * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible
- */
-attribute_deprecated void av_set_cpu_flags_mask(int mask);
-
-/**
- * Parse CPU flags from a string.
- *
- * The returned flags contain the specified flags as well as related unspecified flags.
- *
- * This function exists only for compatibility with libav.
- * Please use av_parse_cpu_caps() when possible.
- * @return a combination of AV_CPU_* flags, negative on error.
- */
-attribute_deprecated
-int av_parse_cpu_flags(const char *s);
-
-/**
 * Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
 *
 * @return negative on error.
@@ -117,6 +104,12 @@
 int av_cpu_count(void);
 
 /**
+ * Overrides cpu count detection and forces the specified count.
+ * Count < 1 disables forcing of specific count.
+ */
+void av_cpu_force_count(int count);
+
+/**
 * Get the maximum data alignment that may be required by FFmpeg.
 *
 * Note that this is affected by the build configuration and the CPU flags mask,

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/crc.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/crc.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/detection_bbox.h Added

@@ -0,0 +1,107 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_DETECTION_BBOX_H
+#define AVUTIL_DETECTION_BBOX_H
+
+#include "rational.h"
+#include "avassert.h"
+#include "frame.h"
+
+typedef struct AVDetectionBBox {
+ /**
+ * Distance in pixels from the left/top edge of the frame,
+ * together with width and height, defining the bounding box.
+ */
+ int x;
+ int y;
+ int w;
+ int h;
+
+#define AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE 64
+
+ /**
+ * Detect result with confidence
+ */
+ char detect_labelAV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE;
+ AVRational detect_confidence;
+
+ /**
+ * At most 4 classifications based on the detected bounding box.
+ * For example, we can get max 4 different attributes with 4 different
+ * DNN models on one bounding box.
+ * classify_count is zero if no classification.
+ */
+#define AV_NUM_DETECTION_BBOX_CLASSIFY 4
+ uint32_t classify_count;
+ char classify_labelsAV_NUM_DETECTION_BBOX_CLASSIFYAV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE;
+ AVRational classify_confidencesAV_NUM_DETECTION_BBOX_CLASSIFY;
+} AVDetectionBBox;
+
+typedef struct AVDetectionBBoxHeader {
+ /**
+ * Information about how the bounding box is generated.
+ * for example, the DNN model name.
+ */
+ char source256;
+
+ /**
+ * Number of bounding boxes in the array.
+ */
+ uint32_t nb_bboxes;
+
+ /**
+ * Offset in bytes from the beginning of this structure at which
+ * the array of bounding boxes starts.
+ */
+ size_t bboxes_offset;
+
+ /**
+ * Size of each bounding box in bytes.
+ */
+ size_t bbox_size;
+} AVDetectionBBoxHeader;
+
+/*
+ * Get the bounding box at the specified {@code idx}. Must be between 0 and nb_bboxes.
+ */
+static av_always_inline AVDetectionBBox *
+av_get_detection_bbox(const AVDetectionBBoxHeader *header, unsigned int idx)
+{
+ av_assert0(idx < header->nb_bboxes);
+ return (AVDetectionBBox *)((uint8_t *)header + header->bboxes_offset +
+ idx * header->bbox_size);
+}
+
+/**
+ * Allocates memory for AVDetectionBBoxHeader, plus an array of {@code nb_bboxes}
+ * AVDetectionBBox, and initializes the variables.
+ * Can be freed with a normal av_free() call.
+ *
+ * @param out_size if non-NULL, the size in bytes of the resulting data array is
+ * written here.
+ */
+AVDetectionBBoxHeader *av_detection_bbox_alloc(uint32_t nb_bboxes, size_t *out_size);
+
+/**
+ * Allocates memory for AVDetectionBBoxHeader, plus an array of {@code nb_bboxes}
+ * AVDetectionBBox, in the given AVFrame {@code frame} as AVFrameSideData of type
+ * AV_FRAME_DATA_DETECTION_BBOXES and initializes the variables.
+ */
+AVDetectionBBoxHeader *av_detection_bbox_create_side_data(AVFrame *frame, uint32_t nb_bboxes);
+#endif

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/dict.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/dict.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/display.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/display.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/dovi_meta.h Added

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2020 Vacing Fang <vacingfang@tencent.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * DOVI configuration
+ */
+
+
+#ifndef AVUTIL_DOVI_META_H
+#define AVUTIL_DOVI_META_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "rational.h"
+
+/*
+ * DOVI configuration
+ * ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2
+ dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2
+ * @code
+ * uint8_t dv_version_major, the major version number that the stream complies with
+ * uint8_t dv_version_minor, the minor version number that the stream complies with
+ * uint8_t dv_profile, the Dolby Vision profile
+ * uint8_t dv_level, the Dolby Vision level
+ * uint8_t rpu_present_flag
+ * uint8_t el_present_flag
+ * uint8_t bl_present_flag
+ * uint8_t dv_bl_signal_compatibility_id
+ * @endcode
+ *
+ * @note The struct must be allocated with av_dovi_alloc() and
+ * its size is not a part of the public ABI.
+ */
+typedef struct AVDOVIDecoderConfigurationRecord {
+ uint8_t dv_version_major;
+ uint8_t dv_version_minor;
+ uint8_t dv_profile;
+ uint8_t dv_level;
+ uint8_t rpu_present_flag;
+ uint8_t el_present_flag;
+ uint8_t bl_present_flag;
+ uint8_t dv_bl_signal_compatibility_id;
+} AVDOVIDecoderConfigurationRecord;
+
+/**
+ * Allocate a AVDOVIDecoderConfigurationRecord structure and initialize its
+ * fields to default values.
+ *
+ * @return the newly allocated struct or NULL on failure
+ */
+AVDOVIDecoderConfigurationRecord *av_dovi_alloc(size_t *size);
+
+/**
+ * Dolby Vision RPU data header.
+ *
+ * @note sizeof(AVDOVIRpuDataHeader) is not part of the public ABI.
+ */
+typedef struct AVDOVIRpuDataHeader {
+ uint8_t rpu_type;
+ uint16_t rpu_format;
+ uint8_t vdr_rpu_profile;
+ uint8_t vdr_rpu_level;
+ uint8_t chroma_resampling_explicit_filter_flag;
+ uint8_t coef_data_type; /* informative, lavc always converts to fixed */
+ uint8_t coef_log2_denom;
+ uint8_t vdr_rpu_normalized_idc;
+ uint8_t bl_video_full_range_flag;
+ uint8_t bl_bit_depth; /* 8, 16 */
+ uint8_t el_bit_depth; /* 8, 16 */
+ uint8_t vdr_bit_depth; /* 8, 16 */
+ uint8_t spatial_resampling_filter_flag;
+ uint8_t el_spatial_resampling_filter_flag;
+ uint8_t disable_residual_flag;
+} AVDOVIRpuDataHeader;
+
+enum AVDOVIMappingMethod {
+ AV_DOVI_MAPPING_POLYNOMIAL = 0,
+ AV_DOVI_MAPPING_MMR = 1,
+};
+
+/**
+ * Coefficients of a piece-wise function. The pieces of the function span the
+ * value ranges between two adjacent pivot values.
+ */
+#define AV_DOVI_MAX_PIECES 8
+typedef struct AVDOVIReshapingCurve {
+ uint8_t num_pivots; /* 2, 9 */
+ uint16_t pivotsAV_DOVI_MAX_PIECES + 1; /* sorted ascending */
+ enum AVDOVIMappingMethod mapping_idcAV_DOVI_MAX_PIECES;
+ /* AV_DOVI_MAPPING_POLYNOMIAL */
+ uint8_t poly_orderAV_DOVI_MAX_PIECES; /* 1, 2 */
+ int64_t poly_coefAV_DOVI_MAX_PIECES3; /* x^0, x^1, x^2 */
+ /* AV_DOVI_MAPPING_MMR */
+ uint8_t mmr_orderAV_DOVI_MAX_PIECES; /* 1, 3 */
+ int64_t mmr_constantAV_DOVI_MAX_PIECES;
+ int64_t mmr_coefAV_DOVI_MAX_PIECES3/* order - 1 */7;
+} AVDOVIReshapingCurve;
+
+enum AVDOVINLQMethod {
+ AV_DOVI_NLQ_NONE = -1,
+ AV_DOVI_NLQ_LINEAR_DZ = 0,
+};
+
+/**
+ * Coefficients of the non-linear inverse quantization. For the interpretation
+ * of these, see ETSI GS CCM 001.
+ */
+typedef struct AVDOVINLQParams {
+ uint16_t nlq_offset;
+ uint64_t vdr_in_max;
+ /* AV_DOVI_NLQ_LINEAR_DZ */
+ uint64_t linear_deadzone_slope;
+ uint64_t linear_deadzone_threshold;
+} AVDOVINLQParams;
+
+/**
+ * Dolby Vision RPU data mapping parameters.
+ *
+ * @note sizeof(AVDOVIDataMapping) is not part of the public ABI.
+ */
+typedef struct AVDOVIDataMapping {
+ uint8_t vdr_rpu_id;
+ uint8_t mapping_color_space;
+ uint8_t mapping_chroma_format_idc;
+ AVDOVIReshapingCurve curves3; /* per component */
+
+ /* Non-linear inverse quantization */
+ enum AVDOVINLQMethod nlq_method_idc;
+ uint32_t num_x_partitions;
+ uint32_t num_y_partitions;
+ AVDOVINLQParams nlq3; /* per component */
+} AVDOVIDataMapping;
+
+/**
+ * Dolby Vision RPU colorspace metadata parameters.
+ *
+ * @note sizeof(AVDOVIColorMetadata) is not part of the public ABI.
+ */
+typedef struct AVDOVIColorMetadata {
+ uint8_t dm_metadata_id;
+ uint8_t scene_refresh_flag;
+
+ /**
+ * Coefficients of the custom Dolby Vision IPT-PQ matrices. These are to be
+ * used instead of the matrices indicated by the frame's colorspace tags.
+ * The output of rgb_to_lms_matrix is to be fed into a BT.2020 LMS->RGB
+ * matrix based on a Hunt-Pointer-Estevez transform, but without any
+ * crosstalk. (See the definition of the ICtCp colorspace for more
+ * information.)
+ */
+ AVRational ycc_to_rgb_matrix9; /* before PQ linearization */
+ AVRational ycc_to_rgb_offset3; /* input offset of neutral value */
+ AVRational rgb_to_lms_matrix9; /* after PQ linearization */
+
+ /**
+ * Extra signal metadata (see Dolby patents for more info).
+ */
+ uint16_t signal_eotf;
+ uint16_t signal_eotf_param0;
+ uint16_t signal_eotf_param1;
+ uint32_t signal_eotf_param2;
+ uint8_t signal_bit_depth;
+ uint8_t signal_color_space;
+ uint8_t signal_chroma_format;
+ uint8_t signal_full_range_flag; /* 0, 3 */
+ uint16_t source_min_pq;
+ uint16_t source_max_pq;
+ uint16_t source_diagonal;
+} AVDOVIColorMetadata;
+
+/**
+ * Combined struct representing a combination of header, mapping and color
+ * metadata, for attaching to frames as side data.
+ *
+ * @note The struct must be allocated with av_dovi_metadata_alloc() and
+ * its size is not a part of the public ABI.
+ */
+
+typedef struct AVDOVIMetadata {
+ /**
+ * Offset in bytes from the beginning of this structure at which the
+ * respective structs start.
+ */
+ size_t header_offset; /* AVDOVIRpuDataHeader */
+ size_t mapping_offset; /* AVDOVIDataMapping */
+ size_t color_offset; /* AVDOVIColorMetadata */
+} AVDOVIMetadata;
+
+static av_always_inline AVDOVIRpuDataHeader *
+av_dovi_get_header(const AVDOVIMetadata *data)
+{
+ return (AVDOVIRpuDataHeader *)((uint8_t *) data + data->header_offset);
+}
+
+static av_always_inline AVDOVIDataMapping *
+av_dovi_get_mapping(const AVDOVIMetadata *data)
+{
+ return (AVDOVIDataMapping *)((uint8_t *) data + data->mapping_offset);
+}
+
+static av_always_inline AVDOVIColorMetadata *
+av_dovi_get_color(const AVDOVIMetadata *data)
+{
+ return (AVDOVIColorMetadata *)((uint8_t *) data + data->color_offset);
+}
+
+/**
+ * Allocate an AVDOVIMetadata structure and initialize its
+ * fields to default values.
+ *
+ * @param size If this parameter is non-NULL, the size in bytes of the
+ * allocated struct will be written here on success
+ *
+ * @return the newly allocated struct or NULL on failure
+ */
+AVDOVIMetadata *av_dovi_metadata_alloc(size_t *size);
+
+#endif /* AVUTIL_DOVI_META_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/encryption_info.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/encryption_info.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/error.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/error.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/eval.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/eval.h Changed

@@ -87,6 +87,30 @@
 double av_expr_eval(AVExpr *e, const double *const_values, void *opaque);
 
 /**
+ * Track the presence of variables and their number of occurrences in a parsed expression
+ *
+ * @param counter a zero-initialized array where the count of each variable will be stored
+ * @param size size of array
+ * @return 0 on success, a negative value indicates that no expression or array was passed
+ * or size was zero
+ */
+int av_expr_count_vars(AVExpr *e, unsigned *counter, int size);
+
+/**
+ * Track the presence of user provided functions and their number of occurrences
+ * in a parsed expression.
+ *
+ * @param counter a zero-initialized array where the count of each function will be stored
+ *                if you passed 5 functions with 2 arguments to av_expr_parse()
+ *                then for arg=2 this will use upto 5 entries.
+ * @param size size of array
+ * @param arg number of arguments the counted functions have
+ * @return 0 on success, a negative value indicates that no expression or array was passed
+ * or size was zero
+ */
+int av_expr_count_func(AVExpr *e, unsigned *counter, int size, int arg);
+
+/**
  * Free a parsed expression previously created with av_expr_parse().
  */
 void av_expr_free(AVExpr *e);

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/ffversion.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/ffversion.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/file.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/file.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/film_grain_params.h Added

@@ -0,0 +1,260 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_FILM_GRAIN_PARAMS_H
+#define AVUTIL_FILM_GRAIN_PARAMS_H
+
+#include "frame.h"
+
+enum AVFilmGrainParamsType {
+    AV_FILM_GRAIN_PARAMS_NONE = 0,
+
+    /**
+     * The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
+     */
+    AV_FILM_GRAIN_PARAMS_AV1,
+
+    /**
+     * The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
+     */
+    AV_FILM_GRAIN_PARAMS_H274,
+};
+
+/**
+ * This structure describes how to handle film grain synthesis for AOM codecs.
+ *
+ * @note The struct must be allocated as part of AVFilmGrainParams using
+ *       av_film_grain_params_alloc(). Its size is not a part of the public ABI.
+ */
+typedef struct AVFilmGrainAOMParams {
+    /**
+     * Number of points, and the scale and value for each point of the
+     * piecewise linear scaling function for the uma plane.
+     */
+    int num_y_points;
+    uint8_t y_points142 /* value, scaling */;
+
+    /**
+     * Signals whether to derive the chroma scaling function from the luma.
+     * Not equivalent to copying the luma values and scales.
+     */
+    int chroma_scaling_from_luma;
+
+    /**
+     * If chroma_scaling_from_luma is set to 0, signals the chroma scaling
+     * function parameters.
+     */
+    int num_uv_points2 /* cb, cr */;
+    uint8_t uv_points2 /* cb, cr */102 /* value, scaling */;
+
+    /**
+     * Specifies the shift applied to the chroma components. For AV1, its within
+     * 8; 11 and determines the range and quantization of the film grain.
+     */
+    int scaling_shift;
+
+    /**
+     * Specifies the auto-regression lag.
+     */
+    int ar_coeff_lag;
+
+    /**
+     * Luma auto-regression coefficients. The number of coefficients is given by
+     * 2 * ar_coeff_lag * (ar_coeff_lag + 1).
+     */
+    int8_t ar_coeffs_y24;
+
+    /**
+     * Chroma auto-regression coefficients. The number of coefficients is given by
+     * 2 * ar_coeff_lag * (ar_coeff_lag + 1) + !!num_y_points.
+     */
+    int8_t ar_coeffs_uv2 /* cb, cr */25;
+
+    /**
+     * Specifies the range of the auto-regressive coefficients. Values of 6,
+     * 7, 8 and so on represent a range of -2, 2), -1, 1), -0.5, 0.5) and
+     * so on. For AV1 must be between 6 and 9.
+     */
+    int ar_coeff_shift;
+
+    /**
+     * Signals the down shift applied to the generated gaussian numbers during
+     * synthesis.
+     */
+    int grain_scale_shift;
+
+    /**
+     * Specifies the luma/chroma multipliers for the index to the component
+     * scaling function.
+     */
+    int uv_mult2 /* cb, cr */;
+    int uv_mult_luma2 /* cb, cr */;
+
+    /**
+     * Offset used for component scaling function. For AV1 its a 9-bit value
+     * with a range -256, 255
+     */
+    int uv_offset2 /* cb, cr */;
+
+    /**
+     * Signals whether to overlap film grain blocks.
+     */
+    int overlap_flag;
+
+    /**
+     * Signals to clip to limited color levels after film grain application.
+     */
+    int limit_output_range;
+} AVFilmGrainAOMParams;
+
+/**
+ * This structure describes how to handle film grain synthesis for codecs using
+ * the ITU-T H.274 Versatile suplemental enhancement information message.
+ *
+ * @note The struct must be allocated as part of AVFilmGrainParams using
+ *       av_film_grain_params_alloc(). Its size is not a part of the public ABI.
+ */
+typedef struct AVFilmGrainH274Params {
+    /**
+     * Specifies the film grain simulation mode.
+     * 0 = Frequency filtering, 1 = Auto-regression
+     */
+    int model_id;
+
+    /**
+     * Specifies the bit depth used for the luma component.
+     */
+    int bit_depth_luma;
+
+    /**
+     * Specifies the bit depth used for the chroma components.
+     */
+    int bit_depth_chroma;
+
+    enum AVColorRange                  color_range;
+    enum AVColorPrimaries              color_primaries;
+    enum AVColorTransferCharacteristic color_trc;
+    enum AVColorSpace                  color_space;
+
+    /**
+     * Specifies the blending mode used to blend the simulated film grain
+     * with the decoded images.
+     *
+     * 0 = Additive, 1 = Multiplicative
+     */
+    int blending_mode_id;
+
+    /**
+     * Specifies a scale factor used in the film grain characterization equations.
+     */
+    int log2_scale_factor;
+
+    /**
+     * Indicates if the modelling of film grain for a given component is present.
+     */
+    int component_model_present3 /* y, cb, cr */;
+
+    /**
+     * Specifies the number of intensity intervals for which a specific set of
+     * model values has been estimated, with a range of 1, 256.
+     */
+    uint16_t num_intensity_intervals3 /* y, cb, cr */;
+
+    /**
+     * Specifies the number of model values present for each intensity interval
+     * in which the film grain has been modelled, with a range of 1, 6.
+     */
+    uint8_t num_model_values3 /* y, cb, cr */;
+
+    /**
+     * Specifies the lower ounds of each intensity interval for whichthe set of
+     * model values applies for the component.
+     */
+    uint8_t intensity_interval_lower_bound3 /* y, cb, cr */256 /* intensity interval */;
+
+    /**
+     * Specifies the upper bound of each intensity interval for which the set of
+     * model values applies for the component.
+     */
+    uint8_t intensity_interval_upper_bound3 /* y, cb, cr */256 /* intensity interval */;
+
+    /**
+     * Specifies the model values for the component for each intensity interval.
+     * - When model_id == 0, the following applies:
+     *     For comp_model_valuey, the range of values is 0, 2^bit_depth_luma - 1
+     *     For comp_model_valuecb..cr, the range of values is 0, 2^bit_depth_chroma - 1
+     * - Otherwise, the following applies:
+     *     For comp_model_valuey, the range of values is -2^(bit_depth_luma - 1), 2^(bit_depth_luma - 1) - 1
+     *     For comp_model_valuecb..cr, the range of values is -2^(bit_depth_chroma - 1), 2^(bit_depth_chroma - 1) - 1
+     */
+    int16_t comp_model_value3 /* y, cb, cr */256 /* intensity interval */6 /* model value */;
+} AVFilmGrainH274Params;
+
+/**
+ * This structure describes how to handle film grain synthesis in video
+ * for specific codecs. Must be present on every frame where film grain is
+ * meant to be synthesised for correct presentation.
+ *
+ * @note The struct must be allocated with av_film_grain_params_alloc() and
+ *       its size is not a part of the public ABI.
+ */
+typedef struct AVFilmGrainParams {
+    /**
+     * Specifies the codec for which this structure is valid.
+     */
+    enum AVFilmGrainParamsType type;
+
+    /**
+     * Seed to use for the synthesis process, if the codec allows for it.
+     *
+     * @note For H.264, this refers to `pic_offset` as defined in
+     *       SMPTE RDD 5-2006.
+     */
+    uint64_t seed;
+
+    /**
+     * Additional fields may be added both here and in any structure included.
+     * If a codec's film grain structure differs slightly over another
+     * codec's, fields within may change meaning depending on the type.
+     */
+    union {
+        AVFilmGrainAOMParams aom;
+        AVFilmGrainH274Params h274;
+    } codec;
+} AVFilmGrainParams;
+
+/**
+ * Allocate an AVFilmGrainParams structure and set its fields to
+ * default values. The resulting struct can be freed using av_freep().
+ * If size is not NULL it will be set to the number of bytes allocated.
+ *
+ * @return An AVFilmGrainParams filled with default values or NULL
+ *         on failure.
+ */
+AVFilmGrainParams *av_film_grain_params_alloc(size_t *size);
+
+/**
+ * Allocate a complete AVFilmGrainParams and add it to the frame.
+ *
+ * @param frame The frame which side data is added to.
+ *
+ * @return The AVFilmGrainParams structure to be filled by caller.
+ */
+AVFilmGrainParams *av_film_grain_params_create_side_data(AVFrame *frame);
+
+#endif /* AVUTIL_FILM_GRAIN_PARAMS_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/frame.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/frame.h Changed

@@ -142,22 +142,65 @@
 */
 AV_FRAME_DATA_ICC_PROFILE,
 
-#if FF_API_FRAME_QP
 /**
- * Implementation-specific description of the format of AV_FRAME_QP_TABLE_DATA.
- * The contents of this side data are undocumented and internal; use
- * av_frame_set_qp_table() and av_frame_get_qp_table() to access this in a
- * meaningful way instead.
+ * Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t
+ * where the first uint32_t describes how many (1-3) of the other timecodes are used.
+ * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
+ * function in libavutil/timecode.h.
 */
- AV_FRAME_DATA_QP_TABLE_PROPERTIES,
+ AV_FRAME_DATA_S12M_TIMECODE,
 
 /**
- * Raw QP table data. Its format is described by
- * AV_FRAME_DATA_QP_TABLE_PROPERTIES. Use av_frame_set_qp_table() and
- * av_frame_get_qp_table() to access this instead.
+ * HDR dynamic metadata associated with a video frame. The payload is
+ * an AVDynamicHDRPlus type and contains information for color
+ * volume transform - application 4 of SMPTE 2094-40:2016 standard.
 */
- AV_FRAME_DATA_QP_TABLE_DATA,
-#endif
+ AV_FRAME_DATA_DYNAMIC_HDR_PLUS,
+
+ /**
+ * Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of
+ * array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size.
+ */
+ AV_FRAME_DATA_REGIONS_OF_INTEREST,
+
+ /**
+ * Encoding parameters for a video frame, as described by AVVideoEncParams.
+ */
+ AV_FRAME_DATA_VIDEO_ENC_PARAMS,
+
+ /**
+ * User data unregistered metadata associated with a video frame.
+ * This is the H.2645 UDU SEI message, and shouldn't be used for any other purpose
+ * The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of
+ * uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte.
+ */
+ AV_FRAME_DATA_SEI_UNREGISTERED,
+
+ /**
+ * Film grain parameters for a frame, described by AVFilmGrainParams.
+ * Must be present for every frame which should have film grain applied.
+ */
+ AV_FRAME_DATA_FILM_GRAIN_PARAMS,
+
+ /**
+ * Bounding boxes for object detection and classification,
+ * as described by AVDetectionBBoxHeader.
+ */
+ AV_FRAME_DATA_DETECTION_BBOXES,
+
+ /**
+ * Dolby Vision RPU raw data, suitable for passing to x265
+ * or other libraries. Array of uint8_t, with NAL emulation
+ * bytes intact.
+ */
+ AV_FRAME_DATA_DOVI_RPU_BUFFER,
+
+ /**
+ * Parsed Dolby Vision metadata, suitable for passing to a software
+ * implementation. The payload is the AVDOVIMetadata struct defined in
+ * libavutil/dovi_meta.h.
+ */
+ AV_FRAME_DATA_DOVI_METADATA,
 };
 
 enum AVActiveFormatDescription {
@@ -180,12 +223,68 @@
 typedef struct AVFrameSideData {
 enum AVFrameSideDataType type;
 uint8_t *data;
- int size;
+ size_t size;
 AVDictionary *metadata;
 AVBufferRef *buf;
 } AVFrameSideData;
 
 /**
+ * Structure describing a single Region Of Interest.
+ *
+ * When multiple regions are defined in a single side-data block, they
+ * should be ordered from most to least important - some encoders are only
+ * capable of supporting a limited number of distinct regions, so will have
+ * to truncate the list.
+ *
+ * When overlapping regions are defined, the first region containing a given
+ * area of the frame applies.
+ */
+typedef struct AVRegionOfInterest {
+ /**
+ * Must be set to the size of this data structure (that is,
+ * sizeof(AVRegionOfInterest)).
+ */
+ uint32_t self_size;
+ /**
+ * Distance in pixels from the top edge of the frame to the top and
+ * bottom edges and from the left edge of the frame to the left and
+ * right edges of the rectangle defining this region of interest.
+ *
+ * The constraints on a region are encoder dependent, so the region
+ * actually affected may be slightly larger for alignment or other
+ * reasons.
+ */
+ int top;
+ int bottom;
+ int left;
+ int right;
+ /**
+ * Quantisation offset.
+ *
+ * Must be in the range -1 to +1. A value of zero indicates no quality
+ * change. A negative value asks for better quality (less quantisation),
+ * while a positive value asks for worse quality (greater quantisation).
+ *
+ * The range is calibrated so that the extreme values indicate the
+ * largest possible offset - if the rest of the frame is encoded with the
+ * worst possible quality, an offset of -1 indicates that this region
+ * should be encoded with the best possible quality anyway. Intermediate
+ * values are then interpolated in some codec-dependent way.
+ *
+ * For example, in 10-bit H.264 the quantisation parameter varies between
+ * -12 and 51. A typical qoffset value of -1/10 therefore indicates that
+ * this region should be encoded with a QP around one-tenth of the full
+ * range better than the rest of the frame. So, if most of the frame
+ * were to be encoded with a QP of around 30, this region would get a QP
+ * of around 24 (an offset of approximately -1/10 * (51 - -12) = -6.3).
+ * An extreme value of -1 would indicate that this region should be
+ * encoded with the best possible quality regardless of the treatment of
+ * the rest of the frame - that is, should be encoded at a QP of -12.
+ */
+ AVRational qoffset;
+} AVRegionOfInterest;
+
+/**
 * This structure describes decoded (raw) audio or video data.
 *
 * AVFrame must be allocated using av_frame_alloc(). Note that this only
@@ -219,21 +318,32 @@
 #define AV_NUM_DATA_POINTERS 8
 /**
 * pointer to the picture/channel planes.
- * This might be different from the first allocated byte
+ * This might be different from the first allocated byte. For video,
+ * it could even point to the end of the image data.
+ *
+ * All pointers in data and extended_data must point into one of the
+ * AVBufferRef in buf or extended_buf.
 *
 * Some decoders access areas outside 0,0 - width,height, please
 * see avcodec_align_dimensions2(). Some filters and swscale can read
 * up to 16 bytes beyond the planes, if these filters are to be used,
 * then 16 extra bytes must be allocated.
 *
- * NOTE: Except for hwaccel formats, pointers not needed by the format
- * MUST be set to NULL.
+ * NOTE: Pointers not needed by the format MUST be set to NULL.
+ *
+ * @attention In case of video, the data pointers can point to the
+ * end of image data in order to reverse line order, when used in
+ * combination with negative values in the linesize array.
 */
 uint8_t *dataAV_NUM_DATA_POINTERS;
 
 /**
- * For video, size in bytes of each picture line.
- * For audio, size in bytes of each plane.
+ * For video, a positive or negative value, which is typically indicating
+ * the size in bytes of each picture line, but it can also be:
+ * - the negative byte size of lines for vertical flipping
+ * (with datan pointing to the end of the data
+ * - a positive or negative multiple of the byte size as for accessing
+ * even and odd fields of a frame (possibly flipped)
 *
 * For audio, only linesize0 may be set. For planar audio, each channel
 * plane must be the same size.
@@ -245,6 +355,9 @@
 *
 * @note The linesize may be larger than the size of usable data -- there
 * may be extra padding present for performance reasons.
+ *
+ * @attention In case of video, line size values can be negative to achieve
+ * a vertically inverted iteration over image lines.
 */
 int linesizeAV_NUM_DATA_POINTERS;
 
@@ -310,15 +423,6 @@
 */
 int64_t pts;
 
-#if FF_API_PKT_PTS
- /**
- * PTS copied from the AVPacket that was decoded to produce this frame.
- * @deprecated use the pts field instead
- */
- attribute_deprecated
- int64_t pkt_pts;
-#endif
-
 /**
 * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)
 * This is also the Presentation time of this AVFrame calculated from
@@ -327,6 +431,14 @@
 int64_t pkt_dts;
 
 /**
+ * Time base for the timestamps in this frame.
+ * In the future, this field may be set on frames output by decoders or
+ * filters, but its value will be by default ignored on input to encoders
+ * or filters.
+ */
+ AVRational time_base;
+
+ /**
 * picture number in bitstream order
 */
 int coded_picture_number;
@@ -345,14 +457,6 @@
 */
 void *opaque;
 
-#if FF_API_ERROR_FRAME
- /**
- * @deprecated unused
- */
- attribute_deprecated
- uint64_t errorAV_NUM_DATA_POINTERS;
-#endif
-
 /**
 * When decoding, this signals how much the picture must be delayed.
 * extra_delay = repeat_pict / (2*fps)
@@ -381,7 +485,6 @@
 * that time,
 * the decoder reorders values as needed and sets AVFrame.reordered_opaque
 * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque
- * @deprecated in favor of pkt_pts
 */
 int64_t reordered_opaque;
 
@@ -396,10 +499,10 @@
 uint64_t channel_layout;
 
 /**
- * AVBuffer references backing the data for this frame. If all elements of
- * this array are NULL, then this frame is not reference counted. This array
- * must be filled contiguously -- if bufi is non-NULL then bufj must
- * also be non-NULL for all j < i.
+ * AVBuffer references backing the data for this frame. All the pointers in
+ * data and extended_data must point inside one of the buffers in buf or
+ * extended_buf. This array must be filled contiguously -- if bufi is
+ * non-NULL then bufj must also be non-NULL for all j < i.
 *
 * There may be at most one AVBuffer per data plane, so for video this array
 * always contains all the references. For planar audio with more than
@@ -514,6 +617,8 @@
 int decode_error_flags;
 #define FF_DECODE_ERROR_INVALID_BITSTREAM 1
 #define FF_DECODE_ERROR_MISSING_REFERENCE 2
+#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4
+#define FF_DECODE_ERROR_DECODE_SLICES 8
 
 /**
 * number of audio channels, only used for audio.
@@ -531,24 +636,6 @@
 */
 int pkt_size;
 
-#if FF_API_FRAME_QP
- /**
- * QP table
- */
- attribute_deprecated
- int8_t *qscale_table;
- /**
- * QP store stride
- */
- attribute_deprecated
- int qstride;
-
- attribute_deprecated
- int qscale_type;
-
- attribute_deprecated
- AVBufferRef *qp_table_buf;
-#endif
 /**
 * For hwaccel-format frames, this should be a reference to the
 * AVHWFramesContext describing the frame.
@@ -596,69 +683,16 @@
 AVBufferRef *private_ref;
 } AVFrame;
 
-#if FF_API_FRAME_GET_SET
-/**
- * Accessors for some AVFrame fields. These used to be provided for ABI
- * compatibility, and do not need to be used anymore.
- */
-attribute_deprecated
-int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
-attribute_deprecated
-int64_t av_frame_get_pkt_duration (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_pkt_duration (AVFrame *frame, int64_t val);
-attribute_deprecated
-int64_t av_frame_get_pkt_pos (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_pkt_pos (AVFrame *frame, int64_t val);
-attribute_deprecated
-int64_t av_frame_get_channel_layout (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_channel_layout (AVFrame *frame, int64_t val);
-attribute_deprecated
-int av_frame_get_channels (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_channels (AVFrame *frame, int val);
-attribute_deprecated
-int av_frame_get_sample_rate (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_sample_rate (AVFrame *frame, int val);
-attribute_deprecated
-AVDictionary *av_frame_get_metadata (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_metadata (AVFrame *frame, AVDictionary *val);
-attribute_deprecated
-int av_frame_get_decode_error_flags (const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_decode_error_flags (AVFrame *frame, int val);
-attribute_deprecated
-int av_frame_get_pkt_size(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_pkt_size(AVFrame *frame, int val);
-#if FF_API_FRAME_QP
-attribute_deprecated
-int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
-attribute_deprecated
-int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
-#endif
-attribute_deprecated
-enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val);
-attribute_deprecated
-enum AVColorRange av_frame_get_color_range(const AVFrame *frame);
-attribute_deprecated
-void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val);
-#endif
 
+#if FF_API_COLORSPACE_NAME
 /**
 * Get the name of a colorspace.
 * @return a static string identifying the colorspace; can be NULL.
+ * @deprecated use av_color_space_name()
 */
+attribute_deprecated
 const char *av_get_colorspace_name(enum AVColorSpace val);
-
+#endif
 /**
 * Allocate an AVFrame and set its fields to default values. The resulting
 * struct must be freed using av_frame_free().
@@ -816,7 +850,7 @@
 */
 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
 enum AVFrameSideDataType type,
- int size);
+ size_t size);
 
 /**
 * Add a new side data to a frame from an existing AVBufferRef
@@ -842,8 +876,7 @@
 enum AVFrameSideDataType type);
 
 /**
- * If side data of the supplied type exists in the frame, free it and remove it
- * from the frame.
+ * Remove and free all side data instances of the given type.
 */
 void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/hash.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hash.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hdr_dynamic_metadata.h Added

@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_HDR_DYNAMIC_METADATA_H
+#define AVUTIL_HDR_DYNAMIC_METADATA_H
+
+#include "frame.h"
+#include "rational.h"
+
+/**
+ * Option for overlapping elliptical pixel selectors in an image.
+ */
+enum AVHDRPlusOverlapProcessOption {
+ AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING = 0,
+ AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING = 1,
+};
+
+/**
+ * Represents the percentile at a specific percentage in
+ * a distribution.
+ */
+typedef struct AVHDRPlusPercentile {
+ /**
+ * The percentage value corresponding to a specific percentile linearized
+ * RGB value in the processing window in the scene. The value shall be in
+ * the range of 0 to100, inclusive.
+ */
+ uint8_t percentage;
+
+ /**
+ * The linearized maxRGB value at a specific percentile in the processing
+ * window in the scene. The value shall be in the range of 0 to 1, inclusive
+ * and in multiples of 0.00001.
+ */
+ AVRational percentile;
+} AVHDRPlusPercentile;
+
+/**
+ * Color transform parameters at a processing window in a dynamic metadata for
+ * SMPTE 2094-40.
+ */
+typedef struct AVHDRPlusColorTransformParams {
+ /**
+ * The relative x coordinate of the top left pixel of the processing
+ * window. The value shall be in the range of 0 and 1, inclusive and
+ * in multiples of 1/(width of Picture - 1). The value 1 corresponds
+ * to the absolute coordinate of width of Picture - 1. The value for
+ * first processing window shall be 0.
+ */
+ AVRational window_upper_left_corner_x;
+
+ /**
+ * The relative y coordinate of the top left pixel of the processing
+ * window. The value shall be in the range of 0 and 1, inclusive and
+ * in multiples of 1/(height of Picture - 1). The value 1 corresponds
+ * to the absolute coordinate of height of Picture - 1. The value for
+ * first processing window shall be 0.
+ */
+ AVRational window_upper_left_corner_y;
+
+ /**
+ * The relative x coordinate of the bottom right pixel of the processing
+ * window. The value shall be in the range of 0 and 1, inclusive and
+ * in multiples of 1/(width of Picture - 1). The value 1 corresponds
+ * to the absolute coordinate of width of Picture - 1. The value for
+ * first processing window shall be 1.
+ */
+ AVRational window_lower_right_corner_x;
+
+ /**
+ * The relative y coordinate of the bottom right pixel of the processing
+ * window. The value shall be in the range of 0 and 1, inclusive and
+ * in multiples of 1/(height of Picture - 1). The value 1 corresponds
+ * to the absolute coordinate of height of Picture - 1. The value for
+ * first processing window shall be 1.
+ */
+ AVRational window_lower_right_corner_y;
+
+ /**
+ * The x coordinate of the center position of the concentric internal and
+ * external ellipses of the elliptical pixel selector in the processing
+ * window. The value shall be in the range of 0 to (width of Picture - 1),
+ * inclusive and in multiples of 1 pixel.
+ */
+ uint16_t center_of_ellipse_x;
+
+ /**
+ * The y coordinate of the center position of the concentric internal and
+ * external ellipses of the elliptical pixel selector in the processing
+ * window. The value shall be in the range of 0 to (height of Picture - 1),
+ * inclusive and in multiples of 1 pixel.
+ */
+ uint16_t center_of_ellipse_y;
+
+ /**
+ * The clockwise rotation angle in degree of arc with respect to the
+ * positive direction of the x-axis of the concentric internal and external
+ * ellipses of the elliptical pixel selector in the processing window. The
+ * value shall be in the range of 0 to 180, inclusive and in multiples of 1.
+ */
+ uint8_t rotation_angle;
+
+ /**
+ * The semi-major axis value of the internal ellipse of the elliptical pixel
+ * selector in amount of pixels in the processing window. The value shall be
+ * in the range of 1 to 65535, inclusive and in multiples of 1 pixel.
+ */
+ uint16_t semimajor_axis_internal_ellipse;
+
+ /**
+ * The semi-major axis value of the external ellipse of the elliptical pixel
+ * selector in amount of pixels in the processing window. The value
+ * shall not be less than semimajor_axis_internal_ellipse of the current
+ * processing window. The value shall be in the range of 1 to 65535,
+ * inclusive and in multiples of 1 pixel.
+ */
+ uint16_t semimajor_axis_external_ellipse;
+
+ /**
+ * The semi-minor axis value of the external ellipse of the elliptical pixel
+ * selector in amount of pixels in the processing window. The value shall be
+ * in the range of 1 to 65535, inclusive and in multiples of 1 pixel.
+ */
+ uint16_t semiminor_axis_external_ellipse;
+
+ /**
+ * Overlap process option indicates one of the two methods of combining
+ * rendered pixels in the processing window in an image with at least one
+ * elliptical pixel selector. For overlapping elliptical pixel selectors
+ * in an image, overlap_process_option shall have the same value.
+ */
+ enum AVHDRPlusOverlapProcessOption overlap_process_option;
+
+ /**
+ * The maximum of the color components of linearized RGB values in the
+ * processing window in the scene. The values should be in the range of 0 to
+ * 1, inclusive and in multiples of 0.00001. maxscl 0 , maxscl 1 , and
+ * maxscl 2 are corresponding to R, G, B color components respectively.
+ */
+ AVRational maxscl3;
+
+ /**
+ * The average of linearized maxRGB values in the processing window in the
+ * scene. The value should be in the range of 0 to 1, inclusive and in
+ * multiples of 0.00001.
+ */
+ AVRational average_maxrgb;
+
+ /**
+ * The number of linearized maxRGB values at given percentiles in the
+ * processing window in the scene. The maximum value shall be 15.
+ */
+ uint8_t num_distribution_maxrgb_percentiles;
+
+ /**
+ * The linearized maxRGB values at given percentiles in the
+ * processing window in the scene.
+ */
+ AVHDRPlusPercentile distribution_maxrgb15;
+
+ /**
+ * The fraction of selected pixels in the image that contains the brightest
+ * pixel in the scene. The value shall be in the range of 0 to 1, inclusive
+ * and in multiples of 0.001.
+ */
+ AVRational fraction_bright_pixels;
+
+ /**
+ * This flag indicates that the metadata for the tone mapping function in
+ * the processing window is present (for value of 1).
+ */
+ uint8_t tone_mapping_flag;
+
+ /**
+ * The x coordinate of the separation point between the linear part and the
+ * curved part of the tone mapping function. The value shall be in the range
+ * of 0 to 1, excluding 0 and in multiples of 1/4095.
+ */
+ AVRational knee_point_x;
+
+ /**
+ * The y coordinate of the separation point between the linear part and the
+ * curved part of the tone mapping function. The value shall be in the range
+ * of 0 to 1, excluding 0 and in multiples of 1/4095.
+ */
+ AVRational knee_point_y;
+
+ /**
+ * The number of the intermediate anchor parameters of the tone mapping
+ * function in the processing window. The maximum value shall be 15.
+ */
+ uint8_t num_bezier_curve_anchors;
+
+ /**
+ * The intermediate anchor parameters of the tone mapping function in the
+ * processing window in the scene. The values should be in the range of 0
+ * to 1, inclusive and in multiples of 1/1023.
+ */
+ AVRational bezier_curve_anchors15;
+
+ /**
+ * This flag shall be equal to 0 in bitstreams conforming to this version of
+ * this Specification. Other values are reserved for future use.
+ */
+ uint8_t color_saturation_mapping_flag;
+
+ /**
+ * The color saturation gain in the processing window in the scene. The
+ * value shall be in the range of 0 to 63/8, inclusive and in multiples of
+ * 1/8. The default value shall be 1.
+ */
+ AVRational color_saturation_weight;
+} AVHDRPlusColorTransformParams;
+
+/**
+ * This struct represents dynamic metadata for color volume transform -
+ * application 4 of SMPTE 2094-40:2016 standard.
+ *
+ * To be used as payload of a AVFrameSideData or AVPacketSideData with the
+ * appropriate type.
+ *
+ * @note The struct should be allocated with
+ * av_dynamic_hdr_plus_alloc() and its size is not a part of
+ * the public ABI.
+ */
+typedef struct AVDynamicHDRPlus {
+ /**
+ * Country code by Rec. ITU-T T.35 Annex A. The value shall be 0xB5.
+ */
+ uint8_t itu_t_t35_country_code;
+
+ /**
+ * Application version in the application defining document in ST-2094
+ * suite. The value shall be set to 0.
+ */
+ uint8_t application_version;
+
+ /**
+ * The number of processing windows. The value shall be in the range
+ * of 1 to 3, inclusive.
+ */
+ uint8_t num_windows;
+
+ /**
+ * The color transform parameters for every processing window.
+ */
+ AVHDRPlusColorTransformParams params3;
+
+ /**
+ * The nominal maximum display luminance of the targeted system display,
+ * in units of 0.0001 candelas per square metre. The value shall be in
+ * the range of 0 to 10000, inclusive.
+ */
+ AVRational targeted_system_display_maximum_luminance;
+
+ /**
+ * This flag shall be equal to 0 in bit streams conforming to this version
+ * of this Specification. The value 1 is reserved for future use.
+ */
+ uint8_t targeted_system_display_actual_peak_luminance_flag;
+
+ /**
+ * The number of rows in the targeted system_display_actual_peak_luminance
+ * array. The value shall be in the range of 2 to 25, inclusive.
+ */
+ uint8_t num_rows_targeted_system_display_actual_peak_luminance;
+
+ /**
+ * The number of columns in the
+ * targeted_system_display_actual_peak_luminance array. The value shall be
+ * in the range of 2 to 25, inclusive.
+ */
+ uint8_t num_cols_targeted_system_display_actual_peak_luminance;
+
+ /**
+ * The normalized actual peak luminance of the targeted system display. The
+ * values should be in the range of 0 to 1, inclusive and in multiples of
+ * 1/15.
+ */
+ AVRational targeted_system_display_actual_peak_luminance2525;
+
+ /**
+ * This flag shall be equal to 0 in bitstreams conforming to this version of
+ * this Specification. The value 1 is reserved for future use.
+ */
+ uint8_t mastering_display_actual_peak_luminance_flag;
+
+ /**
+ * The number of rows in the mastering_display_actual_peak_luminance array.
+ * The value shall be in the range of 2 to 25, inclusive.
+ */
+ uint8_t num_rows_mastering_display_actual_peak_luminance;
+
+ /**
+ * The number of columns in the mastering_display_actual_peak_luminance
+ * array. The value shall be in the range of 2 to 25, inclusive.
+ */
+ uint8_t num_cols_mastering_display_actual_peak_luminance;
+
+ /**
+ * The normalized actual peak luminance of the mastering display used for
+ * mastering the image essence. The values should be in the range of 0 to 1,
+ * inclusive and in multiples of 1/15.
+ */
+ AVRational mastering_display_actual_peak_luminance2525;
+} AVDynamicHDRPlus;
+
+/**
+ * Allocate an AVDynamicHDRPlus structure and set its fields to
+ * default values. The resulting struct can be freed using av_freep().
+ *
+ * @return An AVDynamicHDRPlus filled with default values or NULL
+ * on failure.
+ */
+AVDynamicHDRPlus *av_dynamic_hdr_plus_alloc(size_t *size);
+
+/**
+ * Allocate a complete AVDynamicHDRPlus and add it to the frame.
+ * @param frame The frame which side data is added to.
+ *
+ * @return The AVDynamicHDRPlus structure to be filled by caller or NULL
+ * on failure.
+ */
+AVDynamicHDRPlus *av_dynamic_hdr_plus_create_side_data(AVFrame *frame);
+
+#endif /* AVUTIL_HDR_DYNAMIC_METADATA_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/hmac.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hmac.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/hwcontext.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hwcontext.h Changed

@@ -36,6 +36,7 @@
     AV_HWDEVICE_TYPE_DRM,
     AV_HWDEVICE_TYPE_OPENCL,
     AV_HWDEVICE_TYPE_MEDIACODEC,
+    AV_HWDEVICE_TYPE_VULKAN,
 };
 
 typedef struct AVHWDeviceInternal AVHWDeviceInternal;
@@ -327,6 +328,26 @@
                                    enum AVHWDeviceType type,
                                    AVBufferRef *src_ctx, int flags);
 
+/**
+ * Create a new device of the specified type from an existing device.
+ *
+ * This function performs the same action as av_hwdevice_ctx_create_derived,
+ * however, it is able to set options for the new device to be derived.
+ *
+ * @param dst_ctx On success, a reference to the newly-created
+ *                AVHWDeviceContext.
+ * @param type    The type of the new device to create.
+ * @param src_ctx A reference to an existing AVHWDeviceContext which will be
+ *                used to create the new device.
+ * @param options Options for the new device to create, same format as in
+ *                av_hwdevice_ctx_create.
+ * @param flags   Currently unused; should be set to zero.
+ * @return        Zero on success, a negative AVERROR code on failure.
+ */
+int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ctx,
+                                        enum AVHWDeviceType type,
+                                        AVBufferRef *src_ctx,
+                                        AVDictionary *options, int flags);
 
 /**
  * Allocate an AVHWFramesContext tied to a given device context.

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/hwcontext_cuda.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hwcontext_cuda.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/hwcontext_d3d11va.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hwcontext_d3d11va.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hwcontext_opencl.h Added

@@ -0,0 +1,100 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_HWCONTEXT_OPENCL_H
+#define AVUTIL_HWCONTEXT_OPENCL_H
+
+#ifdef __APPLE__
+#include <OpenCL/cl.h>
+#else
+#include <CL/cl.h>
+#endif
+
+#include "frame.h"
+
+/**
+ * @file
+ * API-specific header for AV_HWDEVICE_TYPE_OPENCL.
+ *
+ * Pools allocated internally are always dynamic, and are primarily intended
+ * to be used in OpenCL-only cases. If interoperation is required, it is
+ * typically required to allocate frames in the other API and then map the
+ * frames context to OpenCL with av_hwframe_ctx_create_derived().
+ */
+
+/**
+ * OpenCL frame descriptor for pool allocation.
+ *
+ * In user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
+ * with the data pointer pointing at an object of this type describing the
+ * planes of the frame.
+ */
+typedef struct AVOpenCLFrameDescriptor {
+ /**
+ * Number of planes in the frame.
+ */
+ int nb_planes;
+ /**
+ * OpenCL image2d objects for each plane of the frame.
+ */
+ cl_mem planesAV_NUM_DATA_POINTERS;
+} AVOpenCLFrameDescriptor;
+
+/**
+ * OpenCL device details.
+ *
+ * Allocated as AVHWDeviceContext.hwctx
+ */
+typedef struct AVOpenCLDeviceContext {
+ /**
+ * The primary device ID of the device. If multiple OpenCL devices
+ * are associated with the context then this is the one which will
+ * be used for all operations internal to FFmpeg.
+ */
+ cl_device_id device_id;
+ /**
+ * The OpenCL context which will contain all operations and frames on
+ * this device.
+ */
+ cl_context context;
+ /**
+ * The default command queue for this device, which will be used by all
+ * frames contexts which do not have their own command queue. If not
+ * intialised by the user, a default queue will be created on the
+ * primary device.
+ */
+ cl_command_queue command_queue;
+} AVOpenCLDeviceContext;
+
+/**
+ * OpenCL-specific data associated with a frame pool.
+ *
+ * Allocated as AVHWFramesContext.hwctx.
+ */
+typedef struct AVOpenCLFramesContext {
+ /**
+ * The command queue used for internal asynchronous operations on this
+ * device (av_hwframe_transfer_data(), av_hwframe_map()).
+ *
+ * If this is not set, the command queue from the associated device is
+ * used instead.
+ */
+ cl_command_queue command_queue;
+} AVOpenCLFramesContext;
+
+#endif /* AVUTIL_HWCONTEXT_OPENCL_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/hwcontext_videotoolbox.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hwcontext_videotoolbox.h Changed

@@ -29,11 +29,14 @@
  * @file
  * An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX.
  *
- * This API currently does not support frame allocation, as the raw VideoToolbox
- * API does allocation, and FFmpeg itself never has the need to allocate frames.
+ * This API supports frame allocation using a native CVPixelBufferPool
+ * instead of an AVBufferPool.
  *
  * If the API user sets a custom pool, AVHWFramesContext.pool must return
  * AVBufferRefs whose data pointer is a CVImageBufferRef or CVPixelBufferRef.
+ * Note that the underlying CVPixelBuffer could be retained by OS frameworks
+ * depending on application usage, so it is preferable to let CoreVideo manage
+ * the pool using the default implementation.
  *
  * Currently AVHWDeviceContext.hwctx and AVHWFramesContext.hwctx are always
  * NULL.
@@ -51,4 +54,42 @@
  */
 uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt);
 
+/**
+ * Same as av_map_videotoolbox_format_from_pixfmt function, but can map and
+ * return full range pixel formats via a flag.
+ */
+uint32_t av_map_videotoolbox_format_from_pixfmt2(enum AVPixelFormat pix_fmt, bool full_range);
+
+/**
+ * Convert an AVChromaLocation to a VideoToolbox/CoreVideo chroma location string.
+ * Returns 0 if no known equivalent was found.
+ */
+CFStringRef av_map_videotoolbox_chroma_loc_from_av(enum AVChromaLocation loc);
+
+/**
+ * Convert an AVColorSpace to a VideoToolbox/CoreVideo color matrix string.
+ * Returns 0 if no known equivalent was found.
+ */
+CFStringRef av_map_videotoolbox_color_matrix_from_av(enum AVColorSpace space);
+
+/**
+ * Convert an AVColorPrimaries to a VideoToolbox/CoreVideo color primaries string.
+ * Returns 0 if no known equivalent was found.
+ */
+CFStringRef av_map_videotoolbox_color_primaries_from_av(enum AVColorPrimaries pri);
+
+/**
+ * Convert an AVColorTransferCharacteristic to a VideoToolbox/CoreVideo color transfer
+ * function string.
+ * Returns 0 if no known equivalent was found.
+ */
+CFStringRef av_map_videotoolbox_color_trc_from_av(enum AVColorTransferCharacteristic trc);
+
+/**
+ * Update a CVPixelBufferRef's metadata to based on an AVFrame.
+ * Returns 0 if no known equivalent was found.
+ */
+int av_vt_pixbuf_set_attachments(void *log_ctx,
+                                 CVPixelBufferRef pixbuf, const struct AVFrame *src);
+
 #endif /* AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H */

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/hwcontext_vulkan.h Added

@@ -0,0 +1,281 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_HWCONTEXT_VULKAN_H
+#define AVUTIL_HWCONTEXT_VULKAN_H
+
+#if defined(_WIN32) && !defined(VK_USE_PLATFORM_WIN32_KHR)
+#define VK_USE_PLATFORM_WIN32_KHR
+#endif
+#include <vulkan/vulkan.h>
+
+#include "pixfmt.h"
+#include "frame.h"
+
+/**
+ * @file
+ * API-specific header for AV_HWDEVICE_TYPE_VULKAN.
+ *
+ * For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
+ * with the data pointer set to an AVVkFrame.
+ */
+
+/**
+ * Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
+ * All of these can be set before init to change what the context uses
+ */
+typedef struct AVVulkanDeviceContext {
+ /**
+ * Custom memory allocator, else NULL
+ */
+ const VkAllocationCallbacks *alloc;
+
+ /**
+ * Pointer to the instance-provided vkGetInstanceProcAddr loading function.
+ * If NULL, will pick either libvulkan or libvolk, depending on libavutil's
+ * compilation settings, and set this field.
+ */
+ PFN_vkGetInstanceProcAddr get_proc_addr;
+
+ /**
+ * Vulkan instance. Must be at least version 1.2.
+ */
+ VkInstance inst;
+
+ /**
+ * Physical device
+ */
+ VkPhysicalDevice phys_dev;
+
+ /**
+ * Active device
+ */
+ VkDevice act_dev;
+
+ /**
+ * This structure should be set to the set of features that present and enabled
+ * during device creation. When a device is created by FFmpeg, it will default to
+ * enabling all that are present of the shaderImageGatherExtended,
+ * fragmentStoresAndAtomics, shaderInt64 and vertexPipelineStoresAndAtomics features.
+ */
+ VkPhysicalDeviceFeatures2 device_features;
+
+ /**
+ * Enabled instance extensions.
+ * If supplying your own device context, set this to an array of strings, with
+ * each entry containing the specified Vulkan extension string to enable.
+ * Duplicates are possible and accepted.
+ * If no extensions are enabled, set these fields to NULL, and 0 respectively.
+ */
+ const char * const *enabled_inst_extensions;
+ int nb_enabled_inst_extensions;
+
+ /**
+ * Enabled device extensions. By default, VK_KHR_external_memory_fd,
+ * VK_EXT_external_memory_dma_buf, VK_EXT_image_drm_format_modifier,
+ * VK_KHR_external_semaphore_fd and VK_EXT_external_memory_host are enabled if found.
+ * If supplying your own device context, these fields takes the same format as
+ * the above fields, with the same conditions that duplicates are possible
+ * and accepted, and that NULL and 0 respectively means no extensions are enabled.
+ */
+ const char * const *enabled_dev_extensions;
+ int nb_enabled_dev_extensions;
+
+ /**
+ * Queue family index for graphics operations, and the number of queues
+ * enabled for it. If unavaiable, will be set to -1. Not required.
+ * av_hwdevice_create() will attempt to find a dedicated queue for each
+ * queue family, or pick the one with the least unrelated flags set.
+ * Queue indices here may overlap if a queue has to share capabilities.
+ */
+ int queue_family_index;
+ int nb_graphics_queues;
+
+ /**
+ * Queue family index for transfer operations and the number of queues
+ * enabled. Required.
+ */
+ int queue_family_tx_index;
+ int nb_tx_queues;
+
+ /**
+ * Queue family index for compute operations and the number of queues
+ * enabled. Required.
+ */
+ int queue_family_comp_index;
+ int nb_comp_queues;
+
+ /**
+ * Queue family index for video encode ops, and the amount of queues enabled.
+ * If the device doesn't support such, queue_family_encode_index will be -1.
+ * Not required.
+ */
+ int queue_family_encode_index;
+ int nb_encode_queues;
+
+ /**
+ * Queue family index for video decode ops, and the amount of queues enabled.
+ * If the device doesn't support such, queue_family_decode_index will be -1.
+ * Not required.
+ */
+ int queue_family_decode_index;
+ int nb_decode_queues;
+} AVVulkanDeviceContext;
+
+/**
+ * Defines the behaviour of frame allocation.
+ */
+typedef enum AVVkFrameFlags {
+ /* Unless this flag is set, autodetected flags will be OR'd based on the
+ * device and tiling during av_hwframe_ctx_init(). */
+ AV_VK_FRAME_FLAG_NONE = (1ULL << 0),
+
+ /* Image planes will be allocated in a single VkDeviceMemory, rather
+ * than as per-plane VkDeviceMemory allocations. Required for exporting
+ * to VAAPI on Intel devices. */
+ AV_VK_FRAME_FLAG_CONTIGUOUS_MEMORY = (1ULL << 1),
+} AVVkFrameFlags;
+
+/**
+ * Allocated as AVHWFramesContext.hwctx, used to set pool-specific options
+ */
+typedef struct AVVulkanFramesContext {
+ /**
+ * Controls the tiling of allocated frames. If left as optimal tiling,
+ * then during av_hwframe_ctx_init() will decide based on whether the device
+ * supports DRM modifiers, or if the linear_images flag is set, otherwise
+ * will allocate optimally-tiled images.
+ */
+ VkImageTiling tiling;
+
+ /**
+ * Defines extra usage of output frames. If left as 0, the following bits
+ * are set: TRANSFER_SRC, TRANSFER_DST. SAMPLED and STORAGE.
+ */
+ VkImageUsageFlagBits usage;
+
+ /**
+ * Extension data for image creation.
+ * If VkImageDrmFormatModifierListCreateInfoEXT is present in the chain,
+ * and the device supports DRM modifiers, then images will be allocated
+ * with the specific requested DRM modifiers.
+ * Additional structures may be added at av_hwframe_ctx_init() time,
+ * which will be freed automatically on uninit(), so users need only free
+ * any structures they've allocated themselves.
+ */
+ void *create_pnext;
+
+ /**
+ * Extension data for memory allocation. Must have as many entries as
+ * the number of planes of the sw_format.
+ * This will be chained to VkExportMemoryAllocateInfo, which is used
+ * to make all pool images exportable to other APIs if the necessary
+ * extensions are present in enabled_dev_extensions.
+ */
+ void *alloc_pnextAV_NUM_DATA_POINTERS;
+
+ /**
+ * A combination of AVVkFrameFlags. Unless AV_VK_FRAME_FLAG_NONE is set,
+ * autodetected flags will be OR'd based on the device and tiling during
+ * av_hwframe_ctx_init().
+ */
+ AVVkFrameFlags flags;
+} AVVulkanFramesContext;
+
+/*
+ * Frame structure, the VkFormat of the image will always match
+ * the pool's sw_format.
+ * All frames, imported or allocated, will be created with the
+ * VK_IMAGE_CREATE_ALIAS_BIT flag set, so the memory may be aliased if needed.
+ *
+ * If all queue family indices in the device context are the same,
+ * images will be created with the EXCLUSIVE sharing mode. Otherwise, all images
+ * will be created using the CONCURRENT sharing mode.
+ *
+ * @note the size of this structure is not part of the ABI, to allocate
+ * you must use @av_vk_frame_alloc().
+ */
+typedef struct AVVkFrame {
+ /**
+ * Vulkan images to which the memory is bound to.
+ */
+ VkImage imgAV_NUM_DATA_POINTERS;
+
+ /**
+ * The same tiling must be used for all images in the frame.
+ */
+ VkImageTiling tiling;
+
+ /**
+ * Memory backing the images. Could be less than the amount of planes,
+ * in which case the offset value will indicate the binding offset of
+ * each plane in the memory.
+ */
+ VkDeviceMemory memAV_NUM_DATA_POINTERS;
+ size_t sizeAV_NUM_DATA_POINTERS;
+
+ /**
+ * OR'd flags for all memory allocated
+ */
+ VkMemoryPropertyFlagBits flags;
+
+ /**
+ * Updated after every barrier
+ */
+ VkAccessFlagBits accessAV_NUM_DATA_POINTERS;
+ VkImageLayout layoutAV_NUM_DATA_POINTERS;
+
+ /**
+ * Synchronization timeline semaphores, one for each sw_format plane.
+ * Must not be freed manually. Must be waited on at every submission using
+ * the value in sem_value, and must be signalled at every submission,
+ * using an incremented value.
+ */
+ VkSemaphore semAV_NUM_DATA_POINTERS;
+
+ /**
+ * Up to date semaphore value at which each image becomes accessible.
+ * Clients must wait on this value when submitting a command queue,
+ * and increment it when signalling.
+ */
+ uint64_t sem_valueAV_NUM_DATA_POINTERS;
+
+ /**
+ * Internal data.
+ */
+ struct AVVkFrameInternal *internal;
+
+ /**
+ * Describes the binding offset of each plane to the VkDeviceMemory.
+ */
+ ptrdiff_t offsetAV_NUM_DATA_POINTERS;
+} AVVkFrame;
+
+/**
+ * Allocates a single AVVkFrame and initializes everything as 0.
+ * @note Must be freed via av_free()
+ */
+AVVkFrame *av_vk_frame_alloc(void);
+
+/**
+ * Returns the format of each image up to the number of planes for a given sw_format.
+ * Returns NULL on unsupported formats.
+ */
+const VkFormat *av_vkfmt_from_pixfmt(enum AVPixelFormat p);
+
+#endif /* AVUTIL_HWCONTEXT_VULKAN_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/imgutils.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/imgutils.h Changed

@@ -68,6 +68,20 @@
 int av_image_fill_linesizes(int linesizes4, enum AVPixelFormat pix_fmt, int width);
 
 /**
+ * Fill plane sizes for an image with pixel format pix_fmt and height height.
+ *
+ * @param size the array to be filled with the size of each image plane
+ * @param linesizes the array containing the linesize for each
+ *        plane, should be filled by av_image_fill_linesizes()
+ * @return >= 0 in case of success, a negative error code otherwise
+ *
+ * @note The linesize parameters have the type ptrdiff_t here, while they are
+ *       int for av_image_fill_linesizes().
+ */
+int av_image_fill_plane_sizes(size_t size4, enum AVPixelFormat pix_fmt,
+                              int height, const ptrdiff_t linesizes4);
+
+/**
  * Fill plane data pointers for an image with pixel format pix_fmt and
  * height height.
  *
@@ -111,6 +125,24 @@
                          int bytewidth, int height);
 
 /**
+ * Copy image data located in uncacheable (e.g. GPU mapped) memory. Where
+ * available, this function will use special functionality for reading from such
+ * memory, which may result in greatly improved performance compared to plain
+ * av_image_copy_plane().
+ *
+ * bytewidth must be contained by both absolute values of dst_linesize
+ * and src_linesize, otherwise the function behavior is undefined.
+ *
+ * @note The linesize parameters have the type ptrdiff_t here, while they are
+ *       int for av_image_copy_plane().
+ * @note On x86, the linesizes currently need to be aligned to the cacheline
+ *       size (i.e. 64) to get improved performance.
+ */
+void av_image_copy_plane_uc_from(uint8_t       *dst, ptrdiff_t dst_linesize,
+                                 const uint8_t *src, ptrdiff_t src_linesize,
+                                 ptrdiff_t bytewidth, int height);
+
+/**
  * Copy image in src_data to dst_data.
  *
  * @param dst_linesizes linesizes for the image in dst_data

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/intreadwrite.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/intreadwrite.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/lfg.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/lfg.h Changed

@@ -24,6 +24,12 @@
 
 #include <stdint.h>
 
+/**
+ * Context structure for the Lagged Fibonacci PRNG.
+ * The exact layout, types and content of this struct may change and should
+ * not be accessed directly. Only its sizeof() is guranteed to stay the same
+ * to allow easy instanciation.
+ */
 typedef struct AVLFG {
 unsigned int state64;
 int index;
@@ -45,8 +51,9 @@
 * it may be good enough and faster for your specific use case.
 */
 static inline unsigned int av_lfg_get(AVLFG *c){
- c->statec->index & 63 = c->state(c->index-24) & 63 + c->state(c->index-55) & 63;
- return c->statec->index++ & 63;
+ unsigned a = c->statec->index & 63 = c->state(c->index-24) & 63 + c->state(c->index-55) & 63;
+ c->index += 1U;
+ return a;
 }
 
 /**
@@ -57,7 +64,9 @@
 static inline unsigned int av_mlfg_get(AVLFG *c){
 unsigned int a= c->state(c->index-55) & 63;
 unsigned int b= c->state(c->index-24) & 63;
- return c->statec->index++ & 63 = 2*a*b+a+b;
+ a = c->statec->index & 63 = 2*a*b+a+b;
+ c->index += 1U;
+ return a;
 }
 
 /**

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/log.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/log.h Changed

@@ -24,7 +24,6 @@
 #include <stdarg.h>
 #include "avutil.h"
 #include "attributes.h"
-#include "version.h"
 
 typedef enum {
 AV_CLASS_CATEGORY_NA = 0,
@@ -108,21 +107,6 @@
 int parent_log_context_offset;
 
 /**
- * Return next AVOptions-enabled child or NULL
- */
- void* (*child_next)(void *obj, void *prev);
-
- /**
- * Return an AVClass corresponding to the next potential
- * AVOptions-enabled child.
- *
- * The difference between child_next and this is that
- * child_next iterates over _already existing_ objects, while
- * child_class_next iterates over _all possible_ children.
- */
- const struct AVClass* (*child_class_next)(const struct AVClass *prev);
-
- /**
 * Category used for visualization (like color)
 * This is only set if the category is equal for all objects using this class.
 * available since version (51 << 16 | 56 << 8 | 100)
@@ -140,6 +124,26 @@
 * available since version (52.12)
 */
 int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
+
+ /**
+ * Return next AVOptions-enabled child or NULL
+ */
+ void* (*child_next)(void *obj, void *prev);
+
+ /**
+ * Iterate over the AVClasses corresponding to potential AVOptions-enabled
+ * children.
+ *
+ * @param iter pointer to opaque iteration state. The caller must initialize
+ * *iter to NULL before the first call.
+ * @return AVClass for the next AVOptions-enabled child or NULL if there are
+ * no more such children.
+ *
+ * @note The difference between child_next and this is that child_next
+ * iterates over _already existing_ objects, while child_class_iterate
+ * iterates over _all possible_ children.
+ */
+ const struct AVClass* (*child_class_iterate)(void **iter);
 } AVClass;
 
 /**
@@ -233,6 +237,27 @@
 */
 void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
 
+/**
+ * Send the specified message to the log once with the initial_level and then with
+ * the subsequent_level. By default, all logging messages are sent to
+ * stderr. This behavior can be altered by setting a different logging callback
+ * function.
+ * @see av_log
+ *
+ * @param avcl A pointer to an arbitrary struct of which the first field is a
+ * pointer to an AVClass struct or NULL if general log.
+ * @param initial_level importance level of the message expressed using a @ref
+ * lavu_log_constants "Logging Constant" for the first occurance.
+ * @param subsequent_level importance level of the message expressed using a @ref
+ * lavu_log_constants "Logging Constant" after the first occurance.
+ * @param fmt The format string (printf-compatible) that specifies how
+ * subsequent arguments are converted to output.
+ * @param state a variable to keep trak of if a message has already been printed
+ * this must be initialized to 0 before the first use. The same state
+ * must not be accessed by 2 Threads simultaneously.
+ */
+void av_log_once(void* avcl, int initial_level, int subsequent_level, int *state, const char *fmt, ...) av_printf_format(5, 6);
+
 
 /**
 * Send the specified message to the log if the level is less than or equal

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/macros.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/macros.h Changed

@@ -25,6 +25,36 @@
 #ifndef AVUTIL_MACROS_H
 #define AVUTIL_MACROS_H
 
+#include "libavutil/avconfig.h"
+
+#if AV_HAVE_BIGENDIAN
+# define AV_NE(be, le) (be)
+#else
+# define AV_NE(be, le) (le)
+#endif
+
+/**
+ * Comparator.
+ * For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0
+ * if x == y. This is useful for instance in a qsort comparator callback.
+ * Furthermore, compilers are able to optimize this to branchless code, and
+ * there is no risk of overflow with signed types.
+ * As with many macros, this evaluates its argument multiple times, it thus
+ * must not have a side-effect.
+ */
+#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
+
+#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
+#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
+#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
+#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
+
+#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
+#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)0))
+
+#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
+#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
+
 /**
 * @addtogroup preproc_misc Preprocessor String Macros
 *

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/mathematics.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/mathematics.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/md5.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/md5.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/mem.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/mem.h Changed

@@ -31,8 +31,8 @@
 #include <stdint.h>
 
 #include "attributes.h"
-#include "error.h"
 #include "avutil.h"
+#include "version.h"
 
 /**
 * @addtogroup lavu_mem
@@ -49,6 +49,10 @@
 * dealing with memory consistently possible on all platforms.
 *
 * @{
+ */
+
+#if FF_API_DECLARE_ALIGNED
+/**
 *
 * @defgroup lavu_mem_macros Alignment Macros
 * Helper macros for declaring aligned variables.
@@ -125,6 +129,7 @@
 /**
 * @}
 */
+#endif
 
 /**
 * @defgroup lavu_mem_attrs Function Attributes
@@ -232,14 +237,15 @@
 * @see av_mallocz()
 * @see av_malloc_array()
 */
-av_alloc_size(1, 2) void *av_mallocz_array(size_t nmemb, size_t size);
+void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
 
+#if FF_API_AV_MALLOCZ_ARRAY
 /**
- * Non-inlined equivalent of av_mallocz_array().
- *
- * Created for symmetry with the calloc() C function.
+ * @deprecated use av_calloc()
 */
-void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
+attribute_deprecated
+void *av_mallocz_array(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
+#endif
 
 /**
 * Allocate, reallocate, or free a block of memory.
@@ -339,7 +345,7 @@
 * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
 * correctly aligned.
 */
-av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
+int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
 
 /**
 * Reallocate the given buffer if it is not large enough, otherwise do nothing.
@@ -363,10 +369,10 @@
 * @endcode
 *
 * @paramin,out ptr Already allocated buffer, or `NULL`
- * @paramin,out size Pointer to current size of buffer `ptr`. `*size` is
- * changed to `min_size` in case of success or 0 in
- * case of failure
- * @paramin min_size New size of buffer `ptr`
+ * @paramin,out size Pointer to the size of buffer `ptr`. `*size` is
+ * updated to the new allocated size, in particular 0
+ * in case of failure.
+ * @paramin min_size Desired minimal size of buffer `ptr`
 * @return `ptr` if the buffer is large enough, a pointer to newly reallocated
 * buffer if the buffer was not large enough, or `NULL` in case of
 * error
@@ -397,10 +403,10 @@
 * @paramin,out ptr Pointer to pointer to an already allocated buffer.
 * `*ptr` will be overwritten with pointer to new
 * buffer on success or `NULL` on failure
- * @paramin,out size Pointer to current size of buffer `*ptr`. `*size` is
- * changed to `min_size` in case of success or 0 in
- * case of failure
- * @paramin min_size New size of buffer `*ptr`
+ * @paramin,out size Pointer to the size of buffer `*ptr`. `*size` is
+ * updated to the new allocated size, in particular 0
+ * in case of failure.
+ * @paramin min_size Desired minimal size of buffer `*ptr`
 * @see av_realloc()
 * @see av_fast_mallocz()
 */
@@ -418,10 +424,10 @@
 * @paramin,out ptr Pointer to pointer to an already allocated buffer.
 * `*ptr` will be overwritten with pointer to new
 * buffer on success or `NULL` on failure
- * @paramin,out size Pointer to current size of buffer `*ptr`. `*size` is
- * changed to `min_size` in case of success or 0 in
- * case of failure
- * @paramin min_size New size of buffer `*ptr`
+ * @paramin,out size Pointer to the size of buffer `*ptr`. `*size` is
+ * updated to the new allocated size, in particular 0
+ * in case of failure.
+ * @paramin min_size Desired minimal size of buffer `*ptr`
 * @see av_fast_malloc()
 */
 void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size);
@@ -666,16 +672,7 @@
 * @paramout r Pointer to the result of the operation
 * @return 0 on success, AVERROR(EINVAL) on overflow
 */
-static inline int av_size_mult(size_t a, size_t b, size_t *r)
-{
- size_t t = a * b;
- /* Hack inspired from glibc: don't try the division if nelem and elsize
- * are both less than sqrt(SIZE_MAX). */
- if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
- return AVERROR(EINVAL);
- *r = t;
- return 0;
-}
+int av_size_mult(size_t a, size_t b, size_t *r);
 
 /**
 * Set the maximum size that may be allocated in one block.

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/murmur3.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/murmur3.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/opt.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/opt.h Changed

@@ -33,7 +33,6 @@
 #include "log.h"
 #include "pixfmt.h"
 #include "samplefmt.h"
-#include "version.h"
 
 /**
 * @defgroup avoptions AVOptions
@@ -114,7 +113,7 @@
 * libavcodec exports generic options, while its priv_data field exports
 * codec-specific options). In such a case, it is possible to set up the
 * parent struct to export a child's options. To do that, simply
- * implement AVClass.child_next() and AVClass.child_class_next() in the
+ * implement AVClass.child_next() and AVClass.child_class_iterate() in the
 * parent struct's AVClass.
 * Assuming that the test_struct from above now also contains a
 * child_struct field:
@@ -143,23 +142,25 @@
 * return t->child_struct;
 * return NULL
 * }
- * const AVClass child_class_next(const AVClass *prev)
+ * const AVClass child_class_iterate(void **iter)
 * {
- * return prev ? NULL : &child_class;
+ * const AVClass *c = *iter ? NULL : &child_class;
+ * *iter = (void*)(uintptr_t)c;
+ * return c;
 * }
 * @endcode
- * Putting child_next() and child_class_next() as defined above into
+ * Putting child_next() and child_class_iterate() as defined above into
 * test_class will now make child_struct's options accessible through
 * test_struct (again, proper setup as described above needs to be done on
 * child_struct right after it is created).
 *
 * From the above example it might not be clear why both child_next()
- * and child_class_next() are needed. The distinction is that child_next()
- * iterates over actually existing objects, while child_class_next()
+ * and child_class_iterate() are needed. The distinction is that child_next()
+ * iterates over actually existing objects, while child_class_iterate()
 * iterates over all possible child classes. E.g. if an AVCodecContext
 * was initialized to use a codec which has private options, then its
 * child_next() will return AVCodecContext.priv_data and finish
- * iterating. OTOH child_class_next() on AVCodecContext.av_class will
+ * iterating. OTOH child_class_iterate() on AVCodecContext.av_class will
 * iterate over all available codecs with private options.
 *
 * @subsection avoptions_implement_named_constants Named constants
@@ -194,7 +195,7 @@
 * For enumerating there are basically two cases. The first is when you want to
 * get all options that may potentially exist on the struct and its children
 * (e.g. when constructing documentation). In that case you should call
- * av_opt_child_class_next() recursively on the parent struct's AVClass. The
+ * av_opt_child_class_iterate() recursively on the parent struct's AVClass. The
 * second case is when you have an already initialized struct with all its
 * children and you want to get all options that can be actually written or read
 * from it. In that case you should call av_opt_child_next() recursively (and
@@ -288,7 +289,10 @@
 */
 #define AV_OPT_FLAG_READONLY 128
 #define AV_OPT_FLAG_BSF_PARAM (1<<8) ///< a generic parameter which can be set by the user for bit stream filtering
+#define AV_OPT_FLAG_RUNTIME_PARAM (1<<15) ///< a generic parameter which can be set by the user at runtime
 #define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
+#define AV_OPT_FLAG_DEPRECATED (1<<17) ///< set if option is deprecated, users should refer to AVOption.help text for more information
+#define AV_OPT_FLAG_CHILD_CONSTS (1<<18) ///< set if option constants can also reside in child objects
 //FIXME think about enc-audio, ... style flags
 
 /**
@@ -646,10 +650,10 @@
 /**
 * Iterate over potential AVOptions-enabled children of parent.
 *
- * @param prev result of a previous call to this function or NULL
+ * @param iter a pointer where iteration state is stored.
 * @return AVClass corresponding to next potential child or NULL
 */
-const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev);
+const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter);
 
 /**
 * @defgroup opt_set_funcs Option setting functions
@@ -668,6 +672,9 @@
 * scalars or named flags separated by '+' or '-'. Prefixing a flag
 * with '+' causes it to be set without affecting the other flags;
 * similarly, '-' unsets a flag.
+ * If the field is of a dictionary type, it has to be a ':' separated list of
+ * key=value parameters. Values containing ':' special characters must be
+ * escaped.
 * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
 * is passed here, then the option may be set on a child of obj.
 *
@@ -728,9 +735,10 @@
 /**
 * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
 *
- * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has
- * AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set
- * to NULL instead of an allocated empty string.
+ * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the
+ * option is of type AV_OPT_TYPE_STRING, AV_OPT_TYPE_BINARY or AV_OPT_TYPE_DICT
+ * and is set to NULL, *out_val will be set to NULL instead of an allocated
+ * empty string.
 */
 int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val);
 int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val);
@@ -782,9 +790,16 @@
 /**
 * Copy options from src object into dest object.
 *
+ * The underlying AVClass of both src and dest must coincide. The guarantee
+ * below does not apply if this is not fulfilled.
+ *
 * Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object.
 * Original memory allocated for such options is freed unless both src and dest options points to the same memory.
 *
+ * Even on error it is guaranteed that allocated options from src and dest
+ * no longer alias each other afterwards; in particular calling av_opt_free()
+ * on both src and dest is safe afterwards if dest has been memdup'ed from src.
+ *
 * @param dest Object to copy from
 * @param src Object to copy into
 * @return 0 on success, negative on error

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/pixdesc.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/pixdesc.h Changed

@@ -26,7 +26,6 @@
 
 #include "attributes.h"
 #include "pixfmt.h"
-#include "version.h"
 
 typedef struct AVComponentDescriptor {
 /**
@@ -56,17 +55,6 @@
 * Number of bits in the component.
 */
 int depth;
-
-#if FF_API_PLUS1_MINUS1
- /** deprecated, use step instead */
- attribute_deprecated int step_minus1;
-
- /** deprecated, use depth instead */
- attribute_deprecated int depth_minus1;
-
- /** deprecated, use offset instead */
- attribute_deprecated int offset_plus1;
-#endif
 } AVComponentDescriptor;
 
 /**
@@ -148,31 +136,9 @@
 #define AV_PIX_FMT_FLAG_RGB (1 << 5)
 
 /**
- * The pixel format is "pseudo-paletted". This means that it contains a
- * fixed palette in the 2nd plane but the palette is fixed/constant for each
- * PIX_FMT. This allows interpreting the data as if it was PAL8, which can
- * in some cases be simpler. Or the data can be interpreted purely based on
- * the pixel format without using the palette.
- * An example of a pseudo-paletted format is AV_PIX_FMT_GRAY8
- *
- * @deprecated This flag is deprecated, and will be removed. When it is removed,
- * the extra palette allocation in AVFrame.data1 is removed as well. Only
- * actual paletted formats (as indicated by AV_PIX_FMT_FLAG_PAL) will have a
- * palette. Starting with FFmpeg versions which have this flag deprecated, the
- * extra "pseudo" palette is already ignored, and API users are not required to
- * allocate a palette for AV_PIX_FMT_FLAG_PSEUDOPAL formats (it was required
- * before the deprecation, though).
- */
-#define AV_PIX_FMT_FLAG_PSEUDOPAL (1 << 6)
-
-/**
 * The pixel format has an alpha channel. This is set on all formats that
- * support alpha in some way. The exception is AV_PIX_FMT_PAL8, which can
- * carry alpha as part of the palette. Details are explained in the
- * AVPixelFormat enum, and are also encoded in the corresponding
- * AVPixFmtDescriptor.
- *
- * The alpha is always straight, never pre-multiplied.
+ * support alpha in some way, including AV_PIX_FMT_PAL8. The alpha is always
+ * straight, never pre-multiplied.
 *
 * If a codec or a filter does not support alpha, it should set all alpha to
 * opaque, or use the equivalent pixel formats without alpha component, e.g.
@@ -347,7 +313,13 @@
 * format writes the values corresponding to the palette
 * component c in data1 to dst, rather than the palette indexes in
 * data0. The behavior is undefined if the format is not paletted.
+ * @param dst_element_size size of elements in dst array (2 or 4 byte)
 */
+void av_read_image_line2(void *dst, const uint8_t *data4,
+ const int linesize4, const AVPixFmtDescriptor *desc,
+ int x, int y, int c, int w, int read_pal_component,
+ int dst_element_size);
+
 void av_read_image_line(uint16_t *dst, const uint8_t *data4,
 const int linesize4, const AVPixFmtDescriptor *desc,
 int x, int y, int c, int w, int read_pal_component);
@@ -365,7 +337,12 @@
 * @param y the vertical coordinate of the first pixel to write
 * @param w the width of the line to write, that is the number of
 * values to write to the image line
+ * @param src_element_size size of elements in src array (2 or 4 byte)
 */
+void av_write_image_line2(const void *src, uint8_t *data4,
+ const int linesize4, const AVPixFmtDescriptor *desc,
+ int x, int y, int c, int w, int src_element_size);
+
 void av_write_image_line(const uint16_t *src, uint8_t *data4,
 const int linesize4, const AVPixFmtDescriptor *desc,
 int x, int y, int c, int w);

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/pixfmt.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/pixfmt.h Changed

@@ -42,6 +42,10 @@
 * This is stored as BGRA on little-endian CPU architectures and ARGB on
 * big-endian CPUs.
 *
+ * @note
+ * If the resolution is not a multiple of the chroma subsampling factor
+ * then the chroma plane resolution must be rounded up.
+ *
 * @par
 * When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized
 * image data is stored in AVFrame.data0. The palette is transported in
@@ -108,21 +112,11 @@
 AV_PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
 AV_PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
 
-#if FF_API_VAAPI
- /** @name Deprecated pixel formats */
- /**@{*/
- AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data3 contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
- AV_PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data3 contains a vaapi_render_state struct which contains fields extracted from headers
- AV_PIX_FMT_VAAPI_VLD, ///< HW decoding through VA API, Picture.data3 contains a VASurfaceID
- /**@}*/
- AV_PIX_FMT_VAAPI = AV_PIX_FMT_VAAPI_VLD,
-#else
 /**
 * Hardware acceleration through VA-API, data3 contains a
 * VASurfaceID.
 */
 AV_PIX_FMT_VAAPI,
-#endif
 
 AV_PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
 AV_PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
@@ -253,18 +247,18 @@
 AV_PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian
 AV_PIX_FMT_YUVJ411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
 
- AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples */
- AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian */
- AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian */
- AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian */
- AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian */
- AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian */
+ AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
+ AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
+ AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
+ AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
+ AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
+ AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
+ AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
+ AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
+ AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
+ AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
+ AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
+ AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
 
 AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing
 
@@ -330,6 +324,47 @@
 */
 AV_PIX_FMT_OPENCL,
 
+ AV_PIX_FMT_GRAY14BE, ///< Y , 14bpp, big-endian
+ AV_PIX_FMT_GRAY14LE, ///< Y , 14bpp, little-endian
+
+ AV_PIX_FMT_GRAYF32BE, ///< IEEE-754 single precision Y, 32bpp, big-endian
+ AV_PIX_FMT_GRAYF32LE, ///< IEEE-754 single precision Y, 32bpp, little-endian
+
+ AV_PIX_FMT_YUVA422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
+ AV_PIX_FMT_YUVA422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
+ AV_PIX_FMT_YUVA444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
+ AV_PIX_FMT_YUVA444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
+
+ AV_PIX_FMT_NV24, ///< planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
+ AV_PIX_FMT_NV42, ///< as above, but U and V bytes are swapped
+
+ /**
+ * Vulkan hardware images.
+ *
+ * data0 points to an AVVkFrame
+ */
+ AV_PIX_FMT_VULKAN,
+
+ AV_PIX_FMT_Y210BE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian
+ AV_PIX_FMT_Y210LE, ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
+
+ AV_PIX_FMT_X2RGB10LE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
+ AV_PIX_FMT_X2RGB10BE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
+ AV_PIX_FMT_X2BGR10LE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
+ AV_PIX_FMT_X2BGR10BE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined
+
+ AV_PIX_FMT_P210BE, ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
+ AV_PIX_FMT_P210LE, ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
+
+ AV_PIX_FMT_P410BE, ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
+ AV_PIX_FMT_P410LE, ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
+
+ AV_PIX_FMT_P216BE, ///< interleaved chroma YUV 4:2:2, 32bpp, big-endian
+ AV_PIX_FMT_P216LE, ///< interleaved chroma YUV 4:2:2, 32bpp, liddle-endian
+
+ AV_PIX_FMT_P416BE, ///< interleaved chroma YUV 4:4:4, 48bpp, big-endian
+ AV_PIX_FMT_P416LE, ///< interleaved chroma YUV 4:4:4, 48bpp, little-endian
+
 AV_PIX_FMT_NB ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
 };
 
@@ -349,6 +384,7 @@
 #define AV_PIX_FMT_GRAY9 AV_PIX_FMT_NE(GRAY9BE, GRAY9LE)
 #define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE)
 #define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE)
+#define AV_PIX_FMT_GRAY14 AV_PIX_FMT_NE(GRAY14BE, GRAY14LE)
 #define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
 #define AV_PIX_FMT_YA16 AV_PIX_FMT_NE(YA16BE, YA16LE)
 #define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE)
@@ -397,12 +433,16 @@
 #define AV_PIX_FMT_GBRPF32 AV_PIX_FMT_NE(GBRPF32BE, GBRPF32LE)
 #define AV_PIX_FMT_GBRAPF32 AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)
 
+#define AV_PIX_FMT_GRAYF32 AV_PIX_FMT_NE(GRAYF32BE, GRAYF32LE)
+
 #define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
 #define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
 #define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
 #define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE)
 #define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE)
 #define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE)
+#define AV_PIX_FMT_YUVA422P12 AV_PIX_FMT_NE(YUVA422P12BE, YUVA422P12LE)
+#define AV_PIX_FMT_YUVA444P12 AV_PIX_FMT_NE(YUVA444P12BE, YUVA444P12LE)
 #define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE)
 #define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE)
 #define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE)
@@ -413,33 +453,43 @@
 #define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE)
 #define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE)
 
+#define AV_PIX_FMT_Y210 AV_PIX_FMT_NE(Y210BE, Y210LE)
+#define AV_PIX_FMT_X2RGB10 AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE)
+#define AV_PIX_FMT_X2BGR10 AV_PIX_FMT_NE(X2BGR10BE, X2BGR10LE)
+
+#define AV_PIX_FMT_P210 AV_PIX_FMT_NE(P210BE, P210LE)
+#define AV_PIX_FMT_P410 AV_PIX_FMT_NE(P410BE, P410LE)
+#define AV_PIX_FMT_P216 AV_PIX_FMT_NE(P216BE, P216LE)
+#define AV_PIX_FMT_P416 AV_PIX_FMT_NE(P416BE, P416LE)
+
 /**
 * Chromaticity coordinates of the source primaries.
- * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.1.
+ * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273.
 */
 enum AVColorPrimaries {
 AVCOL_PRI_RESERVED0 = 0,
- AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
+ AVCOL_PRI_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
 AVCOL_PRI_UNSPECIFIED = 2,
 AVCOL_PRI_RESERVED = 3,
 AVCOL_PRI_BT470M = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
 
 AVCOL_PRI_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
 AVCOL_PRI_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
- AVCOL_PRI_SMPTE240M = 7, ///< functionally identical to above
+ AVCOL_PRI_SMPTE240M = 7, ///< identical to above, also called "SMPTE C" even though it uses D65
 AVCOL_PRI_FILM = 8, ///< colour filters using Illuminant C
 AVCOL_PRI_BT2020 = 9, ///< ITU-R BT2020
 AVCOL_PRI_SMPTE428 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
 AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428,
 AVCOL_PRI_SMPTE431 = 11, ///< SMPTE ST 431-2 (2011) / DCI P3
 AVCOL_PRI_SMPTE432 = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3
- AVCOL_PRI_JEDEC_P22 = 22, ///< JEDEC P22 phosphors
+ AVCOL_PRI_EBU3213 = 22, ///< EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors
+ AVCOL_PRI_JEDEC_P22 = AVCOL_PRI_EBU3213,
 AVCOL_PRI_NB ///< Not part of ABI
 };
 
 /**
 * Color Transfer Characteristic.
- * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.2.
+ * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2.
 */
 enum AVColorTransferCharacteristic {
 AVCOL_TRC_RESERVED0 = 0,
@@ -468,18 +518,18 @@
 
 /**
 * YUV colorspace type.
- * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.3.
+ * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3.
 */
 enum AVColorSpace {
- AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
- AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
+ AVCOL_SPC_RGB = 0, ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
+ AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
 AVCOL_SPC_UNSPECIFIED = 2,
- AVCOL_SPC_RESERVED = 3,
+ AVCOL_SPC_RESERVED = 3, ///< reserved for future use by ITU-T and ISO/IEC just like 15-255 are
 AVCOL_SPC_FCC = 4, ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
 AVCOL_SPC_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
- AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
- AVCOL_SPC_SMPTE240M = 7, ///< functionally identical to above
- AVCOL_SPC_YCGCO = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
+ AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
+ AVCOL_SPC_SMPTE240M = 7, ///< derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
+ AVCOL_SPC_YCGCO = 8, ///< used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
 AVCOL_SPC_YCOCG = AVCOL_SPC_YCGCO,
 AVCOL_SPC_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system
 AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system
@@ -491,12 +541,60 @@
 };
 
 /**
- * MPEG vs JPEG YUV range.
+ * Visual content value range.
+ *
+ * These values are based on definitions that can be found in multiple
+ * specifications, such as ITU-T BT.709 (3.4 - Quantization of RGB, luminance
+ * and colour-difference signals), ITU-T BT.2020 (Table 5 - Digital
+ * Representation) as well as ITU-T BT.2100 (Table 9 - Digital 10- and 12-bit
+ * integer representation). At the time of writing, the BT.2100 one is
+ * recommended, as it also defines the full range representation.
+ *
+ * Common definitions:
+ * - For RGB and luma planes such as Y in YCbCr and I in ICtCp,
+ * 'E' is the original value in range of 0.0 to 1.0.
+ * - For chroma planes such as Cb,Cr and Ct,Cp, 'E' is the original
+ * value in range of -0.5 to 0.5.
+ * - 'n' is the output bit depth.
+ * - For additional definitions such as rounding and clipping to valid n
+ * bit unsigned integer range, please refer to BT.2100 (Table 9).
 */
 enum AVColorRange {
 AVCOL_RANGE_UNSPECIFIED = 0,
- AVCOL_RANGE_MPEG = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
- AVCOL_RANGE_JPEG = 2, ///< the normal 2^n-1 "JPEG" YUV ranges
+
+ /**
+ * Narrow or limited range content.
+ *
+ * - For luma planes:
+ *
+ * (219 * E + 16) * 2^(n-8)
+ *
+ * F.ex. the range of 16-235 for 8 bits
+ *
+ * - For chroma planes:
+ *
+ * (224 * E + 128) * 2^(n-8)
+ *
+ * F.ex. the range of 16-240 for 8 bits
+ */
+ AVCOL_RANGE_MPEG = 1,
+
+ /**
+ * Full range content.
+ *
+ * - For RGB and luma planes:
+ *
+ * (2^n - 1) * E
+ *
+ * F.ex. the range of 0-255 for 8 bits
+ *
+ * - For chroma planes:
+ *
+ * (2^n - 1) * E + 2^(n - 1)
+ *
+ * F.ex. the range of 1-255 for 8 bits
+ */
+ AVCOL_RANGE_JPEG = 2,
 AVCOL_RANGE_NB ///< Not part of ABI
 };

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/rational.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/rational.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/ripemd.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/ripemd.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/samplefmt.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/samplefmt.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/sha.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/sha.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/sha512.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/sha512.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/threadmessage.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/threadmessage.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/timecode.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/timecode.h Changed

@@ -49,9 +49,9 @@
  * Adjust frame number for NTSC drop frame time code.
  *
  * @param framenum frame number to adjust
- * @param fps      frame per second, 30 or 60
+ * @param fps      frame per second, multiples of 30
  * @return         adjusted frame number
- * @warning        adjustment is only valid in NTSC 29.97 and 59.94
+ * @warning        adjustment is only valid for multiples of NTSC 29.97
  */
 int av_timecode_adjust_ntsc_framenum2(int framenum, int fps);
 
@@ -62,15 +62,40 @@
  * @param framenum frame number
  * @return         the SMPTE binary representation
  *
+ * See SMPTE ST 314M-2005 Sec 4.4.2.2.1 "Time code pack (TC)"
+ * the format description as follows:
+ * bits 0-5:   hours, in BCD(6bits)
+ * bits 6:     BGF1
+ * bits 7:     BGF2 (NTSC) or FIELD (PAL)
+ * bits 8-14:  minutes, in BCD(7bits)
+ * bits 15:    BGF0 (NTSC) or BGF2 (PAL)
+ * bits 16-22: seconds, in BCD(7bits)
+ * bits 23:    FIELD (NTSC) or BGF0 (PAL)
+ * bits 24-29: frames, in BCD(6bits)
+ * bits 30:    drop  frame flag (0: non drop,    1: drop)
+ * bits 31:    color frame flag (0: unsync mode, 1: sync mode)
+ * @note BCD numbers (6 or 7 bits): 4 or 5 lower bits for units, 2 higher bits for tens.
  * @note Frame number adjustment is automatically done in case of drop timecode,
  *       you do NOT have to call av_timecode_adjust_ntsc_framenum2().
  * @note The frame number is relative to tc->start.
- * @note Color frame (CF), binary group flags (BGF) and biphase mark polarity
- *       correction (PC) bits are set to zero.
+ * @note Color frame (CF) and binary group flags (BGF) bits are set to zero.
  */
 uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum);
 
 /**
+ * Convert sei info to SMPTE 12M binary representation.
+ *
+ * @param rate     frame rate in rational form
+ * @param drop     drop flag
+ * @param hh       hour
+ * @param mm       minute
+ * @param ss       second
+ * @param ff       frame number
+ * @return         the SMPTE binary representation
+ */
+uint32_t av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff);
+
+/**
  * Load timecode string in buf.
  *
  * @param buf      destination buffer, must be at least AV_TIMECODE_STR_SIZE long
@@ -87,6 +112,23 @@
 /**
  * Get the timecode string from the SMPTE timecode format.
  *
+ * In contrast to av_timecode_make_smpte_tc_string this function supports 50/60
+ * fps timecodes by using the field bit.
+ *
+ * @param buf        destination buffer, must be at least AV_TIMECODE_STR_SIZE long
+ * @param rate       frame rate of the timecode
+ * @param tcsmpte    the 32-bit SMPTE timecode
+ * @param prevent_df prevent the use of a drop flag when it is known the DF bit
+ *                   is arbitrary
+ * @param skip_field prevent the use of a field flag when it is known the field
+ *                   bit is arbitrary (e.g. because it is used as PC flag)
+ * @return           the buf parameter
+ */
+char *av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field);
+
+/**
+ * Get the timecode string from the SMPTE timecode format.
+ *
  * @param buf        destination buffer, must be at least AV_TIMECODE_STR_SIZE long
  * @param tcsmpte    the 32-bit SMPTE timecode
  * @param prevent_df prevent the use of a drop flag when it is known the DF bit
@@ -119,6 +161,23 @@
 int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx);
 
 /**
+ * Init a timecode struct from the passed timecode components.
+ *
+ * @param log_ctx     a pointer to an arbitrary struct of which the first field
+ *                    is a pointer to an AVClass struct (used for av_log)
+ * @param tc          pointer to an allocated AVTimecode
+ * @param rate        frame rate in rational form
+ * @param flags       miscellaneous flags such as drop frame, +24 hours, ...
+ *                    (see AVTimecodeFlag)
+ * @param hh          hours
+ * @param mm          minutes
+ * @param ss          seconds
+ * @param ff          frames
+ * @return            0 on success, AVERROR otherwise
+ */
+int av_timecode_init_from_components(AVTimecode *tc, AVRational rate, int flags, int hh, int mm, int ss, int ff, void *log_ctx);
+
+/**
  * Parse timecode representation (hh:mm:ss:;.ff).
  *
  * @param log_ctx a pointer to an arbitrary struct of which the first field is a

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/tree.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/tree.h Changed

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/tx.h Added

@@ -0,0 +1,152 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_TX_H
+#define AVUTIL_TX_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef struct AVTXContext AVTXContext;
+
+typedef struct AVComplexFloat {
+ float re, im;
+} AVComplexFloat;
+
+typedef struct AVComplexDouble {
+ double re, im;
+} AVComplexDouble;
+
+typedef struct AVComplexInt32 {
+ int32_t re, im;
+} AVComplexInt32;
+
+enum AVTXType {
+ /**
+ * Standard complex to complex FFT with sample data type AVComplexFloat.
+ * Output is not 1/len normalized. Scaling currently unsupported.
+ * The stride parameter is ignored.
+ */
+ AV_TX_FLOAT_FFT = 0,
+
+ /**
+ * Standard MDCT with sample data type of float and a scale type of
+ * float. Length is the frame size, not the window size (which is 2x frame)
+ * For forward transforms, the stride specifies the spacing between each
+ * sample in the output array in bytes. The input must be a flat array.
+ *
+ * For inverse transforms, the stride specifies the spacing between each
+ * sample in the input array in bytes. The output will be a flat array.
+ * Stride must be a non-zero multiple of sizeof(float).
+ *
+ * NOTE: the inverse transform is half-length, meaning the output will not
+ * contain redundant data. This is what most codecs work with. To do a full
+ * inverse transform, set the AV_TX_FULL_IMDCT flag on init.
+ */
+ AV_TX_FLOAT_MDCT = 1,
+
+ /**
+ * Same as AV_TX_FLOAT_FFT with a data type of AVComplexDouble.
+ */
+ AV_TX_DOUBLE_FFT = 2,
+
+ /**
+ * Same as AV_TX_FLOAT_MDCT with data and scale type of double.
+ * Stride must be a non-zero multiple of sizeof(double).
+ */
+ AV_TX_DOUBLE_MDCT = 3,
+
+ /**
+ * Same as AV_TX_FLOAT_FFT with a data type of AVComplexInt32.
+ */
+ AV_TX_INT32_FFT = 4,
+
+ /**
+ * Same as AV_TX_FLOAT_MDCT with data type of int32_t and scale type of float.
+ * Only scale values less than or equal to 1.0 are supported.
+ * Stride must be a non-zero multiple of sizeof(int32_t).
+ */
+ AV_TX_INT32_MDCT = 5,
+};
+
+/**
+ * Function pointer to a function to perform the transform.
+ *
+ * @note Using a different context than the one allocated during av_tx_init()
+ * is not allowed.
+ *
+ * @param s the transform context
+ * @param out the output array
+ * @param in the input array
+ * @param stride the input or output stride in bytes
+ *
+ * The out and in arrays must be aligned to the maximum required by the CPU
+ * architecture unless the AV_TX_UNALIGNED flag was set in av_tx_init().
+ * The stride must follow the constraints the transform type has specified.
+ */
+typedef void (*av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride);
+
+/**
+ * Flags for av_tx_init()
+ */
+enum AVTXFlags {
+ /**
+ * Performs an in-place transformation on the input. The output argument
+ * of av_tn_fn() MUST match the input. May be unsupported or slower for some
+ * transform types.
+ */
+ AV_TX_INPLACE = 1ULL << 0,
+
+ /**
+ * Relaxes alignment requirement for the in and out arrays of av_tx_fn().
+ * May be slower with certain transform types.
+ */
+ AV_TX_UNALIGNED = 1ULL << 1,
+
+ /**
+ * Performs a full inverse MDCT rather than leaving out samples that can be
+ * derived through symmetry. Requires an output array of 'len' floats,
+ * rather than the usual 'len/2' floats.
+ * Ignored for all transforms but inverse MDCTs.
+ */
+ AV_TX_FULL_IMDCT = 1ULL << 2,
+};
+
+/**
+ * Initialize a transform context with the given configuration
+ * (i)MDCTs with an odd length are currently not supported.
+ *
+ * @param ctx the context to allocate, will be NULL on error
+ * @param tx pointer to the transform function pointer to set
+ * @param type type the type of transform
+ * @param inv whether to do an inverse or a forward transform
+ * @param len the size of the transform in samples
+ * @param scale pointer to the value to scale the output if supported by type
+ * @param flags a bitmask of AVTXFlags or 0
+ *
+ * @return 0 on success, negative error code on failure
+ */
+int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type,
+ int inv, int len, const void *scale, uint64_t flags);
+
+/**
+ * Frees a context and sets ctx to NULL, does nothing when ctx == NULL
+ */
+void av_tx_uninit(AVTXContext **ctx);
+
+#endif /* AVUTIL_TX_H */

gpac-2.0.0.tar.gz/extra_lib/include/libavutil/version.h -> gpac-2.2.0.tar.gz/extra_lib/include/libavutil/version.h Changed

@@ -78,8 +78,8 @@
 * @{
 */
 
-#define LIBAVUTIL_VERSION_MAJOR 56
-#define LIBAVUTIL_VERSION_MINOR 14
+#define LIBAVUTIL_VERSION_MAJOR 57
+#define LIBAVUTIL_VERSION_MINOR 17
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
@@ -105,31 +105,10 @@
 * @{
 */
 
-#ifndef FF_API_VAAPI
-#define FF_API_VAAPI (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_FRAME_QP
-#define FF_API_FRAME_QP (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_PLUS1_MINUS1
-#define FF_API_PLUS1_MINUS1 (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_ERROR_FRAME
-#define FF_API_ERROR_FRAME (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_PKT_PTS
-#define FF_API_PKT_PTS (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_CRYPTO_SIZE_T
-#define FF_API_CRYPTO_SIZE_T (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_FRAME_GET_SET
-#define FF_API_FRAME_GET_SET (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_PSEUDOPAL
-#define FF_API_PSEUDOPAL (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
-
+#define FF_API_D2STR (LIBAVUTIL_VERSION_MAJOR < 58)
+#define FF_API_DECLARE_ALIGNED (LIBAVUTIL_VERSION_MAJOR < 58)
+#define FF_API_COLORSPACE_NAME (LIBAVUTIL_VERSION_MAJOR < 58)
+#define FF_API_AV_MALLOCZ_ARRAY (LIBAVUTIL_VERSION_MAJOR < 58)
 
 /**
 * @}

gpac-2.2.0.tar.gz/extra_lib/include/libavutil/video_enc_params.h Added

@@ -0,0 +1,171 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_VIDEO_ENC_PARAMS_H
+#define AVUTIL_VIDEO_ENC_PARAMS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/frame.h"
+
+enum AVVideoEncParamsType {
+ AV_VIDEO_ENC_PARAMS_NONE = -1,
+ /**
+ * VP9 stores:
+ * - per-frame base (luma AC) quantizer index, exported as AVVideoEncParams.qp
+ * - deltas for luma DC, chroma AC and chroma DC, exported in the
+ * corresponding entries in AVVideoEncParams.delta_qp
+ * - per-segment delta, exported as for each block as AVVideoBlockParams.delta_qp
+ *
+ * To compute the resulting quantizer index for a block:
+ * - for luma AC, add the base qp and the per-block delta_qp, saturating to
+ * unsigned 8-bit.
+ * - for luma DC and chroma AC/DC, add the corresponding
+ * AVVideoBlockParams.delta_qp to the luma AC index, again saturating to
+ * unsigned 8-bit.
+ */
+ AV_VIDEO_ENC_PARAMS_VP9,
+
+ /**
+ * H.264 stores:
+ * - in PPS (per-picture):
+ * * initial QP_Y (luma) value, exported as AVVideoEncParams.qp
+ * * delta(s) for chroma QP values (same for both, or each separately),
+ * exported as in the corresponding entries in AVVideoEncParams.delta_qp
+ * - per-slice QP delta, not exported directly, added to the per-MB value
+ * - per-MB delta; not exported directly; the final per-MB quantizer
+ * parameter - QP_Y - minus the value in AVVideoEncParams.qp is exported
+ * as AVVideoBlockParams.qp_delta.
+ */
+ AV_VIDEO_ENC_PARAMS_H264,
+
+ /*
+ * MPEG-2-compatible quantizer.
+ *
+ * Summing the frame-level qp with the per-block delta_qp gives the
+ * resulting quantizer for the block.
+ */
+ AV_VIDEO_ENC_PARAMS_MPEG2,
+};
+
+/**
+ * Video encoding parameters for a given frame. This struct is allocated along
+ * with an optional array of per-block AVVideoBlockParams descriptors.
+ * Must be allocated with av_video_enc_params_alloc().
+ */
+typedef struct AVVideoEncParams {
+ /**
+ * Number of blocks in the array.
+ *
+ * May be 0, in which case no per-block information is present. In this case
+ * the values of blocks_offset / block_size are unspecified and should not
+ * be accessed.
+ */
+ unsigned int nb_blocks;
+ /**
+ * Offset in bytes from the beginning of this structure at which the array
+ * of blocks starts.
+ */
+ size_t blocks_offset;
+ /*
+ * Size of each block in bytes. May not match sizeof(AVVideoBlockParams).
+ */
+ size_t block_size;
+
+ /**
+ * Type of the parameters (the codec they are used with).
+ */
+ enum AVVideoEncParamsType type;
+
+ /**
+ * Base quantisation parameter for the frame. The final quantiser for a
+ * given block in a given plane is obtained from this value, possibly
+ * combined with {@code delta_qp} and the per-block delta in a manner
+ * documented for each type.
+ */
+ int32_t qp;
+
+ /**
+ * Quantisation parameter offset from the base (per-frame) qp for a given
+ * plane (first index) and AC/DC coefficients (second index).
+ */
+ int32_t delta_qp42;
+} AVVideoEncParams;
+
+/**
+ * Data structure for storing block-level encoding information.
+ * It is allocated as a part of AVVideoEncParams and should be retrieved with
+ * av_video_enc_params_block().
+ *
+ * sizeof(AVVideoBlockParams) is not a part of the ABI and new fields may be
+ * added to it.
+ */
+typedef struct AVVideoBlockParams {
+ /**
+ * Distance in luma pixels from the top-left corner of the visible frame
+ * to the top-left corner of the block.
+ * Can be negative if top/right padding is present on the coded frame.
+ */
+ int src_x, src_y;
+ /**
+ * Width and height of the block in luma pixels.
+ */
+ int w, h;
+
+ /**
+ * Difference between this block's final quantization parameter and the
+ * corresponding per-frame value.
+ */
+ int32_t delta_qp;
+} AVVideoBlockParams;
+
+/*
+ * Get the block at the specified {@code idx}. Must be between 0 and nb_blocks.
+ */
+static av_always_inline AVVideoBlockParams*
+av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
+{
+ av_assert0(idx < par->nb_blocks);
+ return (AVVideoBlockParams *)((uint8_t *)par + par->blocks_offset +
+ idx * par->block_size);
+}
+
+/**
+ * Allocates memory for AVVideoEncParams of the given type, plus an array of
+ * {@code nb_blocks} AVVideoBlockParams and initializes the variables. Can be
+ * freed with a normal av_free() call.
+ *
+ * @param out_size if non-NULL, the size in bytes of the resulting data array is
+ * written here.
+ */
+AVVideoEncParams *av_video_enc_params_alloc(enum AVVideoEncParamsType type,
+ unsigned int nb_blocks, size_t *out_size);
+
+/**
+ * Allocates memory for AVEncodeInfoFrame plus an array of
+ * {@code nb_blocks} AVEncodeInfoBlock in the given AVFrame {@code frame}
+ * as AVFrameSideData of type AV_FRAME_DATA_VIDEO_ENC_PARAMS
+ * and initializes the variables.
+ */
+AVVideoEncParams*
+av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type,
+ unsigned int nb_blocks);
+
+#endif /* AVUTIL_VIDEO_ENC_PARAMS_H */

gpac-2.0.0.tar.gz/extra_lib/include/libswresample/version.h -> gpac-2.2.0.tar.gz/extra_lib/include/libswresample/version.h Changed

gpac-2.0.0.tar.gz/extra_lib/include/libswscale/swscale.h -> gpac-2.2.0.tar.gz/extra_lib/include/libswscale/swscale.h Changed

@@ -30,6 +30,7 @@
 #include <stdint.h>
 
 #include "libavutil/avutil.h"
+#include "libavutil/frame.h"
 #include "libavutil/log.h"
 #include "libavutil/pixfmt.h"
 #include "version.h"
@@ -219,6 +220,97 @@
 uint8_t *const dst, const int dstStride);
 
 /**
+ * Scale source data from src and write the output to dst.
+ *
+ * This is merely a convenience wrapper around
+ * - sws_frame_start()
+ * - sws_send_slice(0, src->height)
+ * - sws_receive_slice(0, dst->height)
+ * - sws_frame_end()
+ *
+ * @param dst The destination frame. See documentation for sws_frame_start() for
+ * more details.
+ * @param src The source frame.
+ *
+ * @return 0 on success, a negative AVERROR code on failure
+ */
+int sws_scale_frame(struct SwsContext *c, AVFrame *dst, const AVFrame *src);
+
+/**
+ * Initialize the scaling process for a given pair of source/destination frames.
+ * Must be called before any calls to sws_send_slice() and sws_receive_slice().
+ *
+ * This function will retain references to src and dst, so they must both use
+ * refcounted buffers (if allocated by the caller, in case of dst).
+ *
+ * @param dst The destination frame.
+ *
+ * The data buffers may either be already allocated by the caller or
+ * left clear, in which case they will be allocated by the scaler.
+ * The latter may have performance advantages - e.g. in certain cases
+ * some output planes may be references to input planes, rather than
+ * copies.
+ *
+ * Output data will be written into this frame in successful
+ * sws_receive_slice() calls.
+ * @param src The source frame. The data buffers must be allocated, but the
+ * frame data does not have to be ready at this point. Data
+ * availability is then signalled by sws_send_slice().
+ * @return 0 on success, a negative AVERROR code on failure
+ *
+ * @see sws_frame_end()
+ */
+int sws_frame_start(struct SwsContext *c, AVFrame *dst, const AVFrame *src);
+
+/**
+ * Finish the scaling process for a pair of source/destination frames previously
+ * submitted with sws_frame_start(). Must be called after all sws_send_slice()
+ * and sws_receive_slice() calls are done, before any new sws_frame_start()
+ * calls.
+ */
+void sws_frame_end(struct SwsContext *c);
+
+/**
+ * Indicate that a horizontal slice of input data is available in the source
+ * frame previously provided to sws_frame_start(). The slices may be provided in
+ * any order, but may not overlap. For vertically subsampled pixel formats, the
+ * slices must be aligned according to subsampling.
+ *
+ * @param slice_start first row of the slice
+ * @param slice_height number of rows in the slice
+ *
+ * @return a non-negative number on success, a negative AVERROR code on failure.
+ */
+int sws_send_slice(struct SwsContext *c, unsigned int slice_start,
+ unsigned int slice_height);
+
+/**
+ * Request a horizontal slice of the output data to be written into the frame
+ * previously provided to sws_frame_start().
+ *
+ * @param slice_start first row of the slice; must be a multiple of
+ * sws_receive_slice_alignment()
+ * @param slice_height number of rows in the slice; must be a multiple of
+ * sws_receive_slice_alignment(), except for the last slice
+ * (i.e. when slice_start+slice_height is equal to output
+ * frame height)
+ *
+ * @return a non-negative number if the data was successfully written into the output
+ * AVERROR(EAGAIN) if more input data needs to be provided before the
+ * output can be produced
+ * another negative AVERROR code on other kinds of scaling failure
+ */
+int sws_receive_slice(struct SwsContext *c, unsigned int slice_start,
+ unsigned int slice_height);
+
+/**
+ * @return alignment required for output slices requested with sws_receive_slice().
+ * Slice offsets and sizes passed to sws_receive_slice() must be
+ * multiples of the value returned from this function.
+ */
+unsigned int sws_receive_slice_alignment(const struct SwsContext *c);
+
+/**
 * @param dstRange flag indicating the while-black range of the output (1=jpeg / 0=mpeg)
 * @param srcRange flag indicating the while-black range of the input (1=jpeg / 0=mpeg)
 * @param table the yuv2rgb coefficients describing the output yuv space, normally ff_yuv2rgb_coeffsx
@@ -226,14 +318,22 @@
 * @param brightness 16.16 fixed point brightness correction
 * @param contrast 16.16 fixed point contrast correction
 * @param saturation 16.16 fixed point saturation correction
+#if LIBSWSCALE_VERSION_MAJOR > 6
+ * @return negative error code on error, non negative otherwise
+#else
 * @return -1 if not supported
+#endif
 */
 int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table4,
 int srcRange, const int table4, int dstRange,
 int brightness, int contrast, int saturation);
 
 /**
+#if LIBSWSCALE_VERSION_MAJOR > 6
+ * @return negative error code on error, non negative otherwise
+#else
 * @return -1 if not supported
+#endif
 */
 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
 int *srcRange, int **table, int *dstRange,
@@ -260,17 +360,6 @@
 */
 void sws_normalizeVec(SwsVector *a, double height);
 
-#if FF_API_SWS_VECTOR
-attribute_deprecated SwsVector *sws_getConstVec(double c, int length);
-attribute_deprecated SwsVector *sws_getIdentityVec(void);
-attribute_deprecated void sws_convVec(SwsVector *a, SwsVector *b);
-attribute_deprecated void sws_addVec(SwsVector *a, SwsVector *b);
-attribute_deprecated void sws_subVec(SwsVector *a, SwsVector *b);
-attribute_deprecated void sws_shiftVec(SwsVector *a, int shift);
-attribute_deprecated SwsVector *sws_cloneVec(SwsVector *a);
-attribute_deprecated void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);
-#endif
-
 void sws_freeVec(SwsVector *a);
 
 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,

gpac-2.0.0.tar.gz/extra_lib/include/libswscale/version.h -> gpac-2.2.0.tar.gz/extra_lib/include/libswscale/version.h Changed

gpac-2.0.0.tar.gz/gpac.spec -> gpac-2.2.0.tar.gz/gpac.spec Changed

gpac-2.0.0.tar.gz/include/gpac/avparse.h -> gpac-2.2.0.tar.gz/include/gpac/avparse.h Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / Authoring Tools sub-project
@@ -168,7 +168,7 @@
 thus you can seek the bitstream to copy the payload without re-seeking it
 \param m4v the mpeg video parser
 \param dsi pointer to the decoder specific info parsed
-\param frame_type set to the frame type (I:0, P:1, B:2)
+\param frame_type set to the frame type (I:1, P:2, B:3, 0: no frame header found)
 \param time_inc set to the time increment since last frame
 \param size set to the size of the compressed frame
 \param start set to the position of the first byte in the buffer/bitstream
@@ -357,35 +357,20 @@
 */
 u32 gf_vorbis_check_frame(GF_VorbisParser *vp, u8 *data, u32 data_len);
 
-/*! OPUS parser*/
-typedef struct
-{
-	u32 version;
-
-	u32 sample_rate, channels;
-	u8 OutputChannelCount;
-	u16 PreSkip;
-	u32 InputSampleRate;
-	u16 OutputGain;
-
-	u8 ChannelMappingFamily, StreamCount, CoupledCount;
-	u8 ChannelMapping255;
-} GF_OpusParser;
-
-/*! parses opus header packets - initializes the parser on success, leave it to NULL otherwise
-\param op pointer to a vorbis parser to use
+/*! parses opus header packets - initializes the config  on success, leave it to NULL otherwise
+\param cfg pointer to a opus config to fill
 \param data opus header buffer to parse
 \param data_len size of opus header buffer
 \return 1 if success, 0 if error
 */
-Bool gf_opus_parse_header(GF_OpusParser *op, u8 *data, u32 data_len);
+Bool gf_opus_parse_header(GF_OpusConfig *cfg, u8 *data, u32 data_len);
 
 /*! checks if an opus frame is valid
-\param op the vorbis parser to use
+\param cfg pointer to a opus config to use
 \param data source buffer
 \param data_len size of buffer
 \return 0 if init error or not a vorbis frame, otherwise returns the number of audio samples in this frame*/
-u32 gf_opus_check_frame(GF_OpusParser *op, u8 *data, u32 data_len);
+u32 gf_opus_check_frame(GF_OpusConfig *cfg, u8 *data, u32 data_len);
 
 #endif /*!defined(GPAC_DISABLE_AV_PARSERS) && !defined (GPAC_DISABLE_OGG)*/
 
@@ -674,21 +659,44 @@
 \return GF_TRUE if success
 */
 Bool gf_ac3_parser_bs(GF_BitStream *bs, GF_AC3Config *hdr, Bool full_parse);
+
+/*! parses an EAC-3 header from a buffer and checks for next frame/blocks presence
+\param buffer buffer to parse
+\param buffer_size size of buffer to parse
+\param pos set to start offset (in bytes) of the AC3 header parsed
+\param hdr will be filled by parser
+\param full_parse if GF_TRUE, complete parsing of the header and check for next frame/blocks presence will be done
+\return GF_TRUE if success
+*/
+Bool gf_eac3_parser(u8 *buffer, u32 buffer_size, u32 *pos, GF_AC3Config *hdr, Bool full_parse);
+
 /*! parses an EAC-3 header from a bitstream
 \param bs bitstream to parse
 \param hdr will be filled by parser
-\param full_parse if GF_TRUE, complete parsing of the header will be done
+\param full_parse if GF_TRUE, complete parsing of the header and check for next frame/blocks presence will be done
 \return GF_TRUE if success
 */
 Bool gf_eac3_parser_bs(GF_BitStream *bs, GF_AC3Config *hdr, Bool full_parse);
-/*! gets the number of channels in an AC3 frame
+
+/*! gets the number of channels from chan_loc info of EAC3 config
+\param chan_loc acmod of the associated frame header
+\return number of channels
+*/
+u32 gf_eac3_get_chan_loc_count(u32 chan_loc);
+
+/*! gets the total number of channels in an AC3 frame, including surround but not lfe
 \param acmod acmod of the associated frame header
 \return number of channels
 */
-u32 gf_ac3_get_channels(u32 acmod);
+u32 gf_ac3_get_total_channels(u32 acmod);
+/*! gets the number of surround channels in an AC3 frame
+\param acmod acmod of the associated frame header
+\return number of surround channels
+*/
+u32 gf_ac3_get_surround_channels(u32 acmod);
 /*! gets the bitrate of an AC3 frame
 \param brcode brcode of the associated frame header
-\return bitrate
+\return bitrate in bps
 */
 u32 gf_ac3_get_bitrate(u32 brcode);
 
@@ -738,6 +746,10 @@
 
 #endif /*GPAC_DISABLE_AV_PARSERS*/
 
+/*! get VVC profile name
+\param video_prof profile value
+\return the profile name
+*/
 const char *gf_vvc_get_profile_name(u8 video_prof);
 
 /*! gets chroma format name from MPEG chroma format
@@ -752,7 +764,7 @@
 const char *gf_avc_get_profile_name(u8 profile_idc);
 
 /*! checks if avcc extensions are used for this profile
- param profile_idc the PL indication
+\param profile_idc the PL indication
 \return GF_TRUE if extensions must be written in avcc for the given profile
 */
 Bool gf_avcc_use_extensions(u8 profile_idc);

gpac-2.0.0.tar.gz/include/gpac/base_coding.h -> gpac-2.2.0.tar.gz/include/gpac/base_coding.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -46,8 +46,6 @@
 
 #include <gpac/tools.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 /*!
 \brief base64 encoder
 
@@ -56,7 +54,7 @@
 \param in_buffer_size input data buffer size
 \param out_buffer output Base64 buffer location
 \param out_buffer_size output Base64 buffer allocated size
-\return size of the encoded Base64 buffer
+\return size of the encoded Base64 buffer, 0 if error
 \note the encoded data buffer is not NULL-terminated.
 */
 u32 gf_base64_encode(const u8 *in_buffer, u32 in_buffer_size, u8 *out_buffer, u32 out_buffer_size);
@@ -80,7 +78,7 @@
 \param in_buffer_size input data buffer size
 \param out_buffer output Base16 buffer location
 \param out_buffer_size output Base16 buffer allocated size
-\return size of the encoded Base16 buffer
+\return size of the encoded Base16 buffer, 0 if error
 \note the encoded data buffer is not NULL-terminated.
 */
 u32 gf_base16_encode(u8 *in_buffer, u32 in_buffer_size, u8 *out_buffer, u32 out_buffer_size);
@@ -103,6 +101,4 @@
 }
 #endif
 
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
-
 #endif		/*_GF_BASE_CODING_H_*/

gpac-2.0.0.tar.gz/include/gpac/bitstream.h -> gpac-2.2.0.tar.gz/include/gpac/bitstream.h Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / common tools sub-project
@@ -564,7 +564,6 @@
 /*!
 \brief transfer content from source bitstream to destination bitstream
 
-Returns the size of the associated buffer/file.
 \param dst the target bitstream
 \param src the source bitstream.
 \param keep_src If not set, the source bitstream is empty after calling the function
@@ -582,15 +581,24 @@
 void gf_bs_flush(GF_BitStream *bs);
 
 /*!
-\brief AVC&HEVC Annex B mode, only used for read mode
+\brief NALU-based Annex B mode, only used for read mode
 
-Enables or disable emulation byte prevention for AVC and HEVC annex B formats in read mode. This does NOT apply to \ref gf_bs_read_data nor  \ref gf_bs_skip_bytes
+Enables or disable emulation byte prevention for NALU-based  annex B formats in read mode. This does NOT apply to \ref gf_bs_read_data nor  \ref gf_bs_skip_bytes
 \param bs the target bitstream
 \param do_remove if true, emulation prevention bytes will be removed
  */
 void gf_bs_enable_emulation_byte_removal(GF_BitStream *bs, Bool do_remove);
 
 /*!
+\brief NALU-based Annex B mode, only used for read mode
+
+Enables or disable emulation byte prevention for NALU-based  annex B formats in read mode.
+\param bs the target bitstream
+\return number of bytes currently removed
+ */
+u32 gf_bs_get_emulation_byte_removed(GF_BitStream *bs);
+
+/*!
 \brief Inserts a data block, moving bytes to the end
 
 Inserts a data block at a given position, pushing all bytes after the insertion point to the end of the stream.
@@ -624,6 +632,25 @@
  */
 u64 gf_bs_get_cookie(GF_BitStream *bs);
 
+/*!
+\brief Reads string
+
+reads utf-8 NULL-terminated string - bitstream must be aligned
+\param bs the target bitstream
+\return the string read or NULL if error - MUST be freed by user
+ */
+char *gf_bs_read_utf8(GF_BitStream *bs);
+
+/*!
+\brief Writes string
+
+Writes utf-8 NULL-terminated string - bitstream must be aligned
+\param bs the target bitstream
+\param str UTF-8 string to write
+\return error if any
+ */
+GF_Err gf_bs_write_utf8(GF_BitStream *bs, const char *str);
+
 
 /*!
 \brief Marks overflow access

gpac-2.0.0.tar.gz/include/gpac/compositor.h -> gpac-2.2.0.tar.gz/include/gpac/compositor.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -44,14 +44,22 @@
 in a timed fashion. The compositor can only be run as a filter starting from GPAC 0.9.0, as it requires the filters API
 to fetch media data.
 The compositor can work in real-time mode (player) or as a regular filter. See `gpac -h compositor`for more information.
+
+ The compositor object is the private data of the compositor filter and can be retrieved using \ref gf_filter_get_udta
+
+ The compositor object will look for the following variables in the temp section of the GPAC config:
+	- window-flags: output window initialization flags - see GF_VideoOutputWindowFlags
+	- window-handle: OS-specific window handle (HWND on windows,
+	- window-display
+
 @{
 */
 	
 
 /*include scene graph API*/
 #include <gpac/scenegraph.h>
-/*GF_User and GF_Terminal */
-#include <gpac/user.h>
+/*GF_Event*/
+#include <gpac/events.h>
 /*frame buffer definition*/
 #include <gpac/color.h>
 
@@ -97,6 +105,18 @@
 */
 void gf_sc_invalidate(GF_Compositor *compositor, GF_Node *node);
 
+
+/*! mark next frame as required to be refreshed
+\param compositor the target compositor
+*/
+void gf_sc_invalidate_next_frame(GF_Compositor *compositor);
+
+/*! checks if a frame has been produced since last call to \ref gf_sc_invalidate_next_frame. This is typically used when the caller app has no control over flush
+\param compositor the target compositor
+\return GF_TRUE if frame was produced , GF_FALSE otherwise
+*/
+Bool gf_sc_frame_was_produced(GF_Compositor *compositor);
+
 /*! returns the compositor time. The compositor time is the time every time line is synchronized to
 \param compositor the target compositor
 \return compositor time in milliseconds
@@ -123,6 +143,25 @@
 \return GF_FALSE if event hasn't been handled by the compositor, GF_TRUE otherwise*/
 Bool gf_sc_user_event(GF_Compositor *compositor, GF_Event *event);
 
+/*! disconnects the current url
+\param compositor the target compositor
+*/
+void gf_sc_disconnect(GF_Compositor *compositor);
+
+/*! connects a given url
+\param compositor the target compositor
+\param URL the target URL
+\param startTime start time in milliseconds
+\param pause_at_first_frame indicate if compositor should pause once first frame is reached
+	- If 1, pauses at the first frame
+	- If 2, pauses at the first frame only if the compositor is in paused state
+	- otherwise do not pause
+\param secondary_scene indicate this is a secondary scene (subs, etc)
+\param parent_path parent path of URL, may be NULL
+*/
+void gf_sc_connect_from_time(GF_Compositor *compositor, const char *URL, u64 startTime, u32 pause_at_first_frame, Bool secondary_scene, const char *parent_path);
+
+
 /*! maps screen coordinates to bifs 2D coordinates for the current zoom/pan settings. The input coordinate X and Y are
 point coordinates in the display expressed in BIFS-like fashion (0,0) at center of display and Y increasing from bottom to top
 
@@ -134,19 +173,6 @@
 */
 void gf_sc_map_point(GF_Compositor *compositor, s32 X, s32 Y, Fixed *bifsX, Fixed *bifsY);
 
-/*! sets user options. Options are as defined in user.h
-\param compositor the target compositor
-\param type the target option type
-\param value the target option value
-\return error if any
-*/
-GF_Err gf_sc_set_option(GF_Compositor *compositor, u32 type, u32 value);
-/*! gets user options. Options are as defined in user.h
-\param compositor the target compositor
-\param type the target option type
-\return the option value
-*/
-u32 gf_sc_get_option(GF_Compositor *compositor, u32 type);
 
 /*! returns current FPS
 \param compositor the target compositor
@@ -175,6 +201,27 @@
 */
 GF_Err gf_sc_paste_text(GF_Compositor *compositor, const char *text);
 
+/*! adds an object to the scene - only possible if scene has selectable streams (cf GF_OPT_CAN_SELECT_STREAMS option)
+\param compositor the target compositor
+\param url the URL of the object to inject
+\param auto_play selcts the object for playback when inserting it
+\return error if any
+*/
+GF_Err gf_sc_add_object(GF_Compositor *compositor, const char *url, Bool auto_play);
+
+/*! compositor screen buffer grab mode*/
+typedef enum
+{
+	/*! grab color only */
+	GF_SC_GRAB_DEPTH_NONE = 0,
+	/*! grab depth only */
+	GF_SC_GRAB_DEPTH_ONLY = 1,
+	/*! grab RGB+depth */
+	GF_SC_GRAB_DEPTH_RGBD = 2,
+	/*! grab RGB+depth (7 bits) + 1 bit shape from alpha */
+	GF_SC_GRAB_DEPTH_RGBDS = 3
+} GF_CompositorGrabMode;
+
 /*! gets screen buffer. This locks the scene graph too until \ref gf_sc_get_offscreen_buffer is called
 \param compositor the target compositor
 \param framebuffer will be set to the grabbed framebuffer. The pixel data is owned by the compositor and shall not be freed
@@ -273,6 +320,426 @@
 */
 void gf_sc_reload_config(GF_Compositor *compositor);
 
+
+/*! gets main scene current time
+\param compositor the target compositor
+\return time in milliseconds
+*/
+u32 gf_sc_get_time_in_ms(GF_Compositor *compositor);
+
+/*! switches quality up or down - can be called several time in the same direction
+this will call all decoders to adjust their quality levels
+
+\param compositor the target compositor
+\param up if GF_TRUE, switches quality up,otherwise down
+*/
+void gf_sc_switch_quality(GF_Compositor *compositor, Bool up);
+
+/*! sets addon on or off (only one addon possible for now). When OFF, the associated service is shut down
+\param compositor the target compositor
+\param show_addons if GF_TRUE, displays addons otheriwse hides the addons
+*/
+void gf_sc_toggle_addons(GF_Compositor *compositor, Bool show_addons);
+
+/*! sets playback speed
+\param compositor the target compositor
+\param speed the requested speed
+\return error if any
+*/
+GF_Err gf_sc_set_speed(GF_Compositor *compositor, Fixed speed);
+
+/*! checks if given URL is understood by client.
+\param compositor the target compositor
+\param URL the URL to check
+\param use_parent_url if GF_TRUE, relative URLs are solved against the current presentation URL
+\return GF_TRUE if client should be able to handle the URL*/
+Bool gf_sc_is_supported_url(GF_Compositor *compositor, const char *URL, Bool use_parent_url);
+
+/*! navigates to a given destination or shutdown/restart the current one if any.
+This is the only safe way of restarting/jumping a presentation from inside the EventProc
+where doing a disconnect/connect could deadlock if toURL is NULL, uses the current URL
+\param compositor the target compositor
+\param toURL the new target URL
+*/
+void gf_sc_navigate_to(GF_Compositor *compositor, const char *toURL);
+
+/*! restarts url from given time (in ms).
+\param compositor the target compositor
+\param from_time restart time in milliseconds
+\param pause_at_first_frame if 1, pauses at the first frame. If 2, pauses at the first frame only if the compositor is in paused state.
+\return	0: service is not connected yet, 1: service has no seeking capabilities, 2: service has been seeked
+*/
+u32 gf_sc_play_from_time(GF_Compositor *compositor, u64 from_time, u32 pause_at_first_frame);
+
+/*! disconnects the current url
+\param compositor the target compositor
+*/
+void gf_sc_disconnect(GF_Compositor *compositor);
+
+
+/*! dumps scene graph in specified file, in BT or XMT format
+\param compositor the target compositor
+\param rad_name file radical (NULL for stdout) - if not NULL MUST BE GF_MAX_PATH length
+\param filename sets to the complete filename (rad + ext) and shall be destroyed by caller (optional can be NULL)
+\param xml_dump if GF_TRUE, duimps using XML format (XMT-A, X3D) for scene graphs having both XML and simple text representations
+\param skip_proto is GF_TRUE, proto declarations are not dumped
+\return error if any
+*/
+GF_Err gf_sc_dump_scene(GF_Compositor *compositor, char *rad_name, char **filename, Bool xml_dump, Bool skip_proto);
+
+
+/*! sends a set of scene commands (BT, XMT, X3D, LASeR+XML) to the scene
+\param compositor the target compositor
+\param type indicates the language used - accepted values are
+	"model/x3d+xml" or "x3d": commands is an X3D+XML scene
+	"model/x3d+vrml" or "xrdv": commands is an X3D+VRML scene
+	"model/vrml" or "vrml": commands is an VRML scene
+	"application/x-xmt" or "xmt": commands is an XMT-A scene or a list of XMT-A updates
+	"application/x-bt" or "bt": commands is a BT scene or a list of BT updates
+	"image/svg+xml" or "svg": commands is an SVG scene
+	"application/x-laser+xml" or "laser": commands is an SVG/LASeR+XML scene or a list of LASeR+XML updates
+	if not specified, the type will be guessed from the current root node if any
+\param com the textual update
+\return error if any
+*/
+GF_Err gf_sc_scene_update(GF_Compositor *compositor, char *type, char *com);
+
+/*! selects service by given ID for multiplexed services (MPEG-2 TS)
+\param compositor the target compositor
+\param service_id the service ID to select
+*/
+void gf_sc_select_service(GF_Compositor *compositor, u32 service_id);
+
+/*! gets URL of main scene
+
+\param compositor the target compositor
+\return URL
+*/
+const char *gf_sc_get_url(GF_Compositor *compositor);
+
+/*! gets main pid in scene
+
+\param compositor the target compositor
+\return PID
+*/
+const void *gf_sc_get_main_pid(GF_Compositor *compositor);
+
+/*! gets world info of root scene
+
+\param compositor the target compositor
+\param descriptions filled with descriptions strings (do not free)
+\return world title or NULL if no world info
+*/
+const char *gf_sc_get_world_info(GF_Compositor *compositor, GF_List *descriptions);
+
+/*! gets service ID of root scene
+
+\param compositor the target compositor
+\return service ID or 0 if none speicifed (single service in URL)
+*/
+u32 gf_sc_get_current_service_id(GF_Compositor *compositor);
+
+/*! gets simulation frame rate
+\param compositor the target compositor
+\param nb_frames_drawn set to the number of frames drawn
+\return simulation frames per seconds
+*/
+Double gf_sc_get_simulation_frame_rate(GF_Compositor *compositor, u32 *nb_frames_drawn);
+
+/*! AspectRatio Type */
+enum
+{
+	 /*! keep AR*/
+	GF_ASPECT_RATIO_KEEP = 0,
+	/*! keep 16/9*/
+	GF_ASPECT_RATIO_16_9,
+	/*! keep 4/3*/
+	GF_ASPECT_RATIO_4_3,
+	/*! none (all rendering area used)*/
+	GF_ASPECT_RATIO_FILL_SCREEN
+};
+
+/*! AntiAlias settings*/
+enum
+{
+	/*! no antialiasing*/
+	GF_ANTIALIAS_NONE = 0,
+	/*! only text has antialiasing*/
+	GF_ANTIALIAS_TEXT,
+	/*! full antialiasing*/
+	GF_ANTIALIAS_FULL
+};
+
+/*! PlayState settings*/
+enum
+{
+	/*! compositor is playing (get only)*/
+	GF_STATE_PLAYING = 0,
+	/*! compositor is paused (get only)*/
+	GF_STATE_PAUSED,
+	/*! On set, compositor will pause after next frame (simulation tick). On get, indicates that rendering step hasn't performed yet*/
+	GF_STATE_STEP_PAUSE,
+	/*! indicates resume shall restart from live point if any rather than pause point (set only)*/
+	GF_STATE_PLAY_LIVE = 10
+};
+
+/*! interaction level settings
+\note GF_INTERACT_NORMAL and GF_INTERACT_NAVIGATION filter events. If set, any event processed by these 2 modules won't be forwarded to the user
+*/
+enum
+{
+	/*! regular interactions enabled (touch sensors)*/
+	GF_INTERACT_NORMAL = 1,
+	/*! InputSensor interactions enabled (mouse and keyboard)*/
+	GF_INTERACT_INPUT_SENSOR = 2,
+	/*! all navigation interactions enabled (mouse and keyboard)*/
+	GF_INTERACT_NAVIGATION = 4,
+};
+
+/*! BoundingVolume settings*/
+enum
+{
+	/*! doesn't draw bounding volume*/
+	GF_BOUNDS_NONE = 0,
+	/*! draw object bounding box / rect*/
+	GF_BOUNDS_BOX,
+	/*! draw object AABB tree (3D only) */
+	GF_BOUNDS_AABB
+};
+
+/*! Wireframe settings*/
+enum
+{
+	/*! draw solid volumes*/
+	GF_WIREFRAME_NONE = 0,
+	/*! draw only wireframe*/
+	GF_WIREFRAME_ONLY,
+	/*! draw wireframe on solid object*/
+	GF_WIREFRAME_SOLID
+};
+
+
+/*! navigation type*/
+enum
+{
+	/*! navigation is disabled by content and cannot be forced by user*/
+	GF_NAVIGATE_TYPE_NONE,
+	/*! 2D navigation modes only can be used*/
+	GF_NAVIGATE_TYPE_2D,
+	/*! 3D navigation modes only can be used*/
+	GF_NAVIGATE_TYPE_3D
+};
+
+/*! navigation modes - non-VRML ones are simply blaxxun contact ones*/
+enum
+{
+	/*! no navigation*/
+	GF_NAVIGATE_NONE = 0,
+	/*! 3D navigation modes*/
+	/*! walk navigation*/
+	GF_NAVIGATE_WALK,
+	/*! fly navigation*/
+	GF_NAVIGATE_FLY,
+	/*! pan navigation*/
+	GF_NAVIGATE_PAN,
+	/*! game navigation*/
+	GF_NAVIGATE_GAME,
+	/*! slide navigation, for 2D and 3D*/
+	GF_NAVIGATE_SLIDE,
+	/*! all modes below disable collision detection & gravity in 3D*/
+	/*examine navigation, for 2D and 3D */
+	GF_NAVIGATE_EXAMINE,
+	/*! orbit navigation - 3D only*/
+	GF_NAVIGATE_ORBIT,
+	/*! QT-VR like navigation - 3D only*/
+	GF_NAVIGATE_VR,
+};
+
+/*! collision flags*/
+enum
+{
+	/*! no collision*/
+	GF_COLLISION_NONE,
+	/*! regular collision*/
+	GF_COLLISION_NORMAL,
+	/*! collision with camera displacement*/
+	GF_COLLISION_DISPLACEMENT,
+};
+
+/*! TextTexturing settings*/
+enum
+{
+	/*! text drawn as texture in 3D mode, regular in 2D mode*/
+	GF_TEXTURE_TEXT_DEFAULT = 0,
+	/*! text never drawn as texture*/
+	GF_TEXTURE_TEXT_NEVER,
+	/*! text always drawn*/
+	GF_TEXTURE_TEXT_ALWAYS
+};
+
+/*! Normal drawing settings*/
+enum
+{
+	/*! normals never drawn*/
+	GF_NORMALS_NONE = 0,
+	/*! normals drawn per face (at barycenter)*/
+	GF_NORMALS_FACE,
+	/*! normals drawn per vertex*/
+	GF_NORMALS_VERTEX
+};
+
+
+/*! Back-face culling mode*/
+enum
+{
+	/*! backface culling disabled*/
+	GF_BACK_CULL_OFF = 0,
+	/*! backface culliong enabled*/
+	GF_BACK_CULL_ON,
+	/*! backface culling enabled also for transparent meshes*/
+	GF_BACK_CULL_ALPHA,
+};
+
+/*! 2D drawing mode*/
+enum
+{
+	/*! defer draw mode (only modified parts of the canvas are drawn)*/
+	GF_DRAW_MODE_DEFER=0,
+	/*! immediate draw mode (canvas always redrawn)*/
+	GF_DRAW_MODE_IMMEDIATE,
+	/*! defer debug draw mode (only modified parts of the canvas are drawn, the rest of the canvas is erased)*/
+	GF_DRAW_MODE_DEFER_DEBUG,
+};
+
+/*! compositor options*/
+typedef enum
+{
+	/*! set/get antialias flag (value: one of the AntiAlias enum) - may be ignored in OpenGL mode depending on graphic cards*/
+	GF_OPT_ANTIALIAS =0,
+	/*! set/get fast mode (value: boolean) */
+	GF_OPT_HIGHSPEED,
+	/*! set/get fullscreen flag (value: boolean) */
+	GF_OPT_FULLSCREEN,
+	/*! reset top-level transform to original (value: boolean)*/
+	GF_OPT_ORIGINAL_VIEW,
+	/*! overrides BIFS size info for simple AV - this is not recommended since
+	it will resize the window to the size of the biggest texture (thus some elements
+	may be lost)*/
+	GF_OPT_OVERRIDE_SIZE,
+	/*! set / get audio volume (value is intensity between 0 and 100) */
+	GF_OPT_AUDIO_VOLUME,
+	/*! set / get audio pan (value is pan between 0 (all left) and 100(all right) )*/
+	GF_OPT_AUDIO_PAN,
+	/*! set / get audio mute*/
+	GF_OPT_AUDIO_MUTE,
+	/*! get javascript flag (no set, depends on compil) - value: boolean, true if JS enabled in build*/
+	GF_OPT_HAS_JAVASCRIPT,
+	/*! get selectable stream flag (no set) - value: boolean, true if audio/video/subtitle stream selection is
+	possible with content (if an MPEG-4 scene description is not present). Use regular OD browsing to get streams*/
+	GF_OPT_CAN_SELECT_STREAMS,
+	/*! set/get control interaction, OR'ed combination of interaction flags*/
+	GF_OPT_INTERACTION_LEVEL,
+	/*! set display window visible / get show/hide state*/
+	GF_OPT_VISIBLE,
+	/*! set freeze display on/off / get freeze state freeze_display prevents any screen updates
+	needed when output driver uses direct video memory access*/
+	GF_OPT_FREEZE_DISPLAY,
+	/*! Returns 1 if file playback is considered as done (all streams finished, no active time sensors
+	and no user interactions in the scene)*/
+	GF_OPT_IS_FINISHED,
+	/*! Returns 1 if file timeline is considered as done (all streams finished, no active time sensors)*/
+	GF_OPT_IS_OVER,
+	/*! set/get aspect ratio (value: one of AspectRatio enum) */
+	GF_OPT_ASPECT_RATIO,
+	/*! send a redraw message (SetOption only): all graphics info (display list, vectorial path) is
+	recomputed, and textures are reloaded in HW*/
+	GF_OPT_REFRESH,
+	/*! set/get stress mode (value: boolean) - in stress mode a GF_OPT_FORCE_REDRAW is emulated at each frame*/
+	GF_OPT_STRESS_MODE,
+	/*! get/set bounding volume drawing (value: one of the above option)*/
+	GF_OPT_DRAW_BOUNDS,
+	/*! get/set texture text option - when enabled and usable (that depends on content), text is first rendered
+	to a texture and only the texture is drawn, rather than drawing all the text each time (CPU intensive)*/
+	GF_OPT_TEXTURE_TEXT,
+	/*! reload config file (set only), including drivers. Plugins configs are not reloaded*/
+	GF_OPT_RELOAD_CONFIG,
+	/*! get: returns whether the content enable navigation and if it's 2D or 3D.
+	set: reset viewpoint (whatever value is given)*/
+	GF_OPT_NAVIGATION_TYPE,
+	/*! get current navigation mode - set navigation mode if allowed by content - this is not a resident
+	option (eg not stored in cfg)*/
+	GF_OPT_NAVIGATION,
+	/*! get/set Play state - cf above states for set*/
+	GF_OPT_PLAY_STATE,
+	/*! get only: returns 1 if main addon is playing, 0 if regular scene is playing*/
+	GF_OPT_MAIN_ADDON,
+	/*! get/set bench mode - if enabled, video frames are drawn as soon as possible witthout checking synchronisation*/
+	GF_OPT_VIDEO_BENCH,
+	/*! get/set OpenGL force mode - returns error if OpenGL is not supported*/
+	GF_OPT_USE_OPENGL,
+	/*! set/get draw mode*/
+	GF_OPT_DRAW_MODE,
+	/*! set/get scalable zoom (value: boolean)*/
+	GF_OPT_SCALABLE_ZOOM,
+	/*! set/get YUV acceleration (value: boolean) */
+	GF_OPT_YUV_HARDWARE,
+	/*! get (set not supported yet) hardware YUV format (value: YUV 4CC) */
+	GF_OPT_YUV_FORMAT,
+	/*! max video cache size in kbytes*/
+	GF_OPT_VIDEO_CACHE_SIZE,
+	/*! max HTTP download rate in bits per second, 0 if no limit*/
+	GF_OPT_HTTP_MAX_RATE,
+	/*! set only (value: boolean). If set, the main audio mixer can no longer be reconfigured. */
+	GF_OPT_FORCE_AUDIO_CONFIG,
+
+	/*!		3D ONLY OPTIONS		*/
+	/*! set/get raster outline flag (value: boolean) - when set, no vectorial outlining is done, only OpenGL raster outline*/
+	GF_OPT_RASTER_OUTLINES,
+	/*! set/get pow2 emulation flag (value: boolean) - when set, video textures with non power of 2 dimensions
+	are emulated as pow2 by expanding the video buffer (image is not scaled). Otherwise the entire image
+	is rescaled. This flag does not affect image textures, which are always rescaled*/
+	GF_OPT_EMULATE_POW2,
+	/*! get/set polygon antialiasing flag (value: boolean) (may be ugly with some cards)*/
+	GF_OPT_POLYGON_ANTIALIAS,
+	/*! get/set wireframe flag (value: cf above) (may be ugly with some cards)*/
+	GF_OPT_WIREFRAME,
+	/*! get/set wireframe flag (value: cf above) (may be ugly with some cards)*/
+	GF_OPT_NORMALS,
+	/*! disable backface culling*/
+	GF_OPT_BACK_CULL,
+	/*! get/set RECT Ext flag (value: boolean) - when set, GL rectangular texture extension is not used
+	(but NPO2 texturing is if available)*/
+	GF_OPT_NO_RECT_TEXTURE,
+	/*! set/get headlight (value: boolean)*/
+	GF_OPT_HEADLIGHT,
+	/*! set/get collision (value: cf above)*/
+	GF_OPT_COLLISION,
+	/*! set/get gravity*/
+	GF_OPT_GRAVITY,
+	/*! get the number of offscreen views in stereo mode, or 1 if no offscreen stereo views are available*/
+	GF_OPT_NUM_STEREO_VIEWS,
+	/*! set the mode of display of HEVC multiview videos, 0 to display the two views/layers and 1 to display just the first view/layer*/
+	GF_OPT_MULTIVIEW_MODE,
+	/*! get orientation sensors flag, true if sensors are activated false if not*/
+	GF_OPT_ORIENTATION_SENSORS_ACTIVE,
+} GF_CompositorOption;
+
+
+/*! sets compositor run-time option
+\param compositor the target compositor
+\param type the target option type
+\param value the target option value
+\return error if any
+*/
+GF_Err gf_sc_set_option(GF_Compositor *compositor, GF_CompositorOption type, u32 value);
+
+/*! gets compositor run-time option.
+\param compositor the target compositor
+\param type the target option type
+\return the option value
+*/
+u32 gf_sc_get_option(GF_Compositor *compositor, GF_CompositorOption type);
+
 /*! @} */
 
 #ifdef __cplusplus

gpac-2.0.0.tar.gz/include/gpac/configuration.h -> gpac-2.2.0.tar.gz/include/gpac/configuration.h Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2008-2012
+ *			Copyright (c) Telecom ParisTech 2008-2022
  *					All rights reserved
  *
  *  This file is part of GPAC
@@ -74,6 +74,9 @@
 /*Win32 IPv6 is evaluated at compile time, !! do not uncomment !!*/
 //#define GPAC_HAS_IPV6
 
+/*undefined at compil time if no poll support*/
+#define GPAC_HAS_POLL
+
 #define GPAC_HAS_GLU
 
 #ifndef GPAC_CONFIG_WIN32
@@ -129,7 +132,9 @@
 #elif defined(GPAC_CONFIG_DARWIN) && !defined(GPAC_CONFIG_IOS)
 
 #define GPAC_HAS_IPV6
+//#if !defined(__arm64__)
 #define GPAC_HAS_SSL
+//#endif
 #define GPAC_HAS_SOCK_UN
 
 //64-bits OSX
@@ -145,6 +150,7 @@
 #define GPAC_HAS_GLU
 #define GPAC_HAS_VTB
 #define GPAC_HAS_HTTP2
+#define GPAC_HAS_POLL
 
 #define GPAC_MEMORY_TRACKING
 
@@ -184,6 +190,7 @@
 #define GPAC_HAS_STRLCPY
 #define GPAC_HAS_VTB
 #define GPAC_HAS_HTTP2
+#define GPAC_HAS_POLL
 
 /*Configuration for Symbian*/
 #elif defined(__SYMBIAN32__)
@@ -207,9 +214,6 @@
 /*disables scene manager */
 //#define GPAC_DISABLE_SMGR
 
-/*disables core tools */
-//#define GPAC_DISABLE_CORE_TOOLS
-
 /*disables zlib */
 #ifndef GPAC_MP4BOX_MINI
 //#define GPAC_DISABLE_ZLIB
@@ -217,6 +221,9 @@
 #define GPAC_DISABLE_ZLIB
 #endif
 
+/*disables QuickJS libc*/
+//#define GPAC_DISABLE_QJS_LIBC
+
 /*disables SVG scene graph*/
 //#define GPAC_DISABLE_SVG

gpac-2.0.0.tar.gz/include/gpac/constants.h -> gpac-2.2.0.tar.gz/include/gpac/constants.h Changed

@@ -182,14 +182,13 @@
 	GF_PIXEL_RGBD		=	GF_4CC('R', 'G', 'B', 'D'),
 	/*!RGB24 + depth plane (7 lower bits) + shape mask. Component ordering in bytes is R-G-B-(S+D).*/
 	GF_PIXEL_RGBDS		=	GF_4CC('3', 'C', 'D', 'S'),
-	/*!Stereo RGB24 */
-	GF_PIXEL_RGBS		=	GF_4CC('R', 'G', 'B', 'S'),
-	/*!Stereo RGBA. Component ordering in bytes is R-G-B-A. */
-	GF_PIXEL_RGBAS		=	GF_4CC('R', 'G', 'A', 'S'),
 
 	/*internal format for OpenGL using pachek RGB 24 bit plus planar depth plane at the end of the image*/
 	GF_PIXEL_RGB_DEPTH = GF_4CC('R', 'G', 'B', 'd'),
 
+	/*generic pixel format uncv from ISO/IEC 23001-17*/
+	GF_PIXEL_UNCV = GF_4CC('u', 'n', 'c', 'v'),
+
 	/*!YUV packed 422 format*/
 	GF_PIXEL_YUYV		=	GF_4CC('Y','U','Y','V'),
 	/*!YUV packed 422 format*/
@@ -237,11 +236,17 @@
 	/*!444 YUV, 10 bits, little endian*/
 	GF_PIXEL_YUV444_10	=	GF_4CC('Y','4','1','0'),
 	/*!444 YUV packed*/
-	GF_PIXEL_YUV444_PACK	=	GF_4CC('Y','4','4','p'),
+	GF_PIXEL_YUV444_PACK	=	GF_4CC('Y','U','V','4'),
+	/*!444 VYU packed (v308) */
+	GF_PIXEL_VYU444_PACK	=	GF_4CC('V','Y','U','4'),
 	/*!444 YUV+Alpha packed*/
 	GF_PIXEL_YUVA444_PACK	=	GF_4CC('Y','A','4','p'),
-	/*!444 YUV 10 bit packed*/
+	/*!444 UYVA packed (v408) */
+	GF_PIXEL_UYVA444_PACK	=	GF_4CC('U','Y','V','A'),
+	/*!444 YUV 10 bit packed little endian (v410)*/
 	GF_PIXEL_YUV444_10_PACK	=	GF_4CC('Y','4','1','p'),
+	/*!422 YUV 10 bit packed in v210 format*/
+	GF_PIXEL_V210			= GF_4CC('v','2','1','0'),
 
 	/*!Unknown format exposed a single OpenGL texture to be consumed using samplerExternalOES*/
 	GF_PIXEL_GL_EXTERNAL	=	GF_4CC('E','X','G','L')
@@ -349,7 +354,13 @@
 /*!
 \brief Codec IDs
 
-Codec ID identifies the stream coding type. The enum is divided into values less than 255, which are equivalent to MPEG-4 systems ObjectTypeIndication. Other values are 4CCs, usually matching ISOMEDIA sample entry types*/
+Codec ID identifies the stream coding type. The enum is divided into values less than 255, which are equivalent to MPEG-4 systems ObjectTypeIndication. Other values are 4CCs, usually matching ISOMEDIA sample entry types.
+
+Unless specified otherwise the decoder configuration is:
+- the one specified in MPEG-4 systems if any
+- or the one defined in ISOBMFF and derived specs (3GPP, dolby, etc) if any
+- or NULL
+*/
 typedef enum
 {
 	/*!Never used by PID declarations, but used by filters caps*/
@@ -499,10 +510,15 @@
 	/*! codecid for subtitle/text streams in tx3g / apple text format*/
 	GF_CODECID_TX3G = GF_4CC( 't', 'x', '3', 'g' ),
 
+	/*! codecid for SSA / ASS text streams (only demux -> tx3f conv)*/
+	GF_CODECID_SUBS_SSA = GF_4CC( 'a', 's', 's', 'a' ),
+
+	GF_CODECID_DVB_SUBS = GF_4CC( 'd', 'v', 'b', 's' ),
+	GF_CODECID_DVB_TELETEXT = GF_4CC( 'd', 'v', 'b', 't' ),
 	/*!
 		\brief OGG DecoderConfig
 
-	 The DecoderConfig for theora, vorbis, flac and opus contains all intitialization ogg packets for the codec
+	 The DecoderConfig for theora, vorbis and speek contains all intitialization ogg packets for the codec
 	  and is formatted as follows:\n
 	 \code
 	  while (dsi_size) {
@@ -511,6 +527,11 @@
 			dsi_size -= packet_size;
 		}
 	 \endcode
+
+	 The DecoderConfig for FLAC is the full flac header without "fLaC" magic
+
+	 The DecoderConfig for OPUS is the full opus header without "OpusHead" magic
+
 	*/
 	/*! codecid for theora video streams*/
 	GF_CODECID_THEORA = GF_4CC('t','h','e','u'),
@@ -588,12 +609,13 @@
 	/*! codecid for USAC / xHE-AACv2 audio */
 	GF_CODECID_USAC = GF_4CC('u','s','a','c'),
 
-	GF_CODECID_V210 = GF_4CC('v','2','1','0'),
-
-
 	/*! codecid for MPEG-1 Audio streams, layer 1*/
 	GF_CODECID_MPEG_AUDIO_L1 = GF_4CC('m','p','a','1'),
 
+	GF_CODECID_MSPEG4_V3 = GF_4CC('D','I','V','3'),
+
+	GF_CODECID_ALAC = GF_4CC('A','L','A','C'),
+
 	//fake codec IDs for RTP
 	GF_CODECID_FAKE_MP2T = GF_4CC('M','P','2','T')
 } GF_CodecID;
@@ -643,6 +665,12 @@
 */
 u32 gf_codecid_4cc_type(GF_CodecID codecid);
 
+/*! Checks if reframer/unframer exists for this codec in gpac
+\param codecid target codec ID
+\return GF_TRUE if reframer/unframer exist (bitstream reparse is possible), GF_FALSE otherwise
+*/
+Bool gf_codecid_has_unframer(GF_CodecID codecid);
+
 /*! Gets the codecid given the associated short name
 \param cname target codec short name
 \return codecid codec ID
@@ -893,7 +921,7 @@
 GF_AudioFormat gf_audio_fmt_enum(u32 *idx, const char **name, const char **fileext, const char **desc);
 
 /*! get CICP layout code point from audio configuration
-\param nb_chan number of channels
+\param nb_chan total number of channels
 \param nb_surr number of surround channels
 \param nb_lfe number of LFE channels
 \return CICP layout code point format or 0 if unknown
@@ -1645,7 +1673,6 @@
 	GF_PROJ360_MESH
 };
 
-
 /*! @} */
 
 #ifdef __cplusplus

gpac-2.0.0.tar.gz/include/gpac/crypt_tools.h -> gpac-2.2.0.tar.gz/include/gpac/crypt_tools.h Changed

gpac-2.0.0.tar.gz/include/gpac/dash.h -> gpac-2.2.0.tar.gz/include/gpac/dash.h Changed

@@ -495,11 +495,12 @@
 \param has_next_segment set to GF_TRUE if next segment location is known (unthreaded mode) or next segment is downloaded (threaded mode) (optional, may be NULL)
 \param key_url set to the key URL of the next segment for MPEG-2 TS full segment encryption (optional, may be NULL). The URL is either a URN or a resolved URL
 \param key_IV set to the key initialization vector of the next segment for MPEG-2 TS full segment encryption (optional, may be NULL)
+\param utc set to UTC mapping for first sample of segment, 0 if none defined
 \return GF_BUFFER_TOO_SMALL if no segment found, GF_EOS if end of session, GF_URL_REMOVED if segment is disabled (but all output info is OK, this can be ignored and considered as GF_OK by the user) or error if any
 */
 GF_Err gf_dash_group_get_next_segment_location(GF_DashClient *dash, u32 group_idx, u32 dependent_representation_index, const char **url, u64 *start_range, u64 *end_range,
         s32 *switching_index, const char **switching_url, u64 *switching_start_range, u64 *switching_end_range,
-        const char **original_url, Bool *has_next_segment, const char **key_url, bin128 *key_IV);
+        const char **original_url, Bool *has_next_segment, const char **key_url, bin128 *key_IV, u64 *utc);
 
 /*! gets some info on the segment
 \param dash the target dash client
@@ -868,9 +869,10 @@
 \param group_idx the 0-based index of the target group
 \param segment_timeline_timescale set to segment timeline timescale, or to 0 if no segment timeline
 \param init_url set to initialization URL (template, timeline or base URL for VoD) as indicated in manifest (no resolution to base URL)
+\param hls_variant set toHLS variant name or NULL
 \return segment template, NULL if no templates used. Memory must be freed by caller
 */
-char *gf_dash_group_get_template(GF_DashClient *dash, u32 group_idx, u32 *segment_timeline_timescale, const char **init_url);
+char *gf_dash_group_get_template(GF_DashClient *dash, u32 group_idx, u32 *segment_timeline_timescale, const char **init_url, const char **hls_variant);
 
 /*! checks automatic switching mode
 \param dash the target dash client
@@ -1065,12 +1067,18 @@
 */
 void gf_dash_group_store_stats(GF_DashClient *dash, u32 group_idx, u32 dep_rep_idx, u32 bytes_per_sec, u64 file_size, Bool is_broadcast, u64 us_since_start);
 
+/*! Shifts the computed availabilityStartTime by offsetting (or resetting) the SuggestedPresentationDelay value parsed in the DASH manifest
+\param dash the target dash client
+\param spd availabilityStartTime shift in milliseconds. Positive values shift the clock in the future, negative ones in the past, "-I" will force the SuggestedPresentationDelay value to zero
+*/
+void gf_dash_set_suggested_presentation_delay(GF_DashClient *dash, s32 spd);
+
 /*! sets availabilityStartTime shift for ROUTE. By default the ROUTE tune-in is done by matching the last received segment name
 to the segment template and deriving the ROUTE UTC reference from that. The function allows shifting the computed value by a given amount.
 \param dash the target dash client
 \param ast_shift clock shift in milliseconds of the ROUTE receiver tune-in. Positive values shift the clock in the future, negative ones in the past
 */
-void gf_dash_set_route_ast_shift(GF_DashClient *dash, u32 ast_shift);
+void gf_dash_set_route_ast_shift(GF_DashClient *dash, s32 ast_shift);
 
 /*! gets the minimum wait time before calling \ref gf_dash_process again for unthreaded mode
 \param dash the target dash client

gpac-2.0.0.tar.gz/include/gpac/download.h -> gpac-2.2.0.tar.gz/include/gpac/download.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -109,14 +109,28 @@
 /*!
 \brief callback function for authentication
 
+This function is called back after user and password has been entered
+\param usr_cbk opaque user data passed by download manager
+\param usr_name the user name for the desired site, or NULL if the authentication was canceled
+\param password the password for the desired site and user, or NULL if the authentication was canceled
+\param store_info if TRUE, credentials will be stored in gpac config
+*/
+typedef void (*gf_dm_on_usr_pass)(void *usr_cbk, const char *usr_name, const char *password, Bool store_info);
+/*!
+\brief function for authentication
+
 The gf_dm_get_usr_pass type is the type for the callback of the \ref gf_dm_set_auth_callback function used for password retrieval
+
 \param usr_cbk opaque user data
+\param secure indicates if TLS is used
 \param site_url url of the site the user and password are requested for
 \param usr_name the user name for this site. The allocated space for this buffer is 50 bytes. \note this varaibale may already be formatted.
 \param password the password for this site and user. The allocated space for this buffer is 50 bytes.
-\return 0 if user didn't fill in the information which will result in an authentication failure, 1 otherwise.
+\param async_pass async function to call back when user and pass have been entered. If NULL, sync call will be performed
+\param async_udta async user data to pass back to the async function. If NULL, sync call will be performed
+\return GF_FALSE if user didn't fill in the information which will result in an authentication failure, GF_TRUE otherwise (info was filled if not async, or request was posted).
 */
-typedef Bool (*gf_dm_get_usr_pass)(void *usr_cbk, const char *site_url, char *usr_name, char *password);
+typedef Bool (*gf_dm_get_usr_pass)(void *usr_cbk, Bool secure, const char *site_url, char *usr_name, char *password, gf_dm_on_usr_pass async_pass, void *async_udta);
 
 /*!
 \brief password retrieval assignment
@@ -181,6 +195,10 @@
 	GF_NETIO_SESSION_KEEP_CACHE = 1<<5,
 	/*! do not delete files after download of first resource (used for init segments)*/
 	GF_NETIO_SESSION_KEEP_FIRST_CACHE = 1<<6,
+	/*! session data is cached if content length is known */
+	GF_NETIO_SESSION_AUTO_CACHE = 1<<7,
+	/*! use non-blocking IOs*/
+	GF_NETIO_SESSION_NO_BLOCK = 1<<8,
 } GF_NetIOFlags;
 
 
@@ -387,8 +405,6 @@
 \return the associated URL
 */
 const char *gf_dm_sess_get_resource_name(GF_DownloadSession *sess);
-
-#ifndef GPAC_DISABLE_CORE_TOOLS
 /*!
 Downloads a file over the network using a download manager
 \param dm The download manager to use, function will use all associated cache resources
@@ -414,8 +430,6 @@
 */
 GF_Err gf_dm_wget(const char *url, const char *filename, u64 start_range, u64 end_range, char **redirected_url);
 
-#endif /* GPAC_DISABLE_CORE_TOOLS */
-
 /*!
 Re-setup an existing, completed session to download a new URL. If same server/port/protocol is used, the same socket will be reused if the session has the GF_NETIO_SESSION_PERSISTENT flag set. This is only possible if the session is not threaded.
 \param sess The session
@@ -557,6 +571,56 @@
 	GF_HTTP_DELETE
 };
 
+/*! User credential request state*/
+typedef enum
+{
+	//! no async request for this credential object
+	GF_CREDS_STATE_NONE=0,
+	//! async request pending for this credential object (waiting for user input)
+	GF_CREDS_STATE_PENDING,
+	//! async request done for this credential object
+	GF_CREDS_STATE_DONE,
+} GF_CredentialRequestState;
+
+/*! user credential structure - all fields are setup by the credentials functions
+
+Credentials are currently handled indepentently from protocol scheme
+*/
+typedef struct
+{
+	/*! parent download manager where credentials are stored*/
+	const GF_DownloadManager *dm;
+	/*! site name*/
+	char site1024;
+	/*! user name*/
+	char username50;
+	/*! digest (only Basic for now, "Basic " not included in digest)*/
+	char digest1024;
+	/*! indicate if the credentials are valid or not*/
+	Bool valid;
+	/*! indicate that the async state of the credential request*/
+	GF_CredentialRequestState req_state;
+} GF_UserCredentials;
+
+/*! Find credentials for given site and user
+ \param dm parent download manager
+ \param server_name sever name without protocol scheme - must not be NULL
+ \param user_name user name, can be NULL (will pick first credential for the site)
+ \return credential object or NULL if error
+*/
+GF_UserCredentials *gf_user_credentials_find_for_site(GF_DownloadManager *dm, const char *server_name, const char *user_name);
+
+/*! Register credentials for given site and user/pass
+ \param dm parent download manager
+ \param secure indicate if connection is over TLS
+ \param server_name sever name without protocol scheme - must not be NULL
+ \param username user name, must not be NULL
+ \param password user password, must not be NULL
+ \param valid indicates if credentials are valid (successfull authentication)
+ \return credential object or NULL if error
+*/
+GF_UserCredentials * gf_user_credentials_register(GF_DownloadManager * dm, Bool secure, const char * server_name, const char * username, const char * password, Bool valid);
+
 /*! @} */
 
 #ifdef __cplusplus

gpac-2.0.0.tar.gz/include/gpac/dvb_mpe.h -> gpac-2.2.0.tar.gz/include/gpac/dvb_mpe.h Changed

gpac-2.0.0.tar.gz/include/gpac/events.h -> gpac-2.2.0.tar.gz/include/gpac/events.h Changed

@@ -42,7 +42,7 @@
 \ingroup playback_grp
 \brief Event system used by GPAC playback.
 
-This section documents the event structures used by the terminal, the compositor, input modules and output rendering modules for communication.
+This section documents the event structures used by thethe compositor, input modules and output rendering modules for communication.
 @{
  */
 
@@ -74,6 +74,8 @@
 	u32 button;
 	/*key modifier*/
 	u32 key_states;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventMouse;
 
 /*! Mouse event structure
@@ -91,6 +93,8 @@
 	Fixed pinch;
 	/*number of fingers detected*/
 	u32 num_fingers;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventMultiTouch;
 
 /*! Keyboard key event
@@ -106,6 +110,8 @@
 	u32 hw_code;
 	/*key modifier*/
 	u32 flags;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventKey;
 
 /*! Keyboard character event
@@ -117,17 +123,39 @@
 	u8 type;
 	/*above virtual key code*/
 	u32 unicode_char;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventChar;
 
+/*! Display orientation */
+typedef enum
+{
+	/*! Unknown display orientation */
+    GF_DISPLAY_MODE_UNKNOWN=0,
+    /*! portrait display orientation*/
+    GF_DISPLAY_MODE_PORTRAIT,
+    /*! landscape display orientation (+90deg anti-clockwise from portrait)*/
+    GF_DISPLAY_MODE_LANDSCAPE,
+    /*! inverted landscape display orientation (-90deg anti-clockwise from portrait)*/
+    GF_DISPLAY_MODE_LANDSCAPE_INV,
+    /*! upside down portrait display orientation (+180deg anti-clockwise from portrait)*/
+    GF_DISPLAY_MODE_PORTRAIT_INV
+} GF_DisplayOrientationType;
+
 /*! Window resize event
 	event proc return value: ignored
 */
 typedef struct
 {
-	/*GF_EVENT_SIZE*/
+	/*GF_EVENT_SIZE, GF_EVENT_SCENE_SIZE*/
 	u8 type;
 	/*width and height*/
 	u32 width, height;
+	/*display orientation */
+	GF_DisplayOrientationType orientation;
+	/*ID of window the event occured in (driver to app only)
+	For GF_EVENT_SCENE_SIZE, a value different from 0 indicates the root node is connected (scene is parsed)*/
+	u32 window_id;
 } GF_EventSize;
 
 /*! Video setup (2D or 3D) event
@@ -165,6 +193,8 @@
 	u8 type;
 	/*0: hidden - 1: visible - 2: fullscreen*/
 	u32 show_type;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventShow;
 
 /*! Mouse cursor event
@@ -200,6 +230,8 @@
 	u32 relative;
 	/*0: left/top, 1: middle, 2: right/bottom*/
 	u8 align_x, align_y;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventMove;
 
 /*! Media duration event
@@ -218,7 +250,7 @@
 
 /*! Hyperlink navigation event
 	event proc return value: 0 if URL not supported, 1 if accepted (it is the user responsability to load the url)
-	YOU SHALL NOT DIRECTLY OPEN THE NEW URL IN THE EVENT PROC, THIS WOULD DEADLOCK THE TERMINAL
+	YOU SHALL NOT DIRECTLY OPEN THE NEW URL IN THE EVENT PROC, THIS WOULD DEADLOCK THE COMPOSITOR
 */
 typedef struct
 {
@@ -285,7 +317,7 @@
 } GF_EventConnect;
 
 /*! Addon connection notification event
-	event proc return value: 1 to indicate the terminal should attempt a default layout for this addon, 0: nothing will be done
+	event proc return value: 1 to indicate the compositor should attempt a default layout for this addon, 0: nothing will be done
 */
 typedef struct
 {
@@ -300,14 +332,20 @@
 */
 typedef struct
 {
-	/*GF_EVENT_AUTHORIZATION*/
+	/*! GF_EVENT_AUTHORIZATION*/
 	u8 type;
-	/*the URL the auth request is for*/
+	/*! set to GF_TRUE if TLS is used*/
+	Bool secure;
+	/*! the URL the auth request is for*/
 	const char *site_url;
-	/*user name (provided buffer can hold 50 bytes). It may already be formatted, or an empty ("") string*/
+	/*! user name (provided buffer can hold 50 bytes). It may already be formatted, or an empty ("") string*/
 	char *user;
-	/*password (provided buffer can hold 50 bytes)*/
+	/*! password (provided buffer can hold 50 bytes)*/
 	char *password;
+	/*! async function to call back once pass is entered. If NULL, user/password must be set in the event*/
+	void (*on_usr_pass)(void *usr_cbk, const char *usr_name, const char *password, Bool store_info);
+	/*! user data for async function*/
+	void *async_usr_data;
 } GF_EventAuthorize;
 
 
@@ -316,9 +354,9 @@
 */
 typedef struct
 {
-	/*GF_EVENT_SYS_COLORS*/
+	/*! GF_EVENT_SYS_COLORS*/
 	u8 type;
-	/*ARGB colors, in order:
+	/*! ARGB colors, in order:
 	ActiveBorder, ActiveCaption, AppWorkspace, Background, ButtonFace, ButtonHighlight, ButtonShadow,
 	ButtonText, CaptionText, GrayText, Highlight, HighlightText, InactiveBorder, InactiveCaption,
 	InactiveCaptionText, InfoBackground, InfoText, Menu, MenuText, Scrollbar, ThreeDDarkShadow,
@@ -344,6 +382,8 @@
 	u8 type;
 	u32 nb_files;
 	char **files;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventOpenFile;
 
 /*! Orientation sensor change event
@@ -353,9 +393,25 @@
 {
 	/*GF_EVENT_SENSOR_ORIENTATION*/
 	u8 type;
-	/*device orientation as quaternion if w is not 0, or as radians otherwise*/
+	/* device orientation as quaternion if w is not 0, or as radians otherwise*/
 	Float x, y, z, w;
-} GF_EventSensor;
+} GF_EventOrientationSensor;
+
+/*! GPS sensor change event
+	event proc return value: ignored
+*/
+typedef struct
+{
+	/*GF_EVENT_SENSOR_GPS*/
+	u8 type;
+	/* position in degrees*/
+	Double longitude, latitude;
+	/* altitude in meters above the WGS84 reference ellipsoid*/
+	Double altitude;
+	Float accuracy, bearing;
+	//ms since unix EPOCH
+	u64 timestamp;
+} GF_EventGPS;
 
 
 /*! Orientation sensor activation event
@@ -383,6 +439,8 @@
 	- char * for COPY_TEXT, must be freed by caller
 	*/
 	char *text;
+	/*ID of window the event occured in (driver to app only)*/
+	u32 window_id;
 } GF_EventClipboard;
 
 
@@ -394,7 +452,8 @@
 	GF_EventMultiTouch mtouch;
 	GF_EventKey key;
 	GF_EventChar character;
-	GF_EventSensor sensor;
+	GF_EventOrientationSensor sensor;
+	GF_EventGPS gps;
 	GF_EventSize size;
 	GF_EventShow show;
 	GF_EventDuration duration;

gpac-2.0.0.tar.gz/include/gpac/events_constants.h -> gpac-2.2.0.tar.gz/include/gpac/events_constants.h Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / Events management
@@ -39,117 +39,441 @@
  */
 
 
-/*
-		minimal event system
+/*! GPAC Event types
 
-	DO NOT CHANGE THEIR POSITION IN THE LIST, USED TO SPEED UP FILTERING OF USER INPUT EVENTS
-*/
+	Event for which DOM event name is none are not exposed to DOM
+	Event for which no DOM event name is given use the default DOM event name
 
-/*! Event types*/
+	If the associated struct in \ref GF_Event is not indicated, no structure is used
+*/
 typedef enum {
+	/*
+		Mouse events, MUST be first in list
+		DO NOT CHANGE ORDER of mouse and key events
+	*/
 
-	/******************************************************
-
-		Events used for both GPAC internals and DOM Events
-
-	*******************************************************/
-	/*MouseEvents*/
-	GF_EVENT_CLICK,
+	/*! mouse click event
+		associated struct: \ref GF_EventMouse
+		DOM Event: "click""
+	*/
+	GF_EVENT_CLICK = 1,
+	/*! mouse up event
+		associated struct: \ref GF_EventMouse
+		DOM Event: "mouseup"
+	*/
 	GF_EVENT_MOUSEUP,
+	/*! mouse down event
+		associated struct: \ref GF_EventMouse
+		DOM Event: "mousedown"
+	*/
 	GF_EVENT_MOUSEDOWN,
-	GF_EVENT_MOUSEOVER,
-	GF_EVENT_MOUSEOUT,
-	/*!! ALL MOUSE EVENTS SHALL BE DECLARED BEFORE MOUSEMOVE !! */
+	/*! mouse move event
+		associated struct: \ref GF_EventMouse
+		DOM Event: "mousemove"
+	*/
 	GF_EVENT_MOUSEMOVE,
-	/*mouse wheel event*/
+
+	GF_EVENT_LAST_MOUSE_COORDS = GF_EVENT_MOUSEMOVE,
+	/*! mouse wheel event
+		associated struct: \ref GF_EventMouse
+		DOM Event: "wheel"
+	*/
 	GF_EVENT_MOUSEWHEEL,
+	/*! mouse multitouch  event
+		associated struct: \ref GF_EventMultiTouch
+		DOM Event: none
+	*/
+	GF_EVENT_MULTITOUCH,
+
+	GF_EVENT_LAST_MOUSE = 10,
 
 	/*Key Events*/
-	GF_EVENT_KEYUP,
-	GF_EVENT_KEYDOWN, /* covers KeyDown, KeyPress and AccessKey */
+	GF_EVENT_FIRST_KEY = 20,
+
+	/*! keyup event
+		associated struct: \ref GF_EventKey
+		DOM Event: "keyup"
+	*/
+	GF_EVENT_KEYUP = GF_EVENT_FIRST_KEY,
+	/*! keydown event
+		associated struct: \ref GF_EventKey
+		DOM Event: "keydown", "keypress", "accesskey"
+	*/
+	GF_EVENT_KEYDOWN,
+	/*! long keypress event
+		associated struct: \ref GF_EventKey
+		DOM Event: "longaccesskey"
+	*/
 	GF_EVENT_LONGKEYPRESS,
-	/*character input*/
+	/*! character input event
+		associated struct: \ref GF_EventChar
+		DOM Event: "textInput"
+	*/
 	GF_EVENT_TEXTINPUT,
 
-	GF_EVENT_MULTITOUCH,
 
-	/******************************************************
+	/* Events used for GPAC internals only */
+	GF_EVENT_FIRST_INTERNAL = 30,
 
-		Events used for DOM Events only
+	/*! unknown event - GPAC internal*/
+	GF_EVENT_UNKNOWN = GF_EVENT_FIRST_INTERNAL,
+	/*! same as mousedown, generated internally by GPAC (not by video modules) but sent to GUI
+		associated struct: \ref GF_EventMouse
+		DOM Event: "dblclick"
+	*/
+	GF_EVENT_DBLCLICK,
+
+	/*! scene attached event, dispatched when the root node of a scene is loaded and attached to the window or parent object (animation, inline, ...)
+		associated struct: none
+		DOM Event: "gpac_scene_attached"
+	*/
+	GF_EVENT_SCENE_ATTACHED,
+
+	/*! window size changed event -  indicate new w & h in .x end .y fields of event.
+		- When sent from gpac to a video plugin, indicates the output size should be changed. This is only sent when the plugin
+	manages the output video himself
+		- When sent from a video plugin to gpac, indicates the output size has been changed. This is only sent when the plugin
+	manages the output video himself
+
+		associated struct: \ref GF_EventSize
+		DOM Event: "gpac_size_changed"
+	*/
+	GF_EVENT_SIZE,
+
+	/*! signals the scene size (if indicated in scene) upon connection (sent to the user event proc only)
+		if scene size hasn't changed (seeking or other) this event is not sent
+
+		associated struct: \ref GF_EventSize
+		DOM Event: "gpac_scene_size"
+	*/
+	GF_EVENT_SCENE_SIZE,
+	/*! window show/hide (minimized or other).
+		associated struct: \ref GF_EventShow
+		DOM Event: "gpac_show_hide"
+	*/
+	GF_EVENT_SHOWHIDE,
+	/*! set mouse cursor
+		associated struct: \ref GF_EventCursor
+		DOM Event: "gpac_set_cursor"
+	*/
+	GF_EVENT_SET_CURSOR,
+
+	/*! set window caption
+		associated struct: \ref GF_EventCaption
+		DOM Event: "gpac_set_caption"
+	*/
+	GF_EVENT_SET_CAPTION,
+	/*! move window event
+		associated struct: \ref GF_EventMove
+		DOM Event: "gpac_move"
+	*/
+	GF_EVENT_MOVE,
+	/*! window needs repaint refresh - (whenever needed, eg restore, hide->show, background refresh, paint)
+		DOM Event: "gpac_refresh"
+	*/
+	GF_EVENT_REFRESH,
+	/*! app or window is being closed - a window ID value of 0 indicates global program close event
+		associated struct: \ref GF_EventShow
+		DOM Event: "gpac_quit"
+	*/
+	GF_EVENT_QUIT,
+	/*! video output setup message:
+		- when sent from gpac to plugin, indicates that the plugin should re-setup hardware context due to a window resize:
+			* for 2D output, this means resizing the backbuffer if needed (depending on HW constraints)
+			* for 3D output, this means re-setup of OpenGL context (depending on HW constraints). Depending on windowing systems
+			and implementations, it could be possible to resize a window without destroying the GL context.
+
+		- when sent from plugin to gpac, indicates that hardware has been setup.
+		- when sent from gpac to user, indicate aspect ratio has been modified and video output is ready
+
+		associated struct: \ref GF_EventVideoSetup
+		DOM Event: none
+	*/
+	GF_EVENT_VIDEO_SETUP,
+	/*! set current GL context for the calling thread
+		DOM Event: none
+	*/
+	GF_EVENT_SET_GL,
+	/*! set display orientation - value is given by \ref GF_EventSize orientation field
+		associated struct: \ref GF_EventSize
+		DOM Event: none
+	*/
+	GF_EVENT_SET_ORIENTATION,
+	/*! queries the list of system colors - only exchanged between compositor/vout and video output module
+		associated struct: \ref GF_EventSysColors
+		DOM Event: none
+	*/
+	GF_EVENT_SYS_COLORS,
+
+	/*! indicates text has been pasted - from video output module to compositor/vout only
+		associated struct: \ref GF_EventClipboard
+		DOM Event: none
+	*/
+	GF_EVENT_PASTE_TEXT,
+	/*! queries for text to be copied - from video output module to compositor/vout only
+		associated struct: \ref GF_EventClipboard
+		DOM Event: none
+	*/
+	GF_EVENT_COPY_TEXT,
+
+	/*! root URL connected / disconnected event
+		associated struct: \ref GF_EventConnect
+		DOM Event: "gpac_on_connect"
+	*/
+	GF_EVENT_CONNECT,
+	/*! duration of root URL presentation
+		associated struct: \ref GF_EventDuration
+		DOM Event: "gpac_on_duration"
+	*/
+	GF_EVENT_DURATION,
+	/*! End of scene playback event
+ 		DOM Event:  "gpac_eos"
+	*/
+	GF_EVENT_EOS,
+	/*! user and pass query event
+		associated struct: \ref GF_EventAuthorize
+		DOM Event: "gpac_authorization"
+	*/
+	GF_EVENT_AUTHORIZATION,
+	/*! user app should load or jump to the given URL
+		associated struct: \ref GF_EventNavigate
+ 		DOM Event: "gpac_navigate"
+	*/
+	GF_EVENT_NAVIGATE,
+	/*! indicates the link or its description under the mouse pointer
+		associated struct: \ref GF_EventNavigate
+ 		DOM Event: "gpac_navigate_info"
+	*/
+	GF_EVENT_NAVIGATE_INFO,
+	/*! message from the compositor
+		associated struct: \ref GF_EventMessage
+ 		DOM Event: "gpac_on_message"
+	*/
+	GF_EVENT_MESSAGE,
+	/*! progress message from the compositor
+		associated struct: \ref GF_EventProgress
+  		DOM Event: "gpac_on_progress"
+	*/
+	GF_EVENT_PROGRESS,
+	/*! indicates viewpoint list has changed
+  		DOM Event: "gpac_viewpoints_changed"
+	*/
+	GF_EVENT_VIEWPOINTS,
+	/*! indicates stream list has changed - no struct associated - only used when no scene info is present
+  		DOM Event: "gpac_streamlist_changed"
+	*/
+	GF_EVENT_STREAMLIST,
+	/*! indicates a change in associated metadata - not implemented*/
+	GF_EVENT_METADATA,
+	/*! indicates a list of file paths has been dropped on window
+		associated struct: \ref GF_EventOpenFile
+		DOM Event: none
+	*/
+	GF_EVENT_DROPFILE,
+	/*! signal text editing is starting - only sent from compositor/vout to video output module, to show virtual keyboard
+		DOM Event: none
+	*/
+	GF_EVENT_TEXT_EDITING_START,
+	/*! signal text editing is done - only sent from compositor/vout to video output module, to hide virtual keyboard
+		DOM Event: none
+	*/
+	GF_EVENT_TEXT_EDITING_END,
 
+	/*! quality change is detected by compositor
+  		DOM Event: "gpac_quality_switch"
+	*/
+	GF_EVENT_QUALITY_SWITCHED,
+	/*! timeshift depth changed event
+  		DOM Event: "gpac_timeshift_depth_changed"
+	*/
+	GF_EVENT_TIMESHIFT_DEPTH,
+	/*! position in timeshift buffer changed event
+  		DOM Event: "gpac_timeshift_update"
+	*/
+	GF_EVENT_TIMESHIFT_UPDATE,
+	/*! position overflows the timeshift buffer event
+  		DOM Event: "gpac_timeshift_overflow"
+	*/
+	GF_EVENT_TIMESHIFT_OVERFLOW,
+	/*! position underruns the timeshift bufferevent  (eg fast forward / seek in the future)
+  		DOM Event: "gpac_timeshift_underrun"
+	*/
+	GF_EVENT_TIMESHIFT_UNDERRUN,
+	/*! main addon (injected from active URL) detected
+  		DOM Event: "gpac_addon_found"
+	*/
+	GF_EVENT_ADDON_DETECTED,
+	/*! main addon (injected from active URL) detected
+  		DOM Event: "gpac_main_addon_state"
+	*/
+	GF_EVENT_MAIN_ADDON_STATE,
+	/*! codec running too slow event
+  		DOM Event:  "gpac_codec_slow"
+	*/
+	GF_EVENT_CODEC_SLOW,
+	/*! codec running ok event (only sent after a codec too slow)
+  		DOM Event:  "gpac_codec_ok"
+	*/
+	GF_EVENT_CODEC_OK,
+	/*! sensor request event (send to app)
+		DOM Event: none
+	*/
+	GF_EVENT_SENSOR_REQUEST,
+	/*! orientation  (yaw pitch roll) changed event (send by app)
+		associated struct: \ref GF_EventOrientationSensor
+		DOM Event: none
+	*/
+	GF_EVENT_SENSOR_ORIENTATION,
+	/*! GPS location changed event (send by app)
+		associated struct: \ref GF_EventGPS
+		DOM Event: none
+	*/
+	GF_EVENT_SENSOR_GPS,
+
+
+	GF_EVENT_LAST_INTERNAL,
+
+	/******************************************************
+		Events used for DOM Events only
 	*******************************************************/
-	GF_EVENT_TEXTSELECT,
+	GF_EVENT_FIRST_DOM = 60,
+
 
-	/*DOM UIEvents*/
+	/*! viewport resize event, dispatched when viewport of a scene is being modified attached to the window or parent object
+		associated struct: none
+		DOM Event: "gpac_vp_changed"
+	*/
+	GF_EVENT_VP_RESIZE,
+
+	/*! text is being selected*/
+	GF_EVENT_TEXTSELECT,
+	/*! mouse over node event*/
+	GF_EVENT_MOUSEOVER,
+	/*! mouse out node event*/
+	GF_EVENT_MOUSEOUT,
+	/*! node focus in  event*/
 	GF_EVENT_FOCUSIN,
+	/*! node focus out event*/
 	GF_EVENT_FOCUSOUT,
+	/*! node activate event*/
 	GF_EVENT_ACTIVATE,
+	/*! node focus change event - not implemented*/
 	GF_EVENT_CHANGE,
+	/*! focus received event - not implemented*/
 	GF_EVENT_FOCUS,
+	/*! focus lost event - not implemented*/
 	GF_EVENT_BLUR,
-	/*SVG (HTML) Events*/
+	/*! document load event, also used for XHR */
 	GF_EVENT_LOAD,
+	/*! document unload event */
 	GF_EVENT_UNLOAD,
+	/*! document abort event, also used for XHR */
 	GF_EVENT_ABORT,
+	/*! document error event, also used for XHR */
 	GF_EVENT_ERROR,
+	/*! document resize event*/
 	GF_EVENT_RESIZE,
+	/*! document scroll event*/
 	GF_EVENT_SCROLL,
+	/*! document zoom event*/
 	GF_EVENT_ZOOM,
-	GF_EVENT_BEGIN, /*this is a fake event, it is NEVER fired, only used in SMIL begin*/
+	/*! fake SMIL begin event - it is NEVER fired, only used in SMIL begin parsing*/
+	GF_EVENT_BEGIN,
+	/*! SMIL begin event*/
 	GF_EVENT_BEGIN_EVENT,
-	GF_EVENT_END, /*this is a fake event, it is NEVER fired, only used in SMIL end*/
+	/*! fake SMIL end event - it is NEVER fired, only used in SMIL end parsing*/
+	GF_EVENT_END,
+	/*! SMIL end event*/
 	GF_EVENT_END_EVENT,
-	GF_EVENT_REPEAT, /*this is a fake event, it is NEVER fired, only used in SMIL repeat*/
+	/*! fake SMIL repeat event, it is NEVER fired, only used in SMIL repeat*/
+	GF_EVENT_REPEAT,
+	/*! SMIL repeat event*/
 	GF_EVENT_REPEAT_EVENT,
 
-	/*DOM MutationEvents - NOT SUPPORTED YET*/
+	/*! tree modified mutation event*/
 	GF_EVENT_TREE_MODIFIED,
+	/*! node modified mutation event*/
 	GF_EVENT_NODE_INSERTED,
+	/*! node removed mutation event*/
 	GF_EVENT_NODE_REMOVED,
+	/*! node inserted in doc mutation event - not implemented*/
 	GF_EVENT_NODE_INSERTED_DOC,
+	/*! node removed from doc mutation event - not implemented*/
 	GF_EVENT_NODE_REMOVED_DOC,
+	/*! attribute modified mutation event*/
 	GF_EVENT_ATTR_MODIFIED,
+	/*! text data modified mutation event - not implemented*/
 	GF_EVENT_CHAR_DATA_MODIFIED,
+	/*! node name modified mutation event - not implemented*/
 	GF_EVENT_NODE_NAME_CHANGED,
+	/*! attribute name modified mutation event - not implemented*/
 	GF_EVENT_ATTR_NAME_CHANGED,
-
+	/*! DCCI property of node modified - not implemented*/
 	GF_EVENT_DCCI_PROP_CHANGE,
 
-	/*LASeR events*/
+	/*! LASeR activated event*/
 	GF_EVENT_ACTIVATED,
+	/*! LASeR deactivated event*/
 	GF_EVENT_DEACTIVATED,
+	/*! SMIL and HTML media pause trigger event*/
 	GF_EVENT_PAUSE,
+	/*! SMIL and HTML media pause notification event*/
 	GF_EVENT_PAUSED_EVENT,
+	/*! SMIL and HTML media PLAY event*/
 	GF_EVENT_PLAY,
+	/*! repeat key event*/
 	GF_EVENT_REPEAT_KEY,
+	/*! SMIL resumed event */
 	GF_EVENT_RESUME_EVENT,
+	/*! short access key event */
 	GF_EVENT_SHORT_ACCESSKEY,
-	/*pseudo-event, only used in LASeR coding*/
+	/*! pseudo-event only used in LASeR coding, solved to SMIL scene clock when parsing*/
 	GF_EVENT_EXECUTION_TIME,
 
-	/*HTML5 media events*/
-	GF_EVENT_MEDIA_SETUP_BEGIN,	/*not HTML5 but should be :)*/
-	GF_EVENT_MEDIA_SETUP_DONE,	/*not HTML5 but should be :)*/
+	/*! HTML5 media setup being event - GPAC internal*/
+	GF_EVENT_MEDIA_SETUP_BEGIN,
+	/*! HTML5 media setup done event - GPAC internal*/
+	GF_EVENT_MEDIA_SETUP_DONE,
+	/*! HTML5 media load statr event - also used in XHR*/
 	GF_EVENT_MEDIA_LOAD_START,
-	GF_EVENT_MEDIA_LOAD_DONE,	/*not HTML5 but should be :)*/
+	/*! HTML5 media load done event - also used in XHR*/
+	GF_EVENT_MEDIA_LOAD_DONE,
+	/*! HTML5 media progress event - also used in XHR*/
 	GF_EVENT_MEDIA_PROGRESS,
+	/*! HTML5 media suspend event - not implemented*/
 	GF_EVENT_MEDIA_SUSPEND,
+	/*! HTML5 media emptied event - not implemented*/
 	GF_EVENT_MEDIA_EMPTIED,
+	/*! HTML5 media stalled event - not implemented*/
 	GF_EVENT_MEDIA_STALLED,
+	/*! HTML5 metadata loaded event - not implemented*/
 	GF_EVENT_MEDIA_LOADED_METADATA,
+	/*! HTML5 media  loaded event - not implemented*/
 	GF_EVENT_MEDIA_LODADED_DATA,
+	/*! HTML5 media can play - not implemented*/
 	GF_EVENT_MEDIA_CANPLAY,
+	/*! HTML5 media can play through - not implemented*/
 	GF_EVENT_MEDIA_CANPLAYTHROUGH,
+	/*! HTML5 media playing - not implemented*/
 	GF_EVENT_MEDIA_PLAYING,
+	/*! HTML5 media waiting - not implemented*/
 	GF_EVENT_MEDIA_WAITING,
+	/*! HTML5 media seeking - not implemented*/
 	GF_EVENT_MEDIA_SEEKING,
+	/*! HTML5 media seeked - not implemented*/
 	GF_EVENT_MEDIA_SEEKED,
+	/*! HTML5 media ended*/
 	GF_EVENT_MEDIA_ENDED,
+	/*! HTML5 media duration changed - not implemented*/
 	GF_EVENT_MEDIA_DURATION_CHANGED,
+	/*! HTML5 media time update event*/
 	GF_EVENT_MEDIA_TIME_UPDATE,
+	/*! HTML5 media playbalck rate change event - not implemented*/
 	GF_EVENT_MEDIA_RATECHANGE,
+	/*! HTML5 media volume change event - not implemented*/
 	GF_EVENT_MEDIA_VOLUME_CHANGED,
 
+#if 0
 	GF_EVENT_HTML_MSE_SOURCE_OPEN,
 	GF_EVENT_HTML_MSE_SOURCE_ENDED,
 	GF_EVENT_HTML_MSE_SOURCE_CLOSE,
@@ -160,103 +484,13 @@
 	GF_EVENT_HTML_MSE_UPDATE_ABORT,
 	GF_EVENT_HTML_MSE_ADD_SOURCE_BUFFER,
 	GF_EVENT_HTML_MSE_REMOVE_SOURCE_BUFFER,
+#endif
 
+	/*! battery event - not implemented*/
 	GF_EVENT_BATTERY,
+	/*! CPU event - not implemented*/
 	GF_EVENT_CPU,
-	GF_EVENT_UNKNOWN,
-
-
-	/******************************************************
-
-		Events used for GPAC internals only
-
-	*******************************************************/
 
-	/*same as mousedown, generated internally by GPAC*/
-	GF_EVENT_DBLCLICK,
-
-	/*scene attached event, dispatched when the root node of a scene is loaded and
-	attached to the window or parent object (animation, inline, ...)*/
-	GF_EVENT_SCENE_ATTACHED,
-
-	/*VP resize attached event, dispatched when viewport of a scene is being modified
-	attached to the window or parent object (animation, inline, ...)*/
-	GF_EVENT_VP_RESIZE,
-
-	/*window events*/
-	/*size has changed - indicate new w & h in .x end .y fields of event.
-	When sent from gpac to a video plugin, indicates the output size should be changed. This is only sent when the plugin
-	manages the output video himself
-	When sent from a video plugin to gpac, indicates the output size has been changed. This is only sent when the plugin
-	manages the output video himself
-	*/
-	GF_EVENT_SIZE,
-	/*signals the scene size (if indicated in scene) upon connection (sent to the user event proc only)
-		if scene size hasn't changed (seeking or other) this event is not sent
-	*/
-	GF_EVENT_SCENE_SIZE,
-	GF_EVENT_SHOWHIDE,	/*window show/hide (minimized or other). */
-	GF_EVENT_SET_CURSOR,	/*set mouse cursor*/
-	GF_EVENT_SET_CAPTION,	/*set window caption*/
-	GF_EVENT_MOVE,		/*move window*/
-	GF_EVENT_REFRESH, /*window needs repaint (whenever needed, eg restore, hide->show, background refresh, paint)*/
-	GF_EVENT_QUIT,	/*app is being closed - associated structure is evt.message to carry any potential reason for quiting*/
-	/*video hw setup message:
-		- when sent from gpac to plugin, indicates that the plugin should re-setup hardware context due to a window resize:
-			* for 2D output, this means resizing the backbuffer if needed (depending on HW constraints)
-			* for 3D output, this means re-setup of OpenGL context (depending on HW constraints). Depending on windowing systems
-			and implementations, it could be possible to resize a window without destroying the GL context.
-
-		- when sent from plugin to gpac, indicates that hardware has been setup.
-		- when sent from gpac to user, indicate aspect ratio has been modified and video output is ready
-	*/
-	GF_EVENT_VIDEO_SETUP,
-	//set current GL context for the calling thread
-	GF_EVENT_SET_GL,
-	/*queries the list of system colors - only exchanged between compositor and video output*/
-	GF_EVENT_SYS_COLORS,
-
-	/*indicates some text has been pasted - from video output to compositor only*/
-	GF_EVENT_PASTE_TEXT,
-	/*queries for text to be copied - from video output to compositor only*/
-	GF_EVENT_COPY_TEXT,
-
-	/*terminal events*/
-	GF_EVENT_CONNECT,	/*signal URL is connected*/
-	GF_EVENT_DURATION,	/*signal duration of presentation*/
-	GF_EVENT_EOS,	/*signal End of scene playback*/
-	GF_EVENT_AUTHORIZATION,	/*indicates a user and pass is queried*/
-	GF_EVENT_NAVIGATE, /*indicates the user app should load or jump to the given URL.*/
-	GF_EVENT_NAVIGATE_INFO, /*indicates the link or its description under the mouse pointer*/
-	GF_EVENT_MESSAGE, /*message from the MPEG-4 terminal*/
-	GF_EVENT_PROGRESS, /*progress message from the MPEG-4 terminal*/
-	GF_EVENT_VIEWPOINTS,	/*indicates viewpoint list has changed - no struct associated*/
-	GF_EVENT_STREAMLIST,	/*indicates stream list has changed - no struct associated - only used when no scene info is present*/
-	GF_EVENT_METADATA, /*indicates a change in associated metadata*/
-	GF_EVENT_MIGRATE, /*indicates a session migration request*/
-	GF_EVENT_DISCONNECT, /*indicates the current url should be disconnected*/
-	GF_EVENT_RESOLUTION, /*indicates the screen resolution has changed*/
-	GF_EVENT_DROPFILE,
-	/* Events for Keyboad */
-	GF_EVENT_TEXT_EDITING_START,
-	GF_EVENT_TEXT_EDITING_END,
-
-	//fire when quality change is detected by compositor
-	GF_EVENT_QUALITY_SWITCHED,
-	//fire when timeshift depth changes
-	GF_EVENT_TIMESHIFT_DEPTH,
-	//fire when position in timeshift buffer changes
-	GF_EVENT_TIMESHIFT_UPDATE,
-	//fire when position overflows the timeshift buffer
-	GF_EVENT_TIMESHIFT_OVERFLOW,
-	//fire when position underruns the timeshift buffer (eg fast forward / seek in the future)
-	GF_EVENT_TIMESHIFT_UNDERRUN,
-	GF_EVENT_MAIN_ADDON_STATE,
-
-	GF_EVENT_ADDON_DETECTED,
-
-	GF_EVENT_SENSOR_ORIENTATION,
-	GF_EVENT_SENSOR_REQUEST,
 } GF_EventType;
 
 /*! GPAC/DOM3 key codes*/
@@ -478,7 +712,7 @@
 } GF_KeyCode;
 
 
-/*! key modifiers state - set by terminal (not set by video driver)*/
+/*! key modifiers state*/
 typedef enum
 {
 	GF_KEY_MOD_SHIFT = (1),

gpac-2.0.0.tar.gz/include/gpac/evg.h -> gpac-2.2.0.tar.gz/include/gpac/evg.h Changed

gpac-2.0.0.tar.gz/include/gpac/filters.h -> gpac-2.2.0.tar.gz/include/gpac/filters.h Changed

@@ -33,7 +33,6 @@
 #include <gpac/tools.h>
 #include <gpac/list.h>
 #include <gpac/events.h>
-#include <gpac/user.h>
 #include <gpac/constants.h>
 #include <gpac/download.h>
 #include <gpac/main.h>
@@ -271,7 +270,7 @@
 
 /*! Runs the session
 
-If the session is non-blocking ( created with \ref GF_FS_FLAG_NON_BLOCKING), process all tasks of oldest scheduled filter, process any pending PID connections and returns.
+If the session is non-blocking (created with \ref GF_FS_FLAG_NON_BLOCKING), process all tasks of oldest scheduled filter, process any pending PID connections and returns.
 Otherwise (session is blocking), runs until session is over or aborted.
 
 \param session filter session
@@ -397,6 +396,17 @@
 */
 GF_Err gf_fs_post_user_task(GF_FilterSession *session, Bool (*task_execute) (GF_FilterSession *fsess, void *callback, u32 *reschedule_ms), void *udta_callback, const char *log_name);
 
+/*! Posts a user task to the session main thread only
+\param session filter session
+\param task_execute the callback function for the task. The callback can return:
+ - GF_FALSE to cancel the task
+ - GF_TRUE to reschedule the task, in which case the task will be rescheduled immediately or after reschedule_ms.
+\param udta_callback callback user data passed back to the task_execute function
+\param log_name log name of the task. If NULL, default is "user_task"
+\return the error code if any
+*/
+GF_Err gf_fs_post_user_task_main(GF_FilterSession *session, Bool (*task_execute) (GF_FilterSession *fsess, void *callback, u32 *reschedule_ms), void *udta_callback, const char *log_name);
+
 /*! Session flush types*/
 typedef enum
 {
@@ -607,14 +617,16 @@
 GF_Err gf_fs_get_filter_stats(GF_FilterSession *session, u32 idx, GF_FilterStats *stats);
 
 
-/*! Enumerates filter and meta-filter arguments not matched in the session
+/*! Enumerates filter and meta-filter arguments not matched in the session. All output parameters may be NULL.
 \param session filter session
 \param idx index of argument to query, 0 being first argument; this value is automatically incremented
 \param argname set to argument name
 \param argtype set to argument type: 0 was a filter param (eg :arg=val), 1 was a global arg (eg --arg=val) and 2 was a global meta arg (eg -+arg=val)
+\param meta_name set to meta filter name if any (for local filter args only)
+\param meta_opt set to meta filter suboption name if any (for local filter args only)
 \return GF_TRUE if success, GF_FALSE if nothing more to enumerate
 */
-Bool gf_fs_enum_unmapped_options(GF_FilterSession *session, u32 *idx, char **argname, u32 *argtype);
+Bool gf_fs_enum_unmapped_options(GF_FilterSession *session, u32 *idx, const char **argname, u32 *argtype, const char **meta_name, const char **meta_opt);
 
 
 
@@ -622,9 +634,9 @@
 typedef enum
 {
 	/*! the update event can be sent down the source chain*/
-	GF_FILTER_UPDATE_DOWNSTREAM = 1<<1,
+	GF_FILTER_UPDATE_DOWNSTREAM = 1,
 	/*! the update event can be sent up the filter chain*/
-	GF_FILTER_UPDATE_UPSTREAM = 1<<2,
+	GF_FILTER_UPDATE_UPSTREAM = 1<<1,
 } GF_EventPropagateType;
 
 /*! Enumerates filter and meta-filter arguments not matched in the session
@@ -704,6 +716,22 @@
 */
 Bool gf_fs_fire_event(GF_FilterSession *session, GF_Filter *filter, GF_FilterEvent *evt, Bool upstream);
 
+
+/*! callback functions for external monitoring of filter creation or destruction
+\param udta user data passed back to callback
+\param do_activate if true context must be activated for calling thread, otherwise context is no longer used
+\return error if any
+ */
+typedef	GF_Err (*gf_fs_gl_activate)(void *udta, Bool do_activate);
+
+/*! assign callbacks for filter creation and destruction monitoring
+\param session filter session
+\param on_gl_activate openGL context activation callback, must not be NULL
+\param udta user data for callbacks, may be NULL
+\return error if any
+ */
+GF_Err gf_fs_set_external_gl_provider(GF_FilterSession *session, gf_fs_gl_activate on_gl_activate, void *udta);
+
 /*! @} */
 
 
@@ -783,8 +811,10 @@
 	/*! 4CC on unsigned 32 bit integer*/
 	GF_PROP_4CC			=	25,
 	/*! 4CC list on unsigned 32 bit integer, memory is ALWAYS duplicated when setting the property*/
-	GF_PROP_4CC_LIST			=	26,
-
+	GF_PROP_4CC_LIST	=	26,
+	/*! string list, memory is duplicated when setting the property - to use only with property assignment functions*/
+	GF_PROP_STRING_LIST_COPY = 27,
+	
 	/*! last non-enum property*/
 	GF_PROP_LAST_NON_ENUM,
 
@@ -1031,6 +1061,8 @@
 	GF_PROP_PID_ZORDER = GF_4CC('V', 'Z','I','X'),
 	GF_PROP_PID_TRANS_X = GF_4CC('V','T','R','X'),
 	GF_PROP_PID_TRANS_Y = GF_4CC('V','T','R','Y'),
+	GF_PROP_PID_TRANS_X_INV = GF_4CC('V','T','R','x'),
+	GF_PROP_PID_TRANS_Y_INV = GF_4CC('V','T','R','y'),
 	GF_PROP_PID_HIDDEN = GF_4CC('H','I','D','E'),
 	GF_PROP_PID_CROP_POS = GF_4CC('V','C','X','Y'),
 	GF_PROP_PID_ORIG_SIZE = GF_4CC('V','O','W','H'),
@@ -1072,8 +1104,6 @@
 	GF_PROP_SERVICE_WIDTH = GF_4CC('D','W','D','T'),
 	GF_PROP_SERVICE_HEIGHT = GF_4CC('D','H','G','T'),
 	GF_PROP_PID_CAROUSEL_RATE = GF_4CC('C','A','R','A'),
-	GF_PROP_PID_UTC_TIME = GF_4CC('U','T','C','D'),
-	GF_PROP_PID_UTC_TIMESTAMP = GF_4CC('U','T','C','T'),
 	GF_PROP_PID_AUDIO_VOLUME = GF_4CC('A','V','O','L'),
 	GF_PROP_PID_AUDIO_PAN = GF_4CC('A','P','A','N'),
 	GF_PROP_PID_AUDIO_PRIORITY = GF_4CC('A','P','R','I'),
@@ -1102,6 +1132,7 @@
 	GF_PROP_PID_CENC_PATTERN = GF_4CC('C','P','T','R'),
 	GF_PROP_PID_CENC_STORE = GF_4CC('C','S','T','R'),
 	GF_PROP_PID_CENC_STSD_MODE = GF_4CC('C','S','T','M'),
+	GF_PROP_PID_CENC_HAS_ROLL = GF_4CC('C','R','O','L'),
 	GF_PROP_PID_AMR_MODE_SET = GF_4CC('A','M','S','T'),
 	GF_PROP_PCK_SUBS = GF_4CC('S','U','B','S'),
 	GF_PROP_PID_MAX_NALU_SIZE = GF_4CC('N','A','L','S'),
@@ -1111,6 +1142,8 @@
 	GF_PROP_PCK_FILESUF = GF_4CC('F','S','U','F'),
 	GF_PROP_PCK_EODS = GF_4CC('E','O','D','S'),
 	GF_PROP_PCK_CUE_START = GF_4CC('P','C','U','S'),
+	GF_PROP_PCK_UTC_TIME = GF_4CC('U','T','C','D'),
+	GF_PROP_PCK_MEDIA_TIME = GF_4CC('M','T','I','M'),
 
 	GF_PROP_PID_MAX_FRAME_SIZE = GF_4CC('M','F','R','S'),
 	GF_PROP_PID_AVG_FRAME_SIZE = GF_4CC('A','F','R','S'),
@@ -1134,6 +1167,7 @@
 	GF_PROP_PID_AS_ID = GF_4CC('D','A','I','D'),
 	GF_PROP_PID_MUX_SRC = GF_4CC('M','S','R','C'),
 	GF_PROP_PID_DASH_MODE = GF_4CC('D','M','O','D'),
+	GF_PROP_PID_FORCE_SEG_SYNC = GF_4CC('D','F','S','S'),
 	GF_PROP_PID_DASH_DUR = GF_4CC('D','D','U','R'),
 	GF_PROP_PID_DASH_MULTI_PID = GF_4CC('D','M','S','D'),
 	GF_PROP_PID_DASH_MULTI_PID_IDX = GF_4CC('D','M','S','I'),
@@ -1173,6 +1207,7 @@
 	GF_PROP_PID_COLR_CHROMALOC = GF_4CC('C','L','O','C'),
 	GF_PROP_PID_CONTENT_LIGHT_LEVEL = GF_4CC('C','L','L','I'),
 	GF_PROP_PID_MASTER_DISPLAY_COLOUR = GF_4CC('M','D','C','V'),
+	GF_PROP_PID_ICC_PROFILE = GF_4CC('I','C','C','P'),
 	GF_PROP_PID_SRC_MAGIC = GF_4CC('P','S','M','G'),
 	GF_PROP_PID_MUX_INDEX = GF_4CC('T','I','D','X'),
 	GF_PROP_NO_TS_LOOP = GF_4CC('N','T','S','L'),
@@ -1198,11 +1233,14 @@
 	GF_PROP_PID_VR_POSE = GF_4CC('P','P','O','S'),
 	GF_PROP_PID_CUBE_MAP_PAD = GF_4CC('P','C','M','P'),
 	GF_PROP_PID_EQR_CLAMP = GF_4CC('P','E','Q','C'),
+	GF_PROP_PID_SPARSE = GF_4CC('P','S','P','A'),
 
 	GF_PROP_PID_SCENE_NODE = GF_4CC('P','S','N','D'),
 	GF_PROP_PID_ORIG_CRYPT_SCHEME = GF_4CC('P','O','C','S'),
 	GF_PROP_PID_TIMESHIFT_SEGS = GF_4CC('P','T','S','N'),
 
+	GF_PROP_PID_CHAP_TIMES = GF_4CC('C','H','P','T'),
+	GF_PROP_PID_CHAP_NAMES = GF_4CC('C','H','P','N'),
 
 	//internal for HLS playlist reference, gives a unique ID identifying media mux, and indicated in packets carrying child playlists
 	GF_PROP_PCK_HLS_REF = GF_4CC('H','P','L','R'),
@@ -1220,6 +1258,11 @@
 	GF_PROP_PCK_HLS_VARIANT_NAME = GF_4CC('D','H','L','N'),
 	GF_PROP_PID_HLS_KMS = GF_4CC('H','L','S','K'),
 	GF_PROP_PID_HLS_IV = GF_4CC('H','L','S','I'),
+	GF_PROP_PID_CLEARKEY_URI = GF_4CC('C','C','K','U'),
+	//internal
+	GF_PROP_PID_CLEARKEY_KID = GF_4CC('C','C','K','I'),
+
+
 	//internal property indicating pointer to associated GF_DownloadSession
 	GF_PROP_PID_DOWNLOAD_SESSION = GF_4CC('G','H','T','T'),
 
@@ -1233,13 +1276,23 @@
 	GF_PROP_PCK_XPS_MASK = GF_4CC('P','X','P','M'),
 	GF_PROP_PCK_END_RANGE = GF_4CC('P','C','E','R'),
 
-	/*! Internal property used for FFMPEG codec ID
+	//internal, force creation of rewriter filter (only used for forcing reparse of NALU-based codecs)
+	GF_PROP_PID_FORCE_UNFRAME = GF_4CC('P','F','U','F'),
+
+
+	/*! Internal property used for meta demuxers ( FFMPEG, ...) codec ID
 
 	Property can be:
 	- pointer to codec context: only for ffdmx with old ffmpeg versions)
 	- uint: AVCODEC_ID_* ffdmx with newer versions or ffenc output
 	*/
-	GF_PROP_PID_FFMPEG_CODEC_ID = GF_4CC('F','C','I','D'),
+	GF_PROP_PID_META_DEMUX_CODEC_ID = GF_4CC('M','D','C','I'),
+
+	/*! Internal property used for meta demuxers ( FFMPEG, ...) codec name*/
+	GF_PROP_PID_META_DEMUX_CODEC_NAME = GF_4CC('M','D','C','N'),
+
+	/*! Internal property used for meta demuxers ( FFMPEG, ...) codec opaque data, u32*/
+	GF_PROP_PID_META_DEMUX_OPAQUE = GF_4CC('M','D','O','P'),
 };
 
 /*! Block patching requirements for FILE pids, as signaled by GF_PROP_PID_DISABLE_PROGRESSIVE
@@ -1351,7 +1404,7 @@
 	GF_PROP_DUMP_DATA_INFO,
 	/*! dump data to parsable property, as ADDRESS+'@'+POINTER*/
 	GF_PROP_DUMP_DATA_PTR,
-} GF_PropDumDataMode;
+} GF_PropDumpDataMode;
 
 /*! Dumps a property value to string
 \param att property value
@@ -1360,7 +1413,7 @@
 \param min_max_enum optional, gives the min/max or enum string when the property is a filter argument
 \return string
 */
-const char *gf_props_dump_val(const GF_PropertyValue *att, char dumpGF_PROP_DUMP_ARG_SIZE, GF_PropDumDataMode dump_data_mode, const char *min_max_enum);
+const char *gf_props_dump_val(const GF_PropertyValue *att, char dumpGF_PROP_DUMP_ARG_SIZE, GF_PropDumpDataMode dump_data_mode, const char *min_max_enum);
 
 /*! Dumps a property value to string, resolving any built-in types (pix formats, codec id, ...)
 \param p4cc property 4CC
@@ -1369,7 +1422,7 @@
 \param dump_data_mode data dump mode
 \return string
 */
-const char *gf_props_dump(u32 p4cc, const GF_PropertyValue *att, char dumpGF_PROP_DUMP_ARG_SIZE, GF_PropDumDataMode dump_data_mode);
+const char *gf_props_dump(u32 p4cc, const GF_PropertyValue *att, char dumpGF_PROP_DUMP_ARG_SIZE, GF_PropDumpDataMode dump_data_mode);
 
 /*! Resets a property value, freeing allocated data or strings depending on the property type
 \param prop property 4CC
@@ -1589,7 +1642,10 @@
 
 	/*! GF_FEVT_PLAY only, set when PLAY event is sent upstream to audio out, indicates HW buffer reset*/
 	u8 hw_buffer_reset;
-	/*! GF_FEVT_PLAY only: indicates this is the first PLAY on an element inserted from bcast*/
+	/*!
+		1: indicates this is the first PLAY on an element inserted from broadcast/live (GF_FEVT_PLAY only)
+		2: indicates this is a PLAY preceeding a STOP or a STOP for a PID being disconnected (GF_FEVT_PLAY and GF_FEVT_STOP)
+	*/
 	u8 initial_broadcast_play;
 	/*! params for GF_FEVT_PLAY only
 		0: range is in media time
@@ -2043,6 +2099,8 @@
 This is used by filters loading subchains to enforce that filters from these subchain only connect to each other or the target filter but not other filters outside this chain.
 Filters using this function must setup source IDs on filters of the sunchain(s) they load.
 
+ Noye: This has the same effect has setting `:RSID` option on the filter
+
 \param filter target filter
 */
 void gf_filter_require_source_id(GF_Filter *filter);
@@ -2138,6 +2196,11 @@
 		For source filters, indicates the PIDs should be remuxed to a destination filter with force remux set
 	*/
 	GF_FS_REG_FORCE_REMUX = 1<<12,
+	/*! Indicates the filter must always be run by the same thread, except for the initialize and finalize methods*/
+	GF_FS_REG_SINGLE_THREAD = 1<<13,
+	/*! Indicates the filter needs to be initialized even if temoorary - see \ref gf_filter_is_temporary. Always enabled if GF_FS_REG_META is set */
+	GF_FS_REG_TEMP_INIT = 1<<14,
+
 
 	/*! flag dynamically set at runtime for custom filters*/
 	GF_FS_REG_CUSTOM = 0x40000000,
@@ -2353,6 +2416,20 @@
 */
 void gf_filter_set_name(GF_Filter *filter, const char *name);
 
+/*! Checks is a filter is temporary, ie only loaded to solve caps but will not be used.
+
+ Only filter classes setting the GF_FS_REG_TEMP_INIT or GF_FS_REG_META need to check this, and only during the initialize call.
+
+if filter is temprary, it is loaded only to probe for a filter chain setup and will be finalized immediately after.
+This implies that most filter resources (sockets, file handles, etc) must not be created in this case.
+
+A temporary filter will be finalized as any other filter.
+
+\param filter target filter
+\return GF_TRUE if filter is temporary
+*/
+Bool gf_filter_is_temporary(GF_Filter *filter);
+
 /*! Gets filter name
 \param filter target filter
 \return name of the filter
@@ -2506,6 +2583,15 @@
 */
 Bool gf_filter_is_supported_source(GF_Filter *filter, const char *url, const char *parent_url);
 
+/*! Checks if a URL describes a filter
+
+\param filter the target filter
+\param url filter description chain, with optional arguments.
+\param act_as_source set to GF_TRUE if filter described acts as a source - may be NULL.
+\return GF_TRUE if a filter is described by this url, GF_FALSE otherwise
+*/
+Bool gf_filter_url_is_filter(GF_Filter *filter, const char *url, Bool *act_as_source);
+
 /*! Gets the number of input PIDs connected to a filter
 \param filter the target filter
 \return number of input PIDs
@@ -2678,9 +2764,10 @@
 
 /*! Trigger reconnection of output PIDs of a filter. This is needed when inserting a filter in the chain while the session is running
 \param filter the target filter
+\param for_pid reconnects only the given output PID - if NULL, reconnect all output PIDs
 \return error if any
 */
-GF_Err gf_filter_reconnect_output(GF_Filter *filter);
+GF_Err gf_filter_reconnect_output(GF_Filter *filter, GF_FilterPid *for_pid);
 
 
 /*! Indicates that the filter accept and can process events coming from outside the filter chain, typically used by application firing events.
@@ -2860,9 +2947,10 @@
 \note There may be several OpenGL context created in the filter session, depending on activated filters. A filter using OpenGL must call this function before issuing any OpenGL calls
 
 \param filter filter asking for OpenGL context activation
+\param do_activate if true, context must be activated for the calling thread, otherwise context is being released
 \return error code if any
 */
-GF_Err gf_filter_set_active_opengl_context(GF_Filter *filter);
+GF_Err gf_filter_set_active_opengl_context(GF_Filter *filter, Bool do_activate);
 
 
 /*! Count the number of source filters for the given filter matching the given protocol type.
@@ -2945,9 +3033,10 @@
 know the set of available options at initialize() time.
 \param filter target filter
 \param arg name of the argument not used/found
-\param was_found indicate that this option was found
+\param was_found indicate if option was found ot not
+\param sub_opt_name indicate sub-option name, or NULL for regular options. This is used to track unused values in multiple-values options
 */
-void gf_filter_report_meta_option(GF_Filter *filter, const char *arg, Bool was_found);
+void gf_filter_report_meta_option(GF_Filter *filter, const char *arg, Bool was_found, const char *sub_opt_name);
 
 /*! used by script to set a per-instance description
 \param filter target filter
@@ -3122,6 +3211,25 @@
 */
 GF_Err gf_filter_tag_subsession(GF_Filter *filter, u32 subsession_id, u32 source_id);
 
+/*! Check if connect errors happened in the filter parent session
+\param filter target filter
+\return GF_TRUE if parent session has seen connection errors, GF_FALSE otherwise
+*/
+Bool gf_filter_has_connect_errors(GF_Filter *filter);
+
+
+/*! Sets names of sub-instances involved in a meta-filter instance
+\param filter target filter
+\param instance_names_list space-separated names of meta filter instances, without meta registry name. eg "negate" for ffavf::f=negate
+*/
+void gf_filter_meta_set_instances(GF_Filter *filter, const char *instance_names_list);
+
+/*! Gets names of sub-instances involved in a meta-filter instance
+\param filter target filter
+\return NULL or space-separated names of meta filter instances, without meta registry name. eg "negate" for ffavf::f=negate
+*/
+const char *gf_filter_meta_get_instances(GF_Filter *filter);
+
 /*! @} */
 
 
@@ -3415,7 +3523,7 @@
 	/*! max process rate on that PID in bits per seconds*/
 	u32 max_process_rate;
 	/*! average bitrate for that PID*/
-	u32 avgerage_bitrate;
+	u32 average_bitrate;
 	/*! max bitrate for that PID*/
 	u32 max_bitrate;
 	/*! number of packets processed on that PID*/
@@ -3447,6 +3555,16 @@
 	u64 buffer_time;
 	/*! number of units in input buffer of the filter - only set when querying decoder stats*/
 	u32 nb_buffer_units;
+
+	/*! last RT info update time in microsec (cf \ref gf_sys_clock_high_res) - input pid only */
+	u64 last_rt_report;
+	/*! estimated round-trip time in ms - input pid only */
+	u32 rtt;
+	/*! estimated interarrival jitter in microseconds - input pid only */
+	u32 jitter;
+	/*! loss rate in per-thousand - input pid only */
+	u32 loss_rate;
+
 } GF_FilterPidStatistics;
 
 /*! Direction for stats querying*/
@@ -3454,7 +3572,8 @@
 {
 	/*! statistics are fetched on the current PID's parent filter. If the PID is an output PID, the statistics are fetched on all the destinations for that PID*/
 	GF_STATS_LOCAL = 0,
-	/*! statistics are fetched on the current PID's parent filter. The statistics are fetched on all input of the parent filter*/
+	/*! statistics are fetched on the current PID's parent filter. The statistics are fetched on all input of the parent filter
+	If the pid is an output pid, this is equivalent to GF_STATS_LOCAL*/
 	GF_STATS_LOCAL_INPUTS,
 	/*! statistics are fetched on all inputs of the next decoder filter up the chain (towards the sink)*/
 	GF_STATS_DECODER_SINK,
@@ -3463,7 +3582,9 @@
 	/*! statistics are fetched on all inputs of the next encoder filter up the chain (towards the sink)*/
 	GF_STATS_ENCODER_SINK,
 	/*! statistics are fetched on all inputs of the previous encoder filter down the chain (towards the source)*/
-	GF_STATS_ENCODER_SOURCE
+	GF_STATS_ENCODER_SOURCE,
+	/*! statistics are fetched on all inputs of the next sink filter of the chain*/
+	GF_STATS_SINK
 } GF_FilterPidStatsLocation;
 
 /*! Gets statistics for the PID
@@ -3550,7 +3671,7 @@
 
 /*! Gets cumulated buffer duration of PID (recursive until source)
 \param PID the target filter PID
-\param check_pid_full if GF_TRUE, returns 0 if the PID buffer is not yet full
+\param check_pid_full if GF_TRUE, returns 0 if the PID buffer is not yet full, or GF_FILTER_NO_TS if pid buffer is full
 \return the duration in us, or -1 if session is in final flush
 */
 u64 gf_filter_pid_query_buffer_duration(GF_FilterPid *PID, Bool check_pid_full);
@@ -3611,9 +3732,19 @@
 */
 Bool gf_filter_pid_first_packet_is_empty(GF_FilterPid *PID);
 
+/*! Checks if the first packet on an input PID is a blocking ref.
+\param PID the target filter PID
+\return GF_TRUE if packet is valid and blocking, GF_FALSE otherwise
+*/
+Bool gf_filter_pid_first_packet_is_blocking_ref(GF_FilterPid *PID);
+
 /*! Gets the first packet in the input PID buffer.
 This may trigger a reconfigure signal on the filter. If reconfigure is not OK, returns NULL and the PID passed to the filter NO LONGER EXISTS (implicit remove)
 The packet is still present in the PID buffer until explicitly removed by \ref gf_filter_pid_drop_packet
+
+The returned packet is only valid for the current filter execution (process callback, task, ...), and may be discarded in-between calls, typically when the session is aborted.
+If a filter needs to keep a packet across calls, it must use \ref gf_filter_pck_ref and \ref gf_filter_pck_unref
+
 \param PID the target filter PID
 \return packet or NULL of empty or reconfigure error
 */
@@ -3652,6 +3783,20 @@
 */
 Bool gf_filter_pid_would_block(GF_FilterPid *PID);
 
+/*! Checks if the PID is sparse. A sparse PID may have holes in its timeline.
+
+A sparse PID is always considered blocking for the regulation, even if \ref gf_filter_pid_would_block for this PID can return FALSE (buffers not full).
+This avoids unblocking a filter when only its sparse output PIDs are not full (typically text streams).
+
+A PID is sparse if:
+- it has the property GF_PROP_PID_SPARSE set to true
+- or it does not have the property GF_PROP_PID_SPARSE defined and it is not an audio, video or file stream.
+
+\param PID the target filter PID
+\return GF_TRUE if PID is sparse , GF_FALSE otherwise
+*/
+Bool gf_filter_pid_is_sparse(GF_FilterPid *PID);
+
 /*! Shortcut to access the timescale of the PID - faster than get property as the timescale is locally cached for buffer management
 \param PID the target filter PID
 \return the PID timescale
@@ -3833,6 +3978,23 @@
 */
 u64 gf_filter_pid_get_next_ts(GF_FilterPid *PID);
 
+/*! Checks if a decoder is present in parent chain of this pid.
+This is a recursive call on input chain. The function is typically used when setting up buffer levels on raw media pids.
+\param PID the target filter PID
+\return GF_TRUE if a decoder is present in input chain, GF_FALSE otherwise
+*/
+Bool gf_filter_pid_has_decoder(GF_FilterPid *PID);
+
+
+/*! Sets real-time stats on PID (input PID only for now)
+
+\param PID the target filter PID
+\param rtt_ms estimated round-trip time in ms
+\param jitter_us estimated packet inter-arrival jitter in us
+\param loss_rate loss rate in per-thousand
+\return error if any
+*/
+GF_Err gf_filter_pid_set_rt_stats(GF_FilterPid *PID, u32 rtt_ms, u32 jitter_us, u32 loss_rate);
 
 /*! @} */
 
@@ -3950,7 +4112,7 @@
 */
 GF_FilterPacket *gf_filter_pck_new_copy(GF_FilterPid *PID, GF_FilterPacket *pck_source, u8 **data);
 
-/*! Creates a read-only detached copy of a packet from a source packet and copy all source properties to output.
+/*! Creates a read-only detached copy of a packet from a source packet and copy all source properties to output.
 
 If the source packet uses a frame interface object or has no associated data, returns a copy of the packet.
 If the source packet is referenced more than once (ie more than just the caller), a new packet on the output PID is allocated with source data copied.
@@ -4447,8 +4609,9 @@
 
 
 /*!
-\addtogroup fs_props Filter Properties
-\ingroup filters__cust_grp
+\addtogroup filters__cust_grp Custom Filter
+\ingroup filters_grp
+
 \brief Custom Filter
 
 Custom filters are filters created by the app with no associated registry.

gpac-2.0.0.tar.gz/include/gpac/ietf.h -> gpac-2.2.0.tar.gz/include/gpac/ietf.h Changed

@@ -308,6 +308,8 @@
 	char *service_name;
 	/*RTSP status code of the command as parsed. One of the above RTSP StatusCode*/
 	u32 StatusCode;
+
+	Bool is_resend;
 } GF_RTSPCommand;
 
 /*! creates an RTSP command
@@ -465,8 +467,9 @@
 \param sess the target RTSP session
 \param ResetConnection if set, this will destroy the associated TCP socket. This is useful in case of timeouts, because
 some servers do not restart with the right CSeq.
+\return number of retries for reset happening before first server reply, 0 otherwise
 */
-void gf_rtsp_session_reset(GF_RTSPSession *sess, Bool ResetConnection);
+u32 gf_rtsp_session_reset(GF_RTSPSession *sess, Bool ResetConnection);
 
 /*! checks if an RTSP session matches an RTSP URL
 \param sess the target RTSP session
@@ -479,13 +482,33 @@
 \param sess the target RTSP session
 \return the server name
 */
-char *gf_rtsp_get_server_name(GF_RTSPSession *sess);
+const char *gf_rtsp_get_server_name(GF_RTSPSession *sess);
+
+/*! gets user name of an RTSP session
+\param sess the target RTSP session
+\return the user name or NULL if none
+*/
+const char *gf_rtsp_get_user(GF_RTSPSession *sess);
+
+/*! gets password of an RTSP session
+\param sess the target RTSP session
+\return the password or NULL if none
+*/
+const char *gf_rtsp_get_password(GF_RTSPSession *sess);
+
+
 /*! gets server port of an RTSP session
 \param sess the target RTSP session
 \return the server port
 */
 u16 gf_rtsp_get_session_port(GF_RTSPSession *sess);
 
+/*! checks if RTSP connection is over TLS
+\param sess the target RTSP session
+\return GF_TRUE if connection is secured
+*/
+Bool gf_rtsp_use_tls(GF_RTSPSession *sess);
+
 /*! fetches an RTSP response from the server.  the GF_RTSPResponse will be reseted before fetch
 \param sess the target RTSP session
 \param rsp the response object to fill with the response. This will be reseted before TCP fetch
@@ -530,6 +553,12 @@
 */
 GF_Err gf_rtsp_send_command(GF_RTSPSession *sess, GF_RTSPCommand *com);
 
+/*! checks connection status - should be called before processing any RTSP for non-blocking IO
+\param sess the target RTSP session
+\return GF_IP_NETWORK_EMPTY if connection is still pending or data cannot be flushed, GF_OK if connected and no more data to send or error if any
+*/
+GF_Err gf_rtsp_check_connection(GF_RTSPSession *sess);
+
 
 /*! callback function for interleaved RTSP/TCP transport
 \param sess the target RTSP session
@@ -573,14 +602,18 @@
 /*! creates a new RTSP session from an existing socket in listen state. If no pending connection
 	is detected, return NULL
 \param rtsp_listener the listening server socket
+\param allow_http_tunnel indicate if HTTP tunnel should be enabled
+\param ssl_ctx OpenSSL context
 \return the newly allocated RTSP session if any, NULL otherwise
 */
-GF_RTSPSession *gf_rtsp_session_new_server(GF_Socket *rtsp_listener);
+GF_RTSPSession *gf_rtsp_session_new_server(GF_Socket *rtsp_listener, Bool allow_http_tunnel, void *ssl_ctx);
 
+/*! special error code for \ref gf_rtsp_get_command*/
+#define GF_RTSP_TUNNEL_POST	-1000
 /*! fetches an RTSP request
 \param sess the target RTSP session
 \param com the RTSP command to fill with the command. This will be reseted before fetch
-\return error if any
+\return error if any or GF_RTSP_TUNNEL_POST if this is a POST on a HTPP tunnel
 */
 GF_Err gf_rtsp_get_command(GF_RTSPSession *sess, GF_RTSPCommand *com);
 
@@ -620,6 +653,19 @@
 */
 GF_Err gf_rtsp_session_write_interleaved(GF_RTSPSession *sess, u32 idx, u8 *pck, u32 pck_size);
 
+/*! gets sessioncookie for HTTP tunnel
+\param sess the target RTSP session
+\return cookie or NULL if none
+*/
+const char *gf_rtsp_get_session_cookie(GF_RTSPSession *sess);
+
+/*! move TCP connection of a POST HTTP tunnel link to main session
+\param sess the target RTSP session
+\param post_sess the target RTSP POST http tunnel session - the session is not destroyed, only its connection is detached
+\return error if any
+*/
+GF_Err gf_rtsp_merge_tunnel(GF_RTSPSession *sess, GF_RTSPSession *post_sess);
+
 /*
 		RTP LIB EXPORTS
 */
@@ -747,6 +793,16 @@
 */
 GF_Err gf_rtp_stop(GF_RTPChannel *ch);
 
+/*! sets source-specific IPs - this MUST be called before calling \ref gf_rtp_initialize
+\param ch the target RTP channel
+\param src_ip_inc IP of sources to receive from
+\param nb_src_ip_inc number of sources to receive from
+\param src_ip_exc IP of sources to exclude
+\param nb_src_ip_exc number of sources to exclude
+\return error if any
+*/
+GF_Err gf_rtp_set_ssm(GF_RTPChannel *ch, const char **src_ip_inc, u32 nb_src_ip_inc, const char **src_ip_exc, u32 nb_src_ip_exc);
+
 /*! inits the RTP info after a PLAY or PAUSE, rtp_time is the rtp TimeStamp of the RTP packet
 with seq_num sequence number. This info is needed to compute the CurrentTime of the RTP channel
 ssrc may not be known if sender hasn't indicated it (use 0 then)
@@ -838,6 +894,13 @@
 */
 GF_Err gf_rtp_send_rtcp_report(GF_RTPChannel *ch);
 
+/*! forces loss rate for next Receiver report
+\param ch the target RTP channel
+\param loss_rate loss rate in per-thousand
+\return error if any
+*/
+void gf_rtp_set_loss_rate(GF_RTPChannel *ch, u32 loss_rate);
+
 /*! sends a BYE info (leaving the session)
 \param ch the target RTP channel
 \return error if any
@@ -1220,6 +1283,7 @@
 	/*config of the stream if carried in SDP*/
 	u8 *config;
 	u32 configSize;
+	u8 config_updated;
 	/* Stream Type*/
 	u8 StreamType;
 	/* stream profile and level indication - for AVC/H264, 0xPPCCLL, with PP:profile, CC:compatibility, LL:level*/
@@ -1399,6 +1463,8 @@
 	GF_RTP_PAYT_LATM,
 	/*use AC3 audio format*/
 	GF_RTP_PAYT_AC3,
+	/*use EAC3 audio format*/
+	GF_RTP_PAYT_EAC3,
 	/*use H264-SVC transport*/
 	GF_RTP_PAYT_H264_SVC,
 	/*use HEVC/H265 transport (RFC 7798)*/
@@ -1410,6 +1476,8 @@
 #endif
 	/*use VVC transport (no RFC yet)*/
 	GF_RTP_PAYT_VVC,
+	/*use opus audio format*/
+	GF_RTP_PAYT_OPUS,
 };

gpac-2.0.0.tar.gz/include/gpac/internal/compositor_dev.h -> gpac-2.2.0.tar.gz/include/gpac/internal/compositor_dev.h Changed

@@ -35,7 +35,6 @@
 /*bridge between the rendering engine and the systems media engine*/
 #include <gpac/mediaobject.h>
 #include <gpac/filters.h>
-#include <gpac/term_info.h>
 
 /*raster2D API*/
 #include <gpac/evg.h>
@@ -58,7 +57,9 @@
 typedef struct _gf_scene GF_Scene;
 typedef struct _gf_addon_media GF_AddonMedia;
 typedef struct _object_clock GF_Clock;
-//typedef struct _od_manager GF_ObjectManager;
+
+/*! Media object manager*/
+typedef struct _od_manager GF_ObjectManager;
 
 Bool gf_sc_send_event(GF_Compositor *compositor, GF_Event *evt);
 
@@ -202,9 +203,6 @@
 
 struct __tag_compositor
 {
-	u32 magic;	//must be "comp"
-	void *magic_ptr; //must point to this structure
-
 	u32 init_flags;
 	void *os_wnd;
 
@@ -271,8 +269,10 @@
 	//autofps option
 	Bool vfr;
 	Bool nojs;
-	Bool dyn_filter_mode;
+	Bool forced_alpha;
 	Bool noback;
+	Bool clipframe;
+
 	//frame duration in ms, used to match closest frame in input video streams
 	u32 frame_duration;
 	Bool frame_was_produced;
@@ -305,8 +305,15 @@
 	
 	u32 ogl, mode2d;
 
+	s32 subtx, subty, subd, audd;
+	u32 subfs;
+
+	u64 hint_extra_scene_cts_plus_one;
+	u32 hint_extra_scene_dur_plus_one;
+
 	/*display size*/
 	u32 display_width, display_height;
+	GF_DisplayOrientationType disp_ori;
 
 	/*visual output location on window (we may draw background color outside of it)
 		vp_x & vp_y: horizontal & vertical offset of the drawing area in the video output
@@ -373,6 +380,7 @@
 	//in non player mode, check for eos
 	u32 check_eos_state;
 	u32 last_check_pass;
+	Bool flush_audio;
 
 	/*set whenever 3D HW ctx changes (need to rebuild dlists/textures if any used)*/
 	u32 reset_graphics;
@@ -395,6 +403,7 @@
 	Bool hybrid_opengl;
 
 	Bool fsize;
+	Bool event_pending;
 
 	/*key modif*/
 	u32 key_states;
@@ -701,7 +710,6 @@
 
 	Bool validator_mode;
 
-	//moved from old GF_Terminal
 	struct _gf_scene *root_scene;
 	Bool drop;
 	Bool sclock;
@@ -732,6 +740,10 @@
 	 */
 	GF_List *nodes_pending;
 	GF_List *extensions, *unthreaded_extensions;
+
+	u32 reload_state;
+	char *reload_url;
+
 };
 
 typedef struct
@@ -1324,6 +1336,7 @@
 	Bool need_release;
 	u32 is_open;
 	Bool is_muted;
+	Bool is_playing;
 	Bool register_with_renderer, register_with_parent;
 
 	GF_SoundInterface *snd;
@@ -1595,7 +1608,7 @@
 typedef struct
 {
 	void *udta;
-	/*called when new video frame is ready to be flushed on screen. time is the terminal global clock in ms*/
+	/*called when new video frame is ready to be flushed on screen. time is the compositor global clock in ms*/
 	void (*on_video_frame)(void *udta, u32 time);
 	/*called when video output has been resized*/
 	void (*on_video_reconfig)(void *udta, u32 width, u32 height, u8 bpp);
@@ -1603,7 +1616,14 @@
 
 GF_Err gf_sc_set_scene_size(GF_Compositor *compositor, u32 Width, u32 Height, Bool force_size);
 
-void gf_sc_sys_frame_pending(GF_Compositor *compositor, Double ts_offset, u32 obj_time, GF_Filter *from_filter);
+void gf_sc_sys_frame_pending(GF_Compositor *compositor, u32 cts, u32 obj_time, GF_Filter *from_filter);
+Bool gf_sc_check_sys_frame(GF_Scene *scene, GF_ObjectManager *odm, GF_FilterPid *for_pid, GF_Filter *from_filter, u64 cts_in_ms, u32 dur_in_ms);
+
+/*
+get diff in ms (independent of clock absolute speed value, only speed sign) between a clock value and a timestamp in ms
+return value is positive if timestamp is ahead (in the future of the clock timeline) of clock, negative if in the past (late)
+*/
+s32 gf_clock_diff(GF_Clock *ck, u32 ck_time, u32 cts);
 
 Bool gf_sc_is_over(GF_Compositor *compositor, GF_SceneGraph *scene_graph);
 
@@ -1732,7 +1752,7 @@
 	u32 selected_service_id;
 
 	/*URLs of current video, audio and subs (we can't store objects since they may be destroyed when seeking)*/
-	SFURL visual_url, audio_url, text_url, dims_url;
+	SFURL visual_url, audio_url, text_url, dims_url, subs_url;
 
 	Bool is_tiled_srd;
 	u32 srd_type;
@@ -1772,7 +1792,8 @@
 	GF_List *declared_addons;
 	//set when content is replaced by an addon (DASH PVR mode)
 	Bool main_addon_selected;
-	u32 sys_clock_at_main_activation, obj_clock_at_main_activation;
+	u32 sys_clock_at_main_activation;
+	u64 obj_clock_at_main_activation;
 
 	//0: no pause - 1: paused and trigger pause command to net, 2: only clocks are paused but commands not sent
 	u32 first_frame_pause_type;
@@ -1825,7 +1846,7 @@
 void gf_scene_insert_pid(GF_Scene *scene, GF_SceneNamespace *sns, GF_FilterPid *pid, Bool is_in_iod);
 
 /*exported for compositor: handles filtering of "self" parameter indicating anchor only acts on container inline scene
-not root one. Returns 1 if handled (cf user.h, navigate event)*/
+not root one. Returns 1 if handled - cf \ref GF_EventNavigate*/
 Bool gf_scene_process_anchor(GF_Node *caller, GF_Event *evt);
 void gf_scene_force_size_to_video(GF_Scene *scene, GF_MediaObject *mo);
 
@@ -1842,7 +1863,7 @@
 
 GF_Node *gf_scene_get_subscene_root(GF_Node *inline_node);
 
-void gf_scene_select_main_addon(GF_Scene *scene, GF_ObjectManager *odm, Bool set_on, u32 current_clock_time);
+void gf_scene_select_main_addon(GF_Scene *scene, GF_ObjectManager *odm, Bool set_on, u64 absolute_clock_time);
 void gf_scene_reset_addons(GF_Scene *scene);
 void gf_scene_reset_addon(GF_AddonMedia *addon, Bool disconnect);
 
@@ -1919,6 +1940,9 @@
 	mediaControl and others that would break stream dependencies*/
 	Bool clock_init, has_seen_eos, no_time_ctrl;
 	u32 init_timestamp, start_time, pause_time, nb_paused;
+	//number of loops (x 0xFFFFFFFFUL) at init time, used to recompute absolute 64bit clock value if needed
+	u32 init_ts_loops;
+
 	/*the number of streams buffering on this clock*/
 	u32 nb_buffering;
 	/*associated media control if any*/
@@ -1932,11 +1956,14 @@
 	u32 last_ts_rendered;
 	u32 service_id;
 
-	//media time in ms corresponding to the init tmiestamp of the clock
-	u32 media_time_at_init;
+	//media time in ms
+	u64 media_time_orig;
+	//absolute media timestamp in ms corresponding to the media time
+	u64 media_ts_orig;
 	Bool has_media_time_shift;
 
-	u32 ocr_discontinuity_time;
+	//in ms without 32bit modulo
+	u64 ocr_discontinuity_time;
 	//we increment this one at each reset, and ask the filter chain to mark packets with this flag
 	u32 timeline_id;
 };
@@ -1956,16 +1983,16 @@
 /*return clock time in ms*/
 u32 gf_clock_time(GF_Clock *ck);
 /*return media time in ms*/
-u32 gf_clock_media_time(GF_Clock *ck);
+u64 gf_clock_media_time(GF_Clock *ck);
 
-/*translates from clock time in ms to media time in ms*/
-u32 gf_clock_to_media_time(GF_Clock *ck, u32 clock_val);
+/*translates from clock time in ms to absolute media time in ms*/
+u64 gf_clock_to_media_time(GF_Clock *ck, u32 clock_val);
 
 /*return time in ms since clock started - may be different from clock time when seeking or live*/
 u32 gf_clock_elapsed_time(GF_Clock *ck);
 
 /*sets clock time - FIXME: drift updates for OCRs*/
-void gf_clock_set_time(GF_Clock *ck, u32 TS);
+void gf_clock_set_time(GF_Clock *ck, u64 ref_TS, u32 timescale);
 /*return clock time in ms without drift adjustment - used by audio objects only*/
 u32 gf_clock_real_time(GF_Clock *ck);
 /*pause the clock*/
@@ -1985,6 +2012,11 @@
 audio is usually send to the sound card quite ahead of time, depending on the output compositor settings*/
 void gf_clock_set_audio_delay(GF_Clock *ck, s32 ms_delay);
 
+//convert a 64-bit timestamp to clock time in ms. Clock times are always on 32 bits
+u32 gf_timestamp_to_clocktime(u64 ts, u32 timescale);
+
+//get absolute clock time in ms, including wrapping due to 32bit counting
+u64 gf_clock_time_absolute(GF_Clock *ck);
 
 /*OD manager*/
 
@@ -2033,6 +2065,9 @@
 	GF_ODM_TILED_SHARED_CLOCK = (1<<16),
 	/*flag indicates TEMI info is associated with PID*/
 	GF_ODM_HAS_TEMI = (1<<17),
+
+	/*flag indicates this visual pid is a text subtitle*/
+	GF_ODM_IS_SPARSE = (1<<18),
 };
 
 enum
@@ -2117,8 +2152,9 @@
 	/*number of channels with connection not yet acknowledge*/
 	u32 pending_channels;
 	u32 state;
-	/* during playback: timing as evaluated by the composition memory or the scene codec - this is the timestamp + media time at clock init*/
-	u32 media_current_time;
+	/* during playback: timing as evaluated by the composition memory or the scene codec, in absolute media time
+	or in absolute clock time if no media time mapping*/
+	u64 media_current_time;
 	/*full object duration 0 if unknown*/
 	u64 duration;
 	/*
@@ -2170,6 +2206,7 @@
 
 	Bool ignore_sys;
 	u64 last_filesize_signaled;
+	Bool too_slow;
 };
 
 GF_ObjectManager *gf_odm_new();
@@ -2180,7 +2217,7 @@
 
 void gf_odm_setup_remote_object(GF_ObjectManager *odm, GF_SceneNamespace *parent_ns, char *remote_url, Bool for_addon);
 
-/*disctonnect OD and removes it if desired (otherwise only STOP is propagated)*/
+/*disconnect OD and removes it if desired (otherwise only STOP is propagated)*/
 void gf_odm_disconnect(GF_ObjectManager *odman, u32 do_remove);
 /*setup PID attached to this object*/
 GF_Err gf_odm_setup_pid(GF_ObjectManager *odm, GF_FilterPid *pid);
@@ -2439,26 +2476,23 @@
 void gf_scene_set_service_id(GF_Scene *scene, u32 service_id);
 
 
-/*post extended user mouse interaction to terminal
+/*post extended user mouse interaction to compositor
 	X and Y are point coordinates in the display expressed in 2D coord system top-left (0,0), Y increasing towards bottom
 	@xxx_but_down: specify whether the mouse button is down(2) or up (1), 0 if unchanged
 	@wheel: specify current wheel inc (0: unchanged , +1 for one wheel delta forward, -1 for one wheel delta backward)
 */
-/*NOT NEEDED WHEN THE TERMINAL IS HANDLING THE DISPLAY WINDOW (cf user.h)*/
 void gf_sc_input_sensor_mouse_input(GF_Compositor *compositor, GF_EventMouse *event);
 
-/*post extended user key interaction to terminal
+/*post extended user key interaction to compositor
 	@key_code: GPAC DOM code of input key
 	@hw_code: hardware code of input key
 	@isKeyUp: set if key is released
 */
-/*NOT NEEDED WHEN THE TERMINAL IS HANDLING THE DISPLAY WINDOW (cf user.h)*/
 Bool gf_sc_input_sensor_keyboard_input(GF_Compositor *compositor, u32 key_code, u32 hw_code, Bool isKeyUp);
 
-/*post extended user character interaction to terminal
+/*post extended user character interaction to compositor
 	@character: unicode character input
 */
-/*NOT NEEDED WHEN THE TERMINAL IS HANDLING THE DISPLAY WINDOW (cf user.h)*/
 void gf_sc_input_sensor_string_input(GF_Compositor *compositor, u32 character);
 
 GF_Err gf_input_sensor_setup_object(GF_ObjectManager *odm, GF_ESD *esd);
@@ -2470,13 +2504,79 @@
 void InitStringSensor(GF_Scene *scene, GF_Node *node);
 
 
-GF_Err gf_odm_get_object_info(GF_ObjectManager *odm, GF_MediaInfo *info);
-
+/*! Media Object information*/
+typedef struct
+{
+	u32 ODID;
+	u32 ServiceID;
+	u32 pid_id, ocr_id;
+	Double duration;
+	Double current_time;
+	/*0: stopped, 1: playing, 2: paused, 3: not setup, 4; setup failed.*/
+	u32 status;
+
+	Bool raw_media;
+	Bool generated_scene;
+
+	/*name of module handling the service service */
+	const char *service_handler;
+	/*name of service*/
+	const char *service_url;
+	/*service redirect object*/
+	const char *remote_url;
+	/*set if the service is owned by this object*/
+	Bool owns_service;
+
+	/*stream buffer:
+		-2: stream is not playing
+		-1: stream has no buffering
+		>=0: amount of media data present in buffer, in ms
+	*/
+	s32 buffer;
+	u32 min_buffer, max_buffer;
+	/*number of AUs in DB (cumulated on all input channels)*/
+	u32 db_unit_count;
+	/*number of CUs in composition memory (if any) and CM capacity*/
+	u32 cb_unit_count, cb_max_count;
+	/*inidciate that thye composition memory is bypassed for this decoder (video only) */
+	Bool direct_video_memory;
+	/*clock delay in ms of object clock: this is the delay set by the audio renderer to keep AV in sync
+	and corresponds to the amount of ms to delay non-audio streams to keep sync*/
+	s32 clock_drift;
+	/*codec name*/
+	const char *codec_name;
+	/*object type - match streamType (cf constants.h)*/
+	u32 od_type;
+	/*audio properties*/
+	u32 sample_rate, afmt, num_channels;
+	/*video properties (w & h also used for scene codecs)*/
+	u32 width, height, pixelFormat, par;
+
+	/*average birate over last second and max bitrate over one second at decoder input according to media timeline - expressed in bits per sec*/
+	u32 avg_bitrate, max_bitrate;
+	/*average birate over last second and max bitrate over one second at decoder input according to processing time - expressed in bits per sec*/
+	u32 avg_process_bitrate, max_process_bitrate;
+	u32 nb_dec_frames, nb_dropped;
+	u32 first_frame_time, last_frame_time;
+	u64 total_dec_time, irap_total_dec_time;
+	u32 max_dec_time, irap_max_dec_time;
+	u32 au_duration;
+	u32 nb_iraps;
+	s32 ntp_diff;
+	//0 if mono, 2 or more otherwise
+	u32 nb_views;
 
+	/*4CC of original protection scheme used*/
+	u32 protection;
 
-void gf_sc_connect_from_time_ex(GF_Compositor *compositor, const char *URL, u64 startTime, u32 pause_at_first_frame, Bool secondary_scene, const char *parent_path);
+	u32 lang;
+	const char *lang_code;
 
-void gf_sc_disconnect(GF_Compositor *compositor);
+	/*name of media if not defined in OD framework*/
+	const char *media_url;
+} GF_MediaInfo;
+//todo deprecate ?
+GF_Err gf_odm_get_object_info(GF_ObjectManager *odm, GF_MediaInfo *info);
 
 
 /*restart object and takes care of media control/clock dependencies*/

gpac-2.0.0.tar.gz/include/gpac/internal/ietf_dev.h -> gpac-2.2.0.tar.gz/include/gpac/internal/ietf_dev.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / IETF RTP/RTSP/SDP sub-project
@@ -83,6 +83,17 @@
 /*gets the output of the queue. Packet Data IS YOURS to delete*/
 void *gf_rtp_reorderer_get(GF_RTPReorder *po, u32 *pck_size, Bool force_flush);
 
+#define MAX_RTCP_RR	4
+
+typedef struct
+{
+	u32 ssrc;
+	u32 frac_lost;
+	u32 total_loss;
+	u32 last_rtp_sn;
+	u64 jitter;
+	u32 last_sr, delay_last_sr;
+} GF_RTCP_Report;
 
 /*the RTP channel with both RTP and RTCP sockets and buffers
 each channel is identified by a control string given in RTSP Describe
@@ -133,6 +144,7 @@
 	u32 num_pck_sent, num_payload_bytes;
 	u32 forced_ntp_sec, forced_ntp_frac;
 
+	u32 force_loss_rate;
 	Bool no_auto_rtcp;
 	/*RTCP info*/
 	char *s_name, *s_email, *s_location, *s_phone, *s_tool, *s_note, *s_priv;
@@ -167,6 +179,13 @@
 
 	gf_rtp_tcp_callback send_interleave;
 	void *interleave_cbk1, *interleave_cbk2;
+
+	GF_RTCP_Report rtcp_rrMAX_RTCP_RR;
+	u32 nb_rctp_rr;
+
+
+	const char **ssm, **ssmx;
+	u32 nb_ssm, nb_ssmx;
 };
 
 /*gets UTC in the channel RTP timescale*/
@@ -213,7 +232,7 @@
 	if (sig < 0) { \
 		sprintf(temp, "%d", d);		\
 	} else { \
-		sprintf(temp, "%d", d);		\
+		sprintf(temp, "%u", d);		\
 	}	\
 	RTSP_WRITE_ALLOC_STR_WITHOUT_CHECK(buf, buf_size, pos, temp); \
 	}
@@ -244,6 +263,18 @@
 	void *ch_ptr;
 } GF_TCPChan;
 
+typedef enum
+{
+	RTSP_HTTP_NONE = 0,
+	RTSP_HTTP_CLIENT,
+	RTSP_HTTP_SERVER,
+	RTSP_HTTP_DISABLE
+} RTSP_HTTP_Tunnel;
+
+#ifdef GPAC_HAS_SSL
+#include <openssl/ssl.h>
+#endif
+
 /**************************************
 		RTSP Session
 ***************************************/
@@ -256,27 +287,29 @@
 	/*server port (extracted from URL)*/
 	u16 Port;
 
+	char *User, *Pass;
+
 	/*if RTSP is on UDP*/
 	u8 ConnectionType;
 	/*TCP interleaving ID*/
 	u8 InterID;
 	/*http tunnel*/
-	Bool HasTunnel;
+	RTSP_HTTP_Tunnel tunnel_mode;
 	GF_Socket *http;
-	char HTTP_Cookie30;
-	u32 CookieRadLen;
+	char *HTTP_Cookie;
+	u32 tunnel_state;
 
 	/*RTSP CHANNEL*/
 	GF_Socket *connection;
 	u32 SockBufferSize;
 	/*needs connection*/
 	u32 NeedConnection;
-
+	u32 timeout_in;
 	/*the RTSP sequence number*/
 	u32 CSeq;
 	/*this is for aggregated request in order to check SeqNum*/
 	u32 NbPending;
-
+	u32 nb_retry;
 	/*RTSP sessionID, arbitrary length, alpha-numeric*/
 	const char *last_session_id;
 
@@ -299,21 +332,31 @@
 	/*all RTP channels in an interleaved RTP on RTSP session*/
 	GF_List *TCPChannels;
 	Bool interleaved;
+
+	u8 *async_buf;
+	u32 async_buf_size, async_buf_alloc;
+
+#ifdef GPAC_HAS_SSL
+	Bool use_ssl, ssl_connect_pending;
+	SSL_CTX *ssl_ctx;
+	SSL *ssl, *ssl_http;
+#endif
+
 };
 
 GF_RTSPSession *gf_rtsp_session_new(char *sURL, u16 DefaultPort);
 
-/*check connection status*/
-GF_Err gf_rtsp_check_connection(GF_RTSPSession *sess);
 /*send data on RTSP*/
 GF_Err gf_rtsp_send_data(GF_RTSPSession *sess, u8 *buffer, u32 Size);
 
+GF_Err gf_rstp_do_read_sock(GF_RTSPSession *sess, GF_Socket *sock, u8 *data, u32 data_size, u32 *out_read);
+
 /*
 			Common RTSP tools
 */
 
 /*locate body-start and body size in response/commands*/
-void gf_rtsp_get_body_info(GF_RTSPSession *sess, u32 *body_start, u32 *body_size);
+void gf_rtsp_get_body_info(GF_RTSPSession *sess, u32 *body_start, u32 *body_size, Bool skip_tunnel);
 /*read TCP until a full command/response is received*/
 GF_Err gf_rtsp_read_reply(GF_RTSPSession *sess);
 /*fill the TCP buffer*/
@@ -326,10 +369,6 @@
 GF_Err gf_rtsp_parse_header(u8 *buffer, u32 BufferSize, u32 BodyStart, GF_RTSPCommand *com, GF_RTSPResponse *rsp);
 void gf_rtsp_set_command_value(GF_RTSPCommand *com, char *Header, char *Value);
 void gf_rtsp_set_response_value(GF_RTSPResponse *rsp, char *Header, char *Value);
-/*deinterleave a data packet*/
-GF_Err gf_rtsp_set_deinterleave(GF_RTSPSession *sess);
-/*start session through HTTP tunnel (QTSS)*/
-GF_Err gf_rtsp_http_tunnel_start(GF_RTSPSession *sess, char *UserAgent);
 
 
 
@@ -447,6 +486,7 @@
 GF_Err gp_rtp_builder_do_hevc(GP_RTPPacketizer *builder, u8 *data, u32 data_size, u8 IsAUEnd, u32 FullAUSize);
 GF_Err gp_rtp_builder_do_mp2t(GP_RTPPacketizer *builder, u8 *data, u32 data_size, u8 IsAUEnd, u32 FullAUSize);
 GF_Err gp_rtp_builder_do_vvc(GP_RTPPacketizer *builder, u8 *data, u32 data_size, u8 IsAUEnd, u32 FullAUSize);
+GF_Err gp_rtp_builder_do_opus(GP_RTPPacketizer *builder, u8 *data, u32 data_size, u8 IsAUEnd, u32 FullAUSize);
 
 #define RTP_VVC_AGG_NAL		0x1C //28
 #define RTP_VVC_FRAG_NAL	0x1D //29
@@ -477,6 +517,8 @@
 	GP_RTPSLMap sl_map;
 	/*! RTP clock rate*/
 	u32 clock_rate;
+	/*! audio channels from RTP map*/
+	u32 audio_channels;
 
 	//! clip rect X
 	u32 x;

gpac-2.0.0.tar.gz/include/gpac/internal/isomedia_dev.h -> gpac-2.2.0.tar.gz/include/gpac/internal/isomedia_dev.h Changed

@@ -61,6 +61,7 @@
 	GF_ISOM_BOX_TYPE_ELNG	= GF_4CC( 'e', 'l', 'n', 'g' ),
 	GF_ISOM_BOX_TYPE_MDAT	= GF_4CC( 'm', 'd', 'a', 't' ),
 	GF_ISOM_BOX_TYPE_IDAT	= GF_4CC( 'i', 'd', 'a', 't' ),
+	GF_ISOM_BOX_TYPE_IMDA	= GF_4CC( 'i', 'm', 'd', 'a' ),
 	GF_ISOM_BOX_TYPE_MDHD	= GF_4CC( 'm', 'd', 'h', 'd' ),
 	GF_ISOM_BOX_TYPE_MINF	= GF_4CC( 'm', 'i', 'n', 'f' ),
 	GF_ISOM_BOX_TYPE_MOOV	= GF_4CC( 'm', 'o', 'o', 'v' ),
@@ -350,6 +351,7 @@
 	GF_ISOM_HANDLER_TYPE_MDIR	= GF_4CC( 'm', 'd', 'i', 'r' ),
 	GF_ISOM_BOX_TYPE_CHAP	= GF_4CC( 'c', 'h', 'a', 'p' ),
 	GF_ISOM_BOX_TYPE_TEXT	= GF_4CC( 't', 'e', 'x', 't' ),
+	GF_ISOM_HANDLER_TYPE_MDTA	= GF_4CC( 'm', 'd', 't', 'a' ),
 
 	/*OMA (P)DCF boxes*/
 	GF_ISOM_BOX_TYPE_OHDR	= GF_4CC( 'o', 'h', 'd', 'r' ),
@@ -486,6 +488,8 @@
 	GF_QT_BOX_TYPE_FIEL = GF_4CC('f','i','e','l'),
 	GF_QT_BOX_TYPE_GAMA = GF_4CC('g','a','m','a'),
 	GF_QT_BOX_TYPE_CHRM = GF_4CC('c','h','r','m'),
+	GF_QT_BOX_TYPE_STPS = GF_4CC('s','t','p','s'),
+	GF_QT_BOX_TYPE_CIOS = GF_4CC('c','i','o','s'),
 
 	/* from drm_sample.c */
 	GF_ISOM_BOX_TYPE_264B 	= GF_4CC('2','6','4','b'),
@@ -532,6 +536,8 @@
 
 	//opaque data container
 	GF_ISOM_BOX_TYPE_GDAT	= GF_4CC( 'g', 'd', 'a', 't' ),
+
+	GF_ISOM_BOX_TYPE_KEYS = GF_4CC( 'k', 'e', 'y', 's' ),
 };
 
 enum
@@ -649,9 +655,8 @@
 
 GF_Err gf_isom_box_parse(GF_Box **outBox, GF_BitStream *bs);
 GF_Err gf_isom_box_array_read(GF_Box *s, GF_BitStream *bs);
-GF_Err gf_isom_box_array_read_ex(GF_Box *parent, GF_BitStream *bs, u32 parent_type);
 
-GF_Err gf_isom_box_parse_ex(GF_Box **outBox, GF_BitStream *bs, u32 parent_type, Bool is_root_box);
+GF_Err gf_isom_box_parse_ex(GF_Box **outBox, GF_BitStream *bs, u32 parent_type, Bool is_root_box, u64 parent_size);
 
 //writes box header - shall be called at the beginning of each xxxx_Write function
 //this function is not factorized in order to let box serializer modify box type before writing
@@ -704,6 +709,9 @@
 	/* store the file offset when parsing to access the raw data */
 	u64 bsOffset;
 	u8 *data;
+
+	u32 imda_id;
+	u8 is_imda;
 } GF_MediaDataBox;
 
 typedef struct
@@ -991,7 +999,7 @@
 
 	GF_ISOSample *extracted_samp;
 	GF_BitStream *extracted_bs;
-
+	Bool in_nalu_rewrite;
 } GF_MediaBox;
 
 typedef struct
@@ -1160,7 +1168,7 @@
 	u32 r_FirstSampleInEntry;
 
 	s32 max_cts_delta;
-	u32 sample_num_max_cts_delta;
+	//u32 sample_num_max_cts_delta;
 } GF_CompositionOffsetBox;
 
 
@@ -1521,7 +1529,7 @@
 	GF_ColourInformationBox *colr;
 } GF_J2KHeaderBox;
 
-typedef struct
+typedef struct __full_video_sample_entry
 {
 	GF_ISOM_VISUAL_SAMPLE_ENTRY
 	GF_ESDBox *esd;
@@ -1555,6 +1563,14 @@
 	/*iPod's hack*/
 	GF_UnknownUUIDBox *ipod_ext;
 
+	//for generic video sample entry
+
+	//box type as specified in the file (not this box's type!!)
+	u32 EntryType;
+	//opaque description data (ESDS in MP4, SMI in SVQ3, ...)
+	u8 *data;
+	u32 data_size;
+
 } GF_MPEGVisualSampleEntryBox;
 
 static const u8 GF_ISOM_IPOD_EXT16 = { { 0x6B, 0x68, 0x40, 0xF2, 0x5F, 0x24, 0x4F, 0xC5, 0xBA, 0x39, 0xA5, 0x1B, 0xCF, 0x03, 0x23, 0xF3} };
@@ -1562,16 +1578,7 @@
 Bool gf_isom_is_nalu_based_entry(GF_MediaBox *mdia, GF_SampleEntryBox *_entry);
 GF_Err gf_isom_nalu_sample_rewrite(GF_MediaBox *mdia, GF_ISOSample *sample, u32 sampleNumber, GF_MPEGVisualSampleEntryBox *entry);
 
-/*this is the default visual sdst (to handle unknown media)*/
-typedef struct
-{
-	GF_ISOM_VISUAL_SAMPLE_ENTRY
-	/*box type as specified in the file (not this box's type!!)*/
-	u32 EntryType;
-	/*opaque description data (ESDS in MP4, SMI in SVQ3, ...)*/
-	u8 *data;
-	u32 data_size;
-} GF_GenericVisualSampleEntryBox;
+typedef struct __full_video_sample_entry GF_GenericVisualSampleEntryBox;
 
 enum
 {
@@ -1671,25 +1678,9 @@
 typedef struct
 {
 	GF_ISOM_BOX
-
-	/*OpusSpecificBox*/
-	/*u8 version; //1, field included in base box structure */
-	u8 OutputChannelCount; //same value as the *Output Channel Count* field in the identification header defined in Ogg Opus 3
-	u16 PreSkip; //The value of the PreSkip field shall be at least 80 milliseconds' worth of PCM samples even when removing any number of Opus samples which may or may not contain the priming samples. The PreSkip field is not used for discarding the priming samples at the whole playback at all since it is informative only, and that task falls on the Edit List Box.
-	u32 InputSampleRate; //The InputSampleRate field shall be set to the same value as the *Input Sample Rate* field in the identification header defined in Ogg Opus
-	s16 OutputGain; //The OutputGain field shall be set to the same value as the *Output Gain* field in the identification header define in Ogg Opus 3. Note that the value is stored as 8.8 fixed-point.
-	u8 ChannelMappingFamily; //The ChannelMappingFamily field shall be set to the same value as the *Channel Mapping Family* field in the identification header defined in Ogg Opus 3. Note that the value 255 may be used for an alternative to map channels by ISO Base Media native mapping. The details are described in 4.5.1.
-
-	u8 StreamCount; // The StreamCount field shall be set to the same value as the *Stream Count* field in the identification header defined in Ogg Opus 3.
-	u8 CoupledCount; // The CoupledCount field shall be set to the same value as the *Coupled Count* field in the identification header defined in Ogg Opus 3.
-	u8 ChannelMapping255; // The ChannelMapping field shall be set to the same octet string as *Channel Mapping* field in the identi- fication header defined in Ogg Opus 3.
-
-	/*for internal box use only*/
-//	int channels;
+	GF_OpusConfig opcfg;
 } GF_OpusSpecificBox;
 
-GF_Err gf_isom_opus_config_new(GF_ISOFile *the_file, u32 trackNumber, GF_OpusSpecificBox *cfg, char *URLname, char *URNname, u32 *outDescriptionIndex);
-
 typedef struct
 {
 	GF_ISOM_BOX
@@ -1717,7 +1708,7 @@
 } GF_PCMConfigBox;
 
 
-typedef struct
+typedef struct __full_audio_sample_entry
 {
 	GF_ISOM_AUDIO_SAMPLE_ENTRY
 	//for MPEG4 audio
@@ -1741,18 +1732,16 @@
 	//for FLAC
 	GF_FLACConfigBox *cfg_flac;
 
-} GF_MPEGAudioSampleEntryBox;
-
-/*this is the default visual sdst (to handle unknown media)*/
-typedef struct
-{
-	GF_ISOM_AUDIO_SAMPLE_ENTRY
-	/*box type as specified in the file (not this box's type!!)*/
+	//for generic audio sample entry
+	//box type as specified in the file (not this box's type!!)
 	u32 EntryType;
-	/*opaque description data (ESDS in MP4, ...)*/
+	//opaque description data (ESDS in MP4, ...)
 	u8 *data;
 	u32 data_size;
-} GF_GenericAudioSampleEntryBox;
+
+} GF_MPEGAudioSampleEntryBox;
+
+typedef struct __full_audio_sample_entry GF_GenericAudioSampleEntryBox;
 
 
 typedef struct
@@ -2094,7 +2083,7 @@
 	u8 patch_piff_psec;
 } GF_SampleTableBox;
 
-GF_Err stbl_AppendTrafMap(GF_SampleTableBox *stbl, Bool is_seg_start, u64 seg_start_offset, u64 frag_start_offset, u8 *moof_template, u32 moof_template_size, u64 sidx_start, u64 sidx_end, u32 nb_pack_samples);
+GF_Err stbl_AppendTrafMap(GF_ISOFile *mov, GF_SampleTableBox *stbl, Bool is_seg_start, u64 seg_start_offset, u64 frag_start_offset, u8 *moof_template, u32 moof_template_size, u64 sidx_start, u64 sidx_end, u32 nb_pack_samples);
 
 typedef struct __tag_media_info_box
 {
@@ -2509,6 +2498,20 @@
 	GF_ISOM_BOX
 } GF_GroupListBox;
 
+typedef struct
+{
+	u32 ns;
+	u32 size;
+	u8 *data;
+} GF_MetaKey;
+
+typedef struct {
+	GF_ISOM_FULL_BOX
+
+	GF_List *keys;
+	struct __tag_meta_box *meta;
+} GF_MetaKeysBox;
+
 typedef struct __tag_meta_box
 {
 	GF_ISOM_FULL_BOX
@@ -2522,8 +2525,9 @@
 	GF_ItemPropertiesBox *item_props;
 	GF_ItemReferenceBox *item_refs;
 	GF_GroupListBox *groups_list;
+	GF_MetaKeysBox *keys;
 
-	u8 use_item_sample_sharing, use_item_item_sharing;
+	u8 use_item_sample_sharing, use_item_item_sharing, is_qt, write_qt;
 } GF_MetaBox;
 
 typedef struct
@@ -2687,6 +2691,7 @@
 	u8 truns_first;
 	u8 truns_v1;
 	u8 large_tfdt;
+	u8 no_sdtp_first_flags;
 } GF_TrackFragmentBox;
 
 GF_TrackFragmentBox *gf_isom_get_traf(GF_ISOFile *mov, GF_ISOTrackID TrackID);
@@ -3969,10 +3974,6 @@
 		Movie stuff
 */
 
-
-/*time def for MP4/QT/MJ2K files*/
-#define GF_ISOM_MAC_TIME_OFFSET 2082844800
-
 #ifndef	GPAC_DISABLE_ISOM_FRAGMENTS
 #define GF_ISOM_FORMAT_FRAG_FLAGS(pad, sync, deg) ( ( (pad) << 17) | ( ( !(sync) ) << 16) | (deg) );
 #define GF_ISOM_GET_FRAG_PAD(flag) ( (flag) >> 17) & 0x7
@@ -4091,6 +4092,7 @@
 
 	Bool store_traf_map;
 	Bool signal_frag_bounds;
+	u64 root_sidx_start_offset, root_sidx_end_offset;
 	u64 sidx_start_offset, sidx_end_offset;
 	u64 styp_start_offset;
 	u64 mdat_end_offset;
@@ -4116,10 +4118,11 @@
 
 	GF_Err (*on_block_out)(void *usr_data, u8 *block, u32 block_size);
 	GF_Err (*on_block_patch)(void *usr_data, u8 *block, u32 block_size, u64 block_offset, Bool is_insert);
+	void (*on_last_block_start)(void *usr_data);
 	void *on_block_out_usr_data;
 	u32 on_block_out_block_size;
 
-	//in block disptach mode we don't have the full file, keep the position
+	//in block dispatch mode we don't have the full file, keep the position
 	u64 fragmented_file_pos;
 	u8 *block_buffer;
 	u32 block_buffer_size;
@@ -4282,6 +4285,7 @@
 GF_Err stbl_RemoveRedundant(GF_SampleTableBox *stbl, u32 SampleNumber, u32 nb_samples);
 GF_Err stbl_RemoveSubSample(GF_SampleTableBox *stbl, u32 SampleNumber);
 GF_Err stbl_RemoveSampleGroup(GF_SampleTableBox *stbl, u32 SampleNumber);
+GF_Err stbl_RemoveRAPs(GF_SampleTableBox *stbl, u32 nb_samples);
 
 #ifndef	GPAC_DISABLE_ISOM_FRAGMENTS
 GF_Err gf_isom_close_fragments(GF_ISOFile *movie);
@@ -4636,6 +4640,7 @@
 #ifndef GPAC_DISABLE_VTT
 
 GF_ISOSample *gf_isom_webvtt_to_sample(void *samp);
+u32 gf_isom_webvtt_cues_count(void *s);
 
 typedef struct
 {
@@ -4663,17 +4668,22 @@
 
 void gf_isom_registry_disable(u32 boxCode, Bool disable);
 
-/*Apple extensions*/
-GF_Box *gf_isom_get_meta_extensions(GF_ISOFile *mov, Bool for_xtra);
+/*Apple extensions
+type 0: itunes
+type 1: XTRA (wma)
+type 2: QT mdta
+*/
+GF_Box *gf_isom_get_meta_extensions(GF_ISOFile *mov, u32 type);
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
-GF_Box *gf_isom_create_meta_extensions(GF_ISOFile *mov, Bool for_xtra);
+GF_Box *gf_isom_create_meta_extensions(GF_ISOFile *mov, u32 meta_type);
 #endif /*GPAC_DISABLE_ISOM_WRITE*/
 
 
 #ifndef GPAC_DISABLE_ISOM_DUMP
 GF_Err gf_isom_box_dump_ex(void *ptr, FILE * trace, u32 box_4cc);
 GF_Err gf_isom_box_dump_start(GF_Box *a, const char *name, FILE * trace);
+GF_Err gf_isom_box_dump_start_ex(GF_Box *a, const char *name, FILE * trace, Bool force_version);
 void gf_isom_box_dump_done(const char *name, GF_Box *ptr, FILE *trace);
 Bool gf_isom_box_is_file_level(GF_Box *s);
 #endif
@@ -4682,7 +4692,7 @@
 
 GF_Err gf_isom_read_null_terminated_string(GF_Box *s, GF_BitStream *bs, u64 size, char **out_str);
 
-GF_Err MergeTrack(GF_TrackBox *trak, GF_TrackFragmentBox *traf, GF_MovieFragmentBox *moof, u64 moof_offset, s32 compresed_diff, u64 *cumulated_offset);
+GF_Err MergeTrack(GF_TrackBox *trak, GF_TrackFragmentBox *traf, GF_MovieFragmentBox *moof, u64 moof_offset, s32 compressed_diff, u64 *cumulated_offset);
 
 
 #endif //GPAC_DISABLE_ISOM

gpac-2.0.0.tar.gz/include/gpac/internal/m3u8.h -> gpac-2.2.0.tar.gz/include/gpac/internal/m3u8.h Changed

gpac-2.0.0.tar.gz/include/gpac/internal/media_dev.h -> gpac-2.2.0.tar.gz/include/gpac/internal/media_dev.h Changed

@@ -58,13 +58,6 @@
 
 #define GF_SVC_SSPS_ID_SHIFT	16
 
-/*returns 0 if not a start code, or size of start code (3 or 4 bytes). If start code, bitstream
-is positionned AFTER start code*/
-u32 gf_media_nalu_is_start_code(GF_BitStream *bs);
-
-/*returns size of chunk between current and next startcode (excluding startcode sizes), 0 if no more startcodes (eos)*/
-u32 gf_media_nalu_next_start_code_bs(GF_BitStream *bs);
-
 /*return nb bytes from current data until the next start code and set the size of the next start code (3 or 4 bytes)
 returns data_len if no startcode found and sets sc_size to 0 (last nal in payload)*/
 u32 gf_media_nalu_next_start_code(const u8 *data, u32 data_len, u32 *sc_size);
@@ -115,6 +108,9 @@
 	u8 video_format;
 	Bool video_full_range_flag;
 
+	Bool chroma_location_info_present_flag;
+	u8 chroma_sample_loc_type_top_field, chroma_sample_loc_type_bottom_field;
+
 	Bool colour_description_present_flag;
 	u8 colour_primaries;
 	u8 transfer_characteristics;
@@ -259,7 +255,7 @@
 
 	Bool is_svc;
 	u8 last_nal_type_parsed;
-	s8 last_ps_idx;
+	s8 last_ps_idx, last_sps_idx;
 } AVCState;
 
 typedef struct
@@ -311,6 +307,8 @@
 
 	//if set all video info is removed
 	Bool remove_video_info;
+	//if set timing info is removed
+	Bool remove_vui_timing_info;
 	//new fullrange, -1 to use info from bitstream
 	s32 fullrange;
 	//new vidformat flag, -1 to use info from bitstream
@@ -420,7 +418,7 @@
 	u8 chroma_loc_info_present_flag;
 	u32 chroma_sample_loc_type_top_field, chroma_sample_loc_type_bottom_field;
 
-	u8 neutra_chroma_indication_flag, field_seq_flag, frame_field_info_present_flag;
+	u8 neutral_chroma_indication_flag, field_seq_flag, frame_field_info_present_flag;
 	u8 default_display_window_flag;
 	u32 left_offset, right_offset, top_offset, bottom_offset;
 	u8 hrd_parameters_present_flag;
@@ -637,8 +635,8 @@
 //	u32 inter_layer_ref_pic_idVVC_MAX_REF_PICS;
 } VVC_RefPicList;
 
-#define MAX_TILE_COLS 30
-#define MAX_TILE_ROWS 33
+#define VVC_MAX_TILE_COLS 30
+#define VVC_MAX_TILE_ROWS 33
 
 typedef struct
 {
@@ -719,8 +717,8 @@
 	u32 cw_left, cw_right, cw_top, cw_bottom;
 
 	//tile info
-	u32 tile_rows_height_ctbMAX_TILE_ROWS;
-	u32 tile_cols_width_ctbMAX_TILE_COLS;
+	u32 tile_rows_height_ctbVVC_MAX_TILE_ROWS;
+	u32 tile_cols_width_ctbVVC_MAX_TILE_COLS;
 	u32 pic_width_in_ctbsY, pic_height_in_ctbsY;
 } VVC_PPS;
 
@@ -1015,6 +1013,33 @@
 u64 gf_av1_leb128_write(GF_BitStream *bs, u64 value);
 GF_Err gf_av1_parse_obu_header(GF_BitStream *bs, ObuType *obu_type, Bool *obu_extension_flag, Bool *obu_has_size_field, u8 *temporal_id, u8 *spatial_id);
 
+/*! OPUS packet header*/
+typedef struct
+{
+ Bool self_delimited;
+
+ // parsed header size
+ u8 size;
+
+ u16 self_delimited_length;
+ u8 TOC_config;
+ u8 TOC_stereo;
+ u8 TOC_code;
+ u16 code2_frame_length;
+ u8 code3_vbr;
+ u8 code3_padding;
+ u16 code3_padding_length;
+
+ u8 nb_frames;
+ // either explicitly coded (e.g. self_delimited) or computer (e.g. cbr)
+ u16 frame_lengths255;
+
+ // computed packet size
+ u32 packet_size;
+} GF_OpusPacketHeader;
+
+u8 gf_opus_parse_packet_header(u8 *data, u32 data_length, Bool self_delimited, GF_OpusPacketHeader *header);
+
 typedef struct
 {
 	u32 picture_size;
@@ -1096,6 +1121,8 @@
 void gf_webvtt_parser_del(GF_WebVTTParser *parser);
 void gf_webvtt_parser_suspend(GF_WebVTTParser *vttparser);
 void gf_webvtt_parser_restart(GF_WebVTTParser *parser);
+GF_Err gf_webvtt_parser_parse_payload(GF_WebVTTParser *parser, u64 start, u64 end, const char *vtt_pre, const char *vtt_cueid, const char *vtt_settings);
+GF_Err gf_webvtt_parser_flush(GF_WebVTTParser *parser);
 
 #include <gpac/webvtt.h>
 void gf_webvtt_parser_cue_callback(GF_WebVTTParser *parser, void (*on_cue_read)(void *, GF_WebVTTCue *), void *udta);
@@ -1131,5 +1158,8 @@
 #define M2V_GOP_START_CODE					0xB8
 
 
+/*build isobmf dec info from sequence header+ephdr (only seq hdr is parsed, only advanced profile is supprted) */
+GF_Err gf_media_vc1_seq_header_to_dsi(const u8 *seq_hdr, u32 seq_hdr_len, u8 **dsi, u32 *dsi_size);
+
 #endif		/*_GF_MEDIA_DEV_H_*/

gpac-2.0.0.tar.gz/include/gpac/internal/scenegraph_dev.h -> gpac-2.2.0.tar.gz/include/gpac/internal/scenegraph_dev.h Changed

gpac-2.0.0.tar.gz/include/gpac/isomedia.h -> gpac-2.2.0.tar.gz/include/gpac/isomedia.h Changed

@@ -287,6 +287,7 @@
 	GF_ISOM_SUBTYPE_METX		= GF_4CC( 'm', 'e', 't', 'x' ),
 	GF_ISOM_SUBTYPE_TX3G		= GF_4CC( 't', 'x', '3', 'g' ),
 	GF_ISOM_SUBTYPE_TEXT		= GF_4CC( 't', 'e', 'x', 't' ),
+	GF_ISOM_SUBTYPE_SUBTITLE	= GF_4CC( 's', 'b', 't', 'l' ),
 
 
 	GF_ISOM_SUBTYPE_RTP			= GF_4CC( 'r', 't', 'p', ' ' ),
@@ -360,13 +361,25 @@
 	GF_QT_SUBTYPE_YVYU = GF_4CC('Y','V','Y','U'),
 	GF_QT_SUBTYPE_RGBA = GF_4CC('R','G','B','A'),
 	GF_QT_SUBTYPE_ABGR = GF_4CC('A','B','G','R'),
-
+	GF_QT_SUBTYPE_ALAC = GF_4CC('a','l','a','c'),
 	GF_ISOM_SUBTYPE_FFV1		= GF_4CC( 'F', 'F', 'V', '1' ),
 
 	GF_ISOM_ITEM_TYPE_AUXI 	= GF_4CC('a', 'u', 'x', 'i'),
 
 	GF_QT_SUBTYPE_TMCD = GF_4CC( 't', 'm', 'c', 'd' ),
 
+	GF_ISOM_SUBTYPE_VC1 = GF_4CC( 'v', 'c', '-', '1' ),
+
+	/*GPAC extensions*/
+	GF_ISOM_SUBTYPE_DVB_SUBS	= GF_4CC( 'd', 'v', 'b', 's' ),
+	GF_ISOM_SUBTYPE_DVB_TELETEXT	= GF_4CC( 'd', 'v', 'b', 't' ),
+
+
+	GF_ISOM_SUBTYPE_DTSC = GF_4CC('d','t','s','c'),
+	GF_ISOM_SUBTYPE_DTSH = GF_4CC('d','t','s','h'),
+	GF_ISOM_SUBTYPE_DTSL = GF_4CC('d','t','s','l'),
+	GF_ISOM_SUBTYPE_DTSE = GF_4CC('d','t','s','e'),
+
 };
 
 
@@ -806,6 +819,9 @@
 \return the duration of the movie*/
 u64 gf_isom_get_original_duration(GF_ISOFile *isom_file);
 
+/*! time offset since UNIX EPOC for MP4/QT/MJ2K files*/
+#define GF_ISOM_MAC_TIME_OFFSET 2082844800
+
 /*! gets the creation info of the movie
 \param isom_file the target ISO file
 \param creationTime set to the creation time of the movie
@@ -1101,6 +1117,13 @@
 */
 u32 gf_isom_get_max_sample_delta(GF_ISOFile *isom_file, u32 trackNumber);
 
+/*! gets average sample duration in track, i.e. the sample delta occuring most often
+\param isom_file the target ISO file
+\param trackNumber the target track
+\return average sample delta in media timescale
+*/
+u32 gf_isom_get_avg_sample_delta(GF_ISOFile *isom_file, u32 trackNumber);
+
 /*! gets max sample CTS offset (CTS-DTS) in track
 \param isom_file the target ISO file
 \param trackNumber the target track
@@ -1487,6 +1510,16 @@
 GF_Err gf_isom_get_color_info(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, u32 *colour_type, u16 *colour_primaries, u16 *transfer_characteristics, u16 *matrix_coefficients, Bool *full_range_flag);
 
 
+/*! gets ICC profile
+\param isom_file the target ISO file
+\param trackNumber the target track
+\param sampleDescriptionIndex the target sample description index (1-based)
+\param icc_restricted set to GF_TRUE of restricted ICC profile, GF_FALSE otherwise
+\param icc set to profile data, NULL if none
+\param icc_size set to profile size, 0 if none
+\return error if any*/
+GF_Err gf_isom_get_icc_profile(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, Bool *icc_restricted, const u8 **icc, u32 *icc_size);
+
 /*! gets clean aperture (crop window, see ISO/IEC 14496-12) for a sample description
 \param isom_file the target ISO file
 \param trackNumber the target track number
@@ -2030,7 +2063,7 @@
 */
 GF_Err gf_isom_refresh_size_info(GF_ISOFile *isom_file, u32 trackNumber);
 
-/*! updates the duration of the movie
+/*! updates the duration of the movie.This is done automatically when storing the file or editing timesales/edit list, but it is not done when adding samples.
 \param isom_file the target ISO file
 \return error if any
 */
@@ -2228,7 +2261,7 @@
 /*! deletes copyright
 \param isom_file the target ISO file
 \param trackNumber the target track
-\param index the 1-based index of the copyright notice to remove, or 0 to remove all copyrights
+\param index the 1-based index of the copyright notice to remove, or 0 to remove all chapters
 \return error if any
 */
 GF_Err gf_isom_remove_chapter(GF_ISOFile *isom_file, u32 trackNumber, u32 index);
@@ -2668,7 +2701,9 @@
 	/*! set this flag to avoid cloning track as a QT track while cloning track*/
 	GF_ISOM_CLONE_TRACK_NO_QT = 1<<1,
 	/*! drop track ID while importing*/
-	GF_ISOM_CLONE_TRACK_DROP_ID = 1<<2
+	GF_ISOM_CLONE_TRACK_DROP_ID = 1<<2,
+	/*! reset media duration when cloning */
+	GF_ISOM_CLONE_RESET_DURATION = 1<<3
 } GF_ISOTrackCloneFlags;
 
 /*! clones a track. This clones everything except media data and sample info (DTS, CTS, RAPs, etc...), and also clones sample descriptions
@@ -2746,6 +2781,7 @@
 \param isom_file the target ISO file
 \param on_block_out the block write callback function
 \param on_block_patch the block patch callback function
+\param on_last_block_start called before writing the last block of a sequence of movie fragments
 \param usr_data opaque user data passed to callback functions
 \param block_size desired block size in bytes
 \return error if any
@@ -2753,6 +2789,7 @@
 GF_Err gf_isom_set_write_callback(GF_ISOFile *isom_file,
 			GF_Err (*on_block_out)(void *cbk, u8 *data, u32 block_size),
 			GF_Err (*on_block_patch)(void *usr_data, u8 *block, u32 block_size, u64 block_offset, Bool is_insert),
+ 			void (*on_last_block_start)(void *cbk),
 			void *usr_data,
 			u32 block_size);
 
@@ -3697,7 +3734,7 @@
 GF_AC3Config *gf_isom_ac3_config_get(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex);
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
-/*! creates an AC3 sample description
+/*! creates an AC3 or EAC3 sample description
 \param isom_file the target ISO file
 \param trackNumber the target track
 \param cfg the AC3 config for this sample description
@@ -3707,6 +3744,16 @@
 \return error if any
 */
 GF_Err gf_isom_ac3_config_new(GF_ISOFile *isom_file, u32 trackNumber, GF_AC3Config *cfg, const char *URLname, const char *URNname, u32 *outDescriptionIndex);
+
+/*! updates an AC3 or EAC3 sample description
+\param isom_file the target ISO file
+\param trackNumber the target track
+\param sampleDescriptionIndex the target sample description index
+\param cfg the AC3 config for this sample description
+\return error if any
+*/
+GF_Err gf_isom_ac3_config_update(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, GF_AC3Config *cfg);
+
 #endif /*GPAC_DISABLE_ISOM_WRITE*/
 
 /*! gets TrueHD sample description info
@@ -3761,12 +3808,34 @@
 \param isom_file the target ISO file
 \param trackNumber the target track
 \param sampleDescriptionIndex the target sample description index
-\param dsi set to the OPUS decoder config - shall be freeed by caller
-\param dsi_size set to the size of the OPUS decoder config
+\param dsi set to the OPUS decoder config (without OpusHead tag), may be NULL - shall be freeed by caller
+\param dsi_size set to the size of the OPUS decoder config, may be NULL
 \return error if any
 */
 GF_Err gf_isom_opus_config_get(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, u8 **dsi, u32 *dsi_size);
 
+/*! gets a OPUS sample description
+\param isom_file the target ISO file
+\param trackNumber the target track
+\param sampleDescriptionIndex the target sample description index
+\param opcfg opus config to get
+\return error if any
+*/
+GF_Err gf_isom_opus_config_get_desc(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, GF_OpusConfig *opcfg);
+
+#ifndef GPAC_DISABLE_ISOM_WRITE
+/*! creates a new opus sample description
+\param isom_file the target ISO file
+\param trackNumber the target track
+\param cfg the opus stream configuration
+\param URLname URL value of the data reference, NULL if no data reference (media in the file)
+\param URNname URN value of the data reference, NULL if no data reference (media in the file)
+\param outDescriptionIndex set to the index of the created sample description
+\return error if any
+*/
+GF_Err gf_isom_opus_config_new(GF_ISOFile *isom_file, u32 trackNumber, GF_OpusConfig *cfg, char *URLname, char *URNname, u32 *outDescriptionIndex);
+#endif
+
 #ifndef GPAC_DISABLE_ISOM_WRITE
 
 /*! creates a motion jpeg 2000 sample description
@@ -3834,9 +3903,10 @@
 \param outDescriptionIndex set to the index of the created sample description
 \param dsi the MPEGH audio config (payload of mhaC box): byte0=1 (config version) ,byte1=ProfileLevel, byte2=channel layout, byte3,byte4: the size of what follows the rest being a mpegh3daConfig
 \param dsi_size the size of the MPEGH audio config
+\param mha_subtype mha1/mha2:/mhm1/mhm2 subtype to use
 \return error if any
 */
-GF_Err gf_isom_new_mpha_description(GF_ISOFile *isom_file, u32 trackNumber, const char *URLname, const char *URNname, u32 *outDescriptionIndex, u8 *dsi, u32 dsi_size);
+GF_Err gf_isom_new_mpha_description(GF_ISOFile *isom_file, u32 trackNumber, const char *URLname, const char *URNname, u32 *outDescriptionIndex, u8 *dsi, u32 dsi_size, u32 mha_subtype);
 #endif
 
 /*! gets compatible profile list for mpegh entry
@@ -3849,6 +3919,17 @@
 const u8 *gf_isom_get_mpegh_compatible_profiles(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, u32 *nb_compatible_profiles);
 
 
+#ifndef GPAC_DISABLE_ISOM_WRITE
+/*! sets compatible profile list for mpegh entry
+\param isom_file the target ISO file
+\param trackNumber the target track
+\param sampleDescriptionIndex the target sample description index
+\param profiles array of compatible profiles, NULL to remove compatible profiles
+\param nb_compatible_profiles number of compatible profiles in list, 0 to remove compatible profiles
+\return error if any
+*/
+GF_Err gf_isom_set_mpegh_compatible_profiles(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, const u32 *profiles, u32 nb_compatible_profiles);
+#endif
 
 /*! structure holding youtube 360 video info
 - cf https://github.com/google/spatial-media/blob/master/docs/spherical-video-v2-rfc.md#stereoscopic-3d-video-box-st3d
@@ -4064,6 +4145,13 @@
 \param isom_file the target ISO file
 */
 void gf_isom_enable_traf_map_templates(GF_ISOFile *isom_file);
+/*! get byte range of root sidx if any
+\param isom_file the target ISO file
+\param start set to start offset (0=first byte) of the root sidx
+\param end set to end offset (0 if no sidx) of the root sidx
+\return true if success
+*/
+Bool gf_isom_get_root_sidx_offsets(GF_ISOFile *isom_file, u64 *start, u64 *end);
 
 /*! Segment boundary information*/
 typedef struct
@@ -4343,6 +4431,11 @@
 @{
 */
 
+/*! flag indicating default samples are sync*/
+#define GF_ISOM_FRAG_DEF_IS_SYNC 1
+/*! flag indicating a sync sample table shall be added in the track - cf CMAF rules*/
+#define GF_ISOM_FRAG_USE_SYNC_TABLE (1<<1)
+
 /*! sets up a track for fragmentation by specifying some default values for storage efficiency
 \note If all the defaults are 0, traf flags will always be used to signal them.
 \param isom_file the target ISO file
@@ -4350,7 +4443,7 @@
 \param DefaultSampleDescriptionIndex the default description used by samples in this track
 \param DefaultSampleDuration default duration of samples in this track
 \param DefaultSampleSize default size of samples in this track (0 if unknown)
-\param DefaultSampleIsSync default key-flag (RAP) of samples in this track
+\param DefaultSampleSyncFlags combination of GF_ISOM_FRAG_* flags
 \param DefaultSamplePadding default padding bits for samples in this track
 \param DefaultDegradationPriority default degradation priority for samples in this track
 \param force_traf_flags if GF_TRUE, will ignore these default in each traf but will still write them in moov
@@ -4360,7 +4453,7 @@
 u32 DefaultSampleDescriptionIndex,
 u32 DefaultSampleDuration,
 u32 DefaultSampleSize,
- u8 DefaultSampleIsSync,
+ u8 DefaultSampleSyncFlags,
 u8 DefaultSamplePadding,
 u16 DefaultDegradationPriority,
 									Bool force_traf_flags);
@@ -5871,7 +5964,7 @@
 const char **item_name, const char **item_mime_type, const char **item_encoding,
 const char **item_url, const char **item_urn);
 
-/*! gets item flags for the givesn item
+/*! gets item flags for the given item
 
 \param isom_file the target ISO file
 \param root_meta if GF_TRUE uses meta at the file, otherwise uses meta at the movie level if track number is 0
@@ -5879,7 +5972,7 @@
 \param item_num 1-based index of item to query
 \return item flags
 */
-GF_Err gf_isom_get_meta_item_flags(GF_ISOFile *isom_file, Bool root_meta, u32 track_num, u32 item_num);
+u32 gf_isom_get_meta_item_flags(GF_ISOFile *isom_file, Bool root_meta, u32 track_num, u32 item_num);
 
 /*! gets item index from item ID
 \param isom_file the target ISO file
@@ -6075,6 +6168,11 @@
 	const char *aux_urn;
 	const u8 *aux_data;
 	u32 aux_data_len;
+
+	//serialized box array config, only used for creating item
+	u8 *config_ba;
+	u32 config_ba_size;
+
 } GF_ImageItemProperties;
 
 
@@ -6283,12 +6381,17 @@
 \param track_num if GF_TRUE and root_meta is GF_FALSE, uses meta at the track level
 \param item_id ID of the item
 \param out_image_props set to the image properties information of the item
+\param unmapped_props will contain all properties (box) not mapped to image properties. May be NULL. DO NOT DESTROY the content of the list
+
 \return error if any
 */
-GF_Err gf_isom_get_meta_image_props(GF_ISOFile *isom_file, Bool root_meta, u32 track_num, u32 item_id, GF_ImageItemProperties *out_image_props);
+GF_Err gf_isom_get_meta_image_props(GF_ISOFile *isom_file, Bool root_meta, u32 track_num, u32 item_id, GF_ImageItemProperties *out_image_props, GF_List *unmapped_props);
 
 /*! @} */
 
+
+#endif //GPAC_DISABLE_ISOM
+
 /*!
 \addtogroup isotags_grp iTunes tagging
 \ingroup iso_grp
@@ -6310,7 +6413,7 @@
 	GF_ISOM_ITUNE_GROUP 			= GF_4CC( 0xA9, 'g', 'r', 'p' ),
 	GF_ISOM_ITUNE_WRITER 			= GF_4CC( 0xA9, 'w', 'r', 't' ),
 	GF_ISOM_ITUNE_COMMENT 			= GF_4CC( 0xA9, 'c', 'm', 't' ),
-	GF_ISOM_ITUNE_GENRE_USER		= GF_4CC( 0xA9, 'g', 'n', 'r'),
+	GF_ISOM_ITUNE_GENRE_USER		= GF_4CC( 0xA9, 'g', 'e', 'n'),
 	GF_ISOM_ITUNE_GENRE 			= GF_4CC( 'g', 'n', 'r', 'e' ),
 	GF_ISOM_ITUNE_CREATED 			= GF_4CC( 0xA9, 'd', 'a', 'y' ),
 	GF_ISOM_ITUNE_TRACKNUMBER 		= GF_4CC( 't', 'r', 'k', 'n' ),
@@ -6368,6 +6471,7 @@
 	GF_ISOM_ITUNE_THANKS	 	= GF_4CC( 0xA9, 't', 'h', 'x' ),
 	GF_ISOM_ITUNE_ONLINE	 	= GF_4CC( 0xA9, 'u', 'r', 'l' ),
 	GF_ISOM_ITUNE_EXEC_PRODUCER	= GF_4CC( 0xA9, 'x', 'p', 'd' ),
+	GF_ISOM_ITUNE_LOCATION	 	= GF_4CC( 0xA9, 'x', 'y', 'z' ),
 
 
 	GF_ISOM_ITUNE_ITUNES_DATA 	= GF_4CC( '-', '-', '-', '-' ),
@@ -6385,6 +6489,8 @@
 
 } GF_ISOiTunesTag;
 
+#ifndef GPAC_DISABLE_ISOM
+
 /*! gets the given itunes tag info.
 \warning 'genre' may be coded by ID, the libisomedia doesn't translate the ID. In such a case, the result data is set to NULL and the data_len to the genre ID
 
@@ -6424,6 +6530,99 @@
 */
 GF_Err gf_isom_wma_enum_tag(GF_ISOFile *isom_file, u32 idx, char **out_tag, const u8 **data, u32 *data_len, u32 *version, u32 *data_type);
 
+/*! QT key types */
+typedef enum
+{
+	GF_QT_KEY_OPAQUE=0,
+	GF_QT_KEY_UTF8=1,
+	GF_QT_KEY_UTF16_BE=2,
+	GF_QT_KEY_JIS=3,
+	GF_QT_KEY_UTF8_SORT=4,
+	GF_QT_KEY_UTF16_SORT=5,
+	GF_QT_KEY_JPEG=13,
+	GF_QT_KEY_PNG=14,
+	GF_QT_KEY_SIGNED_VSIZE=21,
+	GF_QT_KEY_UNSIGNED_VSIZE=22,
+	GF_QT_KEY_FLOAT=23,
+	GF_QT_KEY_DOUBLE=24,
+	GF_QT_KEY_BMP=27,
+	GF_QT_KEY_METABOX=28,
+	GF_QT_KEY_SIGNED_8=65,
+	GF_QT_KEY_SIGNED_16=66,
+	GF_QT_KEY_SIGNED_32=67,
+	GF_QT_KEY_POINTF=70,
+	GF_QT_KEY_SIZEF=71,
+	GF_QT_KEY_RECTF=72,
+	GF_QT_KEY_SIGNED_64=74,
+	GF_QT_KEY_UNSIGNED_8=75,
+	GF_QT_KEY_UNSIGNED_16=76,
+	GF_QT_KEY_UNSIGNED_32=77,
+	GF_QT_KEY_UNSIGNED_64=78,
+	GF_QT_KEY_MATRIXF=79,
+
+	//used to remove a key
+	GF_QT_KEY_REMOVE=0xFFFFFFFF
+} GF_QTKeyType;
+
+
+/*! QT userdata key*/
+typedef struct
+{
+	/*! key name*/
+	const char *name;
+	/*! key namespace 4CC*/
+	u32 ns;
+
+	/*! key type*/
+	GF_QTKeyType type;
+	union {
+		/*! UTF-8 string, for GF_QT_KEY_UTF8 and GF_QT_KEY_UTF8_SORT */
+		const char *string;
+		/*! data, for unsupported types, image types, UTF16 types and metabox */
+		struct _tag_data {
+			/*! data */
+			const u8 *data;
+			/*! size */
+			u32 data_len;
+		} data;
+		/*! unsigned integer value*/
+		u64 uint;
+		/*! signed integer value*/
+		s64 sint;
+		/*! number value for GF_QT_KEY_FLOAT and GF_QT_KEY_DOUBLE*/
+		Double number;
+		/*! 2D float value, for GF_QT_KEY_POINTF and GF_QT_KEY_SIZEFF*/
+		struct _tag_vec2 {
+			/*! x-coord*/
+			Float x;
+			/*! y-coord*/
+			Float y;
+		} pos_size;
+		/*! 4D value, for GF_QT_KEY_RECTF*/
+		struct _tag_rec {
+			/*! x-coord*/
+			Float x;
+			/*! y-coord*/
+			Float y;
+			/*! width*/
+			Float w;
+			/*! height*/
+			Float h;
+		} rect;
+		/*! 2x3 matrix */
+		Double matrix9;
+	} value;
+} GF_QT_UDTAKey;
+
+/*! enumerate QT keys tags.
+
+\param isom_file the target ISO file
+\param idx 0-based index of the tag to get
+\param out_key key to be filled with key at given index
+\return error if any (GF_URL_ERROR if no more tags)
+*/
+GF_Err gf_isom_enum_udta_keys(GF_ISOFile *isom_file, u32 idx, GF_QT_UDTAKey *out_key);
+
 #ifndef GPAC_DISABLE_ISOM_WRITE
 /*! sets the given tag info.
 
@@ -6447,6 +6646,12 @@
 */
 GF_Err gf_isom_wma_set_tag(GF_ISOFile *isom_file, char *name, char *value);
 
+/*! sets key (QT style metadata)
+\param isom_file the target ISO file
+\param key the key to use. if NULL, removes ALL keys
+\return error if any
+*/
+GF_Err gf_isom_set_qt_key(GF_ISOFile *isom_file, GF_QT_UDTAKey *key);
 
 /*! sets compatibility tag on AVC tracks (needed by iPod to play files... hurray for standards)
 \param isom_file the target ISO file
@@ -6673,8 +6878,10 @@
 /*! checks if a track as a CENC seig sample group used for key rolling
 \param isom_file the target ISO file
 \param trackNumber the target track
+\param has_selective set to TRUE if some entries describe unprotected samples - may be NULL
+\param has_roll set to TRUE if more than one key defined - may be NULL
 \return GF_TRUE if found, GF_FALSE otherwise*/
-Bool gf_isom_has_cenc_sample_group(GF_ISOFile *isom_file, u32 trackNumber);
+Bool gf_isom_has_cenc_sample_group(GF_ISOFile *isom_file, u32 trackNumber, Bool *has_selective, Bool *has_roll);
 
 /*! gets HEVC tiling info
 \param isom_file the target ISO file
@@ -6696,7 +6903,7 @@
 \param isom_file the target ISO file
 \param trackNumber the target track
 \param sample_number the target sample
-\param sgrp_idx the current index. Must be et to 0 on first call, incremented by this call on each success, must not be NULL
+\param sgrp_idx the current index. Must be set to 0 on first call, incremented by this call on each success, must not be NULL
 \param sgrp_type set to the grouping type, or set to 0 if no more sample group descriptions, must not be NULL
 \param sgrp_parameter set to the grouping_type_parameter or 0 if not defined
 \param sgrp_data set to the sample group description data
@@ -6713,7 +6920,7 @@
 \param sai_type set to the grouping type, or set to 0 if no more sample group descriptions, must not be NULL
 \param sai_parameter set to the grouping_type_parameter or 0 if not defined
 \param sai_data set (allocated) to the sample group description data, must not be NULL and must be freed by caller
-\param sgrp_size set to the sample group description size, must not be NULL
+\param sai_size set to the sample group description size, must not be NULL
 \return error if any
 */
 GF_Err gf_isom_enum_sample_aux_data(GF_ISOFile *isom_file, u32 trackNumber, u32 sample_number, u32 *sai_idx, u32 *sai_type, u32 *sai_parameter, u8 **sai_data, u32 *sai_size);

gpac-2.0.0.tar.gz/include/gpac/maths.h -> gpac-2.2.0.tar.gz/include/gpac/maths.h Changed

gpac-2.0.0.tar.gz/include/gpac/media_tools.h -> gpac-2.2.0.tar.gz/include/gpac/media_tools.h Changed

@@ -86,12 +86,13 @@
  * Get RFC 6381 description for a given track.
 \param isom_file source ISOBMF file
 \param trackNumber track to check
+ \param sample_desc_index sample description index to check
 \param szCodec a pointer to an already allocated string of size RFC6381_CODEC_NAME_SIZE_MAX bytes.
 \param force_inband_xps force inband signaling of parameter sets.
 \param force_sbr forces using explicit signaling for SBR.
 \return error if any.
  */
-GF_Err gf_media_get_rfc_6381_codec_name(GF_ISOFile *isom_file, u32 trackNumber, char *szCodec, Bool force_inband_xps, Bool force_sbr);
+GF_Err gf_media_get_rfc_6381_codec_name(GF_ISOFile *isom_file, u32 trackNumber, u32 sample_desc_index, char *szCodec, Bool force_inband_xps, Bool force_sbr);
 #endif
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
@@ -149,6 +150,15 @@
 */
 GF_Err gf_media_av1_layer_size_get(GF_ISOFile *isom_file, u32 trackNumber, u32 sample_number, u8 op_index, u32 layer_size3);
 
+
+/*! sets keys from name and value, as defined in MP4Box -h tags
+\param isom_file the target ISO file
+\param name the tag name
+\param value the tag value
+\return error if any
+*/
+GF_Err gf_media_isom_apply_qt_key(GF_ISOFile *isom_file, const char *name, const char *value);
+
 #endif
 
 /*! @} */
@@ -719,12 +729,14 @@
 	GF_DASH_BSMODE_INBAND,
 	/*! out of band parameter sets except PPS and APS, used for VVC */
 	GF_DASH_BSMODE_INBAND_PPS,
+	/*! both inband and out of band parameter sets */
+	GF_DASH_BSMODE_BOTH, //Romain
 	/*! attempts to merge parameter sets in a single sample entry */
 	GF_DASH_BSMODE_MERGED,
 	/*! parameter sets are in different sample entries */
 	GF_DASH_BSMODE_MULTIPLE_ENTRIES,
 	/*! forces GF_DASH_BSMODE_INBAND even if only one file is used*/
-	GF_DASH_BSMODE_SINGLE
+	GF_DASH_BSMODE_SINGLE,
 } GF_DashSwitchingMode;
 
 
@@ -951,7 +963,9 @@
 	//! PSSH box in moof and MPD
 	GF_DASH_PSSH_MOOF_MPD,
 	//! PSSH box in MPD only
-	GF_DASH_PSSH_MPD
+	GF_DASH_PSSH_MPD,
+	//! Drop PSSH info from mpd and init seg
+	GF_DASH_PSSH_NONE,
 } GF_DASHPSSHMode;
 
 /*!
@@ -1218,7 +1232,7 @@
 	FILE *dump_file;
 	/*! filter session dump flags*/
 	u32 print_stats_graph;
-	/*! track type: 0: none specified, 1: video, 2: audio*/
+	/*! track type: 0: none specified, 1: video, 2: audio, 3: text*/
 	u32 track_type;
 } GF_MediaExporter;
 
@@ -1230,7 +1244,7 @@
 GF_Err gf_media_export(GF_MediaExporter *dump);
 
 #ifndef GPAC_DISABLE_VTT
-/*! dumps a webvtt tracl to a given file
+/*! dumps a webvtt track to a given file
 \param dumper media dumper object
 \param trackNumber the target track to dump
 \param merge if GF_TRUE, merge vtt cues while dumping them

gpac-2.0.0.tar.gz/include/gpac/mediaobject.h -> gpac-2.2.0.tar.gz/include/gpac/mediaobject.h Changed

gpac-2.0.0.tar.gz/include/gpac/modules/codec.h -> gpac-2.2.0.tar.gz/include/gpac/modules/codec.h Changed

@@ -5,7 +5,7 @@
 *			Copyright (c) Telecom ParisTech 2000-2012
 *					All rights reserved
 *
- * This file is part of GPAC / modules interfaces
+ * This file is part of GPAC / node and input sensor decoders modules interfaces
 *
 * GPAC is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
@@ -37,156 +37,9 @@
 extern "C" {
 #endif
 
-/*multimedia processing levels*/
-enum
-{
-	/*normal, full processing*/
-	GF_CODEC_LEVEL_NORMAL,
-	/*codec is late, should scale down processing*/
-	GF_CODEC_LEVEL_LATE,
-	/*codec is very late, should turn off post-processing, even drop*/
-	GF_CODEC_LEVEL_VERY_LATE,
-	/*input frames are already late before decoding*/
-	GF_CODEC_LEVEL_DROP,
-	/*this is a special level indicating that a seek is happening (decode but no dispatch)
-	it is set dynamically*/
-	GF_CODEC_LEVEL_SEEK
-};
-
-
-/*codec resilience type*/
-enum
-{
-	GF_CODEC_NOT_RESILIENT=0,
-	GF_CODEC_RESILIENT_ALWAYS=1,
-	GF_CODEC_RESILIENT_AFTER_FIRST_RAP=2
-};
-
-/*Define codec matrix*/
-typedef struct __matrix GF_CodecMatrix;
-
-/*the structure for capabilities*/
-typedef struct
-{
-	/*cap code cf below*/
-	u16 CapCode;
-	union {
-		u32 valueInt;
-		Float valueFloat;
-		Bool valueBool;
-	} cap;
-} GF_CodecCapability;
-
-
-/*
-			all codecs capabilities
-*/
 
-enum
-{
-	/*size of a single composition unit */
-	GF_CODEC_OUTPUT_SIZE =	0x01,
-	/*resilency: if packets are lost within an AU, resilience means the AU won't be discarded and the codec
-	will try to decode
-	0: not resilient
-	1: resilient
-	2: resilient after first rap
-	*/
-	GF_CODEC_RESILIENT,
-	/*critical level of composition memory - if below, media management for the object */
-	GF_CODEC_BUFFER_MIN,
-	/*maximum size in CU of composition memory */
-	GF_CODEC_BUFFER_MAX,
-	/*flags that all AUs should be discarded till next RAP (needed in case RAPs are not carried by the transport
-	protocol */
-	GF_CODEC_WAIT_RAP,
-	/*number of padding bytes needed - if the decoder needs padding input cannot be pulled and data is duplicated*/
-	GF_CODEC_PADDING_BYTES,
-	/*codecs can be threaded at will - by default a single thread is used for all decoders and priority is handled
-	by the app, but a codec can configure itself to run in a dedicated thread*/
-	GF_CODEC_WANTS_THREAD,
 
-	/*video width and height and horizontal pitch (in YV12 we assume half Y pitch for U and V planes) */
-	GF_CODEC_WIDTH,
-	GF_CODEC_HEIGHT,
-	GF_CODEC_STRIDE,
-	GF_CODEC_FPS,
-	GF_CODEC_FLIP,
-	/*Pixel Aspect Ratio, expressed as (par.num<<16) | par.den*/
-	GF_CODEC_PAR,
-	/*video color mode - color modes are defined in constants.h*/
-	GF_CODEC_PIXEL_FORMAT,
-	/*signal decoder performs frame re-ordering in temporal scalability*/
-	GF_CODEC_REORDER,
-	/*signal decoder can safely handle CTS when outputting a picture. If not supported by the
-	decoder, the terminal will automatically handle CTS adjustments*/
-	GF_CODEC_TRUSTED_CTS,
-
-	/*set cap only, indicate smax bpp of display*/
-	GF_CODEC_DISPLAY_BPP,
-
-	/*Audio sample rate*/
-	GF_CODEC_SAMPLERATE,
-	/*Audio num channels*/
-	GF_CODEC_NB_CHAN,
-	/*Audio bps*/
-	GF_CODEC_BITS_PER_SAMPLE,
-	/*audio frame format*/
-	GF_CODEC_CHANNEL_CONFIG,
-	/*this is only used for audio in case transport mapping relies on sampleRate (RTP)
-	gets the CU duration in samplerate unit (type: int) */
-	GF_CODEC_CU_DURATION,
-	/*queries whether data is RAW (directly dispatched to CompositionMemory) or not*/
-	GF_CODEC_RAW_MEDIA,
-	/*queries or set support for usage of raw YUV from decoder memory - used for video codecs only, single frame pending*/
-	GF_CODEC_RAW_MEMORY,
-	/*queries or set support for usage of decoded frame from decoder memory - used for video codecs only, multiple frames shall be supported*/
-	GF_CODEC_FRAME_OUTPUT,
-	/*This is only called on scene decoders to signal that potential overlay scene should be
-	showed (cap.valueINT=1) or hidden (cap.valueINT=0). Currently only used with SetCap*/
-	GF_CODEC_SHOW_SCENE,
-	/*This is only called on scene decoders, GetCap only. If the decoder may continue modifying the scene once the last AU is received,
-	it must set cap.valueINT to 1 (typically, text stream decoder will hold the scene for a given duration
-	after the last AU). Otherwise the decoder will be stopped and ask to remove any extra scene being displayed*/
-	GF_CODEC_MEDIA_NOT_OVER,
-
-	/*switches up (1), max (2), down (0) or min (-1) media quality for scalable coding. */
-	GF_CODEC_MEDIA_SWITCH_QUALITY,
-	GF_CODEC_MEDIA_LAYER_DETACH,
-
-	//notifies the codec all streams have been attached for the current time and that it may start init
-	//this is require for L-HEVC+AVC
-	GF_CODEC_CAN_INIT,
-	/*special cap indicating the codec should abort processing as soon as possible because it is about to be destroyed*/
-	GF_CODEC_ABORT,
-
-	/*sets current hitpoint on the video texture. hitpoint is an integer (valueInt) containing:
-		the X coord in upper 16 bits, ranging from 0 to 0xFFFF
-		the Y coord in lower 16 bits, ranging from 0 to 0xFFFF
-	 x,y are in normalized texture coordinates (0,0 bottom left, 1,1 top right)
-	 return GF_NOT_SUPPORTED if your codec does'nt handle this
-	*/
-	GF_CODEC_INTERACT_COORDS,
-	GF_CODEC_NBVIEWS,
-	GF_CODEC_NBLAYERS,
-	GF_CODEC_FORCE_ANNEXB,
-};
-
-
-enum
-{
-	/*stream format is NOT supported by this codec*/
-	GF_CODEC_NOT_SUPPORTED = 0,
-	/*stream type (eg audio, video) is supported by this codec*/
-	GF_CODEC_STREAM_TYPE_SUPPORTED = 1,
-	GF_CODEC_PROFILE_NOT_SUPPORTED = 2,
-	/*stream format may be (partially) supported by this codec*/
-	GF_CODEC_MAYBE_SUPPORTED = 127,
-	/*stream format is supported by this codec*/
-	GF_CODEC_SUPPORTED = 255,
-};
-
-/* Generic interface used by both media decoders and scene decoders
+/* Generic interface used by input sensor decoders (to be deprecated)
 @AttachStream:
 Add a Stream to the codec. If DependsOnESID is NULL, the stream is a base layer
 UpStream means that the decoder should send feedback on this channel.
@@ -214,8 +67,6 @@
 	GF_DECL_MODULE_INTERFACE	\
 	GF_Err (*AttachStream)(IFCE_NAME, GF_ESD *esd);\
 	GF_Err (*DetachStream)(IFCE_NAME, u16 ES_ID);\
-	GF_Err (*GetCapabilities)(IFCE_NAME, GF_CodecCapability *capability);\
-	GF_Err (*SetCapabilities)(IFCE_NAME, GF_CodecCapability capability);\
 	u32 (*CanHandleStream)(IFCE_NAME, u32 StreamType, GF_ESD *esd, u8 ProfileLevelIndication);\
 	const char *(*GetName)(IFCE_NAME);\
 	void *privateStack;	\
@@ -227,31 +78,6 @@
 } GF_BaseDecoder;
 
 
-/*interface name and version for node decoder mainly used by AFX*/
-#define GF_NODE_DECODER_INTERFACE		GF_4CC('G', 'N', 'D', '3')
-
-typedef struct _base_node *LPNODE;
-
-typedef struct _nodedecoder
-{
-	GF_CODEC_BASE_INTERFACE(struct _basedecoder *)
-
-	/*Process the node data in inAU.
-	@inBuffer, inBufferLength: encoded input data (complete framing of encoded data)
-	@ES_ID: stream this data belongs too (scalable object)
-	@AU_Time: specifies the current AU time. This is usually unused, however is needed for decoder
-	handling the scene graph without input data (cf below). In this case the buffer passed is always NULL and the AU
-	time caries the time of the scene (or of the stream object attached to the scene decoder, cf below)
-	@mmlevel: speed indicator for the decoding - cf above for values*/
-	GF_Err (*ProcessData)(struct _nodedecoder *, const char *inBuffer, u32 inBufferLength,
-	 u16 ES_ID, u32 AU_Time, u32 mmlevel);
-
-	/*attaches node to the decoder - currently only one node is only attached to a single decoder*/
-	GF_Err (*AttachNode)(struct _nodedecoder *, LPNODE node);
-} GF_NodeDecoder;
-
-
-
 /*interface name and version for scene decoder */
 #define GF_INPUT_DEVICE_INTERFACE		GF_4CC('G', 'I', 'D', '1')
 
@@ -272,55 +98,6 @@
 } GF_InputSensorDevice;
 
 
-
-/*interface name and version for media decoder */
-#define GF_MEDIA_DECODER_INTERFACE		GF_4CC('G', 'M', 'D', '3')
-
-typedef struct _mediadecoderframe
-{
-	//release media frame
-	void (*Release)(struct _mediadecoderframe *frame);
-	//get media frame plane
-	// @plane_idx: plane index, 0: Y or full plane, 1: U or UV plane, 2: V plane
-	// @outPlane: address of target color plane
-	// @outStride: stride in bytes of target color plane
-	GF_Err (*GetPlane)(struct _mediadecoderframe *frame, u32 plane_idx, const char **outPlane, u32 *outStride);
-
-	GF_Err (*GetGLTexture)(struct _mediadecoderframe *frame, u32 plane_idx, u32 *gl_tex_format, u32 *gl_tex_id, GF_CodecMatrix * texcoordmatrix);
-
-	//allocated space by the decoder
-	void *user_data;
-} GF_MediaDecoderFrame;
-
-/*the media module interface. A media module MUST be implemented in synchronous mode as time
-and resources management is done by the terminal*/
-typedef struct _mediadecoder
-{
-	GF_CODEC_BASE_INTERFACE(struct _basedecoder *)
-
-	/*Process the media data in inAU.
-	@inBuffer, inBufferLength: encoded input data (complete framing of encoded data)
-	@ES_ID: stream this data belongs too (scalable object)
-	@outBuffer, outBufferLength: allocated data for decoding - if outBufferLength is not enough
-		you must set the size in outBufferLength and GF_BUFFER_TOO_SMALL
-
-	@PaddingBits is the padding at the end of the buffer (some codecs need this info)
-	@mmlevel: speed indicator for the decoding - cf above for values*/
-	GF_Err (*ProcessData)(struct _mediadecoder *,
-	 char *inBuffer, u32 inBufferLength,
-	 u16 ES_ID, u32 *CTS,
-	 char *outBuffer, u32 *outBufferLength,
-	 u8 PaddingBits, u32 mmlevel);
-
-
-	/*optional (may be null), retrievs internal output frame of decoder. this function is called only if the decoder returns GF_OK on a SetCapabilities GF_CODEC_RAW_MEMORY*/
-	GF_Err (*GetOutputBuffer)(struct _mediadecoder *, u16 ES_ID, u8 **pY_or_RGB, u8 **pU, u8 **pV);
-
-	/*optional (may be null), retrievs internal output frame object of decoder. this function is called only if the decoder returns GF_OK on a SetCapabilities GF_CODEC_FRAME_OUTPUT*/
-	GF_Err (*GetOutputFrame)(struct _mediadecoder *, u16 ES_ID, GF_MediaDecoderFrame **frame, Bool *needs_resize);
-} GF_MediaDecoder;
-
-
 #ifdef __cplusplus
 }
 #endif

gpac-2.0.0.tar.gz/include/gpac/modules/compositor_ext.h -> gpac-2.2.0.tar.gz/include/gpac/modules/compositor_ext.h Changed

@@ -31,9 +31,10 @@
 extern "C" {
 #endif
 
+#include <gpac/module.h>
 #include <gpac/compositor.h>
 
-/*interface name and version for Terminal Extensions services*/
+/*interface name and version for compositor extensions services*/
 #define GF_COMPOSITOR_EXT_INTERFACE		GF_4CC('C','O','X', '1')
 
 typedef struct _gf_compositor_ext GF_CompositorExt;
@@ -47,12 +48,12 @@
 
 enum
 {
-	/*start terminal extension. If 0 is returned, the module will be unloaded
+	/*start extension. If 0 is returned, the module will be unloaded
 		associated param: GF_Compositor *compositor
 		@return: 1 if OK, 0 otherwise (in which case the extensions will be removed without calling stop)
 	*/
 	GF_COMPOSITOR_EXT_START = 1,
-	/*stop terminal extension
+	/*stop extension
 		associated param: NULL
 		@return: ignored
 	*/
@@ -80,7 +81,6 @@
 	GF_COMPOSITOR_EXTENSION_JS = 1<<2,
 };
 
-
 struct _gf_compositor_ext
 {
 	/* interface declaration*/
@@ -89,8 +89,8 @@
 	/*caps of the module*/
 	u32 caps;
 
-	/*terminal extension proc
-	 termext: pointer to the module
+	/*compositor extension proc
+	 comp_ext: pointer to the module
 	 action: action type of this call
 	 param: associated param of the call
 	*/

gpac-2.0.0.tar.gz/include/gpac/modules/font.h -> gpac-2.2.0.tar.gz/include/gpac/modules/font.h Changed

gpac-2.0.0.tar.gz/include/gpac/modules/video_out.h -> gpac-2.2.0.tar.gz/include/gpac/modules/video_out.h Changed

@@ -90,7 +90,28 @@
 typedef struct _gf_sc_texture_handler GF_TextureH;
 
 /*interface name and version for video output*/
-#define GF_VIDEO_OUTPUT_INTERFACE	GF_4CC('G','V','O','5')
+#define GF_VIDEO_OUTPUT_INTERFACE	GF_4CC('G','V','O','7')
+
+/*! window creation flags*/
+typedef enum
+{
+	/*display should be hidden upon initialization*/
+	GF_VOUT_INIT_HIDE = 1,
+	/*disables video output module - used for bench mode without video*/
+	GF_VOUT_NO_VIDEO = 1<<1,
+	/*works without window thread*/
+	GF_VOUT_WINDOW_NO_THREAD = 1<<2,
+	/*lets the main user handle window events (needed for browser plugins)*/
+	GF_VOUT_NO_WINDOWPROC_OVERRIDE = 1<<3,
+	/*works without title bar*/
+	GF_VOUT_WINDOW_NO_DECORATION = 1<<4,
+
+	/*framebuffer works in 32 bit alpha mode - experimental, only supported on Win32*/
+	GF_VOUT_WINDOW_TRANSPARENT = 1<<5,
+	/*works in windowless mode - experimental, only supported on Win32*/
+	GF_VOUT_WINDOWLESS = 1<<6
+} GF_VideoOutputWindowFlags;
+
 
 /*
 			video output interface
@@ -116,9 +137,11 @@
 	/* interface declaration*/
 	GF_DECL_MODULE_INTERFACE
 
-	/*setup system - if os_handle is NULL the driver shall create the output display (common case)
-	the other case is currently only used by child windows on win32 and winCE
-	@init_flags: a list of initialization flags as specified in user.h*/
+	/*setup video output
+	\param vout: target video output
+	\param os_handle: existing OS-specific window handle (HWND for win32, Window for X11). If NULL the module will create the output window
+	\param os_display: existing OS-specific display handle (currently not used)
+	\param init_flags: bit mask of initialization flags - see GF_VideoOutputWindowFlags*/
 	GF_Err (*Setup)(struct _video_out *vout, void *os_handle, void *os_display, u32 init_flags);
 	/*shutdown system */
 	void (*Shutdown) (struct _video_out *vout);
@@ -222,6 +245,9 @@
 	/*nominal display viewing distance in cm*/
 	Fixed dispdist;
 
+	/*window identifier (one window only per instance of this module)*/
+	u32 window_id;
+
 	/*driver private*/
 	void *opaque;
 } GF_VideoOutput;

gpac-2.0.0.tar.gz/include/gpac/mpd.h -> gpac-2.2.0.tar.gz/include/gpac/mpd.h Changed

@@ -29,7 +29,7 @@
 #include <gpac/xml.h>
 #include <gpac/media_tools.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
+#ifndef GPAC_DISABLE_MPD
 
 /*!
 \file <gpac/mpd.h>
@@ -76,7 +76,7 @@
 \param segment_name target buffer where the segment name is formatted - size must be GF_MAX_PATH
 \param rep_id ID of the target representation
 \param base_url base URL, may be NULL
-\param seg_rad_name base name of the output segements (eg, myfile_ZZZ), shall not be NULL, may be empty ("")
+\param seg_rad_name base name of the output segmeents (eg, myfile_ZZZ), shall not be NULL, may be empty ("")
 \param seg_ext segment extensions
 \param start_time start time of the segment in MPD timescale
 \param bandwidth bandwidth used for the representation
@@ -413,7 +413,7 @@
 {
 	/*! disabled*/
 	Bool disabled;
-	/*! name of cahed init segemnt URL (usually local cache or gmem:// url)*/
+	/*! name of cahed init segment URL (usually local cache or gmem:// url)*/
 	char *cached_init_segment_url;
 	/*! if set indicates the associated gmem memory is owned by this representation*/
 	Bool owned_gmem;
@@ -653,6 +653,13 @@
 
 	/*! target part (cmaf chunk) duration for HLS LL*/
 	Double hls_ll_part_dur;
+
+	/*! tfdt of first segment*/
+	u64 first_tfdt_plus_one;
+	u32 first_tfdt_timescale;
+
+	GF_Fraction hls_max_seg_dur;
+
 } GF_MPD_Representation;
 
 /*! AdaptationSet*/
@@ -877,6 +884,7 @@
 
 	/*! indicates the GPAC state info should be written*/
 	Bool write_context;
+	Bool use_gpac_ext;
 	/*! indicates this is the last static serialization of a previously dynamic MPD*/
 	Bool was_dynamic;
 	/*! indicates the HLS variant files shall be created, otherwise temp files are used*/
@@ -892,6 +900,10 @@
 	Bool llhls_preload;
 	/*! if true inject EXT-X-RENDITION-REPORT*/
 	Bool llhls_rendition_reports;
+	/*! user-defined PART-HOLD-BACK, auto computed if <=0*/
+	Double llhls_part_holdback;
+	//als absolute url flag
+	u32 hls_abs_url;
 } GF_MPD;
 
 /*! parses an MPD Element (and subtree) from DOM
@@ -1233,6 +1245,6 @@
 GF_MPD_Descriptor *gf_mpd_get_descriptor(GF_List *desclist, char *scheme_id);
 
 /*! @} */
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
+#endif /*GPAC_DISABLE_MPD*/
 
 #endif // _MPD_H_

gpac-2.0.0.tar.gz/include/gpac/mpeg4_odf.h -> gpac-2.2.0.tar.gz/include/gpac/mpeg4_odf.h Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / MPEG-4 Object Descriptor sub-project
@@ -1566,7 +1566,7 @@
 void gf_odf_dovi_cfg_del(GF_DOVIDecoderConfigurationRecord *cfg);
 
 
-/*! AC-3 config record extension for EAC-3 - see dolby specs*/
+/*! AC-3 and E-AC3 stream info */
 typedef struct __ec3_stream
 {
 	/*! AC3 fs code*/
@@ -1581,36 +1581,40 @@
 	u8 lfon;
 	/*! asvc mode, only for EC3*/
 	u8 asvc;
-	/*! deps, only for EC3*/
+	/*! number of channels, including lfe and surround channels */
+	u8 channels;
+	/*! number of surround channels */
+	u8 surround_channels;
+	/*! number of dependent substreams, only for EC3*/
 	u8 nb_dep_sub;
-	/*! channel loc, only for EC3*/
-	u8 chan_loc;
+	/*! channel locations for dependent substreams, only for EC3*/
+	u16 chan_loc;
 } GF_AC3StreamInfo;
 
-/*! AC3 config record*/
+/*! AC3 config record  - see dolby specs ETSI TS 102 366 */
 typedef struct __ac3_config
 {
-	/*! indicates if ec3*/
-	u8 is_ec3;
-	/*! if AC3 this is the bitrate code, otherwise cumulated data rate of EC3 streams*/
-	u16 brcode;
-	/*! number of streams :
+	/*! streams info - for AC3, always the first*/
+	GF_AC3StreamInfo streams8;
+	/*! number of independent streams :
 		1 for AC3
-		max 8 for EC3, main stream is included
+		max 8 for EC3
 	*/
 	u8 nb_streams;
-	/*! streams info*/
-	GF_AC3StreamInfo streams8;
-
-	//! \cond  used in parsing not part of the AC3 config record
-	u32 bitrate;
+	/*! indicates if frame is ec3*/
+	u8 is_ec3;
+	/*! if AC3 this is the bitrate code
+	,	 otherwise cumulated data rate of EAC3 streams in kbps
+	*/
+	u16 brcode;
+	/*! sample rate - all additional streams shall have the same sample rate as first independent stream in EC3*/
 	u32 sample_rate;
+	/*! size of the complete frame*/
 	u32 framesize;
-	u32 channels;
-	u16 substreams; //bit-mask, used for channel map > 5.1
-
-	//! \endcond private
-
+	/*! atmos EC3 flag*/
+	u8 atmos_ec3_ext;
+	/*! atmos complexity index*/
+	u8 complexity_index_type;
 } GF_AC3Config;
 
 
@@ -1646,6 +1650,63 @@
 */
 GF_Err gf_odf_ac3_config_parse_bs(GF_BitStream *bs, Bool is_ec3, GF_AC3Config *cfg);
 
+
+
+/*! Opus decoder config*/
+typedef struct
+{
+	//! version (should be 1)
+	u8 version;
+	//!same value as the *Output Channel Count* field in the identification header defined in Ogg Opus 3
+	u8 OutputChannelCount;
+	//!The value of the PreSkip field shall be at least 80 milliseconds' worth of PCM samples even when removing any number of Opus samples which may or may not contain the priming samples. The PreSkip field is not used for discarding the priming samples at the whole playback at all since it is informative only, and that task falls on the Edit List Box.
+	u16 PreSkip;
+	//! The InputSampleRate field shall be set to the same value as the *Input Sample Rate* field in the identification header defined in Ogg Opus
+	u32 InputSampleRate;
+	//! The OutputGain field shall be set to the same value as the *Output Gain* field in the identification header define in Ogg Opus 3. Note that the value is stored as 8.8 fixed-point.
+	s16 OutputGain;
+	//! The ChannelMappingFamily field shall be set to the same value as the *Channel Mapping Family* field in the identification header defined in Ogg Opus 3. Note that the value 255 may be used for an alternative to map channels by ISO Base Media native mapping. The details are described in 4.5.1.
+	u8 ChannelMappingFamily;
+
+	//! The StreamCount field shall be set to the same value as the *Stream Count* field in the identification header defined in Ogg Opus 3.
+	u8 StreamCount;
+	//! The CoupledCount field shall be set to the same value as the *Coupled Count* field in the identification header defined in Ogg Opus 3.
+	u8 CoupledCount;
+	//! The ChannelMapping field shall be set to the same octet string as *Channel Mapping* field in the identi- fication header defined in Ogg Opus 3.
+	u8 ChannelMapping255;
+} GF_OpusConfig;
+
+
+/*! writes Opus  config to buffer
+\param cfg the Opus config to write
+\param bs the bitstream object in which to write the config
+\return error if any
+*/
+GF_Err gf_odf_opus_cfg_write_bs(GF_OpusConfig *cfg, GF_BitStream *bs);
+
+/*! writes Opus config to buffer
+\param cfg the Opus config to write
+\param data set to created output buffer, must be freed by caller
+\param size set to created output buffer size
+\return error if any
+*/
+GF_Err gf_odf_opus_cfg_write(GF_OpusConfig *cfg, u8 **data, u32 *size);
+
+/*! parses an Opus sample description
+\param dsi the encoded config
+\param dsi_len the encoded config size
+\param cfg the Opus config to fill
+\return Error if any
+*/
+GF_Err gf_odf_opus_cfg_parse(u8 *dsi, u32 dsi_len, GF_OpusConfig *cfg);
+
+/*! parses an Opus sample description from bitstream
+\param bs the bitstream object
+\param cfg the Opus config to fill
+\return Error if any
+*/
+GF_Err gf_odf_opus_cfg_parse_bs(GF_BitStream *bs, GF_OpusConfig *cfg);
+
 /*! destroy the descriptors in a list but not the list
 \param descList descriptor list to destroy
 \return error if any

gpac-2.0.0.tar.gz/include/gpac/mpegts.h -> gpac-2.2.0.tar.gz/include/gpac/mpegts.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre, Cyril Concolato, Romain Bouqueau
- *			Copyright (c) Telecom ParisTech 2006-2019
+ *			Copyright (c) Telecom ParisTech 2006-2022
 *
 * This file is part of GPAC / MPEG2-TS sub-project
 *
@@ -288,7 +288,8 @@
 	GF_M2TS_MPE_SECTIONS = 0x90,
 	GF_M2TS_SUBTITLE_DVB			= 0x100,
 	GF_M2TS_AUDIO_OPUS				= 0x101,
-	
+	GF_M2TS_VIDEO_AV1				= 0x102,
+
 	GF_M2TS_DVB_TELETEXT			= 0x152,
 	GF_M2TS_DVB_VBI					= 0x153,
 	GF_M2TS_DVB_SUBTITLE			= 0x154,
@@ -309,7 +310,7 @@
 	GF_M2TS_RA_STREAM_DTS3	= GF_4CC('D','T','S','3'),
 	GF_M2TS_RA_STREAM_OPUS	= GF_4CC('O','p','u','s'),
 	GF_M2TS_RA_STREAM_DOVI	= GF_4CC('D','O','V','I'),
-
+	GF_M2TS_RA_STREAM_AV1	= GF_4CC('A','V','0','1'),
 
 	GF_M2TS_RA_STREAM_GPAC	= GF_4CC('G','P','A','C')
 };
@@ -709,8 +710,10 @@
 	GF_M2TS_FAKE_PCR = 1<<7,
 	/*! signals the stream type is a gpac codec id*/
 	GF_M2TS_GPAC_CODEC_ID = 1<<8,
-	/*! signals the stream type is a gpac codec id*/
+	/*! signals the stream is a PMT*/
 	GF_M2TS_ES_IS_PMT = 1<<9,
+	/*! signals the stream is reused (fake pcr streams), i.e. present twice in ess list*/
+	GF_M2TS_ES_IS_PCR_REUSE = 1<<10,
 
 	/*! all flags above this mask are used by demultiplexer users*/
 	GF_M2TS_ES_STATIC_FLAGS_MASK = 0x0000FFFF,
@@ -722,7 +725,13 @@
 	/*! flag used by importers/readers to mark streams that have been seen already in PMT process (update/found)*/
 	GF_M2TS_ES_ALREADY_DECLARED = 1<<18,
 	/*! flag indicates TEMI info is declared on this stream*/
-	GF_M2TS_ES_TEMI_INFO = 1<<19
+	GF_M2TS_ES_TEMI_INFO = 1<<19,
+	/*! flag indicates each PES is a full AU*/
+	GF_M2TS_ES_FULL_AU = 1<<20,
+	/*! flag indicates ES is not sparse (AV), used to check discontinuity - set by user*/
+	GF_M2TS_CHECK_DISC = 1<<21,
+	/*! flag indicates VC1 sequence header is to be checked - set by user*/
+	GF_M2TS_CHECK_VC1 = 1<<22,
 };
 
 /*! macro for abstract Section/PES stream object, only used for type casting*/
@@ -881,6 +890,10 @@
 	Bool is_resume;
 	/*! DolbiVison info, last byte set to 1 if non-compatible signaling*/
 	u8 dv_info25;
+
+	u64 map_utc, map_utc_pcr, map_pcr;
+	u8 *gpac_meta_dsi;
+	u32 gpac_meta_dsi_size;
 } GF_M2TS_PES;
 
 /*! reserved streamID for PES headers*/
@@ -925,11 +938,17 @@
 /*! TDT/TOT (Time and Date table) information*/
 typedef struct
 {
+	/*! year*/
 	u16 year;
+	/*! month, from 0 to 11*/
 	u8 month;
+	/*! day, from 1 to 31*/
 	u8 day;
+	/*! hour*/
 	u8 hour;
+	/*! minute*/
 	u8 minute;
+	/*! second*/
 	u8 second;
 } GF_M2TS_TDT_TOT;
 
@@ -1391,12 +1410,14 @@
 	GF_ESI_STREAM_WITHOUT_MPEG4_SYSTEMS =	1<<3,
 	/*! stream is not signaled through MPEG-4 Systems (OD stream) */
 	GF_ESI_AAC_USE_LATM =	1<<4,
-	/*! temporrary end of stream (flush of segment)*/
+	/*! temporary end of stream (flush of segment)*/
 	GF_ESI_STREAM_FLUSH	=	1<<5,
 	/*! stream uses HLS SAES encryption*/
 	GF_ESI_STREAM_HLS_SAES	=	1<<6,
 	/*! stream uses non-backward DolbyVision signaling*/
 	GF_ESI_FORCE_DOLBY_VISION = 1<<7,
+	/*! sparse stream with currently no packets*/
+	GF_ESI_STREAM_SPARSE = 1<<8,
 };
 
 /*! elementary stream information*/
@@ -1443,7 +1464,14 @@
 	/*! dv info, not valid if first byte not 1*/
 	u8 dv_info24;
 
+	/*! registration authority code to use, 0 if not applicable*/
 	u32 ra_code;
+	/*! GPAC unmapped meta codec decoder config size*/
+	u32 gpac_meta_dsi_size;
+	/*! GPAC unmapped meta codec decoder config*/
+	u8 *gpac_meta_dsi;
+	/*! GPAC unmapped meta codec name if knwon*/
+	const char *gpac_meta_name;
 } GF_ESInterface;
 
 /*! @} */

gpac-2.0.0.tar.gz/include/gpac/network.h -> gpac-2.2.0.tar.gz/include/gpac/network.h Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / common tools sub-project
@@ -132,6 +132,15 @@
 void gf_url_to_fs_path(char *url);
 
 /*!
+\brief check relative URL
+
+Checks if given URL is absolute or relative
+\param url url to check
+\return GF_TRUE if URL is relative
+ */
+Bool gf_url_is_relative(const char *url);
+
+/*!
 \brief get first after a filename/path
 
 Returns a pointer to the first colon at the end of a filename or URL, if any.
@@ -435,6 +444,20 @@
 \return error if any
  */
 GF_Err gf_sk_send(GF_Socket *sock, const u8 *buffer, u32 length);
+
+/*!
+\brief data emission
+
+Sends a buffer on the socket. The socket must be in a bound or connected mode. This function is usually needed for non-blocking sockets
+\param sock the socket object
+\param buffer the data buffer to send
+\param length the data length to send
+\param written set to number of written bytes - may be NULL
+\return error if any
+ */
+GF_Err gf_sk_send_ex(GF_Socket *sock, const u8 *buffer, u32 length, u32 *written);
+
+
 /*!
 \brief data reception
 
@@ -540,39 +563,33 @@
 \return error if any
  */
 GF_Err gf_sk_setup_multicast(GF_Socket *sock, const char *multi_ip_add, u16 multi_port, u32 TTL, Bool no_bind, char *local_interface_ip);
-/*!
- \brief multicast address test
-
-Tests whether an IP address is a multicast one or not
-\param multi_ip_add the multicast IP address to test
-\return 1 if the address is a multicast one, 0 otherwise
- */
-u32 gf_sk_is_multicast_address(const char *multi_ip_add);
 
 /*!
-\brief send data with wait delay
+\brief source-specific multicast setup
 
-Sends data with a max wait delay. This is used for http / ftp sockets mainly. The socket must be connected.
+Performs multicast setup (BIND and JOIN) for the socket object using allowed and block sources
 \param sock the socket object
-\param buffer the data buffer to send
-\param length the data length to send
-\param delay_sec the maximum delay in second to wait before aborting
-\return If the operation timed out, the function will return a GF_IP_SOCK_WOULD_BLOCK error.
+\param multi_ip_add the multicast IP address
+\param multi_port the multicast port number
+\param TTL the multicast TTL (Time-To-Live)
+\param no_bind if sets, only join the multicast
+\param local_interface_ip the local interface IP address if desired. If NULL, the default interface will be used.
+\param src_ip_inc IP of sources to receive from
+\param nb_src_ip_inc number of sources to receive from
+\param src_ip_exc IP of sources to exclude
+\param nb_src_ip_exc number of sources to exclude
+\return error if any
  */
-GF_Err gf_sk_send_wait(GF_Socket *sock, const u8 *buffer, u32 length, u32 delay_sec);
-/* receive data with a max wait delay of Second - used for http / ftp sockets mainly*/
+GF_Err gf_sk_setup_multicast_ex(GF_Socket *sock, const char *multi_ip_add, u16 multi_port, u32 TTL, Bool no_bind, char *local_interface_ip, const char **src_ip_inc, u32 nb_src_ip_inc, const char **src_ip_exc, u32 nb_src_ip_exc);
+
 /*!
-\brief receive data with wait delay
+ \brief multicast address test
 
-Fetches data with a max wait delay. This is used for http / ftp sockets mainly. The socket must be connected.
-\param sock the socket object
-\param buffer the reception buffer where data is written
-\param length the allocated size of the reception buffer
-\param read the actual number of bytes received
-\param delay_sec the maximum delay in second to wait before aborting
-\return If the operation timed out, the function will return a GF_IP_SOCK_WOULD_BLOCK error.
+Tests whether an IP address is a multicast one or not
+\param multi_ip_add the multicast IP address to test
+\return 1 if the address is a multicast one, 0 otherwise
  */
-GF_Err gf_sk_receive_wait(GF_Socket *sock, u8 *buffer, u32 length, u32 *read, u32 delay_sec);
+u32 gf_sk_is_multicast_address(const char *multi_ip_add);
 
 /*!
 \brief gets socket handle
@@ -611,11 +628,11 @@
 /*! socket selection mode*/
 typedef enum
 {
-	/*! select for both read and write operations */
+	/*! select for either read or write operations */
 	GF_SK_SELECT_BOTH=0,
-	/*! select for both read operations */
+	/*! select for read operations */
 	GF_SK_SELECT_READ,
-	/*! select for both write operations */
+	/*! select for write operations */
 	GF_SK_SELECT_WRITE,
 } GF_SockSelectMode;
 
@@ -623,7 +640,7 @@
 Checks if socket can is ready for read or write
 \param sock the socket object
 \param mode the operation mode desired
-\return GF_OK if ready, GF_IP_SOCK_WOULD_BLOCK if not ready, otherwise error if any (GF_IP_CONNECTION_CLOSED if connection is closed)
+\return GF_OK if ready, GF_IP_NETWORK_EMPTY if not ready, otherwise error if any (GF_IP_CONNECTION_CLOSED if connection is closed)
  */
 GF_Err gf_sk_select(GF_Socket *sock, GF_SockSelectMode mode);
 
@@ -661,7 +678,7 @@
 /*!
 Performs a select (wait) on the socket group
 \param sg socket group object
-\param wait_usec microseconds to wait (can be larger than one second)
+\param wait_usec microseconds to wait (must be less than one second)
 \param mode the operation mode desired
 \return error if any
  */

gpac-2.0.0.tar.gz/include/gpac/rtp_streamer.h -> gpac-2.2.0.tar.gz/include/gpac/rtp_streamer.h Changed

@@ -134,11 +134,12 @@
 \param tx text window horizontal offset
 \param ty text window vertical offset
 \param tl text window z-index
+\param nb_chan number of audio channels, 0 if unknown
 \param for_rtsp if GF_TRUE, produces the SDP for an RTSP describe (no port info)
 \param out_sdp_buffer location to the SDP buffer to allocate and fill
 \return error if any
  */
-GF_Err gf_rtp_streamer_append_sdp_extended(GF_RTPStreamer *rtp, u16 ESID, const u8 *dsi, u32 dsi_len, const u8 *dsi_enh, u32 dsi_enh_len, char *KMS_URI, u32 width, u32 height, u32 tw, u32 th, s32 tx, s32 ty, s16 tl, Bool for_rtsp, char **out_sdp_buffer);
+GF_Err gf_rtp_streamer_append_sdp_extended(GF_RTPStreamer *rtp, u16 ESID, const u8 *dsi, u32 dsi_len, const u8 *dsi_enh, u32 dsi_enh_len, char *KMS_URI, u32 width, u32 height, u32 tw, u32 th, s32 tx, s32 ty, s16 tl, u32 nb_chan, Bool for_rtsp, char **out_sdp_buffer);
 
 /*! sends a full Access Unit over RTP
 \param rtp the target RTP streamer
@@ -241,6 +242,36 @@
 */
 GF_Err gf_rtp_streamer_set_interleave_callbacks(GF_RTPStreamer *streamer, GF_Err (*RTP_TCPCallback)(void *cbk1, void *cbk2, Bool is_rtcp, u8 *pck, u32 pck_size), void *cbk1, void *cbk2);
 
+
+/*! callback function for procesing RTCP  receiver reports
+\param cbk user data passed to \ref  gf_rtp_streamer_read_rtcp
+\param ssrc ssrc for this report, 0 if same as ssrc of channel
+\param rtt_ms round-trip time estimate in ms
+\param jitter_rtp_ts inter-arrival jitter in RTP channel timescale
+\param loss_rate loss rate in per-thousands
+*/
+typedef void (*gf_rtcp_rr_callback)(void *cbk, u32 ssrc, u32 rtt_ms, u64 jitter_rtp_ts, u32 loss_rate);
+
+/*! process rtcp reports if any
+\param streamer the target RTP streamer
+\param rtcp_cbk callback function for RTCP reports
+\param udta user data to use for callback function
+\return error if any, GF_EOS if empty
+*/
+GF_Err gf_rtp_streamer_read_rtcp(GF_RTPStreamer *streamer, gf_rtcp_rr_callback rtcp_cbk, void *udta);
+
+/*! gets ssrc of this streamer
+\param streamer the target RTP streamer
+\return ssrc ID
+*/
+u32 gf_rtp_streamer_get_ssrc(GF_RTPStreamer *streamer);
+
+/*! gets rtp timescale of this streamer
+\param streamer the target RTP streamer
+\return timescale
+*/
+u32 gf_rtp_streamer_get_timescale(GF_RTPStreamer *streamer);
+
 /*! @} */
 
 #ifdef __cplusplus

gpac-2.0.0.tar.gz/include/gpac/setup.h -> gpac-2.2.0.tar.gz/include/gpac/setup.h Changed

@@ -169,6 +169,24 @@
 
 #define snprintf _snprintf
 
+/*	the _USING_V110_SDK71_ macro will be defined when using
+	msvc toolsets like v140_xp, v141_xp, etc.
+*/
+
+#if ( (defined(WINVER) && WINVER <= 0x0502) || _USING_V110_SDK71_)
+#define GPAC_BUILD_FOR_WINXP
+#endif
+
+/*! minimum api versions to use for windows apis with mingw */
+#if (defined(__MINGW32__) || defined(__MINGW64__))
+#if (defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0601)
+#undef _WIN32_WINNT
+#endif
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0601
+#endif
+#endif
+
 #endif	/*END WIN32 non win-ce*/
 /*end WIN32 config*/
 
@@ -433,6 +451,12 @@
 #if (defined (WIN32) || defined (_WIN32_WCE)) && (defined(__MINGW32__) || !defined(__GNUC__))
 
 #if defined(__MINGW32__)
+
+#ifdef __USE_MINGW_ANSI_STDIO
+#undef __USE_MINGW_ANSI_STDIO
+#endif
+#define __USE_MINGW_ANSI_STDIO 1
+
 /*! macro for cross-platform suffix used for formatting s64 integers in logs and printf routines*/
 #define LLD_SUF "lld"
 /*! macro for cross-platform suffix used for formatting u64 integers in logs and printf routines*/

gpac-2.0.0.tar.gz/include/gpac/svg_types.h -> gpac-2.2.0.tar.gz/include/gpac/svg_types.h Changed

gpac-2.0.0.tar.gz/include/gpac/thread.h -> gpac-2.2.0.tar.gz/include/gpac/thread.h Changed

@@ -68,6 +68,55 @@
 #include <windows.h>
 #include <winbase.h>
 
+
+#ifdef GPAC_BUILD_FOR_WINXP
+
+/* Addendum by M. Lackner: Wrap InterlockedExchangeAdd64() around
+ InterlockedCompareExchange64() and name it specifically as an XP
+ function for 32-bit builds only */
+#ifndef GPAC_64_BITS
+#pragma intrinsic(_InterlockedCompareExchange64)
+#define InterlockedCompareExchange64xp _InterlockedCompareExchange64
+static inline LONGLONG InterlockedExchangeAdd64xp(_Inout_ LONGLONG volatile *Addend, _In_ LONGLONG Value)
+{
+	LONGLONG Old;
+	do {
+		Old = *Addend;
+	} while (InterlockedCompareExchange64xp(Addend, Old + Value, Old) != Old);
+	return Old;
+}
+#endif
+/* End of addendum */
+
+
+/*! atomic integer increment */
+#define safe_int_inc(__v) InterlockedIncrement((int *) (__v))
+/*! atomic integer decrement */
+#define safe_int_dec(__v) InterlockedDecrement((int *) (__v))
+/*! atomic integer addition */
+
+/* Modified by M. Lackner for XP & XP x64 compatibility */
+/* InterlockedAdd and InterlockedAdd64 do not exist on Win XP, so we use
+the older InterlockedExchangeAdd and a newly written InterlockedExchangeAdd64xp
+static inline function.
+See:
+https://docs.microsoft.com/en-us/windows/win32/api/winnt/nf-winnt-interlockedexchangeadd
+https://docs.microsoft.com/en-us/windows/win32/api/winnt/nf-winnt-interlockedexchangeadd64
+*/
+
+#define safe_int_add(__v, inc_val) InterlockedExchangeAdd((int *) (__v), inc_val)
+#define safe_int_sub(__v, dec_val) InterlockedExchangeAdd((int *) (__v), -dec_val)
+#ifdef GPAC_64_BITS
+#define safe_int64_add(__v, inc_val) InterlockedExchangeAdd64((LONGLONG *) (__v), inc_val)
+#define safe_int64_sub(__v, dec_val) InterlockedExchangeAdd64((LONGLONG *) (__v), -dec_val)
+#else
+#define safe_int64_add(__v, inc_val) InterlockedExchangeAdd64xp((LONGLONG *) (__v), inc_val)
+#define safe_int64_sub(__v, dec_val) InterlockedExchangeAdd64xp((LONGLONG *) (__v), -dec_val)
+#endif
+/* End of modification by M. Lackner */
+
+#else //not winxp
+
 /*! atomic integer increment */
 #define safe_int_inc(__v) InterlockedIncrement((int *) (__v))
 /*! atomic integer decrement */
@@ -81,7 +130,9 @@
 /*! atomic large integer subtraction */
 #define safe_int64_sub(__v, dec_val) InterlockedAdd64((LONG64 *) (__v), -dec_val)
 
-#else
+#endif //winxp
+
+#else //not windows
 
 #ifdef GPAC_NEED_LIBATOMIC

gpac-2.0.0.tar.gz/include/gpac/token.h -> gpac-2.2.0.tar.gz/include/gpac/token.h Changed

gpac-2.0.0.tar.gz/include/gpac/tools.h -> gpac-2.2.0.tar.gz/include/gpac/tools.h Changed

@@ -182,8 +182,7 @@
 	GF_IP_CONNECTION_CLOSED					= -43,
 	/*! The network operation has failed because no data is available*/
 	GF_IP_NETWORK_EMPTY						= -44,
-	/*! The network operation has been discarded because it would be a blocking one*/
-	GF_IP_SOCK_WOULD_BLOCK					= -45,
+
 	/*! UDP connection did not receive any data at all. Signaled by client services to reconfigure network if possible*/
 	GF_IP_UDP_TIMEOUT						= -46,
 
@@ -411,22 +410,74 @@
 /*!
 \brief System setup
 
-Inits the system high-resolution clock if any, CPU usage manager, random number and GPAC global config. It is strongly recommended to call this function before calling any other GPAC functions, since on some systems (like winCE) it may result in a better memory usage estimation.
+Inits system tools (GPAC global config, high-resolution clock if any, CPU usage manager, random number, ...).
+
+You MUST call this function before calling any libgpac function, typically only once at startup.
 
 The profile allows using a different global config file than the default, and may be a name (without / or \\) or point to an existing config file.
 \note This can be called several times but only the first call will result in system setup.
+
 \param mem_tracker_type memory tracking mode
 \param profile name of the profile to load, NULL for default.
 \return Error code if any
  */
 GF_Err gf_sys_init(GF_MemTrackerType mem_tracker_type, const char *profile);
+
 /*!
 \brief System closing
-Closes the system high-resolution clock and any CPU associated resources.
-\note This can be called several times but the system will be closed when no more users are counted.
+
+Closes allocated system resources opened by \ref gf_sys_init.
+\note This can be called several times but systems resources will be closed when no more users are accounted for.
+
+When JavaScript APIs are loaded, the JS runtime is destroyed in this function call.
+If your application needs to reload GPAC a second time after this, you MUST prevent JS runtime destruction otherwise the application will crash due to static JS class definitions refering to freed memory.
+To prevent destruction, make sure you have called
+ \code gf_opts_set_key("temp", "static-jsrt", "true"); \endcode
+
+before calling \ref gf_sys_close. For example:
+
+\code
+gf_sys_init(GF_MemTrackerNone, NULL);
+//run your code, eg a filter session
+
+//prevent JSRT destruction
+gf_opts_set_key("temp", "static-jsrt", "true");
+gf_sys_close();
+
+//The JSRT is still valid
+
+gf_sys_init(GF_MemTrackerNone, NULL);
+//run your code, eg another filter session
+
+//do NOT prevent JSRT, parent app will exit after this call
+gf_sys_close();
+
+\endcode
+
  */
 void gf_sys_close();
 
+
+#if defined(GPAC_CONFIG_ANDROID)
+
+/*!
+\brief Android paths setup
+
+Sets application data and external storage paths for android, to be called by JNI wrappers BEFORE \ref gf_sys_init is called.
+If not set, default are:
+- app_data is /data/data/io.gpac.gpac
+- ext_storage is /sdcard
+
+The default profile used on android is located in $ext_storage/GPAC/ if that directory exists, otherwise in $app_data/GPAC
+
+\param app_data application data path, with no trailing path separator
+\param ext_storage external storage location, with no trailing path separator
+*/
+void gf_sys_set_android_paths(const char *app_data, const char *ext_storage);
+
+#endif // GPAC_CONFIG_ANDROID
+
+
 /*!
 \brief System arguments
 
@@ -686,7 +737,7 @@
 	GF_LOG_INTERACT,
 	/*! Log message from compositor*/
 	GF_LOG_COMPOSE,
-	/*! Log message from the terminal/compositor, indicating media object state*/
+	/*! Log message from the compositor, indicating media object state*/
 	GF_LOG_COMPTIME,
 	/*! Log for video object cache */
 	GF_LOG_CACHE,
@@ -712,7 +763,7 @@
 	GF_LOG_SCHEDULER,
 	/*! Log for all ROUTE message */
 	GF_LOG_ROUTE,
-	/*! Log for all messages coming from GF_Terminal or script alert()*/
+	/*! Log for all messages coming from script*/
 	GF_LOG_CONSOLE,
 	/*! Log for all messages coming the application, not used by libgpac or the modules*/
 	GF_LOG_APP,
@@ -790,6 +841,15 @@
 Bool gf_log_tool_level_on(GF_LOG_Tool log_tool, GF_LOG_Level log_level);
 
 /*!
+\brief Log tool name
+
+Gets log  tool name
+\param log_tool tool to check
+\return name, or "unknwon" if not known
+*/
+const char *gf_log_tool_name(GF_LOG_Tool log_tool);
+
+/*!
 \brief Log level getter
 
 Gets log level of a given tool
@@ -834,7 +894,8 @@
 Bool gf_log_use_file();
 
 #ifdef GPAC_DISABLE_LOG
-#define GF_LOG(_ll, _lm, __args)
+void gf_log_check_error(u32 ll, u32 lt);
+#define GF_LOG(_ll, _lm, __args) gf_log_check_error(_ll, _lm);
 #else
 /*!
 \brief Message logging
@@ -932,11 +993,11 @@
 char gf_prompt_get_char();
 
 /*!
-\brief Get prompt terminal size
+\brief Get prompt TTY size
 
 Gets the stdin prompt size (columns and rows)
-\param width set to number of rows in the terminal
-\param height set to number of columns in the terminal
+\param width set to number of rows in the TTY
+\param height set to number of columns in the TTY
 \return error if any
 */
 GF_Err gf_prompt_get_size(u32 *width, u32 *height);
@@ -1014,6 +1075,37 @@
 GF_Err gf_blob_release(const char *blob_url);
 
 /*!
+ * Registers a new blob
+\param blob  blob object
+\return URL of blob object (ie gmem://%p), must be freed by user
+ */
+char *gf_blob_register(GF_Blob *blob);
+
+/*!
+ * Unegisters a blob. This must be called before destroying a registered blob
+\param blob  blob object
+ */
+void gf_blob_unregister(GF_Blob *blob);
+
+/*!
+\brief Portable getch()
+
+Returns immediately a typed char from stdin
+\return the typed char
+*/
+int gf_getch();
+
+/*!
+\brief Reads a line of input from stdin
+\param line the buffer to fill
+\param maxSize the maximum size of the line to read
+\param showContent boolean indicating if the line read should be printed on stderr or not
+\return GF_TRUE if some content was read, GF_FALSE otherwise
+*/
+u32 gf_read_line_input(char * line, int maxSize, Bool showContent);
+
+
+/*!
 \addtogroup time_grp
 \brief Time manipulation tools
 @{
@@ -1087,7 +1179,7 @@
 /*!
 \brief returns 64-bit UTC timestamp from year, month, day, hour, min and sec
 \param year the year
-\param month the month
+\param month the month, from 0 to 11
 \param day the day
 \param hour the hour
 \param min the min
@@ -1369,6 +1461,18 @@
 \return same as fprintf
 */
 int gf_fprintf(FILE *stream, const char *format, ...);
+
+/*!
+\brief file writing helper
+
+Wrapper to properly handle calls to vfprintf()
+\param stream same as vfprintf
+\param format same as vfprintf
+\param args same as vfprintf
+\return same as fprintf
+*/
+int gf_vfprintf(FILE *stream, const char *format, va_list args);
+
 /*!
 \brief file flush helper
 
@@ -1956,6 +2060,15 @@
 void gf_sha1_csum(u8 *buf, u32 buflen, u8 digestGF_SHA1_DIGEST_SIZE);
 /*! @} */
 
+/*! checksum size for SHA-256*/
+#define GF_SHA256_DIGEST_SIZE 32
+/*! gets SHA-256 of input buffer
+\param buf input buffer to hash
+\param buflen sizeo of input buffer in bytes
+\param digest buffer to store message digest
+ */
+void gf_sha256_csum(const void *buf, u64 buflen, u8 digestGF_SHA256_DIGEST_SIZE);
+
 
 /*!
 \addtogroup libsys_grp
@@ -2032,6 +2145,12 @@
 GF_Err gf_opts_discard_changes();
 
 /*!
+ * Force immediate write of config
+\return error code
+ */
+GF_Err gf_opts_save();
+
+/*!
  * Returns file name of global config
 \return file name of global config or NULL if libgpac is not initialized
  */
@@ -2044,6 +2163,24 @@
  */
 Bool gf_opts_default_shared_directory(char *path_buffer);
 
+
+/*!
+ * Checks given user and password are valid
+\param username user name
+\param password password
+\return GF_OK if success, GF_NOT_FOUND if no such user or GF_AUTHENTICATION_FAILURE if wrong password
+ */
+GF_Err gf_creds_check_password(const char *username, char *password);
+
+/*!
+ * Checks given user belongs to list of users or groups.
+\param username user name
+\param users comma-seprated list of users to check, may be NULL
+\param groups comma-seprated list of groups to check, may be NULL
+\return GF_TRUE if success, GF_FALSE otherwise
+ */
+Bool gf_creds_check_membership(const char *username, const char *users, const char *groups);
+
 /*! @} */
 
 
@@ -2081,12 +2218,8 @@
 
 //! @endcond
 
+
 /* \cond dummy */
-#ifdef GPAC_CONFIG_ANDROID
-typedef void (*fm_callback_func)(void *cbk_obj, u32 type, u32 param, int *value);
-extern void gf_fm_request_set_callback(void *cbk_obj, fm_callback_func cbk_func);
-void gf_fm_request_call(u32 type, u32 param, int *value);
-#endif //GPAC_CONFIG_ANDROID
 
 /*to call whenever the OpenGL library is opened - this function is needed to bind OpenGL and remotery, and to load
 OpenGL extensions on windows

gpac-2.0.0.tar.gz/include/gpac/version.h -> gpac-2.2.0.tar.gz/include/gpac/version.h Changed

gpac-2.0.0.tar.gz/include/gpac/xml.h -> gpac-2.2.0.tar.gz/include/gpac/xml.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -34,8 +34,6 @@
 #include <gpac/list.h>
 #include <gpac/bitstream.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 /*!
 \file <gpac/xml.h>
 \brief XML functions.
@@ -342,6 +340,12 @@
 GF_Err gf_xml_dom_append_child(GF_XMLNode *node, GF_XMLNode *child);
 
 
+/*! Create a node.
+\param ns the target namespace or NULL if none
+\param name the target name or NULL to create text node
+\return new node, NULL if error. 
+ */
+GF_XMLNode *gf_xml_dom_node_new(const char* ns, const char* name);
 /*! Destroys a node, its attributes and its children
 
 \param node the node to free
@@ -412,10 +416,11 @@
 Parses XML bit sequence in an existing bitstream object. The syntax for the XML is the same as in \ref gf_xml_parse_bit_sequence
 \param bsroot the root node of XML document describing the bitstream to create
 \param parent_url URL of the parent document
+\param base_media URL of base media file if any, relative to parent url. May be NULL
 \param bs target bitstream to write the result into. The bitstream must be a dynamic write bitstream object
 \return error code or GF_OK
 */
-GF_Err gf_xml_parse_bit_sequence_bs(GF_XMLNode *bsroot, const char *parent_url, GF_BitStream *bs);
+GF_Err gf_xml_parse_bit_sequence_bs(GF_XMLNode *bsroot, const char *parent_url, const char *base_media, GF_BitStream *bs);
 
 
 /*! @} */
@@ -424,6 +429,4 @@
 }
 #endif
 
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
-
 #endif		/*_XML_PARSER_H_*/

gpac-2.0.0.tar.gz/mkdmg.sh -> gpac-2.2.0.tar.gz/mkdmg.sh Changed

gpac-2.0.0.tar.gz/modules/Makefile -> gpac-2.2.0.tar.gz/modules/Makefile Changed

gpac-2.0.0.tar.gz/modules/alsa/Makefile -> gpac-2.2.0.tar.gz/modules/alsa/Makefile Changed

gpac-2.0.0.tar.gz/modules/dec_openhevc/Makefile -> gpac-2.2.0.tar.gz/modules/dec_openhevc/Makefile Changed

gpac-2.0.0.tar.gz/modules/dektec_out/Makefile -> gpac-2.2.0.tar.gz/modules/dektec_out/Makefile Changed

gpac-2.0.0.tar.gz/modules/dektec_out/dektec_video.h -> gpac-2.2.0.tar.gz/modules/dektec_out/dektec_video.h Changed

gpac-2.0.0.tar.gz/modules/dektec_out/dektec_video_decl.c -> gpac-2.2.0.tar.gz/modules/dektec_out/dektec_video_decl.c Changed

gpac-2.2.0.tar.gz/modules/deprecated/droid_cam Added

gpac-2.2.0.tar.gz/modules/deprecated/droid_cam/droid_cam.c Added

@@ -0,0 +1,725 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Ivica Arsov, Jean Le Feuvre
+ *			Copyright (c) Mines-Telecom 2009-
+ *					All rights reserved
+ *
+ * This file is part of GPAC / Android camera module
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <gpac/terminal.h>
+#include <gpac/internal/terminal_dev.h>
+#include <gpac/internal/compositor_dev.h>
+#include <gpac/modules/codec.h>
+#include <gpac/constants.h>
+#include <gpac/modules/service.h>
+#include <gpac/thread.h>
+#include <gpac/media_tools.h>
+
+#include <jni.h>
+#include <android/log.h>
+
+#define LOG_TAG "ANDROID_CAMERA"
+#ifdef ANDROID
+# define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+# define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+# define QUOTEME_(x) #x
+# define QUOTEME(x) QUOTEME_(x)
+# define LOGI(...) fprintf(stderr, "I/" LOG_TAG " (" __FILE__ ":" QUOTEME(__LINE__) "): " __VA_ARGS__)
+# define LOGE(...) fprintf(stderr, "E/" LOG_TAG "(" ")" __VA_ARGS__)
+#endif
+
+static JavaVM* javaVM = 0;
+static jclass camCtrlClass;
+static jmethodID cid;
+static jmethodID startCamera;
+static jmethodID stopCamera;
+static jmethodID startProcessing;
+static jmethodID stopProcessing;
+static jmethodID getImageFormat;
+static jmethodID getImageHeight;
+static jmethodID getImageWidth;
+static jmethodID getBitsPerPixel;
+
+#ifndef GPAC_STATIC_MODULES
+jint JNI_OnLoad(JavaVM* vm, void* reserved)
+#else
+jint static_JNI_OnLoad(JavaVM* vm, void* reserved)
+#endif
+{
+	JNIEnv* env = 0;
+	javaVM = vm;
+
+	if ( (*javaVM)->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
+		return -1;
+
+	// Get the class and its methods in the main env
+
+	// Get the CameraController class
+	// This is just a local refenrece. Cannot be used in the other JNI calls.
+	camCtrlClass = (*env)->FindClass(env, "io/gpac/gpac/Preview");
+	if (camCtrlClass == 0)
+	{
+		LOGE("CameraController class = null myCamera.c, startCameraNative()");
+		return -1;
+	}
+
+	// Get Global Reference to be able to use the class
+	camCtrlClass = (*env)->NewGlobalRef(env, camCtrlClass);
+	if ( camCtrlClass == 0 )
+	{
+		LOGE("MPEG-V_IN Cannot create Global Reference\n");
+		return -1;
+	}
+
+	// Get the method ID for the CameraController constructor.
+	cid = (*env)->GetMethodID(env, camCtrlClass, "<init>", "()V");
+	if (cid == 0)
+	{
+		LOGE("Method ID for CameraController constructor is null myCamera.c, startCameraNative()");
+		return -1;
+	}
+
+	// Get startCamera() method from class CameraController
+	startCamera = (*env)->GetMethodID(env, camCtrlClass, "initializeCamera", "(Z)Z");
+	if (startCamera == 0)
+	{
+		LOGE("ANDROID_CAMERA Function startCamera not found");
+		return -1;
+	}
+
+	stopCamera = (*env)->GetMethodID(env, camCtrlClass, "stopCamera", "()V");
+	if (stopCamera == 0)
+	{
+		LOGE("ANDROID_CAMERA Function stopCamera not found");
+		return -1;
+	}
+
+	startProcessing = (*env)->GetMethodID(env, camCtrlClass, "resumePreview", "()V");
+	if (startProcessing == 0)
+	{
+		LOGE("ANDROID_CAMERA Function startProcessing not found");
+		return -1;
+	}
+
+	stopProcessing = (*env)->GetMethodID(env, camCtrlClass, "pausePreview", "()V");
+	if (stopProcessing == 0)
+	{
+		LOGE("ANDROID_CAMERA Function stopProcessing not found");
+		return -1;
+	}
+
+	getImageFormat = (*env)->GetMethodID(env, camCtrlClass, "getPreviewFormat", "()I");
+	if (getImageFormat == 0)
+	{
+		LOGE("ANDROID_CAMERA Function getImageFormat not found");
+		return -1;
+	}
+
+	getImageHeight = (*env)->GetMethodID(env, camCtrlClass, "getImageHeight", "()I");
+	if (getImageHeight == 0)
+	{
+		LOGE("ANDROID_CAMERA Function getImageHeight not found");
+		return -1;
+	}
+
+	getImageWidth = (*env)->GetMethodID(env, camCtrlClass, "getImageWidth", "()I");
+	if (getImageWidth == 0)
+	{
+		LOGE("ANDROID_CAMERA Function getImageWidth not found");
+		return -1;
+	}
+
+	getBitsPerPixel = (*env)->GetMethodID(env, camCtrlClass, "getBitsPerPixel", "()I");
+	if (getBitsPerPixel == 0)
+	{
+		LOGE("ANDROID_CAMERA Function getBitsPerPixel not found");
+		return -1;
+	}
+
+	return JNI_VERSION_1_2;
+}
+
+#ifndef GPAC_STATIC_MODULES
+//----------------------------------------------------------------------
+JavaVM* GetJavaVM()
+{
+	return javaVM;
+}
+
+JNIEnv* GetEnv()
+{
+	JNIEnv* env;
+	if ( (*GetJavaVM())->GetEnv(GetJavaVM(), (void**)&env, JNI_VERSION_1_2) != JNI_OK )
+		return NULL;
+
+	return env;
+}
+#else
+JavaVM* GetJavaVM();
+JNIEnv* GetEnv();
+
+#endif
+
+void JNI_OnUnload(JavaVM *vm, void *reserved)
+{
+	JNIEnv* env = 0;
+
+	if ( (*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
+		return;
+
+	(*env)->DeleteGlobalRef(env, camCtrlClass);
+}
+//----------------------------------------------------------------------
+
+
+//#define CAM_PIXEL_FORMAT GF_PIXEL_NV21
+//GF_PIXEL_RGB_32
+//#define CAM_PIXEL_SIZE 1.5f
+//4
+#define CAM_WIDTH 640
+#define CAM_HEIGHT 480
+
+//GF_PIXEL_RGB_24;
+
+typedef struct
+{
+	GF_InputService *input;
+	/*the service we're responsible for*/
+	GF_ClientService *service;
+	LPNETCHANNEL channel;
+
+	/*input file*/
+	u32 time_scale;
+
+	u32 base_track_id;
+
+	struct _tag_terminal *term;
+
+	u32 cntr;
+
+	u32 width;
+	u32 height;
+
+	Bool started;
+
+	JNIEnv* env;
+	u8 isAttached;
+	jclass camCtrlClass;
+	jmethodID cid;
+	jobject camCtrlObj;
+	jmethodID startCamera;
+	jmethodID stopCamera;
+	jmethodID startProcessing;
+	jmethodID stopProcessing;
+	jmethodID getImageFormat;
+	jmethodID getImageHeight;
+	jmethodID getImageWidth;
+	jmethodID getBitsPerPixel;
+
+} ISOMReader;
+
+ISOMReader* globReader;
+
+void loadCameraControler(ISOMReader *read);
+void camStartCamera(ISOMReader *read);
+void camStopCamera(ISOMReader *read);
+
+Bool CAM_CanHandleURL(GF_InputService *plug, const char *url)
+{
+	if (!strnicmp(url, "hw://camera", 11)) return 1;
+
+	return 0;
+}
+
+void unloadCameraControler(ISOMReader *read)
+{
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA unloadCameraControler: %d\n", gf_th_id()));
+	if ( read->isAttached )
+	{
+		//(*rc->env)->PopLocalFrame(rc->env, NULL);
+		(*GetJavaVM())->DetachCurrentThread(GetJavaVM());
+		read->isAttached = 0;
+	}
+
+	read->env = NULL;
+}
+
+u32 unregisterFunc(void* data)
+{
+	unloadCameraControler(globReader);
+	return 0;
+}
+
+void loadCameraControler(ISOMReader *read)
+{
+	JNIEnv* env = NULL;
+	jint res = 0;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA loadCameraControler: %d\n", gf_th_id()));
+
+	// Get the JNI interface pointer
+	res = (*GetJavaVM())->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2);
+	if ( res == JNI_EDETACHED )
+	{
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA The current thread is not attached to the VM, assuming native thread\n"));
+		res = (*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
+		if ( res )
+		{
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("ANDROID_CAMERA Attach current thread failed: %d\n", res));
+			return;
+		}
+		gf_register_before_exit_function(gf_th_current(), unregisterFunc);
+		read->isAttached = 1;
+		//(*rc->env)->PushLocalFrame(rc->env, 2);
+	}
+	else if ( res == JNI_EVERSION )
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("ANDROID_CAMERA The specified version is not supported\n"));
+		return;
+	}
+
+	read->env = env;
+	read->camCtrlClass = camCtrlClass;
+	read->cid = cid;
+	read->startCamera = startCamera;
+	read->stopCamera = stopCamera;
+	read->startProcessing = startProcessing;
+	read->stopProcessing = stopProcessing;
+	read->getImageFormat = getImageFormat;
+	read->getImageHeight = getImageHeight;
+	read->getImageWidth = getImageWidth;
+	read->getBitsPerPixel = getBitsPerPixel;
+
+	// Create the object.
+	read->camCtrlObj = (*env)->NewObject(env, read->camCtrlClass, read->cid);
+	if (read->camCtrlObj == 0)
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("CameraController object creation failed. myCamera.c, startCameraNative()"));
+		return;
+	}
+}
+
+GF_Err CAM_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
+{
+	ISOMReader *read;
+	if (!plug || !plug->priv || !serv) return GF_SERVICE_ERROR;
+	read = (ISOMReader *) plug->priv;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_ConnectService: %d\n", gf_th_id()));
+
+	read->input = plug;
+	read->service = serv;
+	read->base_track_id = 1;
+	read->time_scale = 1000;
+
+	read->term = serv->term;
+
+	loadCameraControler(read);
+
+	camStartCamera(read);
+
+	/*reply to user*/
+	gf_service_connect_ack(serv, NULL, GF_OK);
+	//if (read->no_service_desc) isor_declare_objects(read);
+
+	return GF_OK;
+}
+
+GF_Err CAM_CloseService(GF_InputService *plug)
+{
+	GF_Err reply;
+	ISOMReader *read;
+	if (!plug || !plug->priv) return GF_SERVICE_ERROR;
+	read = (ISOMReader *) plug->priv;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_CloseService: %d\n", gf_th_id()));
+
+	reply = GF_OK;
+
+	(*GetEnv())->DeleteLocalRef( GetEnv(), read->camCtrlObj );
+	read->camCtrlObj = NULL;
+
+	//unloadCameraControler(read);
+
+	gf_service_disconnect_ack(read->service, NULL, reply);
+	return GF_OK;
+}
+
+u32 getWidth(ISOMReader *read);
+u32 getHeight(ISOMReader *read);
+u32 getFormat(ISOMReader *read);
+u32 getBitsPerPix(ISOMReader *read);
+
+static GF_Descriptor *CAM_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
+{
+	u32 trackID;
+	ISOMReader *read;
+	char *buf;
+	u32 buf_size;
+	if (!plug || !plug->priv) return NULL;
+	read = (ISOMReader *) plug->priv;
+
+	trackID = read->base_track_id;
+	read->base_track_id = 0;
+
+	if (trackID && (expect_type==GF_MEDIA_OBJECT_VIDEO) ) {
+		GF_BitStream *bs;
+		GF_ESD *esd;
+		GF_ObjectDescriptor *od;
+		od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
+		od->objectDescriptorID = 1;
+
+		esd = gf_odf_desc_esd_new(0);
+		esd->slConfig->timestampResolution = 1000;
+		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
+		esd->ESID = 1;
+		esd->decoderConfig->objectTypeIndication = GPAC_OTI_RAW_MEDIA_STREAM;
+
+		bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+
+		read->width = getWidth(read);
+		read->height = getHeight(read);
+
+		gf_bs_write_u32(bs, getFormat(read)); // fourcc
+		gf_bs_write_u16(bs, read->width); // width
+		gf_bs_write_u16(bs, read->height); // height
+		gf_bs_write_u32(bs, read->width * read->height * getBitsPerPix(read) / 8); // framesize
+		gf_bs_write_u32(bs, read->width); // stride
+
+		gf_bs_align(bs);
+		gf_bs_get_content(bs, &buf, &buf_size);
+		gf_bs_del(bs);
+
+		esd->decoderConfig->decoderSpecificInfo->data = buf;
+		esd->decoderConfig->decoderSpecificInfo->dataLength = buf_size;
+
+		gf_list_add(od->ESDescriptors, esd);
+		return (GF_Descriptor *) od;
+	}
+
+	return NULL;
+}
+
+
+
+
+GF_Err CAM_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
+{
+	GF_Err e;
+	ISOMReader *read;
+	if (!plug || !plug->priv) return GF_SERVICE_ERROR;
+	read = (ISOMReader *) plug->priv;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_ConnectChannel: %d\n", gf_th_id()));
+
+	e = GF_OK;
+	if (upstream) {
+		e = GF_ISOM_INVALID_FILE;
+	}
+
+	read->channel = channel;
+
+	gf_service_connect_ack(read->service, channel, e);
+	return e;
+}
+
+GF_Err CAM_DisconnectChannel(GF_InputService *plug, LPNETCHANNEL channel)
+{
+	GF_Err e;
+	ISOMReader *read;
+	if (!plug || !plug->priv) return GF_SERVICE_ERROR;
+	read = (ISOMReader *) plug->priv;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA CAM_DisconnectChannel: %d\n", gf_th_id()));
+
+	e = GF_OK;
+
+	camStopCamera(read);
+
+	gf_service_disconnect_ack(read->service, channel, e);
+	return e;
+}
+
+void Java_com_gpac_Osmo4_Preview_processFrameBuf( JNIEnv* env, jobject thiz, jbyteArray arr)
+{
+	ISOMReader* ctx = globReader;
+	if ( ctx
+	 	&& ctx->started
+	 	&& ctx->term
+	 	&& ctx->term->compositor
+	 	&& ctx->term->compositor->audio_renderer
+	) {
+
+		u8* data;
+		u32 datasize;
+		GF_SLHeader hdr;
+		u32 cts = 0;
+		//u32 convTime = 0;
+		//u32 j = 0;
+		jbyte *jdata;
+		jsize len;
+
+		len = (*env)->GetArrayLength(env, arr);
+		if ( len <= 0 ) return;
+		jdata = (*env)->GetByteArrayElements(env,arr,0);
+
+		//convTime = gf_term_get_time(ctx->term);
+
+		data = (u8*)jdata;//(u8*)decodeYUV420SP((char*)jdata, ctx->width, ctx->height); //
+		datasize = len;//ctx->width * ctx->height * CAM_PIXEL_SIZE;//
+
+		cts = gf_term_get_time(ctx->term);
+
+		//convTime = cts - convTime;
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.compositionTimeStampFlag = 1;
+		hdr.compositionTimeStamp = cts;
+		gf_service_send_packet(ctx->service, ctx->channel, (void*)data, datasize, &hdr, GF_OK);
+
+		//gf_free(data);
+
+		(*env)->ReleaseByteArrayElements(env,arr,jdata,JNI_ABORT);
+
+		//GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Camera Frame Sent %d\n", gf_sys_clock()));
+	}
+}
+
+void CallCamMethod(ISOMReader *read, jmethodID methodID)
+{
+	JNIEnv* env = NULL;
+	jint res = 0;
+	u8 isAttached = 0;
+
+	// Get the JNI interface pointer
+	res = (*GetJavaVM())->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2);
+	if ( res == JNI_EDETACHED )
+	{
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA The current thread is not attached to the VM, assuming native thread\n"));
+		res = (*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
+		if ( res ) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("ANDROID_CAMERA Attach current thread failed: %d\n", res));
+			return;
+		}
+		if ( env != read->env )
+			isAttached = 1;
+	}
+
+	(*env)->CallNonvirtualVoidMethod(env, read->camCtrlObj, read->camCtrlClass, methodID);
+
+	if (isAttached)
+	{
+		(*GetJavaVM())->DetachCurrentThread(GetJavaVM());
+	}
+}
+
+void camStartCamera(ISOMReader *read)
+{
+	JNIEnv* env;
+	jboolean isPortrait = JNI_FALSE;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA startCamera: %d\n", gf_th_id()));
+
+	// Get the JNI interface pointer
+	env = read->env;
+
+	(*env)->CallNonvirtualBooleanMethod(env, read->camCtrlObj, read->camCtrlClass, read->startCamera, isPortrait);
+}
+
+void camStopCamera(ISOMReader *read)
+{
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA stopCamera: %d\n", gf_th_id()));
+
+	CallCamMethod(read, read->stopCamera);
+}
+
+void pauseCamera(ISOMReader *read)
+{
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA pauseCamera: %d\n", gf_th_id()));
+
+	read->started = 0;
+	CallCamMethod(read, read->stopProcessing);
+}
+
+void resumeCamera(ISOMReader *read)
+{
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA resumeCamera: %d\n", gf_th_id()));
+
+	read->started = 1;
+	CallCamMethod(read, read->startProcessing);
+}
+
+u32 getWidth(ISOMReader *read)
+{
+	JNIEnv* env;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getWidth: %d\n", gf_th_id()));
+
+	// Get the JNI interface pointer
+	env = read->env;
+
+	return (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getImageWidth);
+}
+
+u32 getHeight(ISOMReader *read)
+{
+	JNIEnv* env;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getHeight: %d\n", gf_th_id()));
+
+	// Get the JNI interface pointer
+	env = read->env;
+
+	return (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getImageHeight);
+}
+
+u32 getFormat(ISOMReader *read)
+{
+	JNIEnv* env;
+	u32 pixel_format;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getFormat: %d\n", gf_th_id()));
+
+	// Get the JNI interface pointer
+	env = read->env;
+
+	pixel_format = (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getImageFormat);
+	switch (pixel_format) {
+	case 17: //NV21
+		return GF_PIXEL_NV21;
+	case 842094169: //YV12
+		return GF_PIXEL_YV12;
+	default:
+		return 0; //should never be here
+	}
+}
+
+u32 getBitsPerPix(ISOMReader *read)
+{
+	JNIEnv* env;
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("ANDROID_CAMERA getBitsPerPix: %d\n", gf_th_id()));
+
+	// Get the JNI interface pointer
+	env = read->env;
+
+	return (*env)->CallNonvirtualIntMethod(env, read->camCtrlObj, read->camCtrlClass, read->getBitsPerPixel);
+}
+
+GF_Err CAM_ServiceCommand(GF_InputService *plug, GF_NetworkCommand *com)
+{
+	ISOMReader *read;
+	if (!plug || !plug->priv || !com) return GF_SERVICE_ERROR;
+	read = (ISOMReader *) plug->priv;
+
+	if (com->command_type==GF_NET_SERVICE_INFO) {
+		return GF_OK;
+	}
+	if (com->command_type==GF_NET_SERVICE_HAS_AUDIO) {
+		return GF_NOT_SUPPORTED;
+	}
+	if (!com->base.on_channel) return GF_NOT_SUPPORTED;
+
+	switch (com->command_type) {
+	case GF_NET_CHAN_INTERACTIVE:
+		return GF_OK;
+	case GF_NET_CHAN_BUFFER:
+		com->buffer.max = com->buffer.min = 0;
+		return GF_OK;
+	case GF_NET_CHAN_PLAY:
+		resumeCamera(read);
+		return GF_OK;
+	case GF_NET_CHAN_STOP:
+		pauseCamera(read);
+		return GF_OK;
+	/*nothing to do on MP4 for channel config*/
+	case GF_NET_CHAN_CONFIG:
+		return GF_OK;
+	default:
+		break;
+	}
+	return GF_NOT_SUPPORTED;
+}
+
+GF_InputService *CAM_client_load()
+{
+	ISOMReader *reader;
+	GF_InputService *plug;
+	GF_SAFEALLOC(plug, GF_InputService);
+	GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC Camera Plugin", "gpac distribution")
+	plug->CanHandleURL = CAM_CanHandleURL;
+	plug->ConnectService = CAM_ConnectService;
+	plug->CloseService = CAM_CloseService;
+	plug->GetServiceDescriptor = CAM_GetServiceDesc;
+	plug->ConnectChannel = CAM_ConnectChannel;
+	plug->DisconnectChannel = CAM_DisconnectChannel;
+	plug->ServiceCommand = CAM_ServiceCommand;
+
+	GF_SAFEALLOC(reader, ISOMReader);
+	plug->priv = reader;
+	globReader = reader;
+
+
+#ifdef GPAC_STATIC_MODULES
+	static_JNI_OnLoad(GetJavaVM(), NULL);
+#endif
+
+	return plug;
+}
+
+void CAM_client_del(GF_BaseInterface *bi)
+{
+	GF_InputService *plug = (GF_InputService *) bi;
+	ISOMReader *read = (ISOMReader *)plug->priv;
+
+	gf_free(read);
+	gf_free(bi);
+}
+
+GPAC_MODULE_EXPORT
+const u32 *QueryInterfaces()
+{
+	static u32 si = {
+		GF_NET_CLIENT_INTERFACE,
+		0
+	};
+	return si;
+}
+
+GPAC_MODULE_EXPORT
+GF_BaseInterface *LoadInterface(u32 InterfaceType)
+{
+	if (InterfaceType == GF_NET_CLIENT_INTERFACE)
+		return (GF_BaseInterface *)CAM_client_load();
+	return NULL;
+}
+
+GPAC_MODULE_EXPORT
+void ShutdownInterface(GF_BaseInterface *ifce)
+{
+	switch (ifce->InterfaceType) {
+	case GF_NET_CLIENT_INTERFACE:
+		CAM_client_del(ifce);
+		break;
+	}
+}
+
+GPAC_MODULE_STATIC_DECLARATION( droid_cam )

gpac-2.2.0.tar.gz/modules/deprecated/droid_cam/gm_droid_cam.mk Changed

gpac-2.2.0.tar.gz/modules/deprecated/droid_mpegv Added

gpac-2.2.0.tar.gz/modules/deprecated/droid_mpegv/droid_mpegv.c Added

@@ -0,0 +1,495 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Ivica Arsov, Jean Le Feuvre
+ *			Copyright (c) Mines-Telecom 2009-
+ *					All rights reserved
+ *
+ * This file is part of GPAC / MPEG-V Input sensor for android
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <jni.h>
+#include <android/log.h>
+
+/*driver interfaces*/
+
+#include <gpac/list.h>
+#include <gpac/constants.h>
+
+#include <gpac/setup.h>
+
+#include <gpac/modules/codec.h>
+#include <gpac/scenegraph_vrml.h>
+
+#include <gpac/thread.h>
+
+#define LOG_TAG "MPEG-V_IN"
+#ifdef ANDROID
+# define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+# define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+# define QUOTEME_(x) #x
+# define QUOTEME(x) QUOTEME_(x)
+# define LOGI(...) fprintf(stderr, "I/" LOG_TAG " (" __FILE__ ":" QUOTEME(__LINE__) "): " __VA_ARGS__)
+# define LOGE(...) fprintf(stderr, "E/" LOG_TAG "(" ")" __VA_ARGS__)
+#endif
+
+JNIEXPORT void JNICALL Java_com_gpac_Osmo4_MPEGVSensor_sendData( JNIEnv* env, jobject thiz, jint ptr, jstring data);
+
+static JavaVM* javaVM = 0;
+static jclass sensCtrlClass;
+static jmethodID cid;
+static jmethodID startSensor;
+static jmethodID stopSensor;
+
+#ifndef GPAC_STATIC_MODULES
+
+//----------------------------------------------------------------------
+jint JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+	JNIEnv* env = 0;
+	javaVM = vm;
+
+	if ( (*javaVM)->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
+		return -1;
+
+	// Get the class and its methods in the main env
+
+	// Get the CameraController class
+	// This is just a local refenrece. Cannot be used in the other JNI calls.
+	sensCtrlClass = (*env)->FindClass(env, "io/gpac/gpac/MPEGVSensor");
+	if (sensCtrlClass == 0)
+	{
+		LOGE("MPEG-V_IN Class MPEGVSensor not found\n");
+		return -1;
+	}
+
+	// Get Global Reference to be able to use the class
+	sensCtrlClass = (*env)->NewGlobalRef(env, sensCtrlClass);
+	if ( sensCtrlClass == 0 )
+	{
+		LOGE("MPEG-V_IN Caanot create Global Reference\n");
+		return -1;
+	}
+
+	// Get the method ID for the CameraController constructor.
+	cid = (*env)->GetMethodID(env, sensCtrlClass, "<init>", "()V");
+	if (cid == 0)
+	{
+		LOGE("MPEG-V_IN MPEGVSensor Constructor not found\n");
+		return -1;
+	}
+
+	// Get startCamera() method from class CameraController
+	startSensor = (*env)->GetMethodID(env, sensCtrlClass, "startSensor", "(II)V");
+	if (startSensor == 0)
+	{
+		LOGE("MPEG-V_IN Function startSensor not found\n");
+		return -1;
+	}
+
+	stopSensor = (*env)->GetMethodID(env, sensCtrlClass, "stopSensor", "()V");
+	if (stopSensor == 0)
+	{
+		LOGE("MPEG-V_IN Function stopSensor not found\n");
+		return -1;
+	}
+
+	return JNI_VERSION_1_2;
+}
+
+void JNI_OnUnload(JavaVM *vm, void *reserved)
+{
+	JNIEnv* env = 0;
+
+	if ( (*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_2) != JNI_OK )
+		return;
+
+	(*env)->DeleteGlobalRef(env, sensCtrlClass);
+}
+
+//----------------------------------------------------------------------
+JavaVM* GetJavaVM()
+{
+	return javaVM;
+}
+//----------------------------------------------------------------------
+#else
+JavaVM* GetJavaVM();
+JNIEnv* GetEnv();
+
+#endif
+
+typedef struct
+{
+	char sensor50;
+	u16 sensorAndroidType;
+	u8 isAttached;
+
+	GF_Thread *trd;
+	u8 stop;
+
+	JNIEnv* env;
+	jclass sensCtrlClass;
+	jmethodID cid;
+	jobject sensCtrlObj;
+	jmethodID startSensor;
+	jmethodID stopSensor;
+} MPEGVSensorContext;
+
+#define MPEGVSCTX	MPEGVSensorContext *rc = (MPEGVSensorContext *)dr->udta
+
+void unloadSensorController(MPEGVSensorContext *rc)
+{
+	if ( rc->isAttached )
+	{
+		(*rc->env)->PopLocalFrame(rc->env, NULL);
+		(*GetJavaVM())->DetachCurrentThread(GetJavaVM());
+		rc->isAttached = 0;
+	}
+
+	rc->env = NULL;
+}
+
+void loadSensorControler(MPEGVSensorContext *rc)
+{
+	JNIEnv* env = NULL;
+	jint res = 0;
+
+	// Here we can be in a thread
+
+	res = (*GetJavaVM())->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_2);
+	if ( res == JNI_EDETACHED )
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN The current thread is not attached to the VM, assuming native thread\n"));
+		res = (*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
+		if ( res )
+		{
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Attach current thread failed: %d\n", res));
+			return;
+		}
+		rc->isAttached = 1;
+		(*env)->PushLocalFrame(env, 2);
+	}
+	else if ( res == JNI_EVERSION )
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN The specified version is not supported\n"));
+		return;
+	}
+
+	rc->env = env;
+	rc->sensCtrlClass = sensCtrlClass;
+	rc->cid = cid;
+	rc->startSensor = startSensor;
+	rc->stopSensor = stopSensor;
+
+	// Create the sensor object in the thread
+	rc->sensCtrlObj = (*rc->env)->NewObject(rc->env, rc->sensCtrlClass, rc->cid);
+	if (rc->sensCtrlObj == 0)
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Cannot create MPEGVSensor object\n"));
+		return;
+	}
+}
+
+Bool MPEGVS_RegisterDevice(struct __input_device *dr, const char *urn, const char *dsi, u32 dsi_size, void (*AddField)(struct __input_device *_this, u32 fieldType, const char *name))
+{
+	MPEGVSCTX;
+
+	//"MPEG-V:siv:OrientationSensorType"
+
+	if ( strnicmp(urn, "MPEG-V", 6) )
+		return 0;
+
+	if ( strlen(urn) <= 6 )
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("MPEG-V No sensor type specified\n"));
+		return 0;
+	}
+
+	if ( strnicmp(urn+6, ":siv:", 5) )
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("MPEG-V Not valid sensor type specified\n"));
+		return 0;
+	}
+
+	strcpy(rc->sensor, urn+11);
+
+	if ( !strcmp(rc->sensor, "OrientationSensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFVEC3F, "Orientation");
+
+		rc->sensorAndroidType = 3;
+
+		return 1;
+	}
+	else if ( !strcmp(rc->sensor, "AccelerationSensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFVEC3F, "Acceleration");
+
+		rc->sensorAndroidType = 1;
+
+		return 1;
+	}
+	else if ( !strcmp(rc->sensor, "AngularVelocitySensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFVEC3F, "AngularVelocity");
+
+		rc->sensorAndroidType = 4;
+
+		return 1;
+	}
+	else if ( !strcmp(rc->sensor, "MagneticFieldSensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFVEC3F, "MagneticField");
+
+		rc->sensorAndroidType = 2;
+
+		return 1;
+	}
+	else if ( !strcmp(rc->sensor, "LightSensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFFLOAT, "Light");
+
+		rc->sensorAndroidType = 5;
+
+		return 1;
+	}
+	else if ( !strcmp(rc->sensor, "AtmosphericPressureSensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFFLOAT, "AtmosphericPressure");
+
+		rc->sensorAndroidType = 6;
+
+		return 1;
+	}
+	else if ( !strcmp(rc->sensor, "RotationVectorSensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFVEC3F, "RotationVector");
+
+		rc->sensorAndroidType = 11;
+
+		return 1;
+	}
+	else if ( !strcmp(rc->sensor, "GlobalPositionSensorType") )
+	{
+		AddField(dr, GF_SG_VRML_SFVEC3F, "Position");
+		AddField(dr, GF_SG_VRML_SFFLOAT, "Accuracy");
+		AddField(dr, GF_SG_VRML_SFFLOAT, "Bearing");
+
+		rc->sensorAndroidType = 100;
+
+		return 1;
+	}
+	else
+	{
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("MPEG-V_IN Unsupported sensor type: %s\n", rc->sensor));
+		return 0;
+	}
+}
+
+u32 MPEGVS_OnData(struct __input_device * dr, const char* data)
+{
+	GF_BitStream *bs;
+	u8 *buf;
+	u32 buf_size;
+	float x, y, z, /*q,*/ a, b;
+	MPEGVSCTX;
+
+	bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+
+	if ( rc->sensorAndroidType == 1
+	 || rc->sensorAndroidType == 2
+	 || rc->sensorAndroidType == 3
+	 || rc->sensorAndroidType == 4 )
+	{
+		sscanf(data, "%f;%f;%f;", &x, &y, &z);
+		gf_bs_write_int(bs, 1, 1);
+		gf_bs_write_float(bs, x);
+		gf_bs_write_float(bs, y);
+		gf_bs_write_float(bs, z);
+	}
+	else if ( rc->sensorAndroidType == 5
+	 || rc->sensorAndroidType == 6 )
+	{
+		sscanf(data, "%f;", &x);
+
+		gf_bs_write_int(bs, 1, 1);
+		gf_bs_write_float(bs, x);
+	}
+	else if ( rc->sensorAndroidType == 11 )
+	{
+		sscanf(data, "%f;%f;%f;", &x, &y, &z);
+
+		gf_bs_write_int(bs, 1, 1);
+		gf_bs_write_float(bs, x);
+		gf_bs_write_float(bs, y);
+		gf_bs_write_float(bs, z);
+		/*gf_bs_write_float(bs, q);*/
+	}
+	else if ( rc->sensorAndroidType == 100 )
+	{
+		sscanf(data, "%f;%f;%f;%f;%f;", &x, &y, &z, &a, &b);
+
+		gf_bs_write_int(bs, 1, 1);
+		gf_bs_write_float(bs, x);
+		gf_bs_write_float(bs, y);
+		gf_bs_write_float(bs, z);
+		gf_bs_write_int(bs, 1, 1);
+		gf_bs_write_float(bs, a);
+		gf_bs_write_int(bs, 1, 1);
+		gf_bs_write_float(bs, b);
+		/*gf_bs_write_float(bs, q);*/
+	}
+
+	gf_bs_align(bs);
+	gf_bs_get_content(bs, &buf, &buf_size);
+	gf_bs_del(bs);
+
+	dr->DispatchFrame(dr, (u8*)buf, buf_size);
+	gf_free(buf);
+
+	return GF_OK;
+}
+
+JNIEXPORT void Java_com_gpac_Osmo4_MPEGVSensor_sendData( JNIEnv* env, jobject thiz, jint ptr, jstring data)
+{
+	jboolean isCopy;
+	const char * cData = (*env)->GetStringUTFChars(env, data, &isCopy);
+
+	MPEGVS_OnData((struct __input_device *)ptr, cData);
+
+	(*env)->ReleaseStringUTFChars(env, data, cData);
+}
+
+u32 ThreadRun(void* param)
+{
+	struct __input_device * dr = (struct __input_device *)param;
+	MPEGVSCTX;
+
+	GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Start: %d\n", gf_th_id()));
+
+	loadSensorControler(rc);
+
+	if (!rc->env || !rc->sensCtrlObj)
+		return GF_OK;
+
+	(*rc->env)->CallNonvirtualVoidMethod(rc->env, rc->sensCtrlObj, rc->sensCtrlClass, rc->startSensor, (s32)dr, rc->sensorAndroidType);
+
+	while (!rc->stop)
+		gf_sleep(10);
+
+	GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("MPEG-V_IN Stop: %d\n", gf_th_id()));
+
+	if (!rc->env)
+		return GF_OK;
+
+	if ( rc->sensCtrlObj )
+	{
+		(*rc->env)->CallNonvirtualVoidMethod(rc->env, rc->sensCtrlObj, rc->sensCtrlClass, rc->stopSensor);
+
+		(*rc->env)->DeleteLocalRef( rc->env, rc->sensCtrlObj );
+	}
+
+	unloadSensorController(rc);
+	return GF_OK;
+}
+
+void MPEGVS_Start(struct __input_device * dr)
+{
+	MPEGVSCTX;
+
+	rc->trd = gf_th_new("MPEG-V_IN");
+	gf_th_run(rc->trd, ThreadRun, dr);
+}
+
+void MPEGVS_Stop(struct __input_device * dr)
+{
+	MPEGVSCTX;
+
+	if ( rc->trd )
+	{
+		rc->stop = 1;
+		while ( gf_th_status(rc->trd) == GF_THREAD_STATUS_RUN )
+			gf_sleep(5);
+
+		gf_th_del(rc->trd);
+		rc->trd = NULL;
+		rc->stop = 0;
+	}
+}
+
+GF_InputSensorDevice* NewMPEGVSInputSesor()
+{
+	MPEGVSensorContext* ctx;
+	GF_InputSensorDevice* driv;
+
+	driv = (GF_InputSensorDevice *) gf_malloc(sizeof(GF_InputSensorDevice));
+	memset(driv, 0, sizeof(GF_InputSensorDevice));
+	GF_REGISTER_MODULE_INTERFACE(driv, GF_INPUT_DEVICE_INTERFACE, "MPEG-V Sensors Input Module", "gpac distribution");
+
+	driv->RegisterDevice = MPEGVS_RegisterDevice;
+	driv->Start = MPEGVS_Start;
+	driv->Stop = MPEGVS_Stop;
+
+	ctx = (MPEGVSensorContext*) gf_malloc (sizeof(MPEGVSensorContext));
+	memset(ctx, 0, sizeof(MPEGVSensorContext));
+
+	driv->udta = (void*)ctx;
+
+	return driv;
+}
+
+void DeleteMPEGVSInputSensor(GF_InputSensorDevice* dev)
+{
+	MPEGVS_Stop(dev);
+	gf_free(dev->udta);
+	gf_free(dev);
+}
+
+/*interface query*/
+GPAC_MODULE_EXPORT
+const u32 *QueryInterfaces()
+{
+	static u32 si = {
+		GF_INPUT_DEVICE_INTERFACE,
+		0
+	};
+	return si;
+}
+
+/*interface create*/
+GPAC_MODULE_EXPORT
+GF_BaseInterface *LoadInterface(u32 InterfaceType)
+{
+	if (InterfaceType == GF_INPUT_DEVICE_INTERFACE) return (GF_BaseInterface *) NewMPEGVSInputSesor();
+	return NULL;
+}
+
+/*interface destroy*/
+GPAC_MODULE_EXPORT
+void ShutdownInterface(GF_BaseInterface *ifce)
+{
+	switch (ifce->InterfaceType) {
+	case GF_INPUT_DEVICE_INTERFACE:
+		DeleteMPEGVSInputSensor((GF_InputSensorDevice *)ifce);
+		break;
+	}
+}
+
+GPAC_MODULE_STATIC_DECLARATION( droid_mpegv )

gpac-2.2.0.tar.gz/modules/deprecated/droid_mpegv/gm_droid_mpegv.mk Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_cam Added

gpac-2.2.0.tar.gz/modules/deprecated/ios_cam/CameraObject.h Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_cam/CameraObject.m Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_cam/cam_wrap.h Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_cam/cam_wrap.m Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_cam/ios_cam.c Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_mpegv Added

gpac-2.2.0.tar.gz/modules/deprecated/ios_mpegv/SensorAcces.m Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_mpegv/SensorAccess.h Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_mpegv/ios_mpegv-Prefix.pch Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_mpegv/ios_mpegv.c Changed

gpac-2.2.0.tar.gz/modules/deprecated/ios_mpegv/sensor_wrap.h Changed

gpac-2.2.0.tar.gz/modules/deprecated/old_arch/osd/gm_osd.mk Changed

gpac-2.2.0.tar.gz/modules/deprecated/old_arch/widgetman/gm_widgetman.mk Added

gpac-2.0.0.tar.gz/modules/deprecated/old_arch/widgetman/widgetman.c -> gpac-2.2.0.tar.gz/modules/deprecated/old_arch/widgetman/widgetman.c Changed

gpac-2.0.0.tar.gz/modules/directfb_out/directfb_out.c -> gpac-2.2.0.tar.gz/modules/directfb_out/directfb_out.c Changed

@@ -46,49 +46,19 @@
 	// initialisation and surface creation
 	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DirectFB Initialization\n"));
 	// check window mode used - SDL or X11
-	{
-		WINDOW_MODE window_mode = 0;
-		opt = gf_opts_get_key("DirectFB", "WindowMode");
-		if (!opt) gf_opts_set_key("DirectFB", "WindowMode", "X11");
-		if (!opt || !strcmp(opt, "X11")) window_mode = WINDOW_X11;
-		else if (!strcmp(opt, "SDL")) window_mode = WINDOW_SDL;
-		DirectFBVid_InitAndCreateSurface(ctx, window_mode);
-	}
-
-	// check hardware accelerator configuration
-	DirectFBVid_CtxSetDisableAcceleration(ctx, 0);
-	opt = gf_opts_get_key("DirectFB", "DisableAcceleration");
-	if (!opt) gf_opts_set_key("DirectFB", "DisableAcceleration", "no");
-	if (opt && !strcmp(opt, "yes")) DirectFBVid_CtxSetDisableAcceleration(ctx, 1);
-
-	// check for display configuration
-	DirectFBVid_CtxSetDisableDisplay(ctx, 0);
-	opt = gf_opts_get_key("DirectFB", "DisableDisplay");
-	if (!opt) gf_opts_set_key("DirectFB", "DisableDisplay", "no");
-	if (opt && !strcmp(opt, "yes")) DirectFBVid_CtxSetDisableDisplay(ctx, 1);
+	opt = gf_opts_get_key("core", "dfb-sys");
+	DirectFBVid_InitAndCreateSurface(ctx, opt);
 
 	// set flip mode
-	{
-		FLIP_MODE flip_mode = 0;
-		opt = gf_opts_get_key("DirectFB", "FlipSyncMode");
-		if (!opt) gf_opts_set_key("DirectFB", "FlipSyncMode", "waitsync");
-		if (!opt || !strcmp(opt, "waitsync")) flip_mode |= FLIP_WAITFORSYNC;
-		else if (!strcmp(opt, "wait")) flip_mode |= FLIP_WAIT;
-		else if (!strcmp(opt, "sync")) flip_mode |= FLIP_ONSYNC;
-		else if (!strcmp(opt, "swap")) flip_mode |= FLIP_SWAP;
-
-		DirectFBVid_CtxSetFlipMode(ctx, flip_mode);
-	}
+	FLIP_MODE flip_mode = 0;
+	opt = gf_opts_get_key("core", "dfb-flip");
+	if (!opt) gf_opts_set_key("core", "dfb-flip", "waitsync");
+	if (!opt || !strcmp(opt, "waitsync")) flip_mode = FLIP_WAITFORSYNC;
+	else if (!strcmp(opt, "wait")) flip_mode = FLIP_WAIT;
+	else if (!strcmp(opt, "sync")) flip_mode = FLIP_ONSYNC;
+	else if (!strcmp(opt, "swap")) flip_mode = FLIP_SWAP;
 
-	// enable/disable blit
-	opt = gf_opts_get_key("DirectFB", "DisableBlit");
-	if (!opt) gf_opts_set_key("DirectFB", "DisableBlit", "no");
-	if (opt && !strcmp(opt, "all")) {
-		driv->hw_caps &= ~(GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA | GF_VIDEO_HW_HAS_YUV);
-	}
-	else if (opt && !strcmp(opt, "yuv")) driv->hw_caps &= ~GF_VIDEO_HW_HAS_YUV;
-	else if (opt && !strcmp(opt, "rgb")) driv->hw_caps &= ~GF_VIDEO_HW_HAS_RGB;
-	else if (opt && !strcmp(opt, "rgba")) driv->hw_caps &= ~GF_VIDEO_HW_HAS_RGBA;
+	DirectFBVid_CtxSetFlipMode(ctx, flip_mode);
 
 	// end of initialization
 	DirectFBVid_CtxSetIsInit(ctx, 1);
@@ -122,9 +92,6 @@
 {
 	DirectFBVID();
 	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DirectFB Flipping backbuffer\n"));
-	// if display is disabled, nothing to be done
-	if (DirectFBVid_CtxGetDisableDisplay(ctx)) return GF_OK;
-
 	return DirectFBVid_CtxPrimaryFlip(ctx);
 }

gpac-2.0.0.tar.gz/modules/directfb_out/directfb_out.h -> gpac-2.2.0.tar.gz/modules/directfb_out/directfb_out.h Changed

@@ -29,8 +29,12 @@
 typedef struct __DirectFBVidCtx DirectFBVidCtx;
 
 typedef enum {
-	WINDOW_X11 = 1,
-	WINDOW_SDL = 1 << 1,
+	WINDOW_X11 = 0,
+	WINDOW_SDL,
+	WINDOW_VNC,
+	WINDOW_OSX,
+	WINDOW_FBDEV,
+	WINDOW_DEVMEM,
 } WINDOW_MODE;
 
 typedef enum {
@@ -47,7 +51,7 @@
 u32 DirectFBVid_TranslatePixelFormatToGPAC(u32 dfbpf);
 u32 DirectFBVid_TranslatePixelFormatFromGPAC(u32 gpacpf);
 size_t DirectFBVid_GetCtxSizeOf(void);
-void DirectFBVid_InitAndCreateSurface(DirectFBVidCtx *ctx, WINDOW_MODE window_mode);
+void DirectFBVid_InitAndCreateSurface(DirectFBVidCtx *ctx, char *dfb_system);
 void DirectFBVid_CtxSetFlipMode(DirectFBVidCtx *ctx, FLIP_MODE flip_mode);
 void DirectFBVid_CtxPrimaryProcessGetAccelerationMask(DirectFBVidCtx *ctx);
 u32 DirectFBVid_ProcessMessageQueueWrapper(DirectFBVidCtx *ctx, u8 *type, u32 *flags, u32 *key_code, s32 *x, s32 *y, u32 *button);
@@ -62,10 +66,6 @@
 u32 DirectFBVid_CtxGetPixelFormat(DirectFBVidCtx *ctx);
 Bool DirectFBVid_CtxIsHwMemory(DirectFBVidCtx *ctx);
 u32 DirectFBVid_CtxPrimaryFlip(DirectFBVidCtx *ctx);
-void DirectFBVid_CtxSetDisableDisplay(DirectFBVidCtx *ctx, Bool val);
-Bool DirectFBVid_CtxGetDisableDisplay(DirectFBVidCtx *ctx);
-void DirectFBVid_CtxSetDisableAcceleration(DirectFBVidCtx *ctx, Bool val);
-Bool DirectFBVid_CtxGetDisableAcceleration(DirectFBVidCtx *ctx);
 void DirectFBVid_CtxSetIsInit(DirectFBVidCtx *ctx, Bool val);
 u32 DirectFBVid_ShutdownWrapper(DirectFBVidCtx *ctx);
 u32 DirectFBVid_BlitWrapper(DirectFBVidCtx *ctx, u32 video_src_width, u32 video_src_height, u32 video_src_pixel_format, char *video_src_buffer, s32 video_src_pitch_y, u32 src_wnd_x, u32 src_wnd_y, u32 src_wnd_w, u32 src_wnd_h, u32 dst_wnd_x, u32 dst_wnd_y, u32 dst_wnd_w, u32 dst_wnd_h, u32 overlay_type);

gpac-2.0.0.tar.gz/modules/directfb_out/directfb_wrapper.c -> gpac-2.2.0.tar.gz/modules/directfb_out/directfb_wrapper.c Changed

@@ -66,7 +66,7 @@
 
 	/* screen width, height */
 	u32 width, height, pixel_format;
-	Bool use_systems_memory, disable_acceleration, disable_aa, is_init, disable_display;
+	Bool use_systems_memory, disable_aa, is_init;
 
 	/* acceleration */
 	int accel_drawline, accel_fillrect;
@@ -196,7 +196,7 @@
  * 	- initialize and create DirectFB surface
  **/
 u32 DirectFBVid_TranslatePixelFormatToGPAC(u32 dfbpf);
-void DirectFBVid_InitAndCreateSurface(DirectFBVidCtx *ctx, u32 window_mode)
+void DirectFBVid_InitAndCreateSurface(DirectFBVidCtx *ctx, char *dfb_system)
 {
 	DFBResult err;
 	DFBSurfaceDescription dsc;
@@ -210,12 +210,11 @@
 		char *argv_ro2;
 		//http://directfb.org/wiki/index.php/Configuring_DirectFB
 		argv_ro0=argv0=strdup("gpac");
-		// graphis system used is X11
-		if (window_mode == WINDOW_SDL) {
-			argv_ro1=argv1=strdup("--dfb:system=sdl");
-		} else {
-			argv_ro1=argv1=strdup("--dfb:system=x11");
-		}
+		char dev_name100;
+		snprintf(dev_name, 99, "--dfb:system=%s", dfb_system ? dfb_system : "x11");
+		dev_name99=0;
+		strlwr(dev_name);
+		argv_ro1 = argv1 = strdup(dev_name);
 
 		// screen resolution 640x480
 		//~ argv_ro2=argv2=strdup("--dfb:mode=640x480");
@@ -342,46 +341,6 @@
 
 
 /**
- *	function DirectFBVid_CtxSetDisableDisplay
- * 	- set disable display value
- **/
-void DirectFBVid_CtxSetDisableDisplay(DirectFBVidCtx *ctx, Bool val)
-{
-	ctx->disable_display = val;
-}
-
-
-/**
- *	function DirectFBVid_CtxGetDisableDisplay
- * 	- boolean showing whether display is enabled/disabled
- **/
-Bool DirectFBVid_CtxGetDisableDisplay(DirectFBVidCtx *ctx)
-{
-	return ctx->disable_display;
-}
-
-
-/**
- *	function DirectFBVid_CtxSetDisableAcceleration
- * 	- boolean showing whether hardware accelerator is enabled/disabled
- **/
-void DirectFBVid_CtxSetDisableAcceleration(DirectFBVidCtx *ctx, Bool val)
-{
-	ctx->disable_acceleration = val;
-}
-
-
-/**
- *	function DirectFBVid_CtxGetDisableAcceleration
- * 	- return disable_acceleration value
- **/
-Bool DirectFBVid_CtxGetDisableAcceleration(DirectFBVidCtx *ctx)
-{
-	return ctx->disable_acceleration;
-}
-
-
-/**
  *	function DirectFBVid_CtxSetIsInit
  * 	- boolean showing whether DirectFB is initialized
  **/
@@ -463,7 +422,6 @@
 	DFBRectangle dfbsrc, dfbdst;
 
 	if (overlay_type != 0) return 1;
-	if (ctx->disable_display) return 0;
 
 	memset(&srcdesc, 0, sizeof(srcdesc));

gpac-2.0.0.tar.gz/modules/droid_audio/droidaudio.c -> gpac-2.2.0.tar.gz/modules/droid_audio/droidaudio.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Ivica Arsov, Jean Le Feuvre
- *			Copyright (c) Mines-Telecom 2009-
+ *			Copyright (c) Mines-Telecom 2009-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Wrapper
@@ -55,37 +55,10 @@
 
 static const char android_device = "Android Default";
 
-static jclass cAudioTrack = NULL;
-static jobject mtrack = NULL;
-
-static jmethodID mAudioTrack;
-static jmethodID setStereoVolume;
-static jmethodID mGetMinBufferSize;
-static jmethodID mPlay;
-static jmethodID mStop;
-static jmethodID mRelease;
-static jmethodID mWriteB;
-static jmethodID mWriteS;
-static jmethodID mFlush;
-
-#include <android/log.h>
-#define TAG "GPAC Android Audio"
-#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
-#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__)
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
-
-
-/* Uncomment the next line if you want to debug */
-/* #define DROID_EXTREME_LOGS */
-
 typedef struct
 {
 	JNIEnv* env;
 
-	jobject mtrack;
-
 	u32 num_buffers;
 
 	u32 delay, total_length_ms;
@@ -100,16 +73,29 @@
 	u32 volume;
 	u32 pan;
 	jarray buff;
+
+	//JNI vars - do NOT use static vars since we may load/unload the module at run time
+	jclass class_AudioTrack;
+	jobject obj_AudioTrack;
+	jmethodID fun_AudioTrack;
+	jmethodID fun_setStereoVolume;
+	jmethodID fun_GetMinBufferSize;
+	jmethodID fun_Play;
+	jmethodID fun_Stop;
+	jmethodID fun_Release;
+	jmethodID fun_WriteB;
+	jmethodID fun_WriteS;
+	jmethodID fun_Flush;
 } DroidContext;
 
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
+
 // Called by the main thread
-static GF_Err WAV_Setup(GF_AudioOutput *dr, void *os_handle, u32 num_buffers, u32 total_duration)
+static GF_Err AAOut_Setup(GF_AudioOutput *dr, void *os_handle, u32 num_buffers, u32 total_duration)
 {
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 	JNIEnv* env = GetEnv();
-	LOGV("Android Audio Setup for %d buffers", num_buffers);
+
+	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("AndroidAudio Setup for %d buffers", num_buffers ));
 
 	ctx->force_config = (num_buffers && total_duration) ? 1 : 0;
 	ctx->cfg_num_buffers = num_buffers;
@@ -119,113 +105,96 @@
 	ctx->volume = 100;
 	ctx->pan = 50;
 
-	if (!cAudioTrack) {
-		cAudioTrack = (*env)->FindClass(env, "android/media/AudioTrack");
-		if (!cAudioTrack) {
-			return GF_NOT_SUPPORTED;
-		}
+	if (ctx->class_AudioTrack) return GF_OK;
 
-		cAudioTrack = (*env)->NewGlobalRef(env, cAudioTrack);
-
-		mAudioTrack = (*env)->GetMethodID(env, cAudioTrack, "<init>", "(IIIIII)V");
-		mGetMinBufferSize = (*env)->GetStaticMethodID(env, cAudioTrack, "getMinBufferSize", "(III)I");
-		mPlay = (*env)->GetMethodID(env, cAudioTrack, "play", "()V");
-		mStop = (*env)->GetMethodID(env, cAudioTrack, "stop", "()V");
-		mRelease = (*env)->GetMethodID(env, cAudioTrack, "release", "()V");
-		mWriteB = (*env)->GetMethodID(env, cAudioTrack, "write", "(BII)I");
-		mWriteS = (*env)->GetMethodID(env, cAudioTrack, "write", "(SII)I");
-		mFlush = (*env)->GetMethodID(env, cAudioTrack, "flush", "()V");
-		setStereoVolume = (*env)->GetMethodID(env, cAudioTrack, "setStereoVolume", "(FF)I");
+	ctx->class_AudioTrack = (*env)->FindClass(env, "android/media/AudioTrack");
+	if (!ctx->class_AudioTrack) {
+		return GF_NOT_SUPPORTED;
 	}
 
+	ctx->class_AudioTrack = (*env)->NewGlobalRef(env, ctx->class_AudioTrack);
+
+	ctx->fun_AudioTrack = (*env)->GetMethodID(env, ctx->class_AudioTrack, "<init>", "(IIIIII)V");
+	ctx->fun_GetMinBufferSize = (*env)->GetStaticMethodID(env, ctx->class_AudioTrack, "getMinBufferSize", "(III)I");
+	ctx->fun_Play = (*env)->GetMethodID(env, ctx->class_AudioTrack, "play", "()V");
+	ctx->fun_Stop = (*env)->GetMethodID(env, ctx->class_AudioTrack, "stop", "()V");
+	ctx->fun_Release = (*env)->GetMethodID(env, ctx->class_AudioTrack, "release", "()V");
+	ctx->fun_WriteB = (*env)->GetMethodID(env, ctx->class_AudioTrack, "write", "(BII)I");
+	ctx->fun_WriteS = (*env)->GetMethodID(env, ctx->class_AudioTrack, "write", "(SII)I");
+	ctx->fun_Flush = (*env)->GetMethodID(env, ctx->class_AudioTrack, "flush", "()V");
+	ctx->fun_setStereoVolume = (*env)->GetMethodID(env, ctx->class_AudioTrack, "setStereoVolume", "(FF)I");
 	return GF_OK;
 }
-//----------------------------------------------------------------------
+
 // Called by the audio thread
-static void WAV_Shutdown(GF_AudioOutput *dr)
+static void AAOut_Shutdown(GF_AudioOutput *dr)
 {
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 	JNIEnv* env = NULL;
 	jint res = 0;
 
-	LOGV("Android Audio Shutdown START.");
+	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("AndroidAudio Shutdown" ));
 
 	res = (*GetJavaVM())->GetEnv(GetJavaVM(), (void**)&env, JNI_VERSION_1_2);
 	if ( res == JNI_EDETACHED ) {
 		(*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
 	}
 
-	(*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mStop);
-	(*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mRelease);
+	(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Stop);
+	(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Release);
 
 	(*env)->PopLocalFrame(env, NULL);
 
 	(*env)->DeleteGlobalRef(env, ctx->buff);
-	(*env)->DeleteGlobalRef(env, mtrack);
-	(*env)->DeleteGlobalRef(env, cAudioTrack);
+	(*env)->DeleteGlobalRef(env, ctx->obj_AudioTrack);
+	(*env)->DeleteGlobalRef(env, ctx->class_AudioTrack);
 
 	//if ( res == JNI_EDETACHED ) {
 	(*GetJavaVM())->DetachCurrentThread(GetJavaVM());
 	//}
-
-	LOGV("Android Audio Shutdown DONE.");
 }
 
 
-/*we assume what was asked is what we got*/
 /* Called by the audio thread */
-static GF_Err WAV_ConfigureOutput(GF_AudioOutput *dr, u32 *SampleRate, u32 *NbChannels, u32 *nbBitsPerSample, u64 channel_cfg)
+static GF_Err AAOut_ConfigureOutput(GF_AudioOutput *dr, u32 *SampleRate, u32 *NbChannels, u32 *nbBitsPerSample, u64 channel_cfg)
 {
 	JNIEnv* env = NULL;
-	u32 i;
+	u32 bytes_per_samp;
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 
-	LOGI("Android Audio Configure Output for %u channels...", *NbChannels);
-
 	if (!ctx) return GF_BAD_PARAM;
 
 	ctx->sampleRateInHz = *SampleRate;
-	ctx->channelConfig = (*NbChannels == 1) ? CHANNEL_CONFIGURATION_MONO : CHANNEL_CONFIGURATION_STEREO; //AudioFormat.CHANNEL_CONFIGURATION_MONO
-	ctx->audioFormat = (*nbBitsPerSample == 8)? ENCODING_PCM_8BIT : ENCODING_PCM_16BIT; //AudioFormat.ENCODING_PCM_16BIT
+	ctx->channelConfig = (*NbChannels == 1) ? CHANNEL_CONFIGURATION_MONO : CHANNEL_CONFIGURATION_STEREO;
+	ctx->audioFormat = (*nbBitsPerSample == 8) ? ENCODING_PCM_8BIT : ENCODING_PCM_16BIT;
 
 	// Get the java environment in the new thread
 	(*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
 	ctx->env = env;
-	LOGV("Android Audio SampleRate : %d",ctx->sampleRateInHz);
-	LOGV("Android Audio BitPerSample : %d", *nbBitsPerSample);
 
 	(*env)->PushLocalFrame(env, 2);
 
 	ctx->num_buffers = 1;
-	ctx->mbufferSizeInBytes = (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
+	ctx->mbufferSizeInBytes = (*env)->CallStaticIntMethod(env, ctx->class_AudioTrack, ctx->fun_GetMinBufferSize,
 	 ctx->sampleRateInHz, ctx->channelConfig, ctx->audioFormat);
 
-	//ctx->mbufferSizeInBytes *= 3;
+	bytes_per_samp = 1;
+	if (ctx->channelConfig == CHANNEL_CONFIGURATION_STEREO) bytes_per_samp *= 2;
+	if (ctx->audioFormat == ENCODING_PCM_16BIT) bytes_per_samp *= 2;
 
-	LOGV("Android Audio Buffer Size : %d", ctx->mbufferSizeInBytes);
+	ctx->total_length_ms = 1000 * ctx->num_buffers * ctx->mbufferSizeInBytes / bytes_per_samp / ctx->sampleRateInHz;
 
-	i = 1;
-	if ( ctx->channelConfig == CHANNEL_CONFIGURATION_STEREO )
-		i *= 2;
-	if ( ctx->audioFormat == ENCODING_PCM_16BIT )
-		i *= 2;
-
-	ctx->total_length_ms = 1000 * ctx->num_buffers * ctx->mbufferSizeInBytes / i / ctx->sampleRateInHz;
-
-	LOGV("Android Audio Buffer Length ms : %d", ctx->total_length_ms);
+	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("AndroidAudio Configure Output for %u Hz %u channels - Buffer size %u ms", ctx->sampleRateInHz, *NbChannels, ctx->total_length_ms));
 
 	/*initial delay is full buffer size*/
 	ctx->delay = ctx->total_length_ms;
 
-	mtrack = (*env)->NewObject(env, cAudioTrack, mAudioTrack, STREAM_MUSIC, ctx->sampleRateInHz,
+	ctx->obj_AudioTrack = (*env)->NewObject(env, ctx->class_AudioTrack, ctx->fun_AudioTrack, STREAM_MUSIC, ctx->sampleRateInHz,
 	 ctx->channelConfig, ctx->audioFormat, ctx->mbufferSizeInBytes, MODE_STREAM); //AudioTrack.MODE_STREAM
-	if (mtrack) {
-		mtrack = (*env)->NewGlobalRef(env, mtrack);
-		ctx->mtrack = mtrack;
-		(*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mPlay);
-//	 (*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mStop);
+	if (ctx->obj_AudioTrack) {
+		ctx->obj_AudioTrack = (*env)->NewGlobalRef(env, ctx->obj_AudioTrack);
+		(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Play);
 	} else {
-		LOGV("Android Audio mtrack = %p", mtrack);
 		return GF_NOT_SUPPORTED;
 	}
 
@@ -233,98 +202,84 @@
 		ctx->buff = (*env)->NewByteArray(env, ctx->mbufferSizeInBytes);
 	else
 		ctx->buff = (*env)->NewShortArray(env, ctx->mbufferSizeInBytes/2);
-	if ( ctx->buff ) {
+
+	if (ctx->buff) {
 		ctx->buff = (*env)->NewGlobalRef(env, ctx->buff);
 	} else {
-		LOGV("Android Audio ctx->buff = %p", ctx->buff );
 		return GF_NOT_SUPPORTED;
 	}
-
-	LOGV("Android Audio ConfigureOutput DONE.");
 	return GF_OK;
 }
 
 /* Called by the audio thread */
-static void WAV_WriteAudio(GF_AudioOutput *dr)
+static void AAOut_WriteAudio(GF_AudioOutput *dr)
 {
-	DroidContext *ctx = (DroidContext *)dr->opaque;
-	if (!ctx)
-		return;
-	JNIEnv* env = ctx->env;
 	u32 written;
 	void* pBuffer;
-	if (!env)
-		return;
-#ifdef DROID_EXTREME_LOGS
-	LOGV("Android Audio WAV_WriteAudio() : entering",ctx->sampleRateInHz);
-#endif /* DROID_EXTREME_LOGS */
+	DroidContext *ctx = (DroidContext *)dr->opaque;
+	if (!ctx) return;
+	JNIEnv* env = ctx->env;
+	if (!env) return;
 
-	if ( ctx->audioFormat == ENCODING_PCM_8BIT )
+	if (ctx->audioFormat == ENCODING_PCM_8BIT)
 		pBuffer = (*env)->GetByteArrayElements(env, ctx->buff, NULL);
 	else
 		pBuffer = (*env)->GetShortArrayElements(env, ctx->buff, NULL);
 
-	if (pBuffer)
-	{
+	if (pBuffer) {
 		written = dr->FillBuffer(dr->audio_renderer, pBuffer, ctx->mbufferSizeInBytes);
 
-		if ( ctx->audioFormat == ENCODING_PCM_8BIT )
+		if (ctx->audioFormat == ENCODING_PCM_8BIT) {
 			(*env)->ReleaseByteArrayElements(env, ctx->buff, pBuffer, 0);
-		else
+			if (written)
+				(*env)->CallNonvirtualIntMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_WriteB, ctx->buff, 0, written);
+		} else {
 			(*env)->ReleaseShortArrayElements(env, ctx->buff, pBuffer, 0);
-
-		if (written)
-		{
-			if ( ctx->audioFormat == ENCODING_PCM_8BIT )
-				(*env)->CallNonvirtualIntMethod(env, mtrack, cAudioTrack, mWriteB, ctx->buff, 0, ctx->mbufferSizeInBytes);
-			else
-				(*env)->CallNonvirtualIntMethod(env, mtrack, cAudioTrack, mWriteS, ctx->buff, 0, ctx->mbufferSizeInBytes/2);
+			if (written)
+				(*env)->CallNonvirtualIntMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_WriteS, ctx->buff, 0, written/2);
 		}
+	} else {
+		GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("AndroidAudio Failed to get pointer to array bytes"));
 	}
-	else
-	{
-		LOGV("Android Audio Failed to get pointer to array bytes = %p", pBuffer);
-	}
-#ifdef DROID_EXTREME_LOGS
-	LOGV("Android Audio WAV_WriteAudio() : done",ctx->sampleRateInHz);
-#endif /* DROID_EXTREME_LOGS */
 }
 
 /* Called by the main thread */
-static void WAV_Play(GF_AudioOutput *dr, u32 PlayType)
+static void AAOut_Play(GF_AudioOutput *dr, u32 PlayType)
 {
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 	JNIEnv* env = GetEnv();
+	if (!env) return;
 
-	LOGV("Android Audio Play: %d\n", PlayType);
-
-	switch ( PlayType )
-	{
+	switch (PlayType) {
 	case 0:
-		// Stop playing
-		(*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mStop);
-		// Clear the internal buffers
-		(*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mFlush);
+		GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("AndroidAudio Pause\n"));
+		(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Stop);
+		(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Flush);
 		break;
 	case 2:
-		(*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mFlush);
+		GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("AndroidAudio Resume\n"));
+		(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Flush);
+		(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Play);
+		break;
 	case 1:
-		(*env)->CallNonvirtualVoidMethod(env, mtrack, cAudioTrack, mPlay);
+		GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("AndroidAudio Play\n"));
+		(*env)->CallNonvirtualVoidMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_Play);
 		break;
 	default:
-		LOGW("Android Audio Unknown Play method=%d.\n", PlayType);
+		GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("AndroidAudio Unknown play method %d\n", PlayType));
+		break;
 	}
-	LOGV("Android Audio Play DONE (%d).\n", PlayType);
 }
 
-static void WAV_UpdateVolume(DroidContext *ctx) {
+static void AAOut_UpdateVolume(DroidContext *ctx)
+{
 	float lV, rV;
 	JNIEnv* env = GetEnv();
-	if (!ctx)
-		return;
-	if (ctx->pan > 100)
-		ctx->pan = 100;
-	lV =rV = ctx->volume / 100.0;
+	if (!env || !ctx->fun_setStereoVolume || !ctx->obj_AudioTrack || !ctx->class_AudioTrack) return;
+
+	if (ctx->pan > 100) ctx->pan = 100;
+
+	lV = rV = ctx->volume / 100.0;
 	if (ctx->pan > 50) {
 		float m = (100 - ctx->pan) / 50.0;
 		lV*=m;
@@ -332,91 +287,52 @@
 		float m = ctx->pan / 50.0;
 		rV*=m;
 	}
-	if (env && setStereoVolume && mtrack && cAudioTrack) {
-		int success;
-		if (0!= (success=((*env)->CallNonvirtualIntMethod(env, mtrack, cAudioTrack, setStereoVolume, lV, rV))))
-			LOGE("SetVolume(%f,%f) returned Error code %d", lV, rV, success );
-	} else {
-		LOGD("SetVolume(%f,%f)", lV, rV );
+
+	int success = (*env)->CallNonvirtualIntMethod(env, ctx->obj_AudioTrack, ctx->class_AudioTrack, ctx->fun_setStereoVolume, lV, rV);
+	if (success != 0) {
+		GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("AndroidAudio SetVolume(%f,%f) failed with error %d", lV, rV, success));
 	}
 }
 
-static void WAV_SetVolume(GF_AudioOutput *dr, u32 Volume) {
+static void AAOut_SetVolume(GF_AudioOutput *dr, u32 Volume)
+{
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 	ctx->volume = Volume;
-	WAV_UpdateVolume(ctx);
+	AAOut_UpdateVolume(ctx);
 }
 
-static void WAV_SetPan(GF_AudioOutput *dr, u32 Pan)
+static void AAOut_SetPan(GF_AudioOutput *dr, u32 Pan)
 {
 	DroidContext *ctx = (DroidContext *)dr->opaque;
-	WAV_UpdateVolume(ctx);
+	AAOut_UpdateVolume(ctx);
 }
 
 /* Called by the audio thread */
-static GF_Err WAV_QueryOutputSampleRate(GF_AudioOutput *dr, u32 *desired_samplerate, u32 *NbChannels, u32 *nbBitsPerSample)
+static GF_Err AAOut_QueryOutputSampleRate(GF_AudioOutput *dr, u32 *desired_samplerate, u32 *NbChannels, u32 *nbBitsPerSample)
 {
 #ifdef TEST_QUERY_SAMPLE
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 	JNIEnv* env = ctx->env;
-	u32 sampleRateInHz, channelConfig, audioFormat;
-#endif
 
-	LOGV("Query sample=%d", *desired_samplerate );
+	u32 sampleRateInHz = *desired_samplerate;
+	u32 channelConfig = (*NbChannels == 1) ? CHANNEL_CONFIGURATION_MONO : CHANNEL_CONFIGURATION_STEREO;
+	u32 audioFormat = (*nbBitsPerSample == 8)? ENCODING_PCM_8BIT : ENCODING_PCM_16BIT;
 
-#ifdef TEST_QUERY_SAMPLE
-	sampleRateInHz = *desired_samplerate;
-	channelConfig = (*NbChannels == 1) ? CHANNEL_CONFIGURATION_MONO : CHANNEL_CONFIGURATION_STEREO;
-	audioFormat = (*nbBitsPerSample == 8)? ENCODING_PCM_8BIT : ENCODING_PCM_16BIT;
-
-	LOGV3("Android Audio Query: SampleRate ChannelConfig AudioFormat: %d %d %d \n",
+	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("AndroidAudio Query config: SampleRate ChannelConfig AudioFormat: %u %u %u\n",
 	 sampleRateInHz,
 	 (channelConfig == CHANNEL_CONFIGURATION_MONO)? 1 : 2,
-	 (ctx->audioFormat == ENCODING_PCM_8BIT)? 8 : 16);
+	 (ctx->audioFormat == ENCODING_PCM_8BIT)? 8 : 16));
 
 	switch (*desired_samplerate) {
 	case 11025:
-		*desired_samplerate = 11025;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
-			return GF_OK;
 	case 22050:
-		*desired_samplerate = 22050;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
-			return GF_OK;
-		break;
 	case 8000:
-		*desired_samplerate = 8000;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
-			return GF_OK;
 	case 16000:
-		*desired_samplerate = 16000;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
-			return GF_OK;
 	case 32000:
-		*desired_samplerate = 32000;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
-			return GF_OK;
-		break;
 	case 24000:
-		*desired_samplerate = 24000;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
-			return GF_OK;
 	case 48000:
-		*desired_samplerate = 48000;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
-			return GF_OK;
-		break;
 	case 44100:
-		*desired_samplerate = 44100;
-		if ( (*env)->CallStaticIntMethod(env, cAudioTrack, mGetMinBufferSize,
-		 *desired_samplerate, channelConfig, audioFormat) > 0 )
+		if ( (*env)->CallStaticIntMethod(env, ctx->class_AudioTrack, ctx->fun_GetMinBufferSize, *desired_samplerate, channelConfig, audioFormat) > 0 )
 			return GF_OK;
 		break;
 	default:
@@ -427,22 +343,22 @@
 	return GF_OK;
 }
 
-static u32 WAV_GetAudioDelay(GF_AudioOutput *dr)
+static u32 AAOut_GetAudioDelay(GF_AudioOutput *dr)
 {
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 
 	return ctx->delay;
 }
 
-static u32 WAV_GetTotalBufferTime(GF_AudioOutput *dr)
+static u32 AAOut_GetTotalBufferTime(GF_AudioOutput *dr)
 {
 	DroidContext *ctx = (DroidContext *)dr->opaque;
 
 	return ctx->total_length_ms;
 }
 
-//----------------------------------------------------------------------
-void *NewWAVRender()
+
+void *NewAAOutRender()
 {
 	DroidContext *ctx;
 	GF_AudioOutput *driv;
@@ -458,27 +374,26 @@
 	driv->opaque = ctx;
 
 	driv->SelfThreaded = 0;
-	driv->Setup = WAV_Setup;
-	driv->Shutdown = WAV_Shutdown;
-	driv->Configure = WAV_ConfigureOutput;
-	driv->GetAudioDelay = WAV_GetAudioDelay;
-	driv->GetTotalBufferTime = WAV_GetTotalBufferTime;
-	driv->SetVolume = WAV_SetVolume;
-	driv->SetPan = WAV_SetPan;
-	driv->Play = WAV_Play;
-	driv->QueryOutputSampleRate = WAV_QueryOutputSampleRate;
-	driv->WriteAudio = WAV_WriteAudio;
+	driv->Setup = AAOut_Setup;
+	driv->Shutdown = AAOut_Shutdown;
+	driv->Configure = AAOut_ConfigureOutput;
+	driv->GetAudioDelay = AAOut_GetAudioDelay;
+	driv->GetTotalBufferTime = AAOut_GetTotalBufferTime;
+	driv->SetVolume = AAOut_SetVolume;
+	driv->SetPan = AAOut_SetPan;
+	driv->Play = AAOut_Play;
+	driv->QueryOutputSampleRate = AAOut_QueryOutputSampleRate;
+	driv->WriteAudio = AAOut_WriteAudio;
 	return driv;
 }
-//----------------------------------------------------------------------
-void DeleteWAVRender(void *ifce)
+
+void DeleteAAOutRender(void *ifce)
 {
 	GF_AudioOutput *dr = (GF_AudioOutput *) ifce;
 	if (!ifce)
 		return;
 	gf_free(dr);
 }
-//----------------------------------------------------------------------
 
 GPAC_MODULE_EXPORT
 const u32 *QueryInterfaces()
@@ -493,7 +408,7 @@
 GPAC_MODULE_EXPORT
 GF_BaseInterface *LoadInterface(u32 InterfaceType)
 {
-	if (InterfaceType == GF_AUDIO_OUTPUT_INTERFACE) return NewWAVRender();
+	if (InterfaceType == GF_AUDIO_OUTPUT_INTERFACE) return NewAAOutRender();
 	return NULL;
 }
 
@@ -502,7 +417,7 @@
 {
 	switch (ifce->InterfaceType) {
 	case GF_AUDIO_OUTPUT_INTERFACE:
-		DeleteWAVRender((GF_AudioOutput *) ifce);
+		DeleteAAOutRender((GF_AudioOutput *) ifce);
 		break;
 	}
 }

gpac-2.0.0.tar.gz/modules/droid_out/droid_vout.c -> gpac-2.2.0.tar.gz/modules/droid_out/droid_vout.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Ivica Arsov, Jean Le Feuvre
- *			Copyright (c) Mines-Telecom 2009-
+ *			Copyright (c) Mines-Telecom 2009-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Wrapper
@@ -75,17 +75,13 @@
 #define RAW_OUT_PIXEL_FORMAT		GF_PIXEL_RGBA
 #define NBPP						4
 
-#define RAWCTX	AndroidContext *rc = (AndroidContext *)dr->opaque
+#define DROIDVOUTCTX	AndroidContext *rc = (AndroidContext *)dr->opaque
 
 
 
 //Functions specific to OpenGL ES2
 #ifdef GPAC_USE_GLES2
 
-#define GF_TRUE 1
-#define GF_FALSE 0
-
-
 //we custom-define these instead of importing gl_inc.h
 #define GL_COMPILE_STATUS 0x8B81
 #define GL_FRAGMENT_SHADER 0x8B30
@@ -93,8 +89,6 @@
 #define GL_LINK_STATUS 0x8B82
 #define GL_VERTEX_SHADER 0x8B31
 
-
-
 static char *glsl_vertex = "precision mediump float;\
 	attribute vec4 gfVertex;\
 	attribute vec4 gfTexCoord;\
@@ -119,9 +113,7 @@
 {
 	s32 res = glGetError();
 	if (res) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE,
-		 ("GL Error %d file %s line %d\n", res,
-				__FILE__, __LINE__));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("DroidVOUT GL Error %d file %s line %d\n", res, __FILE__, __LINE__));
 	}
 }
 
@@ -130,7 +122,7 @@
 {
 	GLint loc = glGetUniformLocation(glsl_program, uniform_name);
 	if (loc<0) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("V3D:GLSL Cannot find uniform \"%s\" in GLSL program\n", uniform_name));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("DroidVOUT Cannot find uniform \"%s\" in GLSL program\n", uniform_name));
 	}
 	return loc;
 }
@@ -139,20 +131,21 @@
 {
 	GLint loc = glGetAttribLocation(glsl_program, attrib_name);
 	if (loc<0) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("V3D:GLSL Cannot find attrib \"%s\" in GLSL program\n", attrib_name));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("DroidVOUT Cannot find attrib \"%s\" in GLSL program\n", attrib_name));
 	}
 	return loc;
 }
 
 //modified version of visual_3d_compile_shader function
-Bool compile_shader(u32 shader_id, const char *name, const char *source) {
+static Bool compile_shader(u32 shader_id, const char *name, const char *source)
+{
 	GLint blen = 0;
 	GLsizei slen = 0;
 	u32 len;
 	GLint is_compiled = 0;
 
 
-	if(!source || !shader_id) return 0;
+	if (!source || !shader_id) return 0;
 	len = (u32) strlen(source);
 	glShaderSource(shader_id, 1, &source, &len);
 	glCompileShader(shader_id);
@@ -164,8 +157,7 @@
 	if (blen > 1) {
 		char* compiler_log = (char*) gf_malloc(blen);
 		glGetShaderInfoLog(shader_id, blen, &slen, compiler_log);
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("GLSL Failed to compile %s shader: %s\n", name, compiler_log));
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("GLSL ***** faulty shader code ****\n%s\n**********************\n", source));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("DroidVOUT Failed to compile %s shader: %s\nShader code:\n%s\n", name, compiler_log, source));
 		gf_free (compiler_log);
 		return GF_FALSE;
 	}
@@ -174,29 +166,15 @@
 }
 
 
-static Bool initGLES2(AndroidContext *rc) {
-
-
-//PRINT OpengGL INFO
-	char* ext;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android InitGLES2"));
-
-	ext = (char*)glGetString(GL_VENDOR);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Vendor: %s", ext));
-
-	ext = (char*)glGetString(GL_RENDERER);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Renderer: %s", ext));
-
-	ext = (char*)glGetString(GL_VERSION);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Version: %s", ext));
-
-	ext = (char*)glGetString(GL_EXTENSIONS);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Extensions: %s", ext));
-
-
+static Bool initGLES2(AndroidContext *rc)
+{
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT InitGLES2: Version %s - Vendor %s - Renderer %s - Extensions %s",
+		glGetString(GL_VERSION),
+		glGetString(GL_VENDOR),
+		glGetString(GL_RENDERER),
+		glGetString(GL_EXTENSIONS)
+	));
 
-//Generic GL setup
 	/* Set the background black */
 	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
@@ -210,7 +188,7 @@
 	glDepthFunc(GL_LEQUAL);
 
 
-//Shaders setup
+	//Shaders setup
 	Bool res = GF_FALSE;
 	GLint linked;
 
@@ -220,11 +198,11 @@
 	rc->base_vertex = glCreateShader(GL_VERTEX_SHADER);
 	rc->base_fragment = glCreateShader(GL_FRAGMENT_SHADER);
 
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Compiling shaders"));
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT Compiling shaders"));
 	res = compile_shader(rc->base_vertex, "vertex", glsl_vertex);
-	if(!res) return GF_FALSE;
+	if (!res) return GF_FALSE;
 	res = compile_shader(rc->base_fragment, "fragment", glsl_fragment);
-	if(!res) return GF_FALSE;
+	if (!res) return GF_FALSE;
 
 	glAttachShader(rc->base_program, rc->base_vertex);
 	glAttachShader(rc->base_program, rc->base_fragment);
@@ -241,8 +219,6 @@
 	}
 	glUseProgram(rc->base_program);
 	gl_check_error();
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Shaders compiled"))
-
 	return GF_TRUE;
 }
 
@@ -255,14 +231,15 @@
 #endif
 	gl_check_error();
 	loc = glGetUniformLocation(program, name);
-	if(loc<0) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("GL Error (file %s line %d): Invalid matrix name", __FILE__, __LINE__));
+	if (loc<0) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("DroidVOUT GL Error (file %s line %d): Invalid matrix name", __FILE__, __LINE__));
 		return;
 	}
 	gl_check_error();
 
 #ifdef GPAC_FIXED_POINT
-	for (i=0; i<16; i++) _mati = FIX2FLT(mati);
+	for (i=0; i<16; i++)
+		_mati = FIX2FLT(mati);
 	glUniformMatrix4fv(loc, 1, GL_FALSE, (GLfloat *) _mat);
 #else
 	glUniformMatrix4fv(loc, 1, GL_FALSE, mat);
@@ -273,17 +250,16 @@
 
 //ES2 version of glOrthox() - resulting matrix is stored in rc->ortho
 //more info on Orthographic projection matrix at http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho
-static void calculate_ortho(Fixed left, Fixed right, Fixed bottom, Fixed top, Fixed near, Fixed far, AndroidContext *rc) {
-
-
-	if((left==right)|(bottom==top)|(near==far)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("GL Error (file %s line %d): Invalid Orthogonal projection values", __FILE__, __LINE__));
+static void calculate_ortho(Fixed left, Fixed right, Fixed bottom, Fixed top, Fixed near, Fixed far, AndroidContext *rc)
+{
+	if ((left==right)|(bottom==top)|(near==far)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("DroidVOUT GL Error (file %s line %d): Invalid Orthogonal projection values", __FILE__, __LINE__));
 		return;
 	}
 
 	gf_mx_init(rc->ortho);
 
-//For Orthographic Projection
+	//For Orthographic Projection
 	rc->ortho.m0 = gf_divfix(2, (right-left));
 	rc->ortho.m5 = gf_divfix(2, (top-bottom));
 	rc->ortho.m10 = gf_divfix(-2, far-near);
@@ -293,39 +269,28 @@
 	rc->ortho.m15 = FIX_ONE;
 }
 
-
-
 #endif	//Endof specifix for GLES2 (ifdef GPAC_USE_GLES2)
 
 
 #ifndef GPAC_USE_GLES2
-void initGL(AndroidContext *rc)
+static void initGL(AndroidContext *rc)
 {
-	char* ext;
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android InitGL"));
+	char *exts = (char*)glGetString(GL_EXTENSIONS);
 
-	ext = (char*)glGetString(GL_VENDOR);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Vendor: %s", ext));
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT InitGL: Version %s - Vendor %s - Renderer %s - Extensions %s",
+		glGetString(GL_VERSION),
+		glGetString(GL_VENDOR),
+		glGetString(GL_RENDERER),
+		exts
+	));
 
-	ext = (char*)glGetString(GL_RENDERER);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Renderer: %s", ext));
-
-	ext = (char*)glGetString(GL_VERSION);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Version: %s", ext));
-
-	ext = (char*)glGetString(GL_EXTENSIONS);
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("OpenGL ES Extensions: %s", ext));
-
-	if ( strstr(ext, "GL_OES_draw_texture") )
-	{
+	if (strstr(exts, "GL_OES_draw_texture")) {
 		rc->draw_texture = 1;
-		GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("Using GL_OES_draw_texture"));
+		GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("DroidVOUT Using GL_OES_draw_texture"));
 	}
-	if ( strstr(ext, "GL_ARB_texture_non_power_of_two") )
-	{
+	if (strstr(ext, "GL_ARB_texture_non_power_of_two")) {
 		rc->non_power_two = 0;
-		GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("Using GL_ARB_texture_non_power_of_two"));
+		GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("DroidVOUT Using GL_ARB_texture_non_power_of_two"));
 	}
 
 	/* Enable smooth shading */
@@ -348,8 +313,7 @@
 }
 #endif
 
-void gluPerspective(GLfloat fovy, GLfloat aspect,
- GLfloat zNear, GLfloat zFar)
+static void gluPerspective(GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloat zFar)
 {
 #ifndef GPAC_USE_GLES2
 	GLfloat xmin, xmax, ymin, ymax;
@@ -364,9 +328,9 @@
 #endif
 }
 
-void resizeWindow(AndroidContext *rc)
+static void resizeWindow(AndroidContext *rc)
 {
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("resizeWindow : start"));
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT resizing window to %u x %u\n", rc->width, rc->height));
 
 	/* Protect against a divide by zero */
 	if (rc->height==0)
@@ -395,21 +359,16 @@
 	load_matrix_shaders(rc->base_program, (Fixed *) rc->identity.m, "gfModelViewMatrix");
 	gl_check_error();
 #endif
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("resizeWindow : end"));
 }
 
-void drawGLScene(AndroidContext *rc)
+static void drawGLScene(AndroidContext *rc)
 {
-#ifdef DROID_EXTREME_LOGS
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("drawGLScene : start"));
-#endif /* DROID_EXTREME_LOGS */
 #ifdef GPAC_USE_GLES2
 	GLint loc_vertex_array, loc_texcoord_array;
 #endif
 
 	GLfloat vertices43;
 	GLfloat texcoord42;
-//	int i, j;
 
 #ifndef GPAC_USE_GLES2
 	float rgba4;
@@ -445,27 +404,18 @@
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-// for ( i = 0; i < rc->height/2; i++ )
-// 	for ( j = 0; j < rc->width; j++ )
-// 		rc->texData i*rc->width*NBPP + j*NBPP + 3 = 200;
-
-// memset(rc->texData, 255, 4 * rc->width * rc->height );
-
 	glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, rc->tex_width, rc->tex_height, 0,
 	 GL_RGBA, GL_UNSIGNED_BYTE, rc->texData );
 
 	gl_check_error();
-	if ( rc->draw_texture )
-	{
+	if ( rc->draw_texture ) {
 #ifndef GPAC_USE_GLES2
 		gl_check_error();
 		int cropRect4 = {0,rc->height,rc->width,-rc->height};
 		glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, cropRect);
 		glDrawTexsOES(0, 0, 0, rc->width, rc->height);
 #endif
-	}
-	else
-	{
+	} else {
 		gl_check_error();
 
 #ifndef GPAC_USE_GLES2
@@ -494,8 +444,6 @@
 
 
 #endif
-		//glTranslatef(0.0f, 0.0f, -3.3f);
-		//glTranslatef(0.0f, 0.0f, -2.3f);
 
 		/* Top Right Of The Quad */
 		vertices00=rc->tex_width;
@@ -537,41 +485,36 @@
 
 	/* Flush all drawings */
 	glFinish();
-#ifdef DROID_EXTREME_LOGS
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("drawGLScene : end"));
-#endif /* DROID_EXTREME_LOGS */
 }
 
-int releaseTexture(AndroidContext *rc)
+static int releaseTexture(AndroidContext *rc)
 {
 	gl_check_error();
 	if (!rc)
 		return 0;
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Delete Texture"));
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT Delete texture\n"));
 
-	if ( rc->texID >= 0)
-	{
+	if ( rc->texID >= 0) {
 		glDeleteTextures(1, &(rc->texID));
 		rc->texID = -1;
 	}
-	if (rc->texData)
-	{
+
+	if (rc->texData) {
 		gf_free(rc->texData);
 		rc->texData = NULL;
 	}
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Delete Texture DONE"))
 	gl_check_error();
 	return 0;
 }
 
-int createTexture(AndroidContext *rc)
+static int createTexture(AndroidContext *rc)
 {
 	if (!rc)
 		return 0;
-	if ( rc->texID >= 0 )
+	if (rc->texID >= 0)
 		releaseTexture(rc);
 
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("Android Create Texture Size: WxH: %dx%d", rc->tex_width, rc->tex_height));
+	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("DroidVOUT Create Texture %u x %u in RGBA\n", rc->tex_width, rc->tex_height));
 
 	glGenTextures( 1, &(rc->texID) );
 
@@ -592,12 +535,11 @@
 	 GL_RGBA, GL_UNSIGNED_BYTE, NULL/*rc->texData*/ );
 
 	glBindTexture( GL_TEXTURE_2D, 0);
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Create Texture DONE"));
 	return 0;
 }
 
 
-u32 find_pow_2(u32 num)
+static u32 find_pow_2(u32 num)
 {
 	u32 res = 1;
 	while (res < num)
@@ -607,8 +549,8 @@
 
 static GF_Err droid_Resize(GF_VideoOutput *dr, u32 w, u32 h)
 {
-	RAWCTX;
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Resize: %dx%d", w, h));
+	DROIDVOUTCTX;
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT Resize: %u x %u", w, h));
 
 	rc->width = w;
 	rc->height = h;
@@ -622,13 +564,10 @@
 	rc->tex_width = rc->width;
 	rc->tex_height = rc->height;
 #else
-	if ( rc->non_power_two )
-	{
+	if (rc->non_power_two) {
 		rc->tex_width = rc->width;
 		rc->tex_height = rc->height;
-	}
-	else
-	{
+	} else {
 		rc->tex_width = find_pow_2(rc->width);
 		rc->tex_height = find_pow_2(rc->height);
 	}
@@ -636,85 +575,62 @@
 	gl_check_error();
 	resizeWindow(rc);
 
-	if ( rc->out_3d_type == 0 )
-	{
+	if (rc->out_3d_type == 0) {
 		createTexture(rc);
 	}
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Resize DONE", w, h));
 	gl_check_error();
 	return GF_OK;
 }
 
-GF_Err droid_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, u32 init_flags)
+static GF_Err droid_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, u32 init_flags)
 {
-	RAWCTX;
+	DROIDVOUTCTX;
 
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Setup: %d", init_flags));
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT Setup with flags %08X\n", init_flags));
 
 
 #ifdef GPAC_USE_GLES2
-
-	if ( rc->out_3d_type == 0 ) {
+	if (rc->out_3d_type == 0) {
 		Bool res = GF_FALSE;
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("We are in OpenGL: disable mode"));
 		res = initGLES2(rc);
-		if(res==GF_FALSE) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("ERROR Compiling ES2 Shaders"));
-		} else {	//set texture
+		if (res) {
 			glUseProgram(rc->base_program);
 			GLint loc = gf_glGetUniformLocation(rc->base_program, "img");
 			glUniform1i(loc,0);
 		}
 	}
-
 #else
-
-	if ( rc->out_3d_type == 0 )
-
+	if (rc->out_3d_type == 0)
 		initGL(rc);
 #endif //GPAC_USE_GLES2
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Setup DONE"));
 	return GF_OK;
 }
 
 
 static void droid_Shutdown(GF_VideoOutput *dr)
 {
-	RAWCTX;
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Shutdown\n"));
-
+	DROIDVOUTCTX;
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("DroidVOUT Shutdown\n"));
 	releaseTexture(rc);
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Shutdown DONE"));
 }
 
 
 static GF_Err droid_Flush(GF_VideoOutput *dr, GF_Window *dest)
 {
-	RAWCTX;
-#ifdef DROID_EXTREME_LOGS
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Flush\n"));
-#endif /* DROID_EXTREME_LOGS */
-
+	DROIDVOUTCTX;
 	if ( rc->out_3d_type == 0 )
 		drawGLScene(rc);
-#ifdef DROID_EXTREME_LOGS
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android Flush DONE"));
-#endif /* DROID_EXTREME_LOGS */
 	return GF_OK;
 }
 
 static GF_Err droid_LockBackBuffer(GF_VideoOutput *dr, GF_VideoSurface *vi, Bool do_lock)
 {
-	RAWCTX;
-#ifdef DROID_EXTREME_LOGS
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android LockBackBuffer: %d", do_lock));
-#endif /* DROID_EXTREME_LOGS */
+	DROIDVOUTCTX;
+
 	if (do_lock) {
 		if (!vi) return GF_BAD_PARAM;
 
-		if ( rc->out_3d_type != 0 )
+		if (rc->out_3d_type != 0)
 			return GF_NOT_SUPPORTED;
 
 		memset(vi, 0, sizeof(GF_VideoSurface));
@@ -725,11 +641,8 @@
 		vi->pitch_x = NBPP;
 		vi->pitch_y = NBPP * rc->tex_width;
 		vi->pixel_format = RAW_OUT_PIXEL_FORMAT;
-	}
-	else
-	{
-		if (rc->locked_data)
-		{
+	} else {
+		if (rc->locked_data) {
 			//glBindTexture( GL_TEXTURE_2D, rc->texID);
 			//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 			//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
@@ -738,21 +651,17 @@
 			//			GL_RGBA, GL_UNSIGNED_BYTE, rc->locked_data );
 		}
 	}
-#ifdef DROID_EXTREME_LOGS
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android LockBackBuffer DONE"));
-#endif /* DROID_EXTREME_LOGS */
 	return GF_OK;
 }
 
 static GF_Err droid_ProcessEvent(GF_VideoOutput *dr, GF_Event *evt)
 {
-	RAWCTX;
+	DROIDVOUTCTX;
 
 	if (!evt) return GF_OK;
 
 	switch (evt->type) {
 	case GF_EVENT_SIZE:
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("GF_EVENT_SIZE( %d x %d)", evt->setup.width, evt->setup.height));
 		//in fullscreen mode: do not change viewport; just update perspective
 		if (rc->fullscreen) {
 #ifdef GPAC_USE_GLES2
@@ -781,10 +690,8 @@
 			return droid_Resize(dr, evt->setup.width, evt->setup.height);
 
 	case GF_EVENT_VIDEO_SETUP:
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android OpenGL mode: %d", evt->setup.use_opengl));
 		if (!evt->setup.use_opengl) {
 			rc->out_3d_type = 0;
-//					initGL(rc);
 			droid_Resize(dr, evt->setup.width, evt->setup.height);
 		} else {
 			rc->out_3d_type = 1;
@@ -793,18 +700,13 @@
 		return GF_OK;
 
 	case GF_EVENT_SET_CURSOR:
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("GF_EVENT_SET_CURSOR"));
 		return GF_OK;
 	case GF_EVENT_SET_CAPTION:
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("GF_EVENT_SET_CAPTION"));
 		return GF_OK;
 	case GF_EVENT_SHOWHIDE:
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("GF_EVENT_SHOWHIDE"));
 		return GF_OK;
 	default:
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Process Unknown Event: %d", evt->type));
 		return GF_OK;
-
 	case GF_EVENT_TEXT_EDITING_START:
 	case GF_EVENT_TEXT_EDITING_END:
 		return GF_NOT_SUPPORTED;
@@ -814,7 +716,7 @@
 
 static GF_Err droid_SetFullScreen(GF_VideoOutput *dr, Bool bOn, u32 *outWidth, u32 *outHeight)
 {
-	RAWCTX;
+	DROIDVOUTCTX;
 
 	*outWidth = dr->max_screen_width;
 	*outHeight = dr->max_screen_height;
@@ -826,7 +728,7 @@
 {
 	AndroidContext *pCtx;
 	GF_VideoOutput *driv = (GF_VideoOutput *) gf_malloc(sizeof(GF_VideoOutput));
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("Android Video Initialization in progress..."));
+	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("DroidVOUT Loading module"));
 	memset(driv, 0, sizeof(GF_VideoOutput));
 	GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "Android Video Output", "gpac distribution")
 
@@ -847,8 +749,6 @@
 	driv->max_screen_height = 1024;
 
 	driv->hw_caps = GF_VIDEO_HW_OPENGL;// | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA;//GF_VIDEO_HW_DIRECT_ONLY;//
-
-	GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("Android Video Init Done.\n"));
 	return (void *)driv;
 }
 
@@ -856,15 +756,12 @@
 {
 	AndroidContext *rc;
 	GF_VideoOutput *driv = (GF_VideoOutput *) ifce;
-	if (!ifce)
-		return;
+	if (!ifce) return;
 	droid_Shutdown(driv);
 	rc = (AndroidContext *)driv->opaque;
-	if (rc)
-		gf_free(rc);
+	if (rc) gf_free(rc);
 	driv->opaque = NULL;
 	gf_free(driv);
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("Android vout deinit\n"));
 }
 
 /*interface query*/

gpac-2.0.0.tar.gz/modules/dx_hw/dx_hw.rc -> gpac-2.2.0.tar.gz/modules/dx_hw/dx_hw.rc Changed

gpac-2.0.0.tar.gz/modules/dx_hw/dx_video.c -> gpac-2.2.0.tar.gz/modules/dx_hw/dx_video.c Changed

gpac-2.0.0.tar.gz/modules/dx_hw/dx_window.c -> gpac-2.2.0.tar.gz/modules/dx_hw/dx_window.c Changed

@@ -25,7 +25,6 @@
 
 
 #include "dx_hw.h"
-#include <gpac/user.h>
 #include <gpac/utf.h>
 #include "resource.h"
 
@@ -677,7 +676,7 @@
 	memset(&wc, 0, sizeof(WNDCLASS));
 #ifndef _WIN32_WCE
 	wc.style = CS_BYTEALIGNWINDOW;
-	wc.hIcon = LoadIcon (hInst, MAKEINTRESOURCE(IDI_OSMO_ICON) );
+	wc.hIcon = LoadIcon (hInst, MAKEINTRESOURCE(IDI_GPAC_ICON) );
 #ifdef UNICODE
 	wc.lpszClassName = L"GPAC DirectDraw Output";
 #else
@@ -694,20 +693,20 @@
 
 	flags = ctx->switch_res;
 	ctx->switch_res = GF_FALSE;
-	ctx->force_alpha = (flags & GF_TERM_WINDOW_TRANSPARENT) ? GF_TRUE : GF_FALSE;
+	ctx->force_alpha = (flags & GF_VOUT_WINDOW_NO_DECORATION) ? GF_TRUE : GF_FALSE;
 
 	if (!ctx->os_hwnd) {
 #ifndef _WIN32_WCE
 		u32 styles;
 #endif
-		if (flags & GF_TERM_WINDOWLESS) ctx->windowless = GF_TRUE;
+		if (flags & GF_VOUT_WINDOWLESS) ctx->windowless = GF_TRUE;
 
 
 #ifdef _WIN32_WCE
 		ctx->os_hwnd = CreateWindow(_T("GPAC DirectDraw Output"), _T("GPAC DirectDraw Output"), WS_POPUP, 0, 0, 120, 100, NULL, NULL, hInst, NULL);
 #else
 
-		if (flags & GF_TERM_WINDOW_NO_DECORATION) {
+		if (flags & GF_VOUT_WINDOW_NO_DECORATION) {
 			styles = WS_POPUP | WS_THICKFRAME;
 		} else if (ctx->windowless) {
 			styles = WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_POPUP;
@@ -727,7 +726,7 @@
 		}
 		DragAcceptFiles(ctx->os_hwnd, TRUE);
 
-		if (flags & GF_TERM_INIT_HIDE) {
+		if (flags & GF_VOUT_INIT_HIDE) {
 			ShowWindow(ctx->os_hwnd, SW_HIDE);
 		} else {
 			SetForegroundWindow(ctx->os_hwnd);
@@ -843,7 +842,7 @@
 
 	if (ctx->os_hwnd) {
 		/*override window proc*/
-		if (!(flags & GF_TERM_NO_WINDOWPROC_OVERRIDE) ) {
+		if (!(flags & GF_VOUT_NO_WINDOWPROC_OVERRIDE) ) {
 #ifdef _WIN64
 			ctx->orig_wnd_proc = GetWindowLongPtr(ctx->os_hwnd, GWLP_WNDPROC);
 			SetWindowLongPtr(ctx->os_hwnd, GWLP_WNDPROC, (LONG_PTR) DD_WindowProc);
@@ -856,7 +855,7 @@
 	}
 	ctx->switch_res = flags;
 
-	if (flags & GF_TERM_WINDOW_NO_THREAD) {
+	if (flags & GF_VOUT_WINDOW_NO_THREAD) {
 		DD_InitWindows(dr, ctx);
 	} else {
 		/*create event thread*/

gpac-2.0.0.tar.gz/modules/dx_hw/resource.h -> gpac-2.2.0.tar.gz/modules/dx_hw/resource.h Changed

gpac-2.0.0.tar.gz/modules/ft_font/Makefile -> gpac-2.2.0.tar.gz/modules/ft_font/Makefile Changed

gpac-2.0.0.tar.gz/modules/ft_font/ft_font.c -> gpac-2.2.0.tar.gz/modules/ft_font/ft_font.c Changed

@@ -300,6 +300,7 @@
 	gf_opts_set_key("FontCache", "FontFixed", ftpriv->font_fixed);
 	gf_opts_set_key("FontCache", "FontSerif", ftpriv->font_serif);
 	gf_opts_set_key("FontCache", "FontSans", ftpriv->font_sans);
+	gf_opts_save();
 
 	GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("FreeType Font directories scanned\n"));
 }
@@ -493,6 +494,7 @@
 
 static GF_Err ft_set_font(GF_FontReader *dr, const char *OrigFontName, u32 styles)
 {
+	GF_Err e = GF_OK;
 	char *fname;
 	char *fontName;
 	const char *opt;
@@ -536,42 +538,74 @@
 	}
 	fname = gf_malloc(sizeof(char) * (strlen(fontName) + 50));
 
-	{
-		int checkStyles = (styles & GF_FONT_WEIGHT_BOLD) | (styles & GF_FONT_ITALIC);
+	int checkStyles = (styles & GF_FONT_WEIGHT_BOLD) | (styles & GF_FONT_ITALIC);
+
 checkFont:
-		strcpy(fname, fontName);
-		if (styles & GF_FONT_WEIGHT_BOLD & checkStyles) strcat(fname, " Bold");
-		if (styles & GF_FONT_ITALIC & checkStyles) strcat(fname, " Italic");
+	strcpy(fname, fontName);
+	if (checkStyles & GF_FONT_WEIGHT_BOLD) strcat(fname, " Bold");
+	if (checkStyles & GF_FONT_ITALIC) strcat(fname, " Italic");
+
+	opt = gf_opts_get_key("FontCache", fname);
 
-		opt = gf_opts_get_key("FontCache", fname);
+	if (opt) {
+		u32 i, num_faces;
+		FT_Face face;
 
-		if (opt) {
-			FT_Face face;
+		//check font is in cache
+		ftpriv->active_face = ft_font_in_cache(ftpriv, fname, checkStyles);
+		if (ftpriv->active_face) {
 			gf_free(fname);
-			if (FT_New_Face(ftpriv->library, opt, 0, & face )) return GF_IO_ERR;
-			if (!face) return GF_IO_ERR;
-			gf_list_add(ftpriv->loaded_fonts, face);
-			ftpriv->active_face = face;
 			return GF_OK;
 		}
-		if (checkStyles) {
-			/* If we tried font + bold + italic -> we will try font + bold | italic
-			 If we tried font + bold | italic -> we try font
-			 */
-			if (checkStyles == (GF_FONT_WEIGHT_BOLD | GF_FONT_ITALIC))
-				checkStyles = GF_FONT_WEIGHT_BOLD;
-			else if (checkStyles == GF_FONT_WEIGHT_BOLD && (styles & GF_FONT_ITALIC))
-				checkStyles = GF_FONT_ITALIC;
-			else if (checkStyles == GF_FONT_WEIGHT_BOLD || checkStyles == GF_FONT_ITALIC)
-				checkStyles = 0;
-			goto checkFont;
+
+		//load face
+		if (FT_New_Face(ftpriv->library, opt, 0, & face) || !face) {
+			e = GF_IO_ERR;
+			goto exit;
 		}
+
+		//handle collections, figure out which face matches our styles
+		num_faces = face->num_faces;
+		for (i=0; i<num_faces; i++) {
+			if ( ft_check_face(face, NULL, checkStyles)) {
+				gf_free(fname);
+				gf_list_add(ftpriv->loaded_fonts, face);
+				ftpriv->active_face = face;
+				return GF_OK;
+			}
+			FT_Done_Face(face);
+			if (i+1==num_faces) break;
+
+			/*load next font in collection*/
+			if (FT_New_Face(ftpriv->library, opt, i+1, & face ))
+				break;
+			if (!face)
+				break;
+		}
+	}
+	if (checkStyles) {
+		//we tried bold italic, try bold
+		if (checkStyles == (GF_FONT_WEIGHT_BOLD | GF_FONT_ITALIC))
+			checkStyles = GF_FONT_WEIGHT_BOLD;
+		//we tried bold at previous pass, and input styles had italic, try italic
+		else if ((checkStyles == GF_FONT_WEIGHT_BOLD) && (styles & GF_FONT_ITALIC))
+			checkStyles = GF_FONT_ITALIC;
+		//otherwise try with no style
+		else if ((checkStyles == GF_FONT_WEIGHT_BOLD) || (checkStyles == GF_FONT_ITALIC))
+			checkStyles = 0;
+		goto checkFont;
 	}
 
-	GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("FreeType Font %s (%s) not found\n", fontName, fname));
+exit:
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("FreeType Error loading font %s (%s): %s\n", fontName, fname, gf_error_to_string(e) ));
+	} else {
+		GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("FreeType Font %s (%s) not found\n", fontName, fname));
+		e = GF_NOT_SUPPORTED;
+	}
 	gf_free(fname);
 	gf_opts_set_key("temp_freetype", OrigFontName, "not found");
-	return GF_NOT_SUPPORTED;
+	return e;
 }
 
 static GF_Err ft_get_font_info(GF_FontReader *dr, char **font_name, u32 *em_size, s32 *ascent, s32 *descent, s32 *underline, s32 *line_spacing, s32 *max_advance_h, s32 *max_advance_v)

gpac-2.0.0.tar.gz/modules/jack/Makefile -> gpac-2.2.0.tar.gz/modules/jack/Makefile Changed

gpac-2.0.0.tar.gz/modules/sdl_out/Makefile -> gpac-2.2.0.tar.gz/modules/sdl_out/Makefile Changed

gpac-2.0.0.tar.gz/modules/sdl_out/audio.c -> gpac-2.2.0.tar.gz/modules/sdl_out/audio.c Changed

gpac-2.0.0.tar.gz/modules/sdl_out/sdl_out.c -> gpac-2.2.0.tar.gz/modules/sdl_out/sdl_out.c Changed

gpac-2.0.0.tar.gz/modules/sdl_out/sdl_out.h -> gpac-2.2.0.tar.gz/modules/sdl_out/sdl_out.h Changed

gpac-2.0.0.tar.gz/modules/sdl_out/video.c -> gpac-2.2.0.tar.gz/modules/sdl_out/video.c Changed

@@ -24,7 +24,6 @@
 */
 
 #include "sdl_out.h"
-#include <gpac/user.h>
 
 #ifdef WIN32
 #include <windows.h>
@@ -486,6 +485,10 @@
 		flags = SDL_GL_WINDOW_FLAGS;
 		if (ctx->os_handle) flags &= ~SDL_WINDOW_RESIZABLE;
 		if (ctx->fullscreen) flags |= SDL_FULLSCREEN_FLAGS;
+#ifdef GPAC_CONFIG_IOS
+		flags |= SDL_FULLSCREEN_FLAGS | SDL_WINDOW_ALLOW_HIGHDPI;
+#endif
+
 #else
 		flags = SDL_GL_WINDOW_FLAGS;
 		if (ctx->os_handle) flags &= ~SDL_RESIZABLE;
@@ -526,8 +529,9 @@
 				return GF_IO_ERR;
 			}
 			GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("SDL Window created\n"));
+			dr->window_id = SDL_GetWindowID(ctx->screen);
 
-#if SDL_VERSION_ATLEAST(2,0,0) && !defined(GPAC_CONFIG_IOS)
+#if !defined(GPAC_CONFIG_IOS)
 			SDLVid_SetIcon(ctx);
 #endif
 
@@ -558,6 +562,27 @@
 			hw_reset = GF_TRUE;
 		}
 
+		if (flags & SDL_WINDOW_ALLOW_HIGHDPI) {
+			int w, h;
+			SDL_GL_GetDrawableSize(ctx->screen, &w, &h);
+#if SDL_VERSION_ATLEAST(2,0,9)
+			int _h;
+			switch (SDL_GetDisplayOrientation(0)) {
+			case SDL_ORIENTATION_LANDSCAPE:
+			case SDL_ORIENTATION_LANDSCAPE_FLIPPED:
+				break;
+			default:
+				_h = h;
+				h = w;
+				w = _h;
+				break;
+			}
+#endif
+			if ((u32) w > dr->max_screen_width) dr->max_screen_width = w;
+			if ((u32) h > dr->max_screen_height) dr->max_screen_height = h;
+		}
+
+
 		if (!ctx->disable_vsync)
 			ctx->disable_vsync = gf_opts_get_bool("core", "disable-vsync");
 
@@ -623,6 +648,7 @@
 				gf_mx_v(ctx->evt_mx);
 				return GF_IO_ERR;
 			}
+			dr->window_id = SDL_GetWindowID(ctx->screen);
 
 #if SDL_VERSION_ATLEAST(2,0,0) && !defined(GPAC_CONFIG_IOS)
 			SDLVid_SetIcon(ctx);
@@ -685,6 +711,10 @@
 #endif
 }
 
+#include <gpac/list.h>
+static GF_List *video_outputs = NULL;
+static u32 nb_video_outputs=0;
+
 static Bool SDLVid_InitializeWindow(SDLVidCtx *ctx, GF_VideoOutput *dr)
 {
 	u32 flags;
@@ -700,11 +730,18 @@
 	putenv("directx");
 #endif
 
-	flags = SDL_WasInit(SDL_INIT_VIDEO);
-	if (!(flags & SDL_INIT_VIDEO)) {
-		if (SDL_InitSubSystem(SDL_INIT_VIDEO)) {
-			return GF_FALSE;
+	if (!video_outputs) {
+		flags = SDL_WasInit(SDL_INIT_VIDEO);
+		if (!(flags & SDL_INIT_VIDEO)) {
+			if (SDL_InitSubSystem(SDL_INIT_VIDEO)) {
+				return GF_FALSE;
+			}
 		}
+		video_outputs = gf_list_new();
+	}
+	if (gf_list_find(video_outputs, dr)<0) {
+		gf_list_add(video_outputs, dr);
+		nb_video_outputs = gf_list_count(video_outputs);
 	}
 
 	ctx->curs_def = SDL_GetCursor();
@@ -802,23 +839,69 @@
 {
 	SDLVid_DestroyObjects(ctx);
 	SDLVid_ResetWindow(ctx);
-	SDL_QuitSubSystem(SDL_INIT_VIDEO);
+#if SDL_VERSION_ATLEAST(2,0,0)
+	if (ctx->screen) SDL_DestroyWindow(ctx->screen);
+	ctx->screen = NULL;
+#endif
 }
 
 #if defined SDL_TEXTINPUTEVENT_TEXT_SIZE /*&& !defined GPAC_CONFIG_IOS*/
 #include <gpac/utf.h>
 #endif
 
-
 Bool SDLVid_ProcessMessageQueue(SDLVidCtx *ctx, GF_VideoOutput *dr)
 {
 	SDL_Event sdl_evt;
 	GF_Event gpac_evt;
 
 #ifdef GPAC_CONFIG_IOS
-	while (SDL_WaitEventTimeout(&sdl_evt, 0)) {
+	while (SDL_WaitEventTimeout(&sdl_evt, 1)) {
 #else
-	while (SDL_PollEvent(&sdl_evt)) {
+	while (1) {
+
+		if (nb_video_outputs>1) {
+			u32 win_id=0;
+			if (!SDL_PollEvent(NULL)) return GF_TRUE;
+			SDL_PeepEvents(&sdl_evt, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT);
+			switch (sdl_evt.type) {
+			case SDL_WINDOWEVENT: win_id = sdl_evt.window.windowID; break;
+#ifdef SDL_TEXTINPUTEVENT_TEXT_SIZE
+			case SDL_TEXTINPUT: /* Since SDL 1.3, text-input is handled in a specific event */
+				win_id = sdl_evt.text.windowID; break;
+#endif
+			case SDL_KEYDOWN:
+			case SDL_KEYUP:
+				win_id = sdl_evt.key.windowID; break;
+			case SDL_MOUSEMOTION:
+				win_id = sdl_evt.motion.windowID; break;
+			case SDL_MOUSEBUTTONDOWN:
+			case SDL_MOUSEBUTTONUP:
+				win_id = sdl_evt.button.windowID; break;
+			case SDL_MOUSEWHEEL:
+				win_id = sdl_evt.wheel.windowID; break;
+#if SDL_VERSION_ATLEAST(2,0,5)
+			case SDL_DROPFILE:
+				win_id = sdl_evt.drop.windowID; break;
+#endif
+			}
+			//we may get events from destroyed windows still in the queue, flush them
+			if (win_id!=dr->window_id) {
+				Bool found=GF_FALSE;
+				u32 i;
+				for (i=0; i<nb_video_outputs; i++) {
+					GF_VideoOutput *dr2 = gf_list_get(video_outputs, i);
+					if (win_id==dr2->window_id) {
+						found=GF_TRUE;
+						break;
+					}
+				}
+				if (found) return GF_TRUE;
+				else if (win_id) {
+					fprintf(stderr, "Purging event from window id %d\n", win_id);
+				}
+			}
+		}
+		if (!SDL_PollEvent(&sdl_evt)) return GF_TRUE;
 #endif
 
 		switch (sdl_evt.type) {
@@ -827,30 +910,60 @@
 			switch (sdl_evt.window.event) {
 			case SDL_WINDOWEVENT_SIZE_CHANGED:
 				gpac_evt.type = GF_EVENT_SIZE;
+#if SDL_VERSION_ATLEAST(2,0,10) && GPAC_CONFIG_IOS
+				{
+					int w, h;
+					SDL_GL_GetDrawableSize(ctx->screen, &w, &h);
+					gpac_evt.size.width = w;
+					gpac_evt.size.height = h;
+
+					ctx->high_dpi_w = w;
+					ctx->low_dpi_w = sdl_evt.window.data1;
+					ctx->high_dpi_h = h;
+					ctx->low_dpi_h = sdl_evt.window.data2;
+				}
+#else
 				gpac_evt.size.width = sdl_evt.window.data1;
 				gpac_evt.size.height = sdl_evt.window.data2;
+				gpac_evt.size.window_id = dr->window_id;
+#endif
+
+
+#if SDL_VERSION_ATLEAST(2,0,9)
+				switch (SDL_GetDisplayOrientation(0)) {
+				case SDL_ORIENTATION_UNKNOWN: gpac_evt.size.orientation = GF_DISPLAY_MODE_UNKNOWN; break;
+				case SDL_ORIENTATION_LANDSCAPE: gpac_evt.size.orientation = GF_DISPLAY_MODE_LANDSCAPE; break;
+				case SDL_ORIENTATION_LANDSCAPE_FLIPPED: gpac_evt.size.orientation = GF_DISPLAY_MODE_LANDSCAPE_INV; break;
+				case SDL_ORIENTATION_PORTRAIT: gpac_evt.size.orientation = GF_DISPLAY_MODE_PORTRAIT; break;
+				case SDL_ORIENTATION_PORTRAIT_FLIPPED: gpac_evt.size.orientation = GF_DISPLAY_MODE_PORTRAIT_INV; break;
+				}
+#endif
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 				break;
 			case SDL_WINDOWEVENT_EXPOSED:
 			case SDL_WINDOWEVENT_SHOWN:
 				gpac_evt.type = GF_EVENT_REFRESH;
+				gpac_evt.show.window_id = dr->window_id;
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 				break;
 			case SDL_WINDOWEVENT_MOVED:
 				gpac_evt.type = GF_EVENT_MOVE;
 				gpac_evt.move.x = sdl_evt.window.data1;
 				gpac_evt.move.y = sdl_evt.window.data2;
+				gpac_evt.move.window_id = dr->window_id;
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 				break;
 			case SDL_WINDOWEVENT_CLOSE:
 				memset(&gpac_evt, 0, sizeof(GF_Event));
 				gpac_evt.type = GF_EVENT_QUIT;
+				gpac_evt.show.window_id = dr->window_id;
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 				return GF_FALSE;
 			case SDL_WINDOWEVENT_MINIMIZED:
 				memset(&gpac_evt, 0, sizeof(GF_Event));
 				gpac_evt.type = GF_EVENT_SHOWHIDE;
 				gpac_evt.show.show_type = 0;
+				gpac_evt.show.window_id = dr->window_id;
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 				return GF_FALSE;
 			}
@@ -871,6 +984,7 @@
 		case SDL_QUIT:
 			memset(&gpac_evt, 0, sizeof(GF_Event));
 			gpac_evt.type = GF_EVENT_QUIT;
+			gpac_evt.show.window_id = 0;
 			dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 			return GF_FALSE;
 
@@ -886,6 +1000,7 @@
 				gpac_evt.type = GF_EVENT_TEXTINPUT;
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 			}
+			gpac_evt.character.window_id = dr->window_id;
 			break;
 		}
 #endif /* SDL_TEXTINPUTEVENT_TEXT_SIZE */
@@ -893,6 +1008,7 @@
 		case SDL_KEYUP:
 			sdl_translate_key(sdl_evt.key.keysym.sym, &gpac_evt.key);
 			gpac_evt.type = (sdl_evt.key.type==SDL_KEYDOWN) ? GF_EVENT_KEYDOWN : GF_EVENT_KEYUP;
+			gpac_evt.key.window_id = dr->window_id;
 			dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 			if (gpac_evt.key.key_code==GF_KEY_CONTROL) ctx->ctrl_down = (sdl_evt.key.type==SDL_KEYDOWN) ? GF_TRUE : GF_FALSE;
 			else if (gpac_evt.key.key_code==GF_KEY_ALT) ctx->alt_down = (sdl_evt.key.type==SDL_KEYDOWN) ? GF_TRUE : GF_FALSE;
@@ -903,6 +1019,7 @@
 				if ((gpac_evt.key.key_code==GF_KEY_ENTER) || (gpac_evt.key.key_code==GF_KEY_BACKSPACE)) {
 					gpac_evt.type = GF_EVENT_TEXTINPUT;
 					gpac_evt.character.unicode_char = (gpac_evt.key.key_code==GF_KEY_ENTER) ? '\r' : '\b';
+					gpac_evt.character.window_id = dr->window_id;
 					dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 				}
 			}
@@ -920,6 +1037,7 @@
 			 ) {
 				gpac_evt.type = GF_EVENT_PASTE_TEXT;
 				gpac_evt.clipboard.text = (char *) SDL_GetClipboardText();
+				gpac_evt.clipboard.window_id = dr->window_id;
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 				SDL_free(gpac_evt.clipboard.text);
 			}
@@ -944,6 +1062,7 @@
 			 && ((sdl_evt.key.keysym.unicode=='\r') || (sdl_evt.key.keysym.unicode=='\n') || (sdl_evt.key.keysym.unicode=='\b') || (sdl_evt.key.keysym.unicode=='\t') )
 			 ) {
 				gpac_evt.character.unicode_char = sdl_evt.key.keysym.unicode;
+				gpac_evt.character.window_id = dr->window_id;
 				gpac_evt.type = GF_EVENT_TEXTINPUT;
 				dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 			}
@@ -951,20 +1070,42 @@
 #endif
 			break;
 
+		/* rescale mouse event (not multitouch) to highDPI coords - not yet supported in SDL, see https://github.com/libsdl-org/SDL/issues/2999*/
+
 		/*mouse*/
 		case SDL_MOUSEMOTION:
 			ctx->last_mouse_move = SDL_GetTicks();
 			gpac_evt.type = GF_EVENT_MOUSEMOVE;
-			gpac_evt.mouse.x = sdl_evt.motion.x;
-			gpac_evt.mouse.y = sdl_evt.motion.y;
+			gpac_evt.mouse.window_id = dr->window_id;
+
+#if SDL_VERSION_ATLEAST(2,0,0)
+			if (ctx->low_dpi_w && ctx->low_dpi_h) {
+				gpac_evt.mouse.x = (u32) ( (u64) sdl_evt.motion.x * ctx->high_dpi_w / ctx->low_dpi_w);
+				gpac_evt.mouse.y = (u32) ( (u64) sdl_evt.motion.y * ctx->high_dpi_h / ctx->low_dpi_h);
+			} else
+#endif
+			{
+				gpac_evt.mouse.x = sdl_evt.motion.x;
+				gpac_evt.mouse.y = sdl_evt.motion.y;
+			}
+
 			dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 			break;
 		case SDL_MOUSEBUTTONDOWN:
 		case SDL_MOUSEBUTTONUP:
 			ctx->last_mouse_move = SDL_GetTicks();
-			gpac_evt.mouse.x = sdl_evt.motion.x;
-			gpac_evt.mouse.y = sdl_evt.motion.y;
+#if SDL_VERSION_ATLEAST(2,0,0)
+			if (ctx->low_dpi_w && ctx->low_dpi_h) {
+				gpac_evt.mouse.x = (u32) ( (u64) sdl_evt.motion.x * ctx->high_dpi_w / ctx->low_dpi_w);
+				gpac_evt.mouse.y = (u32) ( (u64) sdl_evt.motion.y * ctx->high_dpi_h / ctx->low_dpi_h);
+			} else
+#endif
+			{
+				gpac_evt.mouse.x = sdl_evt.motion.x;
+				gpac_evt.mouse.y = sdl_evt.motion.y;
+			}
 			gpac_evt.type = (sdl_evt.type==SDL_MOUSEBUTTONUP) ? GF_EVENT_MOUSEUP : GF_EVENT_MOUSEDOWN;
+			gpac_evt.mouse.window_id = dr->window_id;
 			switch (sdl_evt.button.button) {
 			case SDL_BUTTON_LEFT:
 				gpac_evt.mouse.button = GF_MOUSE_LEFT;
@@ -996,6 +1137,7 @@
 			the wheel was rotated...*/
 			gpac_evt.mouse.wheel_pos = INT2FIX(sdl_evt.wheel.y);
 			gpac_evt.type = GF_EVENT_MOUSEWHEEL;
+			gpac_evt.mouse.window_id = dr->window_id;
 			dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 			break;
 
@@ -1005,6 +1147,7 @@
 			gpac_evt.mtouch.num_fingers = sdl_evt.mgesture.numFingers;
 			gpac_evt.mtouch.rotation = sdl_evt.mgesture.dTheta;
 			gpac_evt.mtouch.pinch = sdl_evt.mgesture.dDist;
+			gpac_evt.mtouch.window_id = dr->window_id;
 			gpac_evt.type = GF_EVENT_MULTITOUCH;
 			dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 			break;
@@ -1013,6 +1156,7 @@
 			gpac_evt.type = GF_EVENT_DROPFILE;
 			gpac_evt.open_file.nb_files = 1;
 			gpac_evt.open_file.files = &sdl_evt.drop.file;
+			gpac_evt.open_file.window_id = dr->window_id;
 			dr->on_event(dr->evt_cbk_hdl, &gpac_evt);
 
 
@@ -1099,8 +1243,8 @@
 		show_window = GF_TRUE;
 	}
 
-	ctx->force_alpha = (init_flags & GF_TERM_WINDOW_TRANSPARENT) ? GF_TRUE : GF_FALSE;
-	ctx->hidden = (init_flags & GF_TERM_INIT_HIDE) ? GF_TRUE : GF_FALSE;
+	ctx->force_alpha = (init_flags & GF_VOUT_WINDOW_TRANSPARENT) ? GF_TRUE : GF_FALSE;
+	ctx->hidden = (init_flags & GF_VOUT_INIT_HIDE) ? GF_TRUE : GF_FALSE;
 
 	if (!ctx->hidden && show_window) {
 #if SDL_VERSION_ATLEAST(2,0,0)
@@ -1127,7 +1271,11 @@
 	}
 #else
 	if (!SDLVid_InitializeWindow(ctx, dr)) {
-		SDL_QuitSubSystem(SDL_INIT_VIDEO);
+		if (!gf_list_count(video_outputs)) {
+			SDL_QuitSubSystem(SDL_INIT_VIDEO);
+			gf_list_del(video_outputs);
+			video_outputs=NULL;
+		}
 		SDLOUT_CloseSDL();
 		return GF_IO_ERR;
 	}
@@ -1169,6 +1317,7 @@
 
 	SDLOUT_CloseSDL();
 	ctx->is_init = GF_FALSE;
+	dr->window_id = 0;
 }
 
 
@@ -1690,6 +1839,23 @@
 #endif
 	}
 		return GF_OK;
+
+#if SDL_VERSION_ATLEAST(2,0,0)
+	case GF_EVENT_SET_ORIENTATION:
+	{
+		switch (evt->size.orientation) {
+		case GF_DISPLAY_MODE_PORTRAIT: SDL_SetHint(SDL_HINT_ORIENTATIONS, "Portrait"); break;
+		case GF_DISPLAY_MODE_PORTRAIT_INV: SDL_SetHint(SDL_HINT_ORIENTATIONS, "PortraitUpsideDown"); break;
+		case GF_DISPLAY_MODE_LANDSCAPE: SDL_SetHint(SDL_HINT_ORIENTATIONS, "LandscapeRight"); break;
+		case GF_DISPLAY_MODE_LANDSCAPE_INV: SDL_SetHint(SDL_HINT_ORIENTATIONS, "LandscapeLeft"); break;
+		case GF_DISPLAY_MODE_UNKNOWN:
+			SDL_SetHint(SDL_HINT_ORIENTATIONS, "LandscapeLeft LandscapeRight Portrait PortraitUpsideDown");
+			break;
+		}
+		return GF_OK;
+	}
+#endif
+
 	}
 	return GF_OK;
 }
@@ -2072,6 +2238,15 @@
 	gf_th_del(ctx->sdl_th);
 #endif
 	gf_mx_del(ctx->evt_mx);
+
+	gf_list_del_item(video_outputs, dr);
+	nb_video_outputs = gf_list_count(video_outputs);
+	if (!nb_video_outputs) {
+		gf_list_del(video_outputs);
+		video_outputs = NULL;
+
+		SDL_QuitSubSystem(SDL_INIT_VIDEO);
+	}
 	gf_free(ctx);
 	gf_free(dr);
 }

gpac-2.0.0.tar.gz/modules/validator/Makefile -> gpac-2.2.0.tar.gz/modules/validator/Makefile Changed

gpac-2.0.0.tar.gz/modules/validator/validator.c -> gpac-2.2.0.tar.gz/modules/validator/validator.c Changed

@@ -28,7 +28,8 @@
 #include <gpac/internal/compositor_dev.h>
 #include <gpac/internal/media_dev.h>
 #include <gpac/xml.h>
-#include <gpac/options.h>
+
+#ifndef GPAC_DISABLE_PLAYER
 
 typedef struct __validation_module
 {
@@ -148,21 +149,26 @@
 	} else {
 		u32 dst_size = fb.width*fb.height*3;
 		char *dst = (char*)gf_malloc(sizeof(char)*dst_size);
+		if (!dst) e = GF_OUT_OF_MEM;
 
-		e = gf_img_png_enc(fb.video_buffer, fb.width, fb.height, fb.pitch_y, fb.pixel_format, dst, &dst_size);
-		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("Validator Error encoding PNG %s\n", gf_error_to_string(e)));
-		} else {
+		if (!e)
+			e = gf_img_png_enc(fb.video_buffer, fb.width, fb.height, fb.pitch_y, fb.pixel_format, dst, &dst_size);
+
+		if (!e) {
 			FILE *png = gf_fopen(dumpname, "wb");
 			if (!png) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("Validator Error writing file %s\n", dumpname));
+				e = GF_IO_ERR;
 			} else {
-				gf_fwrite(dst, dst_size, png);
+				if (gf_fwrite(dst, dst_size, png)!=dst_size) e = GF_IO_ERR;
 				gf_fclose(png);
-				GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator Writing file %s\n", dumpname));
 			}
 		}
 		if (dst) gf_free(dst);
+		if (e) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("Validator Error encoding PNG to %s: %s\n", dumpname, gf_error_to_string(e)));
+		} else {
+			GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator Writing file %s\n", dumpname));
+		}
 		gf_sc_release_screen_buffer(compositor, &fb);
 	}
 	validator->snapshot_number++;
@@ -865,7 +871,7 @@
 //deprecated		gf_sc_add_video_listener(validator->compositor, &validator->video_listener);
 		if (validator->is_recording)
 			validator->snapshot_next_frame = GF_TRUE;
-		gf_sc_connect_from_time_ex(validator->compositor, filename, 0, 0, 0, NULL);
+		gf_sc_connect_from_time(validator->compositor, filename, 0, 0, 0, NULL);
 
 	}
 //	validator->ck = validator->compositor->root_scene->scene_codec ? validator->compositor->root_scene->scene_codec->ck : validator->compositor->root_scene->dyn_ck;
@@ -970,6 +976,7 @@
 	}
 	validator->evt_loaded = GF_TRUE;
 	validator->compositor->sys_frames_pending = GF_TRUE;
+	validator->compositor->event_pending = GF_TRUE;
 	return GF_TRUE;
 }
 
@@ -980,7 +987,7 @@
 
 	switch (action) {
 
-	/* Upon starting of the terminal, we parse (possibly an XVL file), an XVS file, and start the first test sequence */
+	/* Upon starting of the compositor, we parse (possibly an XVL file), an XVS file, and start the first test sequence */
 	case GF_COMPOSITOR_EXT_START:
 		validator->compositor = (GF_Compositor *) param;
 
@@ -1072,9 +1079,9 @@
 		}
 		return GF_TRUE;
 
-	/* when the terminal stops, we close the XVS parser and XVL parser if any, restore the config,
+	/* when the compositor stops, we close the XVS parser and XVL parser if any, restore the config,
 	and free all validator data (the validator will be destroyed when the module is unloaded)
-	Note: we don't need to disconnect the terminal since it's already stopping */
+	Note: we don't need to disconnect the compositor since it's already stopping */
 	case GF_COMPOSITOR_EXT_STOP:
 		gf_filter_remove_event_listener(validator->compositor->filter, &validator->evt_filter);
 		validator_xvs_close(validator);
@@ -1095,13 +1102,14 @@
 		GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Stopping validator\n"));
 		break;
 
-	/* When called in the main loop of the terminal, we don't do anything in the recording mode.
+	/* When called in the main loop of the compositor, we don't do anything in the recording mode.
 	 In the playing/validating mode, we need to check if an event needs to be dispatched or if snapshots need to be made,
 	 until there is no more event, in which case we trigger either the load of the next XVS or the quit */
 	case GF_COMPOSITOR_EXT_PROCESS:
 		/* if the time is right, dispatch the event and load the next one */
 		while (!validator->is_recording && validator->evt_loaded && validator->root_odm && validator->root_odm->ck && (validator->next_time <= gf_clock_time(validator->root_odm->ck) )) {
 			Bool has_more_events;
+			validator->compositor->event_pending = GF_FALSE;
 			//u32 diff = gf_clock_time(validator->ck) - validator->next_time;
 			//GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("Validator Time diff: evt_time=%d clock_time = %d, diff=%d\n", validator->next_time, gf_clock_time(validator->ck), diff));
 			if (validator->next_event_snapshot) {
@@ -1197,3 +1205,7 @@
 }
 
 GPAC_MODULE_STATIC_DECLARATION( validator )
+
+
+#endif //#ifndef GPAC_DISABLE_PLAYER
+

gpac-2.0.0.tar.gz/modules/x11_out/Makefile -> gpac-2.2.0.tar.gz/modules/x11_out/Makefile Changed

gpac-2.0.0.tar.gz/modules/x11_out/x11_out.c -> gpac-2.2.0.tar.gz/modules/x11_out/x11_out.c Changed

@@ -26,7 +26,6 @@
 #include "x11_out.h"
 #include <gpac/constants.h>
 #include <gpac/utf.h>
-#include <gpac/user.h>
 #include <sys/time.h>
 #include <X11/XKBlib.h>
 #include <X11/Xatom.h>
@@ -1042,7 +1041,6 @@
 		XUnmapWindow (xWindow->display, xWindow->full_wnd);
 		XMapWindow (xWindow->display, xWindow->wnd);
 		XUngrabKeyboard(xWindow->display, CurrentTime);
-		/*looks like this makes osmozilla crash*/
 		//if (xWindow->par_wnd) XSetInputFocus(xWindow->display, xWindow->wnd, RevertToNone, CurrentTime);
 
 		GF_Event evt;
@@ -1234,7 +1232,7 @@
 		 xWindow->visual, 0, NULL);
 	}
 
-	if (!(xWindow->init_flags & GF_TERM_INIT_HIDE)) {
+	if (!(xWindow->init_flags & GF_VOUT_INIT_HIDE)) {
 		XMapWindow (xWindow->display, (Window) xWindow->wnd);
 	}
 
@@ -1257,7 +1255,7 @@
 		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("X11 Cannot select input focus\n"));
 	}
 	XSync(xWindow->display, False);
-	if (!(xWindow->init_flags & GF_TERM_INIT_HIDE)) {
+	if (!(xWindow->init_flags & GF_VOUT_INIT_HIDE)) {
 		XMapWindow (xWindow->display, (Window) xWindow->wnd);
 	}
 	XSizeHints *Hints = XAllocSizeHints ();
@@ -1286,7 +1284,7 @@
 	XkbSetDetectableAutoRepeat(xWindow->display, autorepeat, &supported);
 
 
-	if (xWindow->init_flags & GF_TERM_WINDOW_NO_DECORATION) {
+	if (xWindow->init_flags & GF_VOUT_WINDOW_NO_DECORATION) {
 #define PROP_MOTIF_WM_HINTS_ELEMENTS 5
 #define MWM_HINTS_DECORATIONS (1L << 1)
 		struct {
@@ -1523,12 +1521,11 @@
 
 	//window already setup and this restup asks for visible, show window
 	if (xWindow->wnd) {
-		if (!(xWindow->init_flags & GF_TERM_INIT_HIDE)) {
+		if (!(xWindow->init_flags & GF_VOUT_INIT_HIDE)) {
 			XMapWindow (xWindow->display, (Window) xWindow->wnd);
 		}
 	}
 
-	/*OSMOZILLA HACK*/
 	if (os_display) xWindow->no_select_input = 1;
 
 	/*the rest is done THROUGH THE MAIN RENDERER TRHEAD!!*/

gpac-2.0.0.tar.gz/modules/x11_out/x11_out.h -> gpac-2.2.0.tar.gz/modules/x11_out/x11_out.h Changed

@@ -2,7 +2,7 @@
 *					GPAC Multimedia Framework
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2005-2020
+ *			Copyright (c) Telecom ParisTech 2005-2022
 *					All rights reserved
 *
 * This file is part of GPAC / X11 video output module
@@ -39,7 +39,7 @@
 #include <X11/Xutil.h>
 #include <X11/keysym.h>
 
-#if !defined(GPAC_DISABLE_3D) && !defined(GPAC_USE_GLES1X) && !defined(GPAC_USE_TINYGL)
+#if !defined(GPAC_DISABLE_3D) && !defined(GPAC_USE_GLES1X) && !defined(GPAC_USE_TINYGL) && defined(GPAC_HAS_X11_GLX)
 #define GPAC_HAS_OPENGL
 #endif
 
@@ -58,12 +58,6 @@
 #include <X11/extensions/Xvlib.h>
 #endif
 
-#if defined(ENABLE_JOYSTICK) || defined(ENABLE_JOYSTICK_NO_CURSOR)
-#include <linux/joystick.h>
-#include <unistd.h>
-#include <fcntl.h>
-#endif
-
 #define X11VID()	XWindow *xWindow = (XWindow *)vout->opaque;
 
 #define RGB555(r,g,b) (((r&248)<<7) + ((g&248)<<2) + (b>>3))
@@ -121,10 +115,6 @@
 	Window gl_wnd;
 	u32 offscreen_type;
 #endif
-#if defined(ENABLE_JOYSTICK) || defined(ENABLE_JOYSTICK_NO_CURSOR)
-	/*joystick device file descriptor*/
-	s32 prev_x, prev_y, fd;
-#endif
 } XWindow;
 
 void StretchBits (void *dst, u32 dst_bpp, u32 dst_w, u32 dst_h, u32 dst_pitch,

gpac-2.0.0.tar.gz/packagers/osx/GPAC.app/Contents/Info.plist -> gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Info.plist Changed

@@ -13,7 +13,7 @@
 				<string>xmt</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-4 BIFS Text</string>
 			<key>CFBundleTypeRole</key>
@@ -26,7 +26,7 @@
 				<string>x3d</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_model.icns</string>
+			<string>gpac_model.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Web3D VRML/X3D File</string>
 			<key>CFBundleTypeRole</key>
@@ -38,7 +38,7 @@
 				<string>svg</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>W3C SVG File</string>
 			<key>CFBundleTypeRole</key>
@@ -50,7 +50,7 @@
 				<string>saf</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-4 SAF/LASeR File</string>
 			<key>CFBundleTypeRole</key>
@@ -62,7 +62,7 @@
 				<string>flv</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Flash Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -74,7 +74,7 @@
 				<string>pls</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Shoutcast playlist</string>
 			<key>CFBundleTypeRole</key>
@@ -87,7 +87,7 @@
 				<string>m3u8</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Playlist file</string>
 			<key>CFBundleTypeRole</key>
@@ -100,7 +100,7 @@
 				<string>aif</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>AIFF file</string>
 			<key>CFBundleTypeRole</key>
@@ -112,7 +112,7 @@
 				<string>sdp</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Session Description Protocol File</string>
 			<key>CFBundleTypeRole</key>
@@ -124,7 +124,7 @@
 				<string>wav</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>WAVE Audio File</string>
 			<key>CFBundleTypeRole</key>
@@ -136,7 +136,7 @@
 				<string>vob</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>DVD Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -149,7 +149,7 @@
 				<string>ac3</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Digital Audio</string>
 			<key>CFBundleTypeRole</key>
@@ -161,7 +161,7 @@
 				<string>aac</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>AAC file</string>
 			<key>CFBundleTypeRole</key>
@@ -173,7 +173,7 @@
 				<string>ogm</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Ogg MPEG-4 Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -185,7 +185,7 @@
 				<string>ogg</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeMIMETypes</key>
 			<array>
 				<string>audio/ogg</string>
@@ -201,7 +201,7 @@
 				<string>ogv</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeMIMETypes</key>
 			<array>
 				<string>video/ogg</string>
@@ -217,7 +217,7 @@
 				<string>avi</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>AVI container</string>
 			<key>CFBundleTypeRole</key>
@@ -231,7 +231,7 @@
 				<string>qt</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeMIMETypes</key>
 			<array>
 				<string>video/quicktime</string>
@@ -247,7 +247,7 @@
 				<string>asf</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Advanced Streaming Format</string>
 			<key>CFBundleTypeRole</key>
@@ -259,7 +259,7 @@
 				<string>wma</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Windows Media Audio</string>
 			<key>CFBundleTypeRole</key>
@@ -272,7 +272,7 @@
 				<string>wm</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Windows Media Video</string>
 			<key>CFBundleTypeRole</key>
@@ -287,7 +287,7 @@
 				<string>mpeg2</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>multiplexed MPEG-1/2</string>
 			<key>CFBundleTypeRole</key>
@@ -299,7 +299,7 @@
 				<string>m1v</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-1 Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -315,7 +315,7 @@
 				<string>mpa</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG Audio File</string>
 			<key>CFBundleTypeRole</key>
@@ -328,7 +328,7 @@
 				<string>ps</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-2 Program Stream</string>
 			<key>CFBundleTypeRole</key>
@@ -343,7 +343,7 @@
 				<string>mt2s</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeMIMETypes</key>
 			<array>
 				<string>video/mp2t</string>
@@ -360,7 +360,7 @@
 				<string>mpv</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-2 Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -372,7 +372,7 @@
 				<string>m4i</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-4 Application</string>
 			<key>CFBundleTypeRole</key>
@@ -385,7 +385,7 @@
 				<string>mpeg4</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_generic.icns</string>
+			<string>gpac_generic.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-4 File</string>
 			<key>CFBundleTypeRole</key>
@@ -397,7 +397,7 @@
 				<string>m4v</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-4 Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -409,7 +409,7 @@
 				<string>m4a</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>MPEG-4 Audio File</string>
 			<key>CFBundleTypeRole</key>
@@ -421,7 +421,7 @@
 				<string>3gp</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>3GPP File</string>
 			<key>CFBundleTypeRole</key>
@@ -433,7 +433,7 @@
 				<string>mka</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_audio.icns</string>
+			<string>gpac_audio.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Matroska Audio File</string>
 			<key>CFBundleTypeRole</key>
@@ -445,7 +445,7 @@
 				<string>mkv</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Matroska Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -457,7 +457,7 @@
 				<string>webm</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_video.icns</string>
+			<string>gpac_video.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>WebM Video File</string>
 			<key>CFBundleTypeRole</key>
@@ -469,7 +469,7 @@
 				<string>srt</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_subs.icns</string>
+			<string>gpac_subs.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>Subrip Subtitle File</string>
 			<key>CFBundleTypeRole</key>
@@ -485,7 +485,7 @@
 				<string>ttxt</string>
 			</array>
 			<key>CFBundleTypeIconFile</key>
-			<string>osmo_subs.icns</string>
+			<string>gpac_subs.icns</string>
 			<key>CFBundleTypeName</key>
 			<string>3GPP Subtitle File</string>
 			<key>CFBundleTypeRole</key>
@@ -497,23 +497,26 @@
 		</dict>
 	</array>
 	<key>CFBundleExecutable</key>
-	<string>Osmo4</string>
+	<string>gpac</string>
 	<key>CFBundleGetInfoString</key>
-	<string>Copyright © 2003-2020 Telecom Paris</string>
+	<string>Copyright © 2003-2022 Telecom Paris</string>
 	<key>CFBundleIconFile</key>
-	<string>osmo.icns</string>
+	<string>gpac.icns</string>
 	<key>CFBundleIdentifier</key>
 	<string>com.enst.gpac</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>CFBundleName</key>
-	<string>Osmo4</string>
+	<string>GPAC</string>
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
+	<key>LSEnvironment</key>
+	<dict>
+		<key>GPAC_GUI</key>
+		<string>yes</string>
+	</dict>
 	<key>CFBundleShortVersionString</key>
-
-	<string>9.9.9</string>
+	<string>2.2</string>
 	<key>CFBundleSignature</key>
 	<string>gpac</string>
 	<key>CFBundleURLTypes</key>
@@ -559,10 +562,12 @@
 			</array>
 		</dict>
 	</array>
+	<key>NSCameraUsageDescription</key>
+	<string>GPAC needs camera access to handle this URL</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>GPAC needs microphone access to handle this URL</string>
 	<key>CFBundleVersion</key>
-
-	<string>9999</string>
+	<string>12.10.0</string>
 	<key>LSMinimumSystemVersion</key>
 	<string>10.5.0</string>
 	<key>NSMainNibFile</key>

gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Resources/gpac.icns Changed

gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Resources/gpac_audio.icns Changed

gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Resources/gpac_generic.icns Changed

gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Resources/gpac_model.icns Changed

gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Resources/gpac_subs.icns Changed

gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Resources/gpac_video.icns Changed

gpac-2.2.0.tar.gz/packagers/osx/GPAC.app/Contents/Resources/gpac_widget.icns Changed

gpac-2.0.0.tar.gz/packagers/osx/distribution.xml -> gpac-2.2.0.tar.gz/packagers/osx/distribution.xml Changed

gpac-2.0.0.tar.gz/packagers/win32_64/nsis/gpac_installer.nsi -> gpac-2.2.0.tar.gz/packagers/win32_64/nsis/gpac_installer.nsi Changed

@@ -1,6 +1,6 @@
 ;--------------------------------
 ;General
-!define GPAC_VERSION 2.0
+!define GPAC_VERSION 2.2
 !include default.out
 
 !define GPAC_ROOT ..\..\..
@@ -39,8 +39,8 @@
   !include "MUI2.nsh"
 
 WindowIcon on
-Icon "${GPAC_ROOT}\share\doc\osmo4.ico"
-UninstallIcon "${GPAC_ROOT}\share\doc\osmo4.ico"
+Icon "${GPAC_ROOT}\share\doc\gpac.ico"
+UninstallIcon "${GPAC_ROOT}\share\doc\gpac.ico"
 
 ;--------------------------------
 ;Interface Settings
@@ -73,7 +73,7 @@
 	nsDialogs::Create 1018
 	Pop $DIALOG
 
-  ${NSD_CreateLabel} 0 0 100% 120u "Multimedia technologies are often covered by various patents which are most of the time hard to identify. These patents may or may not apply in your local jurisdiction. By installing this software, you acknowledge that you may have to pay royaltee fees in order to legally use this software. Do not proceed with this setup if you do not understand or do not agree with these terms. In any case, the authors and/or distributors bears no liability for any infringing usage of this software, which is provided for educational or research purposes."
+  ${NSD_CreateLabel} 0 0 100% 120u "Multimedia technologies are often covered by various patents which are most of the time hard to identify. These patents may or may not apply in your local jurisdiction.$\r$\nBy installing this software, you acknowledge that you may have to pay royaltee fees in order to legally use this software.$\r$\n$\r$\nDo not proceed with this setup if you do not understand or do not agree with these terms.$\r$\n$\r$\nIn any case, the authors and/or distributors bears no liability for any infringing usage of this software, which is provided for educational or research purposes."
 	Pop $Label
 
   ${NSD_CreateCheckBox} 0 -30 100% 12u "I understand and accept the conditions"
@@ -88,6 +88,8 @@
 ;--------------------------------
 ;Pages
 
+!define MUI_WELCOMEPAGE_TITLE  "Welcome to GPAC ${GPAC_VERSION} Setup"
+
   !insertmacro MUI_PAGE_WELCOME
   !insertmacro MUI_PAGE_LICENSE "${GPAC_ROOT}\COPYING"
   Page custom customPage
@@ -201,47 +203,6 @@
 
 !define DeleteRegKeyAuth "!insertmacro DeleteRegKeyAuth"
 
-Function InsertGDIPLUS
-   Push $R0
-   Push $R1
-   ReadRegStr $R0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
-   StrCmp $R0 "" 0 lbl_winnt
-
-   ;NOT NT
-   ReadRegStr $R0 HKLM SOFTWARE\Microsoft\Windows\CurrentVersion VersionNumber
-
-   StrCpy $R1 $R0 1
-   ; win95, NOT SUPPORTED
-   StrCmp $R1 '4' 0 lbl_err_95
-   StrCpy $R1 $R0 3
-   StrCmp $R1 '4.0' lbl_err_95
-   ;winME or 98 otherwise
-   StrCmp $R1 '4.9' lbl_add lbl_add
-
-lbl_err_nt:
-   MessageBox MB_OK "Microsoft GDI+ cannot be installed on NT 3 Systems"
-   Goto lbl_done
-
-lbl_err_95:
-   MessageBox MB_OK "Microsoft GDI+ cannot be installed on Windows 95 and older Systems"
-   Goto lbl_done
-
-lbl_winnt:
-   StrCpy $R1 $R0 1
-   StrCmp $R1 '3' lbl_err_nt
-   StrCmp $R1 '4' lbl_add
-   StrCpy $R1 $R0 3
-   StrCmp $R1 '5.0' lbl_add	;2000
-   StrCmp $R1 '5.1' lbl_xp	;XP
-   StrCmp $R1 '5.2' lbl_done	;.NET server
-
-lbl_add:
-
-lbl_xp:
-
-lbl_done:
-FunctionEnd
-
 ;GPAC core
 Section "GPAC Core" SecGPAC
   SectionIn RO
@@ -250,11 +211,15 @@
   File /oname=ReadMe.txt "${GPAC_ROOT}\README.md"
   File /oname=License.txt "${GPAC_ROOT}\COPYING"
   File /oname=Changelog.txt "${GPAC_ROOT}\Changelog"
-  File "${GPAC_ROOT}\share\doc\osmo4.ico"
+  File "${GPAC_ROOT}\share\doc\gpac.ico"
+
+  File "${GPAC_BIN}\gpac.exe"
   File "${GPAC_BIN}\libgpac.dll"
+  File "${GPAC_BIN}\gm_dx_hw.dll"
+
+  ;all our deps
   File "${GPAC_BIN}\libcryptoMD.dll"
   File "${GPAC_BIN}\libsslMD.dll"
-
   File "${GPAC_BIN}\avcodec-*.dll"
   File "${GPAC_BIN}\avdevice-*.dll"
   File "${GPAC_BIN}\avfilter-*.dll"
@@ -266,27 +231,7 @@
   File "${GPAC_BIN}\libx264-*.dll"
   File "${GPAC_BIN}\OpenSVCDecoder.dll"
 
-  ;create default cache
-  SetOutPath $INSTDIR\cache
-
-  SetOutPath $INSTDIR
-
-  ${WriteRegStrAuth} HKCU "SOFTWARE\GPAC" "InstallDir" "$INSTDIR"
-  ${WriteRegStrAuth} HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\GPAC" "DisplayName" "GPAC (remove only)"
-  ${WriteRegStrAuth} HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\GPAC" "UninstallString" "$INSTDIR\uninstall.exe"
-  WriteUninstaller "uninstall.exe"
-
-SectionEnd
-
-;player install
-Section "GPAC Player" SecOsmo4
-  SectionIn 1
-
-  File "${GPAC_BIN}\MP4Client.exe"
-
-  File "${GPAC_BIN}\gm_dx_hw.dll"
-
-  ;copy shared res
+  ;copy shared resources
   SetOutPath $INSTDIR\share
   File "${GPAC_ROOT}\share\default.cfg"
   SetOutPath $INSTDIR\share\res
@@ -297,7 +242,6 @@
   File "${GPAC_ROOT}\share\gui\gui.bt"
   File "${GPAC_ROOT}\share\gui\gui.js"
   File "${GPAC_ROOT}\share\gui\gwlib.js"
-;  File "${GPAC_ROOT}\share\gui\mpegu-core.js"
   SetOutPath $INSTDIR\share\gui\icons
   File /r /x .git ${GPAC_ROOT}\share\gui\icons\*
   SetOutPath $INSTDIR\share\gui\extensions
@@ -307,10 +251,6 @@
   SetOutPath $INSTDIR\share\scripts
   File /r /x .git ${GPAC_ROOT}\share\scripts\*
 
-  ;copy python
-  SetOutPath $INSTDIR\share\python
-  File /r /x .git ${GPAC_ROOT}\share\python\*
-
   ;copy shaders
   SetOutPath $INSTDIR\share\shaders
   File /r /x .git ${GPAC_ROOT}\share\shaders\*
@@ -319,16 +259,22 @@
   SetOutPath $INSTDIR\share\lang
   File /r /x .git ${GPAC_ROOT}\share\lang\*
 
-  ;copy vis
-  SetOutPath $INSTDIR\share\vis
-  File /r /x .git ${GPAC_ROOT}\share\vis\*
-
+  ;create default cache
+  SetOutPath $INSTDIR\cache
   SetOutPath $INSTDIR
+
+  ;update registry
+  ${WriteRegStrAuth} HKCU "SOFTWARE\GPAC" "InstallDir" "$INSTDIR"
+  ${WriteRegStrAuth} HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\GPAC" "DisplayName" "GPAC (remove only)"
+  ${WriteRegStrAuth} HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\GPAC" "UninstallString" "$INSTDIR\uninstall.exe"
+  WriteUninstaller "uninstall.exe"
+
+  Push $INSTDIR
+  Call AddToPath
 SectionEnd
 
 SubSection "GPAC Plugins" SecPlugins
 
-
 Section "FreeType" SecFT
   SectionIn 1
   File "${GPAC_BIN}\gm_ft_font.dll"
@@ -341,7 +287,12 @@
 
 Section "SDL" SecSDL
   SectionIn 1
+!if /FileExists "${GPAC_BIN}\SDL.dll"
   File "${GPAC_BIN}\SDL.dll"
+!endif
+!if /FileExists "${GPAC_BIN}\SDL2.dll"
+  File "${GPAC_BIN}\SDL2.dll"
+!endif
   File "${GPAC_BIN}\gm_sdl_out.dll"
 SectionEnd
 
@@ -367,15 +318,19 @@
   Call AddToPath
 SectionEnd
 
-Section "gpac" SecGPACBIN
+Section "Remotery Visualizer" SecRMT
   SectionIn 1
-  SetOutPath $INSTDIR
-  File "${GPAC_BIN}\gpac.exe"
-  Push $INSTDIR
-  Call AddToPath
+  SetOutPath $INSTDIR\share\vis
+  File /r /x .git ${GPAC_ROOT}\share\vis\*
 SectionEnd
 
 
+Section "Python Bindings" SecPython
+  SectionIn 1
+  SetOutPath $INSTDIR\share\python
+  File /r /x .git ${GPAC_ROOT}\share\python\*
+SectionEnd
+
 Section "GPAC SDK" SecSDK
   SectionIn 1
   SetOutPath $INSTDIR\sdk\include
@@ -419,7 +374,7 @@
 SectionEnd
 
 
-SubSection "GPAC Shortcuts"
+SubSection "GPAC Shortcuts" SecShortcuts
 
 Section "Add Start Menu Shortcuts"
   SectionIn 1
@@ -430,12 +385,11 @@
   SetShellVarContext all
   CreateDirectory "$SMPROGRAMS\GPAC"
   CreateShortCut "$SMPROGRAMS\GPAC\Uninstall.lnk" "$INSTDIR\uninstall.exe" "" "$INSTDIR\uninstall.exe" 0
-  CreateShortCut "$SMPROGRAMS\GPAC\Osmo4.lnk" "$INSTDIR\MP4Client.exe" ""
-  CreateShortCut "$SMPROGRAMS\GPAC\Osmo4 (with Console).lnk" "$INSTDIR\MP4Client.exe" "-guid"
+  CreateShortCut "$SMPROGRAMS\GPAC\GPAC.lnk" "$INSTDIR\gpac.exe" ""
+  CreateShortCut "$SMPROGRAMS\GPAC\Remotery GPAC.lnk" "$INSTDIR\share\vis\index.html" ""
   CreateShortCut "$SMPROGRAMS\GPAC\Readme.lnk" "$INSTDIR\ReadMe.txt"
   CreateShortCut "$SMPROGRAMS\GPAC\License.lnk" "$INSTDIR\License.txt"
   CreateShortCut "$SMPROGRAMS\GPAC\History.lnk" "$INSTDIR\changelog.txt"
-  CreateShortCut "$SMPROGRAMS\GPAC\Configuration Info.lnk" "$INSTDIR\configuration.html"
 SectionEnd
 
 SubSectionEnd
@@ -444,25 +398,25 @@
 
 !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
   !insertmacro MUI_DESCRIPTION_TEXT ${SecGPAC} "GPAC Core"
-  !insertmacro MUI_DESCRIPTION_TEXT ${SecOsmo4} "GPAC Player"
+  !insertmacro MUI_DESCRIPTION_TEXT ${SecMP4B} "MP4Box command-line tool for content packaging (MP4, DASH, HLS)"
   !insertmacro MUI_DESCRIPTION_TEXT ${SecPlugins} "GPAC Plugins"
   !insertmacro MUI_DESCRIPTION_TEXT ${SecFT} "FreeType font parsing"
-  !insertmacro MUI_DESCRIPTION_TEXT ${SecWAVE} "Windows MME Audio output support"
+  !insertmacro MUI_DESCRIPTION_TEXT ${SecWAVE} "Windows MME Audio output"
   !insertmacro MUI_DESCRIPTION_TEXT ${SecOHEVC} "Support for HEVC decoding through OpenHEVC Decoder"
 ;  !insertmacro MUI_DESCRIPTION_TEXT ${SecUPnP} "Support for UPnP based on Platinum"
 ;  !insertmacro MUI_DESCRIPTION_TEXT ${SecMPEGU} "Support for W3C and MPEG-U Widgets"
-  !insertmacro MUI_DESCRIPTION_TEXT ${SecMP4B} "MP4Box command-line tool for MP4 file manipulation"
-  !insertmacro MUI_DESCRIPTION_TEXT ${SecGPACBIN} "gpac command-line tool for various multimedia operations"
-  !insertmacro MUI_DESCRIPTION_TEXT ${SecSDK} "GPAC SDK: headers and library files needed to develop modules for GPAC or appllication based on GPAC"
-  !insertmacro MUI_DESCRIPTION_TEXT ${SecSDL} "GPAC SDL support"
+  !insertmacro MUI_DESCRIPTION_TEXT ${SecSDK} "Headers and library files needed to develop modules for GPAC or applications based on GPAC"
+  !insertmacro MUI_DESCRIPTION_TEXT ${SecPython} "Python bindings for libgpac"
+  !insertmacro MUI_DESCRIPTION_TEXT ${SecRMT} "Remotery HTML visualizer"
+  !insertmacro MUI_DESCRIPTION_TEXT ${SecSDL} "SDL Audio and Video output"
   !insertmacro MUI_DESCRIPTION_TEXT ${SecValidator} "GPAC Test Validator"
-
+  !insertmacro MUI_DESCRIPTION_TEXT ${SecShortcuts} "System menu shortucts"
 !insertmacro MUI_FUNCTION_DESCRIPTION_END
 
 
 Function .onInstSuccess
 ;  MessageBox MB_YESNO "GPAC Framework installation complete. Do you want to launch the player?" IDNO NoLaunch
-;  Exec $INSTDIR\Osmo4.exe
+;  Exec $INSTDIR\gpac.exe
 ;  NoLaunch:
 FunctionEnd
 
@@ -479,7 +433,6 @@
   ; remove registry keys
   ${DeleteRegKeyAuth} HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\GPAC"
   ${DeleteRegKeyAuth} HKCU "SOFTWARE\GPAC"
-  ${DeleteRegKeyAuth} HKCU "SOFTWARE\MozillaPlugins\@gpac/osmozilla,version=1.0"
   ${DeleteRegKeyAuth} HKCR GPAC\mp4\DefaultIcon
   ${DeleteRegKeyAuth} HKCR GPAC\mp4\shell\open\command
   ${DeleteRegKeyAuth} HKCR GPAC\mp4
@@ -505,8 +458,8 @@
   SetShellVarContext all
   Delete "$SMPROGRAMS\GPAC\*.*"
   RMDir "$SMPROGRAMS\GPAC"
-  Delete "$QUICKLAUNCH\Osmo4.lnk"
-  Delete "$DESKTOP\Osmo4.lnk"
+  Delete "$QUICKLAUNCH\GPAC.lnk"
+  Delete "$DESKTOP\GPAC.lnk"
 
 SectionEnd
 
@@ -678,34 +631,6 @@
 #            Utility Functions            #
 ###########################################
 
-; IsNT
-; no input
-; output, top of the stack = 1 if NT or 0 if not
-;
-; Usage:
-;   Call IsNT
-;   Pop $R0
-;  ($R0 at this point is 1 or 0)
-
-!macro IsNT un
-Function ${un}IsNT
-  Push $0
-  ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
-  StrCmp $0 "" 0 IsNT_yes
-  ; we are not NT.
-  Pop $0
-  Push 0
-  Return
-
-  IsNT_yes:
-    ; NT!!!
-    Pop $0
-    Push 1
-FunctionEnd
-!macroend
-!insertmacro IsNT ""
-!insertmacro IsNT "un."
-
 ; StrStr
 ; input, top of stack = string to search for
 ;        top of stack-1 = string to search in

gpac-2.0.0.tar.gz/share/default.cfg -> gpac-2.2.0.tar.gz/share/default.cfg Changed

@@ -4,15 +4,15 @@
 -info=src=@{+1:N} inspect
 -mplay=src=@{+1:N} aout vout
 -bench=reframer:raw=av @ -o null -stats -i @{1}
--vbench=vout:!vsync -i @{1} -stats
+-vbench=-i @{1} vout:!vsync -stats
 -gui=-noprog compositor:player=gui -xopt
--mp4c=-i @{1} compositor:player=base
+-mp4c=compositor:player=base:src=@{1}
 gpac.aliasdoc
--play=play file. EX: gpac -play source.mp4
--plist=build seamless playlist of files. EX: gpac -plist s1.mp4 ... sN.mp4
--info=inspect files. EX: gpac -info s1.mp4 ... sN.mp4
--mplay=play input files in parallel. EX: gpac -mplay s1.mp4 ... sN.mp4
--bench=check decoding speed of source. EX: gpac -bench source.mp4
--vbench=check decoding and display speed of source. EX: gpac -vbench source.mp4
--gui=launch GUI (see `gpac -gui -h` for GUI options and `gpac -hx compositor` for compositor options)
--mp4c=launch player without GUI (same as MP4Client)
+-play=play file. Syntax: `gpac -play source.mp4`
+-plist=build seamless playlist of files. Syntax: `gpac -plist s1.mp4 ... sN.mp4`
+-info=inspect files. Syntax: `gpac -info s1.mp4 ... sN.mp4`
+-mplay=play input files in parallel. Syntax: `gpac -mplay s1.mp4 ... sN.mp4`
+-bench=check decoding speed of source. Syntax: `gpac -bench source.mp4`
+-vbench=check decoding and display speed of source. Syntax: `gpac -vbench source.mp4`
+-gui=launch GUI (see `gpac -h gui` for GUI options and `gpac -hx compositor` for compositor options)
+-mp4c=launch player without GUI (see `gpac -h/-hx mp4c` for options). Syntax: `gpac -mp4c URL`

gpac-2.0.0.tar.gz/share/deprecated/iphone_wm_gui.js -> gpac-2.2.0.tar.gz/share/deprecated/iphone_wm_gui.js Changed

gpac-2.0.0.tar.gz/share/deprecated/mpegu-core.js -> gpac-2.2.0.tar.gz/share/deprecated/mpegu-core.js Changed

gpac-2.0.0.tar.gz/share/doc/CODING_STYLE -> gpac-2.2.0.tar.gz/share/doc/CODING_STYLE Changed

gpac-2.0.0.tar.gz/share/doc/doxyfile -> gpac-2.2.0.tar.gz/share/doc/doxyfile Changed

@@ -765,6 +765,9 @@
 
 WARN_LOGFILE           = doxygen_warnings.txt
 
+WARN_AS_ERROR	 = FAIL_ON_WARNINGS
+
+
 #---------------------------------------------------------------------------
 # Configuration options related to the input files
 #---------------------------------------------------------------------------
@@ -776,7 +779,7 @@
 # Note: If this tag is empty the current directory is searched.
 
 #for some weird reason on OSX enumeration does not work properly, add IDL files by hand
-INPUT=../../include/gpac/ ../../README.md ../../share/doc/idl/core.idl ../../share/doc/idl/jsf.idl ../../share/doc/idl/xhr.idl ../../share/doc/idl/evg.idl ../../share/doc/idl/scenejs.idl ../../share/doc/idl/storage.idl ../../share/doc/idl/webgl.idl ../../share/doc/idl/filtersession.idl ../../share/doc/idl/dash_algo.idl  ../../share/doc/idl/nodejs.idl ../../share/python/libgpac.py
+INPUT=../../include/gpac/ ../../README.md ../../share/doc/idl/core.idl ../../share/doc/idl/jsf.idl ../../share/doc/idl/xhr.idl ../../share/doc/idl/evg.idl ../../share/doc/idl/scenejs.idl ../../share/doc/idl/storage.idl ../../share/doc/idl/webgl.idl ../../share/doc/idl/filtersession.idl ../../share/doc/idl/dash_algo.idl  ../../share/doc/idl/nodejs.idl ../../share/python/libgpac/libgpac.py
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses

gpac-2.0.0.tar.gz/share/doc/doxyfile-full -> gpac-2.2.0.tar.gz/share/doc/doxyfile-full Changed

gpac-2.2.0.tar.gz/share/doc/gpac.ico Changed

gpac-2.0.0.tar.gz/share/doc/idl/core.idl -> gpac-2.2.0.tar.gz/share/doc/idl/core.idl Changed

@@ -70,8 +70,8 @@
 void prompt_code(unsigned long code);
 
 
-/*! gets stdin terminal size - see \ref gf_prompt_get_size
-\return terminal size object, or null if not available
+/*! gets stdin TTY size - see \ref gf_prompt_get_size
+\return TTY size object, or null if not available
 */
 WinRect prompt_size();
 
@@ -137,14 +137,14 @@
 
 /*! gets UTC timestamp for a given date - see \ref gf_net_get_utc_ts
 \param year date's year
-\param month date's month of the year
-\param day date's day of the week
+\param month date's month of the year, 0 to 11
+\param day date's day of the week, 1 to 31
 \param hour date's hours
 \param min date's minutes
 \param sec date's seconds
 \return UTC 64 bit timestamp
 */
-unsigned long long get_utc();
+unsigned long long get_utc(unsigned long year, unsigned long month, unsigned long day, unsigned long hour, unsigned long min, unsigned long sec);
 
 
 /*! gets UTC clock from a date - see \ref gf_net_parse_date
@@ -337,10 +337,22 @@
 unsigned long pixfmt_size(DOMString pix_fmt, unsigned long width, unsigned long height);
 
 /*! checks if pixel format is potentially transparent (uses alpha)
-\param pcm_fmt PCM format name
+\param pix_fmt pixel format name
 \return true if transparent, false otherwise
 */
-unsigned long pixfmt_transparent(DOMString pcm_fmt);
+boolean pixfmt_transparent(DOMString pix_fmt);
+
+/*! checks if pixel format is YUV
+\param pix_fmt pixel format name
+\return true if YUV, false otherwise
+*/
+boolean pixfmt_yuv(DOMString pix_fmt);
+
+/*! checks bit depth of component in pixel format
+\param pix_fmt pixel format name
+\return number of bits per component
+*/
+boolean pixfmt_depth(DOMString pix_fmt);
 
 /*! gets size in bytes of an audio sample in the given format
 \param pcm_fmt PCM format name
@@ -499,12 +511,12 @@
 
 };
 
-/*! object used for terminal size info - cannot be created through constructor*/
+/*! object used for TTY size info - cannot be created through constructor*/
 interface WinRect {
-/*! width of terminal in characters*/
+/*! width of TTY in characters*/
 attribute readonly unsigned long w;
 
-/*! height of terminal in characters*/
+/*! height of TTY in characters*/
 attribute readonly unsigned long h;
 };
 
@@ -714,6 +726,16 @@
 \return number of bytes read*/
 unsigned long get_data(ArrayBuffer buffer, optional unsigned long nb_bytes=0);
 
+
+/*! get utf8 string
+\return value read*/
+DOMString get_string();
+
+/*! reads 4CC
+\return four-character code read
+*/
+DOMString get_4cc();
+
 /*! write 8-bit unsigned value
 \param value value to write*/
 void put_u8(unsigned long value);
@@ -783,6 +805,16 @@
 */
 unsigned long put_data(ArrayBuffer buffer, optional unsigned long nb_bytes=0);
 
+/*! write 4CC
+\param fcc four-character code to write
+*/
+void put_4cc(DOMString fcc);
+
+/*! write UTF-8 string
+\param str string to write
+*/
+void put_string(DOMString str);
+
 /*! write 64-bit float value
 \param buffer buffer to write
 \param nb_bytes number of bytes to write - if 0, uses array buffer size. If more than array buffer size, truncated to array buffer size

gpac-2.0.0.tar.gz/share/doc/idl/dash_algo.idl -> gpac-2.2.0.tar.gz/share/doc/idl/dash_algo.idl Changed

gpac-2.0.0.tar.gz/share/doc/idl/evg.idl -> gpac-2.2.0.tar.gz/share/doc/idl/evg.idl Changed

@@ -1117,6 +1117,16 @@
 	\return the converted value
 	*/
 	Object get_pixel(unsigned long x, unsigned long y, optional bool as_array=false);
+
+	/*! gets MAE (Mean Absolute Error) and/or MSE (Mean Square Error) metric of texture compared with another texture. Both textures shall have the same size and pixel format.
+	\param diff_with texture to compute difference with
+	\param mode string indicating metric(s) to compute as a comma-separated list. Currently only 'mae' and 'mse' are supported.
+	\param split_planes if true, metrics are computed per plane, otherwise averaged on all planes. For YUV textures, if this is not set, metric is only computed on luma plane and alpha plane if present.
+	\return an array of object, each containing 'mae' and 'mse' properties. Values are numbers between 0 (all identical) and 100 (all pixels have full intensity difference).
+
+	If split_planes is false, the array contains a single object. Otherwise, it contains 4 objects if alpha plane or 3 otherwise, in {R,G,B,A} or {Y,U,V,A} order.
+	*/
+	Array diff_score(Texture diff_with, optional DOMString mode="mae", optional boolean split_planes=false);
 };
 
 /*! convolution kernel interface*/

gpac-2.0.0.tar.gz/share/doc/idl/filtersession.idl -> gpac-2.2.0.tar.gz/share/doc/idl/filtersession.idl Changed

@@ -70,6 +70,11 @@
 */
 JSFSFilter get_filter(DOMString iname);
 
+
+/*! enable remotery - this should be called as early as possible in the session
+*/
+void enable_rmt();
+
 /*! sends the given string to the remotery client(s)
 \param command the command to send
 \return error code if any
@@ -106,6 +111,17 @@
 \param callback callback function - it is passed a single parameter set, an event instance of FilterEvent interface. The return value of the function should be as indicated for each event type*/
 void set_event_fun(function callback);
 
+/*! sets callback function to get authentication requests (see \ref gf_fs_set_ui_callback).
+\param callback callback function - the function takes 5 parameters and no return value type:
+	- server: name of server
+	- user: username
+	- pass: password if known
+	- secure: boolean indicating if connection is secured (TLS)
+	- auth_obj: object used to acknowledge authentication, with a single function `done()` taking up to 3 parameters: user, passord and boolean indicating if credentials should be stored. If user or password are not set, authentication fails
+*/
+void set_auth_fun(function callback);
+
+
 /*! fires a given event on all registered user event if no filter is specified, or on the filter
 \param evt the event to send
 \param filter the filter to send the event to
@@ -125,6 +141,15 @@
 */
 JSFilter new_filter(DOMString name=null);
 
+
+/*! loads all arguments of of a filter description. This will load all arguments on meta filters (not visible otherwise)
+
+\param desciption description for the filter. Sources can be specified using `src=URL`, sinks can be specified using `dst=URL`.
+\return array of JSFSFilterArg
+*/
+Array filter_args(DOMString desciption);
+
+
 /*! number of filters in the session - see \ref gf_fs_get_filters_count. 
 This number is only valid when session is locked*/
 attribute long nb_filters;
@@ -249,6 +274,39 @@
 */
 void opid_props(unsigned long idx, function fun_callback);
 
+/*! get statistics on input pid
+\param idx the index of the input pid to query
+\param mode mode used to query stats - cf \ref GF_FilterPidStatsLocation
+\return object matching \ref GF_FilterPidStatistics
+*/
+Object ipid_stats(unsigned long idx, optional unsigned int mode=0);
+
+/*! get statistics on output pid
+\param idx the index of the output pid to query
+\param mode mode used to query stats - cf \ref GF_FilterPidStatsLocation
+\return object matching \ref GF_FilterPidStatistics
+*/
+Object opid_stats(unsigned long idx, optional unsigned int mode=0);
+
+/*! Forces a filter to only link to filters having at least one sourceID defined - cf \ref gf_filter_require_source_id
+*/
+void require_source_id();
+
+
+/*! computes link from an output pid of the filter to a given filter description
+\param idx the index of the output pid to query
+\param description filter descrition, destination can be specified using dst=URL
+\param load_args if set, will load all possible arguments for each filter
+
+If arguments are loaded, the return value is an array of object with property `fname` set to the registry name and `args` set to an array of JSFSFilterArg, including arguments of meta filters (not visible otherwise)
+
+If arguments are not loaded, the return value is an array registry names
+
+\return array of found filters, NULL if not found
+*/
+Array compute_link(unsigned long idx, DOMString description, optional Boolean load_args=false);
+
+
 /*! Gets source filter for an input pid
 \param idx the index of the input pid to query
 \return input filter or null
@@ -276,8 +334,9 @@
 /*! sends argument update to filter
 \param arg_name name of argument to update
 \param arg_val value of argument to update. Can be a string or a native type which will be serialized based on the argument type
+\param propagate_mask flags indicating if updates must be send to up-chain filters (2), down-chain filters (1), both (3) or only on filter (0)
 */
-void update(DOMString arg_name, DOMString arg_val);
+void update(DOMString arg_name, DOMString arg_val, unsigned int propagate_mask=0);
 
 /*! removes filter from graph*/
 void remove();

gpac-2.0.0.tar.gz/share/doc/idl/jsf.idl -> gpac-2.2.0.tar.gz/share/doc/idl/jsf.idl Changed

@@ -400,6 +400,8 @@
 readonly attribute boolean eos_received;
 /*! blocking state - see \ref gf_filter_pid_would_block*/
 readonly attribute boolean would_block;
+/*! sparse status - see \ref gf_filter_pid_is_sparse*/
+readonly attribute boolean sparse;
 /*! name of parent filter*/
 readonly attribute DOMString filter_name;
 /*! name of source filter*/
@@ -445,7 +447,9 @@
 /*! playing state - see \ref gf_filter_pid_is_playing*/
 readonly attribute unsigned long playing;
 /*! next estimated timestamp, or null if not computable - see \ref gf_filter_pid_get_next_ts*/
-readonly attribute boolean next_ts;
+readonly attribute unsigned long long next_ts;
+/*! set to true if input chain has a decoder filter - see \ref gf_filter_pid_has_decoder*/
+readonly attribute boolean has_decoder;
 
 /*! sends an event on the pid - see \ref gf_filter_pid_send_event
 \param evt the event to send*/
@@ -540,7 +544,7 @@
 boolean disconnected;
 unsigned long average_process_rate;
 unsigned long max_process_rate;
-unsigned long avgerage_bitrate;
+unsigned long average_bitrate;
 unsigned long max_bitrate;
 unsigned long nb_processed;
 unsigned long max_process_time;
@@ -619,7 +623,7 @@
 /*! creates a new output packet using string as payload
 \param str the string to use
 \param use_shared creates a shared packet, holding a GC reference to the string until release - see gf_filter_pck_new_shared
-\param destroy_callback_fun when shared mode is used, specify a callback function to be used upon destruction of the packet. The function takes no parameter and uses the pid as this object
+\param destroy_callback_fun when shared mode is used, specify a callback function to be used upon destruction of the packet. The function has two parameters pid (output pid of the packet destroyed) and packet (the packet destroyed)
 \return new packet or null*/
 FilterPacket new_packet(DOMString str, optional boolean use_shared=false, optional function destroy_callback_fun=null);
 
@@ -631,7 +635,7 @@
 /*! creates a new output packet using ArrayBuffer as payload
 \param ab the ArrayBuffer to use (views are also allowed)
 \param use_shared creates a shared packet, holding a GC reference to the array buffer until release - see gf_filter_pck_new_shared
-\param destroy_callback_fun when shared mode is used, specify a callback function to be used upon destruction of the packet. The function takes no parameter and uses the pid as this object
+\param destroy_callback_fun when shared mode is used, specify a callback function to be used upon destruction of the packet. The function has two parameters pid (output pid of the packet destroyed) and packet (the packet destroyed)
 \return new packet or null*/
 FilterPacket new_packet(ArrayBuffer ab, optional boolean use_shared=false, optional function destroy_callback_fun=null);
 
@@ -648,10 +652,19 @@
 /*! creates a new output packet from a source packet
 \param pck the source packet to use
 \param use_shared creates a shared packet - see gf_filter_pck_new_shared
-\param destroy_callback_fun when shared mode is used, specify a callback function to be used upon destruction of the packet. The function takes no parameter and uses the pid as this object. Ignored if use_shared is false
+\param destroy_callback_fun when shared mode is used, specify a callback function to be used upon destruction of the packet. The function has two parameters pid (output pid of the packet destroyed) and packet (the packet destroyed). Ignored if use_shared is false
 \return new packet or null
 */
-FilterPacket new_packet(FilterPacket pck, optional boolean use_shared=false, optional function destroy_callback_fun=false);
+FilterPacket new_packet(FilterPacket pck, optional boolean use_shared=false, optional function destroy_callback_fun=null);
+
+
+/*! creates a new output packet for OpenGL texture interface
+\param fetch_texture_fun specify a callback function to use to fetch textures. The function has three parameters pid (output pid of the packet queried), packet (the packet queried) and plane_index (the plane/texture index). The function shall return null if error, or an object with attributes "id" (a WebGL texture or openGL texture identifier) and "fmt" (openGL texture format, e.g. GL_TEXTURE_2D).
+\param destroy_callback_fun specify a callback function to be used upon destruction of the packet. The function has two parameters pid (output pid of the packet destroyed) and packet (the packet destroyed).
+\param is_blocking indicates if this frame is blocking (filter cannot dispatch new frame until this frame is destroyed)
+\return new packet or null
+*/
+FilterPacket new_packet(function fetch_texture_fun, optional function destroy_callback_fun=null, optional boolean is_blocking=false);
 
 
 /*! forwards a source packet to outout - see \ref gf_filter_pck_forward
@@ -718,6 +731,9 @@
 /*! set to true if data of the packet is available through a GF_FilterFrameInterface object*/
 readonly attribute boolean frame_ifce;
 
+/*! set to true if data of the packet is available through a GF_FilterFrameInterface object on openGL textures*/
+readonly attribute boolean frame_ifce_gl;
+
 /*! set to true if packet has properties other than default ones - see gf_filter_pck_has_properties*/
 readonly attribute boolean has_properties;
 
@@ -803,7 +819,7 @@
 
 The resulting packet is in read/write mode and may have its own memory allocated.
 This is typically used by sink filters wishing to access underling GPU data of a packet using frame interface.
-The resulting packet can be explicitly discarded using \ref discard, otherwise will be garrbage collected.
+The resulting packet can be explicitly discarded using \ref discard, otherwise will be garbage collected.
 
 \param cached_pck if set, will be reuse for creation of new packet. This can greatly reduce memory allocations
 \return the new FilterPacket or None if failure or None if failure ( if grabbing the frame into a local copy failed)

gpac-2.0.0.tar.gz/share/doc/idl/nodejs.idl -> gpac-2.2.0.tar.gz/share/doc/idl/nodejs.idl Changed

@@ -357,16 +357,17 @@
 
 /*! insert a given filter after this filter - see \ref gf_filter_set_source and \ref gf_filter_reconnect_output
 \param f _Filter to insert
+\param pid_idx index of pid to relink, negative value means all output pids
 \param link_args link options
 */
-void insert(_Filter f, DOMString link_args=null);
+void insert(_Filter f, long pid_idx=-1, DOMString link_args=null);
 
 /*! get an input pid property by name
 \param idx index of input pid
 \param prop_name name of property
 \return property value or None if not found
 */
-PropertyValue ipid_prop(unsigned long idx, DOMStreing prop_name);
+PropertyValue ipid_prop(unsigned long idx, DOMString prop_name);
 
 /*! enumerate an input pid properties
 \param idx index of input pid
@@ -387,6 +388,22 @@
 */
 void opid_enum_props(unsigned long idx, function callback_fun);
 
+
+/*! get statistics on input pid
+\param idx index of input pid
+\param mode search mode for stats (one of GF_STATS_XXX)
+\return stats or null if error
+*/
+PidStatistics ipid_stats(unsigned long idx, unsigned long mode=0);
+
+/*! get statistics on output pid
+\param idx index of input pid
+\param mode search mode for stats (one of GF_STATS_XXX)
+\return stats or null if error
+*/
+PidStatistics opid_stats(unsigned long idx, unsigned long mode=0);
+
+
 /*! gets the filter at the source of an input pid
 \param idx index of input PID
 \return filter or null if error
@@ -437,6 +454,14 @@
 	
 };
 
+/*! Statistics object for pid as defined in libgpac.
+
+Fields have the same types, names and semantics as \ref GF_FilterPidStatistics
+*/
+interface PidStatistics {
+
+};
+
 
 /*! PropertyValue for filter, PIDs and packets are passed as 
 :
@@ -723,6 +748,9 @@
 /*! True if PID would block - see \ref gf_filter_pid_would_block*/
 attribute readonly boolean would_block;
 
+/*! True if PID is sparse - see \ref gf_filter_pid_is_sparse*/
+attribute readonly boolean sparse;
+
 /*! maximum buffer of PID in microseconds - see \ref gf_filter_pid_get_max_buffer and \ref gf_filter_pid_set_max_buffer*/
 attribute unsigned long long max_buffer;
 
@@ -754,6 +782,9 @@
 attribute readonly unsigned long long next_ts;
 
 
+/*! Set to true if input chain has a decoder - see \ref gf_filter_pid_has_decoder*/
+attribute readonly boolean has_decoder;
+
 
 /*! send an event on the pid - see \ref gf_filter_pid_send_event
 \param evt filter event to send
@@ -1052,7 +1083,7 @@
 /*! creates a new packet cloning a source packet - see \ref gf_filter_pck_dangling_copy.
 The resulting packet is read/write mode and may have its own memory allocated.
 This is typically used by sink filters wishing to access underling GPU data of a packet using frame interface.
-the resulting packet can be explicitly discarded using \ref discard, otherwise will be garrbage collected.
+the resulting packet can be explicitly discarded using \ref discard, otherwise will be garbage collected.
 \param cached_pck if set, will be reuse for creation of new packet. This can greatly reduce memory allocations
 \return the new FilterPacket or None if failure or None if failure ( if grabbing the frame into a local copy failed)
 */
@@ -1177,7 +1208,7 @@
 /*! List of _DASHQualityInfo for group*/
 attribute readonly Array qualities;
 
-/*! period duration in milliseconds, 0 if unknwon*/
+/*! period duration in milliseconds, 0 if unknown*/
 attribute readonly unsigned long duration;
 
 /*! SRD object or null if no SRD defined*/
@@ -1268,7 +1299,7 @@
 /*! display height in pixels of object*/
 attribute readonly unsigned long display_height;
 
-/*! index of current quality*/
+/*! index of current quality or last downloaded quality*/
 attribute readonly unsigned long active_quality_idx;
 
 /*! minimum buffer in milliseconds, below witch rebuffer occurs*/

gpac-2.0.0.tar.gz/share/doc/man/gpac-filters.1 -> gpac-2.2.0.tar.gz/share/doc/man/gpac-filters.1 Changed

@@ -36,6 +36,9 @@
 .br
 
 .br
+.SH Custom property duming
+.LP
+.br
 The packet inspector can be configured to dump specific properties of packets using .I fmt.
 .br
 When the option is not present, all properties are dumped. Otherwise, only properties identified by $TOKEN$ are printed. You may use '$', '@' or '%' for TOKEN separator. TOKEN can be:
@@ -92,7 +95,7 @@
 .br
 * t: insert tab
 .br
-* data: hex dump of packet (big output!)
+* data: hex dump of packet (big output!) or as string if legal UTF-8
 .br
 * lp: leading picture flag
 .br
@@ -102,6 +105,14 @@
 .br
 * red: redundant coding flag
 .br
+* start: packet composition time as HH:MM:SS.ms
+.br
+* startc: packet composition time as HH:MM:SS,ms
+.br
+* end: packet end time as HH:MM:SS.ms
+.br
+* endc: packet end time as HH:MM:SS,ms
+.br
 * ck: clock type used for PCR discontinuities
 .br
 * pcr: MPEG-2 TS last PCR, n/a if not available
@@ -118,6 +129,8 @@
 .br
 * pid.PropName: Name of PID property
 .br
+* fn: Filter name
+.br
 
 .br
 Example
@@ -138,10 +151,31 @@
 .br
 
 .br
+.SH Note on playback
+.LP
+.br
+Buffering can be enabled to check the input filter chain behaviour, e.g. check HAS adaptation logic.
+.br
+The various buffering options control when packets are consumed. Buffering events are logged using media@info for state changes and media@debug for media filling events.
+.br
+The .I speed option is only used to configure the filter chain but is ignored by the filter when consuming packets.
+.br
+If real-time consumption is required, a reframer filter must be setup before the inspect filter.
+.br
+Example
+.br
+gpac -i SRC reframer:rt=on inspect:buffer=10000:rbuffer=1000:mbuffer=30000:speed=2
+.br
+
+.br
+This will play the session at 2x speed, using 30s of maximum buffering, consumming packets after 10s of media are ready and rebuffering if less than 1s of media.
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
-log (str, default: stdout, minmax: fileName, stderr, stdout or null): set inspect log filename
+log (str, default: stdout, minmax: fileName, stderr, stdout, GLOG or null): set probe log filename to print number of streams, GLOG uses GPAC logs app@info(default for android)
 .br
 mode (enum, default: pck):     dump mode
 .br
@@ -201,7 +235,11 @@
 .br
 dtype (bool, default: false, updatable): dump property type
 .br
-buffer (uint, default: 0):     set buffer in ms (mostly used for testing DASH algo)
+buffer (uint, default: 0):     set playback buffer in ms
+.br
+mbuffer (uint, default: 0):    set max buffer occupancy in ms. If less than buffer, use buffer
+.br
+rbuffer (uint, default: 0, updatable): rebuffer trigger in ms. If 0 or more than buffer, disable rebuffering
 .br
 test (enum, default: no, updatable): skip predefined set of properties, used for test mode
 .br
@@ -245,7 +283,7 @@
 .SH Options (expert):
 .LP
 .br
-log (str, default: stdout, minmax: fileName, stderr, stdout or null): set probe log filename to print number of streams
+log (str, default: stdout, minmax: fileName, stderr, stdout GLOG or null): set probe log filename to print number of streams, GLOG uses GPAC logs app@info(default for android)
 .br
 
 .br
@@ -298,6 +336,8 @@
 .br
 This can be changed by assigning the .I opfmt option.
 .br
+If either .I opfmt specifies alpha channel or .I bc is not 0 but has alpha=0, background creation in default scene will be skipped.
+.br
 
 .br
 In filter-only mode, the special URL gpid:// is used to locate PIDs in the scene description, in order to design scenes independently from source media.
@@ -684,7 +724,7 @@
 .br
 noaudio (bool, default: false): disable audio output
 .br
-opfmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,yuv444ap,yuv444p_10,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,rgbs,rgbas): pixel format to use for output. Ignored in .I player mode
+opfmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,v308,yuv444ap,v408,v410,v210,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,uncv): pixel format to use for output. Ignored in .I player mode
 .br
 drv (enum, default: auto):     indicate if graphics driver should be used
 .br
@@ -704,6 +744,18 @@
 .br
 gazer_enabled (bool, default: false, updatable): enable gaze event dispatch
 .br
+subtx (sint, default: 0, updatable): horizontal translation in pixels towards right for subtitles renderers
+.br
+subty (sint, default: 0, updatable): vertical translation in pixels towards top for subtitles renderers
+.br
+subfs (uint, default: 0, updatable): font size for subtitles renderers (0 means automatic)
+.br
+subd (sint, default: 0, updatable): subtitle delay in milliseconds for subtitles renderers
+.br
+audd (sint, default: 0, updatable): audio delay in milliseconds
+.br
+clipframe (bool, default: false): visual output is clipped to bounding rectangle
+.br
 
 .br
 .SH mp4dmx
@@ -734,9 +786,11 @@
 .br
  * #trackID=VAL: only use the track with given ID
 .br
- * #ID=VAL: only use the track with given ID
+ * #itemID=VAL: only use the item with given ID
+.br
+ * #ID=VAL: only use the track/item with given ID
 .br
- * #VAL: only use the track with given ID
+ * #VAL: only use the track/item with given ID
 .br
 
 .br
@@ -828,6 +882,8 @@
 .br
 nodata (bool, default: false): do not load sample data
 .br
+initseg (str):                 local init segment name when input is a single ISOBMFF segment
+.br
 
 .br
 .SH bifsdec
@@ -904,6 +960,8 @@
 .br
 mime (cstr):                   set file mime type
 .br
+pck (mem):                     data to use instead of file
+.br
 
 .br
 .SH btplay
@@ -941,6 +999,12 @@
 .br
 Content format can be forced through .I mime and file extension can be changed through .I ext.
 .br
+
+.br
+The filter supports both http and https schemes, and will attempt reconnecting as TLS if TCP connection fails.
+.br
+
+.br
 Note: Unless disabled at session level (see .I -no-probe ), file extensions are usually ignored and format probing is done on the first data block.
 .br
 
@@ -954,6 +1018,8 @@
 .br
 cache (enum, default: disk):   set cache mode
 .br
+* auto: cache to disk if content length is known, no cache otherwise
+.br
 * disk: cache to disk,  discard once session is no longer used
 .br
 * keep: cache to disk and keep
@@ -974,6 +1040,8 @@
 .br
 mime (cstr):                   set file mime type
 .br
+blockio (bool, default: false): use blocking IO
+.br
 
 .br
 .SH svgplay
@@ -1009,6 +1077,14 @@
 .br
 
 .br
+The following extensions for PNG change the pixel format for RGBA images:
+.br
+* pngd: use RGB+depth map pixel format
+.br
+* pngds: use RGB+depth(7bits)+shape(MSB of alpha channel) pixel format
+.br
+
+.br
 No options
 .br
 
@@ -1312,6 +1388,8 @@
 .br
 sigfrag (bool, default: false): signal segment boundaries on output packets for DASH or HLS sources
 .br
+dvbtxt (bool, default: false): export DVB teletext streams
+.br
 
 .br
 .SH sockin
@@ -1382,6 +1460,10 @@
 .br
 reorder_delay (uint, default: 10): number of ms delay for RTP reordering (M2TS over RTP)
 .br
+ssm (strl):                    list of IP to include for source-specific multicast
+.br
+ssmx (strl):                   list of IP to exclude for source-specific multicast
+.br
 
 .br
 .SH dvbin
@@ -1451,6 +1533,8 @@
 .br
 disable_hw (bool, default: false): disable hardware decoding
 .br
+wait_sync (bool, default: false, updatable): wait for sync frame before decoding
+.br
 
 .br
 .SH mcdec
@@ -1562,10 +1646,6 @@
 .br
 
 .br
-Note: This mode used to be trigger by .I filemode option, still recognized.
-.br
-
-.br
 If the source has dependent media streams (scalability) and all qualities and initialization segments need to be forwarded, add .I split_as.
 .br
 
@@ -1611,7 +1691,7 @@
 .br
 * `FileNumber`: current segment number
 .br
-* `FileName`: current segment file name without manifest base url
+* `FileName`: current segment file name without manifest (MPD or master HLS) base url
 .br
 * `DFPStart`: set with value 0 if this is the first packet in the period, absent otherwise
 .br
@@ -1645,10 +1725,12 @@
 .br
 * `stl_timescale`: timescale used by SegmentTimeline, or 0 if no SegmentTimeline
 .br
-* `init_url`: unresolved intialization URL (as it appears in the manifest)
+* `init_url`: unresolved intialization URL (as it appears in the MPD or in the variant playlist)
 .br
 * `manifest_url`: manifest URL
 .br
+* `hls_variant_name`: HLS variant playlist name (as it appears in the HLS master playlist)
+.br
 
 .br
 When the dasher is used together with this mode, this will force all generated segments to have the same name, duration and fragmentation properties as the input ones. It is therefore not recommended for sessions stored/generated on local storage to generate the output in the same directory.
@@ -1730,6 +1812,8 @@
 .br
 shift_utc (sint, default: 0):  shift DASH UTC clock in ms
 .br
+spd (sint, default: -I):       suggested presentation delay in ms
+.br
 route_shift (sint, default: 0): shift ROUTE requests time by given ms
 .br
 server_utc (bool, default: yes): use ServerUTC or Date HTTP headers instead of local UTC
@@ -1999,6 +2083,8 @@
 .br
 The built-in tag names are indicated by MP4Box -h tags.
 .br
+QT tags can be specified using qtt_NAME property names, and will be added using formatting specified in MP4Box -h tags.
+.br
 Other tag class may be specified using tag_NAME property names, and will be added if .I tags is set to all using:
 .br
 - NAME as a box 4CC if NAME is four characters long
@@ -2064,7 +2150,7 @@
 .br
   
 .br
-The filter watches the property DSIWrap (4CC as int or string) on incoming PID to wrap decoder configuration in a box of given type (unknonw wraping)
+The filter watches the property DSIWrap (4CC as int or string) on incoming PID to wrap decoder configuration in a box of given type (unknown wrapping)
 .br
 Example
 .br
@@ -2072,7 +2158,19 @@
 .br
 
 .br
-This will wrap the uknown stream using VIUK code point in stsd and wrap any decoder configuration data in a cfgv box.
+This will wrap the unknown stream using VIUK code point in stsd and wrap any decoder configuration data in a cfgv box.
+.br
+
+.br
+If .I pad_sparse is set, the filter watches the property Sparse on incoming PID to decide whether empty packets should be injected to keep packet duration info.
+.br
+Such packets are only injected when a whole in the timeline is detected.
+.br
+- if Sparse is absent, empty packet is inserted for unknown text and metadata streams
+.br
+- if Sparse is true, empty packet is inserted for all stream types
+.br
+- if Sparse is false, empty packet is never injected
 .br
 
 .br
@@ -2125,7 +2223,7 @@
 .br
 * fstart: write samples as they arrive and moov before mdat
 .br
-* tight:  uses per-sample interleaving of all tracks (requires temporary storage of all media)
+* tight: uses per-sample interleaving of all tracks (requires temporary storage of all media)
 .br
 * frag: fragments the file using cdur duration
 .br
@@ -2175,6 +2273,8 @@
 .br
 * moov: in movie box
 .br
+* both: in movie box and in first moof of each segment
+.br
 * none: pssh is discarded
 .br
 
@@ -2323,6 +2423,12 @@
 .br
 
 .br
+pad_sparse (bool, default: true): inject sample with no data (size 0) to keep durations in unknown sparse text and metadata tracks
+.br
+force_dv (bool, default: false): force DV sample entry types even when AVC/HEVC compatibility is signaled
+.br
+tsalign (bool, default: true): enable timeline realignment to 0 for first sample in fragmented mode
+.br
 
 .br
 .SH rfqcp
@@ -2383,7 +2489,7 @@
 .br
 fps (frac, default: 0/1000):   import frame rate (0 default to FPS from bitstream or 25 Hz)
 .br
-index (dbl, default: 1.0):     indexing window length
+index (dbl, default: -1.0):    indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 20M (slows down importers) unless a play with start range > 0 is issued
 .br
 vfr (bool, default: false):    set variable frame rate import
 .br
@@ -2457,7 +2563,7 @@
 .br
 fps (frac, default: 0/1000):   import frame rate (0 default to FPS from bitstream or 25 Hz)
 .br
-index (dbl, default: -1.0):    indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 100M (slows down importers) unless a play with start range > 0 is issued
+index (dbl, default: -1.0):    indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 20M (slows down importers) unless a play with start range > 0 is issued
 .br
 explicit (bool, default: false): use explicit layered (SVC/LHVC) import
 .br
@@ -2497,19 +2603,19 @@
 .br
 * auto: signal DV profile if RPU or EL are found
 .br
-* force: always signal DV profile
-.br
 * clean: do not signal and remove RPU and EL NAL units
 .br
-* single: remove EL NAL units
+* single: signal DV profile if RPU are found and remove EL NAL units
 .br
 
 .br
-dv_profile (uint, default: 5): profile for DolbyVision (currently defined profiles are 4, 5, 7, 8, 9)
+dv_profile (uint, default: 0): profile for DolbyVision (currently defined profiles are 4, 5, 7, 8, 9), 0 for auto-detect
+.br
+dv_compatid (enum, default: auto): cross-compatibility ID for DolbyVision
 .br
-dv_compatid (enum, default: none): cross-compatibility ID for DolbyVision
+* auto: auto-detect
 .br
-* none: do not signal compatibility
+* none: no cross-compatibility
 .br
 * hdr10: CTA HDR10, as specified by EBU TR 03
 .br
@@ -2570,6 +2676,8 @@
 .br
 importer (bool, default: false): compatibility with old importer, displays import results
 .br
+noreframe (bool, default: false): skip media reframer
+.br
 
 .br
 .SH txtin
@@ -2579,7 +2687,7 @@
 .br
 
 .br
-This filter reads subtitle data from input file PID to produce subtitle frames on a single PID.
+This filter reads subtitle data from input PID to produce subtitle frames on a single PID.
 .br
 The filter supports the following formats:
 .br
@@ -2595,6 +2703,8 @@
 .br
 * SUB: one subtitle per line formatted as {start_frame}{end_frame}text
 .br
+* SSA (Substation Alpha): basic parsing support for common files
+.br
 
 .br
 Input files must be in UTF-8 or UTF-16 format, with or without BOM. The internal frame format is: 
@@ -2610,13 +2720,23 @@
 .SH TTML Support
 .LP
 .br
-The .I ttml_dur option controls how the TTML document is split into packets:
+If .I ttml_split option is set, the TTML document is split in independent time segments by inspecting all overlapping subtitles in the body.
+.br
+Empty periods in TTML will result in empty TTML documents or will be skipped if .I no_empty option is set.
+.br
+
+.br
+The first sample has a CTS assigned as indicated by .I ttml_cts:
 .br
-- if negative (default), TTML document is split in independent time segments by inspecting all overlapping subtitles in the body
+- a numerator of -2 indicates the first CTS is 0
 .br
-- if 0, the input document is not split, forwarded as a single frame with CTS matching the first active time in document and a duration equal to the document duration
+- a numerator of -1 indicates the first CTS is the first active time in document
 .br
-- if >0, the input document is not split, forwarded as a single frame with CTS=0 and the specified duration in timescale units.
+- a numerator >= 0 indicates the CTS to use for first sample
+.br
+
+.br
+When TTML splitting is disabled, the duration of the TTML sample is given by .I ttml_dur if not 0, or set to the document duration
 .br
 
 .br
@@ -2660,6 +2780,29 @@
 .br
 
 .br
+.SH Simple Text Support
+.LP
+.br
+The text loader can convert input files in simple text streams of a single packet, by forcing the codec type on the input:EX gpac -i test.txt:#CodecID=stxt  ...
+.br
+Example
+.br
+gpac fin:pck="Text Data":#CodecID=stxt  ...
+.br
+
+.br
+
+.br
+The content of the source file will be the payload of the text sample. The .I stxtmod option allows specifying WebVTT, TX3G or simple text mode for output format.
+.br
+In this mode, the .I stxtdur option is used to control the duration of the generated subtitle:
+.br
+- a positive value always forces the duration
+.br
+- a negative value forces the duration if input packet duration is not known
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
@@ -2687,12 +2830,28 @@
 .br
 timescale (uint, default: 1000): default timescale of the PID
 .br
-ttml_dur (sint, default: -1):  force single sample mode
+ttml_split (bool, default: true): split ttml doc in non-overlapping samples
+.br
+ttml_cts (lfrac, default: -1/1): first sample cts - see filter help
+.br
+ttml_dur (frac, default: 0/1): sample duration when not spliting split - see filter help
 .br
 ttml_embed (bool, default: false): force embedding TTML resources
 .br
 ttml_zero (str):               set subtitle zero time for TTML
 .br
+no_empty (bool, default: false): do not send empty samples
+.br
+stxtdur (frac, default: 1):    duration for simple text
+.br
+stxtmod (enum, default: none): simple text stream mode- none: declares output PID as simple text stream
+.br
+* tx3g: declares output PID as TX3G/Apple stream
+.br
+* vtt: declares output PID as WebVTT stream
+.br
+
+.br
 
 .br
 .SH ttxtdec
@@ -2708,6 +2867,16 @@
 .br
 
 .br
+In stand-alone rendering (no associated video), the filter will use:
+.br
+- Width and Height properties of input pid if any
+.br
+- otherwise, osize option of compositor if set
+.br
+- otherwise, .I txtw and .I txth
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
@@ -2734,6 +2903,14 @@
 .br
 The filter options are used to override the JS global variables of the WebVTT renderer.
 .br
+In stand-alone rendering (no associated video), the filter will use:
+.br
+- Width and Height properties of input pid if any
+.br
+- otherwise, osize option of compositor if set
+.br
+- otherwise, .I txtw and .I txth
+.br
 
 .br
 .SH Options (expert):
@@ -2749,10 +2926,6 @@
 .br
 lineSpacing (flt, default: 1.0, updatable): line spacing as scaling factor to font size
 .br
-txtx (flt, default: 5, updatable): horizontal offset
-.br
-txty (flt, default: 5, updatable): vertical offset
-.br
 txtw (uint, default: 400):     default width in standalone rendering
 .br
 txth (uint, default: 200):     default height in standalone rendering
@@ -2774,6 +2947,16 @@
 .br
 
 .br
+In stand-alone rendering (no associated video), the filter will use:
+.br
+- Width and Height properties of input pid if any
+.br
+- otherwise, osize option of compositor if set
+.br
+- otherwise, .I txtw and .I txth
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
@@ -2797,10 +2980,6 @@
 .br
 lineSpacing (flt, default: 1.0, updatable): line spacing as scaling factor to font size
 .br
-txtx (flt, default: 5, updatable): horizontal offset
-.br
-txty (flt, default: 5, updatable): vertical offset
-.br
 txtw (uint, default: 400):     default width in standalone rendering
 .br
 txth (uint, default: 200):     default height in standalone rendering
@@ -2824,7 +3003,19 @@
 .br
  
 .br
-The filter produces either PIDs with media frames, or file PIDs with multiplexed data (e.g. MPEG-2 TS).
+The filter produces either PIDs with media frames, or file PIDs with multiplexed data (e.g. MPEG-2 TS). 
+.br
+The filter will use:
+.br
+- RTSP over HTTP tunnel if server port is 80 or 8080 or if protocol scheme is rtsph://.
+.br
+- RTSP over TLS if server port is 322 or if protocol scheme is rtsps://.
+.br
+- RTSP over HTTPS tunnel if server port is 443 and if protocol scheme is rtsph://.
+.br
+ 
+.br
+The filter will attempt reconnecting in TLS mode after two consecutive initial connection failures.
 .br
 
 .br
@@ -2843,7 +3034,7 @@
 .br
 reorder_delay (uint, default: 50): max delay in RTP re-orderer, packets will be dispatched after that
 .br
-block_size (uint, default: 0x200000): buffer size for RTP/UDP or RTSP when interleaved
+block_size (uint, default: 0x100000): buffer size for RTP/UDP or RTSP when interleaved
 .br
 disable_rtcp (bool, default: false): disable RTCP reporting
 .br
@@ -2859,19 +3050,25 @@
 .br
 satip_port (uint, default: 1400, minmax: 0-65535): set default port for SATIP
 .br
-interleave (bool, default: false): set RTP over RTSP
+transport (enum, default: auto): set RTP over RTSP
 .br
-udp_timeout (uint, default: 10000): default timeout before considering UDP is down
+* auto: set interleave on if HTTP tunnel is used, off otherwise and retry in interleaved mode if UDP timeout
 .br
-rtsp_timeout (uint, default: 3000): default timeout before considering RTSP is down
+* tcp: enable RTP over RTSP
+.br
+* udp: disable RTP over RTSP
+.br
+
+.br
+udp_timeout (uint, default: 10000): default timeout before considering UDP is down
 .br
 rtcp_timeout (uint, default: 5000): default timeout for RTCP traffic in ms. After this timeout, playback will start out of sync. If 0 always wait for RTCP
 .br
-autortsp (bool, default: true): automatically reconfig RTSP interleaving if UDP timeout
+first_packet_drop (uint, default: 0, updatable): set number of first RTP packet to drop (0 if no drop)
 .br
-first_packet_drop (uint, default: 0): set number of first RTP packet to drop (0 if no drop)
+frequency_drop (uint, default: 0, updatable): drop 1 out of N packet (0 disable dropping)
 .br
-frequency_drop (uint, default: 0): drop 1 out of N packet (0 disable dropping)
+loss_rate (sint, default: -1, updatable): loss rate to signal in RTCP, -1 means real loss rate, otherwise a per-thousand of packet lost
 .br
 user_agent (str, default: $GUA): user agent string, by default solved from GPAC preferences
 .br
@@ -2891,6 +3088,10 @@
 .br
 forceagg (bool, default: false): force RTSP control aggregation (patch for buggy servers)
 .br
+ssm (strl):                    list of IP to include for source-specific multicast
+.br
+ssmx (strl):                   list of IP to exclude for source-specific multicast
+.br
 
 .br
 .SH fout
@@ -3123,15 +3324,17 @@
 .br
 * 'T'H:M:S.MS, 'T'M:S.MS, 'T'S.MS: specify time in hours, minutes, seconds and milliseconds
 .br
-* INT, FLOAT: specify time in seconds
+* INT, FLOAT, NUM/DEN: specify time in seconds (number or fraction)
 .br
-* NUM/DEN: specify time in seconds as fraction
+* 'D'INT, 'D'FLOAT, 'D'NUM/DEN: specify end time as offset to start time in seconds (number or fraction) - only valid for .I xe
 .br
 * 'F'NUM: specify time as frame number
 .br
+* XML DateTime: specify absolute UTC time
+.br
   
 .br
-In this mode, the timestamps are rewritten to form a continuous timeline.
+In this mode, the timestamps are rewritten to form a continuous timeline, unless .I xots is set.
 .br
 When multiple ranges are given, the filter will try to seek if needed and supported by source.
 .br
@@ -3157,11 +3360,11 @@
 .br
 Example
 .br
-gpac -i m.mp4 reframer:xs=0,10,25:xe=5 dst
+gpac -i m.mp4 reframer:xs=0,10,25:xe=5,20 dst
 .br
 
 .br
-This will extract the time ranges 0s,5s, 10s,25s and all media starting from 25s
+This will extract the time ranges 0s,5s, 10s,20s and all media starting from 25s
 .br
 Example
 .br
@@ -3241,6 +3444,25 @@
 .br
 
 .br
+.SH UTC-based range extraction
+.LP
+.br
+The filter can perform range extraction based on UTC time rather than media time. In this mode, the end time must be:
+.br
+* a UTC date: range extraction will stop after this date
+.br
+* a time in second: range extraction will stop after the specified duration
+.br
+
+.br
+The UTC reference is specified using .I utc_ref.
+.br
+If UTC signal from media source is used, the filter will probe for .I utc_probe before considering the source has no UTC signal.
+.br
+
+.br
+The properties SenderNTP and, if absent, UTC of source packets are checked for establishing the UTC reference.
+.br
 .SH Other split actions
 .LP
 .br
@@ -3250,7 +3472,7 @@
 .br
 * `SAP`: split source at each SAP/RAP
 .br
-* `D`VAL: split source by chunks of VAL ms
+* `D`VAL: split source by chunks of VAL seconds
 .br
 * `D`NUM/DEN: split source by chunks of NUM/DEN seconds
 .br
@@ -3283,7 +3505,7 @@
 .br
 refs (bool, default: false):   forward only frames used as reference frames, if indicated in the input stream
 .br
-speed (dbl, default: 1.0):     speed for real-time regulation mode
+speed (dbl, default: 0.0):     speed for real-time regulation mode, a value of 0 uses speed from play commands
 .br
 raw (enum, default: no):       force input AV streams to be in raw format
 .br
@@ -3297,7 +3519,7 @@
 .br
 
 .br
-frames (uintl):                drop all except listed frames (first being 1)
+frames (sintl):                drop all except listed frames (first being 1). A negative value -V keeps only first frame every V frames
 .br
 xs (strl):                     extraction start time(s)
 .br
@@ -3317,11 +3539,13 @@
 .br
 xadjust (bool, default: false): adjust end time of extraction range to be before next I-frame
 .br
+xots (bool, default: false):   keep original timestamps after extraction
+.br
 nosap (bool, default: false):  do not cut at SAP when extracting range (may result in broken streams)
 .br
 splitrange (bool, default: false): signal file boundary at each extraction first packet for template-base file generation
 .br
-seeksafe (dbl, default: 10.0): rewind play requests by given seconds (to make sur I-frame preceding start is catched)
+seeksafe (dbl, default: 10.0): rewind play requests by given seconds (to make sure the I-frame preceding start is catched)
 .br
 tcmdrw (bool, default: true):  rewrite TCMD samples when splitting
 .br
@@ -3331,6 +3555,18 @@
 .br
 probe_ref (bool, default: false): allow extracted range to be longer in case of B-frames with reference frames presented outside of range
 .br
+utc_ref (enum, default: any):  set reference mode for UTC range extraction
+.br
+* local: use UTC of local host
+.br
+* any: use UTC of media, or UTC of local host if not found in media after probing time
+.br
+* media: use UTC of media (abort if none found)
+.br
+
+.br
+utc_probe (uint, default: 5000): timeout in milliseconds to try to acquire UTC reference from media
+.br
 
 .br
 .SH writegen
@@ -3351,7 +3587,7 @@
 .br
 exporter (bool, default: false): compatibility with old exporter, displays export results
 .br
-pfmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,yuv444ap,yuv444p_10,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,rgbs,rgbas): pixel format for raw extract. If not set, derived from extension
+pfmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,v308,yuv444ap,v408,v410,v210,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,uncv): pixel format for raw extract. If not set, derived from extension
 .br
 afmt (afmt, default: none, minmax: none,u8,s16,s16b,s24,s32,flt,dbl,u8p,s16p,s24p,s32p,fltp,dblp): audio format for raw extract. If not set, derived from extension
 .br
@@ -3431,14 +3667,14 @@
 .br
 
 .br
-.SH writevtt
+.SH ufvtt
 .LP
 .br
-Description: WebVTT writer
+Description: WebVTT unframer
 .br
 
 .br
-This filter converts a single ISOBMFF WebVTT stream to a WebVTT output file.
+This filter converts a single ISOBMFF WebVTT stream to its unframed format.
 .br
 
 .br
@@ -3447,7 +3683,7 @@
 .br
 exporter (bool, default: false): compatibility with old exporter, displays export results
 .br
-merge (bool, default: false):  merge VTT cue if needed
+merge_cues (bool, default: true): merge VTT cues (undo ISOBMFF cue split)
 .br
 
 .br
@@ -3623,6 +3859,8 @@
 .br
 rebuffer (luint):              system time in us at which last rebuffer started, 0 if not rebuffering (readonly, for user app)
 .br
+media_offset (dbl, default: 0): media offset (substract this value to CTS to get media time - readonly)
+.br
 
 .br
 .SH ufm4v
@@ -3643,6 +3881,24 @@
 .br
 
 .br
+.SH ufvc1
+.LP
+.br
+Description: VC1 writer
+.br
+
+.br
+This filter converts VC1 visual streams into writable format (reinsert decoder config and start codes if needed).
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+rcfg (bool, default: true):    force repeating decoder config at each I-frame
+.br
+
+.br
 .SH resample
 .LP
 .br
@@ -3661,7 +3917,7 @@
 .br
 osr (uint, default: 0):        desired sample rate of output audio (0 for auto)
 .br
-ofmt (afmt, default: none):    desired format of output audio (none for auto)
+osfmt (afmt, default: none):   desired sample format of output audio (none for auto)
 .br
 olayout (str, minmax: mono,stereo,3/0.0,3/1.0,3/2.0,3/2.1,5/2.1,1+1,2/1.0,2/2.0,3/3.1,3/4.1,11/11.2,5/2.1,5/5.2,5/4.1,6/5.1,6/7.1,5/6.1,7/6.1): desired CICP layout of output audio (null for auto)
 .br
@@ -3751,12 +4007,20 @@
 .br
 out (str, default: dump):      radical of dump frame filenames. If no extension provided, frames are exported as $OUT_%d.PFMT
 .br
+async (bool, default: true):   sync video to audio output if any
+.br
 owsize (v2di):                 output window size (readonly)
 .br
 buffer_done (bool):            buffer done indication (readonly)
 .br
 rebuffer (luint):              system time in us at which last rebuffer started, 0 if not rebuffering (readonly)
 .br
+vjs (bool, default: true):     use default JS script for vout control
+.br
+media_offset (dbl, default: 0): media offset (substract this value to CTS to get media time - readonly)
+.br
+wid (uint, default: 0):        window id (readonly)
+.br
 vflip (enum, default: no, updatable): flip video (GL only)
 .br
 * no: no flipping
@@ -3865,7 +4129,7 @@
 .br
 size (v2di, default: 0x0):     source video resolution
 .br
-spfmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,yuv444ap,yuv444p_10,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,rgbs,rgbas): source pixel format. When not set, derived from file extension
+spfmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,v308,yuv444ap,v408,v410,v210,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,uncv): source pixel format. When not set, derived from file extension
 .br
 fps (frac, default: 25/1):     number of frames per second
 .br
@@ -3880,7 +4144,7 @@
 .br
 
 .br
-This filter parses raw PCM file/data and outputs corresponding raw audio PID and frames.
+This filter parses raw PCM file/data or WAVE files and outputs corresponding raw audio PID and frames.
 .br
 
 .br
@@ -3998,7 +4262,7 @@
 .br
 If the sort mode is datex and source files are images or single frame files, the following applies:
 .br
-- options .I floop, .I revert and .I dur are ignored
+- options .I floop, .I revert and .I fdur are ignored
 .br
 - the files are sorted by modification time
 .br
@@ -4077,6 +4341,8 @@
 .br
 * sprops=STR: assigns properties described in STR to all PIDs of the main content during a splice (cf below). STR is formatted according to gpac -h doc using the default parameter set.
 .br
+* chap=NAME: assigns chapter name at the start of next URL (filter always removes source chapter names).
+.br
 
 .br
 The following global options (applying to the filter, not the sources) may also be set in the playlist:
@@ -4460,7 +4726,7 @@
 .br
 The filter will look for property M2TSRA set on the input stream.
 .br
-The value can either be a 4CC or a string, indicating the MP2G-2 TS Registration tag for unknwon media types.
+The value can either be a 4CC or a string, indicating the MP2G-2 TS Registration tag for unknown media types.
 .br
 
 .br
@@ -4806,6 +5072,14 @@
 .br
 
 .br
+The segmenter will by default announce a new segment in the manifest(s) as soon as its size/offset is known or its name is known, but the segment (or part in LL-HLS) may still not be completely written/sent.
+.br
+This may result in temporary mismatches between segment/part size currently received versus size as advertized in manifest.
+.br
+If the target destination cannot support this, use .I seg_sync to update manifest(s) only once segments/parts are completely flushed; this will however slightly increase the latency of manifest updates.
+.br
+
+.br
 .SS Dynamic (real-time live) Mode
 .br
 The dasher does not perform real-time regulation by default.
@@ -4828,6 +5102,12 @@
 .br
 * llhls: enable low latency for HLS
 .br
+
+.br
+Note: .I llhls will force CMAF to cmfc if .I cmaf is not set.
+.br
+
+.br
 If your sources are not real-time, insert a reframer filter with real-time regulation
 .br
 Example
@@ -5080,7 +5360,7 @@
 .br
  * subs_sidx=0: indicates an SIDX shall be generated - only added if not already specified by user
 .br
- * xps_inband=all|no: indicates AVC/HEVC/... parameter sets shall be sent inband or out of band
+ * xps_inband=all|no|both: indicates AVC/HEVC/... parameter sets shall be sent inband, out of band, or both
 .br
  * nofragdef: indicates fragment defaults should be set in each segment rather than in init segment
 .br
@@ -5094,12 +5374,14 @@
 .br
 * LLHLS: identifies LLHLS is used; the multiplexer must send fragment size events back to the dasher, and set LLHLSFragNum on the first packet of each fragment
 .br
+* SegSync: indicates that fragments/segments must be completely flushed before sending back size events
+.br
 
 .br
 .SH Options (expert):
 .LP
 .br
-segdur (frac, default: 0/0):   target segment duration in seconds. A value less than or equal to 0 means to 1.0 second
+segdur (frac, default: 0/0):   target segment duration in seconds. A value less than or equal to 0 defaults to 1.0 second
 .br
 tpl (bool, default: true):     use template mode (multiple segment, template URLs)
 .br
@@ -5147,6 +5429,8 @@
 .br
 * inband: moves decoder config inband if possible
 .br
+* both: inband and outband parameter sets
+.br
 * pps: moves PPS and APS inband, keep VPS,SPS and DCI out of band (used for VVC RPR)
 .br
 * force: enables it even if only one representation
@@ -5221,7 +5505,7 @@
 .br
 * f: stores in movie fragment only
 .br
-* v: stores in movie only
+* v: stores in movie only, or movie and fragments if key roll is detected
 .br
 * m: stores in mpd only
 .br
@@ -5285,6 +5569,8 @@
 .br
 * on: warn if any PID uses SAP 3 or 4 and switch to FULL profile
 .br
+* intra: ignore SAP types greater than 3 on all media types
+.br
 
 .br
 subs_sidx (sint, default: -1): number of subsegments per sidx. negative value disables sidx. Only used to inherit sidx option of destination
@@ -5357,6 +5643,24 @@
 .br
 ll_rend_rep (bool, default: true): inject rendition reports for LL-HLS
 .br
+ll_part_hb (dbl, default: -1): user-defined part hold-back for LLHLS, negative value means 3 times max part duration in session
+.br
+ckurl (str):                   set the ClearKey URL common to all encrypted streams (overriden by CKUrl pid property)
+.br
+hls_absu (enum, default: no):  use absolute url in HLS generation using first URL in base
+.br
+* no: do not use absolute URL
+.br
+* var: use absolute URL only in variant playlists
+.br
+* mas: use absolute URL only in master playlist
+.br
+* both: use absolute URL everywhere
+.br
+
+.br
+seg_sync (bool, default: false): force waiting for last packet of fragment/segment to be written before announcing segment in DASH/HLS playlist
+.br
 cmaf (enum, default: no):      use cmaf guidelines
 .br
 * no: CMAF not enforced
@@ -5373,6 +5677,22 @@
 .br
 gencues (bool, default: false): only insert segment boundaries and do not generate manifests
 .br
+force_init (bool, default: false): force init segment creation in bitstream switching mode
+.br
+keep_src (bool, default: false): keep source URLs in manifest generation mode
+.br
+gxns (bool, default: false):   insert some gpac extensions in manifest (for now, only tfdt of first segment)
+.br
+dkid (enum, default: auto):    control injection of default KID in MPD
+.br
+* off: default KID not injected
+.br
+* on: default KID always injected
+.br
+* auto: default KID only injected if no key roll is detected (as per DASH-IF guidelines)
+.br
+
+.br
 
 .br
 .SH tileagg
@@ -5564,6 +5884,12 @@
 .br
 On non windows hosts, the created pipe will delete the pipe file upon filter destruction.
 .br
+The pipe can be kept alive after a broken pipe is detected using .I ka. This is typically used when clients crash/exits and resumes.
+.br
+When a keep-alive pipe is broken, input data is discarded and the filter will keep trashing data as fast as possible.
+.br
+It is therefore recommended to use this mode with real-time inputs (use a reframer if needed).
+.br
 
 .br
 .SH Options (expert):
@@ -5585,6 +5911,8 @@
 .br
 block_size (uint, default: 5000): buffer size used to write to pipe, windows only
 .br
+ka (bool, default: false):     keep pipe alive when broken pipe is detected
+.br
 
 .br
 .SH gsfmx
@@ -5868,7 +6196,7 @@
 .br
 fps (frac, default: 0/1000):   import frame rate (0 default to FPS from bitstream or 25 Hz)
 .br
-index (dbl, default: -1.0):    indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 100M (slows down importers) unless a play with start range > 0 is issued
+index (dbl, default: -1.0):    indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 20M (slows down importers) unless a play with start range > 0 is issued
 .br
 importer (bool, default: false): compatibility with old importer
 .br
@@ -5878,7 +6206,7 @@
 .br
 temporal_delim (bool, default: false): keep temporal delimiters in reconstructed frames
 .br
-bsdbg (enum, default: off):    debug NAL parsing in parser@debug logs
+bsdbg (enum, default: off):    debug OBU parsing in media@debug logs
 .br
 * off: not enabled
 .br
@@ -5921,6 +6249,8 @@
 .br
 This filter decodes MPEG-2, MPEG-4 Part 2, AVC|H264 and HEVC streams through NVidia decoder. It allows GPU frame dispatch or direct frame copy.
 .br
+If the SDK is not available, the configuration key nvdec@disabled will be written in configuration file to avoid future load attempts.
+.br
 
 .br
 .SH Options (expert):
@@ -6187,6 +6517,10 @@
 .br
 
 .br
+The filter does not check for RTCP timeout and will run until all input PIDs reach end of stream.
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
@@ -6245,6 +6579,19 @@
 .br
 
 .br
+The scheduling algorithm and RTP options are the same as the RTP output filter, see gpac -h rtpout
+.br
+The server will disconnect UDP streaming sessions if no RTCP traffic has been received for .I timeout seconds.
+.br
+
+.br
+The server can run over TLS by specifying .I cert and .I pkey, in which case the default .I port is 322.
+.br
+
+.br
+.SH Sink mode
+.LP
+.br
 The filter can work as a simple output filter by specifying the .I dst option:
 .br
 Example
@@ -6259,6 +6606,9 @@
 .br
 
 .br
+.SH Server mode
+.LP
+.br
 The filter can work as a regular RTSP server by specifying the .I mounts option to indicate paths of media file to be served:
 .br
 Example
@@ -6267,7 +6617,33 @@
 .br
 
 .br
-In server mode, it is possible to load any source supported by gpac by setting the option .I dynurl.
+In this case, content RES from any of the specified directory is exposed as rtsp://SERVER/RES
+.br
+
+.br
+The .I mounts option can also specify access rule file(s), see gpac -h creds. When rules are used:
+.br
+- if a directory has a name rule, it will be used in the URL
+.br
+- otherwise, the directory is directly available under server root /
+.br
+- only read access and multicast rights are checked
+.br
+Example
+.br
+foodir
+.br
+name=bar
+.br
+
+.br
+Content RES of this directory is exposed as rtsp://SERVER/bar/RES.
+.br
+  
+.br
+
+.br
+In this mode, it is possible to load any source supported by gpac by setting the option .I dynurl.
 .br
 The expected syntax of the dynamic RTSP URLs is rtsp://servername/?URL1&URLN or rtsp://servername/@URL1@URLN 
 .br
@@ -6285,6 +6661,33 @@
 .br
 
 .br
+The parameter name=VAL is reserved to assign a session name in case multicast mirroring is used.
+.br
+Example
+.br
+gpac -i rtsp://localhost/?name=live?pipe://mynamepipe&myfile.mp4 dst filters
+.br
+
+.br
+
+.br
+Usage of dynamic URLs can also be configured using the specific directory $dynurl in an access rule file.
+.br
+EX$dynurl
+.br
+ru=foo
+.br
+This will allow dynamic URLs only for foo user.
+.br
+
+.br
+Note: If the .I dynurl is set, it is enabled for all users, without authentication.
+.br
+
+.br
+.SH Multicasting
+.LP
+.br
 In both modes, clients can setup multicast if the .I mcast option is on or mirror.
 .br
 When .I mcast is set to mirror mode, any DESCRIBE command on a resource already delivered through a multicast session will use that multicast.
@@ -6293,7 +6696,16 @@
 .br
 
 .br
-The scheduling algorithm and RTP options are the same as the RTP output filter, see gpac -h rtpout
+In server mode, multicast can be enabled per read directory using the mcast access rule of the directory configuration - see gpac -h creds.
+.br
+
+.br
+.SH HTTP Tunnel
+.LP
+.br
+The server mode supports handling RTSP over HTTP tunnel by default. This can be disabled using .I htun.
+.br
+The tunnel conforms to QT specification, and only HTTP 1.0 and 1.1 tunnels are supported.
 .br
 
 .br
@@ -6334,9 +6746,11 @@
 .br
 maxc (uint, default: 100):     maximum number of connections
 .br
+timeout (uint, default: 20):   timeout in seconds for inactive sessions (0 disable timeout)
+.br
 user_agent (str, default: $GUA): user agent string, by default solved from GPAC preferences
 .br
-close (bool, default: true):   close RTSP connection after each request, except when RTP over RTSP is used
+close (bool, default: false):  close RTSP connection after each request, except when RTP over RTSP is used
 .br
 loop (bool, default: true):    loop all streams in session (not always possible depending on source type)
 .br
@@ -6352,6 +6766,24 @@
 .br
 
 .br
+quit (bool, default: false):   exit server once first session is over (for test purposes)
+.br
+htun (bool, default: true):    enable RTSP over HTTP tunnel
+.br
+trp (enum, default: both):     transport mode
+.br
+* both: allow TCP or UDP traffic
+.br
+* udp: only allow UDP traffic
+.br
+* tcp: only allow TCP traffic
+.br
+
+.br
+cert (str):                    certificate file in PEM format to use for TLS mode
+.br
+pkey (str):                    private key file in PEM format to use for TLS mode
+.br
 
 .br
 .SH httpout
@@ -6397,6 +6829,26 @@
 .br
   
 .br
+A directory rule file (cf gpac -h creds) can be specified in .I rdirs but NOT in .I wdir. When rules are used:
+.br
+- if a directory has a name rule, it will be used in the URL
+.br
+- otherwise, the directory is directly available under server root /
+.br
+- read and write access rights are checked
+.br
+Example
+.br
+foodir
+.br
+name=bar
+.br
+
+.br
+Content RES of this directory is exposed as http://SERVER/bar/RES.
+.br
+  
+.br
 Listing can be enabled on server using .I dlist.
 .br
 When disabled, a GET on a directory will fail.
@@ -6483,6 +6935,14 @@
 .br
 This will inject the header ice-Genre: CoolRock in the response.  
 .br
+Once one complete input file is sent, it is no longer available for download unless .I reopen is set and input PID is not over.
+.br
+  
+.br
+This mode should not be used with multiple files muxers such as DASH or HLS.
+.br
+  
+.br
 .SH HTTP server file sink
 .LP
 .br
@@ -6520,13 +6980,15 @@
 .br
   
 .br
-If .I max_cache_segs valeu N is not 0, each incoming PID will store at most:
+If .I max_cache_segs value N is not 0, each incoming PID will store at most:
 .br
 - MIN(N, time-shift depth) files if stored in memory
 .br
+- -N files if stored locally and N is negative
+.br
 - MAX(N, time-shift depth) files if stored locally and N is positive
 .br
-- -N files if stored locally and N is negative
+- unlimited otherwise (files stored locally, N is positive and no time-shift info)
 .br
   
 .br
@@ -6645,7 +7107,7 @@
 .br
 
 .br
-timeout (uint, default: 30):   timeout in seconds for persistent connections (0 disable timeout)
+timeout (uint, default: 5):    timeout in seconds for persistent connections (0 disable timeout)
 .br
 ext (cstr):                    set extension for graph resolution, regardless of file extension
 .br
@@ -6677,6 +7139,12 @@
 .br
 max_cache_segs (sint, default: 5): maximum number of segments cached per HAS quality (see filter help)
 .br
+reopen (bool, default: false): in server mode with no read dir, accept requests on files already over but with input pid not in end of stream
+.br
+max_async_buf (uint, default: 100000): maximum async buffer size in bytes when sharing output over multiple connection without file IO
+.br
+blockio (bool, default: false): use blocking IO in push or source mode or in server mode with no read dir
+.br
 
 .br
 .SH hevcsplit
@@ -6820,11 +7288,19 @@
 .br
 
 .br
+By default the reframer will only check CRC footer of frames if a change in sample rate or channel mapping is detected.
+.br
+This should accomodate for most configurations, but CRC check can be enforced using .I docrc.
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
 index (dbl, default: 1.0):     indexing window length
 .br
+docrc (bool, default: false):  perform CRC check after each frame
+.br
 
 .br
 .SH rfmhas
@@ -6977,6 +7453,8 @@
 .br
 novsi (bool, default: false, updatable): remove video_signal_type from VUI in AVC|H264 and HEVC
 .br
+novuitiming (bool, default: false, updatable): remove timing_info from VUI in AVC|H264 and HEVC
+.br
 prof (sint, default: -1, updatable): profile indication for AVC|H264
 .br
 lev (sint, default: -1, updatable): level indication for AVC|H264, level_idc for VVC
@@ -7119,12 +7597,179 @@
 .br
 
 .br
+.SH ufttxt
+.LP
+.br
+Description: TX3G unframer
+.br
+
+.br
+This filter converts a single ISOBMFF TX3G stream to TTXT (xml format) unframed stream.
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+exporter (bool, default: false): compatibility with old exporter, displays export results
+.br
+
+.br
+.SH tx3g2srt
+.LP
+.br
+Description: TX3G to SRT
+.br
+
+.br
+This filter converts a single ISOBMFF TX3G stream to an SRT unframed stream.
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+exporter (bool, default: false): compatibility with old exporter, displays export results
+.br
+
+.br
+.SH tx3g2vtt
+.LP
+.br
+Description: TX3G to WebVTT
+.br
+
+.br
+This filter converts a single ISOBMFF TX3G stream to a WebVTT unframed stream.
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+exporter (bool, default: false): compatibility with old exporter, displays export results
+.br
+
+.br
+.SH tx3g2ttml
+.LP
+.br
+Description: TX3G to TTML
+.br
+
+.br
+This filter converts ISOBMFF TX3G stream to a TTML stream.
+.br
+
+.br
+Each output TTML frame is a complete TTML document.
+.br
+
+.br
+No options
+.br
+
+.br
+.SH vtt2tx3g
+.LP
+.br
+Description: WebVTT to TX3G
+.br
+
+.br
+This filter rewrites unframed WebVTT to TX3G / QT Timed Text (binary format)
+.br
+
+.br
+Unframed WebVTT packets consist in single cues:
+.br
+- cue payload as packet payload
+.br
+- prefix as packet string property vtt_pre
+.br
+- cue ID as packet string property vtt_cueid
+.br
+- cue settings as packet string property vtt_settings
+.br
+- packet timing contains the cue timing (start and duration)
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+fontname (str):                default font
+.br
+fontsize (uint, default: 18):  default font size
+.br
+
+.br
+.SH rfsrt
+.LP
+.br
+Description: SRT reframer
+.br
+
+.br
+This filter rewrites unframed SRT to TX3G / QT Timed Text (binary format)
+.br
+
+.br
+An unframed SRT packet consists in a single SRT cue as packet payload and packet timing contains the cue timing (start and duration).
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+fontname (str):                default font
+.br
+fontsize (uint, default: 18):  default font size
+.br
+
+.br
+.SH ttml2vtt
+.LP
+.br
+Description: TTML to WebVTT
+.br
+
+.br
+This filter converts TTML frames to unframed WebVTT
+.
+.br
+Conversion is quite limited: only the first div is analyzed and only basic styling is implemented.
+.br
+
+.br
+No options
+.br
+
+.br
+.SH ttml2srt
+.LP
+.br
+Description: TTML to SRT
+.br
+
+.br
+This filter converts TTML frames to unframed SRT
+.
+.br
+Conversion is quite limited: only the first div is analyzed and only basic styling is implemented.
+.br
+
+.br
+No options
+.br
+
+.br
 .SH ffdmx
 .LP
 .br
 Description: FFMPEG demultiplexer
 .br
-Version: Lavf59.17.102
+Version: Lavf59.34.102
 .br
 
 .br
@@ -7156,7 +7801,7 @@
 .br
 Description: FFMPEG decoder
 .br
-Version: Lavc59.21.100
+Version: Lavc59.55.100
 .br
 
 .br
@@ -7179,7 +7824,7 @@
 .br
 The .I ffcmap option allows specifying FFMPEG codecs for codecs not supported by GPAC.
 .br
-Each entry in the list is formated as GID@name or GID@+name, with:
+Each entry in the list is formatted as GID@name or GID@+name, with:
 .br
 * GID: 4CC or 32 bit identifier of codec ID, as indicated by gpac -i source inspect:full
 .br
@@ -7191,7 +7836,7 @@
 .br
 Example
 .br
-gpac -i source --ffcmap=BKV1@binkvideo vout
+gpac -i source.mp4 --ffcmap=BKV1@binkvideo vout
 .br
 
 .br
@@ -7204,6 +7849,8 @@
 .br
 ffcmap (strl):                 codec map
 .br
+c (str):                       codec name (GPAC or ffmpeg), only used to query possible arguments - updated to ffmpeg codec name after initialization
+.br
 * (str):                       any possible options defined for AVCodecContext and sub-classes. See gpac -hx ffdec and gpac -hx ffdec:*
 .br
 
@@ -7213,7 +7860,7 @@
 .br
 Description: FFMPEG AV Capture
 .br
-Version: Lavd59.5.100
+Version: Lavd59.8.101
 .br
 
 .br
@@ -7262,6 +7909,16 @@
 .br
 
 .br
+You may need to escape the .I dev option if the format uses ':' as separator, as is the case for AVFoundation:
+.br
+Example
+.br
+gpac -i av://::dev=0:1 ...
+.br
+
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
@@ -7298,7 +7955,7 @@
 .br
 Description: FFMPEG video rescaler
 .br
-Version: SwS6.5.100
+Version: SwS6.8.112
 .br
 
 .br
@@ -7373,7 +8030,7 @@
 .br
 osize (v2di):                  osize of output video
 .br
-ofmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,yuv444ap,yuv444p_10,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,rgbs,rgbas): pixel format for output video. When not set, input format is used
+ofmt (pfmt, default: none, minmax: none,yuv420,yvu420,yuv420_10,yuv422,yuv422_10,yuv444,yuv444_10,uyvy,vyuy,yuyv,yvyu,uyvl,vyul,yuyl,yvyl,nv12,nv21,nv1l,nv2l,yuva,yuvd,yuv444a,yuv444p,v308,yuv444ap,v408,v410,v210,grey,algr,gral,rgb4,rgb5,rgb6,rgba,argb,bgra,abgr,rgb,bgr,xrgb,rgbx,xbgr,bgrx,rgbd,rgbds,uncv): pixel format for output video. When not set, input format is used
 .br
 scale (enum, default: bicubic): scaling mode (see filter help) (fastbilinear|bilinear|bicubic|X|point|area|bicublin|gauss|sinc|lanzcos|spline)
 .br
@@ -7416,7 +8073,7 @@
 .br
 Description: FFMPEG encoder
 .br
-Version: Lavc59.21.100
+Version: Lavc59.55.100
 .br
 
 .br
@@ -7456,10 +8113,22 @@
 .br
 
 .br
+The filter will look for property logpass on input PID to set 2-pass log filename, otherwise defaults to ffenc2pass-PID.log.
+.br
+
+.br
+Arguments may be updated at runtime. If .I rld is set, the encoder will be flushed then reloaded with new options.
+.br
+If codec is video and .I fintra is set, reload will happen at next forced intra; otherwise, reload happens at next encode.
+.br
+The .I rld option is usually needed for dynamic updates of rate control parameters, since most encoders in ffmpeg do not support it.
+.br
+
+.br
 .SH Options (expert):
 .LP
 .br
-c (str):                       codec identifier. Can be any supported GPAC codec name or ffmpeg codec name
+c (str):                       codec identifier. Can be any supported GPAC codec name or ffmpeg codec name - updated to ffmpeg codec name after initialization
 .br
 pfmt (pfmt, default: none):    pixel format for input video. When not set, input format is used
 .br
@@ -7471,6 +8140,8 @@
 .br
 rc (bool, default: false):     reset encoder when forcing intra frame (some encoders might not support intra frame forcing)
 .br
+rld (bool, default: false, updatable): force reloading of encoder when arguments are updated
+.br
 * (str):                       any possible options defined for AVCodecContext and sub-classes. see gpac -hx ffenc and gpac -hx ffenc:*
 .br
 
@@ -7480,7 +8151,7 @@
 .br
 Description: FFMPEG multiplexer
 .br
-Version: Lavf59.17.102
+Version: Lavf59.34.102
 .br
 
 .br
@@ -7517,7 +8188,7 @@
 .br
 speed (dbl, default: 1.0):     set playback speed. If negative and start is 0, start is set to -1
 .br
-interleave (bool, default: true): write frame in interleave mode
+ileave (frac, default: 1):     interleave window duration in second, a value of 0 disable interleaving
 .br
 nodisc (bool, default: false): ignore stream configuration changes while multiplexing, may result in broken streams
 .br
@@ -7529,6 +8200,8 @@
 .br
 block_size (uint, default: 4096): block size used to read file when using avio context
 .br
+keepts (bool, default: true):  do not shift input timeline back to 0
+.br
 * (str):                       any possible options defined for AVFormatContext and sub-classes (see gpac -hx ffmx and gpac -hx ffmx:*)
 .br
 
@@ -7538,7 +8211,7 @@
 .br
 Description: FFMPEG AVFilter
 .br
-Version: Lavf59.17.102
+Version: Lavf59.34.102
 .br
 
 .br
@@ -7569,6 +8242,26 @@
 .br
 ffavf::f=showspectrum=size=320x320 or ffavf::f=showspectrum=size=320x320::pfmt=rgb
 .br
+ffavf::f=anullsrc=channel_layout=5.1:sample_rate=48000
+.br
+
+.br
+
+.br
+For complex filter graphs, it is possible to store options in a file (e.g. opts.txt):
+.br
+Example
+.br
+:f=anullsrc=channel_layout=5.1:sample_rate=48000
+.br
+
+.br
+And load arguments from file:
+.br
+Example
+.br
+ffavf:opts.txt aout
+.br
 
 .br
 
@@ -7656,6 +8349,50 @@
 .br
 
 .br
+.SH ffbsf
+.LP
+.br
+Description: FFMPEG BitStream filter
+.br
+Version: Lavc59.55.100
+.br
+
+.br
+This filter provides bitstream filters (BSF) for compressed audio and video formats.
+.br
+See FFMPEG documentation (https://ffmpeg.org/documentation.html) for more details
+.br
+To list all supported bitstream filters for your GPAC build, use gpac -h ffbsf:*.
+.br
+
+.br
+Several BSF may be specified in .I f for different coding types. BSF not matching the coding type are silently ignored.
+.br
+When no BSF matches the input coding type, or when .I f is empty, the filter acts as a passthrough filter.
+.br
+
+.br
+Options are specified after the desired filters:
+.br
+- ffbsf:f=h264_metadata:video_full_range_flag=0
+.br
+- ffbsf:f=h264_metadata,av1_metadata:video_full_range_flag=0:color_range=tv
+.br
+
+.br
+Note: Using BSFs on some media types (e.g. avc, hevc) may trigger creation of a reframer filter (e.g. rfnalu)
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+f (strl):                      bitstream filters name - see filter help
+.br
+* (str):                       any possible options defined for AVBitstreamFilter and sub-classes. See gpac -hx ffbsf and gpac -hx ffbsf:*
+.br
+
+.br
 .SH jsf
 .LP
 .br
@@ -7956,6 +8693,8 @@
 .br
 index (dbl, default: 1.0):     indexing window length
 .br
+auxac3 (bool, default: false): expose auxiliary AC-3 stream if present
+.br
 
 .br
 .SH cryptin
@@ -8029,7 +8768,7 @@
 .br
 
 .br
-The specified delay per stream class can be either positive (stream presented later) or negative (stream presented sooner).
+The delays (global or per stream class) can be either positive (stream presented later) or negative (stream presented sooner).
 .br
 
 .br
@@ -8060,6 +8799,8 @@
 .br
 fps (frac, default: 0/1):      target fps
 .br
+delay (frac, default: 0/1, updatable): delay to add to all streams
+.br
 delay_v (frac, default: 0/1, updatable): delay to add to video streams
 .br
 delay_a (frac, default: 0/1, updatable): delay to add to audio streams
@@ -8078,6 +8819,76 @@
 .br
 
 .br
+tsinit (lfrac, default: -1/1): initial timestamp to resync to, negative values disables resync
+.br
+
+.br
+.SH oggmx
+.LP
+.br
+Description: OGG multiplexer
+.br
+
+.br
+This filter multiplexes audio and video to produce an OGG stream.
+.br
+
+.br
+The .I cdur option allows specifiying the interleaving duration (max time difference between consecutive packets of different streams). 
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+cdur (frac, default: 1/10):    stream interleaving duration in seconds
+.br
+rcfg (frac, default: 0/1):     stream config re-injection frequency in seconds
+.br
+
+.br
+.SH unframer
+.LP
+.br
+Description: Stream unframer
+.br
+
+.br
+This filter is used to force reframing of input sources using the same internal framing as GPAC (e.g. ISOBMFF) but with broken framing or signaling.
+.br
+Example
+.br
+gpac -i src.mp4 unframer -o dst.mp4
+.br
+
+.br
+This will:
+.br
+- force input PIDs of unframer to be in serialized form (AnnexB, ADTS, ...)
+.br
+- trigger reframers to be instanciated after the unframer filter.
+.br
+Using the unframer filter avoids doing a dump to disk then reimport or other complex data piping.
+.br
+
+.br
+No options
+.br
+
+.br
+.SH writeuf
+.LP
+.br
+Description: Stream to unframed format
+.br
+
+.br
+Generic single stream to unframed format converter, used when converting PIDs. This filter should not be explicitly loaded.
+.br
+
+.br
+No options
+.br
 
 .br
 .SH dtout
@@ -8146,6 +8957,220 @@
 .br
 
 .br
+.SH glpush
+.LP
+.br
+Description: GPU texture uploader
+.br
+Version: 1.0
+.br
+Author: GPAC team
+.br
+
+.br
+This filter pushes input video streams to GPU as OpenGL textures. It can be used to simulate hardware decoders dispatching OpenGL textures
+.br
+
+.br
+No options
+.br
+
+.br
+.SH thumbs
+.LP
+.br
+Description: Thumbnail collection generator
+.br
+Version: 1.0
+.br
+Author: GPAC team
+.br
+
+.br
+This filter generates screenshots from a video stream.
+.br
+
+.br
+The input video is downsampled by the .I scale factor. The output size is configured based on the number of images per line and per column in the .I grid. 
+.br
+Once configured, the output size is no longer modified.
+.br
+
+.br
+The .I snap option indicates to use one video frame every given seconds. If value is 0, all input frames are used.
+.br
+
+.br
+If the number of rows is 0, it will be computed based on the source duration and desired .I snap time, and will default to 10 if it cannot be resolved.
+.br
+
+.br
+To output one image per input frame, use :grid=1x1.
+.br
+
+.br
+If a single image per output frame is used, the default value for .I snap is 0 and for .I scale is 1.
+.br
+Otherwise, the default value for .I snap is 1 second and for .I scale is 10.
+.br
+
+.br
+A single line of text can be inserted over each frame. Predefined keywords can be used in input text, identified as $KEYWORD$:
+.br
+* ts: replaced by packet timestamp
+.br
+* timescale: replaced by PID timescale
+.br
+* time: replaced by packet time as HH:MM:SS.ms
+.br
+* cpu: replaced by current CPU usage of process
+.br
+* mem: replaced by current memory usage of process
+.br
+* version: replaced by GPAC version
+.br
+* fversion: replaced by GPAC full version
+.br
+* mae: replaced by Mean Absolute Error with previous frame
+.br
+* mse: replaced by Mean Square Error with previous frame
+.br
+* P4CC, PropName: replaced by corresponding PID property
+.br
+
+.br
+Example
+.br
+gpac -i src reframer:saps=1 thumbs:snap=30:grid=6x30 -o dump/$num$.png
+.br
+
+.br
+This will generate images from key-frames only, inserting one image every 30 seconds. Using key-frame filtering is much faster but may give unexpected results if there are not enough key-frames in the source.
+.br
+
+.br
+Example
+.br
+gpac -i src thumbs:snap=0:grid=5x5 -o dump/$num$.png
+.br
+
+.br
+This will generate one image containing 25 frames every second at 25 fps.
+.br
+
+.br
+If a single image per output frame is used and the scaling factor is 1, the input packet is reused as input with text and graphics overlaid.
+.br
+
+.br
+Example
+.br
+gpac -i src thumbs:grid=1x1:txt='Frame $time$' -o dump/$num$.png
+.br
+
+.br
+This will inject text over each frame and keep timing and other packet properties.
+.br
+
+.br
+A json output can be specified in input .I list to let applications retrieve frame position in output image from its timing.
+.br
+
+.br
+.SH Scene change detection
+.LP
+.br
+
+.br
+The filter can compute the absolute and/or square error metrics between consecutive images and drop image if the computed metric is less than the given threshold.
+.br
+If both .I mae and .I mse thresholds are 0, scene detection is not performed (default).
+.br
+If both .I mae and .I mse thresholds are not 0, the frame is added if it passes both thresholds.
+.br
+
+.br
+For both metrics, a value of 0 means all pixels are the same, a value of 100 means all pixels have 100% intensity difference (e.g. black versus white).
+.br
+
+.br
+The scene detection is performed after the .I snap filtering and uses:
+.br
+- the previous frame in the stream, whether it was added or not, if .I scref is not set,
+.br
+- the last added frame otherwise.
+.br
+
+.br
+Typical thresholds for scene cut detection are 14 to 20 for .I mae and 5 to 7 for .I mse.
+.br
+
+.br
+Since this is a costly process, it is recommended to use it combined with key-frames selection:
+.br
+
+.br
+Example
+.br
+gpac -i src reframer:saps=1 thumbs:mae=15 -o dump/$num$.png
+.br
+
+.br
+
+.br
+The .I maxsnap option can be used to force insertion after the given time if no scene cut is found.
+.br
+
+.br
+.SH Options (expert):
+.LP
+.br
+grid (v2di, default: 6x0):     number of images per lines and columns
+.br
+scale (dbl, default: -1):      scale factor for input size
+.br
+mae (uint, default: 0, minmax: 0,100): scene diff threshold using Mean Absolute Error
+.br
+mse (uint, default: 0, minmax: 0,100): scene diff threshold using Mean Square Error
+.br
+lw (dbl, default: 0.0):        line width between images in pixels
+.br
+lc (str, default: white):      line color
+.br
+clear (str, default: white):   clear color
+.br
+snap (dbl, default: -1):       duration between images, 0 for all images
+.br
+maxsnap (dbl, default: -1):    maximum duration between two thumbnails when scene change detection is enabled
+.br
+pfmt (pfmt, default: rgb):     output pixel format
+.br
+txt (str, default: ):          text to insert per thumbnail
+.br
+tc (str, default: white):      text color
+.br
+tb (str, default: black):      text shadow
+.br
+font (str, default: SANS):     font to use
+.br
+fs (dbl, default: 10):         font size to use in percent of scaled height
+.br
+tv (dbl, default: 0):          text vertical position in percent of scaled height
+.br
+thread (sint, default: -1):    number of threads for software rasterizer, -1 for all available cores
+.br
+blt (bool, default: true):     use blit instead of software rasterizer
+.br
+scref (bool, default: false):  use last inserted image as reference for scene change detection
+.br
+dropfirst (bool, default: false): drop first image
+.br
+list (str, default: null):     export json list of frame times and positions to given file
+.br
+lxy (bool, default: false):    add explict x and y in json export
+.br
+
+.br
 .SH avmix
 .LP
 .br
@@ -8437,9 +9462,25 @@
 .br
 * date: converted to UTC date in live mode, and to 0 for non-live mode
 .br
-* N: converted to current utc clock plus N seconds UTC
+* N: converted to current utc clock (or 0 for non-live mode) plus N seconds UTC
+.br
+* "N": converted to current utc clock (or 0 for non-live mode) plus N seconds UTC
 .br
-* "N": converted to current utc clock plus N seconds UTC
+
+.br
+In 'live' mode, if start is set using a UTC date, the sequence will have a start range equal to MAX(current_UTC - start_in_UTC, 0). Some sources may be skipped to fulfill this condition.
+.br
+This allows different instances of the filter using the same playlist to initialize media time in the same fashion.
+.br
+
+.br
+When reloading the playlist:
+.br
+- if the sequence is active, start value is ignored 
+.br
+- if the sequence was not started, start value is updated 
+.br
+- if the sequence was over, start value is updated only of greater than previous resolved UTC start time. 
 .br
 
 .br
@@ -8475,6 +9516,8 @@
 .br
 * prefetch (500): prefetch duration in ms (play before start time of source), 0 for no prefetch
 .br
+* hold (false): if media duration is known and media stop time is greater than media duration, activate no signal mode until desired stop time is reached (disable transition), otherwise move to next source at end of stream
+.br
 
 .br
 .SS Source Locations
@@ -8813,6 +9856,18 @@
 .br
   * other: no audio fade
 .br
+* autoshow (true): automatically deactivate scene when sequences set in sources are not active
+.br
+* nosig ('lost'): enable no-signal message for scenes using sequences:
+.br
+  * no: disable message
+.br
+  * lost: display message when signal is lost
+.br
+  * before: display message if source is not yet active
+.br
+  * all: always display message if source is inactive
+.br
 * styles (): list of style IDs to use
 .br
 - any other property exposed by the underlying scene JS module.
@@ -8831,6 +9886,10 @@
 .br
 
 .br
+If a scene uses one or more sequences and autoshow is not set, the scene will be drawn with no sequence attached if all sequences are inactive (not yet started or over).
+.br
+
+.br
 .SS Transitions and Mixing effects
 .br
 .P
@@ -9340,8 +10399,6 @@
 .br
  {"replace": "seq1@start", "with": "now"}
 .br
- }
-.br
 
 .br
 
@@ -9515,6 +10572,8 @@
 .br
 * fversion: replaced by GPAC full version
 .br
+* P4CC, PropName: replaced by corresponding PID property
+.br
 
 .br
 .SS Custom paths
@@ -9609,7 +10668,7 @@
 .br
 * keep_ar (true): keep aspect ratio
 .br
-* pad_color ('none'): color to use for texture padding if rs or rt are false. Use none to use texture edge, 0x00FFFFFF for transparent (always enforced if source is transparent)
+* pad_color ('0x00FFFFFF'): color to use for texture padding if rs or rt are false. Use none to use texture edge, 0x00FFFFFF for transparent (always enforced if source is transparent)
 .br
 * txmx (): texture matrix - all 6 coefficients must be set, i.e. xx xy tx yx yy ty
 .br
@@ -9879,7 +10938,7 @@
 .br
 maxdepth (uint, default: 100): maximum depth of a branch in the scene graph
 .br
-vsize (v2d, default: 1920x1080): output video size
+vsize (v2d, default: 1920x1080): output video size, 0 disable video output
 .br
 fps (frac, default: 25):       output video frame rate
 .br
@@ -9895,9 +10954,9 @@
 .br
 
 .br
-sr (uint, default: 44100):     output audio sample rate
+sr (uint, default: 44100):     output audio sample rate, 0 disable audio output
 .br
-ch (uint, default: 2):         number of output audio channels
+ch (uint, default: 2):         number of output audio channels, 0 disable audio output
 .br
 afmt (afmt, default: s16):     output audio format (only s16, s32, flt and dbl are supported)
 .br
@@ -10046,6 +11105,8 @@
 .br
 rates (strl):                  number of target bitrates to assign, one per size
 .br
+logt (bool):                   log frame time to console
+.br
 
 .br
 .SH EXAMPLES
@@ -10057,10 +11118,10 @@
 .br
 For bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac
 .br
-build: 1.1.0-DEV-rev1777-gb91a8dad3-master
+build: 2.2-rev655-g65430e305-master
 .br
 Copyright: (c) 2000-2022 Telecom Paris distributed under LGPL v2.1+ - http://gpac.io
 .br
 .SH SEE ALSO
 .LP
-gpac(1), MP4Client(1), MP4Box(1)
+gpac(1), MP4Box(1)

gpac-2.0.0.tar.gz/share/doc/man/gpac.1 -> gpac-2.2.0.tar.gz/share/doc/man/gpac.1 Changed

@@ -64,7 +64,12 @@
 .TP
 .B \-runfor (int)
 .br
-run for the given amount of milliseconds
+run for the given amount of milliseconds, exit with full session flush
+.br
+.TP
+.B \-runforf (int)
+.br
+run for the given amount of milliseconds, exit with fast session flush
 .br
 .TP
 .B \-runforx (int)
@@ -177,11 +182,17 @@
 .br
 * modules: print available modules
 .br
+* creds: print credential help
+.br
 * filters: print name of all available filters
 .br
 * filters:*: print name of all available filters, including meta filters
 .br
-* codecs: print the supported builtin codecs
+* codecs: print the supported builtin codecs - use -hx to include unmapped codecs (ffmpeg, ...)
+.br
+* formats: print the supported formats (-ha: print filter names, -hx: include meta filters (ffmpeg,...), -hh: print mime types)
+.br
+* protocols: print the supported protocol schemes (-ha: print filter names, -hx: include meta filters (ffmpeg,...), -hh: print all)
 .br
 * props: print the supported builtin PID and packet properties
 .br
@@ -259,6 +270,11 @@
 .br
 unrecognized options and filters declaration following this option are ignored - used to pass arguments to GUI
 .br
+.TP
+.B \-creds (string)
+.br
+setup credentials as used by servers
+.br
 
 .br
   
@@ -353,6 +369,21 @@
 .br
 disable memory recycling for packets and properties. This uses much less memory but stresses the system memory allocator much more
 .br
+.TP
+.B \-buffer-gen (int, default: 1000)
+.br
+default buffer size in microseconds for generic pids
+.br
+.TP
+.B \-buffer-dec (int, default: 1000000)
+.br
+default buffer size in microseconds for decoder input pids
+.br
+.TP
+.B \-buffer-units (int, default: 1)
+.br
+default buffer size in frames when timing is not available
+.br
 .SH Using Aliases
 .PL
 The gpac command line can become quite complex when many sources or filters are used. In order to simplify this, an alias system is provided.
@@ -405,7 +436,7 @@
 .br
 
 .br
-Before solving aliases, all option arguments are moved at the beginging of the command line. This implies that alias arguments cannot be options.
+Before solving aliases, all option arguments are moved at the beginning of the command line. This implies that alias arguments cannot be options.
 .br
 Arguments not used by any aliases are kept on the command line, other ones are removed
 .br
@@ -451,28 +482,149 @@
 .br
 
 .br
-.SH Configuration file
+.SH User Credentials
 .LP
 .br
-GPAC uses a configuration file to modify default options of libgpac and filters. This configuration file is located in $HOME/.gpac/GPAC.cfg.
+Some servers in GPAC can use user-based and group-based authentication.
+.br
+The information is stored by default in the file users.cfg located in the GPAC profile directory.
+.br
+The file can be overwritten using the .I -users option.
+.br
+
+.br
+By default, this file does not exist until at least one user has been configured.
+.br
+
+.br
+The .I creds option allows inspecting or modifying the users and groups information. The syntax for the option value is:
+.br
+* `show` or no value: prints the users.cfg file
+.br
+* `reset`: deletes the users.cfg file (i.e. deletes all users and groups)
+.br
+* `NAME`: show information of user NAME
+.br
+* `+NAME`: adds user NAME
+.br
+* `+NAME:I1=V1,I2=V2`: sets info I1 with value V1 to user NAME. the info name password resets password without prompt.
+.br
+* `-NAME`: removes user NAME
+.br
+* `_NAME`: force password change of user NAME
+.br
+* `@NAME`: show information of group NAME
+.br
+* `@+NAME:u1,u2`: adds group NAME if not existing and adds specified users to group
+.br
+* `@-NAME:u1,u2`: removes specified users from group NAME
+.br
+* `@-NAME`: removes group NAME
+.br
+
+.br
+By default all added users are members of the group users.
+.br
+Passwords are not stored, only a SHA256 hash is stored.
+.br
+
+.br
+Servers using authentication rules can use a configuration file instead of a directory name.
+.br
+This configuration file is organized in sections, each section name descibing a directory.
+.br
+Example
+.br
+somedir
+.br
+ru=foo
+.br
+rg=bar
+.br
+
+.br
+
+.br
+The following keys are defined per directory, but may be ignored by the server depending on its operation mode:
+.br
+* ru: comma-separated list of user names with read access to the directory
+.br
+* rg: comma-separated list of group names with read access to the directory
+.br
+* wu: comma-separated list of user names with write access to the directory
+.br
+* wg: comma-separated list of group names with write access to the directory
+.br
+* mcast: comma-separated list of user names with multicast creation rights (RTSP server only)
 .br
-Applications in GPAC can also specify a different configuration file through the .I -p option to indicate a profile. This allows different configurations for different usages and simplifies command line typing.
+* filters: comma-separated list of filter names for which the directory is valid. If not found or all, applies to all filters
+.br
+
+.br
+Rights can be configured on sub-directories by adding sections for the desired directories.
 .br
 Example
 .br
-gpac -p=foo 
+d1
+.br
+rg=bar
+.br
+d1/d2
+.br
+ru=foo
+.br
+
+.br
+With this configuration:
+.br
+- the directory d1 will be readable by all members of group bar
+.br
+- the directory d1/d2 will be readable by user foo only
 .br
 
 .br
+Servers in GPAC currently only support the Basic HTTP authentication scheme, and should preferably be run over TLS.
+.br
+.SH Configuration file
+.LP
+.br
+GPAC uses a configuration file to modify default options of libgpac and filters. This file is called GPAC.cfg and is located:
+.br
+- on Windows platforms, in C:\Users\FOO\AppData\Roaming\GPAC or in C:\Program Files\GPAC.
+.br
+- on iOS platforms, in a .gpac folder in the app storage directory.
+.br
+- on Android platforms, in /sdcard/GPAC/ if this directory exists, otherwise in /data/data/io.gpac.gpac/GPAC.
+.br
+- on other platforms, in a $HOME/.gpac/.
+.br
+
+.br
+Applications in GPAC can also specify a different configuration file through the .I -p profile option. EX gpac -p=foo 
+.br
 This will load configuration from $HOME/.gpac/foo/GPAC.cfg, creating it if needed.
 .br
 The reserved name 0 is used to disable configuration file writing.
 .br
-By default the configuration file only holds a few system specific options and directories. It is possible to serialize the entire set of options to the configuration file, using .I -wc .I -wf. This should be avoided as the resulting configuration file size will be quite large, hence larger memory usage for the applications.
+
+.br
+The configuration file is structured in sections, each made of one or more keys:
+.br
+- section foo is declared as foo\n
+.br
+- key bar with value N is declared as bar=N\n. The key value N is not interpreted and always handled as ASCII text.
+.br
+
+.br
+By default the configuration file only holds a few system specific options and directories. It is possible to serialize the entire set of options to the configuration file, using .I -wc .I -wf.
+.br
+This should be avoided as the resulting configuration file size will be quite large, hence larger memory usage for the applications.
 .br
-The options specified in the configuration file may be overridden by the values in restrict.cfg file located in GPAC share system directory (e.g. /usr/share/gpac), if present; this allows enforcing system-wide configuration values.
+The options specified in the configuration file may be overridden by the values in restrict.cfg file located in GPAC share system directory (e.g. /usr/share/gpac or C:\Program Files\GPAC), if present; this allows enforcing system-wide configuration values.
 .br
-Note: The methods describe in this section apply to any application in GPAC transferring their arguments to libgpac. This is the case for gpac, MP4Box, MP4Client/Osmo4.
+Note: The methods describe in this section apply to any application in GPAC transferring their arguments to libgpac. This is the case for gpac and MP4Box.
+.br
+
 .br
 .SH Core options
 .LP
@@ -481,7 +633,9 @@
 .br
 Example
 .br
-corethreads=2
+core
+.br
+threads=2
 .br
 
 .br
@@ -496,7 +650,9 @@
 .br
 Example
 .br
-filter@rtpininterleave=yes
+filter@rtpin
+.br
+interleave=yes
 .br
 
 .br
@@ -541,7 +697,7 @@
 .br
   
 .br
-For both syntax, it is possible to specify the filter registry name of the option, using --FNAME:OPTNAME=VAL or --FNAME@OPTNAME=VAL.
+For both syntaxes, it is possible to specify the filter registry name of the option, using --FNAME:OPTNAME=VAL or --FNAME@OPTNAME=VAL.
 .br
 In this case the option will only be set for filters which are instances of registry FNAME. This is used when several registries use same option names.
 .br
@@ -664,6 +820,31 @@
 dump unhandled promise rejections
 .br
 .TP
+.B \-startup-file (string)
+.br
+startup file of compositor in GUI mode
+.br
+.TP
+.B \-docs-dir (string)
+.br
+default documents directoty (for GUI on iOS and Android)
+.br
+.TP
+.B \-last-dir (string)
+.br
+last working directory (for GUI)
+.br
+.TP
+.B \-no-poll
+.br
+disable poll and use select for socket groups
+.br
+.TP
+.B \-no-tls-rcfg
+.br
+disble automatic TCP to TLS reconfiguration
+.br
+.TP
 .B \-cache (string)
 .br
 cache directory location
@@ -709,14 +890,14 @@
 specify cache size in bytes
 .br
 .TP
-.B \-head-timeout (int, default: 5000)
+.B \-tcp-timeout (int, default: 5000)
 .br
-set HTTP head request timeout in milliseconds
+time in milliseconds to wait for HTTP/RTSP connect before error
 .br
 .TP
-.B \-req-timeout (int, default: 20000)
+.B \-req-timeout (int, default: 10000)
 .br
-set HTTP/RTSP request timeout in milliseconds
+time in milliseconds to wait on HTTP/RTSP request before error
 .br
 .TP
 .B \-no-timeout
@@ -759,6 +940,11 @@
 set window analysis length in milliseconds for chunk-transfer encoding rate estimation
 .br
 .TP
+.B \-cred (string)
+.br
+path to 128 bits key for credential storage
+.br
+.TP
 .B \-no-h2
 .br
 disable HTTP2
@@ -860,6 +1046,21 @@
 disable memory recycling for packets and properties. This uses much less memory but stresses the system memory allocator much more
 .br
 .TP
+.B \-buffer-gen (int, default: 1000)
+.br
+default buffer size in microseconds for generic pids
+.br
+.TP
+.B \-buffer-dec (int, default: 1000000)
+.br
+default buffer size in microseconds for decoder input pids
+.br
+.TP
+.B \-buffer-units (int, default: 1)
+.br
+default buffer size in frames when timing is not available
+.br
+.TP
 .B \-switch-vres
 .br
 select smallest video resolution larger than scene size, otherwise use current video resolution
@@ -923,7 +1124,17 @@
 .TP
 .B \-video-output (string)
 .br
-indicate the name of the video output module to use (see gpac -h modules). The reserved name glfbo is used in player mode to draw in the OpenGL texture identified by .I glfbo-txid.  In this mode, the application is responsible for sending event to the terminal
+indicate the name of the video output module to use (see gpac -h modules). The reserved name glfbo is used in player mode to draw in the OpenGL texture identified by .I glfbo-txid.  In this mode, the application is responsible for sending event to the compositor
+.br
+.TP
+.B \-dfb-sys (string, default: x11)
+.br
+system DirectFB (x11, sdl, vnc, fbdev, osx ordevmem)
+.br
+.TP
+.B \-dfb-flip (string, default: waitsync)
+.br
+vsync mode for DirectFB (waitsync, wait, sync or swap)
 .br
 .TP
 .B \-audio-output (string)
@@ -971,6 +1182,19 @@
 force writing hour when serializing WebVTT
 .br
 .TP
+.B \-charset (string)
+.br
+set charset when not recognized from input. Possible values are:
+.br
+* utf8: force UTF-8
+.br
+* utf16: force UTF-16 little endian
+.br
+* utf16be: force UTF-16 big endian
+.br
+* other: attempt to parse anyway
+.br
+.TP
 .B \-rmt
 .br
 enable profiling through Remotery. A copy of Remotery visualizer is in gpac/share/vis, usually installed in /usr/share/gpac/vis or Program Files/GPAC/vis
@@ -1030,6 +1254,11 @@
 .br
 hack for old vvdec+libavcodec supporting only annexB format
 .br
+.TP
+.B \-heif-hevc-urn
+.br
+use HEVC URN for alpha and depth in HEIF instead of MPEG-B URN (HEIF first edition)
+.br
 .SH libgpac logs options:
 .LP
 .br
@@ -1158,7 +1387,7 @@
 .br
 use new line at each progress messages
 .br
-.SH General
+.SH Overview
 .LP
 .br
 Filters are configurable processing units consuming and producing data packets. These packets are carried between filters through a data channel called PID. A PID is in charge of allocating/tracking data packets, and passing the packets to the destination filter(s). A filter output PID may be connected to zero or more filters. This fan-out is handled internally by GPAC (no such thing as a tee filter in GPAC).
@@ -1188,6 +1417,8 @@
 .br
 * N-dimension (vectors): formatted as DIM1xDIM2xDIM3xDIM4 values, without unit multiplier.
 .br
+  * For 2D integer vectors, the following resolution names can be used: 360, 480, 576, 720, 1080, hd, 2k, 2160, 4k, 4320, 8k
+.br
 * string: formatted as:
 .br
   * `value`: copies value to string.
@@ -1434,7 +1665,7 @@
 .br
 - if DST filter has link directives, use them to allow or reject PID connection.
 .br
-- otherwise, if complete mode is enabled, allow connection.
+- otherwise, if complete mode is enabled, allow connection..
 .br
 - otherwise (implicit mode):
 .br
@@ -1446,6 +1677,12 @@
 .br
 
 .br
+In all linking modes, a filter can prevent being linked to a filter with no link directives by setting RSID option on the filter.
+.br
+This is typically needed when dynamically inserting/removing filters in an existing session where some filters have no ID defined and are not desired for the inserted chain.
+.br
+
+.br
 Example
 .br
 gpac -i file.mp4 c=avc -o output
@@ -1880,6 +2117,8 @@
 .br
 * pname=VAL: uses PID property with name VAL
 .br
+* cts, dts, dur, sap: uses properties of first packet in PID at template resolution time
+.br
 * OTHER: locates property 4CC for the given name, or property name if no 4CC matches.
 .br
   
@@ -2080,7 +2319,9 @@
 .br
 An option file is a simple text file containing one or more options or PID properties on one or more lines.
 .br
-A line beginning with "//" is a comment and is ignored.
+- A line beginning with "//" is a comment and is ignored (not configurable).
+.br
+- A line beginning with ":" indicates an escaped option (the entire line is parsed as a single option).
 .br
 Options in an option file may point to other option files, with a maximum redirection level of 5.
 .br
@@ -2107,6 +2348,14 @@
 .br
 * $GJS: replaced by the first path from global share directory and paths set through .I -js-dirs that contains the file name following the macro, e.g. $GJS/source.js
 .br
+* $GDOCS: replaced by system path to:
+.br
+  - application document directory for iOS
+.br
+  - EXTERNAL_STORAGE environment variable if present or /sdcard otherwise for Android
+.br
+  - user home directory for other platforms
+.br
 * $GLANG: replaced by the global config language option .I -lang
 .br
 * $GUA: replaced by the global config user agent option .I -user-agent
@@ -2131,25 +2380,61 @@
 .br
 * FID: filter identifier
 .br
-* SID: filter source(s)
+* SID: filter source(s) (string value)
+.br
+* N=NAME: filter name (string value)
+.br
+* FS: sub-session identifier (unsigned int value)
+.br
+* RSID: require sourceID to be present on target filters (no value)
 .br
-* N: filter name
+* TAG: filter tag (string value)
 .br
-* FS: sub-session identifier
+* FBT: buffer time in microseconds (unsigned int value)
 .br
-* TAG: filter tag
+* FBU: buffer units (unsigned int value)
 .br
-* clone: filter cloning flag
+* FBD: decode buffer time in microseconds (unsigned int value)
 .br
-* nomux: enable/disable direct file copy
+* clone: filter cloning flag (no value)
 .br
-* gfreg: preferred filter registry names for link solving
+* nomux: enable/disable direct file copy (no value)
 .br
-* gfloc: following options are local to filter declaration (not inherited)
+* gfreg: preferred filter registry names for link solving (string value)
 .br
-* gfopt: following options are not tracked
+* gfloc: following options are local to filter declaration, not inherited (no value)
 .br
-* gpac: argument separator for URLs
+* gfopt: following options are not tracked (no value)
+.br
+* gpac: argument separator for URLs (no value)
+.br
+
+.br
+The buffer control options are used to change the default buffering of PIDs of a filter:
+.br
+- FBT controls the maximum buffer time of output PIDs of a filter
+.br
+- FBU controls the maximum number of packets in buffer of output PIDs of a filter when timing is not available
+.br
+- FBD controls the maximum buffer time of input PIDs of a decoder filter, ignored for other filters
+.br
+
+.br
+If another filter sends a buffer requirement messages, the maximum value of FBT (resp. FBD) and the user requested buffer time will be used for output buffer time (resp. decoding buffer time).
+.br
+
+.br
+These options can be set:
+.br
+* per filter instance: fA reframer:FBU=2
+.br
+* per filter class for the run: --reframer@FBU=2
+.br
+* in the GPAC config file in a per-filter section: filter@reframerFBU=2
+.br
+
+.br
+The default values are defined by the session default parameters -buffer-gen, buffer-units and -buffer-dec.
 .br
 
 .br
@@ -2452,7 +2737,7 @@
 .TP
 .B Duration (PDUR,lfrac,  )
 .br
-Media duration
+Media duration (a negative value means an estimated duration based on rate)
 .br
 .TP
 .B NumFrames (NFRM,uint,D )
@@ -2637,12 +2922,22 @@
 .TP
 .B TransX (VTRX,sint,  )
 .br
-Horizontal translation of the video
+Horizontal translation of the video (positive towards right)
 .br
 .TP
 .B TransY (VTRY,sint,  )
 .br
-Vertical translation of the video
+Vertical translation of the video (positive towards up)
+.br
+.TP
+.B TransXRight (VTRx,sint,  )
+.br
+Horizontal offset of the video from right (positive towards right), for cases where reference width is unknown
+.br
+.TP
+.B TransYTop (VTRy,sint,  )
+.br
+Vertical translation of the video (0 is top, positive towards down), for cases where reference height is unknown
 .br
 .TP
 .B Hidden (HIDE,bool,  )
@@ -2652,7 +2947,7 @@
 .TP
 .B CropOrigin (VCXY,v2di,  )
 .br
-Position in source window, X,Y indicates coord in source
+Position in source window, X,Y indicate coordinates in source (0,0 for top-left)
 .br
 .TP
 .B OriginalSize (VOWH,v2di,  )
@@ -2686,7 +2981,7 @@
 .TP
 .B Mirror (VMIR,uint,  )
 .br
-Mirror mode (0: no mirror, 1: along Y-axis, 2: along X-axis)
+Mirror mode (as bit mask with flags 0: no mirror, 1: along Y-axis, 2: along X-axis)
 .br
 .TP
 .B Rotate (VROT,uint,  )
@@ -2844,16 +3139,6 @@
 Repeat rate in ms for systems carousel data
 .br
 .TP
-.B UTC (UTCD,luint,D )
-.br
-UTC date and time of PID
-.br
-.TP
-.B UTCTimestamp (UTCT,luint,D )
-.br
-Timestamp corresponding to UTC date and time
-.br
-.TP
 .B AudioVolume (AVOL,uint,D )
 .br
 Volume of audio
@@ -2936,12 +3221,17 @@
 .TP
 .B SenderNTP (NTPS,luint,DP)
 .br
-NTP time at sender side or grabber side
+NTP 64 bits timestamp at sender side or grabber side
 .br
 .TP
 .B ReceiverNTP (NTPR,luint,DP)
 .br
-Receiver NTP time (usually associated with the sender NTP property)
+Receiver NTP (64 bits timestamp) usually associated with the sender NTP property
+.br
+.TP
+.B UTC (UTCD,luint,DP)
+.br
+UTC timestamp (in milliseconds) of parent packet
 .br
 .TP
 .B Encrypted (EPCK,bool,  )
@@ -3057,6 +3347,11 @@
 Set on packets marking the beginning of a DASH/HLS segment for cue-driven segmentation - see dasher help
 .br
 .TP
+.B MediaTime (MTIM,dbl,D )
+.br
+Corresponding media time of the parent packet (0 being the origin)
+.br
+.TP
 .B MaxFrameSize (MFRS,uint,D )
 .br
 Max size of frame in stream - changes are signaled through PID info change (no reconfigure)
@@ -3167,6 +3462,11 @@
 DASH mode to be used by multiplexer if any, set by dasher. 0 is no DASH, 1 is regular DASH, 2 is VoD
 .br
 .TP
+.B SegSync (DFSS,bool,D )
+.br
+Indicate segment must be completely flushed before sending segment/fragment size events
+.br
+.TP
 .B DashDur (DDUR,frac,D )
 .br
 DASH target segment duration in seconds
@@ -3307,6 +3607,11 @@
 Init Vector for HLS decode
 .br
 .TP
+.B CKUrl (CCKU,str,  )
+.br
+URL for ClearKey licence server
+.br
+.TP
 .B ColorPrimaries (CPRM,cprm,D )
 .br
 Color primaries
@@ -3347,6 +3652,11 @@
 Master display colour info, payload of mdcv box (see ISO/IEC 14496-12), can be set as a list of 10 integers in fragment declaration (e.g. "=dpx0,dpy0,dpx1,dpy1,dpx2,dpy2,wpx,wpy,max,min")
 .br
 .TP
+.B ICC (ICCP,mem,D )
+.br
+ICC profile (see ISO 15076-1 or ICC.1)
+.br
+.TP
 .B SrcMagic (PSMG,luint,D )
 .br
 Magic number to store in the track, only used by importers
@@ -3392,9 +3702,9 @@
 Set to true if packet is a complete DASH init segment file
 .br
 .TP
-.B RawGrab (PGRB,bool,D )
+.B RawGrab (PGRB,uint,D )
 .br
-PID is a raw media grabber (webcam, microphone, etc...)
+PID is a raw media grabber (webcam, microphone, etc...). Value 2 is used for front camera
 .br
 .TP
 .B KeepAfterEOS (PKAE,bool,D )
@@ -3487,7 +3797,7 @@
 PID is a scene node decoder (AFX BitWrapper in BIFS)
 .br
 .TP
-.B OrigCryptoScheme (POCS,uint,  )
+.B OrigCryptoScheme (POCS,4cc,  )
 .br
 Original crypto scheme on a decrypted PID
 .br
@@ -3502,6 +3812,21 @@
 PID is a HAS manifest
 .br
 .TP
+.B Sparse (PSPA,bool,D )
+.br
+PID has potentially empty times between packets
+.br
+.TP
+.B ChapTimes (CHPT,uintl,D )
+.br
+Chapter start times
+.br
+.TP
+.B ChapNames (CHPN,strl,D )
+.br
+Chapter names
+.br
+.TP
 .B SkipBegin (PCKS,uint, P)
 .br
 Amount of media to skip from beginning of packet in PID timescale
@@ -3632,7 +3957,7 @@
 .TP
 .B nv21 (ext *.nv21)
 .br
-Semi-planar YUV 420 8 bit, Y plane and VU packed plane
+Semi-planar YVU 420 8 bit, Y plane and VU packed plane
 .br
 .TP
 .B nv1l (ext *.nv1l)
@@ -3642,7 +3967,7 @@
 .TP
 .B nv2l (ext *.nv2l)
 .br
-Semi-planar YUV 420 8 bit, Y plane and VU plane
+Semi-planar YVU 420 8 bit, Y plane and VU plane
 .br
 .TP
 .B yuva (ext *.yuva)
@@ -3665,14 +3990,29 @@
 Packed YUV 444 8 bit
 .br
 .TP
+.B v308 (ext *.v308)
+.br
+Packed VYU 444 8 bit
+.br
+.TP
 .B yuv444ap (ext *.y4ap)
 .br
 Packed YUV+alpha 444 8 bit
 .br
 .TP
-.B yuv444p_10 (ext *.y4lp)
+.B v408 (ext *.v408)
+.br
+Packed UYV+alpha 444 8 bit
+.br
+.TP
+.B v410 (ext *.v410)
 .br
-Packed YUV 444 10 bit
+Packed UYV 444 10 bit LE
+.br
+.TP
+.B v210 (ext *.v210)
+.br
+Packed UYVY 422 10 bit LE
 .br
 .TP
 .B grey (ext *.grey)
@@ -3765,25 +4105,16 @@
 RGB+depth+bit shape (8 bits / RGB component, 7 bit depth (low bits) + 1 bit shape)
 .br
 .TP
-.B rgbs (ext *.rgbs)
-.br
-RGB 24 bits stereo (side-by-side) - to be removed
-.br
-
-.br
-.TP
-.B rgbas (ext *.rgbas)
+.B extgl (ext *.extgl)
 .br
-RGBA 32 bits stereo (side-by-side) - to be removed
+External OpenGL texture of unknown format, to be used with samplerExternalOES
 .br
 
 .br
 .TP
-.B extgl (ext *.extgl)
+.B uncv (ext *.uncv)
 .br
-External OpenGL texture of unknown format, to be used with samplerExternalOES
-.br
-
+Generic uncompressed format ISO/IEC 23001-17
 .br
 .SH Audio formats
 .LP
@@ -4275,6 +4606,11 @@
 Subtitle/text 3GPP/Apple Stream
 .br
 .TP
+.B ssa
+.br
+SSA /ASS Subtitles
+.br
+.TP
 .B theo|theora
 .br
 Theora Video
@@ -4470,14 +4806,29 @@
 xHEAAC / USAC Audio
 .br
 .TP
-.B v210
+.B ffv1
 .br
-v210 YUV 422 10 bits
+FFMPEG Video Codec 1
 .br
 .TP
-.B ffv1
+.B dvbs
 .br
-FFMPEG Video Codec 1
+DVB Subtitles
+.br
+.TP
+.B dvbs
+.br
+DVB-TeleText
+.br
+.TP
+.B div3
+.br
+MS-MPEG4 V3
+.br
+.TP
+.B caf
+.br
+Apple Lossless Audio
 .br
 .SH Stream types
 .LP
@@ -4591,10 +4942,10 @@
 .br
 For bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac
 .br
-build: 1.1.0-DEV-rev1777-gb91a8dad3-master
+build: 2.2-rev655-g65430e305-master
 .br
 Copyright: (c) 2000-2022 Telecom Paris distributed under LGPL v2.1+ - http://gpac.io
 .br
 .SH SEE ALSO
 .LP
-gpac-filters(1), MP4Client(1), MP4Box(1)
+gpac-filters(1),MP4Box(1)

gpac-2.0.0.tar.gz/share/doc/man/mp4box.1 -> gpac-2.2.0.tar.gz/share/doc/man/mp4box.1 Changed

@@ -28,9 +28,23 @@
 .br
 
 .br
+Track identifier for track-based operations (usually referred to as tkID in the help) use the following syntax:
+.br
+* INT: target is track with ID INT
+.br
+* n`INT`: target is track number INT
+.br
+* `audio`, `video`, `text`: target is first audio, video or text track
+.br
+* `audioN`, `videoN`, `textN`: target is the Nth audio, video or text track, with N=1 being the first track of desired type
+.br
+ 
+.br
 Option values:
 .br
-Unless specified otherwise, an option of type integer expects a trackID value following it.An option of type boolean expects no following value.Note: Track operations identify tracks through their ID (usually referred to as tkID in the help), not their order.
+Unless specified otherwise, a track operation option of type integer expects a track identifer value following it.
+.br
+An option of type boolean expects no following value.
 .br
 
 .br
@@ -173,12 +187,12 @@
 set chapter information from given file, using QT signaling for text tracks
 .br
 .TP
-.B \-set-track-id id1:id2
+.B \-set-track-id tkID:id2
 .br
-change id of track with id1 to id2
+change id of track to id2
 .br
 .TP
-.B \-swap-track-id id1:id2
+.B \-swap-track-id tkID1:tkID1
 .br
 swap the id between tracks with id1 to id2
 .br
@@ -269,7 +283,7 @@
 set track handler name to NAME (UTF-8 string)
 .br
 .TP
-.B \-itags (string)
+.B \-tags,-itags (string)
 .br
 set iTunes tags to file, see -h tags
 .br
@@ -278,13 +292,13 @@
 .br
 create a new grouping information in the file. Format is a colon-separated list of following options:
 .br
-* refTrack=ID: ID of the track used as a group reference. If not set, the track will belong to the same group as the previous trackID specified. If 0 or no previous track specified, a new alternate group will be created
+* refTrack=ID: track used as a group reference. If not set, the track will belong to the same group as the previous trackID specified. If 0 or no previous track specified, a new alternate group will be created
 .br
 * switchID=ID: ID of the switch group to create. If 0, a new ID will be computed for you. If <0, disables SwitchGroup
 .br
 * criteria=string: list of space-separated 4CCs
 .br
-* trackID=ID: ID of the track to add to this group
+* trackID=ID: track to add to this group
 .br
 
 .br
@@ -308,7 +322,7 @@
 remove all group information from all tracks
 .br
 .TP
-.B \-ref id:XXXX:refID
+.B \-ref tkID:XXXX:refID
 .br
 add a reference of type 4CC from track ID to track refID
 .br
@@ -488,7 +502,11 @@
 .TP
 .B \-mpd (string)
 .br
-convert given HLS or smooth manifest (local or remote http) to MPD. 
+convert given HLS or smooth manifest (local or remote http) to MPD - options -url-template and -segment-timelinecan be used in this mode. 
+.br
+Note: This only provides basic conversion, for more advanced conversions, see gpac -h dasher
+.br
+ 
 .br
 Warning: This is not compatible with other DASH options and does not convert associated segments
 .br
@@ -534,7 +552,7 @@
 .br
 * :xlink=VALUE: set the xlink value for the period containing this element. Only the xlink declared on the first rep of a period will be used
 .br
-* :asID=VALUE: set the AdaptationSet ID to NAME
+* :asID=VALUE: set the AdaptationSet ID to VALUE (unsigned int)
 .br
 * :role=VALUE: set the role of this representation (cf DASH spec). Media with different roles belong to different adaptation sets.
 .br
@@ -776,6 +794,8 @@
 .br
 * mf, fm: in movie fragments and MPD
 .br
+* n: remove PSSH from MPD, initial movie and movie fragments
+.br
 .TP
 .B \-sample-groups-traf
 .br
@@ -969,7 +989,7 @@
 .br
 * `S-E`: S start and E end times, formatted as HH:MM:SS.ms, MM:SS.ms or time in seconds (int, double, fraction)
 .br
-* `S:E`: S start time and E end times in seconds (int, double, fraction)
+* `S:E`: S start time and E end times in seconds (int, double, fraction). If E is prefixed with D, this sets E = S + time
 .br
 * `S:end` or `S:end-N`: S start time in seconds (int, double), N number of seconds (int, double) before the end
 .br
@@ -997,6 +1017,8 @@
 .br
 The output file name(s) can be specified using -out and templates (e.g. -out split$num%04d$.mp4 produces split0001.mp4, split0002.mp4, ...).
 .br
+Multiple time ranges can be specified as a comma-seperated list for -splitx, -splitz and -splitg.
+.br
 
 .br
 .TP
@@ -1516,7 +1538,7 @@
 .TP
 .B fps (string)
 .br
-same as .I fps
+S same as .I fps
 .br
 .TP
 .B rap
@@ -1800,6 +1822,17 @@
 keep AV1 temporal delimiter OBU in samples, might help if source file had losses
 .br
 .TP
+.B dlba (string)
+.br
+S force DolbyAtmos mode for EAC3. Value can be
+.br
+* no: disable Atmos signaling
+.br
+* auto: use Atmos signaling from first sample
+.br
+* N: force Atmos signaling using complexibility type index N
+.br
+.TP
 .B font (string)
 .br
 specify font name for text import (default Serif)
@@ -1903,9 +1936,9 @@
 .TP
 .B colr (string)
 .br
-S set color profile for imported video content (see ISO/IEC 23001-8). Value is formatted as:
+S set color profile for imported video content. Value is formatted as:
 .br
- * nclc,p,t,m: with p colour primary (int or string), t transfer characteristics (int or string) and m matrix coef (int or string)
+ * nclc,p,t,m: with p colour primary (int or string), t transfer characteristics (int or string) and m matrix coef (int or string), cf -h cicp
 .br
 * nclx,p,t,m,r: same as nclx with r full range flag (yes, on or no, off)
 .br
@@ -1921,7 +1954,7 @@
 S set HDR info on track (see .I -hdr ), 'none' removes HDR info
 .br
 .TP
-.B dv-profile (string)
+.B dvp,-dv-profile (string)
 .br
 S set the Dolby Vision profile on imported track
 .br
@@ -2116,7 +2149,7 @@
 .br
 force frame rate for video and SUB subtitles import to the given value, expressed as a number, as TS-inc or TS/inc. 
 .br
-Note: For raw H263 import, default FPS is 15, otherwise 25. This is ignored for ISOBMFF import, use :rescale option for that
+Note: For raw H263 import, default FPS is 15, otherwise 25. This is accepted for ISOBMFF import but :rescale option should be preferred
 .br
 .TP
 .B \-mpeg4
@@ -2614,7 +2647,59 @@
 .br
 
 .br
-Supported tag names, values, types, aliases:
+.SS QT metadata key
+.br
+The tag is added as a QT metadata key if:
+.br
+- tag_name starts with QT/
+.br
+- or tag_name is not recognized and longer than 4 characters
+.br
+ 
+.br
+The tag_name can optionnally be prefixed with HDLR@, indicating the tag namespace 4CC, the default namespace being mdta.
+.br
+The tag_value can be prefixed with:
+.br
+* S: force string encoding (must be placed first) instead of parsing the tag value
+.br
+* b: use 8-bit encoding for signed or unsigned int
+.br
+* s: use 16-bit encoding for signed or unsigned int
+.br
+* l: use 32-bit encoding for signed or unsigned int
+.br
+* L: use 64-bit encoding for signed or unsigned int
+.br
+* f: force float encoding for numbers
+.br
+Numbers are converted by default and stored in variable-size mode.
+.br
+To force a positive integer to use signed storage, add + in front of the number.
+.br
+Example
+.br
+-tags io.gpac.some_tag=s+32
+.br
+
+.br
+This will force storing value 32 in signed 16 bit format.
+.br
+The tag_value can also be formatted as:
+.br
+* XxY@WxH: a rectangle type
+.br
+* XxY: a point type
+.br
+* W@H: a size type
+.br
+* A,B,C,D,E,F,G,H,I: a 3x3 matrix
+.br
+* FNAME: data is loaded from FNAME, type set to jpeg or png if needed
+.br
+ 
+.br
+.SS Supported tag names (name, value, type, aliases)
 .br
 title (A9nam) string (alias name)
 .br
@@ -2742,6 +2827,10 @@
 .br
 exec_producer (A9xpd) string
 .br
+genre (A9gen) string (ID3 genre tag)
+.br
+location (A9xyz) string
+.br
 .SH Live Scene Encoder Options
 .LP
 .br
@@ -2835,10 +2924,10 @@
 .br
 For bug reports, feature requests, more information and source code, visit https://github.com/gpac/gpac
 .br
-build: 1.1.0-DEV-rev1777-gb91a8dad3-master
+build: 2.2-rev655-g65430e305-master
 .br
 Copyright: (c) 2000-2022 Telecom Paris distributed under LGPL v2.1+ - http://gpac.io
 .br
 .SH SEE ALSO
 .LP
-gpac(1), MP4Client(1)
+gpac(1)

gpac-2.0.0.tar.gz/share/gpac.desktop -> gpac-2.2.0.tar.gz/share/gpac.desktop Changed

gpac-2.0.0.tar.gz/share/gui/extensions/about/info.js -> gpac-2.2.0.tar.gz/share/gui/extensions/about/info.js Changed

gpac-2.2.0.tar.gz/share/gui/extensions/dashif Added

gpac-2.2.0.tar.gz/share/gui/extensions/dashif/dashif.svg Added

gpac-2.2.0.tar.gz/share/gui/extensions/dashif/dashif_tests.js Added

@@ -0,0 +1,367 @@
+extension = {
+filter_event : function(evt) {
+	switch (evt.type) {
+	case GF_JS_EVENT_PLAYBACK:
+		this.set_option('SequenceIndex', ''+ evt.index);
+		return false;
+	default:
+		return false;
+	}
+},
+
+create_event_filter : function (__anobj) {
+	return function (evt) {
+		return __anobj.filter_event(evt);
+	}
+},
+
+_event_filter : null,
+
+start: function () {
+	if (!this._event_filter) {
+		this._event_filter = this.create_event_filter(this);
+		gwlib_add_event_filter(this._event_filter);
+	}
+	var e = {};
+	e.type = GF_JS_EVENT_PLAYLIST_RESET;
+	gwlib_filter_event(e);
+
+	e.type = GF_JS_EVENT_PLAYLIST_ADD;
+	for (var i=0; i<this.sequences.length; i++) {
+		e.url = this.sequencesi;
+		gwlib_filter_event(e);
+	}
+	
+	var sequence_index = parseInt( this.get_option('SequenceIndex', '0') );
+	if (sequence_index >= this.sequences.length) sequence_index = 0;
+	else if (sequence_index < 0) sequence_index = 0;
+	
+	var msg = gw_new_message(null, 'DASH-IF Playlist Loaded', '');
+	msg.set_size(20 * gwskin.default_text_font_size, gwskin.default_icon_height + gwskin.default_text_font_size);
+	msg.set_alpha(0.8);
+	msg.show();
+
+	e.type = GF_JS_EVENT_PLAYLIST_PLAY;
+	e.index = sequence_index;
+	gwlib_filter_event(e);
+},
+
+sequences : 
+"https://dash.akamaized.net/dash264/TestCasesUHD/2b/11/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesUHD/2a/11/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/adapatationSetSwitching/5/manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/multiplePeriods/2/manifest_multiple_Periods_Add_Remove_AdaptationSet.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/multiplePeriods/1/manifest_multiple_Periods_Add_Remove_Representation.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/alternative_content/6/manifest_alternative_lang.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/alternative_content/4/manifest_alternative_Essentialproperty_live.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/alternative_content/1/manifest_alternative_content_live.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/alternative_content/3/manifest_alternative_maxWidth_live.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/alternative_content/2/manifest_alternative_content_ondemand.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/alternative_content/7/360_VR_BavarianAlpsWimbachklamm-AlternativeContent-with-ViewPoint.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/associative_content/1/manifest_associated_content_live.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/xHE-AAC_Stereo/2/Sintel/sintel_audio_video_brs.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/xHE-AAC_Stereo/1/Sintel/sintel_audio_only_brs.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/xHE-AAC_Stereo/3/Sintel/sintel_audio_only_64kbps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/CMAF/UnifiedStreaming/ToS_AVC_MultiRate_MultiRes_AAC_Eng_WebVTT.mpd",
+"https://dash.akamaized.net/dash264/TestCases/2c/qualcomm/1/MultiResMPEG2.mpd",
+"https://dash.akamaized.net/dash264/TestCases/2c/qualcomm/2/MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/2b/qualcomm/1/MultiResMPEG2.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/2b/qualcomm/2/MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/2b/DTV/1/live.mpd",
+"https://dash.akamaized.net/dash264/TestCases/2b/qualcomm/1/MultiResMPEG2.mpd",
+"https://dash.akamaized.net/dash264/TestCases/2b/qualcomm/2/MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/2c/qualcomm/1/MultiResMPEG2.mpd",
+"https://dash.akamaized.net/dash264/TestCases/2a/qualcomm/1/MultiResMPEG2.mpd",
+"https://dash.akamaized.net/dash264/TestCases/2a/qualcomm/2/MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/2a/qualcomm/1/MultiResMPEG2.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/2a/qualcomm/2/MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1b/qualcomm/1/MultiRatePatched.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1b/qualcomm/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1c/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1c/qualcomm/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1b/qualcomm/1_1/MultiRatePatched.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1a/netflix/exMPD_BIP_TC1.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1a/netflix/exMPD_BIP_TC1.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1a/sony/SNE_DASH_SD_CASE1A_REVISED.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1a/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/1a/qualcomm/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/CMAF/UnifiedStreaming/ToS_AVC_HEVC_MutliRate_MultiRes_IFrame_AAC.m3u8",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/CMAF/UnifiedStreaming/ToS_Playready_AVC_HEVC_MultiRate_MultiRes_IFrame_AAC.m3u8",
+"https://akamai-axtest.akamaized.net/routes/lapd-v1-acceptance/www_c4/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v8-MultiContent/Clear/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_AudioOnly_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_1080p_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_AudioOnly_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_1080p_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_AudioOnly_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p_ClearKey.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/WSSReporting-OK-MultiRes.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/HTTPSReporting-Conf-OK-MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesNegative/2/1.mpd",
+"https://dash.akamaized.net/dash264/TestCasesNegative/2/2.mpd",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Clear/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Clear/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cbcs/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cenc/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cenc/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cbcs/Manifest_1080p.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/multiplePeriods/4/manifest_multiple_Periods_Different_SegmentDuration.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dolby/6/DashIf-HDR10_UHD.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dolby/6/DashIf-SDR_UHD.mpd",
+"http://54.72.87.160/stattodyn/statodyn.php?type=mpd&pt=1376172180&tsbd=120&origmpd=https%3A%2F%2Fdash.akamaized.net%2Fdash264%2FTestCases%2F1b%2Fqualcomm%2F2%2FMultiRate.mpd&php=http%3A%2F%2Fdasher.eu5.org%2Fstatodyn.php&mpd=&debug=0&hack=.mpd",
+"http://54.72.87.160/stattodyn/statodyn.php?type=mpd&pt=1376172390&tsbd=120&origmpd=http%3A%2F%2Fdash.akamaized.net%2Fdash264%2FTestCases%2F1b%2Fqualcomm%2F2%2FMultiRate.mpd&php=http%3A%2F%2Fdasher.eu5.org%2Fstatodyn.php&mpd=&debug=0&hack=.mpd",
+"http://54.72.87.160/stattodyn/statodyn.php?type=mpd&pt=1376172485&tsbd=10&origmpd=http%3A%2F%2Fdash.akamaized.net%2Fdash264%2FTestCases%2F1b%2Fqualcomm%2F1%2FMultiRatePatched.mpd&php=http%3A%2F%2Fdasher.eu5.org%2Fstatodyn.php&mpd=&debug=0&hack=.mpd",
+"https://dash.akamaized.net/dash264/TestCasesNegative/1/1.mpd",
+"https://dash.akamaized.net/dash264/TestCasesNegative/1/2.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/MPDChaining/fallback_chain/1/manifest_fallback_MPDChaining.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/MPDChaining/fallback_chain/2/manifest_terminationEvent_fallback_MPDChaining.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2b/15/tos_live_multires_10bit_hev.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2b/17/bbb_live_multires_10bit_hev.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2a/12/tos_ondemand_multires_10bit_hev.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1a/5/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1b/5/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHDR/3b/3/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHDR/3a/3/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2b/16/tos_live_multires_10bit_hvc.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2b/18/bbb_live_multires_10bit_hvc.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2a/13/tos_ondemand_multires_10bit_hvc.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2b/14/tos_live_multires_hvc.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2a/11/tos_ondemand_multires_hvc.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1b/10/tos_live_multirate_hvc.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1a/9/tos_ondemand_multirate_hvc.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/CMAF/UnifiedStreaming/ToS_HEVC_MultiRate_MultiRes_IFrame_AAC_WebVTT.m3u8",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/CMAF/UnifiedStreaming/ToS_HEVC_MultiRate_MultiRes_AAC_Eng_TTML.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/CMAF/UnifiedStreaming/ToS_HEVC_MultiRate_MultiRes_AAC_Eng_WebVTT.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2b/1/TOS_Live_HEVC_MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2b/2/BBB_Live_HEVC_MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2a/1/TOS_OnDemand_HEVC_MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/2a/2/BBB_OnDemand_HEVC_MultiRes.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1b/1/TOS_Live_HEVC_MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1b/2/BBB_Live_HEVC_MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1a/1/TOS_OnDemand_HEVC_MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHEVC/1a/2/BBB_OnDemand_HEVC_MultiRate.mpd",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Clear/Manifest_1080p.m3u8",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Clear/Manifest.m3u8",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cbcs/Manifest_1080p.m3u8",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cbcs/Manifest.m3u8",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cenc/Manifest_1080p.m3u8",
+"https://media.axprod.net/TestVectors/v9-MultiFormat/Encrypted_Cenc/Manifest.m3u8",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/HTTPHeader-OK-MultiRes.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/HTTP-OK-MultiRes.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/HTTPS-OK-MultiRes.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/HTTPSQuery-OK-MultiRes.mpd",
+"https://dash.akamaized.net/dash264/CTA/imsc1/IT1-20171027_dash.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/LastSegmentNumber/1/manifest_last_segment_num.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/xlink_30/insertad_2/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/xlink_30/insertad_4/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/start_1800/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/xlink_30/insertad_5/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/scte35_2/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/mup_300/tsbd_500/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/baseurl_d40_u20/baseurl_u40_d20/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/baseurl_u10_d20/baseurl_d10_u20/periods_10/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/periods_20/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/continuous_1/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/etp_30/etpDuration_10/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/etp_30/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_0/peroff_1/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_2/peroff_1/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/scte35_2/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_1/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/segtimeline_1/testpic_6s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/segtimeline_1/testpic_6s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_1/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/modulo_10/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/utc_direct-head/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/utc_ntp/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/utc_sntp/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim-dev/periods_60/xlink_30/insertad_3/testpic_2s/Manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCasesUHD/2b/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesUHD/2b/3/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesUHD/2b/4/MultiRate.mpd",
+"https://akamai-axtest.akamaized.net/routes/lapd-v1-acceptance/www_c4/Manifest.m3u8",
+"https://livesim.dashif.org/livesim-dev/periods_60/xlink_30/insertad_1/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/chunkdur_1/ato_7/testpic4_8s/Manifest300.mpd",
+"https://livesim.dashif.org/livesim/chunkdur_1/ato_7/testpic4_8s/Manifest.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/HTTPSReporting-OK-MultiRes.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/WSSReporting-OK-MultiRes.mpd",
+"https://livesim.dashif.org/livesim/periods_60/mpdcallback_30/testpic_2s/Manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/MPEGH_Stereo_lc_mha1/1/Sintel/sintel_audio_video_mpegh_mha1_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dolby/1/1/ChID_voices_51_256_ddp.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/9/Living_Room_1080p_51_192k_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/11/Living_Room_1080p_51_192k_320k_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/10/Living_Room_1080p_51_192k_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/12/Living_Room_1080p_51_192k_320k_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/7/Living_Room_1080p_20_96k_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/8/Living_Room_1080p_20_96k_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/3/Living_Room_1080p_51_192k_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/5/Living_Room_1080p_51_192k_320k_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/4/Living_Room_1080p_51_192k_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/6/Living_Room_1080p_51_192k_320k_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/1/Living_Room_1080p_20_96k_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesDolby/2/Living_Room_1080p_20_96k_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dolby/4/1/ChID_voices_71_384_448_768_ddp.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dolby/2/1/ChID_voices_71_768_ddp.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dolby/3/1/ChID_voices_20_128_ddp.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/3/Paint_dtsc_testD.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/1/Paint_dtsc_testA.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/3/Paint_dtse_testD.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/1/Paint_dtse_testA.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/3/Paint_dtsh_testD.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/1/Paint_dtsh_testA.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/3/Paint_dtsl_testD.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/1/Paint_dtsl_testA.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/2/Paint_dtsc_testB.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/2/Paint_dtse_testB.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/dts/2/Paint_dtsl_testB.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/HE-AACv2_Multichannel/1/6chID/6chId_480p_single_adapt_heaac5_1_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/HE-AACv2_Multichannel/2/8chID/8ch_id_480p_single_adapt_heaac7_1_cf12_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/HE-AACv2_Multichannel/3/ElephantsDream_6ch/elephants_dream_480p_heaac5_1_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/HE-AACv2_Multichannel/3/Sintel_6ch/sintel_480p_heaac5_1_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/HE-AACv2_Multichannel/3/Sintel_8ch/sintel_480p_heaac7_1_cf12_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/MPEG_Surround/1/6chID/6chId_480p_single_adapt_mps5_1_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/MPEG_Surround/2/ElephantsDream_6ch/elephants_dream_480p_mps5_1_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/MPEG_Surround/2/Sintel_6ch/sintel_480p_mps5_1_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/MPEGH_51_lc_mha1/1/Sintel/sintel_audio_video_mpegh_mha1_5_1_brs_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/MPEGH_714_lc_mha1/1/Sintel/sintel_audio_video_mpegh_mha1_7_1_4_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesMCA/fraunhofer/MPEGH_Stereo_lc_mha1/1/Sintel/sintel_audio_video_mpegh_mha1_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/5_1b.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/4_1f.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/5_1f.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/5_1d.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/5_1c.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/5_1a.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/4_1d.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/4_1e.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/5_1e.mpd",
+"https://media.axprod.net/TestVectors/v7-Clear/Manifest_MultiPeriod_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-Clear/Manifest_MultiPeriod.mpd",
+"https://media.axprod.net/TestVectors/v7-Clear/Manifest_MultiPeriod_AudioOnly.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3b/sony/SNE_DASH_CASE3B_SD_REVISED.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3b/fraunhofer/aac-lc_stereo_with_video/ElephantsDream/elephants_dream_480p_aaclc_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3b/fraunhofer/aac-lc_stereo_with_video/Sintel/sintel_480p_aaclc_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3a/fraunhofer/aac-lc_stereo_without_video/ElephantsDream/elephants_dream_audio_only_aaclc_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3a/fraunhofer/aac-lc_stereo_without_video/Sintel/sintel_audio_only_aaclc_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3a/fraunhofer/heaac_stereo_without_video/ElephantsDream/elephants_dream_audio_only_heaac_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3a/fraunhofer/heaac_stereo_without_video/Sintel/sintel_audio_only_heaac_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3a/fraunhofer/heaacv2_stereo_without_video/ElephantsDream/elephants_dream_audio_only_heaacv2_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3a/fraunhofer/heaacv2_stereo_without_video/Sintel/sintel_audio_only_heaacv2_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3b/fraunhofer/heaac_stereo_with_video/ElephantsDream/elephants_dream_480p_heaac_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3b/fraunhofer/heaac_stereo_with_video/Sintel/sintel_480p_heaac_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3b/fraunhofer/heaacv2_stereo_with_video/ElephantsDream/elephants_dream_480p_heaacv2_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCases/3b/fraunhofer/heaacv2_stereo_with_video/Sintel/sintel_480p_heaacv2_stereo_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/multiplePeriods/3/manifest_multiple_Periods_Content_Offering_CDN.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/4_1b.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5a/nomor/1.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5a/nomor/3.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5a/nomor/5.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/3.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5a/nomor/4.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/1.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/2.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/6.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/7.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/10.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/11.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/4.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/5.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/8.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5b/nomor/9.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/4_1c.mpd",
+"https://dash.akamaized.net/dash264/TestCases/5c/nomor/4_1a.mpd",
+"https://dash.akamaized.net/dash264/TestCases/4b/qualcomm/2/TearsOfSteel_onDem5secSegSubTitles.mpd",
+"https://dash.akamaized.net/dash264/TestCases/4b/qualcomm/1/ED_OnDemand_5SecSeg_Subtitles.mpd",
+"https://dash.akamaized.net/dash264/TestCases/10a/1/iis_forest_short_poem_multi_lang_480p_single_adapt_aaclc_sidx.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/adapatationSetSwitching/4/manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/adapatationSetSwitching/2/manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCasesUHD/2a/5/MultiRate.mpd",
+"https://media.axprod.net/TestVectors/v8-MultiContent/Encrypted/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_AudioOnly.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_AudioOnly.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_AudioOnly.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_AudioOnly.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_AudioOnly.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_AudioOnly.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/adapatationSetSwitching/3/manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/adapatationSetSwitching/1/manifest.mpd",
+"https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd#t=posix:1465406946",
+"https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd#t=posix:now",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/MPDChaining/regular_chain/1/manifest_regular_MPDChaining_live.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/MPDChaining/regular_chain/2/manifest_regular_MPDChaining_OnDemand.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP33/resolveToZero/1/manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCases/4b/qualcomm/3/Solekai.mpd",
+"https://media.axprod.net/TestVectors/v7-Clear/Manifest_1080p.mpd",
+"https://media.axprod.net/TestVectors/v7-Clear/Manifest.mpd",
+"https://media.axprod.net/TestVectors/v7-Clear/Manifest_AudioOnly.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/1a/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/1a/qualcomm/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/1b/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/4c/1/dash.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/1b/qualcomm/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/1c/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/MultiPeriod_OnDemand/ThreePeriods/ThreePeriod_OnDemand2.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/MultiPeriod_OnDemand/ThreePeriods/ThreePeriod_OnDemand_presentationDur.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/MultiPeriod_OnDemand/ThreePeriods/ThreePeriod_OnDemand_presentationDur_AudioTrim.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/CMS/Axinom-CMS_AVC_MultiRes_MultiRate_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/CMS/Axinom-CMS_AVC_MultiRes_MultiRate_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/CMS/Axinom-CMS_HEVC_MultiRes_MultiRate_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/CMS/Axinom-CMS_HEVC_MultiRes_MultiRate_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/CMS/Axinom-CMS_MultiCodec_MultiRes_MultiRate_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/CMS/Axinom-CMS_MultiCodec_MultiRes_MultiRate_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/DRM/Axinom-DRM-in-disconnected-environments_AVC_MultiRes_MultiRate_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/DRM/Axinom-DRM-in-disconnected-environments_AVC_MultiRes_MultiRate_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/DRM/Axinom-DRM-in-disconnected-environments_HEVC_MultiRes_MultiRate_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/DRM/Axinom-DRM-in-disconnected-environments_HEVC_MultiRes_MultiRate_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/DRM/Axinom-DRM-in-disconnected-environments_MultiCodec_MultiRes_MultiRate_25fps.mpd",
+"https://dash.akamaized.net/dash264/TestAdvertising/DRM/Axinom-DRM-in-disconnected-environments_MultiCodec_MultiRes_MultiRate_2997fps.mpd",
+"https://dash.akamaized.net/dash264/TestCases/9b/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/9b/qualcomm/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/9c/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/9a/qualcomm/1/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCases/9a/qualcomm/2/MultiRate.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/MultiPeriod_OnDemand/TwoPeriods/TwoPeriod_OnDemand.mpd",
+"https://dash.akamaized.net/dash264/TestCasesHD/MultiPeriod_OnDemand/TwoPeriods/TwoPeriod_OnDemand_presentationDur.mpd",
+"https://dash.akamaized.net/dash264/TestCasesIOP41/MultiTrack/alternative_content/5/manifest_alternative_ToS_Viewpoint.mpd",
+"https://livesim.dashif.org/livesim/utc_direct/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/utc_head/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/utc_ntp/testpic_2s/Manifest.mpd",
+"https://livesim.dashif.org/livesim/utc_sntp/testpic_2s/Manifest.mpd",
+"https://dash.akamaized.net/dash264/TestCasesVP9/vp9-hd-adaptive/sintel-vp9-hd-adaptive.mpd",
+"https://dash.akamaized.net/dash264/TestCasesVP9/vp9-hd/sintel-vp9-hd.mpd",
+"https://dash.akamaized.net/dash264/TestCasesVP9/vp9-hd-hdr/sintel-vp9-hd-hdr.mpd",
+"https://dash.akamaized.net/dash264/TestCasesVP9/vp9-hd-encrypted/sintel-vp9-hd-encrypted.mpd",
+"https://dash.akamaized.net/dash264/TestCasesVP9/vp9-uhd/sintel-vp9-uhd.mpd",
+"https://dash.akamaized.net/dash264/TestCasesVP9/vp9-uhd-hdr/sintel-vp9-uhd-hdr.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_1080p_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey/Manifest_AudioOnly_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_1080p_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-MultiKey-MultiPeriod/Manifest_AudioOnly_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_ClearKey.mpd",
+"https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_AudioOnly_ClearKey.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/WS-OK-MultiRes.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/WSS-OK-MultiRes.mpd",
+"https://raw.githubusercontent.com/Dash-Industry-Forum/SAND-Test-Vectors/master/mpd/dash-if/WSSQuery-OK-MultiRes.mpd"
+
+
+};

gpac-2.2.0.tar.gz/share/gui/extensions/dashif/init.js Added

gpac-2.0.0.tar.gz/share/gui/extensions/player/fileopen.js -> gpac-2.2.0.tar.gz/share/gui/extensions/player/fileopen.js Changed

@@ -11,7 +11,12 @@
 
 filebrowse.on_display_size = function (width, height) {
 if (gwskin.mobile_device) {
- this.set_size(width, height);
+			dh = 0;
+			if (gwskin.display_cutout) {
+				dh = gwskin.default_control_height;
+			}
+ this.set_size(width, height-dh);
+ this.move(0, -dh/2);
 } else {
 var w = width / 2;
 if (w < 200) w = width - 20;
@@ -195,9 +200,12 @@
 }
 
 popup.on_display_size = function (w, h) {
- this.edit.set_size(w, 2 * gwskin.default_text_font_size);
- this.set_size(w, 2 * gwskin.default_text_font_size + gwskin.default_icon_height);
- this.move(0, h / 2 - this.height / 2);
+			let ed_h = 2 * gwskin.default_text_font_size;
+			if (gwskin.mobile_device) ed_h *= 1.5;
+ this.edit.set_size(w, ed_h);
+ this.set_size(w, ed_h + gwskin.default_icon_height);
+// this.move(0, h / 2 - this.height / 2);
+			this.move(0, 0);
 }
 
 popup.on_display_size(gw_display_width, gw_display_height);
@@ -208,6 +216,7 @@
 this.dlg.enable();
 }
 }
+ popup._init_focus = popup.edit.edit;
 popup.show();
 }

gpac-2.0.0.tar.gz/share/gui/extensions/player/init.js -> gpac-2.2.0.tar.gz/share/gui/extensions/player/init.js Changed

@@ -4,7 +4,7 @@
     name: "Player",
     icon: "applications-multimedia.svg",
     author: "JeanLF",
-    description: "Nice test extension",
+    description: "This extension provides media playback and control",
     url: "http://foo.bar",
     execjs: "player.js", "fileopen.js", "playlist.js", "stats.js",
     autostart: true,
@@ -14,11 +14,13 @@
     version_minor: 0,
     clopts: 
      {name: "-stat", type: "", description: "show GUI stats"},
-     {name: "-loop", type: "", description: "loop content"},
-     {name: "-speed", type: "number", description: "set speed content"},
-     {name: "-play-from", type: "number", description: "play from given time"},
+     {name: "-loop", type: "", description: "loop playback"},
+     {name: "-fs", type: "", description: "start in fullscreen"},
+     {name: "-speed", type: "number", description: "set playback speed"},
+     {name: "-start", type: "number", description: "play from given time in seconds"},
      {name: "-service", type: "int", description: "set initial service ID for multi-service sources"},
      {name: "-addon", type: "URL", description: "inject specified URL as addon of main content"},
+     {name: "-size", type: "string", description: "set window size as `WidthxHeight`"},
     ,
     clusage: "options URL options URL2",
 };

gpac-2.0.0.tar.gz/share/gui/extensions/player/player.js -> gpac-2.2.0.tar.gz/share/gui/extensions/player/player.js Changed

@@ -50,6 +50,9 @@
 	medialist_wnd: null,
 reverse_playback_supported: false,
 	view_stereo: 0,
+	orient_lock: 0,
+	init_w: 0,
+	init_h: 0,
 
 stats_wnd: null,
 stats_data: ,
@@ -74,7 +77,8 @@
 
 ext_filter_event: function (evt) {
 		if (this.disabled) return false;
-		
+		let items;
+
 switch (evt.type) {
 		case GF_EVENT_MOUSEUP:
 			if ((gwskin.last_hit_x == evt.mouse_x) && (gwskin.last_hit_y == evt.mouse_y)) {
@@ -94,6 +98,13 @@
 				this.stats_wnd.quality_changed();
 			}
 			return true;
+		case GF_EVENT_DBLCLICK:
+			if (gwskin.mobile_device && this.root_odm) {
+				let ori = this.orient_lock ? 0 : scene.orientation;
+				scene.orientation = ori;
+				this.orient_lock = !this.orient_lock;
+			}
+			return true;
 		case GF_EVENT_TIMESHIFT_UPDATE:
 			if (this.timeshift_depth) {
 				this.set_time(0);
@@ -119,8 +130,24 @@
 			}
 			return true;
 		case GF_EVENT_NAVIGATE:
-			this.set_movie_url(evt.target_url);
+ items = evt.url.split(',');
+ if (items.length==1) {
+ 			this.set_movie_url(evt.url);
+ this.set_playlist_mode(false);
+ } else {
+ this.playlist_load(items, true);
+ }
 			return true;
+ case GF_EVENT_DROPFILE:
+ items = evt.dropfiles;
+ if (items.length==1) {
+ this.set_movie_url(items0);
+ this.set_playlist_mode(false);
+ } else {
+ this.playlist_load(items, true);
+ }
+ return true;
+
 		case GF_EVENT_KEYDOWN:
 			//alert('key is '+evt.keycode + ' hw code is ' + evt.hwkey);
 			if (evt.keycode == 'F1') {
@@ -181,7 +208,6 @@
 
 this.movie.children0.on_scene_size = function (evt) {
 var ext = this.extension;
-
 if (!this.callback_done) {
 this.callback_done = true;
 
@@ -191,7 +217,13 @@
 scene.exit(1); 
 }
 
- var notif = gw_new_message(null, 'Error opening file!', 'Failed to open ' + this.url0 + '\n\nReason: ' + Sys.error_string(evt.error));
+ var url = this.url0;
+ if (url.startsWith('gpac://')) url = url.slice(7);
+ names = url.split('%2f');
+ if (names.length==1)
+						names = url.split('/');
+ url = namesnames.length-1;
+ var notif = gw_new_message(null, 'Error opening file!', 'Failed to open "' + url + '"\n\n' + Sys.error_string(evt.error));
 notif.show();
 
 var url = ext.movie.children0.url.length ? ext.movie.children0.url0 : '';
@@ -249,7 +281,6 @@
 } else {
 ext.local_url = false;
 }
-
 ext.root_odm = scene.get_object_manager(ext.current_url);
 ext.reverse_playback_supported = ext.root_odm.reverse_playback_supported;
 
@@ -292,8 +323,9 @@
 //force display size notif on controler to trigger resize of the window
 ext.controler.on_display_size(ext.controler.width, ext.controler.height);
 }
-
-// ext.root_odm = scene.get_object_manager(ext.current_url);
+ //when doing stop + play
+ if (!ext.root_odm)
+ ext.root_odm = scene.get_object_manager(ext.current_url);
 ext.set_state(ext.GF_STATE_PLAY);
 
 //override scene size info
@@ -304,6 +336,11 @@
 w = evt.width;
 h = evt.height;
 
+ if (this.extension.init_w && this.extension.init_h) {
+					w = this.extension.init_w;
+					h = this.extension.init_h;
+				}
+
 if (w > scene.screen_width) {
 					h *= scene.screen_width;
 					h /= w;
@@ -353,12 +390,17 @@
 e.height = evt.height;
 gwlib_filter_event(e);
 }
+ this.movie.children0.on_codec_slow = function(evt) {
+			msg = gw_new_message(null, 'Codec too slow', 'Cannot play back at required speed ' + this.extension.movie_control.mediaSpeed);
+			msg.set_size(380, gwskin.default_icon_height + 2 * gwskin.default_text_font_size);
+			msg.show();
+		}
 
 this.movie.children0.addEventListener('gpac_scene_attached', this.movie.children0.on_scene_size, 0);
 this.movie.children0.addEventListener('gpac_addon_found', this.movie.children0.on_addon_found, 0);
 this.movie.children0.addEventListener('gpac_streamlist_changed', this.movie.children0.on_streamlist_changed, 0);
 this.movie.children0.addEventListener('gpac_scene_size', this.movie.children0.on_scene_size_modify, 0);
-
+ this.movie.children0.addEventListener('gpac_codec_slow', this.movie.children0.on_codec_slow, 0);
 
 this.movie.children0.on_media_progress = function (evt) {
 if (evt.buffering) {
@@ -402,6 +444,7 @@
 this.extension.playlist_next();
 } else {
 this.extension.set_state(this.extension.GF_STATE_STOP);
+ this.extension.set_time(0);
 }
 }
 }
@@ -423,7 +466,6 @@
 this.extension.controler.layout();
 }
 
-
 this.movie.children0.addEventListener('progress', this.movie.children0.on_media_progress, 0);
 this.movie.children0.addEventListener('playing', this.movie.children0.on_media_playing, 0);
 this.movie.children0.addEventListener('canplay', this.movie.children0.on_media_playing, 0);
@@ -623,6 +665,10 @@
 }
 }
 
+ wnd.chapters = gw_new_icon(wnd.infobar, 'chapters');
+ wnd.chapters.extension = this;
+ wnd.chapters.hide();
+
 wnd.loop = gw_new_icon(wnd.infobar, 'play_once');
 wnd.loop.extension = this;
 wnd.loop.add_icon(gwskin.images.play_loop);
@@ -658,26 +704,29 @@
 
 wnd.snd_low = gw_new_icon(wnd.infobar, 'audio');
 wnd.snd_low.extension = this;
- wnd.snd_ctrl = gw_new_slider(wnd.infobar);
- wnd.snd_ctrl.extension = this;
- wnd.snd_ctrl.stick_to_previous = true;
- wnd.snd_low.add_icon('audio_mute');
- wnd.snd_low.on_click = function () {
- if (this.extension.muted) {
- scene.volume = this.extension.muted;
- this.extension.muted = 0;
- this.switch_icon(0);
- } else {
- this.extension.muted = scene.volume ? scene.volume : 1;
- scene.volume = 0;
- this.switch_icon(1);
- }
- }
- wnd.snd_ctrl.on_slide = function (value, type) {
- if (this.extension.muted) this.extension.controler.snd_low.on_click();
- scene.volume = value;
- }
- wnd.snd_ctrl.set_value(scene.volume);
+		wnd.snd_low.add_icon('audio_mute');
+		wnd.snd_low.on_click = function () {
+			if (this.extension.muted) {
+				scene.volume = this.extension.muted;
+				this.extension.muted = 0;
+				this.switch_icon(0);
+			} else {
+				this.extension.muted = scene.volume ? scene.volume : 1;
+				scene.volume = 0;
+				this.switch_icon(1);
+			}
+		}
+		wnd.snd_ctrl = null;
+ if (!gwskin.mobile_device) {
+			wnd.snd_ctrl = gw_new_slider(wnd.infobar);
+			wnd.snd_ctrl.extension = this;
+			wnd.snd_ctrl.stick_to_previous = true;
+			wnd.snd_ctrl.on_slide = function (value, type) {
+				if (this.extension.muted) this.extension.controler.snd_low.on_click();
+				scene.volume = value;
+			}
+			wnd.snd_ctrl.set_value(scene.volume);
+		}
 
 wnd.open = null;
 if (!gwskin.browser_mode) {
@@ -709,7 +758,7 @@
 
 wnd.home = null;
 if (!gwskin.browser_mode) {
- wnd.home = gw_new_icon(wnd.infobar, 'osmo');
+ wnd.home = gw_new_icon(wnd.infobar, 'gpac');
 wnd.home.extension = this;
 wnd.home.on_click = function () {
 this.extension.controler.hide();
@@ -852,6 +901,11 @@
 if (this.extension.root_odm && !this.extension.dynamic_scene && !this.extension.root_odm.is_over)
 is_over = false;
 
+
+				if (this.chapters.visible) {
+ full_w += control_icon_size;
+				}
+
 } else {
 this.stats.hide();
 this.stop.hide();
@@ -1003,52 +1057,44 @@
 //check our args
 var i;
 //get URL when loading compositor in GUI mode with src option set
- var url_arg = scene.get_option('temp', 'gui_load_url');
- var prog_name = Sys.args0; 
+ var init_urls = ;
+ var url_arg = scene.get_option('temp', 'gui_load_urls');
+
+ if (url_arg && (url_arg.indexOf(',')>0)) {
+				init_urls = url_arg.split(',');
+ } else if (url_arg) {
+ init_urls.push(url_arg);
+ }
+
+ var prog_name = Sys.args0;
 var check_gpac_args = 1;
- if (url_arg && (url_arg.indexOf('://') < 0) )
- url_arg = 'gpac://' + url_arg;
 
- //check mp4client or MP4Client
- if (prog_name && (prog_name.indexOf('lient')>=0))
- check_gpac_args = 0;
- 
 for (i = 1; i < Sys.args.length; i++) {
 var arg = Sys.argsi;
 if (!arg) break;
 
- if (check_gpac_args==1) {
- if (arg=='-xopt') check_gpac_args=2;
+ if (check_gpac_args) {
+ if (arg=='-xopt') check_gpac_args = 0;
 continue;
 }
 
- //that's our file
+ //that's a URL
 if (arg.charAt(0) != '-') {
 //do not reopen ourselves !
 if (arg.indexOf('gui.bt') >= 0) continue;
 
- if (arg.indexOf('://') < 0) url_arg = 'gpac://' + arg;
- else url_arg = arg;
+ init_urls.push(arg);
 continue;
 }
 
- //MP4Client options taking 2 args
- if (!check_gpac_args) {
- if ((arg == '-rti') || (arg == '-rtix') || (arg == '-p') || (arg == '-size') || (arg == '-lf') || (arg == '-log-file') || (arg == '-logs')
- || (arg == '-opt') || (arg == '-ifce') || (arg == '-views') || (arg == '-mosaic') || (arg == '-avi') || (arg == '-out') || (arg == '-ntp-shift')
- || (arg == '-fps') || (arg == '-scale') || (arg == '-run-for') || (arg == '-bl')
- ) {
- i++;
- continue;
- }
- }
-
 if (arg.startsWith('-service=')) {
 this.initial_service_id = parseInt(arg.substring(9));
 } else if (arg.startsWith('-addon=')) {
 this.default_addon = arg.substring(7);
 } else if (arg == '-loop') {
 this.initial_loop = true;
+ } else if (arg == '-fs') {
+ scene.fullscreen = true;
 } else if ((arg == '-stats') || (arg == '-stat')) {
 this.show_stats_init = true;
 } else if (arg == '-gui-test') {
@@ -1056,8 +1102,15 @@
 this.show_stats_init = true;
 } else if (arg.startsWith('-speed=')) {
 this.initial_speed = Number(arg.substring(7));
- } else if (arg.startsWith('-play-from=')) {
- this.initial_start = Number(arg.substring(11));
+ } else if (arg.startsWith('-start=')) {
+ this.initial_start = Number(arg.substring(7));
+ } else if (arg.startsWith('-size=')) {
+					let s = arg.substring(6).split('x');
+					if (s.length==2) {
+						this.init_w = Number(s0);
+						this.init_h = Number(s1);
+						scene.set_size(this.init_w, this.init_h);
+					}
 } else {
 continue;
 }
@@ -1070,7 +1123,9 @@
 gwskin.media_clock = 0;
 gwskin.restore_session = this.create_restore_session(this);
 
- if (url_arg != null) {
+ if (init_urls.length==1) {
+ url_arg = init_urls0;
+ if (url_arg.indexOf('://') < 0) url_arg = 'gpac://' + url_arg;
 this.set_playlist_mode(false);
 var def_addon = this.default_addon;
 this.set_movie_url(url_arg);
@@ -1079,6 +1134,9 @@
 return;
 }
 this.set_playlist_mode(true);
+ if (init_urls.length) {
+ this.playlist_load(init_urls, true);
+ }
 }
 
 this.controler.show();
@@ -1219,6 +1277,7 @@
 str = '-';
 }
 }
+
 if (this.test_mode && (value>3)) {
 scene.exit(3); 
 }
@@ -1312,7 +1371,10 @@
 if (state == this.state) return;
 
 if (state == this.GF_STATE_STOP) {
- if (this.stats_wnd) this.stats_wnd.close_all();
+ if (this.stats_wnd) {
+ this.stats_wnd.close_all();
+ this.stats_wnd = null;
+ }
 this.stopped_url = '' + this.current_url;
 if (this.controlled_renderer) this.controlled_renderer.Stop();
 else {
@@ -1323,6 +1385,8 @@
 this.movie_control.mediaStartTime = 0;
 this.controler.media_line.set_value(0);
 this.controler.play.switch_icon(this.icon_play);
+ this.controler.media_list.hide();
+ this.controler.channels.hide();
 this.state = this.GF_STATE_STOP;
 this.set_speed(1);
 this.stats_resources = ;
@@ -1624,7 +1688,8 @@
 this.services = ;
 
 var root_odm = this.root_odm;
-
+ let chaps = null;
+ this.controler.chapters.hide();
 if (root_odm) {
 for (var res_i = 0; res_i < root_odm.nb_resources; res_i++) {
 var m = root_odm.get_resource(res_i);
@@ -1640,8 +1705,39 @@
 this.services.push(m);
 }
 }
+			chaps = root_odm.get_chapters();
 }
 
+		if (chaps) {
+			if (!this.controler.chapters.visible) {
+				this.controler.chapters.show();
+				this.controler.layout();
+			}
+
+			this.controler.chapters.on_click = function () {
+
+				if (this.extension.channels_wnd) {
+					this.extension.channels_wnd.close();
+					return;
+				}
+				var wnd = gw_new_popup(this.extension.controler.channels, 'up');
+				this.extension.channels_wnd = wnd;
+				wnd.extension = this.extension;
+
+				wnd.on_close = function () {
+					this.extension.channels_wnd = null;
+				}
+
+				chaps.forEach(chap => {
+					wnd.add_menu_item(chap.name, function () {
+						this.extension.movie_control.mediaStartTime = chap.start/1000.0;
+					});
+				});
+				wnd.on_display_size(gw_display_width, gw_display_height);
+				wnd.show();
+			}
+		}
+
 if (this.services.length <= 1) {
 this.controler.channels.hide();
 this.controler.channels.on_click = function () { }
@@ -1727,11 +1823,14 @@
 			} ) (extension);
 
 			wnd.make_item = function (text, obj) {
-				wnd.add_menu_item(text, function () {
-								 obj.select()
-								 });
+ let pref = "";
+ if (m.status == 'Playing') pref= "* ";
+ else if (m.status == 'Paused') pref= "* ";
+				wnd.add_menu_item(pref+text, function () {
+				 obj.select();
+			 });
 			}
-			
+
 			for (var res_i = 0; res_i < root_odm.nb_resources; res_i++) {
 				var m = root_odm.get_resource(res_i);
 				if (root_odm.selected_service != m.service_id) continue;
@@ -1740,10 +1839,10 @@
 					var text = 'Video #'+m.id;
 					wnd.make_item(text, m);
 				} else if (m.type=='Audio' && (nb_audio>1)) {
-					var text = 'Audio '+m.lang;
+					var text = 'Audio ('+m.lang+')';
 					wnd.make_item(text, m);
-				} else if (m.type=='Text' && (nb_subs>1)) {
-					var text = 'Subtitle '+m.lang;
+				} else if (m.type=='Text') {
+					var text = 'Subtitle ('+m.lang+')';
 					wnd.make_item(text, m);
 				}
 			}

gpac-2.0.0.tar.gz/share/gui/extensions/player/playlist.js -> gpac-2.2.0.tar.gz/share/gui/extensions/player/playlist.js Changed

gpac-2.0.0.tar.gz/share/gui/extensions/player/stats.js -> gpac-2.2.0.tar.gz/share/gui/extensions/player/stats.js Changed

@@ -211,7 +211,7 @@
 
 iw.on_close = function (width, height) {
 this.timer.stop();
- this.odm.gui.info_wnd = null;
+ if (this.odm) this.odm.gui.info_wnd = null;
 }
 
 iw.area = gw_new_text_area(iw, '');
@@ -442,65 +442,70 @@
 
 
 wnd.on_display_size = function (width, height) {
- var w;
+ var w, w_select;
 var h = 2 * gwskin.default_icon_height;
+ var icon_h = gwskin.default_icon_height;
 
 if (gwskin.mobile_device) {
 w = width;
+ icon_h *= 0.66;
+			if (this.has_select)
+				w_select = 4*icon_h;
 } else {
 w = 20 * gwskin.default_text_font_size;
 w += 4 * gwskin.default_icon_height;
+			if (this.has_select) {
+				w_select = 6*icon_h;
+				w += w_select;
+			}
 }
 
- if (this.has_select)
- w += 6 * gwskin.default_icon_height;
-
 for (var i = 0; i < this.extension.stats_resources.length; i++) {
 var res = this.extension.stats_resourcesi;
 var aw = w;
 
 if (res.gui.info) {
-				res.gui.info.set_size(1.5 * gwskin.default_icon_height, gwskin.default_icon_height);
+				res.gui.info.set_size(1.5 * icon_h, icon_h);
 				aw -= res.gui.info.width;
 			}
 if (res.gui.buffer) {
- res.gui.buffer.set_size(2 * gwskin.default_icon_height, 0.75 * gwskin.default_icon_height);
+ res.gui.buffer.set_size(2 * icon_h, 0.75 * icon_h);
 }
 if (res.gui.play) {
- res.gui.play.set_size(gwskin.default_icon_height, gwskin.default_icon_height);
+ res.gui.play.set_size(icon_h, icon_h);
 }
- aw -= 4 * gwskin.default_icon_height;
+ aw -= 4 * icon_h;
 
 if (res.gui.select) {
- res.gui.select.set_size(gwskin.default_icon_height, gwskin.default_icon_height);
- aw -= gwskin.default_icon_height;
- res.gui.select_label.set_size(6 * gwskin.default_icon_height, 0.75 * gwskin.default_icon_height);
- aw -= 4 * gwskin.default_icon_height;
+ res.gui.select.set_size(icon_h, icon_h);
+ aw -= icon_h;
+ res.gui.select_label.set_size(w_select, 0.75 * icon_h);
+ aw -= 4 * icon_h;
 }
 
 
- res.gui.txt.set_size(aw, gwskin.default_icon_height);
+ res.gui.txt.set_size(aw, icon_h);
 res.gui.txt.set_width(aw);
- h += gwskin.default_icon_height;
+ h += icon_h;
 }
 
 if (this.plot) {
- this.plot.set_size(w, 8 * gwskin.default_icon_height);
- h += 8 * gwskin.default_icon_height;
+ this.plot.set_size(w, 8 * icon_h);
+ h += 8 * icon_h;
 }
 
 if (this.http_control) {
- this.http_text.set_size(11 * gwskin.default_text_font_size, gwskin.default_icon_height);
- var ch = 0.5 * gwskin.default_icon_height;
- this.http_control.set_size(w - 11 * gwskin.default_text_font_size, ch, ch, ch);
- h += gwskin.default_icon_height;
+ this.http_text.set_size(10 * gwskin.default_text_font_size, icon_h);
+ var ch = 0.5 * icon_h;
+ this.http_control.set_size(w - 10 * gwskin.default_text_font_size, ch, ch, ch);
+ h += icon_h;
 }
 		
 		if (this.srd_modes) {
-			var cw = 0.75 * gwskin.default_icon_height;
-			this.srd_text.set_size(12 * gwskin.default_text_font_size, gwskin.default_icon_height);
-			this.srd_modes.set_size(w - 12 * gwskin.default_text_font_size - gwskin.default_icon_height, cw);
-			this.srd_select.set_size(gwskin.default_icon_height, cw);
+			var cw = 0.75 * icon_h;
+			this.srd_text.set_size(12 * gwskin.default_text_font_size, icon_h);
+			this.srd_modes.set_size(w - 12 * gwskin.default_text_font_size - icon_h, cw);
+			this.srd_select.set_size(icon_h, cw);
 		}
 
 this.set_size(w, h);
@@ -519,10 +524,13 @@
 }
 }
 
- var label = 'Statistics (' + Sys.nb_cores + ' cores - ';
+ var label = 'Statistics (' + Sys.nb_cores + ' cores';
 let mem = Sys.physical_memory;
- if (mem > 1000000000) label += '' + Math.round(mem / 1000 / 1000 / 1000) + ' GB RAM)';
- else label += '' + Math.round(mem / 1000 / 1000) + ' MB RAM)';
+ if (mem) {
+		if (mem > 1000000000) label += ' - ' + Math.round(mem / 1000 / 1000 / 1000) + ' GB RAM';
+		else label += ' - ' + Math.round(mem / 1000 / 1000) + ' MB RAM';
+	}
+	label += ')';
 
 wnd.set_label(label);

gpac-2.2.0.tar.gz/share/gui/extensions/showroom/gpac.bt Changed

gpac-2.0.0.tar.gz/share/gui/extensions/showroom/init.js -> gpac-2.2.0.tar.gz/share/gui/extensions/showroom/init.js Changed

gpac-2.0.0.tar.gz/share/gui/gui.js -> gpac-2.2.0.tar.gz/share/gui/gui.js Changed

@@ -1,7 +1,7 @@
 /////////////////////////////////////////////////////////////////////////////////
 //
 //	Authors:	
-// Jean Le Feuvre, (c) 2010-2020 Telecom Paris
+// Jean Le Feuvre, (c) 2010-2022 Telecom Paris
 //
 /////////////////////////////////////////////////////////////////////////////////
 import {scene} from 'scenejs'
@@ -85,10 +85,10 @@
 //var icon;
 var i, count, wid;
 
- scene.caption = 'Osmo4';
+ scene.caption = 'GPAC';
 
- gw_display_width = parseInt(scene.get_option('General', 'LastWidth'));
- gw_display_height = parseInt(scene.get_option('General', 'LastHeight'));
+ gw_display_width = parseInt(scene.get_option('GUI', 'width'));
+ gw_display_height = parseInt(scene.get_option('GUI', 'height'));
 if (!scene.fullscreen && (!gw_display_width || !gw_display_height)) {
 gw_display_width = 320;
 gw_display_height = 240;
@@ -102,7 +102,6 @@
 //request event listeners on the window - GPAC specific BIFS extensions !!! We don't allow using the event proc for size events
 root.addEventListener('resize', on_resize, 0);
 
- 
 /*load the UI lib*/
 Browser.loadScript('gwlib.js', false);
 gwlib_init(ui_root);
@@ -200,7 +199,7 @@
 
 for (i = 1; i < Sys.args.length; i++) {
 var arg = Sys.argsi;
- if (arg=='-h') {
+ if ((arg=='-h') || (arg=='-ha') || (arg=='-hx') || (arg=='-hh')) {
 print_help();
 scene.exit(); 
 return;
@@ -222,14 +221,71 @@
 
 //let's do the layout 
 layout();
- gwskin.enable_focus(true); 
+ gwskin.enable_focus(true);
+
+
+	session.set_auth_fun( (site, user, pass, secure, auth_cbk) => {
+ var popup = gw_new_window_full(null, true, 'Authentication for ' + site + (secure ? " - secured" : " - NOT SECURED"));
+ popup.area = gw_new_grid_container(popup);
+ popup.area.dlg = popup;
+ popup.area.spread_h = true;
+
+		popup.user='';
+		popup.pass='';
+		popup.state=0;
+		popup.auth_cbk = auth_cbk;
+ popup.name = gw_new_text(popup.area, 'Username');
+ popup.store = gw_new_checkbox(popup.area, 'Remember Me');
+
+ popup.edit = gw_new_text_edit(popup.area, user);
+ popup.edit.dlg = popup;
+ scene.set_focus(popup.edit);
+ popup.edit.on_text = function (val) {
+ if (val != '') {
+				if (popup.state==0) {
+					popup.user=val;
+					popup.state = 1;
+					popup.name.set_label('Password');
+					popup.edit.reset(true);
+					scene.set_focus(popup.edit.edit);
+				} else if (popup.state==1) {
+					print('done');
+					popup.pass=val;
+					popup.state = 2;
+					this.dlg.close();
+				}
+ } else {
+				this.dlg.close();
+			}
+		}
+
+ popup.on_display_size = function (w, h) {
+			let ed_h = 2 * gwskin.default_text_font_size;
+			if (gwskin.mobile_device) ed_h *= 1.5;
+ this.name.set_size(w/2, ed_h);
+ this.store.set_size(w/2, ed_h);
+ this.edit.set_size(w, ed_h);
+ this.set_size(w, 2*ed_h + gwskin.default_icon_height);
+			this.move(0, 0);
+ }
+
+ popup.on_display_size(gw_display_width, gw_display_height);
+ popup.set_alpha(1.0);
 
+ popup.on_close = function () {
+			this.auth_cbk.done(this.user, this.pass, this.store.checked);
+			this.pass='';
+			this.auth_cbk = null;
+ }
+ popup._init_focus = popup.edit.edit;
+ popup.show();
+	});
 }
 
 function print_help()
 {
 globalThis._gpac_log_name = "";
- print(-2, "GPAC GUI Help\nOptions are specified as '-opt' or '-opt=value'.\n");
+ print(-2, "GPAC GUI command-line help\nOptions are specified as `-opt` or `-opt=value`.\nSee `gpac -hx compositor` for rendering options.\n");
 
 //launch all default ext
 var i;
@@ -238,7 +294,10 @@
 && (typeof all_extensionsi.clopts != 'undefined')
 && all_extensionsi.icon.ext_description.autostart) {
 
- print(-2, '' + all_extensionsi.icon.ext_description.name + ' extension');
+ print(-2, '# ' + all_extensionsi.icon.ext_description.name + ' extension');
+
+ if (typeof all_extensionsi.description != 'undefined')
+ print(-2, '' + all_extensionsi.description);
 
 if (typeof all_extensionsi.clusage != 'undefined')
 print(-2, 'Usage: ' + all_extensionsi.clusage);
@@ -284,8 +343,8 @@
 gw_display_width = evt.width;
 gw_display_height = evt.height;
 if (!scene.fullscreen) {
- scene.set_option('General', 'LastWidth', '' + gw_display_width);
- scene.set_option('General', 'LastHeight', '' + gw_display_height);
+ scene.set_option('GUI', 'width', '' + gw_display_width);
+ scene.set_option('GUI', 'height', '' + gw_display_height);
 }
 /*
 var v = 12;

gpac-2.0.0.tar.gz/share/gui/gwlib.js -> gpac-2.2.0.tar.gz/share/gui/gwlib.js Changed

@@ -652,6 +652,19 @@
 s.font.style += ' SIMPLE_EDIT';
 s.font.skin = true;
 
+s = { name: 'editpw' };
+gwskin.styles.push(s);
+s.normal = gw_new_appearance(1, 1, 1);
+s.normal.texture = gw_make_gradient('vertical', 0, 1, 0.0, 0.2, 0.4, 0.0, 0.8, 1);
+s.over = gw_new_appearance(1, 1, 1);
+s.over.texture = gw_make_gradient('vertical', 0, 1, 0.0, 0.2, 0.4, 0.0, 0.8, 1);
+s.over.material.lineProps = gw_new_lineprops(0.0, 0.8, 1);
+s.text = gw_new_appearance(0, 0, 0);
+s.text.skin = true;
+s.font = gw_new_fontstyle(gwskin.default_text_font_size, 0);
+s.font.style += ' SIMPLE_EDIT PASSWD';
+s.font.skin = true;
+
 s = { name: 'window' };
 gwskin.styles.push(s);
 s.normal = gw_new_appearance(0.6, 0.6, 0.6);
@@ -778,8 +791,8 @@
 gwskin.labels.device = 'Device';
 gwskin.images.home = 'icons/home.svg';
 gwskin.labels.home = 'Home';
-gwskin.images.osmo = 'icons/osmo.svg';
-gwskin.labels.osmo = 'Home';
+gwskin.images.gpac = 'icons/gpac.svg';
+gwskin.labels.gpac = 'Home';
 gwskin.images.media = 'icons/more.svg';
 gwskin.labels.media = 'Media';
 gwskin.images.favorite = 'icons/heart.svg';
@@ -832,6 +845,8 @@
 gwskin.labels.view360 = 'VR';
 gwskin.images.sensors = 'icons/compass.svg';
 gwskin.labels.sensors = 'Orientation';
+gwskin.images.chapters = 'icons/chapter.svg';
+gwskin.labels.chapters = 'Chapters';
 
 
 gwskin.mime_video_default_ext = " mp4 mp4s m4s 3gp 3gpp m2ts ts trp m3u8 mpd avi mov ";
@@ -965,8 +980,12 @@
 gw_ui_top_wnd = wnd;
 }
 if (typeof (wnd._no_focus) == 'boolean') return;
- if (gwskin.focus_on)
- scene.set_focus(gw_ui_top_wnd);
+ if (gwskin.focus_on) {
+			if (typeof (wnd._init_focus) != 'undefined')
+				scene.set_focus(wnd._init_focus);
+			else
+				scene.set_focus(gw_ui_top_wnd);
+		}
 }
 
 gw_ui_root.remove_focus = function(wnd) {
@@ -1017,12 +1036,16 @@
 
 if ((device == 'ios') || (device == 'android')) gwskin.mobile_device = true;
 else gwskin.mobile_device = false;
- 
+
+ var cutout = scene.get_option('temp', 'display-cutout');
+ gwskin.display_cutout = (cutout == 'yes') ? true : false;
+
 if (gwskin.mobile_device) {
 var size = scene.screen_width;
 if (size > scene.screen_height) size = scene.screen_height;
- gwskin_set_default_control_height(size/6);
- gwskin_set_default_icon_height(size/12);
+
+ gwskin_set_default_control_height(size/8);
+ gwskin_set_default_icon_height(size/10);
 }
 
 	gwskin_set_white_blue();
@@ -1985,14 +2008,14 @@
 obj.on_check = NULL;
 obj.down = false;
 obj.over = false;
- obj._checked = false;
+ obj.checked = false;
 obj._on_active = function (value, timestamp) {
 if (value) {
 this.down = true;
 } else {
 if (this.down && this.over) {
- this._set_checked(!this._checked);
- if (this.on_check) this.on_check(this._checked);
+ this._set_checked(!this.checked);
+ if (this.on_check) this.on_check(this.checked);
 }
 this.down = false;
 }
@@ -2002,7 +2025,7 @@
 gw_reset_hit(this, value);
 
 if (gwskin.pointing_device) {
- var app = gwskin.get_style(class_name, value ? 'over' : (this._checked ? 'down' : 'normal') );
+ var app = gwskin.get_style(class_name, value ? 'over' : (this.checked ? 'down' : 'normal') );
 if (app) {
 this._icon_root.children0.children0.set_style(app);
 }
@@ -2015,7 +2038,7 @@
 
 
 obj._set_checked = function (value) {
- this._checked = value;
+ this.checked = value;
 var app = gwskin.get_style(class_name, value ? 'down' : 'normal');
 this._icon_root.children0.children0.set_style(app);
 }
@@ -2910,7 +2933,8 @@
 // gw_add_child(obj, edit);
 obj.on_text = null;
 obj._text_edited = function (val) {
- if (this.on_text) this.on_text(val0);
+		if (this.nb_reset) this.nb_reset--;
+		else if (this.on_text) this.on_text(val0);
 };
 Browser.addRoute(obj.children1.children0.children0.geometry, 'string', obj, obj._text_edited);
 
@@ -2921,8 +2945,16 @@
 this.children1.move(5 - w / 2, 0);
 };
 obj.on_event = function (x, y) { return false; }
-
-
+ obj.nb_reset=0;
+ obj.reset = function (use_pass) {
+		this.nb_reset++;
+		edit.set_label('');
+		if (use_pass)
+			edit.children0.children0.geometry.fontStyle = gwskin.get_font('editpw');
+		else
+			edit.children0.children0.geometry.fontStyle = gwskin.get_font('edit');
+ }
+ obj.edit = edit;
 gw_add_child(parent, obj);
 return obj;
 }
@@ -3499,7 +3531,7 @@
 obj.add_serie = function (legend, units, r, g, b) {
 var s = gw_new_curve2d('plot');
 s.set_color(r, g, b);
-
+		s.set_line_width(gwskin.default_icon_height/10);
 s.dlg = this;
 s.legend = legend;
 s.units = units;
@@ -3619,7 +3651,7 @@
 var s = childreni.get_label().length;
 if (s>max_s) max_s = s;
 }
-
+		max_s *= 0.66;
 for (var i=0; i<children.length; i++) {
 childreni.set_size(max_s * gwskin.default_text_font_size, gwskin.default_icon_height);
 }

gpac-2.2.0.tar.gz/share/gui/icons/chapter.svg Added

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 1000 1000" enable-background="new 0 0 1000 1000" xml:space="preserve">
+<metadata> Svg Vector Icons : http://www.onlinewebfonts.com/icon </metadata>
+<g><path d="M52.4,294.2c112.7,55.2,225.7,110,338.2,165.9c35.1,17.4,70.5,30.5,101.2,29.2c38.9-0.2,68.7-5.6,97.3-19.7c119.6-58.8,239.5-117.2,359.4-175.9c11-5.5,22.2-10.7,31.1-20.6c14.1-15.5,13.9-32.9-0.5-48c-7.3-7.7-16-13-25-17.4C843.7,154,733.5,100.3,623.5,46.1c-35.3-17.4-70.2-35-109.7-36c-33.4-0.9-66.2,1.8-97.2,16.8C293,86.9,169.8,147.4,46.5,207.7c-9.7,4.7-18.9,10.4-26.5,18.8c-13.1,14.8-13,30.7-0.1,45.7C29,282.8,40.7,288.4,52.4,294.2z"/><path d="M957.9,460.4c-23.8-11.7-47.5-23.9-71.5-34.9c-18.4-8.3-37.6-7.9-55.9,1c-58.8,28.4-117.6,57.2-176.2,86.2c-43.1,21.3-85.8,42.7-134.1,44.9c-43.7,2.1-86.5-2.4-127-22c-74.6-35.9-148.9-72.6-223.4-108.8c-19.4-9.4-39.3-9.3-58.5-0.7c-22.1,10-43.6,21.2-65.4,31.9c-9.6,4.8-18.9,10.3-26.5,18.9c-12.8,14.9-12.7,31.1,0.4,45.7c8.5,9.6,19.2,15.1,30.1,20.5c111,54.4,222.1,108.4,333,163.4c37.6,18.6,75.3,34.7,117.2,32.9c29.6-0.7,58.7-5,86.4-18.5c122.6-60,245.3-120,368-180c8.7-4.3,17.2-9.4,24.3-17c14.5-15.3,14.7-32.4,0.5-48C973.2,469.3,965.9,464.3,957.9,460.4z"/><path d="M956.4,709.8c-21.1-10.5-42.4-20.8-63.6-31.2c-21.9-10.7-43.5-10.9-65.5-0.1c-60.1,29.5-120.7,58.1-180.6,88.4c-43.5,22.1-87.4,40.8-135.8,41.7c-41.8,0.8-82.3-5-121.1-23.9c-72.9-35.7-146-71.4-218.9-107c-20.2-9.8-40.8-9.8-61.1-0.2c-22.4,10.7-44.8,21.9-67.1,32.9c-9.1,4.5-17.5,10.2-24.3,18.7c-10.6,13.2-11,27-1,40.9c7.5,10.3,17.6,16.5,28.2,21.7c114.8,56.2,229.8,112,344.4,168.6c34.8,17.2,69.8,30.7,108.3,29.6c32.3-0.3,63.4-6.1,93.5-20.9c120.7-59.5,241.8-118.2,362.7-177.4c10.8-5.3,21.2-11.7,28.8-22.5c9.3-13.3,8.7-26.4-1.1-39.3C975.1,720.6,966,714.6,956.4,709.8z"/></g>
+</svg>
\ No newline at end of file

gpac-2.2.0.tar.gz/share/gui/icons/gpac.svg Changed

gpac-2.0.0.tar.gz/share/lang/fr.txt -> gpac-2.2.0.tar.gz/share/lang/fr.txt Changed

gpac-2.0.0.tar.gz/share/nodejs/src/gpac_napi.c -> gpac-2.2.0.tar.gz/share/nodejs/src/gpac_napi.c Changed

@@ -980,6 +980,8 @@
 static u32 FS_PROP_PID_MIN_PCK_DUR = 13;
 static u32 FS_PROP_PID_PLAYING = 14;
 static u32 FS_PROP_PID_NEXT_TS = 15;
+static u32 FS_PROP_PID_SPARSE = 16;
+static u32 FS_PROP_PID_HAS_DECODER = 17;
 
 #define FILTERPID\
 	GF_FilterPid *pid=NULL;\
@@ -1033,6 +1035,10 @@
 		NAPI_CALL( napi_get_boolean(env, gf_filter_pid_would_block(pid), &ret) );
 		return ret;
 	}
+	if (magic == &FS_PROP_PID_SPARSE) {
+		NAPI_CALL( napi_get_boolean(env, gf_filter_pid_is_sparse(pid), &ret) );
+		return ret;
+	}
 	if (magic == &FS_PROP_PID_MAX_BUFFER) {
 		NAPI_CALL( napi_create_uint32(env, gf_filter_pid_get_max_buffer(pid), &ret) );
 		return ret;
@@ -1086,6 +1092,10 @@
 		}
         return ret;
 	}
+	if (magic == &FS_PROP_PID_HAS_DECODER) {
+		NAPI_CALL( napi_get_boolean(env, gf_filter_pid_has_decoder(pid), &ret) );
+        return ret;
+	}
 	return NULL;
 }
 
@@ -1935,12 +1945,13 @@
 }
 napi_value filter_update(napi_env env, napi_callback_info info)
 {
-	NARG_ARGS_THIS(2, 2)
+	NARG_ARGS_THIS(3, 2)
 	FILTER
 	NARG_STR(name, 0, NULL);
 	NARG_STR_ALLOC(value, 1, NULL);
+	NARG_U32(mask, 2, 0)
 
-	gf_fs_send_update(NULL, NULL, f, name, value, 0);
+	gf_fs_send_update(NULL, NULL, f, name, value, mask);
 	if (value) gf_free(value);
 	return NULL;
 }
@@ -1972,17 +1983,34 @@
 }
 napi_value filter_insert(napi_env env, napi_callback_info info)
 {
+	GF_FilterPid *opid=NULL;
+	s32 offset=1;
 	GF_Err e;
-	NARG_ARGS_THIS(2, 1)
+	NARG_ARGS_THIS(3, 1)
 	FILTER
 	FILTER_ARG(ins_f, 0)
-	NARG_STR(link_ext, 1, NULL);
+
+	//check if 2nd param is int, get opid
+	if (argc>1) {
+		s32 idx = -1;
+		if (napi_get_value_int32(env, argv1, &idx) == napi_ok) {
+			offset = 2;
+			if (idx>=0) {
+				opid = gf_filter_get_opid(f, (u32) idx);
+				if (!opid) {
+					napi_throw_error(env, NULL, "Invalid output PID index");
+					return NULL;
+				}
+			}
+		}
+	}
+	NARG_STR(link_ext, offset, NULL);
 
 	e = gf_filter_set_source(f, ins_f, link_ext);
 	if (e)
 		napi_throw_error(env, gf_error_to_string(e), "Failed to set source");
 	else
-		gf_filter_reconnect_output(f);
+		gf_filter_reconnect_output(f, opid);
 	return NULL;
 }
 
@@ -2059,21 +2087,6 @@
 	return napi_ok;
 }
 
-napi_value filter_get_statistics(napi_env env, napi_callback_info info)
-{
-	GF_Err e;
-	GF_FilterStats stats;
-	napi_value res, val;
-	NARG_THIS
-	FILTER
-
-	e = gf_filter_get_stats(f, &stats);
- 	if (e) {
-		napi_throw_error(env, gf_error_to_string(e), "Failed to get filter stats");
-		return NULL;
-	}
-	NAPI_CALL(napi_create_object(env, &res) );
-
 #define SET_BOOL(_val) \
 	NAPI_CALL(napi_get_boolean(env, stats._val ? true : false, &val) ); \
 	NAPI_CALL(napi_set_named_property(env, res, #_val, val) );
@@ -2102,6 +2115,22 @@
 	}\
 	NAPI_CALL(napi_set_named_property(env, res, #_val, val) );
 
+napi_value filter_get_statistics(napi_env env, napi_callback_info info)
+{
+	GF_Err e;
+	GF_FilterStats stats;
+	napi_value res, val;
+	NARG_THIS
+	FILTER
+
+	e = gf_filter_get_stats(f, &stats);
+ 	if (e) {
+		napi_throw_error(env, gf_error_to_string(e), "Failed to get filter stats");
+		return NULL;
+	}
+	NAPI_CALL(napi_create_object(env, &res) );
+
+
 	NAPI_CALL(napi_get_boolean(env, stats.filter_alias ? true : false, &val) );
 	NAPI_CALL(napi_set_named_property(env, res, "filter_alias", val) );
 	if (stats.filter_alias) {
@@ -2690,6 +2719,67 @@
 	return filter_iopid_prop(env, info, GF_TRUE);
 }
 
+napi_value filter_iopid_stats(napi_env env, napi_callback_info info, Bool is_opid)
+{
+	GF_Err e;
+	napi_value res, val;
+	GF_FilterPidStatistics stats;
+	GF_FilterPid *pid=NULL;
+	NARG_ARGS_THIS(2, 1)
+	FILTER
+	NARG_U32(idx, 0, 0)
+	NARG_U32(mode, 1, 0)
+
+	if (is_opid) {
+		pid = gf_filter_get_opid(f, idx);
+	} else {
+		pid = gf_filter_get_ipid(f, idx);
+	}
+	if (!pid) {
+		napi_throw_error(env, NULL, "Invalid PID index");
+		return NULL;
+	}
+
+	e = gf_filter_pid_get_statistics(pid, &stats, mode);
+ 	if (e) {
+		napi_throw_error(env, gf_error_to_string(e), "Failed to get filter stats");
+		return NULL;
+	}
+	NAPI_CALL(napi_create_object(env, &res) );
+	SET_BOOL(disconnected)
+	SET_U32(average_process_rate)
+	SET_U32(max_process_rate)
+	SET_U32(average_bitrate)
+	SET_U32(max_bitrate)
+	SET_U32(nb_processed)
+	SET_U32(max_process_time)
+	SET_U64(total_process_time)
+	SET_U64(first_process_time)
+	SET_U64(last_process_time)
+	SET_U32(min_frame_dur)
+	SET_U32(nb_saps)
+	SET_U32(max_sap_process_time)
+	SET_U64(total_sap_process_time)
+	SET_U64(max_buffer_time)
+	SET_U64(max_playout_time)
+	SET_U64(min_playout_time)
+	SET_U64(buffer_time)
+	SET_U32(nb_buffer_units)
+	SET_U64(last_rt_report)
+	SET_U32(rtt)
+	SET_U32(jitter)
+	SET_U32(loss_rate)
+	return res;
+}
+napi_value filter_ipid_stats(napi_env env, napi_callback_info info)
+{
+	return filter_iopid_stats(env, info, GF_FALSE);
+}
+napi_value filter_opid_stats(napi_env env, napi_callback_info info)
+{
+	return filter_iopid_stats(env, info, GF_TRUE);
+}
+
 napi_value filter_ipid_source(napi_env env, napi_callback_info info)
 {
 	GF_FilterPid *pid=NULL;
@@ -2864,6 +2954,7 @@
 		{ "has_seen_eos", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_HAS_SEEN_EOS},
 		{ "eos_received", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_HAS_RECEIVED},
 		{ "would_block", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_WOULD_BLOCK},
+		{ "sparse", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_SPARSE},
 		{ "max_buffer", NULL, NULL, filterpid_getter, filterpid_setter, NULL, napi_enumerable, &FS_PROP_PID_MAX_BUFFER},
 		{ "buffer", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_BUFFER},
 		{ "buffer_full", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_BUFFER_FULL},
@@ -2874,6 +2965,7 @@
 		{ "min_pck_dur", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_MIN_PCK_DUR},
 		{ "playing", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_PLAYING},
 		{ "next_ts", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_NEXT_TS},
+		{ "has_decoder", NULL, NULL, filterpid_getter, NULL, NULL, napi_enumerable, &FS_PROP_PID_HAS_DECODER},
 
 		{ "remove", 0, filterpid_remove, 0, 0, 0, napi_enumerable, 0 },
 		{ "enum_props", 0, filterpid_enum_props, 0, 0, 0, napi_enumerable, 0 },
@@ -3388,6 +3480,8 @@
 		{ "get_statistics", 0, filter_get_statistics, 0, 0, 0, napi_enumerable, 0 },
 		{ "require_source_id", 0, filter_require_source_id, 0, 0, 0, napi_enumerable, 0 },
 		{ "bind", 0, filter_bind, 0, 0, 0, napi_enumerable, 0 },
+		{ "ipid_stats", 0, filter_ipid_stats, 0, 0, 0, napi_enumerable, 0 },
+		{ "opid_stats", 0, filter_opid_stats, 0, 0, 0, napi_enumerable, 0 },
 	};
 
 	if (napi_f) {
@@ -4715,6 +4809,7 @@
 	DEF_CONST(GF_STATS_DECODER_SOURCE)
 	DEF_CONST(GF_STATS_ENCODER_SINK)
 	DEF_CONST(GF_STATS_ENCODER_SOURCE)
+	DEF_CONST(GF_STATS_SINK)
 
 	DEF_CONST(GF_FILTER_CLOCK_NONE)
 	DEF_CONST(GF_FILTER_CLOCK_PCR)
@@ -4758,7 +4853,6 @@
 	DEF_CONST(GF_IP_NETWORK_FAILURE)
 	DEF_CONST(GF_IP_CONNECTION_CLOSED)
 	DEF_CONST(GF_IP_NETWORK_EMPTY)
-	DEF_CONST(GF_IP_SOCK_WOULD_BLOCK)
 	DEF_CONST(GF_IP_UDP_TIMEOUT)
 	DEF_CONST(GF_AUTHENTICATION_FAILURE)
 	DEF_CONST(GF_SCRIPT_NOT_READY)
@@ -4795,6 +4889,8 @@
 	DEF_CONST(GF_EVENT_SET_CAPTION)
 	DEF_CONST(GF_EVENT_REFRESH)
 	DEF_CONST(GF_EVENT_QUIT)
+	DEF_CONST(GF_EVENT_CODEC_SLOW)
+	DEF_CONST(GF_EVENT_CODEC_OK)
 
 	DEF_CONST(GF_KEY_UNIDENTIFIED)
 	DEF_CONST(GF_KEY_ACCEPT)

gpac-2.2.0.tar.gz/share/python/__init__.py Added

gpac-2.2.0.tar.gz/share/python/libgpac Added

gpac-2.2.0.tar.gz/share/python/libgpac/__init__.py Added

gpac-2.2.0.tar.gz/share/python/libgpac/libgpac.py Added

@@ -0,0 +1,4679 @@
+#
+# GPAC - Multimedia Framework C SDK
+#
+# Authors: Jean Le Feuvre
+# Copyright (c) Telecom Paris 2020-2022
+# All rights reserved
+#
+# Python ctypes bindings for GPAC (core initialization and filters API only)
+#
+# GPAC is free software; you can redistribute it and/or modify
+# it under the terfsess of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GPAC is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; see the file COPYING. If not, write to
+# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+
+
+## 
+# \defgroup pyapi_grp Python APIs
+# \brief Python API for libgpac.
+#
+# # Foreword
+# This module provides ctypes(https://docs.python.org/3/library/ctypes.html) bindings for libgpac. These bindings currently allow:
+# - initializing libgpac, setting global arguments for the library
+# - creation, running and destruction of a filter session in blocking mode or non-blocking mode
+# - inspection of filters in a session
+# - user tasks scheduling
+# - Creation of custom filters in Python
+#
+# \note This is an initial work and more bindings might be needed, feel free to contribute/PR on https://github.com/gpac/gpac
+#
+# # Error handling
+#
+# Errors are handled through raising exceptions, except callback methods wich must return a \ref GF_Err value. 
+# # Properties handling
+#
+# Properties types are automatically converted to and from string. If the property name is not a built-in property type, the property is assumed to be a user-defined property. 
+# For example, when querying or setting a stream type property, use the property name `StreamType`.
+# See `gpac -h props`(https://github.com/gpac/gpac/wiki/filters_properties) for the complete list of built-in property names.
+#
+# Properties values are automatically converted to or from python types whenever possible. Types with no python equivalent (vectors, fractions) are defined as classes in python.
+# For example:
+# - when setting a UIntList property, pass a python list of ints 
+# - when reading a UIntList property, a python list of ints will be returned 
+# - when setting a PropVec2i property, pass a PropVec2i object 
+# - when setting a PropVec2iList property, pass a python list of PropVec2i 
+#
+# 4CCs are handled as strings in python, and list of 4CCs are handled as list of strings
+#
+# The following builtin property types are always handled as strings in Python instead of int in libgpac :
+# - StreamType: string containing the streamtype name
+# - CodecID: string containing the codec name
+# - Enumeration properties (PixelFormat, AudioFormat, ...): string containing the corresponding name
+#
+# # Basic setup
+#
+# You can initialize libgpac before any other calls to set memory tracker or profile. When importing the module, libgpac is by default initialized with no memory tracking and using the default profile.
+# You currently must uninintialize it after everything gpac-related is done.
+# You also must destroy explicitly the filter session, as otherwise the garbage collection on the filter session object could happen after libgpac shutdown and will likely crash
+#
+# \code
+# import libgpac as gpac
+# gpac.init()
+# #create a session in blocking mode
+# fs = gpac.FilterSession()
+# #setup all your filters
+# ...
+# #run the session
+# fs.run()
+# fs.delete()
+# gpac.close()
+# \endcode
+#
+# You can specify global options of libgpac and filters (e.g. --opt) by assigning arguments to libgpac:
+# \code
+# #set global arguments, here inherited from command line
+# gpac.set_args(sys.argv)
+# \endcode
+#
+# You can also specify the log levels you want
+# \code
+# gpac.set_logs("all@info")
+# \endcode
+# # Session using built-in filters
+#
+# Filters are loaded as usual in gpac as a string description
+# \code
+# src = fs.load_src("$URL:opt:opt2=val")
+# dst = fs.load_dst("$URL2:opt3:opt4=val")
+# f = fs.load("filtername:optX")
+# \endcode
+#
+# By default the filter session will run with implicit linking.
+#
+# It is possible to assign sources of a filter (much like the `@` command in `gpac`):
+# \code
+# dst.set_source(f)
+# \endcode
+#
+#
+# # Posting user tasks
+# 
+# You can post tasks to the session scheduler to get called back (useful when running the session in blocking mode)
+# Tasks must derive FilterTask class and implement their own `execute` method
+# \code
+# class MyTask(FilterTask): 
+# def exectute(self):
+# do_something()
+# #last scheduled task (session is over), abort
+# if self.session.last_task:
+# return -1 
+# //keep task active, reschedule in 500 ms 
+# return 500 
+#
+# task = MyTask('CustomTask')
+# fs.post_task(task)
+# \endcode
+#
+# # Creating custom filters
+#
+# A custom filter allows your application to interact closely with the media pipeline, but cannot be used in graph resolution.
+# Custom filters can be sources, sinks, or intermediate filters. The following limitations however exist:
+#- custom filters will not be cloned
+#- custom filters cannot be used as sources of filters loading a source filter graph dynamically, such as the dashin filter.
+#- custom filters cannot be used as destination of filters loading a destination filter graph dynamically, such as the dasher filters.
+#
+# A custom filter must implement the \ref FilterCustom class, and optionally provide the following methods
+# - configure_pid: callback for PID configuration, mandatory if your filter is not a source
+# - process: callback for processing
+# - process_event: callback for processing and event
+# - probe_data: callback for probing a data format
+# - reconfigure_output: callback for output reconfiguration (PID capability negociation)
+#
+# A custom filter must also declare its capabilities, input and output, using push_cap method 
+# \code
+# class MyFilter(FilterTask): 
+# def __init__(self, session):
+# # !! call constructor of parent class first !!
+# gpac.FilterCustom.__init__(self, session, "PYnspect")
+# #indicate what we accept and produce - this can be done either in the constructor or after, but before calling \ref run or \ref run_step 
+# #here we indicate we accept anything of type visual, and produce anything of type visual
+# self.push_cap("StreamType", "Visual", gpac.GF_CAPS_INPUT_OUTPUT)
+#
+# #we accept input pids, we must configure them
+# #def configure_pid(self, pid, is_remove):
+# #do something, return value is a GF_Err value
+# #pid being removed
+# if is_remove:
+# #pid being reconfigured
+# elif pid in self.ipids:
+# #pid first connection
+# else:
+#
+# #process
+# #def process(self):
+# #do something, return value is a GF_Err value
+#
+# #process_event takes a \ref FilterEvent parameter
+# #def process_event(self, evt):
+# #do something, return value is True (cancelled) or False
+#
+# #probe_data takes a NumPy array if numpy is available (and _size can be ignored) or a POINTER(c_ubyte) otherwise
+# #def probe_data(self, data, _size):
+# #do something, return value is mime type or None
+#
+# #probe_data takes the target output pid as parameter
+# #def reconfigure_output(self, opid):
+# #do something, return value is a GF_Err value
+#
+# \endcode
+#
+# \note
+# The \ref FilterCustom object has a list of input and output PIDs created. Before a callback to configure_pid, the input PID is not registered to the list 
+# of input PIDs if this is the first time the PID is configured.
+#
+# \code
+# src = fs.load_src("$URL:opt:opt2=val")
+# dst = fs.load_dst("$URL2:opt3:opt4=val")
+# #load a custom filter
+# my_filter = MyFilter(fs)
+# #make sure dst only consumes from our custom filter
+# dst.set_source(f)
+# \endcode
+# @{
+#
+
+
+## 
+# \defgroup pycore_grp libgpac core tools
+# \ingroup pyapi_grp Python APIs
+# \brief Core tools for libgpac.
+#
+# @{
+
+
+from ctypes import *
+from ctypes.util import find_library
+import datetime
+import types
+import os
+import copy
+
+## set to True if numpy was successfully loaded
+##\hideinitializer
+numpy_support=True
+
+try:
+ import numpy as np
+except ImportError:
+ numpy_support = False
+ print("\nWARNING! numpy not present, packet data type is ctypes POINTER(c_ubyte)\n")
+
+##ctypes instance of libgpac
+##\hideinitializer
+_libgpac=None
+
+## \cond private
+#load libgpac
+try:
+ dll_path = find_library("libgpac.dll")
+ if not dll_path:
+ raise OSError("No libgpac.dll")
+
+ _libgpac = cdll.LoadLibrary(os.path.abspath(dll_path))
+except OSError:
+ try:
+ _libgpac = cdll.LoadLibrary("libgpac.so")
+ except OSError:
+ try:
+ _libgpac = cdll.LoadLibrary("libgpac.dylib")
+ except OSError:
+ print('Failed to locate libgpac (.so/.dll/.dylib) - make sure it is in your system path')
+ os._exit(1)
+
+#change this to reflect API we encapsulate. An incomatibility in either of these will throw a warning
+GF_ABI_MAJOR=12
+GF_ABI_MINOR=10
+
+gpac_abi_major=_libgpac.gf_gpac_abi_major()
+gpac_abi_minor=_libgpac.gf_gpac_abi_minor()
+
+## \endcond private
+
+## Set to true if mismatch was detected between the ABI version the Python wrapper was designed and the libgpac shared library ABI version
+# A warning is thrown if mismatched, but it is left up to the pythin script to decide whether it still wants to use libgpac wrapper
+_libgpac_abi_mismatch=False
+
+## \cond private
+if (gpac_abi_major != GF_ABI_MAJOR) or (gpac_abi_minor != GF_ABI_MINOR):
+ abi_mismatch=True
+ print('WARNING: this python wrapper is for GPAC ABI ' + str(GF_ABI_MAJOR) + '.' + str(GF_ABI_MINOR) + ' but native libgpac ABI is ' + str(gpac_abi_major) + '.' + str(gpac_abi_minor) + '\n\tUndefined behavior or crashes might happen, please update libgpac.py')
+
+## \endcond private
+
+#
+# Type definitions
+#
+
+##\cond private
+_gf_filter_session = c_void_p
+_gf_filter = c_void_p
+_gf_filter_pid = c_void_p
+_gf_filter_packet = c_void_p
+_gf_property_entry = c_void_p
+_gf_list = c_void_p
+gf_bool = c_uint
+
+##\endcond
+
+
+
+
+##\cond private
+#error to string helper
+_libgpac.gf_error_to_string.argtypes = c_int
+_libgpac.gf_error_to_string.restype = c_char_p
+ 
+_libgpac.gf_gpac_version.restype = c_char_p
+_libgpac.gf_gpac_copyright.restype = c_char_p
+_libgpac.gf_gpac_copyright_cite.restype = c_char_p
+
+_libgpac.gf_sys_set_args.argtypes = c_int, POINTER(POINTER(c_char))
+
+_libgpac.gf_sys_init.argtypes = c_int, c_char_p
+_libgpac.gf_log_set_tools_levels.argtypes = c_char_p, c_int
+_libgpac.gf_props_get_type_name.argtypes = c_uint
+_libgpac.gf_props_get_type_name.restype = c_char_p
+
+_libgpac.gf_sys_clock.restype = c_uint
+_libgpac.gf_sys_clock_high_res.restype = c_ulonglong
+
+_libgpac.gf_sys_profiler_send.argtypes = c_char_p
+_libgpac.gf_sys_profiler_sampling_enabled.restype = gf_bool
+_libgpac.gf_sys_profiler_enable_sampling.argtypes = gf_bool
+
+_libgpac.gf_4cc_to_str.argtypes = c_uint
+_libgpac.gf_4cc_to_str.restype = c_char_p
+
+_libgpac.gf_4cc_parse.argtypes = c_char_p
+_libgpac.gf_4cc_parse.restype = c_uint
+
+_libgpac.gf_sleep.argtypes = c_uint
+_libgpac.gf_sleep.restype = c_uint
+
+#default init of libgpac
+_libgpac.user_init = False
+err = _libgpac.gf_sys_init(0, None)
+if err<0:
+	raise Exception('Failed to initialize libgpac: ' + e2s(err))
+
+#\endcond
+
+##libgpac version (string)
+#\hideinitializer
+version = _libgpac.gf_gpac_version().decode("utf-8")
+##libgpac copyright notice (string)
+#\hideinitializer
+copyright = _libgpac.gf_gpac_copyright().decode("utf-8")
+##libgpac full copyright notice (string)
+#\hideinitializer
+copyright_cite = _libgpac.gf_gpac_copyright_cite().decode("utf-8")
+
+## convert error value to string message
+# \param err gpac error code (int)
+# \return string
+def e2s(err):
+ return _libgpac.gf_error_to_string(err).decode('utf-8')
+
+
+## initialize libgpac - see \ref gf_sys_init
+# \param mem_track
+# \param profile
+# \return
+#
+def init(mem_track=0, profile=None):
+ if _libgpac.user_init:
+ return
+ _libgpac.user_init = True
+ _libgpac.gf_sys_close()
+ err = _libgpac.gf_sys_init(mem_track, profile)
+ if err<0:
+ raise Exception('Failed to initialize libgpac: ' + e2s(err))
+
+
+## close libgpac - see \ref gf_sys_close
+# \note Make sure you have destroyed all associated gpac resources before calling this !
+# \return
+#
+def close():
+ _libgpac.gf_sys_close()
+ if hasattr(_libgpac, 'gf_memory_size'):
+ if _libgpac.gf_memory_size() or _libgpac.gf_file_handles_count():
+ set_logs("mem@info")
+ _libgpac.gf_memory_print()
+ return 2
+ return 0
+
+## set log tools and levels - see \ref gf_log_set_tools_levels
+# \note Make sure you have destroyed all associated gpac resources before calling this !
+# \param logs
+# \param reset if true, resets all logs to default
+# \return
+def set_logs(logs, reset=False):
+ _libgpac.gf_log_set_tools_levels(logs.encode('utf-8'), reset)
+
+## get clock - see \ref gf_sys_clock
+# \return clock in milliseconds
+def sys_clock():
+ return _libgpac.gf_sys_clock()
+
+## get high res clock - see \ref gf_sys_clock_high_res
+# \return clock in microseconds
+def sys_clock_high_res():
+ return _libgpac.gf_sys_clock_high_res()
+
+##\cond private
+
+#keep args at libgpac level to avoid python GC
+_libgpac._args=None
+
+##\endcond private
+
+## set libgpac arguments - see \ref gf_sys_set_args
+# \param args list of strings, the first string is ignored (considered to be the executable name)
+# \return
+def set_args(args):
+ _libgpac.user_init = True
+ nb_args = len(args)
+ _libgpac._args = (POINTER(c_char)*nb_args)()
+ for i, arg in enumerate(args):
+ enc_arg = arg.encode('utf-8')
+ _libgpac._argsi = create_string_buffer(enc_arg)
+ _libgpac.gf_sys_set_args(nb_args, cast(_libgpac._args, POINTER(POINTER(c_char))) )
+
+
+##\cond private
+_libgpac.gf_sys_profiler_set_callback.argtypes = py_object, c_void_p
+@CFUNCTYPE(c_int, c_void_p, c_char_p)
+def rmt_fun_cbk(_udta, text):
+ obj = cast(_udta, py_object).value
+ obj.on_rmt_event(text.decode('utf-8'))
+ return 0
+##\endcond private
+
+
+## set profiler (Remotery) callback - see \ref gf_sys_profiler_set_callback
+# \param callback_obj object to call back, must have a method `on_rmt_event` taking a single string parameter
+# \return True if success, False if no Remotery support
+def set_rmt_fun(callback_obj):
+ _libgpac.user_init = True
+ if hasattr(callback_obj, 'on_rmt_event')==False:
+ raise Exception('No on_rmt_event function on callback')
+ err = _libgpac.gf_sys_profiler_set_callback(py_object(callback_obj), rmt_fun_cbk)
+ if err<0:
+ return False
+ return True
+
+## send message to profiler (Remotery) - see \ref gf_sys_profiler_send
+# \param text text to send
+# \return True if success, False if no Remotery support
+def rmt_send(text):
+ err = _libgpac.gf_sys_profiler_send(text.encode('utf-8'))
+ if err<0:
+ return False
+ return True
+
+## check if profiler (Remotery) sampling is enabled - see \ref gf_sys_profiler_sampling_enabled
+# \return True if enabled, False otherwise
+def rmt_on():
+ return _libgpac.gf_sys_profiler_sampling_enabled()
+
+## enable or disable sampling in profiler (Remotery) - see \ref gf_sys_profiler_enable_sampling
+# \param value enable or disable sampling
+# \return
+def rmt_enable(value):
+ _libgpac.user_init = True
+ _libgpac.gf_sys_profiler_enable_sampling(value)
+ 
+
+## sleep for given time in milliseconds
+# \param value time to sleep
+# \return
+def sleep(value):
+ _libgpac.gf_sleep(value)
+
+
+## @}
+
+
+## 
+# \defgroup pystruct_grp Structure Wrappers
+# \ingroup pyapi_grp
+# \brief Python Structures 
+#
+# Python Wrappers for gpac C structures used in this API
+#
+# @{
+
+## fraction object, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_Fraction
+class Fraction(Structure):
+ ## \cond private
+ def __init(self, num, den):
+ self.num = num
+ self.den = den
+ _fields_ = ("num", c_int), ("den", c_uint)
+ def __str__(self):
+ return str(self.num)+'/' + str(self.den)
+ ## \endcond
+
+## large fraction object, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_Fraction64
+class Fraction64(Structure):
+ ## \cond private
+ _fields_ = ("num", c_longlong), ("den", c_ulonglong)
+ def __str__(self):
+ return str(self.num)+'/' + str(self.den)
+ ## \endcond
+
+## filter statistics object, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FilterStats
+class FilterStats(Structure):
+ ## \cond private
+	_fields_ = 
+		("filter", _gf_filter),
+		("filter_alias", _gf_filter),
+		("nb_tasks_done", c_ulonglong),
+		("nb_pck_processed", c_ulonglong),
+		("nb_bytes_processed", c_ulonglong),
+		("nb_pck_sent", c_ulonglong),
+		("nb_hw_pck_sent", c_ulonglong),
+		("nb_errors", c_uint),
+		("nb_bytes_sent", c_ulonglong),
+		("time_process", c_ulonglong),
+		("percent", c_int),
+		("status", c_char_p),
+		("report_updated", gf_bool),
+		("name", c_char_p),
+		("reg_name", c_char_p),
+		("filter_id", c_char_p),
+		("done", gf_bool),
+		("nb_pid_in", c_uint),
+		("nb_in_pck", c_ulonglong),
+		("nb_pid_out", c_uint),
+		("nb_out_pck", c_ulonglong),
+		("in_eos", gf_bool),
+		("type", c_int),
+		("stream_type", c_int),
+		("codecid", c_int),
+		("last_ts_sent", Fraction64),
+		("last_ts_drop", Fraction64)
+	
+ ## \endcond
+
+## filter pid statistics object, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FilterPidStatistics
+class FilterPidStatistics(Structure):
+ ## \cond private
+	_fields_ = 
+		("disconnected", c_uint),
+		("average_process_rate", c_uint),
+		("max_process_rate", c_uint),
+		("average_bitrate", c_uint),
+		("max_bitrate", c_uint),
+		("nb_processed", c_uint),
+		("max_process_time", c_uint),
+		("total_process_time", c_ulonglong),
+		("first_process_time", c_ulonglong),
+		("last_process_time", c_ulonglong),
+		("min_frame_dur", c_uint),
+		("nb_saps", c_uint),
+		("max_sap_process_time", c_uint),
+		("total_sap_process_time", c_ulonglong),
+		("max_buffer_time", c_ulonglong),
+		("max_playout_time", c_ulonglong),
+		("min_playout_time", c_ulonglong),
+		("buffer_time", c_ulonglong),
+		("nb_buffer_units", c_uint),
+		("last_rt_report", c_ulonglong),
+		("rtt", c_uint),
+		("jitter", c_uint),
+		("loss_rate", c_uint)
+	
+ ## \endcond
+## filter argument object, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FilterArgs
+class FilterArg(Structure):
+ ## \cond private
+ _fields_ = 
+ ("name", c_char_p),
+ ("reserved", c_int),
+ ("description", c_char_p),
+ ("type", c_int),
+ ("default", c_char_p),
+ ("min_max_enum", c_char_p),
+ ("flags", c_uint)
+ 
+ def __str__(self):
+ res = '- ' + self.name.decode('utf-8') + ' (' + _libgpac.gf_props_get_type_name(self.type).decode('utf-8') + '): ' + self.description.decode('utf-8')
+ if self.default or self.min_max_enum:
+ res += ' ('
+ if self.default:
+ res += 'default: ' + self.default.decode('utf-8')
+ if self.min_max_enum:
+ res += ' min_max_enum: ' + self.min_max_enum.decode('utf-8')
+ res += ')'
+ return res
+ ## \endcond
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropVec2i
+class PropVec2i(Structure):
+ ## \cond private
+ _fields_ = ("x", c_int), ("y", c_int)
+ def __str__(self):
+ return str(self.x)+'x' + str(self.y)
+ ## \endcond
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropVec2
+class PropVec2(Structure):
+ ## \cond private
+ _fields_ = ("x", c_double),("y", c_double)
+ def __str__(self):
+ return str(self.x)+'x' + str(self.y)
+ ## \endcond
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropVec3i
+class PropVec3i(Structure):
+ ## \cond private
+ _fields_ = ("x", c_int), ("y", c_int), ("z", c_int)
+ def __str__(self):
+ return str(self.x)+'x' + str(self.y)+'x' + str(self.z)
+ ## \endcond
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropVec4i
+class PropVec4i(Structure):
+ ## \cond private
+ _fields_ = ("x", c_int), ("y", c_int), ("z", c_int), ("w", c_int)
+ def __str__(self):
+ return str(self.x)+'x' + str(self.y)+'x' + str(self.z)+'x' + str(self.w)
+ ## \endcond
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropData
+class PropData(Structure):
+ ## \cond private
+ _fields_ = ("ptr", c_void_p), ("size", c_uint)
+ def __str__(self):
+ return 'data,size:'+str(self.size)
+ ## \endcond
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropUIntList
+class PropStringList(Structure):
+ ## \cond private
+ _fields_ = ("vals", POINTER(c_char_p)), ("nb_items", c_uint)
+ def __str__(self):
+ res=''
+ for i in range(self.nb_items):
+ if i:
+ res += ','
+ res += self.valsi.decode('utf-8')
+ return res
+ ## \endcond private
+
+## \cond private
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropUIntList
+class PropUIntList(Structure):
+ _fields_ = ("vals", POINTER(c_uint)), ("nb_items", c_uint)
+ def __str__(self):
+ res=''
+ for i in range(self.nb_items):
+ if i:
+ res += ','
+ res += str(self.valsi)
+ return res
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropIntList
+class PropIntList(Structure):
+ _fields_ = ("vals", POINTER(c_int)), ("nb_items", c_uint)
+ def __str__(self):
+ res=''
+ for i in range(self.nb_items):
+ if i:
+ res += ','
+ res += str(self.valsi)
+ return res
+
+## filter prop type, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_PropVec2iList
+class PropVec2iList(Structure):
+ _fields_ = ("vals", POINTER(PropVec2i)), ("nb_items", c_uint)
+ def __str__(self):
+ res=''
+ for i in range(self.nb_items):
+ if i:
+ res += ','
+ res += str(self.valsi.x) + 'x' + str(self.valsi.y)
+ return res
+
+## filter property union value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as GF_PropertyValue
+class PropertyValueUnion(Union):
+	_fields_ = 
+		("longuint", c_ulonglong),
+		("longsint", c_longlong),
+		("sint", c_int),
+		("uint", c_uint),
+		("boolean", gf_bool),
+		("frac", Fraction),
+		("lfrac", Fraction64),
+		("fnumber", c_float),
+		("number", c_double),
+		("vec2i", PropVec2i),
+		("vec2", PropVec2),
+		("vec3i", PropVec3i),
+		("vec4i", PropVec3i),
+		("data", PropData),
+		("string", c_char_p),
+		("ptr", c_void_p),
+ ("string_list", PropStringList),
+ ("uint_list", PropUIntList),
+		("sint_list", PropIntList),
+		("v2i_list", PropVec2iList)
+	
+
+## filter property value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as GF_PropertyValue
+class PropertyValue(Structure):
+	_fields_ = 
+		("type", c_uint),
+		("value", PropertyValueUnion)
+	
+
+## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_Base
+class FEVT_Base(Structure):
+ ## \cond private
+ _fields_ = ("type", c_uint), ("on_pid", _gf_filter_pid)
+ ## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_Play
+class FEVT_Play(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("start_range", c_double),
+ ("end_range", c_double),
+ ("speed", c_double),
+ ("from_pck", c_uint),
+ ("hw_buffer_reset", c_ubyte),
+ ("initial_broadcast_play", c_ubyte),
+ ("timestamp_based", c_ubyte),
+ ("full_file_only", c_ubyte),
+ ("forced_dash_segment_switch", c_ubyte),
+ ("drop_non_ref", c_ubyte),
+ ("no_byterange_forward", c_ubyte)
+ 
+ ## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_SourceSeek
+class FEVT_SourceSeek(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("start_offset", c_ulonglong),
+ ("end_offset", c_ulonglong),
+ ("source_switch", c_char_p),
+ ("is_init_segment", c_ubyte),
+ ("skip_cache_expiration", c_ubyte),
+ ("hint_block_size", c_uint)
+ 
+ ## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_SegmentSize
+class FEVT_SegmentSize(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("seg_url", c_char_p),
+ ("is_init", gf_bool),
+ ("media_range_start", c_ulonglong),
+ ("media_range_end", c_ulonglong),
+ ("idx_range_start", c_ulonglong),
+ ("idx_range_end", c_ulonglong)
+ 
+ ## \endcond
+
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_AttachScene
+class FEVT_AttachScene(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("odm", c_void_p),
+ ("node", c_void_p)
+ 
+ ## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_QualitySwitch
+class FEVT_QualitySwitch(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("up", gf_bool),
+ ("dependent_group_index", c_uint),
+ ("q_idx", c_int),
+ ("set_tile_mode_plus_one", c_uint),
+ ("quality_degradation", c_uint)
+ 
+ ## \endcond
+
+#TODO GF_FEVT_Event;
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_FileDelete
+class FEVT_FileDelete(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("url", c_char_p)
+ 
+ ## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_VisibilityHint
+class FEVT_VisibilityHint(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("min_x", c_uint),
+ ("max_x", c_uint),
+ ("min_y", c_uint),
+ ("max_y", c_uint),
+ ("is_gaze", gf_bool)
+ 
+ ## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as \ref GF_FEVT_BufferRequirement
+class FEVT_BufferRequirement(Structure):
+ ## \cond private
+ _fields_ = 
+ ("type", c_uint),
+ ("on_pid", _gf_filter_pid),
+ ("max_buffer_us", c_uint),
+ ("max_playout_us", c_uint),
+ ("min_playout_us", c_uint),
+ ("pid_only", gf_bool)
+ 
+ ## \endcond
+
+## event value, as defined in libgpac and usable as a Python object
+#Fields have the same types, names and semantics as GF_FilterEvent
+class FilterEvent(Union):
+ ## constructor
+ #\param type type of event
+ def __init__(self, type=0):
+ self.base.type = type
+ ## \cond private
+ _libgpac.user_init = True
+
+ _fields_ = 
+ ("base", FEVT_Base),
+ ("play", FEVT_Play),
+ ("seek", FEVT_SourceSeek),
+ ("attach_scene", FEVT_AttachScene),
+ #("user_event", FEVT_Event,
+ ("quality_switch", FEVT_QualitySwitch),
+ ("visibility_hint", FEVT_VisibilityHint),
+ ("buffer_req", FEVT_BufferRequirement),
+ ("seg_size", FEVT_SegmentSize),
+ ("file_del", FEVT_FileDelete)
+ 
+ ## \endcond
+
+
+## Buffer occupancy object 
+class BufferOccupancy:
+ ##\cond private
+ def __init__(self, max_units, nb_pck, max_dur, dur, is_final_flush):
+ ##\endcond
+ ##maximum number of packets (partial or full AU) allowed in buffer
+ self.max_units = max_units
+ ##number of block allowed in buffer
+ self.nb_pck = nb_pck
+ ##maximum buffer duration in microseconds
+ self.max_dur = max_dur
+ ## buffer duration in microseconds
+ self.dur = dur
+ ##if true, the session has been aborted and this is the final flush for this buffer
+ self.is_final_flush = is_final_flush
+
+
+## @}
+
+
+## 
+# \defgroup pycst_grp Constants
+# \ingroup pyapi_grp
+# \brief Constants definitions
+#
+# Python Wrappers for gpac C constants used in this API
+#
+# @{
+
+
+# scheduler type definitions
+##\hideinitializer
+#see \ref GF_FS_SCHEDULER_LOCK_FREE
+GF_FS_SCHEDULER_LOCK_FREE=0
+##\hideinitializer
+##see \ref GF_FS_SCHEDULER_LOCK
+GF_FS_SCHEDULER_LOCK=1
+##\hideinitializer
+##see \ref GF_FS_SCHEDULER_LOCK_FREE_X
+GF_FS_SCHEDULER_LOCK_FREE_X=2
+##\hideinitializer
+##see \ref GF_FS_SCHEDULER_LOCK_FORCE
+GF_FS_SCHEDULER_LOCK_FORCE=3
+##\hideinitializer
+##see \ref GF_FS_SCHEDULER_DIRECT
+GF_FS_SCHEDULER_DIRECT=4
+
+#session flags
+##\hideinitializer
+#see \ref GF_FS_FLAG_LOAD_META
+GF_FS_FLAG_LOAD_META=1<<1
+##\hideinitializer
+#see \ref GF_FS_FLAG_NON_BLOCKING
+GF_FS_FLAG_NON_BLOCKING=1<<2
+##\hideinitializer
+#see \ref GF_FS_FLAG_NO_GRAPH_CACHE
+GF_FS_FLAG_NO_GRAPH_CACHE=1<<3
+##\hideinitializer
+#see \ref GF_FS_FLAG_NO_REGULATION
+GF_FS_FLAG_NO_REGULATION=1<<4
+##\hideinitializer
+#see \ref GF_FS_FLAG_NO_PROBE
+GF_FS_FLAG_NO_PROBE=1<<5
+##\hideinitializer
+#see \ref GF_FS_FLAG_NO_REASSIGN
+GF_FS_FLAG_NO_REASSIGN=1<<6
+##\hideinitializer
+#see \ref GF_FS_FLAG_PRINT_CONNECTIONS
+GF_FS_FLAG_PRINT_CONNECTIONS=1<<7
+##\hideinitializer
+#see \ref GF_FS_FLAG_NO_ARG_CHECK
+GF_FS_FLAG_NO_ARG_CHECK=1<<8
+##\hideinitializer
+#see \ref GF_FS_FLAG_NO_RESERVOIR
+GF_FS_FLAG_NO_RESERVOIR=1<<0
+##\hideinitializer
+#see \ref GF_FS_FLAG_FULL_LINK
+GF_FS_FLAG_FULL_LINK=1<<10
+##\hideinitializer
+#see \ref GF_FS_FLAG_NO_IMPLICIT
+GF_FS_FLAG_NO_IMPLICIT=1<<11
+
+
+##\hideinitializer
+#see \ref GF_PROP_FORBIDEN
+GF_PROP_FORBIDEN=0
+##\hideinitializer
+#see \ref GF_PROP_SINT
+GF_PROP_SINT=1
+##\hideinitializer
+#see \ref GF_PROP_UINT
+GF_PROP_UINT=2
+##\hideinitializer
+#see \ref GF_PROP_LSINT
+GF_PROP_LSINT=3
+##\hideinitializer
+#see \ref GF_PROP_LUINT
+GF_PROP_LUINT=4
+##\hideinitializer
+#see \ref GF_PROP_BOOL
+GF_PROP_BOOL=5
+##\hideinitializer
+#see \ref GF_PROP_FRACTION
+GF_PROP_FRACTION=6
+##\hideinitializer
+#see \ref GF_PROP_FRACTION64
+GF_PROP_FRACTION64=7
+##\hideinitializer
+#see \ref GF_PROP_FLOAT
+GF_PROP_FLOAT=8
+##\hideinitializer
+#see \ref GF_PROP_DOUBLE
+GF_PROP_DOUBLE=9
+##\hideinitializer
+#see \ref GF_PROP_VEC2I
+GF_PROP_VEC2I=10
+##\hideinitializer
+#see \ref GF_PROP_VEC2
+GF_PROP_VEC2=11
+##\hideinitializer
+#see \ref GF_PROP_VEC3I
+GF_PROP_VEC3I=12
+##\hideinitializer
+#see \ref GF_PROP_VEC4I
+GF_PROP_VEC4I=13
+##\hideinitializer
+#see \ref GF_PROP_STRING
+GF_PROP_STRING=14
+##\hideinitializer
+#see \ref GF_PROP_STRING_NO_COPY
+GF_PROP_STRING_NO_COPY=15
+##\hideinitializer
+#see \ref GF_PROP_DATA
+GF_PROP_DATA=16
+##\hideinitializer
+#see \ref GF_PROP_NAME
+GF_PROP_NAME=17
+##\hideinitializer
+#see \ref GF_PROP_DATA_NO_COPY
+GF_PROP_DATA_NO_COPY=18
+##\hideinitializer
+#see \ref GF_PROP_CONST_DATA
+GF_PROP_CONST_DATA=19
+##\hideinitializer
+#see \ref GF_PROP_POINTER
+GF_PROP_POINTER=20
+##\hideinitializer
+#see \ref GF_PROP_STRING_LIST
+GF_PROP_STRING_LIST=21
+##\hideinitializer
+#see \ref GF_PROP_UINT_LIST
+GF_PROP_UINT_LIST=22
+##\hideinitializer
+#see \ref GF_PROP_SINT_LIST
+GF_PROP_SINT_LIST=23
+##\hideinitializer
+#see \ref GF_PROP_VEC2I_LIST
+GF_PROP_VEC2I_LIST=24
+##\hideinitializer
+#see \ref GF_PROP_4CC
+GF_PROP_4CC=25
+##\hideinitializer
+#see \ref GF_PROP_4CC_LIST
+GF_PROP_4CC_LIST=26
+
+##\hideinitializer
+#see \ref GF_PROP_FIRST_ENUM
+GF_PROP_FIRST_ENUM=40
+##\hideinitializer
+#see \ref GF_PROP_PIXFMT
+GF_PROP_PIXFMT=GF_PROP_FIRST_ENUM
+##\hideinitializer
+#see \ref GF_PROP_PCMFMT
+GF_PROP_PCMFMT=GF_PROP_FIRST_ENUM+1
+##\hideinitializer
+#see \ref GF_PROP_CICP_COL_PRIM
+GF_PROP_CICP_COL_PRIM=GF_PROP_FIRST_ENUM+2
+##\hideinitializer
+#see \ref GF_PROP_CICP_COL_TFC
+GF_PROP_CICP_COL_TFC=GF_PROP_FIRST_ENUM+3
+##\hideinitializer
+#see \ref GF_PROP_CICP_COL_MX
+GF_PROP_CICP_COL_MX=GF_PROP_FIRST_ENUM+4
+
+##\hideinitializer
+#see GF_FEVT_PLAY
+GF_FEVT_PLAY = 1
+##\hideinitializer
+#see GF_FEVT_SET_SPEED
+GF_FEVT_SET_SPEED = 2
+##\hideinitializer
+#see GF_FEVT_STOP
+GF_FEVT_STOP = 3
+##\hideinitializer
+#see GF_FEVT_PAUSE
+GF_FEVT_PAUSE = 4
+##\hideinitializer
+#see GF_FEVT_RESUME
+GF_FEVT_RESUME = 5
+##\hideinitializer
+#see GF_FEVT_SOURCE_SEEK
+GF_FEVT_SOURCE_SEEK = 6
+##\hideinitializer
+#see GF_FEVT_SOURCE_SWITCH
+GF_FEVT_SOURCE_SWITCH = 7
+##\hideinitializer
+#see GF_FEVT_SEGMENT_SIZE
+GF_FEVT_SEGMENT_SIZE = 8
+##\hideinitializer
+#see GF_FEVT_ATTACH_SCENE
+GF_FEVT_ATTACH_SCENE = 9
+##\hideinitializer
+#see GF_FEVT_RESET_SCENE
+GF_FEVT_RESET_SCENE = 10
+##\hideinitializer
+#see GF_FEVT_QUALITY_SWITCH
+GF_FEVT_QUALITY_SWITCH = 11
+##\hideinitializer
+#see GF_FEVT_VISIBILITY_HINT
+GF_FEVT_VISIBILITY_HINT = 12
+##\hideinitializer
+#see GF_FEVT_INFO_UPDATE
+GF_FEVT_INFO_UPDATE = 13
+##\hideinitializer
+#see GF_FEVT_BUFFER_REQ
+GF_FEVT_BUFFER_REQ = 14
+##\hideinitializer
+#see GF_FEVT_CAPS_CHANGE
+GF_FEVT_CAPS_CHANGE = 15
+##\hideinitializer
+#see GF_FEVT_CONNECT_FAIL
+GF_FEVT_CONNECT_FAIL = 16
+##\hideinitializer
+#see GF_FEVT_USER
+GF_FEVT_USER = 17
+##\hideinitializer
+#see GF_FEVT_PLAY_HINT
+GF_FEVT_PLAY_HINT = 18
+##\hideinitializer
+#see GF_FEVT_FILE_DELETE
+GF_FEVT_FILE_DELETE = 19
+
+
+##\hideinitializer
+#see GF_FS_ARG_HINT_NORMAL
+GF_FS_ARG_HINT_NORMAL = 0
+##\hideinitializer
+#see GF_FS_ARG_HINT_ADVANCED
+GF_FS_ARG_HINT_ADVANCED = 1<<1
+##\hideinitializer
+#see GF_FS_ARG_HINT_EXPERT
+GF_FS_ARG_HINT_EXPERT = 1<<2
+##\hideinitializer
+#see GF_FS_ARG_HINT_HIDE
+GF_FS_ARG_HINT_HIDE = 1<<3
+##\hideinitializer
+#see GF_FS_ARG_UPDATE
+GF_FS_ARG_UPDATE = 1<<4
+##\hideinitializer
+#see GF_FS_ARG_META
+GF_FS_ARG_META = 1<<5
+##\hideinitializer
+#see GF_FS_ARG_META_ALLOC
+GF_FS_ARG_META_ALLOC = 1<<6
+##\hideinitializer
+#see GF_FS_ARG_SINK_ALIAS
+GF_FS_ARG_SINK_ALIAS = 1<<7
+
+
+##\hideinitializer
+#see GF_CAPFLAG_IN_BUNDLE
+GF_CAPFLAG_IN_BUNDLE = 1
+##\hideinitializer
+#see GF_CAPFLAG_INPUT
+GF_CAPFLAG_INPUT = 1<<1
+##\hideinitializer
+#see GF_CAPFLAG_OUTPUT
+GF_CAPFLAG_OUTPUT = 1<<2
+##\hideinitializer
+#see GF_CAPFLAG_EXCLUDED
+GF_CAPFLAG_EXCLUDED = 1<<3
+##\hideinitializer
+#see GF_CAPFLAG_LOADED_FILTER
+GF_CAPFLAG_LOADED_FILTER = 1<<4
+##\hideinitializer
+#see GF_CAPFLAG_STATIC
+GF_CAPFLAG_STATIC = 1<<5
+##\hideinitializer
+#see GF_CAPFLAG_OPTIONAL
+GF_CAPFLAG_OPTIONAL = 1<<6
+
+#helpers
+##\hideinitializer
+#see GF_CAPS_INPUT
+GF_CAPS_INPUT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT)
+##\hideinitializer
+#see GF_CAPS_INPUT_OPT
+GF_CAPS_INPUT_OPT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OPTIONAL)
+##\hideinitializer
+#see GF_CAPS_INPUT_STATIC
+GF_CAPS_INPUT_STATIC = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_STATIC)
+##\hideinitializer
+#see GF_CAPS_INPUT_STATIC_OPT
+GF_CAPS_INPUT_STATIC_OPT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_STATIC|GF_CAPFLAG_OPTIONAL)
+##\hideinitializer
+#see GF_CAPS_INPUT_EXCLUDED
+GF_CAPS_INPUT_EXCLUDED = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_EXCLUDED)
+##\hideinitializer
+#see GF_CAPS_INPUT_LOADED_FILTER
+GF_CAPS_INPUT_LOADED_FILTER = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_LOADED_FILTER)
+##\hideinitializer
+#see GF_CAPS_OUTPUT
+GF_CAPS_OUTPUT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT)
+##\hideinitializer
+#see GF_CAPS_OUTPUT_LOADED_FILTER
+GF_CAPS_OUTPUT_LOADED_FILTER = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_LOADED_FILTER)
+##\hideinitializer
+#see GF_CAPS_OUTPUT_EXCLUDED
+GF_CAPS_OUTPUT_EXCLUDED = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_EXCLUDED)
+##\hideinitializer
+#see GF_CAPS_OUTPUT_STATIC
+GF_CAPS_OUTPUT_STATIC = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_STATIC)
+##\hideinitializer
+#see GF_CAPS_OUTPUT_STATIC_EXCLUDED
+GF_CAPS_OUTPUT_STATIC_EXCLUDED = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_EXCLUDED|GF_CAPFLAG_STATIC)
+##\hideinitializer
+#see GF_CAPS_INPUT_OUTPUT
+GF_CAPS_INPUT_OUTPUT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OUTPUT)
+##\hideinitializer
+#see GF_CAPS_INPUT_OUTPUT_OPT
+GF_CAPS_INPUT_OUTPUT_OPT = (GF_CAPFLAG_IN_BUNDLE|GF_CAPFLAG_INPUT|GF_CAPFLAG_OUTPUT|GF_CAPFLAG_OPTIONAL)
+
+
+##\hideinitializer
+#see GF_STATS_LOCAL
+GF_STATS_LOCAL = 0
+##\hideinitializer
+#see GF_STATS_LOCAL_INPUTS
+GF_STATS_LOCAL_INPUTS = 1
+##\hideinitializer
+#see GF_STATS_DECODER_SINK
+GF_STATS_DECODER_SINK = 2
+##\hideinitializer
+#see GF_STATS_DECODER_SOURCE
+GF_STATS_DECODER_SOURCE = 3
+##\hideinitializer
+#see GF_STATS_ENCODER_SINK
+GF_STATS_ENCODER_SINK = 4
+##\hideinitializer
+#see GF_STATS_ENCODER_SOURCE
+GF_STATS_ENCODER_SOURCE = 5
+##\hideinitializer
+#see GF_STATS_SINK
+GF_STATS_SINK = 6
+
+
+##\hideinitializer
+#see \ref GF_SCRIPT_INFO
+GF_SCRIPT_INFO = 3
+##\hideinitializer
+#see \ref GF_PENDING_PACKET
+GF_PENDING_PACKET = 2
+##\hideinitializer
+#see \ref GF_EOS
+GF_EOS = 1
+##\hideinitializer
+#see \ref GF_OK
+GF_OK = 0
+##\hideinitializer
+#see \ref GF_BAD_PARAM
+GF_BAD_PARAM = -1
+##\hideinitializer
+#see \ref GF_OUT_OF_MEM
+GF_OUT_OF_MEM = -2
+##\hideinitializer
+#see \ref GF_IO_ERR
+GF_IO_ERR = -3
+##\hideinitializer
+#see \ref GF_NOT_SUPPORTED
+GF_NOT_SUPPORTED = -4
+##\hideinitializer
+#see \ref GF_CORRUPTED_DATA
+GF_CORRUPTED_DATA = -5
+##\hideinitializer
+#see \ref GF_SCRIPT_ERROR
+GF_SCRIPT_ERROR = -8
+##\hideinitializer
+#see \ref GF_BUFFER_TOO_SMALL
+GF_BUFFER_TOO_SMALL = -9
+##\hideinitializer
+#see \ref GF_NON_COMPLIANT_BITSTREAM
+GF_NON_COMPLIANT_BITSTREAM = -10
+##\hideinitializer
+#see \ref GF_FILTER_NOT_FOUND
+GF_FILTER_NOT_FOUND = -11
+##\hideinitializer
+#see \ref GF_URL_ERROR
+GF_URL_ERROR = -12
+##\hideinitializer
+#see \ref GF_SERVICE_ERROR
+GF_SERVICE_ERROR = -13
+##\hideinitializer
+#see \ref GF_REMOTE_SERVICE_ERROR
+GF_REMOTE_SERVICE_ERROR = -14
+##\hideinitializer
+#see \ref GF_STREAM_NOT_FOUND
+GF_STREAM_NOT_FOUND = -15
+##\hideinitializer
+#see \ref GF_URL_REMOVED
+GF_URL_REMOVED = -16
+##\hideinitializer
+#see \ref GF_IP_ADDRESS_NOT_FOUND
+GF_IP_ADDRESS_NOT_FOUND = -40
+##\hideinitializer
+#see \ref GF_IP_CONNECTION_FAILURE
+GF_IP_CONNECTION_FAILURE = -41
+##\hideinitializer
+#see \ref GF_IP_NETWORK_FAILURE
+GF_IP_NETWORK_FAILURE = -42
+##\hideinitializer
+#see \ref GF_IP_CONNECTION_CLOSED
+GF_IP_CONNECTION_CLOSED = -43
+##\hideinitializer
+#see \ref GF_IP_NETWORK_EMPTY
+GF_IP_NETWORK_EMPTY = -44
+##\hideinitializer
+#see \ref GF_IP_UDP_TIMEOUT
+GF_IP_UDP_TIMEOUT = -46
+##\hideinitializer
+#see \ref GF_AUTHENTICATION_FAILURE
+GF_AUTHENTICATION_FAILURE = -50
+##\hideinitializer
+#see \ref GF_SCRIPT_NOT_READY
+GF_SCRIPT_NOT_READY = -51
+##\hideinitializer
+#see \ref GF_INVALID_CONFIGURATION
+GF_INVALID_CONFIGURATION = -52
+##\hideinitializer
+#see \ref GF_NOT_FOUND
+GF_NOT_FOUND = -53
+##\hideinitializer
+#see \ref GF_PROFILE_NOT_SUPPORTED
+GF_PROFILE_NOT_SUPPORTED = -54
+##\hideinitializer
+#see \ref GF_REQUIRES_NEW_INSTANCE
+GF_REQUIRES_NEW_INSTANCE = -56
+##\hideinitializer
+#see \ref GF_FILTER_NOT_SUPPORTED
+GF_FILTER_NOT_SUPPORTED = -57
+
+##notification is a setup error, the filter chain was never connected
+GF_SETUP_ERROR=0
+##notification is an error but keep the filter chain connected
+GF_NOTIF_ERROR=1
+##notification is an error and disconnect the filter chain
+GF_NOTIF_ERROR_AND_DISCONNECT=2
+
+
+##Do not flush session: everything is discarded, potentially breaking output files
+GF_FS_FLUSH_NONE=0,
+##Flush all pending data before closing sessions: sources will be forced into end of stream and all emitted packets will be processed
+GF_FS_FLUSH_ALL=1
+##Stop session (resetting buffers) and flush pipeline
+GF_FS_FLUSH_FAST=2
+
+## @}
+
+##\cond private
+
+_gf_filter_session = c_void_p
+_gf_filter = c_void_p
+_gf_filter_pid = c_void_p
+
+#
+# filter session bindings
+#
+
+_libgpac.gf_fs_new.argtypes = c_int, c_int, c_int, c_char_p
+_libgpac.gf_fs_new.restype = _gf_filter_session
+
+_libgpac.gf_fs_del.argtypes = _gf_filter_session
+_libgpac.gf_fs_del.restype = None
+
+_libgpac.gf_fs_run.argtypes = _gf_filter_session
+
+_libgpac.gf_fs_load_source.argtypes = _gf_filter_session, c_char_p, c_char_p, c_char_p, POINTER(c_int)
+_libgpac.gf_fs_load_source.restype = _gf_filter
+
+_libgpac.gf_fs_load_destination.argtypes = _gf_filter_session, c_char_p, c_char_p, c_char_p, POINTER(c_int)
+_libgpac.gf_fs_load_destination.restype = _gf_filter
+
+_libgpac.gf_fs_load_filter.argtypes = _gf_filter_session, c_char_p, POINTER(c_int)
+_libgpac.gf_fs_load_filter.restype = _gf_filter
+
+_libgpac.gf_fs_new_filter.argtypes = _gf_filter_session, c_char_p, c_uint, POINTER(c_int)
+_libgpac.gf_fs_new_filter.restype = _gf_filter
+
+
+_libgpac.gf_fs_post_user_task.argtypes = _gf_filter_session, c_void_p, py_object, c_char_p
+_libgpac.gf_fs_post_user_task.restype = c_int
+
+_libgpac.gf_fs_is_last_task.argtypes = _gf_filter_session
+_libgpac.gf_fs_is_last_task.restype = gf_bool
+
+_libgpac.gf_fs_get_filters_count.argtypes = _gf_filter_session
+_libgpac.gf_fs_get_filter.argtypes = _gf_filter_session, c_int
+_libgpac.gf_fs_get_filter.restype = _gf_filter
+
+_libgpac.gf_fs_abort.argtypes = _gf_filter_session, c_int
+
+_libgpac.gf_fs_get_http_max_rate.argtypes = _gf_filter_session
+_libgpac.gf_fs_get_http_rate.argtypes = _gf_filter_session
+_libgpac.gf_fs_set_http_max_rate.argtypes = _gf_filter_session, c_uint
+
+_libgpac.gf_fs_lock_filters.argtypes = _gf_filter_session, gf_bool
+_libgpac.gf_fs_enable_reporting.argtypes = _gf_filter_session, gf_bool
+
+_libgpac.gf_fs_print_stats.argtypes = _gf_filter_session
+_libgpac.gf_fs_print_connections.argtypes = _gf_filter_session
+
+_libgpac.gf_fs_fire_event.argtypes = _gf_filter_session, _gf_filter, POINTER(FilterEvent), gf_bool
+_libgpac.gf_fs_fire_event.restype = gf_bool
+
+_libgpac.gf_fs_is_supported_mime.argtypes = _gf_filter_session, c_char_p
+_libgpac.gf_fs_is_supported_mime.restype = gf_bool
+
+_libgpac.gf_fs_is_supported_mime.argtypes = _gf_filter_session, c_char_p
+_libgpac.gf_fs_is_supported_mime.restype = gf_bool
+
+_libgpac.gf_fs_is_supported_source.argtypes = _gf_filter_session, c_char_p, c_char_p
+_libgpac.gf_fs_is_supported_source.restype = gf_bool
+
+_libgpac.gf_pixel_fmt_sname.argtypes = c_uint
+_libgpac.gf_pixel_fmt_sname.restype = c_char_p
+
+
+@CFUNCTYPE(c_int, _gf_filter_session, c_void_p, POINTER(c_uint))
+def fs_task_fun(sess, cbk, resched):
+ obj = cast(cbk, py_object).value
+ res = obj.execute()
+ if res==None or res<0:
+ obj.session.rem_task(obj)
+ return 0
+ resched.contents.value=res
+ return 1
+
+
+
+_libgpac.gf_fs_set_filter_creation_callback.argtypes = _gf_filter_session, c_void_p, py_object, gf_bool
+@CFUNCTYPE(c_int, c_void_p, _gf_filter, gf_bool)
+def on_filter_new_del(cbk, _filter, is_del):
+ sess = cast(cbk, py_object).value
+ f = sess._to_filter(_filter)
+ if is_del:
+ if hasattr(sess, 'on_filter_del'):
+ sess.on_filter_del(f)
+ sess._filters.remove(f)
+ elif hasattr(sess, 'on_filter_new'):
+ sess.on_filter_new(f)
+
+ return 0
+
+
+_libgpac.gf_fs_set_external_gl_provider.argtypes = _gf_filter_session, c_void_p, py_object
+@CFUNCTYPE(c_int, c_void_p, gf_bool)
+def on_gl_ctx_activate(cbk, set_active):
+ sess = cast(cbk, py_object).value
+ if hasattr(sess, 'on_gl_activate'):
+ sess.on_gl_activate(set_active)
+ return 0
+
+##\endcond
+
+
+## Task object for user callbacks from libgpac scheduler 
+class FilterTask:
+ ## constructor for tasks
+ #\param name name of the task (used for logging)
+ def __init__(self, name):
+ ##Task name
+ #\hideinitializer
+ self.name = name
+ ##Filter session
+ #\hideinitializer
+ self.session = None
+ ## task execution function
+ #\return -1 or less to remove the task from the scheduler, 0 or more to indicate the number of milliseconds to wait before calling the task again
+ def execute(self):
+ return -1
+
+
+## filter session object - see \ref GF_FilterSession
+class FilterSession:
+ ## constructor for filter session - see \ref gf_fs_new
+ #\param flags session flags (int)
+ #\param blacklist list of blacklisted filters
+ #\param nb_threads number of threads to use (int)
+ #\param sched_type session scheduler type
+ def __init__(self, flags=0, blacklist=None, nb_threads=0, sched_type=0):
+ ##\cond private
+ _libgpac.user_init = True
+ self._sess = None
+ if blacklist:
+ self._sess = _libgpac.gf_fs_new(nb_threads, sched_type, flags, blacklist.encode('utf-8'))
+ else:
+ self._sess = _libgpac.gf_fs_new(nb_threads, sched_type, flags, None)
+ if not self._sess:
+ raise Exception('Failed to create new filter session')
+ self._filters = 
+ self._tasks = 
+ #for now force sync user tasks and filter management to run on main thread, not tested otherwise
+ _libgpac.gf_fs_set_filter_creation_callback(self._sess, on_filter_new_del, py_object(self), True)
+
+ ##\endcond
+ #hack for doxygen to generate member vars (not support for parsing @property)
+ if 0:
+ ##set to true if this is the last task running, readonly - see \ref gf_fs_is_last_task
+ self.last_task=0
+ ##number of filters in session, readonly - see \ref gf_fs_get_filters_count
+ self.nb_filters=0
+ ##current HTTP cumulated download rate, readonly - see \ref gf_fs_get_http_rate
+ self.http_bitrate=0
+ ##HTTP max download rate - see \ref gf_fs_get_http_max_rate and \ref gf_fs_set_http_max_rate
+ self.http_max_bitrate=0
+
+
+ ## delete an existing filter session - see \ref gf_fs_del
+ #\warning The filter session must be explicitly destroyed if close (\ref gf_sys_close) is called after that 
+ #\return
+ def delete(self):
+ ##\cond private
+ if self._sess:
+ _libgpac.gf_fs_del(self._sess)
+ self._sess=None
+ ##\endcond private
+
+ ## called whenever a new filter is added, typically used by classes deriving from FilterSession
+ #\param filter Filter object being added
+ #\return
+ def on_filter_new(self, filter):
+ pass
+
+ ## called whenever a filter is destroyed, typically used by classes deriving from FilterSession
+ #\param filter Filter object being removed
+ #\return
+ def on_filter_del(self, filter):
+ pass
+
+ ## called whenever a GL context must be activated, typically used by classes deriving from FilterSession
+ #\param do_activate set to true if openGL context ust be activated for calling thread
+ #\return
+ def on_gl_activate(self, do_activate):
+ return 0
+
+ ## call this function to prevent openGL context creation in libgpac, delegating GL context management to the calling app
+ #\return
+ def external_opengl_provider(self):
+ _libgpac.gf_fs_set_external_gl_provider(self._sess, on_gl_ctx_activate, py_object(self))
+
+ ##\cond private
+ def _to_filter(self, f):
+ for i, a_f in enumerate(self._filters):
+ if a_f._filter == f:
+ return a_f
+ filter = Filter(self, f)
+ self._filters.append(filter)
+ return filter
+ ##\endcond private
+
+ ##run the session - see \ref gf_fs_run
+ #\return
+ def run(self):
+ err = _libgpac.gf_fs_run(self._sess)
+ if err<0: 
+ raise Exception('Failed to run session: ' + e2s(err))
+
+ ##load source filter - see \ref gf_fs_load_source
+ #\param URL source URL to load
+ #\param parentURL URL of parent resource for relative path resolution
+ #\return new Filter object
+ def load_src(self, URL, parentURL=None):
+ errp = c_int(0)
+ if parentURL:
+ filter = _libgpac.gf_fs_load_source(self._sess, URL.encode('utf-8'), None, parentURL.encode('utf-8'), byref(errp))
+ else:
+ filter = _libgpac.gf_fs_load_source(self._sess, URL.encode('utf-8'), None, None, byref(errp))
+ err = errp.value
+ if err<0: 
+ raise Exception('Failed to load source filter ' + URL + ': ' + e2s(err))
+ return self._to_filter(filter)
+
+ ##load destination filter - see \ref gf_fs_load_destination
+ #\param URL source URL to load
+ #\param parentURL URL of parent resource for relative path resolution
+ #\return new Filter object
+ def load_dst(self, URL, parentURL=None):
+ errp = c_int(0)
+ if parentURL:
+ filter = _libgpac.gf_fs_load_destination(self._sess, URL.encode('utf-8'), None, parentURL.encode('utf-8'), byref(errp))
+ else:
+ filter = _libgpac.gf_fs_load_destination(self._sess, URL.encode('utf-8'), None, None, byref(errp))
+ err = errp.value
+ if err<0: 
+ raise Exception('Failed to load destination filter ' + URL + ': ' + e2s(err))
+ return self._to_filter(filter)
+
+
+ ##load a filter - see \ref gf_fs_load_filter
+ #\param fname filter name and options
+ #\return new Filter object
+ def load(self, fname):
+ errp = c_int(0)
+ filter = _libgpac.gf_fs_load_filter(self._sess, fname.encode('utf-8'), byref(errp))
+ err = errp.value
+ if err<0: 
+ raise Exception('Failed to load filter ' + fname + ': ' + e2s(err))
+ return self._to_filter(filter)
+
+ ##post a user task to the filter sesison - see \ref gf_fs_post_user_task
+ #\param task task object to post
+ #\return
+ def post(self, task):
+ task.session = self
+ err = _libgpac.gf_fs_post_user_task(self._sess, fs_task_fun, py_object(task), task.name.encode('utf-8'))
+ if err<0: 
+ raise Exception('Failed to post task ' + task.name + ': ' + e2s(err))
+ self._tasks.append(task)
+
+ ##\cond private
+ #\return
+ def rem_task(self, task):
+ task.session = None
+ self._tasks.remove(task)
+ ##\endcond
+
+ ##abort the session - see \ref gf_fs_abort
+ #\param flush flush pipeline before abort
+ #\return
+ def abort(self, flush=0):
+ _libgpac.gf_fs_abort(self._sess, flush)
+ 
+ ##get a filter by index - see \ref gf_fs_get_filter
+ #\param index index of filter
+ #\return Filter object
+ def get_filter(self, index):
+ f = _libgpac.gf_fs_get_filter(self._sess, index)
+ if not f:
+ raise Exception('Failed to get filter at index ' + str(index) )
+ return self._to_filter(f)
+
+ 
+ ##lock the session - see \ref gf_fs_lock_filters
+ #\param lock if True, locks otherwise unlocks
+ #\return
+ def lock(self, lock):
+ _libgpac.gf_fs_lock_filters(self._sess, lock)
+
+ ##enable status reporting by filters - see \ref gf_fs_enable_reporting
+ #\param do_report if True, enables reporting
+ #\return
+ def reporting(self, do_report):
+ _libgpac.gf_fs_enable_reporting(self._sess, do_report)
+
+ ##print statistics on stderr - see \ref gf_fs_print_stats
+ #\return
+ def print_stats(self):
+ _libgpac.gf_fs_print_stats(self._sess)
+
+ ##print graph on stderr - see \ref gf_fs_print_connections
+ #\return
+ def print_graph(self):
+ _libgpac.gf_fs_print_connections(self._sess)
+
+ ##fire an event on the given filter if any, or on any filter accepting user events
+ # \param evt FilterEvent to fire
+ # \param filter Filter to use as target
+ # \param upstream if true, walks the chain towards the sink, otehrwise towards the source
+ #\return
+ def fire_event(self, evt, filter=None, upstream=False):
+ if filter:
+ return _libgpac.gf_fs_fire_event(self._sess, filter._filter, byref(evt), upstream)
+ return _libgpac.gf_fs_fire_event(self._sess, None, byref(evt), upstream)
+
+ ##checks if a given mime is supported - see \ref gf_fs_is_supported_mime
+ # \param mime mime type to check
+ # \return true or false
+ def is_supported_mime(self, mime):
+ return _libgpac.gf_fs_is_supported_mime(self._sess, mime.encode('utf-8'))
+
+ ##checks if a given source URL is supported - see \ref gf_fs_is_supported_source
+ # \param url URL to check
+ # \param parent parent URL for relative URLs
+ # \return true or false
+ def is_supported_source(self, url, parent=None):
+ if parent:
+ return _libgpac.gf_fs_is_supported_source(self._sess, url.encode('utf-8'), parent.encode('utf-8'))
+ return _libgpac.gf_fs_is_supported_source(self._sess, url.encode('utf-8'), None)
+
+
+ ##\cond private: until end, properties
+ @property
+ def last_task(self):
+ if _libgpac.gf_fs_is_last_task(self._sess):
+ return True
+ return False
+
+ @property
+ def nb_filters(self):
+ return _libgpac.gf_fs_get_filters_count(self._sess)
+
+ @property
+ def http_bitrate(self):
+ return _libgpac.gf_fs_get_http_rate(self._sess)
+ 
+ @property
+ def http_max_bitrate(self):
+ return _libgpac.gf_fs_get_http_max_rate(self._sess)
+
+ @http_max_bitrate.setter
+ def http_max_bitrate(self, value):
+ _libgpac.gf_fs_set_http_max_rate(self._sess, value)
+
+ ##\endcond
+
+
+ #TODO
+ #global session: session caps ?
+
+ #missing features available in JSFilterSession API but with no native direct equivalents:
+ #set_new_filter_fun, set_del_filter_fun, set_event_fun
+
+
+
+## \cond private
+#
+# filter bindings
+#
+_libgpac.gf_filter_get_name.argtypes = _gf_filter
+_libgpac.gf_filter_get_name.restype = c_char_p
+_libgpac.gf_filter_get_id.argtypes = _gf_filter
+_libgpac.gf_filter_get_id.restype = c_char_p
+_libgpac.gf_filter_get_ipid_count.argtypes = _gf_filter
+_libgpac.gf_filter_get_opid_count.argtypes = _gf_filter
+
+
+
+_libgpac.gf_filter_get_stats.argtypes = _gf_filter, POINTER(FilterStats)
+_libgpac.gf_filter_remove.argtypes = _gf_filter
+_libgpac.gf_fs_send_update.argtypes = _gf_filter_session, c_char_p, _gf_filter, c_char_p, c_char_p, c_uint
+_libgpac.gf_filter_set_source.argtypes = _gf_filter, _gf_filter, c_char_p
+_libgpac.gf_filter_set_source_restricted.argtypes = _gf_filter, _gf_filter, c_char_p
+_libgpac.gf_filter_reconnect_output.argtypes = _gf_filter, _gf_filter_pid
+
+_libgpac.gf_props_get_id.argtypes = c_char_p
+_libgpac.gf_filter_get_ipid.argtypes = _gf_filter, c_uint
+_libgpac.gf_filter_get_ipid.restype = _gf_filter_pid
+_libgpac.gf_filter_get_opid.argtypes = _gf_filter, c_uint
+_libgpac.gf_filter_get_opid.restype = _gf_filter_pid
+_libgpac.gf_filter_pid_get_property.argtypes = _gf_filter_pid, c_uint
+_libgpac.gf_filter_pid_get_property.restype = POINTER(PropertyValue)
+_libgpac.gf_filter_pid_get_property_str.argtypes = _gf_filter_pid, c_char_p
+_libgpac.gf_filter_pid_get_property_str.restype = POINTER(PropertyValue)
+
+_libgpac.gf_filter_pid_get_info.argtypes = _gf_filter_pid, c_uint, POINTER(POINTER(_gf_property_entry))
+_libgpac.gf_filter_pid_get_info.restype = POINTER(PropertyValue)
+_libgpac.gf_filter_pid_get_info_str.argtypes = _gf_filter_pid, c_char_p, POINTER(POINTER(_gf_property_entry))
+_libgpac.gf_filter_pid_get_info_str.restype = POINTER(PropertyValue)
+_libgpac.gf_filter_release_property.argtypes = POINTER(_gf_property_entry)
+
+_libgpac.gf_filter_pid_get_statistics.argtypes = _gf_filter, POINTER(FilterPidStatistics), c_uint
+
+_libgpac.gf_props_type_is_enum.argtypes = c_uint
+_libgpac.gf_props_type_is_enum.restype = c_int
+
+_libgpac.gf_props_parse_enum.argtypes = c_uint, c_char_p
+_libgpac.gf_props_parse_enum.restype = c_uint
+
+_libgpac.gf_pixel_fmt_name.argtypes = c_uint
+_libgpac.gf_pixel_fmt_name.restype = c_char_p
+
+_libgpac.gf_audio_fmt_name.argtypes = c_uint
+_libgpac.gf_audio_fmt_name.restype = c_char_p
+
+_libgpac.gf_filter_pid_enum_properties.argtypes = _gf_filter_pid, POINTER(c_uint), POINTER(c_uint), POINTER(c_char_p)
+_libgpac.gf_filter_pid_enum_properties.restype = POINTER(PropertyValue)
+
+_libgpac.gf_props_4cc_get_name.argtypes = c_uint
+_libgpac.gf_props_4cc_get_name.restype = c_char_p
+
+_libgpac.gf_stream_type_name.argtypes = c_uint
+_libgpac.gf_stream_type_name.restype = c_char_p
+
+_libgpac.gf_codecid_file_ext.argtypes = c_uint
+_libgpac.gf_codecid_file_ext.restype = c_char_p
+
+_libgpac.gf_filter_pid_get_source_filter.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_source_filter.restype = _gf_filter
+
+_libgpac.gf_filter_pid_enum_destinations.argtypes = _gf_filter_pid, c_uint
+_libgpac.gf_filter_pid_enum_destinations.restype = _gf_filter
+
+_libgpac.gf_filter_enumerate_args.argtypes = _gf_filter, c_uint
+_libgpac.gf_filter_enumerate_args.restype = POINTER(FilterArg)
+
+_libgpac.gf_filter_get_info.argtypes = _gf_filter, c_uint, POINTER(POINTER(_gf_property_entry))
+_libgpac.gf_filter_get_info.restype = POINTER(PropertyValue)
+_libgpac.gf_filter_get_info_str.argtypes = _gf_filter, c_char_p, POINTER(POINTER(_gf_property_entry))
+_libgpac.gf_filter_get_info_str.restype = POINTER(PropertyValue)
+
+_libgpac.gf_filter_require_source_id.argtypes = _gf_filter
+
+_libgpac.gf_filter_bind_dash_algo_callbacks.argtypes = _gf_filter, py_object, c_void_p, c_void_p, c_void_p, c_void_p
+@CFUNCTYPE(c_int, c_void_p, c_uint)
+def dash_period_reset(cbk, reset_type):
+ obj = cast(cbk, py_object).value
+ if hasattr(obj, 'on_period_reset'):
+ obj.on_period_reset(reset_type)
+ if not reset_type:
+ obj.groups = 
+ return 0
+
+class DASHQualityInfoNat(Structure):
+ _fields_ = 
+ ("bandwidth", c_uint),
+ ("ID", c_char_p),
+ ("mime", c_char_p),
+ ("codec", c_char_p),
+ ("width", c_uint),
+ ("height", c_uint),
+ ("interlaced", gf_bool),
+ ("fps_num", c_uint),
+ ("fps_den", c_uint),
+ ("sar_num", c_uint),
+ ("sar_den", c_uint),
+ ("sample_rate", c_uint),
+ ("nb_channels", c_uint),
+ ("disabled", gf_bool),
+ ("is_selected", gf_bool),
+ ("ast_offset", c_double),
+ ("avg_duration", c_double),
+ ("sizes", _gf_list),
+ 
+
+class DASHByteRange(Structure):
+ _fields_ = 
+ ("start", c_ulonglong),
+ ("end", c_ulonglong)
+ 
+
+class DASHSegURL(Structure):
+ _fields_ = 
+ ("media", c_char_p),
+ ("media_range", POINTER(DASHByteRange))
+ #ignore the rest
+ 
+
+
+_libgpac.gf_dash_group_get_num_qualities.argtypes = c_void_p, c_uint
+_libgpac.gf_dash_get_period_duration.argtypes = c_void_p
+_libgpac.gf_dash_group_get_quality_info.argtypes = c_void_p, c_uint, c_uint, POINTER(DASHQualityInfoNat) 
+
+_libgpac.gf_dash_group_get_srd_info.argtypes = c_void_p, c_uint, POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint), POINTER(c_uint) 
+
+_libgpac.gf_list_count.argtypes = c_void_p
+_libgpac.gf_list_count.restype = c_uint
+
+_libgpac.gf_list_get.argtypes = c_void_p, c_uint
+_libgpac.gf_list_get.restype = c_void_p
+
+
+## \endcond
+
+## 
+# \defgroup pydash_grp DASH custom algorithm
+# \ingroup pyapi_grp
+# \brief Python API for libgpac.
+#
+# @{
+
+## DASH media quality information (Representation info)
+class DASHQualityInfo:
+ ## \cond priv
+ def __init__(self, qinfon):
+ ## \endcond
+ ## bandwidth in bits per second
+ self.bandwidth = qinfon.bandwidth
+ ## ID (representation ID in DASH)
+ self.ID = qinfon.ID.decode('utf-8')
+ ## MIME type
+ self.mime = qinfon.mime.decode('utf-8')
+ ## codec parameter string
+ self.codec = qinfon.codec.decode('utf-8')
+ ## width in pixels, 0 if not visual
+ self.width = qinfon.width
+ ## height in pixels, 0 if not visual
+ self.height = qinfon.height
+ ## interlaced flag, false 0 if not visual
+ self.interlaced = qinfon.interlaced
+ ## Frame Rate (Fraction), 0/0 if not visual
+ self.fps = Fraction(qinfon.fps_num, qinfon.fps_den)
+ ## Sample Aspect Ration (Fraction), 0/0 if not visual
+ self.sar = Fraction(qinfon.sar_num, qinfon.sar_den)
+ ## Samplerate, 0 if not audio
+ self.sample_rate = qinfon.sample_rate
+ ## Number of channels, 0 if not audio
+ self.nb_channels = qinfon.nb_channels
+ ## set to true if quality is disabled (no playback support)
+ self.disabled = qinfon.disabled
+ ## set to true if quality is selected
+ self.is_selected = qinfon.is_selected
+ ## AST offset for DASH low latency mode, 0 otherwise
+ self.ast_offset = qinfon.ast_offset
+ ## Average segment duration in seconds, 0 if unknown
+ self.avg_duration = qinfon.avg_duration
+ ## list of segment sizes for VoD cases, None otherwise or if unknown
+ self.sizes = None
+ ## \cond priv
+ if qinfon.sizes == None:
+ return
+ count = _libgpac.gf_list_count(qinfon.sizes)
+ self.sizes = 
+ for i in range(count):
+ surl = cast(_libgpac.gf_list_get(qinfon.sizes, i), POINTER(DASHSegURL)).contents
+ self.sizes.append( surl.media_range.contents.end - surl.media_range.contents.start + 1)
+ ## \endcond priv
+
+##DASH Spatial Relation Descriptor object, used for tiling
+class DASHSRD:
+ ## \cond priv
+ def __init__(self, id, x, y, w, h, fw, fh):
+ ## \endcond
+ ## ID of SRD source - all SRD with same source describe the same video composition, possibly with different grid sizes
+ self.id = id
+ ## X coordinate of SRD for this tile
+ self.x = x
+ ## Y coordinate of SRD for this tile
+ self.y = y
+ ## width of SRD for this tile - 0 for tile base track
+ self.w = w
+ ## height of SRD for this tile - 0 for tile base track
+ self.h = h
+ ## total width of SRD descriptor for this tile
+ self.fw = fw
+ ## total height of SRD descriptor for this tile
+ self.fh = fh
+
+##\cond priv
+def make_srd(dashptr, groupidx):
+ srd_id=c_uint(0)
+ srd_x=c_uint(0)
+ srd_y=c_uint(0)
+ srd_w=c_uint(0)
+ srd_h=c_uint(0)
+ srd_fw=c_uint(0)
+ srd_fh=c_uint(0)
+ _libgpac.gf_dash_group_get_srd_info(dashptr, groupidx, byref(srd_id), byref(srd_x), byref(srd_y), byref(srd_w), byref(srd_h), byref(srd_fw), byref(srd_fh) )
+ if not srd_fw.value or not srd_fh.value:
+ return None
+ return DASHSRD(srd_id.value, srd_x.value, srd_y.value, srd_w.value, srd_h.value, srd_fw.value, srd_fh.value)
+
+##\endcond
+
+## DASH group object
+class DASHGroup:
+ ## \cond priv
+ def __init__(self, ptr_dash, groupidx):
+ ## \endcond
+ ## Index of group, as used in callbacks
+ self.idx = groupidx
+ ## List of DASHQualityInfo for group
+ self.qualities = 
+ ## period duration in milliseconds, 0 if unknown
+ self.duration = _libgpac.gf_dash_get_period_duration(ptr_dash)
+ ## SRD object or None if no SRD defined
+ self.SRD = make_srd(ptr_dash, groupidx)
+ ## \cond priv
+ self._dash = ptr_dash
+ nb_qualities = _libgpac.gf_dash_group_get_num_qualities(ptr_dash, groupidx)
+ for i in range(nb_qualities):
+ qinfo = DASHQualityInfoNat()
+ _libgpac.gf_dash_group_get_quality_info(ptr_dash, groupidx, i, byref(qinfo))
+
+ self.qualities.append( DASHQualityInfo(qinfo) )
+ ## \endcond
+
+## DASH groups statistics object
+class DASHGroupStatistics(Structure):
+ ## \cond priv
+ def __init__(self):
+ ## \endcond
+ ##download rate of last segment in bits per second, divided by current playback speed
+ self.download_rate = 0
+ ##size of last segment in bytes
+ self.filesize = 0
+ ##current playback speed
+ self.speed = 0
+ ##max playback speed based on associated codec runtime statistics
+ self.max_available_speed = 0
+ ##display width in pixels of object
+ self.display_width = 0
+ ##display height in pixels of object
+ self.display_height = 0
+ ##index of current quality or of last downloaded segment quality if previous was skipped
+ self.active_quality_idx = 0
+ ##minimum buffer in milliseconds, below witch rebuffer occurs
+ self.buffer_min = 0
+ ##maximum buffer in milliseconds, algorithm should not fill more than this
+ self.buffer_max = 0
+ ##current buffer in milliseconds
+ self.buffer = 0
+ ##degradation hint, 0 means no degradation, 100 means tile completely hidden
+ self.quality_degradation_hint = 0
+ ##cumulated download rate of all active groups - 0 means all files are local
+ self.total_rate = 0
+
+ ## \cond private
+ _fields_ = 
+ ("download_rate", c_uint),
+ ("filesize", c_uint),
+ ("speed", c_double),
+ ("max_available_speed", c_double),
+ ("display_width", c_uint),
+ ("display_height", c_uint),
+ ("active_quality_idx", c_uint),
+ ("buffer_min", c_uint),
+ ("buffer_max", c_uint),
+ ("buffer", c_uint),
+ ("degradation_hint", c_uint),
+ ("total_rate", c_uint)
+ 
+ def __str__(self):
+ res = 'active_quality_idx ' + str(self.active_quality_idx)
+ res += ' rate ' + str(self.download_rate) + ' speed ' + str(self.speed) + ' max_speed ' + str(self.max_available_speed)
+ res += ' display_width ' + str(self.display_width) + ' display_height ' + str(self.display_height)
+ res += ' buffer_min ' + str(self.buffer_min) + ' buffer_max ' + str(self.buffer_max) + ' buffer ' + str(self.buffer)
+ return res
+ ## \endcond
+
+## DASH group current segment download statistics object
+class DASHGroupDownloadStatistics(Structure):
+ ## \cond priv
+ def __init__(self):
+ ## \endcond
+ ##download rate of last segment in bits per second
+ self.bits_per_sec = 0
+ ##total number of bytes in segment
+ self.total_bytes = 0
+ ##number of downloaded bytes from segment (starting from first byte)
+ self.bytes_done = 0
+ ##number of microseconds elapsed since segment was scheduled for download
+ self.time_since_start = 0
+ ##current buffer length in milliseconds
+ self.buffer_dur = 0
+ ##duration of segment being downloaded, in milliseconds - 0 if unknown
+ self.current_seg_dur = 0
+
+ ## \cond private
+ _fields_ = 
+ ("bits_per_sec", c_uint),
+ ("total_bytes", c_ulonglong),
+ ("bytes_done", c_ulonglong),
+ ("time_since_start", c_ulonglong),
+ ("buffer_dur", c_uint),
+ ("current_seg_dur", c_uint),
+ 
+
+ def __str__(self):
+ res = 'bits_per_sec ' + str(self.bits_per_sec)
+ res += ' - total_bytes ' + str(self.total_bytes) + ' bytes_done ' + str(self.bytes_done)
+ res += ' - time_since_start ' + str(self.time_since_start) + ' us - buffer_dur ' + str(self.buffer_dur) + ' ms - current_seg_dur ' + str(self.current_seg_dur) + ' ms'
+ return res
+ ## \endcond
+
+
+
+## DASH custom algo
+# Upon successful binding to the dashin filter, the object will be assigned a list member called `groups`, containing the declared group for the active period
+class DASHCustomAlgorithm:
+
+ ##Callback (optional) called upon a period reset.
+ #\param reset_type indicate the type of period reset. Values can be:
+ # - 0: end of period (groups are no longer valid)
+ # - 1: start of a static period
+ # - 2: start of a dynamic (live) period
+ #\return 
+ def on_period_reset(self, reset_type):
+ pass
+
+ ##Callback (optional) called when a new group (adaptation set) is created
+ #\param group the newly created \ref DASHGroup
+ #\return 
+ def on_new_group(self, group):
+ pass
+
+
+ ##Callback (mandatory) called at the end of the segment download to perform rate adaptation
+ #\param group the \ref DASHGroup on which to perform adaptation
+ #\param base_group the associated base \ref DASHGroup (tiling only), or None if no base group
+ #\param force_low_complexity indicates that the client would like a lower complexity (typically because it is dropping frames)
+ #\param stats the \ref DASHGroupStatistics for the downloaded segment
+ #\return value can be:
+ # - new quality index,
+ # - -1 to take no decision
+ # - -2 to disable quality (debug, will drop segment)
+ # - other negative values are handled as error
+ def on_rate_adaptation(self, group, base_group, force_low_complexity, stats):
+ pass
+
+ ##Callback (optional) called on regular basis during a segment download
+ #\param group the \ref DASHGroup associated with the current download
+ #\param stats the \ref DASHGroupDownloadStatistics for the download
+ #\return value can be:
+ # - `-1` to continue download
+ # - `-2` to abort download but without retrying to downloading the same segment at lower quality
+ # - the index of the new quality to download for the same segment index (same time)
+ def on_download_monitor(self, group, stats):
+ pass
+
+## @}
+
+
+## \cond priv
+
+
+@CFUNCTYPE(c_int, c_void_p, c_uint, c_void_p)
+def dash_group_new(cbk, groupidx, _dashobj):
+ obj = cast(cbk, py_object).value
+ if not hasattr(obj, 'on_new_group'):
+ return 0
+ new_group = DASHGroup(_dashobj, groupidx)
+ obj.groups.append(new_group)
+ obj.on_new_group(new_group)
+ return 0
+
+
+
+@CFUNCTYPE(c_int, c_void_p, c_uint, c_uint, gf_bool, POINTER(DASHGroupStatistics))
+def dash_rate_adaptation(cbk, groupidx, base_groupidx, force_low_complex, stats):
+ obj = cast(cbk, py_object).value
+ group = None
+ base_group = None
+ for i in range(len(obj.groups)):
+ if obj.groupsi.idx==groupidx:
+ group = obj.groupsi
+ if obj.groupsi.idx==base_groupidx:
+ base_group = obj.groupsi
+
+ return obj.on_rate_adaptation(group, base_group, force_low_complex, stats.contents)
+
+
+@CFUNCTYPE(c_int, c_void_p, c_uint, POINTER(DASHGroupDownloadStatistics))
+def dash_download_monitor(cbk, groupidx, stats):
+ obj = cast(cbk, py_object).value
+ group = None
+ for i in range(len(obj.groups)):
+ if obj.groupsi.idx==groupidx:
+ group = obj.groupsi
+ break
+
+ return obj.on_download_monitor(group, stats.contents)
+
+
+def _prop_to_python(pname, prop):
+ type = prop.type
+
+ if type==GF_PROP_SINT:
+ return prop.value.sint
+ if type==GF_PROP_UINT:
+ if pname=="StreamType":
+ return _libgpac.gf_stream_type_name(prop.value.uint).decode('utf-8')
+ if pname=="PixelFormat":
+ return _libgpac.gf_pixel_fmt_sname(prop.value.uint).decode('utf-8')
+ if pname=="CodecID":
+ cid = _libgpac.gf_codecid_file_ext(prop.value.uint).decode('utf-8')
+ names=cid.split('|')
+ return names0
+ return prop.value.uint
+
+ if _libgpac.gf_props_type_is_enum(type):
+ pname = _libgpac.gf_props_enum_name(type, prop.value.uint)
+ return pname.decode('utf-8')
+
+ if type==GF_PROP_4CC:
+ return _libgpac.gf_4cc_to_str(prop.value.uint).decode('utf-8')
+ if type==GF_PROP_LSINT:
+ return prop.value.longsint
+ if type==GF_PROP_LUINT:
+ return prop.value.longuint
+ if type==GF_PROP_BOOL:
+ return prop.value.boolean
+ if type==GF_PROP_FRACTION:
+ return prop.value.frac
+ if type==GF_PROP_FRACTION64:
+ return prop.value.lfrac
+ if type==GF_PROP_FLOAT:
+ return prop.value.fnumber
+ if type==GF_PROP_DOUBLE:
+ return prop.value.number
+ if type==GF_PROP_VEC2I:
+ return prop.value.vec2i
+ if type==GF_PROP_VEC2:
+ return prop.value.vec2
+ if type==GF_PROP_VEC3I:
+ return prop.value.vec3i
+ if type==GF_PROP_VEC4I:
+ return prop.value.vec4i
+ if type==GF_PROP_STRING or type==GF_PROP_STRING_NO_COPY or type==GF_PROP_NAME:
+ return prop.value.string.decode('utf-8')
+ if type==GF_PROP_DATA or type==GF_PROP_DATA_NO_COPY or type==GF_PROP_CONST_DATA:
+ return prop.value.data
+ if type==GF_PROP_POINTER:
+ return prop.value.ptr
+ if type==GF_PROP_STRING_LIST:
+ res = 
+ for i in range(prop.value.string_list.nb_items):
+ val = prop.value.string_list.valsi.decode('utf-8')
+ res.append(val)
+ return res
+ if type==GF_PROP_UINT_LIST:
+ res = 
+ for i in range(prop.value.uint_list.nb_items):
+ val = prop.value.uint_list.valsi
+ res.append(val)
+ return res
+ if type==GF_PROP_4CC_LIST:
+ res = 
+ for i in range(prop.value.uint_list.nb_items):
+ val = _libgpac.gf_4cc_to_str(prop.value.uint).decode('utf-8')
+ res.append(val)
+ return res
+ if type==GF_PROP_SINT_LIST:
+ res = 
+ for i in range(prop.value.uint_list.nb_items):
+ val = prop.value.sint_list.valsi
+ res.append(val)
+ return res
+ if type==GF_PROP_VEC2I_LIST:
+ res = 
+ for i in range(prop.value.v2i_list.nb_items):
+ val = prop.value.v2i_list.valsi
+ res.append(val)
+ return res
+
+ raise Exception('Unknown property type ' + str(type))
+
+## \endcond
+
+
+## filter object
+class Filter:
+ ## \cond private
+ def __init__(self, session, filter):
+ self._filter = filter
+ self._session = session
+ ## \endcond
+ #hack for doxygen to generate member vars (not support for parsing @property)
+ if 0:
+ ##name of the filter, readonly - see \ref gf_filter_get_name
+ #\hideinitializer
+ self.name=0
+ ##ID of the filter, readonly - see \ref gf_filter_get_id
+ #\hideinitializer
+ self.ID=0
+ ##number of input pids for that filter, readonly - see \ref gf_filter_get_ipid_count
+ #\hideinitializer
+ self.nb_ipid=0
+ ##number of output pids for that filter, readonly - see \ref gf_filter_get_opid_count
+ #\hideinitializer
+ self.nb_opid=0
+
+
+ ## \cond private
+ def __str__(self):
+ return self.name
+ ## \endcond
+
+ ## remove this filter - see \ref gf_filter_remove
+ #\return
+ def remove(self):
+ _libgpac.gf_filter_remove(self._filter)
+
+ ## send option update to this filter - see \ref gf_fs_send_update
+ #\param name name of option (string)
+ #\param value value of option (string)
+	#\param propagate_mask flags indicating if updates must be send to up-chain filters (2), down-chain filters (1), both (3) or only on filter (0)
+ #\return
+ def update(self, name, value, propagate_mask=0):
+ _libgpac.gf_fs_send_update(None, None, self._filter, name.encode('utf-8'), value.encode('utf-8'), propagate_mask)
+
+ ## set a given filter as source for this filter - see \ref gf_filter_set_source
+ #
+ #\note Setting a source will force the filter session linker to run in explicit linking mode.
+ #\param f source Filter
+ #\param link_args link options (string)
+ #\return
+ def set_source(self, f, link_args=None):
+ if f:
+ _libgpac.gf_filter_set_source(self._filter, f._filter, link_args)
+
+ ## set a given filter as restricted source for this filter - see \ref gf_filter_set_source_restricted
+ #\param f source Filter
+ #\param link_args link options (string)
+ #\return
+ def set_source_restricted(self, f, link_args=None):
+ if f:
+ _libgpac.gf_filter_set_source_restricted(self._filter, f._filter, link_args)
+
+
+ ## insert a given filter after this filter - see \ref gf_filter_set_source and \ref gf_filter_reconnect_output
+ #\param f Filter to insert
+ #\param opid index of output pid to reconnect, -1 for all pids
+ #\param link_args link options (string)
+ #\return
+ def insert(self, f, opid=-1, link_args=None):
+ if f:
+ _libgpac.gf_filter_set_source(f._filter, self._filter, link_args)
+ pid = None
+ if opid>=0:
+ pid = _libgpac.gf_filter_get_opid(self._filter, opid)
+ if not pid:
+ raise Exception('No output PID with index ' + str(opid) + ' in filter ' + self.name )
+ err = _libgpac.gf_filter_reconnect_output(f._filter, pid)
+ if err<0:
+ raise Exception('Failed to reconnect output: ' + e2s(err))
+
+ ## \cond private
+ def _pid_prop_ex(self, prop_name, pid, IsInfo):
+ _name = prop_name.encode('utf-8')
+ p4cc = _libgpac.gf_props_get_id(_name)
+ if IsInfo:
+ pe = POINTER(_gf_property_entry)()
+ if p4cc:
+ prop = _libgpac.gf_filter_pid_get_info(pid, p4cc, byref(pe))
+ else:
+ prop = _libgpac.gf_filter_pid_get_info_str(pid, _name, byref(pe))
+ if prop:
+ res = _prop_to_python(prop_name, prop.contents)
+ _libgpac.gf_filter_release_property(pe)
+ return res
+ return None
+
+ if p4cc:
+ prop = _libgpac.gf_filter_pid_get_property(pid, p4cc)
+ else:
+ prop = _libgpac.gf_filter_pid_get_property_str(pid, _name)
+ if prop:
+ return _prop_to_python(prop_name, prop.contents)
+ return None
+
+ def _pid_prop(self, idx, prop_name, IsInput):
+ if IsInput:
+ pid = _libgpac.gf_filter_get_ipid(self._filter, idx)
+ else:
+ pid = _libgpac.gf_filter_get_opid(self._filter, idx)
+ if not pid:
+ raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
+ return self._pid_prop_ex(self, prop_name, pid, False)
+
+ def _pid_enum_props_ex(self, callback_obj, _pid):
+ if hasattr(callback_obj, 'on_prop_enum')==False:
+ raise Exception('No on_prop_enum function on callback')
+
+ pidx=c_uint(0)
+ while True:
+ _p4cc=c_uint(0)
+ _pname=c_char_p(0)
+ prop = _libgpac.gf_filter_pid_enum_properties(_pid, byref(pidx), byref(_p4cc), byref(_pname))
+ if prop:
+ p4cc=_p4cc.value
+ pname=None
+ if _pname:
+ pname=_pname.value.decode('utf-8')
+ else:
+ pname=_libgpac.gf_props_4cc_get_name(p4cc).decode('utf-8')
+ pval = _prop_to_python(pname, prop.contents)
+ callback_obj.on_prop_enum(pname, pval)
+ else:
+ break
+
+ def _pid_enum_props(self, idx, callback_obj, IsInput):
+ if IsInput:
+ pid = _libgpac.gf_filter_get_ipid(self._filter, idx)
+ else:
+ pid = _libgpac.gf_filter_get_opid(self._filter, idx)
+
+ if not pid:
+ raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
+
+ self._pid_enum_props_ex(callback_obj, pid)
+
+ ## \endcond 
+
+ ##get an input pid property by name
+ #\param idx index of input pid
+ #\param prop_name name of property
+ #\return property value or None if not found
+ def ipid_prop(self, idx, prop_name):
+ return self._pid_prop(idx, prop_name, True)
+ ##enumerate an input pid properties
+ #\param idx index of input pid
+ #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval(property value)
+ #\return
+ def ipid_enum_props(self, idx, callback_obj):
+ self._pid_enum_props(idx, callback_obj, True)
+ ##get an output pid property by name
+ #\param idx index of output pid
+ #\param prop_name name of property
+ #\return property value or None if not found
+ def opid_prop(self, idx, prop_name):
+ return self._pid_prop(idx, prop_name, False)
+ ##enumerate an output pid properties
+ #\param idx index of output pid
+ #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval(property value)
+ #\return
+ def opid_enum_props(self, idx, callback_obj):
+ self._pid_enum_props(idx, callback_obj, False)
+
+ ##Gets the statistics of an input pid of filter - see \ref gf_filter_pid_get_statistics
+ #\param idx index of input pid
+ #\param mode search mode for stats cf \ref GF_FilterPidStatsLocation
+ #\return FilterPidStatistics object
+ def ipid_stats(self, idx, mode=0):
+ pid = _libgpac.gf_filter_get_ipid(self._filter, idx)
+ if not pid:
+ raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
+ stats = FilterPidStatistics()
+ err = _libgpac.gf_filter_pid_get_statistics(pid, byref(stats), mode)
+ if err<0:
+ raise Exception('Failed to fetch filter pid stats: ' + e2s(err))
+ return stats
+
+ ##Gets the statistics of an output pid of filter - see \ref gf_filter_pid_get_statistics
+ #\param idx index of output pid
+ #\param mode search mode for stats cf \ref GF_FilterPidStatsLocation
+ #\return FilterPidStatistics object
+ def opid_stats(self, idx, mode=0):
+ pid = _libgpac.gf_filter_get_opid(self._filter, idx)
+ if not pid:
+ raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
+ stats = FilterPidStatistics()
+ err = _libgpac.gf_filter_pid_get_statistics(pid, byref(stats), mode)
+ if err<0:
+ raise Exception('Failed to fetch filter pid stats: ' + e2s(err))
+ return stats
+
+ ##gets the filter at the source of an input pid
+ #\param idx index of input PID
+ #\return Filter or None if error
+ def ipid_source(self, idx):
+ pid = _libgpac.gf_filter_get_ipid(self._filter, idx)
+ if not pid:
+ raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
+ f = _libgpac.gf_filter_pid_get_source_filter(pid)
+ if not f:
+ return None
+ return self._session._to_filter(f)
+
+ ##gets the list of destination filters of an output pid
+ #\param idx index of output PID
+ #\return list of Filter
+ def opid_sinks(self, idx):
+ pid = _libgpac.gf_filter_get_opid(self._filter, idx)
+ if not pid:
+ raise Exception('No PID with index ' + str(idx) + ' in filter ' + self.name )
+ res=
+ f_idx=0
+ while True:
+ f = _libgpac.gf_filter_pid_enum_destinations(pid, f_idx)
+ f_idx+=1 
+ if f==None:
+ break
+ filter = self._session._to_filter(f)
+ res.append(filter)
+ return res
+
+ ##gets all defined options / arguments for a filter
+ #\return list of FilterArg
+ def all_args(self):
+ res=
+ a_idx=0
+ while True:
+ arg = _libgpac.gf_filter_enumerate_args(self._filter, a_idx)
+ if arg:
+ arg_val = arg.contents
+ res.append(arg_val)
+ else:
+ break
+ a_idx+=1
+ return res
+
+ ##gets a property info on a filter - see \ref gf_filter_get_info and \ref gf_filter_get_info_str
+ #\param prop_name property to query
+ #\return property value or None if not found
+ def get_info(self, prop_name):
+ _name = prop_name.encode('utf-8')
+ p4cc = _libgpac.gf_props_get_id(_name)
+ pe = POINTER(_gf_property_entry)()
+ if p4cc:
+ prop = _libgpac.gf_filter_get_info(self._filter, p4cc, byref(pe))
+ else:
+ prop = _libgpac.gf_filter_get_info_str(self._filter, _name, byref(pe))
+ if prop:
+ res = _prop_to_python(prop_name, prop.contents)
+ _libgpac.gf_filter_release_property(pe)
+ return res
+ return None
+
+ ##Gets the statistics of a filter - see \ref gf_filter_get_stats
+ #\return FilterStats object
+ def get_statistics(self):
+ stats = FilterStats()
+ err = _libgpac.gf_filter_get_stats(self._filter, byref(stats))
+ if err<0: 
+ raise Exception('Failed to fetch filter stats: ' + e2s(err))
+ return stats
+
+ ##enforces sourceID to be present for output pids of this filter - see \ref gf_filter_require_source_id
+ #\return
+ def require_source_id(self):
+ err = _libgpac.gf_filter_require_source_id(self._filter)
+ if err<0:
+ raise Exception('Failed to require sourceID for filter: ' + e2s(err))
+ return
+
+ ##\cond private
+ def _bind_dash_algo(self, object):
+ if not hasattr(object, 'on_rate_adaptation'):
+ raise Exception('Missing on_rate_adaptation member function on object, cannot bind')
+ object.groups = 
+ if hasattr(object, 'on_download_monitor'):
+ err = _libgpac.gf_filter_bind_dash_algo_callbacks(self._filter, py_object(object), dash_period_reset, dash_group_new, dash_rate_adaptation, dash_download_monitor)
+ else:
+ err = _libgpac.gf_filter_bind_dash_algo_callbacks(self._filter, py_object(object), dash_period_reset, dash_group_new, dash_rate_adaptation, None)
+ if err<0: 
+ raise Exception('Failed to bind dash algo: ' + e2s(err))
+ return 0
+ ##\endcond private
+
+
+ ## \brief binds a given object to the filter
+ #
+ #Binds the given object to the underlying filter for callbacks override - only supported by DASH demuxer for the current time
+ #
+ #For DASH, the object must derive from or implement the methods of the \ref DASHCustomAlgorithm class:
+ #
+ #\param object object to bind
+ #\return
+ def bind(self, object):
+ if self.name=="dashin":
+ return self._bind_dash_algo(object)
+ raise Exception('No possible binding to filter class ' + self.name)
+
+ ##\cond private: until end, properties
+
+ @property
+ def name(self):
+ return _libgpac.gf_filter_get_name(self._filter).decode('utf-8')
+
+ @property
+ def ID(self):
+ return _libgpac.gf_filter_get_id(self._filter).decode('utf-8')
+
+ @property
+ def nb_ipid(self):
+ return _libgpac.gf_filter_get_ipid_count(self._filter)
+
+ @property
+ def nb_opid(self):
+ return _libgpac.gf_filter_get_opid_count(self._filter)
+
+ ##\endcond 
+
+
+
+##\cond private
+
+#
+# custom filter bindings
+#
+
+_libgpac.gf_filter_push_caps.argtypes = _gf_filter, c_uint, POINTER(PropertyValue), c_char_p, c_uint, c_uint
+_libgpac.gf_props_4cc_get_type.argtypes = c_uint
+_libgpac.gf_stream_type_by_name.argtypes = c_char_p
+_libgpac.gf_stream_type_by_name.restype = c_uint
+
+_libgpac.gf_codecid_parse.argtypes = c_char_p
+_libgpac.gf_codecid_parse.restype = c_uint
+
+_libgpac.gf_pixel_fmt_parse.argtypes = c_char_p
+_libgpac.gf_pixel_fmt_parse.restype = c_uint
+
+_libgpac.gf_audio_fmt_parse.argtypes = c_char_p
+_libgpac.gf_audio_fmt_parse.restype = c_uint
+
+_libgpac.gf_cicp_color_primaries_name.argtypes = c_uint
+_libgpac.gf_cicp_color_primaries_name.restype = c_char_p
+_libgpac.gf_cicp_color_transfer_name.argtypes = c_uint
+_libgpac.gf_cicp_color_transfer_name.restype = c_char_p
+_libgpac.gf_cicp_color_matrix_name.argtypes = c_uint
+_libgpac.gf_cicp_color_matrix_name.restype = c_char_p
+
+_libgpac.gf_cicp_parse_color_primaries.argtypes = c_char_p
+_libgpac.gf_cicp_parse_color_primaries.restype = c_uint
+_libgpac.gf_cicp_parse_color_transfer.argtypes = c_char_p
+_libgpac.gf_cicp_parse_color_transfer.restype = c_uint
+_libgpac.gf_cicp_parse_color_matrix.argtypes = c_char_p
+_libgpac.gf_cicp_parse_color_matrix.restype = c_uint
+
+
+
+def _make_prop(prop4cc, propname, prop, custom_type=0):
+ prop_val = PropertyValue()
+ if prop4cc==0:
+ if not custom_type:
+ prop_val.type = GF_PROP_STRING
+ prop_val.value.string = str(prop).encode('utf-8')
+ return prop_val
+ type = custom_type
+ else:
+ type = _libgpac.gf_props_4cc_get_type(prop4cc)
+
+ prop_val.type = type
+ if propname=="StreamType":
+ prop_val.value.uint = _libgpac.gf_stream_type_by_name(prop.encode('utf-8'))
+ return prop_val
+ elif propname=="CodecID":
+ prop_val.value.uint = _libgpac.gf_codecid_parse(prop.encode('utf-8'))
+ return prop_val
+
+ if type==GF_PROP_SINT:
+ prop_val.value.sint = prop
+ elif type==GF_PROP_UINT:
+ prop_val.value.uint = prop
+ elif type==GF_PROP_4CC:
+ prop_val.value.uint = _libgpac.gf_4cc_parse(prop.encode('utf-8'))
+ elif type==GF_PROP_LSINT:
+ prop_val.value.longsint = prop
+ elif type==GF_PROP_LUINT:
+ prop_val.value.longuint = prop
+ elif type==GF_PROP_BOOL:
+ prop_val.value.boolean = prop
+ elif type==GF_PROP_FRACTION:
+ if hasattr(prop, 'den') and hasattr(prop, 'num'):
+ prop_val.value.frac.num = prop.num
+ prop_val.value.frac.den = prop.den
+ elif is_integer(prop):
+ prop_val.value.frac.num = prop
+ prop_val.value.frac.den = 1
+ else:
+ prop_val.value.frac.num = 1000*prop
+ prop_val.value.frac.den = 1000
+ elif type==GF_PROP_FRACTION64:
+ if hasattr(prop, 'den') and hasattr(prop, 'num'):
+ prop_val.value.lfrac.num = prop.num
+ prop_val.value.lfrac.den = prop.den
+ elif is_integer(prop):
+ prop_val.value.lfrac.num = prop
+ prop_val.value.lfrac.den = 1
+ else:
+ prop_val.value.lfrac.num = 1000000*prop
+ prop_val.value.lfrac.den = 1000000
+ elif type==GF_PROP_FLOAT:
+ prop_val.value.fnumber = prop
+ elif type==GF_PROP_DOUBLE:
+ prop_val.value.number = prop
+ elif type==GF_PROP_VEC2I:
+ if hasattr(prop, 'x') and hasattr(prop, 'y'):
+ prop_val.value.vec2i.x = prop.x
+ prop_val.value.vec2i.y = prop.y
+ else:
+ raise Exception('Invalid property value for vec2i: ' + str(prop))
+ elif type==GF_PROP_VEC2:
+ if hasattr(prop, 'x') and hasattr(prop, 'y'):
+ prop_val.value.vec2.x = prop.x
+ prop_val.value.vec2.y = prop.y
+ else:
+ raise Exception('Invalid property value for vec2: ' + str(prop))
+ elif type==GF_PROP_VEC3I:
+ if hasattr(prop, 'x') and hasattr(prop, 'y') and hasattr(prop, 'z'):
+ prop_val.value.vec3i.x = prop.x
+ prop_val.value.vec3i.y = prop.y
+ prop_val.value.vec3i.z = prop.z
+ else:
+ raise Exception('Invalid property value for vec3i: ' + str(prop))
+ elif type==GF_PROP_VEC4I:
+ if hasattr(prop, 'x') and hasattr(prop, 'y') and hasattr(prop, 'z') and hasattr(prop, 'w'):
+ prop_val.value.vec4i.x = prop.x
+ prop_val.value.vec4i.y = prop.y
+ prop_val.value.vec4i.z = prop.z
+ prop_val.value.vec4i.w = prop.w
+ else:
+ raise Exception('Invalid property value for vec4i: ' + str(prop))
+ elif type==GF_PROP_STRING or type==GF_PROP_STRING_NO_COPY or type==GF_PROP_NAME:
+ prop_val.value.string = str(prop).encode('utf-8')
+ elif type==GF_PROP_DATA or type==GF_PROP_DATA_NO_COPY or type==GF_PROP_CONST_DATA:
+ raise Exception('Setting data property from python not yet implemented !')
+ elif type==GF_PROP_POINTER:
+ raise Exception('Setting pointer property from python not yet implemented !')
+ elif type==GF_PROP_STRING_LIST:
+ if isinstance(prop, list)==False:
+ raise Exception('Property is not a list')
+ prop_val.value.string_list.nb_items = len(prop)
+ prop_val.value.string_list.vals = (ctypes.c_char_p * len(prop))
+ i=0
+ for str in list:
+ prop_val.value.string_list.valsi = str.encode('utf-8')
+ i+=1
+ elif type==GF_PROP_UINT_LIST:
+ if isinstance(prop, list)==False:
+ raise Exception('Property is not a list')
+ prop_val.value.uint_list.nb_items = len(prop)
+ prop_val.value.uint_list.vals = (ctypes.c_uint * len(prop))(*prop)
+ elif type==GF_PROP_4CC_LIST:
+ if isinstance(prop, list)==False:
+ raise Exception('Property is not a list')
+ prop_val.value.uint_list.nb_items = len(prop)
+ prop_val.value.uint_list.vals = (ctypes.c_uint * len(prop))
+ i=0
+ for str in list:
+ prop_val.value.uint_list.valsi = _libgpac.gf_4cc_parse( str.encode('utf-8') )
+ i+=1
+ elif type==GF_PROP_SINT_LIST:
+ if isinstance(prop, list)==False:
+ raise Exception('Property is not a list')
+ prop_val.value.sint_list.nb_items = len(prop)
+ prop_val.value.sint_list.vals = (ctypes.c_int * len(prop))(*prop)
+ elif type==GF_PROP_VEC2I_LIST:
+ if isinstance(prop, list)==False:
+ raise Exception('Property is not a list')
+ prop_val.value.sint_list.nb_items = len(prop)
+ prop_val.value.v2i_list.vals = (GF_PropVec2i * len(prop))
+ for i in range (len(prop)):
+ prop_val.value.v2i_list.valsi.x = propi.x
+ prop_val.value.v2i_list.valsi.y = propi.y
+
+ elif _libgpac.gf_props_type_is_enum(type):
+ prop_val.value.uint = _libgpac.gf_props_parse_enum(type, prop.encode('utf-8'))
+ return prop_val
+ else:
+ raise Exception('Unsupported property type ' + str(type) )
+
+ return prop_val
+
+
+_libgpac.gf_filter_set_rt_udta.argtypes = _gf_filter, py_object
+_libgpac.gf_filter_get_rt_udta.argtypes = _gf_filter
+_libgpac.gf_filter_get_rt_udta.restype = c_void_p
+
+_libgpac.gf_filter_pid_set_udta.argtypes = _gf_filter, py_object
+_libgpac.gf_filter_pid_get_udta.argtypes = _gf_filter
+_libgpac.gf_filter_pid_get_udta.restype = c_void_p
+
+_libgpac.gf_filter_pid_send_event.argtypes = _gf_filter_pid, POINTER(FilterEvent)
+
+
+_libgpac.gf_filter_set_configure_ckb.argtypes = _gf_filter, c_void_p
+@CFUNCTYPE(c_int, _gf_filter, _gf_filter_pid, gf_bool)
+def filter_cbk_configure(_f, _pid, is_remove):
+ obj = _libgpac.gf_filter_get_rt_udta(_f)
+ filter = cast(obj, py_object).value
+ obj = _libgpac.gf_filter_pid_get_udta(_pid)
+ if obj:
+ pid_obj = cast(obj, py_object).value
+ else:
+ pid_obj=None
+
+ first=True
+ if pid_obj:
+ first=False
+ else:
+ pid_obj = FilterPid(filter, _pid, True)
+ _libgpac.gf_filter_pid_set_udta(_pid, py_object(pid_obj))
+ res = filter.configure_pid(pid_obj, is_remove)
+
+ if is_remove:
+ _libgpac.gf_filter_pid_set_udta(_pid, None)
+ filter.ipids.remove(pid_obj)
+ return
+
+ if first:
+ filter.ipids.append(pid_obj)
+
+ return res
+
+
+_libgpac.gf_filter_set_process_ckb.argtypes = _gf_filter, c_void_p
+@CFUNCTYPE(c_int, _gf_filter)
+def filter_cbk_process(_f):
+ obj = _libgpac.gf_filter_get_rt_udta(_f)
+ filter = cast(obj, py_object).value
+ return filter.process()
+
+_libgpac.gf_filter_set_process_event_ckb.argtypes = _gf_filter, c_void_p
+@CFUNCTYPE(c_int, _gf_filter, POINTER(FilterEvent) )
+def filter_cbk_process_event(_f, _evt):
+ obj = _libgpac.gf_filter_get_rt_udta(_f)
+ filter = cast(obj, py_object).value
+ res = filter.process_event(_evt.contents)
+ if res:
+ return 1
+ return 0
+
+_libgpac.gf_filter_set_probe_data_cbk.argtypes = _gf_filter, c_void_p
+@CFUNCTYPE(c_int, POINTER(c_ubyte), c_uint, POINTER(c_uint) )
+def filter_cbk_probe_data(_data, _size, _probe):
+ obj = _libgpac.gf_filter_get_rt_udta(_f)
+ filter = cast(obj, py_object).value
+ if numpy_support:
+ ar_data = np.ctypeslib.as_array(_data, (_size,))
+ ar_data.flags.writeable=False
+ res = filter.probe_data(ar_data, _size)
+ else:
+ res = filter.probe_data(_data, _size)
+ if res==None:
+ _probe.contents=0
+ return None
+ _probe.contents=2 #GF_FPROBE_MAYBE_SUPPORTED
+ return res.encode('utf-8')
+
+
+_libgpac.gf_filter_set_reconfigure_output_ckb.argtypes = _gf_filter, c_void_p
+@CFUNCTYPE(c_int, _gf_filter, _gf_filter_pid )
+def filter_cbk_reconfigure_output(_f, _pid):
+ obj = _libgpac.gf_filter_get_rt_udta(_f)
+ filter = cast(obj, py_object).value
+ obj = _libgpac.gf_filter_pid_get_udta(_pid)
+ if obj:
+ pid_obj = cast(obj, py_object).value
+ else:
+ pid_obj=None
+ if pid_obj:
+ return filter.reconfigure_output(_f)
+ raise Exception('Reconfigure on unknown output pid !')
+
+
+_libgpac.gf_filter_pid_get_packet.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_packet.restype = _gf_filter_packet
+
+_libgpac.gf_filter_pid_drop_packet.argtypes = _gf_filter_pid
+
+_libgpac.gf_filter_pid_new.argtypes = _gf_filter
+_libgpac.gf_filter_pid_new.restype = _gf_filter_pid
+
+_libgpac.gf_filter_update_status.argtypes = _gf_filter, c_uint, c_char_p
+
+_libgpac.gf_filter_ask_rt_reschedule.argtypes = _gf_filter
+_libgpac.gf_filter_post_process_task.argtypes = _gf_filter
+
+
+_libgpac.gf_filter_ask_rt_reschedule.argtypes = _gf_filter, c_int, gf_bool
+_libgpac.gf_filter_setup_failure.argtypes = _gf_filter, c_int
+_libgpac.gf_filter_make_sticky.argtypes = _gf_filter
+_libgpac.gf_filter_prevent_blocking.argtypes = _gf_filter, gf_bool
+_libgpac.gf_filter_block_eos.argtypes = _gf_filter, gf_bool
+_libgpac.gf_filter_set_max_extra_input_pids.argtypes = _gf_filter, c_uint
+_libgpac.gf_filter_block_enabled.argtypes = _gf_filter
+_libgpac.gf_filter_block_enabled.restype = gf_bool
+_libgpac.gf_filter_get_output_buffer_max.argtypes = _gf_filter, POINTER(c_uint), POINTER(c_uint)
+_libgpac.gf_filter_all_sinks_done.argtypes = _gf_filter
+_libgpac.gf_filter_all_sinks_done.restype = gf_bool
+_libgpac.gf_filter_get_num_events_queued.argtypes = _gf_filter
+
+_libgpac.gf_filter_get_clock_hint.argtypes = _gf_filter, POINTER(c_ulonglong), POINTER(Fraction64)
+_libgpac.gf_filter_connections_pending.argtypes = _gf_filter
+_libgpac.gf_filter_connections_pending.restype = gf_bool
+_libgpac.gf_filter_hint_single_clock.argtypes = _gf_filter, c_ulonglong, Fraction64
+
+GF_FS_REG_MAIN_THREAD=1<<1
+
+##\endcond
+
+## Base class used to create custom filters in python
+class FilterCustom(Filter):
+
+ ##constructor, see \ref gf_fs_new_filter
+ #\param session FilterSession object
+ #\param fname name of the filter
+ #\param flags flags for the filter
+ def __init__(self, session, fname="Custom", flags=0):
+ errp = c_int(0)
+ _filter = _libgpac.gf_fs_new_filter(session._sess, fname.encode('utf-8'), flags | GF_FS_REG_MAIN_THREAD, byref(errp))
+ err = errp.value
+ if err<0: 
+ raise Exception('Failed to create filter ' + URL + ': ' + e2s(err))
+ #create base class
+ Filter.__init__(self, session, _filter)
+ #register with our filter bank
+ session._filters.append(self)
+
+ #setup callback udta and callback functions
+ _libgpac.gf_filter_set_rt_udta(_filter, py_object(self) )
+ if hasattr(self, 'configure_pid'):
+ _libgpac.gf_filter_set_configure_ckb(self._filter, filter_cbk_configure)
+
+ if hasattr(self, 'process'):
+ _libgpac.gf_filter_set_process_ckb(self._filter, filter_cbk_process)
+
+ if hasattr(self, 'process_event'):
+ _libgpac.gf_filter_set_process_event_ckb(self._filter, filter_cbk_process_event)
+
+ if hasattr(self, 'probe_data'):
+ _libgpac.gf_filter_set_probe_data_ckb(self._filter, filter_cbk_probe_data)
+
+ if hasattr(self, 'reconfigure_output'):
+ _libgpac.gf_filter_set_reconfigure_output_ckb(self._filter, filter_cbk_reconfigure_output)
+
+ ##List of input FilterPid
+ self.ipids=
+ ##List of output FilterPid
+ self.opids=
+
+ #hack for doxygen to generate member vars (not support for parsing @property)
+ if 0:
+ ##filter blocking is enabled, readonly - see \ref gf_filter_block_enabled
+ #\hideinitializer
+ self.block_enabled=0
+ ##maximum output buffer time, readonly - see \ref gf_filter_get_output_buffer_max
+ #\hideinitializer
+ self.output_buffer=0
+ ##maximum plyaout buffer time, readonly - see \ref gf_filter_get_output_buffer_max
+ #\hideinitializer
+ self.playout_buffer=0
+ ##all sinks are done for this filter, readonly - see \ref gf_filter_all_sinks_done
+ #\hideinitializer
+ self.sinks_done=0
+ ##number of queued events on the filter, readonly - see \ref gf_filter_get_num_events_queued
+ #\hideinitializer
+ self.nb_evts_queued=0
+ ##clock hint value in microseconds, readonly - see \ref gf_filter_get_clock_hint
+ #\hideinitializer
+ self.clock_hint_time=0
+ ##clock hint media time as Fraction64, readonly - see \ref gf_filter_get_clock_hint
+ #\hideinitializer
+ self.clock_hint_mediatime=0
+ ##boolean indicating connections are pending on the filter, readonly - see \ref gf_filter_connections_pending
+ #\hideinitializer
+ self.connections_pending=0
+
+
+
+ ##push a capability in the current capability bundle - see \ref gf_filter_push_caps
+ #\param pcode capability name (property type)
+ #\param prop capability value
+ #\param flag capability flags (input, output, etc)
+ #\param priority capability priority
+ #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
+ #\return
+ def push_cap(self, pcode, prop, flag, priority=0, custom_type=0):
+ prop_4cc = pcode
+ prop_name = None
+ if isinstance(pcode, str):
+ _pname = pcode.encode('utf-8')
+ prop_4cc = _libgpac.gf_props_get_id(_pname)
+ if prop_4cc==0:
+ prop_name = _pname
+
+ prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
+ err = _libgpac.gf_filter_push_caps(self._filter, prop_4cc, byref(prop_val), prop_name, flag, priority)
+ if err<0: 
+ raise Exception('Failed to push cap: ' + e2s(err))
+
+ ##create a new output pid for this filter - see \ref gf_filter_pid_new
+ #\return FilterPid object
+ def new_pid(self):
+ _pid = _libgpac.gf_filter_pid_new(self._filter)
+ if _pid:
+ pid_obj = FilterPid(self, _pid, False)
+ _libgpac.gf_filter_pid_set_udta(_pid, py_object(pid_obj))
+ self.opids.append(pid_obj)
+ pid_obj.pck_refs = 
+ return pid_obj
+ raise Exception('Failed to create output pid')
+
+ ##update filter status - see \ref gf_filter_update_status
+ #\param status status string
+ #\param percent progress in per 10000, int
+ #\return
+ def update_status(self, status, percent):
+ _libgpac.gf_filter_update_status(self._filter, percent, status.encode('utf-8'))
+
+ ##reschedule the filter after a given delay - see \ref gf_filter_ask_rt_reschedule and \ref gf_filter_post_process_task
+ #\param when delay in microseconds
+ #\return
+ def reschedule(self, when=0):
+ if when:
+ _libgpac.gf_filter_ask_rt_reschedule(self._filter, when)
+ else:
+ _libgpac.gf_filter_post_process_task(self._filter)
+
+ ##notify an internal failure of the filter has happend - see \ref gf_filter_notification_failure and \ref gf_filter_setup_failure
+ #\param err the failure reason (gpac error code, int)
+ #\param error_type the failure notification type
+ #\return
+ def notify_failure(self, err, error_type=GF_SETUP_ERROR):
+ if error_type==GF_NOTIF_ERROR:
+ _libgpac.gf_filter_notification_failure(self._filter, err, False)
+ elif error_type==GF_NOTIF_ERROR_AND_DISCONNECT:
+ _libgpac.gf_filter_notification_failure(self._filter, err, True)
+ else:
+ _libgpac.gf_filter_setup_failure(self._filter, err)
+
+ ##make the filter sticky - see \ref gf_filter_make_sticky
+ #\return
+ def make_sticky(self):
+ _libgpac.gf_filter_make_sticky(self._filter)
+
+ ##prevent blocking on the filter - see \ref gf_filter_prevent_blocking
+ #\param enable if True, blocking prevention is enabled
+ #\return
+ def prevent_blocking(self, enable):
+ _libgpac.gf_filter_prevent_blocking(self._filter, enable)
+
+ ##block eos signaling on the filter - see \ref gf_filter_block_eos
+ #\param enable if True, eos blocking is enabled
+ #\return
+ def block_eos(self, enable):
+ _libgpac.gf_filter_block_eos(self._filter, enable)
+
+ ##set maximum number of extra pids accepted by this filter - see \ref gf_filter_set_max_extra_input_pids
+ #\param max_pids number of extra pids
+ #\return
+ def set_max_pids(self, max_pids):
+ _libgpac.gf_filter_set_max_extra_input_pids(self._filter, max_pids)
+
+ ##set clock hint - see \ref gf_filter_hint_single_clock
+ #\param clock_us clock in microseconds
+ #\param media_time media time as Fraction64
+ #\return
+ def hint_clock(self, clock_us, media_time):
+ _libgpac.gf_filter_hint_single_clock(self._filter, clock_us, media_time)
+
+
+ ##\cond private: until end, properties
+
+ @property
+ def block_enabled(self):
+ return _libgpac.gf_filter_block_enabled(self._filter)
+
+ @property
+ def output_buffer(self):
+ val = c_uint(0)
+ _libgpac.gf_filter_get_output_buffer_max(self._filter, byref(val), None)
+ return val.value
+
+ @property
+ def playout_buffer(self):
+ val = c_uint(0)
+ _libgpac.gf_filter_get_output_buffer_max(self._filter, None, byref(val))
+ return val.value
+
+ @property
+ def sinks_done(self):
+ return _libgpac.gf_filter_all_sinks_done(self._filter)
+
+ @property
+ def nb_evts_queued(self):
+ return _libgpac.gf_filter_get_num_events_queued(self._filter)
+
+ @property 
+ def clock_hint_time(self):
+ val = c_ulonglong(0)
+ _libgpac.gf_filter_get_clock_hint(self._filter, byref(val), None)
+ return val.value
+
+ @property 
+ def clock_hint_mediatime(self):
+ val = Fraction64
+ _libgpac.gf_filter_get_clock_hint(self._filter, None, byref(val))
+ return val.value
+
+ @property 
+ def connections_pending(self):
+ return _libgpac.gf_filter_connections_pending(self._filter)
+
+ ##\endcond
+
+ #todo
+ #add_source, add_destination, add_filter: not needed, acces to filter session
+
+
+
+#
+# filter PID bindings
+#
+
+## \cond private
+_libgpac.gf_filter_pid_copy_properties.argtypes = _gf_filter_pid, _gf_filter_pid
+_libgpac.gf_filter_pck_forward.argtypes = _gf_filter_packet, _gf_filter_pid
+
+_libgpac.gf_filter_pid_set_property.argtypes = _gf_filter_pid, c_uint, POINTER(PropertyValue)
+_libgpac.gf_filter_pid_set_property_str.argtypes = _gf_filter_pid, c_char_p, POINTER(PropertyValue)
+_libgpac.gf_filter_pid_set_info.argtypes = _gf_filter_pid, c_uint, POINTER(PropertyValue)
+_libgpac.gf_filter_pid_set_info_str.argtypes = _gf_filter_pid, c_char_p, POINTER(PropertyValue)
+_libgpac.gf_filter_pid_clear_eos.argtypes = _gf_filter_pid, gf_bool
+_libgpac.gf_filter_pid_check_caps.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_check_caps.restype = gf_bool
+_libgpac.gf_filter_pid_discard_block.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_allow_direct_dispatch.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_reset_properties.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_clock_info.argtypes = _gf_filter_pid, POINTER(c_longlong), POINTER(c_uint)
+_libgpac.gf_filter_pid_remove.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_is_filter_in_parents.argtypes = _gf_filter_pid, _gf_filter
+_libgpac.gf_filter_pid_is_filter_in_parents.restype = gf_bool
+
+_libgpac.gf_filter_pid_get_name.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_name.restype = c_char_p
+_libgpac.gf_filter_pid_set_name.argtypes = _gf_filter_pid, c_char_p
+
+_libgpac.gf_filter_pid_is_eos.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_is_eos.restype = gf_bool
+_libgpac.gf_filter_pid_set_eos.argtypes = _gf_filter_pid
+
+_libgpac.gf_filter_pid_has_seen_eos.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_has_seen_eos.restype = gf_bool
+
+_libgpac.gf_filter_pid_eos_received.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_eos_received.restype = gf_bool
+
+_libgpac.gf_filter_pid_would_block.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_would_block.restype = gf_bool
+_libgpac.gf_filter_pid_set_loose_connect.argtypes = _gf_filter_pid
+
+_libgpac.gf_filter_pid_is_sparse.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_is_sparse.restype = gf_bool
+
+_libgpac.gf_filter_pid_set_framing_mode.argtypes = _gf_filter_pid, gf_bool
+
+_libgpac.gf_filter_pid_get_max_buffer.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_max_buffer.restype = c_uint
+_libgpac.gf_filter_pid_set_max_buffer.argtypes = _gf_filter_pid, c_uint
+
+_libgpac.gf_filter_pid_query_buffer_duration.argtypes = _gf_filter_pid, gf_bool
+_libgpac.gf_filter_pid_query_buffer_duration.restype = c_ulonglong
+
+_libgpac.gf_filter_pid_first_packet_is_empty.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_first_packet_is_empty.restype = gf_bool
+
+_libgpac.gf_filter_pid_get_first_packet_cts.argtypes = _gf_filter_pid, POINTER(c_ulonglong)
+_libgpac.gf_filter_pid_get_first_packet_cts.restype = gf_bool
+
+_libgpac.gf_filter_pid_get_packet_count.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_timescale.argtypes = _gf_filter_pid
+
+_libgpac.gf_filter_pid_set_clock_mode.argtypes = _gf_filter_pid, gf_bool
+_libgpac.gf_filter_pid_set_discard.argtypes = _gf_filter_pid, gf_bool
+
+_libgpac.gf_filter_pid_require_source_id.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_recompute_dts.argtypes = _gf_filter_pid, gf_bool
+
+
+_libgpac.gf_filter_pid_get_min_pck_duration.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_is_playing.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_is_playing.restype = gf_bool
+
+_libgpac.gf_filter_pid_get_filter_name.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_filter_name.restype = c_char_p
+
+_libgpac.gf_filter_pid_get_next_ts.argtypes = _gf_filter_pid
+_libgpac.gf_filter_pid_get_next_ts.restype = c_longlong
+
+
+_libgpac.gf_filter_pid_caps_query.argtypes = _gf_filter_pid, c_uint
+_libgpac.gf_filter_pid_caps_query.restype = POINTER(PropertyValue)
+_libgpac.gf_filter_pid_caps_query_str.argtypes = _gf_filter_pid, c_char_p
+_libgpac.gf_filter_pid_caps_query_str.restype = POINTER(PropertyValue)
+
+_libgpac.gf_filter_pid_negociate_property.argtypes = _gf_filter_pid, c_uint, POINTER(PropertyValue)
+_libgpac.gf_filter_pid_negociate_property_dyn.argtypes = _gf_filter_pid, c_char_p, POINTER(PropertyValue)
+
+_libgpac.gf_filter_pck_new_ref.argtypes = _gf_filter_pid, c_uint, c_uint, _gf_filter_packet
+_libgpac.gf_filter_pck_new_ref.restype = _gf_filter_packet
+
+_libgpac.gf_filter_pck_new_alloc.argtypes = _gf_filter_pid, c_uint, POINTER(c_void_p)
+_libgpac.gf_filter_pck_new_alloc.restype = _gf_filter_packet
+
+_libgpac.gf_filter_pck_new_clone.argtypes = _gf_filter_pid, _gf_filter_packet, POINTER(c_void_p)
+_libgpac.gf_filter_pck_new_clone.restype = _gf_filter_packet
+_libgpac.gf_filter_pck_new_copy.argtypes = _gf_filter_pid, _gf_filter_packet, POINTER(c_void_p)
+_libgpac.gf_filter_pck_new_copy.restype = _gf_filter_packet
+
+## \endcond private
+
+
+## \cond private
+
+#callback for packet destruction
+
+_libgpac.gf_filter_pck_new_shared.argtypes = _gf_filter_pid, POINTER(c_ubyte), c_uint, c_void_p
+_libgpac.gf_filter_pck_new_shared.restype = _gf_filter_packet
+
+@CFUNCTYPE(c_int, _gf_filter, _gf_filter_pid, _gf_filter_packet)
+def filter_cbk_release_packet(_f, _pid, _pck):
+ obj = _libgpac.gf_filter_get_rt_udta(_f)
+ filter = cast(obj, py_object).value
+ pck_obj=None
+ obj = _libgpac.gf_filter_pid_get_udta(_pid)
+ if obj:
+ pid_obj = cast(obj, py_object).value
+ else:
+ raise Exception('unknown PID on packet destruction callback')
+
+ for pck in pid_obj.pck_refs:
+ if pck._pck==_pck:
+ pck_obj = pck
+ break
+
+ if not pck_obj:
+ raise Exception('unknown packet on packet destruction callback')
+ pid_obj.pck_refs.remove(pck_obj)
+ filter.packet_release(pid_obj, pck_obj)
+ return 0
+
+## \endcond private
+
+## Object representing a PID of a custom filter
+class FilterPid:
+ ## \cond private
+ def __init__(self, filter, pid, IsInput):
+ self._filter = filter
+ self._pid = pid
+ self._cur_pck = None
+ self._input = IsInput
+ ## \endcond
+ #hack for doxygen to generate member vars (not support for parsing @property)
+ if 0:
+ ##name of the PID - see \ref gf_filter_pid_get_name and \ref gf_filter_pid_set_name
+ #\hideinitializer
+ self.name=0
+ ##name of the parent filter, readonly - see \ref gf_filter_pid_get_filter_name
+ #\hideinitializer
+ self.filter_name=0
+ ##end of stream property of PID - see \ref gf_filter_pid_is_eos and \ref gf_filter_pid_set_eos
+ #\hideinitializer
+ self.eos=0
+ ##True if end of stream was seen in the chain but has not yet reached the filter, readonly - see \ref gf_filter_pid_has_seen_eos
+ #\hideinitializer
+ self.has_seen_eos=0
+ ##True if end of stream was seen on the input PID but some packets are still to be processed, readonly - see \ref gf_filter_pid_eos_received
+ #\hideinitializer
+ self.eos_received=0
+ ##True if PID would block, readonly - see \ref gf_filter_pid_would_block
+ #\hideinitializer
+ self.would_block=0
+ ##True if PID is sparse, readonly - see \ref gf_filter_pid_is_sparse
+ #\hideinitializer
+ self.sparse=0
+ ##maximum buffer of PID in microseconds - see \ref gf_filter_pid_get_max_buffer and \ref gf_filter_pid_set_max_buffer
+ #\hideinitializer
+ self.max_buffer=0
+ ##buffer of PID in microseconds, readonly - see \ref gf_filter_pid_query_buffer_duration
+ #\hideinitializer
+ self.buffer=0
+ ##True if buffer is full, readonly - see \ref gf_filter_pid_query_buffer_duration
+ #\hideinitializer
+ self.buffer_full=0
+ ##True if no pending packet, readonly - see \ref gf_filter_pid_first_packet_is_empty
+ #\hideinitializer
+ self.first_empty=0
+ ##value of CTS of first pending packet, None if none, readonly - see \ref gf_filter_pid_get_first_packet_cts
+ #\hideinitializer
+ self.first_cts=0
+ ##number of queued packets for input pid, readonly - see \ref gf_filter_pid_get_packet_count
+ #\hideinitializer
+ self.nb_pck_queued=0
+ ##timescale of pid, readonly - see \ref gf_filter_pid_get_timescale
+ #\hideinitializer
+ self.timescale=0
+ ##minimum packet duration (in timescale) of pid, readonly - see \ref gf_filter_pid_get_min_pck_duration
+ #\hideinitializer
+ self.min_pck_dur=0
+ ##True if PID is playing, readonly - see \ref gf_filter_pid_is_playing
+ #\hideinitializer
+ self.playing=0
+ ##Next estimated timestamp on pid, readonly - see \ref gf_filter_pid_get_next_ts
+ #\hideinitializer
+ self.next_ts=0
+
+
+ ##send an event on the pid - see \ref gf_filter_pid_send_event
+ #\param evt FilterEvent to send
+ #\return
+ def send_event(self, evt):
+ evt.base.on_pid = self._pid
+ _libgpac.gf_filter_pid_send_event(self._pid, byref(evt))
+
+ ##removes this output pid - see \ref gf_filter_pid_remove
+ #\return
+ def remove(self):
+ if self._input:
+ raise Exception('Cannot remove input pid')
+ return
+ _libgpac.gf_filter_pid_remove(self._pid)
+
+ ##enumerates property on pid
+ #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval(property value)
+ #\return
+ def enum_props(self, callback_obj):
+ self._filter._pid_enum_props_ex(callback_obj, self._pid)
+
+ ##get a PID property
+ #\param pname property name
+ #\return property value or None if not found
+ def get_prop(self, pname):
+ return self._filter._pid_prop_ex(pname, self._pid, False)
+
+ ##get a PID info
+ #\param pname property name
+ #\return property value or None if not found
+ def get_info(self, pname):
+ return self._filter._pid_prop_ex(pname, self._pid, True)
+
+ ##get first packet of input PID - see gf_filter_pid_get_packet
+ #\return FilterPacket or None if no packet available
+ def get_packet(self):
+ ##\cond private
+ if self._cur_pck:
+ return self._cur_pck
+ pck = _libgpac.gf_filter_pid_get_packet(self._pid)
+ if pck:
+ self._cur_pck = FilterPacket(pck, True)
+ return self._cur_pck
+ ##\endcond
+
+ ##drops (removes) the first packet of input PID - see \ref gf_filter_pid_drop_packet
+ #\return
+ def drop_packet(self):
+ ##\cond private
+ if self._cur_pck:
+ self._cur_pck = None
+ _libgpac.gf_filter_pid_drop_packet(self._pid)
+ ##\endcond
+
+ ##copy property of given PID to the current pid - see \ref gf_filter_pid_copy_properties
+ #\param ipid FilterPid to copy from
+ #\return
+ def copy_props(self, ipid):
+ if self._input:
+ raise Exception('Cannot copy properties on input PID')
+ return
+ if ipid==None:
+ return
+ err = _libgpac.gf_filter_pid_copy_properties(self._pid, ipid._pid)
+ if err<0:
+ raise Exception('Cannot copy properties: ' + e2s(err) )
+ 
+ ##removes all properties of the current pid - see \ref gf_filter_pid_reset_properties
+ #\return
+ def reset_props(self):
+ if self._input:
+ raise Exception('Cannot reset properties on input PID')
+ return
+ _libgpac.gf_filter_pid_reset_properties(self._pid)
+
+ ##forward a packet on the current pid - see \ref gf_filter_pck_forward
+ #\param ipck packet to forward
+ #\return
+ def forward(self, ipck):
+ if self._input:
+ raise Exception('Cannot copy properties on input PID')
+ return
+ if ipck==None:
+ return
+ _libgpac.gf_filter_pck_forward(ipck._pck, self._pid)
+
+ ##set a property the current pid - see \ref gf_filter_pid_set_property and \ref gf_filter_pid_set_property_str
+ #\param pcode property type
+ #\param prop property value to set
+ #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
+ #\return
+ def set_prop(self, pcode, prop, custom_type=0):
+ if self._input:
+ raise Exception('Cannot set properties on input PID')
+ return
+ prop_4cc = pcode
+ prop_name = None
+ if isinstance(pcode, str):
+ _pname = pcode.encode('utf-8')
+ prop_4cc = _libgpac.gf_props_get_id(_pname)
+ if prop_4cc==0:
+ prop_name = _pname
+
+ if prop==None:
+ if prop_4cc:
+ _libgpac.gf_filter_pid_set_property(self._pid, prop_4cc, None)
+ else:
+ _libgpac.gf_filter_pid_set_property_str(self._pid, prop_name, None)
+ return
+
+ prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
+ if prop_4cc:
+ _libgpac.gf_filter_pid_set_property(self._pid, prop_4cc, byref(prop_val))
+ else:
+ _libgpac.gf_filter_pid_set_property_str(self._pid, prop_name, byref(prop_val))
+
+ ##set a info property the current pid - see \ref gf_filter_pid_set_info and \ref gf_filter_pid_set_info_str
+ #\param pcode property type
+ #\param prop property value to set
+ #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
+ #\return
+ def set_info(self, pcode, prop, custom_type=0):
+ if self._input:
+ raise Exception('Cannot set info on input PID')
+ return
+ prop_4cc = pcode
+ prop_name = None
+ if isinstance(pcode, str):
+ _pname = pcode.encode('utf-8')
+ prop_4cc = _libgpac.gf_props_get_id(_pname)
+ if prop_4cc==0:
+ prop_name = _pname
+
+ if prop==None:
+ if prop_4cc:
+ _libgpac.gf_filter_pid_set_info(self._pid, prop_4cc, None)
+ else:
+ _libgpac.gf_filter_pid_set_info_str(self._pid, prop_name, None)
+ return
+
+ prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
+ if prop_4cc:
+ _libgpac.gf_filter_pid_set_info(self._pid, prop_4cc, byref(prop_val))
+ else:
+ _libgpac.gf_filter_pid_set_info_str(self._pid, prop_name, byref(prop_val))
+
+ ##clears EOS on the current PID - see \ref gf_filter_pid_clear_eos
+ #\param all_pids if True, clears eos on all input pids
+ #\return
+ def clear_eos(self, all_pids):
+ _libgpac.gf_filter_pid_clear_eos(self._pid, all_pids)
+
+ ##check PID properties match capability of filter - see \ref gf_filter_pid_check_caps
+ #\return
+ def check_caps(self):
+ return _libgpac.gf_filter_pid_check_caps(self._pid)
+
+ ##discard blocking mode on PID - see \ref gf_filter_pid_discard_block
+ #\return
+ def discard_block(self):
+ _libgpac.gf_filter_pid_discard_block(self._pid)
+
+ ##allow direct dispatch of output to destinations - see \ref gf_filter_pid_allow_direct_dispatch
+ #\return
+ def allow_direct_dispatch(self):
+ _libgpac.gf_filter_pid_allow_direct_dispatch(self._pid)
+
+ ##get current clock type info - see \ref gf_filter_pid_get_clock_info
+ #\return clock type (int)
+ def get_clock_type(self):
+ return _libgpac.gf_filter_pid_get_clock_info(self._pid, None, None)
+
+ ##get current clock time stamp - see \ref gf_filter_pid_get_clock_info
+ #\return clock timestamp (Fraction64)
+ def get_clock_timestamp(self):
+ timestamp = c_longlong(0)
+ timescale = c_uint(0)
+ _libgpac.gf_filter_pid_get_clock_info(self._pid, byref(timestamp), byref(timescale))
+ v = Fraction64()
+ v.value.num = timestamp.value
+ v.value.den = timescale.value
+ return v
+
+ ##check if a filter is in the parent filter chain of the pid - see \ref gf_filter_pid_is_filter_in_parents
+ #\param filter Filter to check
+ #\return True or False
+ def is_filter_in_parents(self, filter):
+ return _libgpac.gf_filter_pid_is_filter_in_parents(self._pid, filter._f)
+
+ ##get buffer occupancy - see \ref gf_filter_pid_get_buffer_occupancy
+ #\return BufferOccupancy object
+ def get_buffer_occupancy(self):
+ max_units = c_uint(0)
+ nb_pck = c_uint(0)
+ max_dur = c_uint(0)
+ dur = c_uint(0)
+ in_final_flush = _libgpac.gf_filter_pid_get_buffer_occupancy(self._pid, byref(max_units), byref(nb_pck), byref(max_dur), byref(dur) )
+ in_final_flush = not in_final_flush
+ return BufferOccupancy(max_units, nb_pck, max_dur, dur, not_in_final_flush)
+
+ ##sets loose connect mode - see \ref gf_filter_pid_set_loose_connect
+ #\return
+ def loose_connect(self):
+ _libgpac.gf_filter_pid_set_loose_connect(self._pid)
+
+ ##sets framing mode - see \ref gf_filter_pid_set_framing_mode
+ #\param framed if True, complete frames only will be delivered on the pid
+ #\return
+ def set_framing(self, framed):
+ _libgpac.gf_filter_pid_set_framing_mode(self._pid, framed)
+
+ ##sets clock mode - see \ref gf_filter_pid_set_clock_mode
+ #\param cmode clock mode operation of filter
+ #\return
+ def set_clock_mode(self, cmode):
+ _libgpac.gf_filter_pid_set_clock_mode(self._pid, cmode)
+
+ ##sets discard mode - see \ref gf_filter_pid_set_discard
+ #\param do_discard if True, discard is on
+ #\return
+ def set_discard(self, do_discard):
+ _libgpac.gf_filter_pid_set_discard(self._pid, do_discard)
+
+ ##enforces sourceID to be present for output pids of this filter - see \ref gf_filter_pid_require_source_id
+ #\return
+ def require_source_id(self):
+ err = _libgpac.gf_filter_pid_require_source_id(self._pid)
+ if err<0:
+ raise Exception('Failed to require sourceID for pid: ' + e2s(err))
+ return
+
+ ##sets DTS recomputing mode - see \ref gf_filter_pid_recompute_dts
+ #\param do_compute if True, DTS are recomputed
+ #\return
+ def recompute_dts(self, do_compute):
+ _libgpac.gf_filter_pid_recompute_dts(self._pid, do_compute)
+
+ ##queries a capability property on output PID - see \ref gf_filter_pid_caps_query and \ref gf_filter_pid_caps_query_str
+ #\param pcode property to check
+ #\return property value if found, None otherwise
+ def query_cap(self, pcode):
+ if self._input:
+ raise Exception('Cannot query caps on input PID')
+ return
+ prop_4cc = pcode
+ prop_name = None
+ if isinstance(pcode, str):
+ _pname = pcode.encode('utf-8')
+ prop_4cc = _libgpac.gf_props_get_id(_pname)
+ if prop_4cc==0:
+ prop_name = _pname
+
+ if prop_4cc:
+ prop_val = _libgpac.gf_filter_pid_caps_query(self._pid, prop_4cc)
+ else:
+ prop_val = _libgpac.gf_filter_pid_caps_query_str(self._pid, _pname)
+
+ if prop_val:
+ return _prop_to_python(pname, prop.contents)
+ return None
+
+ ##negociates a capability property on input PID - see \ref gf_filter_pid_negociate_property and \ref gf_filter_pid_negociate_property_dyn
+ #\param pcode property to negotiate
+ #\param prop property to negotiate
+ #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
+ #\return
+ def negociate_cap(self, pcode, prop, custom_type=0):
+ if not self._input:
+ raise Exception('Cannot negociate caps on output PID')
+ return
+ prop_4cc = pcode
+ prop_name = None
+ if isinstance(pcode, str):
+ _pname = pcode.encode('utf-8')
+ prop_4cc = _libgpac.gf_props_get_id(_pname)
+ if prop_4cc==0:
+ prop_name = _pname
+
+ prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
+ if prop_4cc:
+ _libgpac.gf_filter_pid_negociate_property(self._pid, prop_4cc, byref(prop_val))
+ else:
+ _libgpac.gf_filter_pid_negociate_property_dyn(self._pid, prop_name, byref(prop_val))
+
+ ##resolves a template string - see \ref gf_filter_pid_resolve_file_template
+ #\param template the template string
+ #\param file_idx the file index
+ #\param suffix the file suffix
+ #\return the resolved template string
+ def resolve_template(self, template, file_idx=0, suffix=None):
+ res = create_string_buffer(2000)
+ err = _libgpac.gf_filter_pid_resolve_file_template(self._pid, res, template.encode('utf-8'), file_idx, suffix)
+ if err<0:
+ raise Exception('Cannot resolve file template ' + template + ': ' + e2s(err))
+ return res.raw.decode('utf-8')
+
+ ##creates a new packet referring to an existing packet - see \ref gf_filter_pck_new_ref
+ #\param ipck the input (referenced) packet
+ #\param size the data size of the new packet
+ #\param offset the offset in the original data
+ #\return the new FilterPacket or None if failure
+ def new_pck_ref(self, ipck, size=0, offset=0):
+ if ipck==None:
+ raise Exception('NULL input packet in new_pck_ref !')
+ _pck = _libgpac.gf_filter_pck_new_ref(self._pid, offset, size, ipck._pck)
+ if _pck:
+ return FilterPacket(_pck, False)
+ return None
+
+ ##creates a new packet of the given size, allocating memory in libgpac - see \ref gf_filter_pck_new_alloc
+ #\param size the data size of the new packet
+ #\return the new FilterPacket or None if failure
+ def new_pck(self, size=0):
+ _pck = _libgpac.gf_filter_pck_new_alloc(self._pid, size, None)
+ if _pck:
+ pck = FilterPacket(_pck, False)
+ pck._readonly = False
+ return pck
+ return None
+
+ ##creates a new packet sharing memory of the filter - see \ref gf_filter_pck_new_shared
+ #The filter object must have a `packet_release` method with arguments FilterPid, FilterPacket 
+ #\param data the data to use. If NumPy is detected, accept a NP Array. Otherwise data is type casted into POINTER(c_ubyte)
+ #\return the new FilterPacket or None if failure
+ def new_pck_shared(self, data):
+ data_p = None
+ data_len = 0
+ readonly=False
+ if not hasattr(self._filter, 'packet_release'):
+ raise Exception('Filter ' + self._filter.name + ' has no packet_release callback function defined')
+
+ if numpy_support and isinstance(data, np.ndarray):
+ data_p = data.ctypes.data_as(POINTER(c_ubyte))
+ data_len = data.size * data.itemsize
+ readonly = not data.flags.writeable
+ else:
+ data_p = cast(data, POINTER(c_ubyte) )
+ data_len = len(data)
+
+ if not data_p:
+ raise Exception('Unknown data reference class ' + data.__class__.__name__)
+
+ _pck = _libgpac.gf_filter_pck_new_shared(self._pid, data_p, data_len, filter_cbk_release_packet)
+ if _pck:
+ pck = FilterPacket(_pck, False)
+ pck._readonly = readonly
+ self.pck_refs.append(pck)
+ return pck
+ return None
+
+ ##creates a new packet copying a source packet - see \ref gf_filter_pck_new_copy
+ #\param ipck the FilterPacket to copy
+ #\return the new FilterPacket or None if failure
+ def new_pck_copy(self, ipck):
+ if ipck==None:
+ raise Exception('NULL input packet in new_pck_copy !')
+ _pck = _libgpac.gf_filter_pck_new_copy(self._pid, ipck._pck, None)
+ if _pck:
+ pck = FilterPacket(_pck, False)
+ pck._readonly = False
+ return pck
+ return None
+
+ ##creates a new packet cloning a source packet - see \ref gf_filter_pck_new_clone
+ #\param ipck the FilterPacket to clone
+ #\return the new FilterPacket or None if failure
+ def new_pck_clone(self, ipck):
+ if ipck==None:
+ raise Exception('NULL input packet in new_pck_clone !')
+ _pck = _libgpac.gf_filter_pck_new_clone(self._pid, ipck._pck, None)
+ if _pck:
+ pck = FilterPacket(_pck, False)
+ pck._readonly = False
+ return pck
+ return None
+
+ ##\cond private: until end, properties
+ ##name of the PID - see \ref gf_filter_pid_get_name and \ref gf_filter_pid_set_name
+ #\return
+ @property
+ def name(self):
+ return _libgpac.gf_filter_pid_get_name(self._pid).decode('utf-8')
+
+ ##\cond private
+ @name.setter
+ def name(self, val):
+ _libgpac.gf_filter_pid_set_name(self._pid, val.encode('utf-8'))
+ ##\endcond
+
+ ##name of the parent filter - see \ref gf_filter_pid_get_filter_name
+ #\return
+ @property
+ def filter_name(self):
+ return _libgpac.gf_filter_pid_get_filter_name(self._pid).decode('utf-8')
+
+ ##end of stream property of PID - see \ref gf_filter_pid_is_eos and \ref gf_filter_pid_set_eos
+ #\return
+ @property
+ def eos(self):
+ return _libgpac.gf_filter_pid_is_eos(self._pid)
+
+ ##\cond private
+ @eos.setter
+ def eos(self, Value):
+ _libgpac.gf_filter_pid_set_eos(self._pid)
+ ##\endcond private
+
+ ##True if end of stream was seen in the chain but not yet reached by the filter - see \ref gf_filter_pid_has_seen_eos
+ #\return
+ @property
+ def has_seen_eos(self):
+ return _libgpac.gf_filter_pid_has_seen_eos(self._pid)
+
+ ##True if end of stream was seen on pid but some packets are still pending - see \ref gf_filter_pid_eos_received
+ #\return
+ @property
+ def eos_receievd(self):
+ return _libgpac.gf_filter_pid_eos_received(self._pid)
+
+ ##True if PID would block - see \ref gf_filter_pid_would_block
+ #\return
+ @property
+ def would_block(self):
+ return _libgpac.gf_filter_pid_would_block(self._pid)
+
+ ##True if PID is sparse - see \ref gf_filter_pid_is_sparse
+ #\return
+ @property
+ def sparse(self):
+ return _libgpac.gf_filter_pid_is_sparse(self._pid)
+
+ ##maximum buffer of PID in microseconds - see \ref gf_filter_pid_get_max_buffer and \ref gf_filter_pid_set_max_buffer
+ #\return
+ @property
+ def max_buffer(self):
+ return _libgpac.gf_filter_pid_get_max_buffer(self._pid)
+
+ ##\cond private
+ @max_buffer.setter
+ def max_buffer(self, value):
+ return _libgpac.gf_filter_pid_set_max_buffer(self._pid, value)
+ ##\endcond
+
+ ##buffer of PID in microseconds - see \ref gf_filter_pid_query_buffer_duration
+ #\return
+ @property
+ def buffer(self):
+ return _libgpac.gf_filter_pid_query_buffer_duration(self._pid, False)
+
+ ##True if buffer is full - see \ref gf_filter_pid_query_buffer_duration
+ #\return
+ @property
+ def buffer_full(self):
+ dur = _libgpac.gf_filter_pid_query_buffer_duration(self._pid, True)
+ if dur:
+ return True
+ else:
+ return False
+
+ ##True if no pending packet - see \ref gf_filter_pid_first_packet_is_empty
+ #\return
+ @property
+ def first_empty(self):
+ return _libgpac.gf_filter_pid_first_packet_is_empty(self._pid)
+
+ ##value of CTS of first pending packet, None if none - see \ref gf_filter_pid_get_first_packet_cts
+ #\return
+ @property
+ def first_cts(self):
+ cts = c_ulonglong(0)
+ res = _libgpac.gf_filter_pid_get_first_packet_cts(self._pid, byref(cts))
+ if not res:
+ return None
+ return cts.value
+
+ ##number of queued packets for input pid - see \ref gf_filter_pid_get_packet_count
+ #\return
+ @property
+ def nb_pck_queued(self):
+ return _libgpac.gf_filter_pid_get_packet_count(self._pid)
+
+ ##timescale of pid - see \ref gf_filter_pid_get_timescale
+ #\return
+ @property
+ def timescale(self):
+ return _libgpac.gf_filter_pid_get_timescale(self._pid)
+
+ ##minimum packet duration (in timescale) of pid - see \ref gf_filter_pid_get_min_pck_duration
+ #\return
+ @property
+ def min_pck_dur(self):
+ return _libgpac.gf_filter_pid_get_min_pck_duration(self._pid)
+
+ ##True if PID is playing - see \ref gf_filter_pid_is_playing
+ #\return
+ @property
+ def playing(self):
+ return _libgpac.gf_filter_pid_is_playing(self._pid)
+
+ #\return
+ @property
+ def next_ts(self):
+ return _libgpac.gf_filter_pid_get_next_ts(self._pid)
+
+ ##\endcond
+
+ #vars:
+ #src_name, args, src_args, src_url, dst_url: probably not needed since the entire session is exposed to the custom filter
+
+
+
+
+#
+# filter packet bindings
+#
+
+##\cond private
+
+#getters
+_libgpac.gf_filter_pck_get_dts.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_dts.restype = c_ulonglong
+_libgpac.gf_filter_pck_set_dts.argtypes = _gf_filter_packet, c_ulonglong
+
+_libgpac.gf_filter_pck_get_cts.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_cts.restype = c_ulonglong
+_libgpac.gf_filter_pck_set_cts.argtypes = _gf_filter_packet, c_ulonglong
+
+_libgpac.gf_filter_pck_get_sap.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_sap.restype = c_uint
+_libgpac.gf_filter_pck_set_sap.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_get_duration.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_duration.restype = c_uint
+_libgpac.gf_filter_pck_set_duration.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_get_data.argtypes = _gf_filter_packet, POINTER(c_uint)
+_libgpac.gf_filter_pck_get_data.restype = POINTER(c_ubyte)
+
+_libgpac.gf_filter_pck_get_framing.argtypes = _gf_filter_packet, POINTER(gf_bool), POINTER(gf_bool)
+_libgpac.gf_filter_pck_set_framing.argtypes = _gf_filter_packet, gf_bool, gf_bool
+
+_libgpac.gf_filter_pck_get_timescale.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_timescale.restype = c_uint
+
+_libgpac.gf_filter_pck_get_interlaced.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_interlaced.restype = c_uint
+_libgpac.gf_filter_pck_set_interlaced.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_get_corrupted.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_corrupted.restype = gf_bool
+_libgpac.gf_filter_pck_set_corrupted.argtypes = _gf_filter_packet, gf_bool
+
+_libgpac.gf_filter_pck_get_seek_flag.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_seek_flag.restype = gf_bool
+_libgpac.gf_filter_pck_set_seek_flag.argtypes = _gf_filter_packet, gf_bool
+
+_libgpac.gf_filter_pck_get_byte_offset.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_byte_offset.restype = c_ulonglong
+_libgpac.gf_filter_pck_set_byte_offset.argtypes = _gf_filter_packet, c_ulonglong
+
+_libgpac.gf_filter_pck_get_roll_info.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_roll_info.restype = c_short
+_libgpac.gf_filter_pck_set_roll_info.argtypes = _gf_filter_packet, c_short
+
+_libgpac.gf_filter_pck_get_crypt_flags.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_crypt_flags.restype = c_uint
+_libgpac.gf_filter_pck_set_crypt_flags.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_get_clock_type.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_clock_type.restype = c_uint
+_libgpac.gf_filter_pck_set_clock_type.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_get_carousel_version.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_carousel_version.restype = c_uint
+_libgpac.gf_filter_pck_set_carousel_version.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_get_seq_num.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_seq_num.restype = c_uint
+_libgpac.gf_filter_pck_set_seq_num.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_get_dependency_flags.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_dependency_flags.restype = c_uint
+_libgpac.gf_filter_pck_set_dependency_flags.argtypes = _gf_filter_packet, c_uint
+
+
+class FrameInterface(Structure):
+ _fields_ = 
+ ("get_plane", c_void_p),
+ ("get_gl_texture", c_void_p),
+ ("flags", c_uint),
+ ("user_data", c_void_p)
+ 
+
+get_gl_tex_fun = CFUNCTYPE(c_int, POINTER(FrameInterface), c_uint, POINTER(c_uint), POINTER(c_uint), POINTER(c_void_p))
+
+
+_libgpac.gf_filter_pck_get_frame_interface.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_get_frame_interface.restype = POINTER(FrameInterface)
+
+_libgpac.gf_filter_pck_is_blocking_ref.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_is_blocking_ref.restype = gf_bool
+
+_libgpac.gf_filter_pck_has_properties.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_has_properties.restype = gf_bool
+
+_libgpac.gf_filter_pck_enum_properties.argtypes = _gf_filter_packet, POINTER(c_uint), POINTER(c_uint), POINTER(c_char_p)
+_libgpac.gf_filter_pck_enum_properties.restype = POINTER(PropertyValue)
+
+_libgpac.gf_filter_pck_get_property.argtypes = _gf_filter_packet, c_uint
+_libgpac.gf_filter_pck_get_property.restype = POINTER(PropertyValue)
+_libgpac.gf_filter_pck_get_property_str.argtypes = _gf_filter_packet, c_char_p
+_libgpac.gf_filter_pck_get_property_str.restype = POINTER(PropertyValue)
+
+_libgpac.gf_filter_pck_ref_ex.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_ref_ex.restype = _gf_filter_packet
+_libgpac.gf_filter_pck_unref.argtypes = _gf_filter_packet
+
+_libgpac.gf_filter_pck_discard.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_set_readonly.argtypes = _gf_filter_packet
+_libgpac.gf_filter_pck_send.argtypes = _gf_filter_packet
+
+_libgpac.gf_filter_pck_merge_properties.argtypes = _gf_filter_packet, _gf_filter_packet
+
+_libgpac.gf_filter_pck_set_property.argtypes = _gf_filter_packet, c_uint, POINTER(PropertyValue)
+_libgpac.gf_filter_pck_set_property_str.argtypes = _gf_filter_packet, c_char_p, POINTER(PropertyValue)
+_libgpac.gf_filter_pck_truncate.argtypes = _gf_filter_packet, c_uint
+
+_libgpac.gf_filter_pck_dangling_copy.argtypes = _gf_filter_packet, _gf_filter_packet
+_libgpac.gf_filter_pck_dangling_copy.restype = _gf_filter_packet
+
+##\endcond private
+
+## OpenGL texture info 
+class GLTextureInfo:
+ ##\cond private
+ def __init__(self, gl_id, gl_format):
+ ##\endcond
+ ##OpenGL texture ID
+ #\hideinitializer
+ self.id = gl_id
+ ##OpenGL texture format (e.g., GL_TEXTURE_2D)
+ #\hideinitializer
+ self.format = gl_format
+
+##filter packet object
+class FilterPacket:
+ ##\cond private
+ def __init__(self, pck, is_src):
+ self._pck = pck
+ self._is_src = is_src
+ self._readonly = True
+ ##\endcond private
+ #hack for doxygen to generate member vars (not support for parsing @property)
+ if 0:
+ ##Decode Timestamp - see \ref gf_filter_pck_get_dts and \ref gf_filter_pck_set_dts
+ #\hideinitializer
+ self.dts=0
+ ##Compose Timestamp - see \ref gf_filter_pck_get_cts and \ref gf_filter_pck_set_cts
+ #\hideinitializer
+ self.cts=0
+ ##SAP type - see \ref gf_filter_pck_get_sap and \ref gf_filter_pck_set_sap
+ #\hideinitializer
+ self.sap=0
+ ##Duration - see \ref gf_filter_pck_get_duration and \ref gf_filter_pck_set_duration
+ #\hideinitializer
+ self.dur=0
+ ##Size of packet data, readonly
+ #\hideinitializer
+ self.size=0
+ ##Packet data - see \ref gf_filter_pck_get_data
+ #If NumPy is available, the data is returned as a np Array, otherwise it is a POINTER(c_ubyte) object
+ #The property is readonly (cannot be set) but content can be modified for non-refs output packets
+ #\hideinitializer
+ self.data=0
+ ##frame start - see \ref gf_filter_pck_get_framing and \ref gf_filter_pck_set_framing
+ #\hideinitializer
+ self.start=0
+ ##frame end - see \ref gf_filter_pck_get_framing and \ref gf_filter_pck_set_framing
+ #\hideinitializer
+ self.end=0
+ ##associated timescale, readonly - see \ref gf_filter_pck_get_timescale
+ #\hideinitializer
+ self.timescale=0
+ ##Interlaced flags - see \ref gf_filter_pck_get_interlaced and \ref gf_filter_pck_set_interlaced
+ #\hideinitializer
+ self.interlaced=0
+ ##Corrupted flag - see \ref gf_filter_pck_get_corrupted and \ref gf_filter_pck_set_corrupted
+ #\hideinitializer
+ self.corrupted=0
+ ##Seek flag - see \ref gf_filter_pck_get_seek_flag and \ref gf_filter_pck_set_seek_flag
+ #\hideinitializer
+ self.seek=0
+ ##Byte offset - see \ref gf_filter_pck_get_byte_offset and \ref gf_filter_pck_set_byte_offset
+ #\hideinitializer
+ self.byte_offset=0
+ ##Roll info - see \ref gf_filter_pck_get_roll_info and \ref gf_filter_pck_set_roll_info
+ #\hideinitializer
+ self.roll=0
+ ##Encryption flags - see \ref gf_filter_pck_get_crypt_flags and \ref gf_filter_pck_set_crypt_flags
+ #\hideinitializer
+ self.crypt=0
+ ##Clock reference flag - see \ref gf_filter_pck_get_clock_type and \ref gf_filter_pck_set_clock_type
+ #\hideinitializer
+ self.clock=0
+ ##Carousel version - see \ref gf_filter_pck_get_carousel_version and \ref gf_filter_pck_set_carousel_version
+ #\hideinitializer
+ self.carousel=0
+ ##Sequence number - see \ref gf_filter_pck_get_seq_num and \ref gf_filter_pck_set_seq_num
+ #\hideinitializer
+ self.seqnum=0
+ ##Dependency flags - see \ref gf_filter_pck_get_dependency_flags and \ref gf_filter_pck_set_dependency_flags
+ #\hideinitializer
+ self.deps=0
+ ##true if packet holds a GF_FrameInterface object and not a data packet, readonly
+ #\hideinitializer
+ self.frame_ifce=0
+ ##true if packet holds a GF_FrameInterface object providing OpenGL only access and not a data packet, readonly
+ #\hideinitializer
+ self.frame_ifce_gl=0
+ ##Custom properties present, readonly - see \ref gf_filter_pck_has_properties
+ #\hideinitializer
+ self.has_properties=0
+ ##true if packet is a blocking reference, readonly - see \ref gf_filter_pck_is_blocking_ref
+ #\hideinitializer
+ self.blocking_ref=0
+
+ ##enumerate an packet properties
+ #\param callback_obj callback object to use, must have a 'on_prop_enum' method defined taking two parameters, prop_name(string) and propval
+ #\return
+ def enum_props(self, callback_obj):
+ if not hasattr(callback_obj, 'on_prop_enum'):
+ return
+
+ pidx=c_uint(0)
+ while True:
+ _p4cc=c_uint(0)
+ _pname=c_char_p(0)
+ prop = _libgpac.gf_filter_pck_enum_properties(self._pck, byref(pidx), byref(_p4cc), byref(_pname))
+ if prop:
+ p4cc=_p4cc.value
+ pname=None
+ if _pname:
+ pname=_pname.value.decode('utf-8')
+ else:
+ pname=_libgpac.gf_props_4cc_get_name(p4cc).decode('utf-8')
+ pval = _prop_to_python(pname, prop.contents)
+ callback_obj.on_prop_enum(pname, pval)
+ else:
+ break
+
+ ##get a packet property - see \ref gf_filter_pck_get_property and \ref gf_filter_pck_get_property_str
+ #\param prop_name name of property to get
+ #\return property value, or None if not found
+ def get_prop(self, prop_name):
+ _name = prop_name.encode('utf-8')
+ p4cc = _libgpac.gf_props_get_id(_name)
+ if p4cc:
+ prop = _libgpac.gf_filter_pck_get_property(self._pck, p4cc)
+ else:
+ prop = _libgpac.gf_filter_pck_get_property_str(self._pck, _name)
+ if prop:
+ return _prop_to_python(prop_name, prop.contents)
+ return None
+
+ ##increase packet reference count - see \ref gf_filter_pck_ref_ex
+ #\return
+ def ref(self):
+ ##\cond private
+ self._pck = _libgpac.gf_filter_pck_ref_ex(self._pck)
+ ##\endcond private
+
+ ##decrease packet reference count - see \ref gf_filter_pck_unref
+ #\return
+ def unref(self):
+ _libgpac.gf_filter_pck_unref(self._pck)
+
+
+ ##discard an output packet instead of sending it - see \ref gf_filter_pck_discard
+ #\return
+ def discard(self):
+ ##\cond private
+ if self._is_src:
+ raise Exception('Cannot discard on source packet')
+ _libgpac.gf_filter_pck_discard(self._pck)
+ self._pck = None
+ ##\endcond private
+
+ ##creates a new packet cloning a source packet - see \ref gf_filter_pck_dangling_copy.
+ #The resulting packet is read/write mode and may have its own memory allocated.
+ #This is typically used by sink filters wishing to access underling GPU data of a packet using frame interface.
+ #the resulting packet can be explicitly discarded using \ref discard, otherwise will be garbage collected.
+ #\param cached_pck if set, will be reuse for creation of new packet. This can greatly reduce memory allocations
+ #\return the new FilterPacket or None if failure or None if failure ( if grabbing the frame into a local copy failed)
+ def clone(self, cached_pck=None):
+ if cached_pck:
+ _pck = _libgpac.gf_filter_pck_dangling_copy(self._pck, cached_pck._pck)
+ else:
+ _pck = _libgpac.gf_filter_pck_dangling_copy(self._pck, None)
+
+ if _pck:
+ pck = FilterPacket(_pck, False)
+ pck._readonly = False
+ return pck
+ return None
+
+
+ ##mark an output packet as readonly - see \ref gf_filter_pck_set_readonly
+ #\return
+ def readonly(self):
+ if self._is_src:
+ raise Exception('Cannot set readonly on source packet')
+ _libgpac.gf_filter_pck_set_readonly(self._pck)
+
+ ##send the packet - see \ref gf_filter_pck_send
+ #\return
+ def send(self):
+ if self._is_src:
+ raise Exception('Cannot send on source packet')
+ _libgpac.gf_filter_pck_send(self._pck)
+
+ ##copy properties of source packet in this packet - see \ref gf_filter_pck_merge_properties
+ #\param ipck source packet
+ #\return
+ def copy_props(self, ipck):
+ if self._is_src:
+ raise Exception('Cannot copy properties on source packet')
+ if ipck==None:
+ return
+ err = _libgpac.gf_filter_pck_merge_properties(ipck._pck, self._pck)
+ if err<0:
+ raise Exception('Cannot copy properties: ' + e2s(err) )
+
+ ##set property in this packet - see \ref gf_filter_pck_set_property and \ref gf_filter_pck_set_property_str
+ #\param pcode name of property
+ #\param prop property value
+ #\param custom_type type of property if user-defined property. If not set and user-defined, property is a string
+ #\return
+ def set_prop(self, pcode, prop, custom_type=0):
+ if self._is_src:
+ raise Exception('Cannot copy properties on source packet')
+ prop_4cc = pcode
+ prop_name = None
+ if isinstance(pcode, str):
+ _pname = pcode.encode('utf-8')
+ prop_4cc = _libgpac.gf_props_get_id(_pname)
+ if prop_4cc==0:
+ prop_name = _pname
+
+ if prop==None:
+ if prop_4cc:
+ _libgpac.gf_filter_pck_set_property(self._pck, prop_4cc, None)
+ else:
+ _libgpac.gf_filter_pck_set_property_str(self._pck, prop_name, None)
+ return
+
+ prop_val = _make_prop(prop_4cc, pcode, prop, custom_type)
+ if prop_4cc:
+ _libgpac.gf_filter_pck_set_property(self._pck, prop_4cc, byref(prop_val))
+ else:
+ _libgpac.gf_filter_pck_set_property_str(self._pck, prop_name, byref(prop_val))
+
+ ##truncates an output packet to the given size - see \ref gf_filter_pck_truncate
+ #\param size new size of packet
+ #\return
+ def truncate(self, size):
+ if self._is_src:
+ raise Exception('Cannot truncate an source packet')
+ _libgpac.gf_filter_pck_truncate(self._pck, size)
+
+
+ ##return OpenGL texture info for a given color plane of a frame interface packet
+ #\param idx index of texture to fetch. The number of texture depends on the underlying pixel format
+ #\return GLTextureInfo object or None if error
+ def get_gl_texture(self, idx):
+ p = _libgpac.gf_filter_pck_get_frame_interface(self._pck)
+ if not p:
+ return None
+ if not p.contents.get_gl_texture:
+ return None
+
+ get_tex = get_gl_tex_fun(p.contents.get_gl_texture)
+ gl_format=c_uint(0)
+ gl_tex_id=c_uint(0)
+ ret = get_tex(p, idx, byref(gl_format), byref(gl_tex_id), None)
+ if ret:
+ return None
+ obj = GLTextureInfo(gl_tex_id.value, gl_format.value)
+ return obj
+
+ ##\cond private: until end, all packet properties
+ @property
+ def blocking_ref(self):
+ return _libgpac.gf_filter_pck_is_blocking_ref(self._pck)
+
+ @property
+ def dts(self):
+ return _libgpac.gf_filter_pck_get_dts(self._pck)
+
+ @dts.setter
+ def dts(self, val):
+ if self._is_src:
+ raise Exception('Cannot set DTS on source packet')
+ _libgpac.gf_filter_pck_set_dts(self._pck, val)
+
+ @property
+ def cts(self):
+ return _libgpac.gf_filter_pck_get_cts(self._pck)
+
+ @cts.setter
+ def cts(self, val):
+ if self._is_src:
+ raise Exception('Cannot set CTS on source packet')
+ return _libgpac.gf_filter_pck_set_cts(self._pck, val)
+
+ @property
+ def sap(self):
+ return _libgpac.gf_filter_pck_get_sap(self._pck)
+
+ @sap.setter
+ def sap(self, val):
+ if self._is_src:
+ raise Exception('Cannot set SAP on source packet')
+ return _libgpac.gf_filter_pck_set_sap(self._pck, val)
+
+ @property
+ def dur(self):
+ return _libgpac.gf_filter_pck_get_duration(self._pck)
+
+ @dur.setter
+ def dur(self, val):
+ if self._is_src:
+ raise Exception('Cannot set duration on source packet')
+ return _libgpac.gf_filter_pck_set_duration(self._pck, val)
+
+ @property
+ def size(self):
+ size = c_uint(0)
+ _libgpac.gf_filter_pck_get_data(self._pck, byref(size))
+ return size.value
+
+ @property
+ def data(self):
+ size = c_uint(0)
+ data = _libgpac.gf_filter_pck_get_data(self._pck, byref(size))
+ if not data:
+ return None
+
+ if numpy_support:
+ data = np.ctypeslib.as_array(data, (size.value,))
+ if self._readonly:
+ data.flags.writeable=False
+ return data 
+
+ @property
+ def start(self):
+ start = gf_bool(False)
+ end = gf_bool(False)
+ _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
+ return start.value
+
+ @start.setter
+ def start(self, value):
+ if self._is_src:
+ raise Exception('Cannot set framing on source packet')
+ start = gf_bool(False)
+ end = gf_bool(False)
+ _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
+ _libgpac.gf_filter_pck_set_framing(self._pck, value, end.value)
+
+ @property
+ def end(self):
+ start = gf_bool(False)
+ end = gf_bool(False)
+ _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
+ return end.value
+
+ @end.setter
+ def end(self, value):
+ if self._is_src:
+ raise Exception('Cannot set framing on source packet')
+ start = gf_bool(False)
+ end = gf_bool(False)
+ _libgpac.gf_filter_pck_get_framing(self._pck, byref(start), byref(end))
+ _libgpac.gf_filter_pck_set_framing(self._pck, start.value, value)
+
+ @property
+ def timescale(self):
+ return _libgpac.gf_filter_pck_get_timescale(self._pck)
+
+ @property
+ def interlaced(self):
+ return _libgpac.gf_filter_pck_get_interlaced(self._pck)
+
+ @interlaced.setter
+ def interlaced(self, value):
+ if self._is_src:
+ raise Exception('Cannot set interlaced on source packet')
+ return _libgpac.gf_filter_pck_set_interlaced(self._pck, value)
+
+ @property
+ def corrupted(self):
+ return _libgpac.gf_filter_pck_get_corrupted(self._pck)
+
+ @corrupted.setter
+ def corrupted(self, value):
+ if self._is_src:
+ raise Exception('Cannot set corrupted on source packet')
+ return _libgpac.gf_filter_pck_set_corrupted(self._pck, value)
+
+ @property
+ def seek(self):
+ return _libgpac.gf_filter_pck_get_seek_flag(self._pck)
+
+ @seek.setter
+ def seek(self, value):
+ if self._is_src:
+ raise Exception('Cannot set seek on source packet')
+ return _libgpac.gf_filter_pck_set_seek_flag(self._pck, value)
+
+ @property
+ def byte_offset(self):
+ return _libgpac.gf_filter_pck_get_byte_offset(self._pck)
+
+ @byte_offset.setter
+ def byte_offset(self, value):
+ if self._is_src:
+ raise Exception('Cannot set byte offset on source packet')
+ return _libgpac.gf_filter_pck_set_byte_offset(self._pck, value)
+
+ @property
+ def roll(self):
+ return _libgpac.gf_filter_pck_get_roll_info(self._pck)
+
+ @roll.setter
+ def roll(self):
+ if self._is_src:
+ raise Exception('Cannot set roll on source packet')
+ return _libgpac.gf_filter_pck_set_roll_info(self._pck, value)
+
+ @property
+ def crypt(self):
+ return _libgpac.gf_filter_pck_get_crypt_flags(self._pck)
+
+ @crypt.setter
+ def crypt(self, value):
+ if self._is_src:
+ raise Exception('Cannot set crypt on source packet')
+ return _libgpac.gf_filter_pck_set_crypt_flags(self._pck, value)
+
+ @property
+ def clock(self):
+ return _libgpac.gf_filter_pck_get_clock_type(self._pck)
+
+ @clock.setter
+ def clock(self, value):
+ if self._is_src:
+ raise Exception('Cannot set clock on source packet')
+ return _libgpac.gf_filter_pck_set_clock_type(self._pck, value)
+
+ @property
+ def carousel(self):
+ return _libgpac.gf_filter_pck_get_carousel_version(self._pck)
+
+ @carousel.setter
+ def carousel(self, value):
+ if self._is_src:
+ raise Exception('Cannot set carousel on source packet')
+ return _libgpac.gf_filter_pck_set_carousel_version(self._pck, value)
+
+ @property
+ def seqnum(self):
+ return _libgpac.gf_filter_pck_get_seq_num(self._pck)
+
+ @seqnum.setter
+ def seqnum(self):
+ if self._is_src:
+ raise Exception('Cannot set segnum on source packet')
+ return _libgpac.gf_filter_pck_set_seq_num(self._pck, value)
+
+ @property
+ def deps(self):
+ return _libgpac.gf_filter_pck_get_dependency_flags(self._pck)
+
+ @deps.setter
+ def deps(self, value):
+ if self._is_src:
+ raise Exception('Cannot set deps on source packet')
+ return _libgpac.gf_filter_pck_set_dependency_flags(self._pck, value)
+
+ @property
+ def has_properties(self):
+ if _libgpac.gf_filter_pck_has_properties(self._pck):
+ return True
+ return False
+
+ @property
+ def frame_ifce(self):
+ p = _libgpac.gf_filter_pck_get_frame_interface(self._pck)
+ if p:
+ return True
+ return False
+
+ @property
+ def frame_ifce_gl(self):
+ p = _libgpac.gf_filter_pck_get_frame_interface(self._pck)
+ if not p:
+ return False
+ if p.contents == 0:
+ return False
+ if p.contents.get_gl_texture == None:
+ return False
+ return True
+
+ ##\endcond private
+
+ #todo
+ #append ?
+
+## @}
+
+
+##\cond private
+_gf_fileio = c_void_p
+_libgpac.gf_fileio_new.argtypes = c_char_p, py_object, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p
+_libgpac.gf_fileio_new.restype = _gf_fileio
+
+_libgpac.gf_fileio_url.argtypes = _gf_fileio
+_libgpac.gf_fileio_url.restype = c_char_p
+
+_libgpac.gf_fileio_resource_url.argtypes = _gf_fileio
+_libgpac.gf_fileio_resource_url.restype = c_char_p
+
+_libgpac.gf_fileio_translate_url.argtypes = c_char_p
+_libgpac.gf_fileio_translate_url.restype = c_char_p
+
+_libgpac.gf_fileio_get_udta.argtypes = _gf_fileio
+_libgpac.gf_fileio_get_udta.restype = c_void_p
+
+_libgpac.gf_fileio_del.argtypes = _gf_fileio
+
+_libgpac.gf_fileio_tag_main_thread.argtypes = _gf_fileio
+
+#wraps gf_url_concatenate to be able to free the value
+#we declare a void * return value
+_libgpac.gf_url_concatenate.argtypes = c_char_p, c_char_p
+_libgpac.gf_url_concatenate.restype = c_void_p
+_libgpac.gf_url_free.argtypes = c_void_p
+
+def url_concatenate(_parent, _url):
+	#this is c_void_p
+	_path = _libgpac.gf_url_concatenate(_parent, _url)
+	if _path==None:
+		raise Exception('Failed to concatenate path, out of memory')
+	#this is a string
+	path = cast(_path, c_char_p).value.decode('utf-8')
+	#we still have the pointer, we can free it
+	_libgpac.gf_url_free(_path)
+	return path
+
+#fio open callback
+@CFUNCTYPE(_gf_fileio, _gf_fileio, c_char_p, c_char_p, POINTER(c_int))
+def fileio_cbk_open(_fio_ref, _url, _mode, error):
+ fio_ref = cast(_libgpac.gf_fileio_get_udta(_fio_ref), py_object).value
+ mode = _mode.decode('utf-8')
+ error.contents.value=GF_OK
+ if mode=="url":
+ path = url_concatenate(_libgpac.gf_fileio_resource_url(_fio_ref), _url);
+ new_gfio = FileIO(path, fio_ref)
+ fio_ref.factory.pending_urls.append(new_gfio)
+ #prevent garbage collection
+ fio_ref.factory.gc_exclude.append(new_gfio)
+ fio_ref.factory.all_refs+=1
+ return new_gfio._gf_fio
+
+ if mode=="ref":
+ fio_ref.nb_refs+=1
+ fio_ref.factory.all_refs+=1
+ return _fio_ref
+
+ if mode=="probe":
+ if not hasattr(fio_ref.factory.root_obj, 'exists'):
+ return None
+ if not fio_ref.factory.root_obj.exists(url):
+ error.contents.value=GF_URL_ERROR
+ return None
+
+ do_delete=False
+ if mode=="unref":
+ fio_ref.nb_refs-=1
+ fio_ref.factory.all_refs-=1
+ if fio_ref.nb_refs:
+ return _fio_ref
+ do_delete=True
+
+ if mode=="close":
+ if fio_ref.py_obj != None:
+ fio_ref.py_obj.close()
+ fio_ref.factory.all_refs-=1
+
+ if fio_ref.nb_refs:
+ return None
+ do_delete=True
+
+ if do_delete:
+ #file no longer used, can now be garbage collected
+ fio_ref.factory.gc_exclude.remove(fio_ref)
+
+ if not fio_ref.factory == fio_ref:
+ _libgpac.gf_fileio_del(fio_ref._gf_fio)
+ fio_ref._gf_fio = None
+
+ if not fio_ref.factory.all_refs and not len(fio_ref.factory.pending_urls) and not len(fio_ref.factory.gc_exclude):
+ _libgpac.gf_fileio_del(fio_ref.factory._gf_fio)
+ fio_ref.factory._gf_fio = None
+ fio_ref.factory.root_obj = None
+ return None
+
+
+	#this is an open() call
+ fio_url = _url.decode('utf-8')
+
+	#check if associated object exists, if not so we can use this instance
+ fio = None
+ if fio_ref.py_obj == None:
+ fio = fio_ref
+ if fio_ref in fio_ref.factory.pending_urls:
+ fio_ref.factory.all_refs-=1
+ fio_ref.factory.pending_urls.remove(fio_ref)
+
+	#check in pending urls
+ if fio == None:
+ for afio in fio_ref.factory.pending_urls:
+ a_url = _libgpac.gf_fileio_resource_url(afio._gf_fio).decode('utf-8')
+ if a_url == fio_url:
+ fio_ref.factory.all_refs-=1
+ fio_ref.factory.pending_urls.remove(afio)
+ fio = afio
+ break;
+
+	#we need to create a new FileIO
+ created=False
+ if fio==None:
+ created=True
+
+	#read url, translate
+ if fio_url.startswith('gfio://')==True:
+ fio_url = _libgpac.gf_fileio_translate_url(_url).decode('utf-8')
+	#if we create a new FileIO, we need to resolve url, against parent URL
+ elif created:
+ fio_url = url_concatenate(_libgpac.gf_fileio_resource_url(fio_ref._gf_fio), _url)
+
+ if fio==None:
+ fio = FileIO(fio_url, fio_ref)
+
+ #create object, direct copy of the object passed at construction
+ fio.py_obj = copy.copy(fio.factory.root_obj)
+ res = fio.py_obj.open(fio_url, mode)
+
+ if res==True:
+ if not fio in fio.factory.gc_exclude:
+ fio.factory.gc_exclude.append(fio)
+ fio.factory.all_refs+=1
+ return fio._gf_fio
+
+ #failure to open a new created object, remove FileIO and let the object be garbage collected
+ if created:
+ _libgpac.gf_fileio_del(fio._gf_fio)
+ fio._gf_fio = None
+
+ error.contents.value=GF_URL_ERROR
+ return None
+
+#fio write callback
+@CFUNCTYPE(c_uint, _gf_fileio, POINTER(c_ubyte), c_uint)
+def fileio_cbk_write(_fio, buf, size):
+ fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
+ if numpy_support:
+ ar_data = np.ctypeslib.as_array(buf, shape=(size,))
+ ar_data.flags.writeable=False
+ return fio.py_obj.write(ar_data, size)
+ return fio.py_obj.write(buf, size)
+
+#fio read callback
+@CFUNCTYPE(c_uint, _gf_fileio, POINTER(c_ubyte), c_uint)
+def fileio_cbk_read(_fio, buf, size):
+ fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
+ if numpy_support:
+ ar_data = np.ctypeslib.as_array(buf, shape=(size,))
+ ar_data.flags.writeable=True
+ return fio.py_obj.read(ar_data, size)
+ return fio.py_obj.read(buf, size)
+
+#fio seek callback
+@CFUNCTYPE(c_uint, _gf_fileio, c_ulonglong, c_int)
+def fileio_cbk_seek(_fio, pos, whence):
+ fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
+ return fio.py_obj.seek(pos, whence)
+
+#fio tell callback
+@CFUNCTYPE(c_ulonglong, _gf_fileio)
+def fileio_cbk_tell(_fio):
+ fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
+ return fio.py_obj.tell()
+
+#fio eof callback
+@CFUNCTYPE(gf_bool, _gf_fileio)
+def fileio_cbk_eof(_fio):
+ fio = cast(_libgpac.gf_fileio_get_udta(_fio), py_object).value
+ return fio.py_obj.eof()
+
+
+
+##\endcond private
+
+##
+# \defgroup pyfileio_grp libgpac core tools
+# \ingroup pycore_grp Python APIs
+# \brief FileIO tools for libgpac.
+#
+# @{
+
+
+## FileIO object for file IO callbacks from libgpac
+#
+#
+# The FileIO object is used to create input or output interfaces in which GPAC will read or write.
+# This allows generating content in python without any disk IO, or passing python data as input to GPAC without intermediate file.
+#
+# This object passed to the FileIO constructor must implement the following callbacks:
+#
+# \code boolean open(string URL, string mode)\endcode
+#Opens the file in read or write mode.
+#- URL: string containing file to open
+#- mode: open mode (same as fopen)
+#- return true if success, false otherwise
+#
+#\note There is no guarantee that the URL is checked for existence before calling open
+#\note There is no guarantee that the first call to open is on the URL provided for the constructor (e.g. for DASH generation, this will depend on the DASH profile used which may require to write the manifest after one or more segments)
+#
+# \code void close()\endcode
+#Closes the file
+#
+# \code int write(numpy buffer, unsigned long size)\endcode
+#Writes the file
+#- buffer: numpy array to fill if numpy support, ctypes.c_ubyte otherwise
+#- size: number of bytes to write starting from first byte in buffer
+#- return number of bytes writen, at most the size of the array
+#
+# \code int read(numy buffer, unsigned long size)\endcode
+#Reads the file
+#- buffer: numpy array to read if numpy support, ctypes.c_ubyte otherwise
+#- size: number of bytes to read
+#- return number of bytes read, at most the size of the array
+#
+# \code void seek(unsigned long long pos, int whence)\endcode
+#Seeks current position in file (same as fopen)
+#- pos: position
+#- whence: origin of the position
+#- return 0 if no error, error code otherwise
+#
+# \code unsigned long long tell()\endcode
+#Gets current position in file (same as ftell)
+#- pos: position
+#- return current position
+#
+# \code boolean eof()\endcode
+#Checks if the current position is at the end of the file (same as feof)
+#- return true if file end reached, false otherwise
+#
+# \code boolean exists(string URL)\endcode
+#Checks if the given URL exists. This callback is optional
+#- return true if associated URL exists, false otherwise
+#
+#\warning All these callbacks MUST perform synchronously
+#
+# The URL passed to the constructor indentifies the file name wrapped.
+# Some file types such as HLS or DASH manifest may imply reading or writing several files.
+# To handle these cases, the object passed to the constructor will be cloned for each call to open().
+#
+#\warning This object is a shallow copy of the factory object, not an empty object (difference with NodeJS bindings).
+#
+# All FileIO callbacks will be done in the main thread.
+#
+class FileIO:
+	## constructor for FileIO
+	#\param url url for this fileIO factory
+	#\param obj instance of the class used for IOs. This instance will be cloned (shallow copy) for each new file to open
+	def __init__(self, url, obj):
+		if 0:
+			## the underlying gfio:// URL to be provided to GPAC
+			self.url = 0
+
+##\cond private
+		_libgpac.user_init = True
+		self.nb_refs=0
+		self.py_obj = None
+		#this is internal constructor call from open
+		if obj.__class__.__name__=="FileIO":
+			self.factory = obj.factory
+		#this is regular constructor call
+		else:
+			if hasattr(obj, 'open')==False:
+				raise Exception('No open function on FileIO callback')
+			if hasattr(obj, 'close')==False:
+				raise Exception('No close function on FileIO callback')
+			if hasattr(obj, 'write')==False:
+				raise Exception('No write function on FileIO callback')
+			if hasattr(obj, 'read')==False:
+				raise Exception('No read function on FileIO callback')
+			if hasattr(obj, 'seek')==False:
+				raise Exception('No see function on FileIO callback')
+			if hasattr(obj, 'tell')==False:
+				raise Exception('No tell function on FileIO callback')
+			self.factory = self
+			self.factory.all_refs=0
+			self.factory.pending_urls=
+			#keep all created file IOs still useful here to prevent garbage collection
+			self.factory.gc_exclude=
+			self.factory.root_obj = obj
+
+		self._gf_fio = _libgpac.gf_fileio_new(url.encode('utf-8'), py_object(self), fileio_cbk_open, fileio_cbk_seek, fileio_cbk_read, fileio_cbk_write, fileio_cbk_tell, fileio_cbk_eof, None )
+		if self._gf_fio==None:
+			raise Exception('Failed to create FileIO for ' + url)
+		#ask for all file IOs to happen on main thread
+		_libgpac.gf_fileio_tag_main_thread(self._gf_fio)
+
+	@property
+	def url(self):
+		_url = _libgpac.gf_fileio_url(self._gf_fio)
+		if _url==None:
+			return None
+		return _url.decode('utf-8')
+##\endcond private
+
+## @}
+#

gpac-2.2.0.tar.gz/share/python/setup.py Added

gpac-2.0.0.tar.gz/share/scripts/jsf/avgen/init.js -> gpac-2.2.0.tar.gz/share/scripts/jsf/avgen/init.js Changed

gpac-2.0.0.tar.gz/share/scripts/jsf/avmix/help.js -> gpac-2.2.0.tar.gz/share/scripts/jsf/avmix/help.js Changed

@@ -143,9 +143,16 @@
 The syntax for \`start\` and  \`stop\` fields is:
 - \`now\`: resolves to current UTC clock in \`live\` mode, and to 0 for non-live mode
 - date: converted to UTC date in \`live\` mode, and to 0 for non-live mode
-- N: converted to current utc clock plus N seconds UTC
-- "N": converted to current utc clock plus N seconds UTC
+- N: converted to current utc clock (or 0 for non-live mode) plus N seconds UTC
+- "N": converted to current utc clock (or 0 for non-live mode) plus N seconds UTC
 
+In \'live\' mode, if \`start\` is set using a UTC date, the sequence will have a start range equal to \`MAX(current_UTC - start_in_UTC, 0)\`. Some sources may be skipped to fulfill this condition.
+This allows different instances of the filter using the same playlist to initialize media time in the same fashion.
+
+When reloading the playlist:
+- if the sequence is active, \`start\` value is ignored 
+- if the sequence was not started, \`start\` value is updated 
+- if the sequence was over, \`start\` value is updated only of greater than previous resolved UTC start time. 
 
 ## Sources
 ### Properties for \`source\` objects
@@ -162,6 +169,7 @@
 - keep_alive (false): if using a dedicated gpac process for one or more input, relaunch process(es) at source end if exit code is greater than 2 or if not responding after \`rtimeout\`
 - seek (false): if true and \`keep_alive\` is active, adjust \`start\` according to the time elapsed since source start when relaunching process(es)
 - prefetch (500): prefetch duration in ms (play before start time of source), 0 for no prefetch
+- hold (false): if media duration is known and media stop time is greater than media duration, activate no signal mode until desired stop time is reached (disable transition), otherwise move to next source at end of stream
 
 ## Source Locations
 ### Properties for \`sourceURL\` objects
@@ -325,6 +333,12 @@
   - out: audio fade-out when playing last frame at scene activation
   - inout: both fade-in and fade-out are enabled
   - other: no audio fade
+- autoshow (true): automatically deactivate scene when sequences set in \`sources\` are not active
+- nosig ('lost'): enable no-signal message for scenes using sequences:
+  - no: disable message
+  - lost: display message when signal is lost
+  - before: display message if source is not yet active
+  - all: always display message if source is inactive
 - styles (): list of style IDs to use
 - any other property exposed by the underlying scene JS module.
 
@@ -333,6 +347,8 @@
 
 A default scene will be injected if none is found when initially loading the playlist. If you need to start with an empty output, use a scene with no sequence associated.
 
+If a scene uses one or more sequences and \`autoshow\` is not set, the scene will be drawn with no sequence attached if all sequences are inactive (not yet started or over).
+
 ## Transitions and Mixing effects
 ### JSON syntax
 Properties for \`transition\` objects:
@@ -565,7 +581,6 @@
 EX 
 EX  {"replace": "scene1@x", "with": 20},
 EX  {"replace": "seq1@start", "with": "now"}
-EX  }
 EX 
 
 `;

gpac-2.0.0.tar.gz/share/scripts/jsf/avmix/init.js -> gpac-2.2.0.tar.gz/share/scripts/jsf/avmix/init.js Changed

@@ -1,9 +1,13 @@
-import {WebGLContext} from 'webgl'
 import * as evg from 'evg'
 import { Sys as sys } from 'gpaccore'
 import { AudioMixer as amix } from 'gpaccore'
 import * as os from 'os'
 
+//import {WebGLContext} from 'webgl'
+
+let WebGLContext = null;
+import('webgl').then(obj => { WebGLContext = obj.WebGLContext;}).catch(err => {});
+
 
 const UPDATE_PID = 1;
 const UPDATE_SIZE = 1<<1;
@@ -276,7 +280,7 @@
 filter.set_arg({ name: "maxdepth", desc: "maximum depth of a branch in the scene graph", type: GF_PROP_UINT, def: "100", hint:"expert"} );
 
 //video output options
-filter.set_arg({ name: "vsize", desc: "output video size", type: GF_PROP_VEC2, def: "1920x1080"} );
+filter.set_arg({ name: "vsize", desc: "output video size, 0 disable video output", type: GF_PROP_VEC2, def: "1920x1080"} );
 filter.set_arg({ name: "fps", desc: "output video frame rate", type: GF_PROP_FRACTION, def: "25"} );
 filter.set_arg({ name: "pfmt", desc: "output pixel format. Use \`rgba\` in GPU mode to force alpha channel", type: GF_PROP_PIXFMT, def: "yuv"} );
 filter.set_arg({ name: "dynpfmt", desc: `allow dynamic change of output pixel format in software mode
@@ -285,8 +289,8 @@
 - all: pixel format changes each time a full-screen input PID at same resolution is used`, type: GF_PROP_UINT, def: "init", minmax_enum: 'off|init|all', hint:"expert"} );
 
 //audio output options
-filter.set_arg({ name: "sr", desc: "output audio sample rate", type: GF_PROP_UINT, def: "44100"} );
-filter.set_arg({ name: "ch", desc: "number of output audio channels", type: GF_PROP_UINT, def: "2"} );
+filter.set_arg({ name: "sr", desc: "output audio sample rate, 0 disable audio output", type: GF_PROP_UINT, def: "44100"} );
+filter.set_arg({ name: "ch", desc: "number of output audio channels, 0 disable audio output", type: GF_PROP_UINT, def: "2"} );
 filter.set_arg({ name: "afmt", desc: "output audio format (only s16, s32, flt and dbl are supported)", type: GF_PROP_PCMFMT, def: "s16"} );
 filter.set_arg({ name: "alen", desc: "default number of samples per frame", type: GF_PROP_UINT, def: "1024", hint:"expert"} );
 
@@ -528,6 +532,10 @@
 	if (filter.maxdepth<=0)
 		filter.maxdepth = 100;
 
+	if ((WebGLContext == null) && this.gpu) {
+		print(GF_LOG_INFO, 'GPAC compiled without WebGL, using software mode');
+		this.gpu = 0;
+	}
 	if (this.gpu) {
 		video_width = filter.vsize.x;
 		video_height = filter.vsize.y;
@@ -548,6 +556,8 @@
 
 	configure_vout();
 	configure_aout();
+	if (filter.live)
+		print(GF_LOG_INFO, 'Initialized at ' + new Date());;
 
 	if (!filter.ltimeout)
 			filter.ltimeout = 1000;
@@ -610,6 +620,21 @@
 	if (filter.gpu) {
 		print(GF_LOG_INFO, (filter.live ? 'Live ' : '' ) + 'Video output ' + filter.vsize.x + 'x' + filter.vsize.y + ' FPS ' + filter.fps.n + '/' + filter.fps.d + ' OpenGL pixfmt ' + filter.pfmt);
 	} else {
+		let test_canvas=null;
+		try {
+			test_canvas = new evg.Canvas(48, 48, filter.pfmt);
+		} catch (e) {
+			let change_fmt;
+		 if (sys.pixfmt_yuv(filter.pfmt)) {
+				let bpp = sys.pixfmt_depth(filter.pfmt);
+				change_fmt = (bpp>8) ? 'yp4l' : 'yuv4';
+		 } else {
+				change_fmt = 'rgb';
+		 }
+			print(GF_LOG_WARNING, 'Pixel format ' + filter.pfmt + ' not supported by rasterizer, defaulting to ' + change_fmt);
+			filter.pfmt = change_fmt;
+		}
+
 		print(GF_LOG_INFO, (filter.live ? 'Live ' : '' ) + 'Video output ' + filter.vsize.x + 'x' + filter.vsize.y + ' FPS ' + filter.fps.n + '/' + filter.fps.d + ' pixfmt ' + filter.pfmt);
 	}
 
@@ -686,18 +711,7 @@
 	max_aframe_size = sample_size * channels * sample_per_frame;
 	chan_buffer = new Float32Array(channels);
 
-	if (audio_afmt === 's32') {
-		filter.get_sample = function(buf, idx) { return buf.getInt32(idx, true) / 4294967295; };
-		filter.set_sample = function(buf, idx, val) { return buf.setInt32(idx, val * 4294967295, true); };
-	} else if (audio_afmt === 's16') {
-		filter.get_sample = function(buf, idx) { return buf.getInt16(idx, true) / 65535; };
-		filter.set_sample = function(buf, idx, val) { return buf.setInt16(idx, val*65535, true); };
-	} else if (audio_afmt === 'flt') {
-		filter.get_sample = function(buf, idx) { return buf.getFloat32(idx); };
-		filter.set_sample = function(buf, idx, val) { return buf.setFloat32(idx, val); };
-	} else if (audio_afmt === 'dbl') {
-		filter.get_sample = function(buf, idx) { return buf.getFloat64(idx); };
-		filter.set_sample = function(buf, idx, val) { return buf.setFloat64(idx, val); };
+	if ((audio_afmt === 's32') || (audio_afmt === 's16') || (audio_afmt === 'flt') || (audio_afmt === 'dbl')) {
 	} else {
 		print(GF_LOG_ERROR, 'Unsupported sample format ' + audio_afmt);
 		sys.exit(1);
@@ -744,6 +758,9 @@
 	let p = pid.get_prop('StreamType');
 	let ts = 0;
 	if (p == 'Visual') {
+		//silently ignore
+		if (!vout) return GF_EOS;
+
 		pid.pfmt = pid.get_prop('PixelFormat');
 		pid.type = TYPE_VIDEO;
 		ts = video_timescale;
@@ -753,8 +770,12 @@
 		pid.reconfigure = true;
 		pid.mirror = pid.get_prop('Mirror');
 		pid.rotate = pid.get_prop('Rotate');
+		pid.pfmt_check = 0;
 	}	
 	else if (p == 'Audio') {
+		//silently ignore
+		if (!aout) return GF_EOS;
+
 		pid.type = TYPE_AUDIO;
 		pid.data = null;
 		ts = audio_timescale;
@@ -772,6 +793,8 @@
 		pid.last_sample_time = 0;
 	} else {
 		pid.type = TYPE_UNHANDLED;
+		//silently ignore
+		return GF_EOS;
 	}
 
 	if (pid.timescale != ts) {
@@ -820,6 +843,12 @@
 if (index < 0) return;
 pids.splice(index, 1);
 
+ if (typeof pid.source != 'undefined') {
+	 index = pid.source.pids.indexOf(pid);
+	 if (index>=0)
+			pid.source.pids.splice(index, 1);
+ }
+
 	do_traverse(root_scene, scene => {
 		for (let i=0; i<scene.mod.pids.length; i++) {
 			let pid_link = scene.mod.pidsi;
@@ -1106,6 +1135,9 @@
 	}
 
 	if (do_audio) {
+		//video is not playing, we must update the scenes for audio
+		if (!vout) update_display_list();
+
 		process_audio();
 		if (!video_playing) {
 			video_time = audio_time * video_timescale;
@@ -1742,6 +1774,31 @@
 	//not ready
 	if (!scene_update_visual_pids(scene)) return;
 
+	scene.no_signal_time = 0;
+	//sequences defined, check for no sequence active if autoshow / nosig are set 
+	if (scene.sequences.length && scene.check_active) {
+		let disabled=true;
+		let min_nosig = 0;
+		scene.sequences.forEach (seq => {
+			if (seq.active_state != 1) {
+				if ( (seq.start_time > current_utc_clock) && (!min_nosig || (min_nosig>seq.start_time)) )
+					min_nosig = seq.start_time;
+				return;
+			}
+			seq.sources.forEach(s => {
+				if (!s.in_prefetch) disabled = false;
+			});
+		});
+		if (disabled) {
+			//sequence not yet activated but we monitor no signal message
+			if ((scene.nosig == 'before') && min_nosig) {}
+			//sequence not activate, don't draw if autoshow
+			else if (scene.nosig != 'all') {
+				if (scene.autoshow) return;
+			}
+			scene.no_signal_time = min_nosig ? min_nosig : -1;
+		}
+	}
 	//compute scene size in pixels
 	let sw = get_dim(scene, true);
 	let sh = get_dim(scene, false);
@@ -1850,20 +1907,40 @@
 
 	if (!has_clip_mask && cover_type) {
 		let opaque_pid_idx = scene.mod.fullscreen();
+		let skip_opaque_test = false;
+		//no pids associated (inactive sequence), do not reuse input pck
 		if (scene.sequences.length && !scene.mod.pids.length) {
-		} else if ((scene.sequences.length>1) && scene.transition) {
+			skip_opaque_test = true;
+		}
+		//scene is using mix effect between sequence, do not reuse input pck
+		else if ((scene.sequences.length>1) && scene.transition) {
+			skip_opaque_test = true;
+		} else if (scene.mod.pids.length) {
+			let s = scene.mod.pids0.pid.source;
+			//no signal on input, do not reuse input pck (which may be non-null if `hold` was set)
+			if (s.no_signal)
+				skip_opaque_test = true;
+			//sequence us in active transision state, do not reuse input pck
+			else if ((s.sequence.transition_state>1) && (s.sequence.transition_state<4))
+				skip_opaque_test = true;
+		}
+
+		//no reuse, force scene draw
+		if (skip_opaque_test) {
+			scene.mod.force_draw = true;
 		} else {
+			//get opaque pid
 			if ((opaque_pid_idx>=0) && (opaque_pid_idx<scene.mod.pids.length)) {
 				opaque_pid = scene.mod.pidsopaque_pid_idx.pid;
 			}
-
 			if (!opaque_pid) {
 				is_opaque = scene.mod.is_opaque() || false;
 			} else {
-				//disable reuse if transition
-				if (opaque_pid.source.sequence.transition_state) {
+				//disable reuse if transition is active on pid
+				if ((opaque_pid.source.sequence.transition_state>1) && (opaque_pid.source.sequence.transition_state<4)) {
 					opaque_pid = null;
 					is_opaque = false;
+					scene.mod.force_draw = true;
 				}
 			}
 		}
@@ -1969,35 +2046,40 @@
 function draw_display_list_2d()
 {
 	display_list.forEach(ctx => {
-			if (!set_active_scene(ctx)) return;
-
-			//offscreen group
-			if (ctx.group) {
-				//only used to get the matrix
-				active_scene = ctx;
-				ctx.group.texture.mx = ctx.group.texture_mx;
-				ctx.group.texture.set_alphaf(ctx.group.opacity);
-				canvas_draw(ctx.group.path, ctx.group.texture, true);
-				return;
-			}
-			let scene = ctx.scene;
-
-			if (mask_mode) {
-				scene.mod.screen_rect = null;
-			} else if (round_scene_size && scene.sequences.length && scene.mod.screen_rect) {
-				scene.mod.screen_rect = round_rect(scene.mod.screen_rect);
-			}
+		if (!set_active_scene(ctx)) return;
+		//offscreen group
+		if (ctx.group) {
+			//only used to get the matrix
+			active_scene = ctx;
+			ctx.group.texture.mx = ctx.group.texture_mx;
+			ctx.group.texture.set_alphaf(ctx.group.opacity);
+			canvas_draw(ctx.group.path, ctx.group.texture, true);
+			return;
+		}
+		let scene = ctx.scene;
+
+		//if mask is active or if transition is active, disable blit
+		if (mask_mode
+			|| (scene.mod.pids.length && scene.mod.pids0.pid && ((scene.mod.pids0.pid.source.sequence.transition_state==3) || scene.mod.pids0.pid.source.no_signal))
+		) {
+			scene.mod.screen_rect = null;
+		} else if (round_scene_size && scene.sequences.length && scene.mod.screen_rect) {
+			scene.mod.screen_rect = round_rect(scene.mod.screen_rect);
+		}
 
-			if (1) {
-					scene.mod.draw(canvas);
-			} else {
-				try {
-					scene.mod.draw(canvas);
-				} catch (e) {
-					print(GF_LOG_ERROR, 'Error during scene ' + scene.id + ' draw, disabling scene - error was ');
-					scene.active = false;
-				}
+		if (scene.no_signal_time) {
+			draw_scene_no_signal();
+		}
+		else if (1) {
+				scene.mod.draw(canvas);
+		} else {
+			try {
+				scene.mod.draw(canvas);
+			} catch (e) {
+				print(GF_LOG_ERROR, 'Error during scene ' + scene.id + ' draw, disabling scene - error was ');
+				scene.active = false;
 			}
+		}
 
 		canvas.matrix = null;
 		canvas.path = null;
@@ -2006,6 +2088,18 @@
 }
 
 
+function update_display_list()
+{
+ display_list.length = 0;
+ has_clip_mask = false;
+	has_opaque = false;
+	reference_width = video_width;
+	reference_height = video_height;
+	active_camera = null;
+	global_transform.identity = true;
+	root_scene.scenes.forEach(elm => do_traverse_all(elm, update_scene) );
+}
+
 function process_video()
 {
 	if (!video_inputs_ready) {
@@ -2039,14 +2133,7 @@
 		}
 	}
 
- display_list.length = 0;
- has_clip_mask = false;
-	has_opaque = false;
-	reference_width = video_width;
-	reference_height = video_height;
-	active_camera = null;
-	global_transform.identity = true;
-	root_scene.scenes.forEach(elm => do_traverse_all(elm, update_scene) );
+	update_display_list();
 
 //sort display list - BROKEN if multiple scene instances
 display_list.sort( (e1, e2) => { return e1.zorder - e2.zorder ; } );
@@ -2070,7 +2157,17 @@
 				pid_background = ctx.opaque_pid;
 				pid_background_forward = (ctx.scene && ctx.scene.mod.identity()) || false;
 
-				if (!pid_background.pck) {
+				//first time we try using this pid as base for canvas, check if pixel format is supported as canvas target
+				if (ctx.opaque_pid.pfmt_check==0) {
+					ctx.opaque_pid.pfmt_check = 1;
+					try {
+						let cnv = new evg.Canvas(48, 48, pid.pfmt);
+					} catch (e) {
+						ctx.opaque_pid.pfmt_check = 2;
+					}
+				}
+
+				if (!pid_background.pck || (ctx.opaque_pid.pfmt_check == 2)) {
 					pid_background_forward = false;
 					pid_background = null;
 					has_opaque = false;
@@ -2331,9 +2428,14 @@
 
 	}
 
+	let empty_ok = false;
 	pids.forEach(pid => {
 		if (pid.type != TYPE_AUDIO) return;
 		if (!pid.source.playing) return;
+		if (pid.source.no_signal_state) {
+			empty_ok = true;
+			return;
+		}
 		if (pid.source.disabled) return;
 		if (pid.eos) return;
 		if (pid.done) return;
@@ -2364,13 +2466,16 @@
 				print(GF_LOG_DEBUG, 'waiting for audio frame');
 				return;
 			}
-			let atime = init_clock_us + (audio_time + 2*filter.alen)*1000000/filter.sr;
-			let now = sys.clock_us();
-			if (atime >= now) {
-				print(GF_LOG_DEBUG, 'waiting for audio frame');
-				return;
+			if (!empty_ok) {
+				let atime = init_clock_us + (audio_time + 2*filter.alen)*1000000/filter.sr;
+				let now = sys.clock_us();
+				if (atime >= now) {
+					print(GF_LOG_DEBUG, 'waiting for audio frame');
+					return;
+				}
+				if (!empty_ok)
+					print(GF_LOG_WARNING, 'empty audio input but audio frame due since ' + Math.ceil(now-atime) + ' us');
 			}
-			print(GF_LOG_WARNING, 'empty audio input but audio frame due since ' + Math.ceil(now-atime) + ' us');
 		}
 
 		//send an empty packet of 100 samples
@@ -2543,6 +2648,7 @@
 	}
 
 	s.video_time_at_init = 0;
+	let force_load_source = false;
 
 	while (1) {
 
@@ -2560,7 +2666,7 @@
 	}
 
 	let next_src = next_source(s, false);
-	let is_same_source = (next_src === s) ? true : false;
+	let is_same_source = (!force_load_source && (next_src === s)) ? true : false;
 	if (force_seq_reload)
 		is_same_source = false;
 
@@ -2608,6 +2714,7 @@
 			if (dur && (dur < s.sequence.start_offset)) {
 				print(GF_LOG_DEBUG, 'source ' + next_src.logname + ' will end before sequence start offset ' + s.sequence.start_offset + ' - skipping');
 				s = next_src;
+				force_load_source = true;
 				continue;	
 			}
 
@@ -2620,6 +2727,7 @@
 		}
 	} else if (! is_transition_start) {
 		inactive_sources++;
+		s.sequence.active_state = 2;
 		print(GF_LOG_DEBUG, 'sequence over');
 	}
 	return;
@@ -2642,21 +2750,27 @@
 	//check if source must be started
 	if (!s.playing) {
 		if (!s.sequence.active_state && (s.sequence.start_time>0) && (s.sequence.start_time <= current_utc_clock + s.prefetch_ms)) {
-			s.sequence.start_offset = (current_utc_clock + s.prefetch_ms - s.sequence.start_time ) / 1000.0;
-			if (s.sequence.start_offset<0.1) s.sequence.start_offset = 0;
+			if (s.sequence.skip_start_offset) {
+				s.sequence.start_offset = 0;
+				print(GF_LOG_INFO, 'Starting sequence ' + s.sequence.id + ' at UTC ' + current_utc_clock);
+			} else {
+				s.sequence.start_offset = (current_utc_clock + s.prefetch_ms - s.sequence.start_time ) / 1000.0;
+				if (s.sequence.start_offset<0) s.sequence.start_offset = 0;
+				print(GF_LOG_INFO, 'Starting sequence ' + s.sequence.id + ' at UTC ' + current_utc_clock + ' with start offset ' + s.sequence.start_offset + ' sec');
+			}
+
 			s.sequence.active_state = 1;
 			if (s.sequence.id)
 				trigger_watcher(s.sequence, 'active', true);
 
-			print(GF_LOG_DEBUG, 'Starting sequence start offset ' + s.sequence.start_offset + ' - ' + s.sequence.start_time + ' - UTC ' + current_utc_clock);
-
 			if (s.media_start + s.media_stop < s.sequence.start_offset) {
-					print(GF_LOG_DEBUG, 'source ' + s.logname + ' will end before sequence start_offset, skipping source ');
+					print(GF_LOG_INFO, 'source ' + s.logname + ' will end before sequence start_offset, skipping source');
 					s.sequence.start_offset -= s.media_start + s.media_stop;
 					inactive_sources++;
 					sequence_over(s, false);
 					return;
 			} else {
+					print(GF_LOG_INFO, 'source ' + s.logname + ' open');
 				open_source(s);
 				play_source(s);
 				if (current_utc_clock < s.sequence.start_time) {
@@ -2778,10 +2892,23 @@
 		//source is active (has packets)
 		nb_active++;
 
-		if (!s.sequence.prefetch_check) {
+		let check_transition = false;
+		if (video_playing) {
+			if (pid.type == TYPE_VIDEO) check_transition = true;
+		} else {
+			if (pid.type != TYPE_VIDEO) check_transition = true;
+		}
+
+		if (!s.sequence.prefetch_check && check_transition) {
 			let check_end = s.duration;
 			if ((s.media_stop>s.media_start) && (s.media_stop<s.duration)) check_end = s.media_stop;
 
+			if (s.duration && s.hold && (s.media_stop > s.duration)) {
+				s.sequence.transition_state = 4;
+				s.transition_offset = 0;
+				s.sequence.transition_dur = 0;
+			}
+
 			if ((s.sequence.transition_state<=1) && s.sequence.transition_effect && next_source(s, true) ) {
 				let dur = s.sequence.transition_effect.dur || 0;
 				if (dur) {
@@ -2824,7 +2951,7 @@
 			}
 		}
 
-		if (s.sequence.transition_state==1) {
+		if (check_transition && (s.sequence.transition_state==1)) {
 			let check_end = s.duration;
 			if ((s.media_stop>s.media_start) && (s.media_stop<s.duration)) check_end = s.media_stop;
 
@@ -2936,14 +3063,13 @@
 			}
 		}
 
-		print(GF_LOG_DEBUG, 'Video from ' + s.logname + ' will draw pck CTS ' + pid.pck.cts + ' translated ' + pid.frame_ts + ' video time ' + video_time);
+		print(GF_LOG_DEBUG, 'Video from ' + s.logname + ' will draw pck CTS ' + pid.pck.cts + '/' + pid.timescale + ' translated ' + pid.frame_ts + ' video time ' + video_time);
 		return;
 	}
 	});
 	//done fetching pids
 
 	if (s.pids.length && (nb_over == s.pids.length)) {
-		print(GF_LOG_INFO, 'source ' + s.logname + ' is over - transition state: ' + s.sequence.transition_state);
 		nb_over = 1;
 		let relaunch=false;
 		s.src.forEach(src => {
@@ -2964,6 +3090,38 @@
 
 		if (relaunch) {
 			source_restart = true;
+		} else if (s.duration && s.hold && (s.media_stop > s.duration)) {
+			let pid = s.pids0;
+			let target_end, ref_time, ref_timescale;
+			if (pid.type == TYPE_VIDEO) {
+				ref_timescale = video_timescale;
+				ref_time = video_time;
+			} else {
+				ref_timescale = audio_timescale;
+				ref_time = audio_time;
+			}
+			target_end = pid.init_clock + ref_timescale * (s.media_stop - s.media_start);
+
+			if (target_end > ref_time) {
+				nb_over = 0;
+				s.no_signal = true;
+				if (!s.no_signal_state) {
+					print(GF_LOG_INFO, 'source ' + s.logname + ' is over but hold enabled, entering no signal state');
+				}
+				s.no_signal_state = (target_end - ref_time) / ref_timescale;
+				return;
+			} else {
+				s.no_signal = false;
+				s.no_signal_state = false;
+				//first source in sequence is done, reset start offset
+				s.sequence.start_offset = 0;
+				s.sequence.transition_state = 0;
+				print(GF_LOG_INFO, 'source ' + s.logname + ' is over, exiting no signal state');
+			}
+		} else {
+			//first source in sequence is done, reset start offset
+			s.sequence.start_offset = 0;
+			print(GF_LOG_INFO, 'source ' + s.logname + ' is over - transition state: ' + s.sequence.transition_state);
 		}
 } else if (!s.pids.length && s.has_ka_process) {
 	nb_over = 0;
@@ -2979,6 +3137,7 @@
 	 if (nb_over == s.src.length) {
 	 	nb_over = 1;
 	 	force_seq_over = true;
+			return;
 	 } else {
 	 	nb_over = 0;
 	 }
@@ -3064,15 +3223,22 @@
 }
 
 
-function get_source(id, src)
+function get_source(id, src, par_seq)
 {
 	for (let i=0; i<sources.length; i++) {
-		let elem = sourcesi; 
+		let elem = sourcesi;
+		//if parent sequence is given and differs from source parent, not our source
+		if (par_seq && (elem.sequence != par_seq)) continue;
+		//same id, this is our source
 		if (id && (elem.id == id)) return elem;
+		
+		//if source ID is given and differs from source ID, not our source. This allows having 2 sources with the same URLs in the same sequence
+		if (id && (elem.id != id)) continue;
+
 		if (src && (elem.src.length == src.length)) {
 			let diff = false;
 			elem.src.forEach( (v, index) => {
-				if (!(v.in === srcindex.in)) diff = true; // Romain: if sources have the same input name they are discarded!!
+				if (!(v.in === srcindex.in)) diff = true; // FIXME: if sources have the same input name they are discarded!!
 				let id1 = v.id || 0;
 				let id2 = srcindex.id || 0;
 				if (id1 && id2 && !(id1 === id2)) diff = true;
@@ -3252,6 +3418,8 @@
 //	filter.reset_source();
 	wait_for_pids = current_utc_clock;
 
+	print(GF_LOG_DEBUG, 'Open source ' + s.logname);
+
 s.has_ka_process = false;
 	s.src.forEach(src => {
 
@@ -3485,6 +3653,7 @@
 	else
 		src.mix = true;
 
+	src.hold = pl_el.hold || false;
 	src.seek = pl_el.seek || false;
 	if (typeof pl_el.prefetch_ms == 'number') src.prefetch_ms = pl_el.prefetch;
 	else src.prefetch_ms = 500;
@@ -3511,6 +3680,8 @@
 	s.mix_volume = 1.0;
 	s.keep_alive = el.keep_alive || false;
 	s.video_time_at_init = 0;
+	s.no_signal = false;
+	s.no_signal_state = false;
 
 	sources.push(s);
 	if (s.id==="") {
@@ -3551,13 +3722,14 @@
 
 	let id = src_pl.id || 0;
 
-	let src = get_source(id, src_pl.src);
+	let par_seq = seq_pl ? get_sequence_by_json(seq_pl) : null;
+	let src = get_source(id, src_pl.src, par_seq);
+
 	if (!src) {
 		push_source(src_pl, id, seq_pl);
 	} else {
-		let par_seq = get_sequence_by_json(seq_pl);
 		if (src.sequence != par_seq) {
-			print(GF_LOG_ERROR, 'source update cannot change parent sequence, ignoring');
+			print(GF_LOG_ERROR, 'source update cannot change parent sequence, ignoring ' + JSON.stringify(seq_pl));
 			return;
 		}
 		src.pl_update = true;
@@ -3594,6 +3766,7 @@
 		if (propertyName == 'fade') continue;
 		if (propertyName == 'keep_alive') continue;
 		if (propertyName == 'seek') continue;
+		if (propertyName == 'hold') continue;
 
 		if (propertyName.charAt(0) == '_') continue;
 
@@ -3653,6 +3826,7 @@
 	//got new seg
 	seq.pl_update = true;
 
+	let first = seq.crc ? false : true;
 	let crc = sys.crc32(JSON.stringify(pl));
 	if (crc != seq.crc) {
 		seq.crc = crc;
@@ -3663,11 +3837,32 @@
 		return;
 	}
 
- //parse UTC start time
-	if (seq.start_time<=0) {
+ //parse UTC start time. If reload and new start and active, we cannot modify the start time
+	if (!first && (seq.start_time_json != pl.start) && (seq.active_state == 1)) {
+		print(GF_LOG_ERROR, 'Cannot change sequence start time while active, ignoring start ' + pl.start);
+	}
+	//we're not started or over, parse the new start
+	else if (seq.active_state != 1) {
+		let old_start = seq.start_time;
+		let old_start_json = seq.start_time_json;
 		seq.start_time = parse_date_time(pl.start, true);
-		if (seq.start_time<0) 
+		if (seq.start_time<0) {
 			seq.start_time = -1;
+		}
+		//start is a date, don't skip range adjustment
+		else if ((typeof pl.start == 'string') && (pl.start.indexOf(':')>0)) {
+			seq.skip_start_offset = false;
+		}
+		//start is not a date, source will start from its start range
+		else {
+			seq.skip_start_offset = true;
+		}
+		//seq is over, check if we need to restart
+		if (seq.active_state>1) {
+			if ((pl.start != "now") && (pl.start != old_start_json) && (seq.start_time > old_start))
+				seq.active_state = 0;
+		}
+		seq.start_time_json = pl.start;
 	}
 
 	seq.stop_time = parse_date_time(pl.stop, true);
@@ -4358,7 +4553,7 @@
 		if (!elem) elem = get_script(s_id);
 		if (!elem) elem = get_timer(s_id);
 		if (!elem) elem = get_sequence(s_id);
-		if (!elem) elem = get_source(s_id);
+		if (!elem) elem = get_source(s_id, null, null);
 
 		if (!elem) {
 			print(GF_LOG_WARNING, 'No watchable element with ID ' + s_id + ' discarding watcher');
@@ -4813,6 +5008,8 @@
 	{ name: "volume", def_val: 1, update_flag: 0, is_mod: true},
 	{ name: "fade", def_val: "inout", update_flag: 0, is_mod: true},
 	{ name: "mix_ratio", def_val: 0, update_flag: 0, is_mod: true},
+	{ name: "autoshow", def_val: true, update_flag: 0, is_mod: false},
+	{ name: "nosig", def_val: "lost", update_flag: 0, is_mod: false},
 ;
 
 function scene_get_update_type(prop_name)
@@ -4861,6 +5058,10 @@
 		}
 	});
 
+	scene.check_active = false;
+	if (scene.autoshow || (scene.nosig != 'lost'))
+		scene.check_active = true;
+
 	//common with group
 	parse_group_transform(scene, params);
 
@@ -5240,7 +5441,7 @@
 {
 	let res = -1;
 	if (typeof d == 'string') {
-		//float as string means offset to current time, wether live or offline
+		//float as string means offset to current time, whether live or offline
 		if (d.indexOf(':')<0) {
 			res = parseFloat(d);
 			//NaN
@@ -5930,6 +6131,8 @@
 
 function draw_scene_no_signal()
 {
+	if (active_scene && (active_scene.nosig == 'no')) return;
+
 	if (!no_signal_path) no_signal_path = new evg.Text();
 
 	let text = no_signal_path;
@@ -5945,14 +6148,19 @@
 	if (no_signal_text==null) {
 		//let version = 'GPAC '+sys.version + ' API '+sys.version_major+'.'+sys.version_minor+'.'+sys.version_micro;
 		let version = 'GPAC ' + (sys.test_mode ? 'Test Mode' : sys.version_full);
-		no_signal_text = 'No input', '', version, '(c) 2000-2021 Telecom Paris';
+		no_signal_text = 'No input', '', version, '(c) 2000-2022 Telecom Paris';
 	}
 	let s1 = null;
 	if (active_scene && active_scene.mod.pids.length) {
 		if (sys.test_mode) 
 			s1 = 'Signal lost';
+		else if (active_scene.mod.pids0.pid.source.no_signal_state)
+			s1 = 'No signal (next scheduled in ' + Math.floor(active_scene.mod.pids0.pid.source.no_signal_state) + ' s)';
 		else
 			s1 = 'Signal lost (' + Math.floor(active_scene.mod.pids0.pid.source.no_signal/1000) + ' s)';
+	} else if (active_scene && (active_scene.no_signal_time>0)) {
+		let next = new Date(active_scene.no_signal_time);
+		s1 = 'No input (next schedule ' + next.toUTCString() + ' s)';
 	} else {
 		s1 = 'No input';
 	}
@@ -5965,11 +6173,14 @@
 	}
 
 	if (active_scene)
-		no_signal_transform.copy(global_transform)
+		no_signal_transform.copy(active_scene.mx);
 	else
 		no_signal_transform.identity = true;
 
 no_signal_transform.translate(-w/2, 0);
+ //comment if align to left
+ let m = text.measure();
+ no_signal_transform.translate(m.width/2, 0);
 
 if (!no_signal_outline) {
 	no_signal_outline = text.get_path().outline( { width: 6, align: GF_PATH_LINE_CENTER, cap: GF_LINE_CAP_ROUND, join: GF_LINE_JOIN_ROUND } );
@@ -6494,7 +6705,6 @@
 {
 	let scene = active_scene;
 	let pids = scene.mod.pids;
-
 	let op_type = 0;
 	let op_param = 0;
 	let op_tx = null;
@@ -6510,6 +6720,11 @@
 		scene.active=false;
 		return;
 	}
+
+	if (pids0.pid.source.no_signal) {
+		draw_scene_no_signal();
+		return;
+	}
 	if ((pids.length==1) && !op_type) {
 		let tx = pids0.texture;
 		//should not happen
@@ -6519,11 +6734,6 @@
 	 return; 
 	}
 
-	if (pids0.pid.source.no_signal) {
-		draw_scene_no_signal();
-		return;
-	}
-
 	if (op_type) {
 	 if ((op_type == GF_EVG_OPERAND_MIX_DYN) || (op_type == GF_EVG_OPERAND_MIX_DYN_ALPHA)) {
 			if (pids.length<=1) {
@@ -6572,6 +6782,7 @@
 
 		//as fraction
 		ratio = time / seq.transition_dur;
+		if (ratio>1) ratio=1;
 	} else if (scene.transition) {
 		let skip_tansition = !use_gpu;
 		transition = scene.transition;
@@ -7381,7 +7592,7 @@
 {
 	let media_time = -4;
 	if ((arguments.length == 1) && arguments0) {
-		let s = get_source(arguments0, null);
+		let s = get_source(arguments0, null, null);
 		if (!s) return -4;
 		if (!s.playing) return -3;
 		if (s.in_prefetch) return -1;
@@ -7642,6 +7853,14 @@
 				return false;
 			} else {
 				seq.start_time = parse_date_time(pl.with, true);
+				//start is a date, don't skip range adjustment
+				if ((typeof pl.with == 'string') && (pl.with.indexOf(':')>0)) {
+					seq.skip_start_offset = false;
+				}
+				//start is not a date, source will start from its start range
+				else {
+					seq.skip_start_offset = true;
+				}
 				seq.active_state = 0;
 				seq.stop_time = 0;
 			}

gpac-2.0.0.tar.gz/share/scripts/jsf/avmix/scenes/shape.js -> gpac-2.2.0.tar.gz/share/scripts/jsf/avmix/scenes/shape.js Changed

@@ -47,6 +47,7 @@
 - mem: replaced by current memory usage of process
 - version: replaced by GPAC version
 - fversion: replaced by GPAC full version
+- P4CC, PropName: replaced by corresponding PID property
 
 ## Custom paths
 
@@ -96,7 +97,7 @@
 {name:"rs", value: false, desc: "repeat texture horizontally", dirty: UPDATE_SIZE},
 {name:"rt", value: false, desc: "repeat texture vertically", dirty: UPDATE_SIZE},
 {name:"keep_ar", value: true, desc: "keep aspect ratio", dirty: UPDATE_POS},
- {name:"pad_color", value: "none", desc: `color to use for texture padding if \`rs\` or \`rt\` are false. Use \`none\` to use texture edge, \`0x00FFFFFF\` for transparent (always enforced if source is transparent)`, dirty: UPDATE_POS},
+ {name:"pad_color", value: "0x00FFFFFF", desc: `color to use for texture padding if \`rs\` or \`rt\` are false. Use \`none\` to use texture edge, \`0x00FFFFFF\` for transparent (always enforced if source is transparent)`, dirty: UPDATE_POS},
 {name:"txmx", value: , desc: "texture matrix - all 6 coefficients must be set, i.e. xx xy tx yx yy ty", dirty: UPDATE_POS},
 {name:"cmx", value: , desc: "color transform - all 20 coefficients must be set in order, i.e. Mrr, Mrg, Mrb, Mra, Tr, Mgr, Mgg ...", dirty: UPDATE_POS},
 {name:"line_width", value: 0, desc: "line width in percent of width if positive, or absolute value if negative", dirty: UPDATE_LINE},
@@ -403,6 +404,7 @@
 }
 }
 this.blit_path = null;
+ tx_info.pad_color = pad_color_pid;
 if ((sw != sw_o) || (sh != sh_o)) {
 this.can_reuse = false;
 scale_tx_sw = sw_o / sw;
@@ -422,7 +424,6 @@
 }
 } else {
 this.use_blit = false;
- tx_info.pad_color = pad_color_pid;
 let a = sys.color_component(pad_color_pid, 0);
 if (a < 1.0) this.opaque = false;
 }
@@ -578,7 +579,17 @@
 }
 else if (kword=='fversion') {
 item = sys.version_full;
+ } else {
+ try {
+ let p = ipid.get_prop(item);
+ if (!p) p = ipid.get_info(item);
+ if (typeof p != 'undefined') {
+ if (p==null) item = 'n/a';
+ else item = '' + p;
+ }
+ } catch (e) {}
 }
+
 new_line += item;
 
 if (timeout) {

gpac-2.2.0.tar.gz/share/scripts/jsf/glpush.js Added

@@ -0,0 +1,222 @@
+import {WebGLContext} from 'webgl'
+import {Texture, Matrix} from 'evg'
+
+
+//metadata
+filter.set_name("glpush");
+filter.set_desc("GPU texture uploader");
+filter.set_version("1.0");
+filter.set_author("GPAC team");
+filter.set_help("This filter pushes input video streams to GPU as OpenGL textures. It can be used to simulate hardware decoders dispatching OpenGL textures");
+
+//raw video in and out
+filter.set_cap({id: "StreamType", value: "Video", inout: true} );
+filter.set_cap({id: "CodecID", value: "raw", inout: true} );
+
+let gl=null;
+filter.initialize = function() {
+  gl = new WebGLContext(16, 16);
+}
+
+let pids=;
+
+function cleanup_texture(pid)
+{
+  pid.o_textures.forEach( t => {
+    gl.deleteTexture(t.id);
+
+  });
+  pid.o_textures = ;  
+}
+filter.configure_pid = function(pid)
+{
+  if (typeof pid.o_pid == 'undefined') {
+      pid.o_pid = this.new_pid();
+      pid.o_pid.i_pid = pid;
+      pid.o_pid.wtf = "toto";
+      pid.o_w = 0;
+      pid.o_h = 0;
+      pid.o_pf = '';
+      pid.o_textures = ;
+      pid.frame_pending = false;
+      pid.cache_pck = null;
+      pids.push(pid);
+  }
+  pid.o_pid.copy_props(pid);
+  pid.o_pid.set_prop('Stride', null);
+  pid.o_pid.set_prop('StrideUV', null);
+  let i_w = pid.get_prop('Width');
+  let i_h = pid.get_prop('Height');
+  let i_pf = pid.get_prop('PixelFormat');
+  let i_stride = pid.get_prop('Stride');
+  let i_stride_uv = pid.get_prop('StrideUV');
+  if ((i_w == pid.o_w) && (i_h == pid.o_h) && (i_pf == pid.o_pf)) return;
+
+  pid.o_w = i_w;
+  pid.o_h = i_h;
+  pid.o_pf = i_pf;
+  cleanup_texture(pid);
+  print('Configure pid ' + pid.o_w + 'x' + pid.o_h + '@' + pid.o_pf);
+
+    if (!i_stride) i_stride = i_w;
+
+  if ((i_pf == 'nv12') || (i_pf == 'nv21')) {
+    let tx = {};
+    tx.id=0;
+    tx.offset=0;
+    tx.size=i_stride*i_h;
+    tx.w=i_w;
+    tx.h=i_h;
+    tx.fmt = gl.LUMINANCE;
+    pid.o_textures.push(tx);
+
+    tx = {};
+    tx.id=0;
+    tx.offset=i_stride*i_h;
+    tx.size=i_stride*i_h/2;
+    tx.w=i_w/2;
+    tx.h=i_h/2;
+    tx.fmt = gl.LUMINANCE_ALPHA;
+    pid.o_textures.push(tx);
+  }
+  else if ((i_pf == 'yuv420') || (i_pf == 'yvu420')) {
+    if (!i_stride_uv) i_stride_uv = i_stride/2;
+    let tx = {};
+    tx.id=0;
+    tx.offset=0;
+    tx.size=i_stride*i_h;
+    tx.w=i_w;
+    tx.h=i_h;
+    tx.fmt = gl.LUMINANCE;
+    pid.o_textures.push(tx);
+
+    tx = {};
+    tx.offset=i_stride*i_h;
+    tx.size=i_stride_uv*i_h/2;
+    tx.id=0;
+    tx.w=i_w/2;
+    tx.h=i_h/2;
+    tx.fmt = gl.LUMINANCE;
+    pid.o_textures.push(tx);
+
+    tx = {};
+    tx.id=0;
+    tx.offset=i_stride*i_h + i_stride_uv*i_h/2;
+    tx.size=i_stride_uv*i_h/2;
+    tx.w=i_w/2;
+    tx.h=i_h/2;
+    tx.fmt = gl.LUMINANCE;
+    pid.o_textures.push(tx);
+  }
+  else if ((i_pf == 'rgba') || (i_pf == 'argb') || (i_pf == 'abgr') || (i_pf == 'bgra')
+      || (i_pf == 'xrgb') || (i_pf == 'rgbx') || (i_pf == 'xbgr') || (i_pf == 'bgrx')
+  ) {
+    let tx = {};
+    tx.id=0;
+    tx.offset=0;
+    tx.size=i_stride*i_h*4;
+    tx.w=i_w;
+    tx.h=i_h;
+    tx.fmt = gl.RGBA;
+    pid.o_textures.push(tx);
+  }
+  else if ((i_pf == 'rgb') || (i_pf == 'bgr')) {
+    let tx = {};
+    tx.id=0;
+    tx.offset=0;
+    tx.size=i_stride*i_h*3;
+    tx.w=i_w;
+    tx.h=i_h;
+    tx.fmt = gl.RGB;
+    pid.o_textures.push(tx);
+  }
+  else if ((i_pf == 'algr') || (i_pf == 'gral')) {
+    let tx = {};
+    tx.id=0;
+    tx.offset=0;
+    tx.size=i_stride*i_h*2;
+    tx.w=i_w;
+    tx.h=i_h;
+    tx.fmt = gl.LUMINANCE_ALPHA;
+    pid.o_textures.push(tx);
+  }
+  else if ((i_pf == 'grey')) {
+    let tx = {};
+    tx.id=0;
+    tx.offset=0;
+    tx.size=i_stride*i_h;
+    tx.w=i_w;
+    tx.h=i_h;
+    tx.fmt = gl.LUMINANCE;
+    pid.o_textures.push(tx);
+  }
+  else {
+    //todo
+    print(GF_LOG_ERROR, "Unsupported pixel format " + i_pf + " for GPU upload");
+    return GF_NOT_SUPPORTED;
+  }
+}
+
+filter.remove_pid = function(pid)
+{
+  cleanup_texture(pid);
+  pids.splice(pids.indexOf(pid), 1);
+}
+
+
+filter.process = function()
+{
+
+  pids.forEach(pid => {
+    if (pid.frame_pending) return;
+    let ipck = pid.get_packet();
+    if (!ipck) {
+      if (pid.eos) pid.o_pid.eos = true;
+      return;
+    }
+    //frame is already in gpu, simply forward
+    if (ipck.frame_ifce_gl) {
+      pid.o_pid.forward(ipck);
+      pid.drop_packet();
+      return;
+    }
+
+    //frame is an interface, force fetching data (no per-plane access in JS)
+    let clone_pck = null;
+    if (ipck.frame_ifce) {
+      clone_pck = ipck.clone(pid.cache_pck);
+      ipck = clone_pck;
+    }
+
+    //upload all textures
+    pid.o_textures.forEach( (tx, index) => {
+      let ab = new Uint8Array(ipck.data, tx.offset, tx.size);
+      if (!tx.id) tx.id = gl.createTexture();
+      gl.bindTexture(gl.TEXTURE_2D, tx.id);
+      gl.texImage2D(gl.TEXTURE_2D, 0, tx.fmt, tx.w, tx.h, 0, tx.fmt, gl.UNSIGNED_BYTE, ab);
+    }); 
+
+    //send new frame interface in blocking mode since the same set of textures is used for each packet
+    let opck = pid.o_pid.new_packet( 
+        (pid, pck, plane_idx) => {
+          let i_pid = pid.i_pid;
+          if (plane_idx >= i_pid.o_textures.length) return null;
+          return {"id": i_pid.o_texturesplane_idx.id, 'fmt': gl.TEXTURE_2D};
+        },
+        (pid, pck) => {
+            let i_pid = pid.i_pid;
+            i_pid.frame_pending = false;
+        },
+        true
+    );
+    opck.copy_props(ipck);
+    pid.frame_pending = true;
+    opck.send();
+    pid.drop_packet();
+    if (clone_pck)
+        clone_pck.discard();
+  }); 
+
+  return GF_OK;
+}
+

gpac-2.2.0.tar.gz/share/scripts/jsf/thumbs Added

gpac-2.2.0.tar.gz/share/scripts/jsf/thumbs/init.js Added

@@ -0,0 +1,647 @@
+import * as evg from 'evg'
+import { Sys as sys } from 'gpaccore'
+import { File as File } from 'gpaccore'
+
+//metadata
+filter.set_name("thumbs");
+filter.set_desc("Thumbnail collection generator");
+filter.set_version("1.0");
+filter.set_author("GPAC team");
+filter.set_help(`This filter generates screenshots from a video stream.
+
+The input video is downsampled by the -scale() factor. The output size is configured based on the number of images per line and per column in the -grid(). 
+Once configured, the output size is no longer modified.
+
+The -snap() option indicates to use one video frame every given seconds. If value is 0, all input frames are used.
+
+If the number of rows is 0, it will be computed based on the source duration and desired -snap() time, and will default to 10 if it cannot be resolved.
+
+To output one image per input frame, use \`:grid=1x1\`.
+
+If a single image per output frame is used, the default value for -snap() is 0 and for -scale() is 1.
+Otherwise, the default value for -snap() is 1 second and for -scale() is 10.
+
+A single line of text can be inserted over each frame. Predefined keywords can be used in input text, identified as \`$KEYWORD$\`:
+- ts: replaced by packet timestamp
+- timescale: replaced by PID timescale
+- time: replaced by packet time as HH:MM:SS.ms
+- cpu: replaced by current CPU usage of process
+- mem: replaced by current memory usage of process
+- version: replaced by GPAC version
+- fversion: replaced by GPAC full version
+- mae: replaced by Mean Absolute Error with previous frame
+- mse: replaced by Mean Square Error with previous frame
+- P4CC, PropName: replaced by corresponding PID property
+
+EX gpac -i src reframer:saps=1 thumbs:snap=30:grid=6x30 -o dump/$num$.png
+This will generate images from key-frames only, inserting one image every 30 seconds. Using key-frame filtering is much faster but may give unexpected results if there are not enough key-frames in the source.
+
+EX gpac -i src thumbs:snap=0:grid=5x5 -o dump/$num$.png
+This will generate one image containing 25 frames every second at 25 fps.
+
+
+If a single image per output frame is used and the scaling factor is 1, the input packet is reused as input with text and graphics overlaid.
+
+EX gpac -i src thumbs:grid=1x1:txt='Frame $time$' -o dump/$num$.png
+This will inject text over each frame and keep timing and other packet properties.
+
+A json output can be specified in input -list() to let applications retrieve frame position in output image from its timing.
+
+# Scene change detection
+
+The filter can compute the absolute and/or square error metrics between consecutive images and drop image if the computed metric is less than the given threshold.
+If both -mae() and -mse() thresholds are 0, scene detection is not performed (default).
+If both -mae() and -mse() thresholds are not 0, the frame is added if it passes both thresholds.
+
+For both metrics, a value of 0 means all pixels are the same, a value of 100 means all pixels have 100% intensity difference (e.g. black versus white).
+
+The scene detection is performed after the -snap() filtering and uses:
+- the previous frame in the stream, whether it was added or not, if -scref() is not set,
+- the last added frame otherwise.
+
+Typical thresholds for scene cut detection are 14 to 20 for -mae() and 5 to 7 for -mse().
+
+Since this is a costly process, it is recommended to use it combined with key-frames selection:
+
+EX gpac -i src reframer:saps=1 thumbs:mae=15 -o dump/$num$.png
+
+The -maxsnap() option can be used to force insertion after the given time if no scene cut is found.
+
+`);
+
+filter.set_arg({ name: "grid", desc: "number of images per lines and columns", type: GF_PROP_VEC2I, def: "6x0"} );
+filter.set_arg({ name: "scale", desc: "scale factor for input size", type: GF_PROP_DOUBLE, def: "-1"} );
+filter.set_arg({ name: "mae", desc: "scene diff threshold using Mean Absolute Error", type: GF_PROP_UINT, def: "0", hint:"advanced", minmax_enum: "0,100"} );
+filter.set_arg({ name: "mse", desc: "scene diff threshold using Mean Square Error", type: GF_PROP_UINT, def: "0", hint:"advanced", minmax_enum: "0,100"} );
+filter.set_arg({ name: "lw", desc: "line width between images in pixels", type: GF_PROP_DOUBLE, def: "0.0", hint:"advanced"} );
+filter.set_arg({ name: "lc", desc: "line color", type: GF_PROP_STRING, def: "white", hint:"advanced"} );
+filter.set_arg({ name: "clear", desc: "clear color", type: GF_PROP_STRING, def: "white", hint:"advanced"} );
+filter.set_arg({ name: "snap", desc: "duration between images, 0 for all images", type: GF_PROP_DOUBLE, def: "-1"} );
+filter.set_arg({ name: "maxsnap", desc: "maximum duration between two thumbnails when scene change detection is enabled", type: GF_PROP_DOUBLE, def: "-1"} );
+filter.set_arg({ name: "pfmt", desc: "output pixel format", type: GF_PROP_PIXFMT, def: "rgb", hint:"expert"} );
+filter.set_arg({ name: "txt", desc: "text to insert per thumbnail", type: GF_PROP_STRING, def: "", hint:"advanced"} );
+filter.set_arg({ name: "tc", desc: "text color", type: GF_PROP_STRING, def: "white", hint:"expert"} );
+filter.set_arg({ name: "tb", desc: "text shadow", type: GF_PROP_STRING, def: "black", hint:"expert"} );
+filter.set_arg({ name: "font", desc: "font to use", type: GF_PROP_STRING, def: "SANS", hint:"expert"} );
+filter.set_arg({ name: "fs", desc: "font size to use in percent of scaled height", type: GF_PROP_DOUBLE, def: "10", hint:"expert"} );
+filter.set_arg({ name: "tv", desc: "text vertical position in percent of scaled height", type: GF_PROP_DOUBLE, def: "0", hint:"expert"} );
+filter.set_arg({ name: "thread", desc: "number of threads for software rasterizer, -1 for all available cores", type: GF_PROP_SINT, def: "-1", hint:"expert"} );
+filter.set_arg({ name: "blt", desc: "use blit instead of software rasterizer", type: GF_PROP_BOOL, def: "true", hint:"expert"} );
+filter.set_arg({ name: "scref", desc: "use last inserted image as reference for scene change detection", type: GF_PROP_BOOL, def: "false", hint:"expert"} );
+filter.set_arg({ name: "dropfirst", desc: "drop first image", type: GF_PROP_BOOL, def: "false", hint:"expert"} );
+filter.set_arg({ name: "list", desc: "export json list of frame times and positions to given file", type: GF_PROP_STRING, def: null, hint:"expert"} );
+filter.set_arg({ name: "lxy", desc: "add explict x and y in json export", type: GF_PROP_BOOL, def: "false", hint:"expert"} );
+
+
+filter.initialize = function() {
+
+	if ((this.grid.x==1) && (this.grid.y==1)) {
+		if (this.scale==-1) this.scale = 1;
+		if (this.snap==-1) this.snap = 0;
+	} else {
+		if (this.scale==-1) this.scale = 10;
+		if (this.snap==-1) this.snap = 1;	
+	}
+
+	if (this.scale<=0) {
+		print(GF_LOG_ERROR, 'Invalid scale factor, must be greater than 0');
+		return GF_BAD_PARAM;
+	}
+	if (this.grid.x<=0) {
+		print(GF_LOG_ERROR, 'Invalid tile grid, must be at least 1x1');
+		return GF_BAD_PARAM;
+	}
+	this.set_cap({id: "StreamType", value: "Video", inout: true} );
+	this.set_cap({id: "CodecID", value: "raw", inout: true} );
+
+	let test_canvas=null;
+	try {
+		test_canvas = new evg.Canvas(48, 48, filter.pfmt);
+	} catch (e) {
+		print(GF_LOG_WARNING, 'Pixel format ' + filter.pfmt + ' not supported by rasterizer, defaulting to rgb');
+		filter.pfmt = 'rgb';
+	}
+
+	if (this.txt.length) use_text = true;
+
+	let mode=0;
+	if (this.mae > 0) mode = (this.mse>0) ? 3 : 1;
+	else if (this.mse>0) mode = 2;
+
+	if (this.txt && (this.txt.indexOf('mae')>=0)) {
+		if (!mode) mode=1;
+		else if (mode==2) mode = 3;
+	}
+	if (this.txt && (this.txt.indexOf('mse')>=0)) {
+		if (!mode) mode=2;
+		else if (mode==1) mode = 3;
+	}
+	if (mode==3) sd_mode="mae,mse";
+	else if (mode==2) sd_mode="mse";
+	else if (mode==1) sd_mode="mae";
+
+}
+
+let use_text=false;
+let nb_tiles=0;
+let max_tiles;
+let opck=null;
+let canvas=null;
+let opid=null;
+let ipid=null;
+let timescale=0;
+let nb_oframe=0;
+let last_dur=0;
+let init_ts=0;
+let path=null;
+let outline=null;
+let tot_tiles=0;
+let swidth=0, sheight=0, owidth, oheight, osize;
+let can_blit;
+
+let mx = new evg.Matrix2D();
+let line_brush = new evg.SolidBrush();
+let reuse_src=false;
+let reuse_pfmt=false;
+let tx_matrix=null;
+let sd_mode=null;
+let delay=0;
+let out_list = null;
+
+
+filter.configure_pid = function(pid) 
+{
+	if (!opid)
+		opid = this.new_pid();
+	ipid = pid;
+
+	//only configure once
+	if (swidth || sheight) {
+		if (pid.timescale != timescale) {
+			init_ts = 0;
+			timescale = pid.timescale;
+			if (reuse_src) opid.copy_props(ipid);
+		}
+		return GF_OK;
+	}
+	swidth = pid.get_prop('Width');
+	sheight = pid.get_prop('Height');
+	if (!swidth || !sheight) return GF_OK;
+
+	timescale = pid.timescale;
+	swidth = Math.floor(swidth/this.scale);
+	if (swidth%2) swidth++;
+	sheight = Math.floor(sheight/this.scale);
+	if (sheight%2) sheight++;
+
+	pid.mirror = pid.get_prop('Mirror');
+	pid.rotate = pid.get_prop('Rotate');
+	delay = pid.get_prop('Delay');
+
+	if (this.grid.y<=0) {
+		if (this.snap>0) {
+			let dur = pid.get_prop('Duration');
+			if (dur && dur.n && dur.d) {
+				let nb_img = Math.ceil(dur.n / dur.d / this.snap / this.grid.x);
+				if (nb_img) {
+					print('Using ' + nb_img + ' rows');
+					this.grid.y = nb_img;
+				}
+			}
+		}
+		if (!this.grid.y) {
+			if (this.snap>0) {
+				print(GF_LOG_WARNING, 'Cannot determine video duration, using 10 as default output rows');
+			}
+			this.grid.y = 10;
+		}
+	}
+
+	can_blit = true;
+ if ((pid.rotate==1) || (pid.rotate==3)) {
+ let tmp = swidth;
+ swidth = sheight;
+ sheight = tmp;
+ }
+ if (pid.rotate || pid.mirror) can_blit=false;
+
+	owidth = swidth * this.grid.x;
+	oheight = sheight * this.grid.y;
+	max_tiles = this.grid.x * this.grid.y;
+
+	if ((max_tiles==1) && (filter.scale==1) && can_blit) {
+		reuse_src=true;
+		opid.copy_props(ipid);
+		swidth = pid.get_prop('Width');
+		sheight = pid.get_prop('Height');
+		reuse_pfmt = pid.get_prop('PixelFormat');
+	} else {
+		opid.reset_props();
+		opid.set_prop('Width', owidth);
+		opid.set_prop('Height', oheight);
+		opid.set_prop('StreamType', 'Video');
+		opid.set_prop('CodecID', 'raw');
+		opid.set_prop('PixelFormat', this.pfmt);
+		opid.set_prop('Timescale', timescale);
+	}
+
+	if (this.list) {
+		out_list = {};
+		out_list.timescale = timescale;
+		out_list.grid_width = this.grid.x;
+		out_list.grid_height = this.grid.y;
+		out_list.thumb_width = swidth;
+		out_list.thumb_height = sheight;
+		out_list.images = ;
+	}
+
+	osize = sys.pixfmt_size(this.pfmt, owidth, oheight);
+	canvas = null;
+	path = new evg.Path();
+	path.rectangle(0, 0, swidth, sheight, true);
+
+	if (this.lw) {
+		outline = path.outline({width: this.lw, align: GF_PATH_LINE_CENTER, join: GF_LINE_JOIN_BEVEL});
+	}
+ build_tx_matrix();
+
+}
+
+
+function flush_frame()
+{
+	tot_tiles+=nb_tiles;
+	nb_tiles = 0;
+	opck.send();
+	nb_oframe++;
+	canvas=null;
+	opck=null;
+}
+
+let prev_tx = null;
+let prev_pck = null;
+let frame_mae = 0;
+let frame_mse = 0;
+let last_thumb_ts=0;
+
+filter.process = function()
+{
+	let ipck = ipid.get_packet();
+	if (!ipck) {
+		if (ipid.eos) {
+			if (nb_tiles) {
+				flush_frame();
+				print(reuse_src ? GF_LOG_DEBUG : GF_LOG_INFO, 'generated ' + nb_oframe + ' images for ' + tot_tiles + ' tiles');
+			}
+			if (prev_pck) {
+				prev_pck.unref();
+				prev_pck=null;
+			}
+			opid.eos = true;
+			if (out_list.images.length && this.list) {
+				let out = new File(this.list, "w");
+				out.puts(JSON.stringify(out_list));
+				out.close();
+				out_list.images.length=;
+			}
+			return GF_EOS;
+		}
+		return GF_OK;
+	}
+
+	if (this.snap>0) {
+		if (!init_ts) {
+			last_thumb_ts = init_ts = ipck.cts+1;
+			if (this.dropfirst) {
+				ipid.drop_packet();
+				return GF_OK;	 		
+			}
+		} else {
+			let time = ipck.cts - init_ts+1;
+			if (time < this.snap * timescale) {
+				if (sd_mode && !this.scref && 0) {
+					prev_pck = ipck.ref();
+					prev_tx = new evg.Texture(ipck);
+				}
+				ipid.drop_packet();
+				return GF_OK;
+			}
+			init_ts = ipck.cts+1;
+		}
+	} 
+
+	let tx = new evg.Texture(ipck);
+	if (sd_mode) {
+		let forward = false;
+		if (!prev_pck) {
+			forward = true;
+			frame_mae = 0;
+			frame_mse = 0;
+		} else {
+			let diff_score = tx.diff_score(prev_tx, sd_mode);
+			let mae = diff_score0.mae;
+			let mse = diff_score0.mse;
+
+			if (filter.mae>0) {
+				if (filter.mse>0) {
+					if ((mae >= filter.mae) && (mse >= filter.mse))
+						forward = true;
+				} else {
+					if (mae >= filter.mae)
+						forward = true;
+				}
+			}
+			else if (filter.mse>0) {
+				if (mse >= filter.mse)
+					forward = true;
+			}
+			//mae and mse disabled but we run them for stats
+			else {
+				forward = true;
+			}
+
+			if (!forward && (this.maxsnap>0) && last_thumb_ts) {
+				let diff = ipck.cts - last_thumb_ts - 1;
+				if (diff >= this.maxsnap*timescale) {
+					forward = true;
+				}
+			}
+			if (!forward) {
+				if (!this.scref) {
+					if (prev_pck) prev_pck.unref();
+					prev_pck = ipck.ref();
+					prev_tx = tx;
+				}
+				ipid.drop_packet();
+				return GF_OK;
+			}
+			if (prev_pck) prev_pck.unref();
+			frame_mae = mae;
+			frame_mse = mse;
+			last_thumb_ts = ipck.cts+1;
+		}
+		prev_pck = ipck.ref();
+		prev_tx = tx;
+	}
+
+	if (reuse_src) {
+		//create a clone of the input data, requesting inplace processing 
+		opck = opid.new_packet(ipck, false, false);
+
+		try {
+			/*create a canvas for our output data if first time, otherwise reassign internal canvas data*/
+			if (!canvas) {
+				canvas = new evg.Canvas(swidth, sheight, reuse_pfmt, opck.data);
+			} else {		
+				canvas.reassign(opck.data);
+			}
+		} catch (e) {
+			print(GF_LOG_ERROR, 'Failed to create canvas from packet: ' + e);
+			canvas = null;
+			return GF_SERVICE_ERROR;
+		}
+		print(GF_LOG_DEBUG, 'Created create canvas from input packet');
+	}
+
+	/*create a canvas for our output data if first time, otherwise reassign internal canvas data*/
+	if (!canvas) {
+		opck = opid.new_packet(osize);
+		opck.cts = ipck.cts;
+		try {
+			canvas = new evg.Canvas(owidth, oheight, filter.pfmt, opck.data);
+		} catch (e) {
+			print(GF_LOG_ERROR, 'Failed to create canvas from packet: ' + e + ' - try changing output pixel format');
+			canvas = null;
+			return GF_SERVICE_ERROR;	
+		}
+		if (filter.thread) {
+			canvas.enable_threading(filter.thread);
+		}
+		canvas.clear(this.clear);
+	}
+
+	mx.identity = true;
+	let off_x = nb_tiles % this.grid.x;
+	let off_y = (nb_tiles-off_x) / this.grid.x;
+	off_x *= swidth;
+	off_y *= sheight;
+	mx.translate(-owidth/2 + off_x + swidth/2, oheight/2 - off_y - sheight/2);
+
+	if (!reuse_src) {
+		let do_soft=true;
+		if (filter.blt && can_blit) {
+			try {
+				let dst_rc = {x: off_x, y: off_y, w: swidth, h: sheight};
+				canvas.blit(tx, dst_rc, null);
+				do_soft=false;
+			} catch (e) {
+				print(GF_LOG_WARNING, 'blit failed: ' + e);
+			}
+		}
+		if (do_soft) {
+			tx.mx = tx_matrix;
+			canvas.path = path;
+			canvas.matrix = mx;
+			canvas.fill(tx);
+		}
+	}
+
+	if (outline) { 	
+		line_brush.set_color(this.lc);
+		canvas.path = outline;
+		canvas.matrix = mx;
+		canvas.fill(line_brush);
+	}
+
+	if (use_text) {
+		let txt = new evg.Text();
+		txt.font = filter.font;
+		txt.fontsize = filter.fs * sheight/100;
+		let diff = (sheight - 2*txt.fontsize) * filter.tv / 100;
+		mx.translate(0, -sheight/2 + txt.fontsize/2 + diff);
+
+		txt.baseline = GF_TEXT_BASELINE_ALPHABETIC;
+		txt.align = GF_TEXT_ALIGN_LEFT;
+		txt.maxWidth = swidth;
+
+		set_text(txt, ipck);
+
+		let tsize = txt.measure();
+		mx.translate(-tsize.width/2, 0);
+
+		canvas.path = txt;
+		canvas.matrix = mx;
+
+		line_brush.set_color(filter.tb);
+		canvas.fill(line_brush);
+		line_brush.set_color(filter.tc);
+		mx.translate(-1.25, 1.25);
+		canvas.matrix = mx;
+		canvas.fill(line_brush);
+	}
+
+	if (this.list) {
+		let it = { frame: nb_tiles+1, page: nb_oframe+1, ts: (ipck.cts+delay)};
+		if (this.lxy) {
+			it.x = off_x;
+			it.y = off_y;
+		}
+		out_list.images.push(it);
+	}
+
+	/*send packet*/
+	ipid.drop_packet();
+
+	nb_tiles++;
+	print(reuse_src ? GF_LOG_DEBUG : GF_LOG_INFO, 'processing tile '+nb_tiles+'/'+max_tiles+ ' (' + nb_oframe + ' images sent) \r');
+
+	if (nb_tiles==max_tiles) {
+		flush_frame();
+	}
+	return GF_OK;
+}
+
+
+function build_tx_matrix()
+{
+	tx_matrix = null;
+
+	if (!ipid.rotate && !ipid.mirror) return;
+
+	let mirrored=0;
+	let rotated=0;
+	let scale_tx_sw = 1;
+	let scale_tx_sh = 1;
+	let trans_tx_x = 0;
+	let trans_tx_y = 0;
+	let mxflip = new evg.Matrix2D();
+	if (ipid.mirror) {
+		mirrored=ipid.mirror;
+		if (mirrored==1) mxflip.scale(-1, 1);
+		else if (mirrored==2) mxflip.scale(1, -1);
+		else if (mirrored==3) {
+			mxflip.scale(-1, 1);
+			mxflip.scale(1, -1);
+		}
+	}
+
+	if (ipid.rotate) {
+		rotated=ipid.rotate;
+		if (rotated==3) mxflip.rotate(0, 0, -Math.PI/2);
+		else if (rotated==2) mxflip.rotate(0, 0, Math.PI);
+		else if (rotated==1) mxflip.rotate(0, 0, Math.PI/2);
+	}
+
+	if ((rotated==1) || (rotated==3)) {
+		scale_tx_sw = swidth / sheight;
+		scale_tx_sh = sheight / swidth;
+	}
+	let txmx = new evg.Matrix2D();
+	txmx.scale(scale_tx_sw, scale_tx_sh);
+	txmx.add(mxflip);
+
+	if (rotated==0) {
+		if (mirrored==2) txmx.translate(0, 1);
+		else if (mirrored==3) txmx.translate(1, 1);
+		else if (mirrored==1) txmx.translate(1, 0);
+		else txmx.translate(0, 0);
+	}
+	else if (rotated==1) {
+		if (mirrored==2) txmx.translate(0, 0);
+		else if (mirrored==3) txmx.translate(0, 1);
+		else if (mirrored==1) txmx.translate(1, 1);
+		else txmx.translate(1, 0);
+	}
+	else if (rotated==2) {
+		if (mirrored==2) txmx.translate(1, 0);
+		else if (mirrored==3) txmx.translate(0, 0);
+		else if (mirrored==1) txmx.translate(0, 1);
+		else txmx.translate(1, 1);
+	}
+	else { // (rotated==3) 
+		if (mirrored==2) txmx.translate(1, 1);
+		else if (mirrored==3) txmx.translate(1, 0);
+		else if (mirrored==1) txmx.translate(0, 0);
+		else txmx.translate(0, 1);
+	}
+	tx_matrix = txmx;
+}	
+
+
+function set_text(txt, pck)
+{
+	let line = filter.txt;
+
+	if (line.indexOf('$') < 0) {
+		txt.set_text(line);
+		return;
+	}
+	let first_is_sep = (line.charAt(0)=='$') ? true : false; 
+	let last_is_sep = (line.charAt(line.length-1)=='$') ? true : false; 
+	let split_text = line.split('$');
+	let len = split_text.length;
+	let new_line='';
+
+	split_text.forEach( (item, index) => {
+		if (!index && !first_is_sep) {
+			new_line += item;
+			return;
+		}
+		if (!last_is_sep && (index==len-1)) {
+			new_line += item;
+			return;
+		}
+		let timeout=0;
+		let kword = item.toLowerCase();
+		if (kword=='ts') {
+			item = '' + pck.cts;
+		}
+		else if (kword=='timescale') {
+			item = '' + pid.timescale;
+		}
+		else if (kword=='time') {
+			let time = pck.cts * 1000 / timescale;
+			let time_s = Math.floor(time/1000);
+			let h = Math.floor(time_s/3600);
+			let m = Math.floor(time_s/60 - h*60);
+			let s = Math.floor((time_s - h*3600 - m*60));
+			item = ((h<10) ? '0' : '') + h + ((m<10) ? ':0' : ':') + m + ((s<10) ? ':0' : ':') + s + '.';
+			time = Math.floor(time - time_s*1000);
+			if (time < 10) item += '00';
+			else if (time < 100) item += '0';
+			item += time;
+		}
+		else if (kword=='cpu') {
+			item = '' + sys.process_cpu_usage;
+		}
+		else if (kword=='mem') {
+			item = '' + Math.floor(sys.process_memory/1000000) + ' MB';
+		}
+		else if (kword=='version') {
+			item = sys.version;
+		}
+		else if (kword=='fversion') {
+			item = sys.version_full;
+		}
+		else if (kword=='mae') {
+			item = '' + Math.floor(frame_mae*1000)/1000;
+		}
+		else if (kword=='mse') {
+			item = '' + Math.floor(frame_mse*1000)/1000;
+		}
+		else {
+			try {
+				let p = ipid.get_prop(item);
+				if (!p) p = ipid.get_info(item);
+				if (typeof p != 'undefined') {
+					if (p==null) item = 'n/a';
+					else item = '' + p;
+				}
+			} catch (e) {}
+		}
+		new_line += item;
+	});
+
+	txt.set_text(new_line); 
+}
+

gpac-2.0.0.tar.gz/share/scripts/ttml-renderer.js -> gpac-2.2.0.tar.gz/share/scripts/ttml-renderer.js Changed

@@ -45,8 +45,8 @@
 ttml_dbg_msg("TTML Rendered Loaded size: " + width + "x" + height);
 
 //filter-assignable variables - if changing names, also do it in filters/dec_ttml.c
-var xOffset = 5;
-var yOffset = 5;
+var xOffset = 0;
+var yOffset = 0;
 var fontSize = 20;
 var textColor = "white";
 var fontFamily = "SANS";
@@ -60,23 +60,23 @@
 
 function create_text_area(settings) {
 	var t = document.createElement("textArea");
-	t.setAttribute("x", xOffset + settings.x_offset);
-	t.setAttribute("y", yOffset);
+	t.setAttribute("x", settings.x_offset);
+	t.setAttribute("y", -5);
 	var w, h;
 	if (settings.align_top==2) {
 		t.setAttribute("display-align", "before");
-		h=height - 2*yOffset;
+		h=height ;
 	} else if (settings.align_top==1) {
 		t.setAttribute("display-align", "center");
-		h=height - 2*yOffset;
+		h=height ;//- 2*yOffset;
 	} else {
 		t.setAttribute("display-align", "after");
-		h = height - 2*yOffset - settings.linePosition;
+		h = height - settings.linePosition ;//- 2*yOffset;
 	}
-	w = settings.size - 2*(xOffset + settings.x_offset);
+	w = settings.size - 2*( settings.x_offset);
 	t.setAttribute("height", h);
 	t.setAttribute("width", w);
-	ttml_dbg_msg("Creating textArea size " + w + " x " + h + " - xoffset: " + xOffset);
+	ttml_dbg_msg("Creating textArea size " + w + " x " + h + " - offset: " + xOffset + " x " + yOffset);
 	
 	t.setAttribute("fill", textColor);
 
@@ -89,17 +89,24 @@
 	t.setAttribute("text-align", settings.align);
 	t.setAttribute("line-increment", lineSpaceFactor*fontSize);
 
+
+	let g = document.createElement("g");
+	let mx = g.getMatrixTrait('transform');
+ mx.mTranslate(xOffset, -yOffset);
+	g.setMatrixTrait('transform', mx);
+	display_area.appendChild(g);
+
 	if (ttml_view_area) {
 		var r = document.createElement("rect");
-		r.setAttribute("x", xOffset+settings.x_offset);
-		r.setAttribute("y", yOffset);
+		r.setAttribute("x", settings.x_offset);
+		r.setAttribute("y", -5);
 		r.setAttribute("fill", "cyan");
 		r.setAttribute("width", w);
 		r.setAttribute("height", h);
-		display_area.appendChild(r);
+		g.appendChild(r);
 	}
 
-	display_area.appendChild(t);
+	g.appendChild(t);
 	ttml_dbg_msg("textArea created: "+t);
 	return t;
 }
@@ -112,6 +119,7 @@
 		if (styles.italic) span.setAttribute("font-style", "italic");
 		if (styles.underlined) span.setAttribute("text-decoration", "underline");
 		if (styles.bold) span.setAttribute("font-weight", "bold");
+		if (styles.colors) span.setAttribute("fill", ""+styles.color);
 	}
 	span.textContent = text;
 	parent.appendChild(span);
@@ -176,6 +184,25 @@
 	var children = node.childNodes;
 		ttml_dbg_msg("child " + node.nodeName + " children " + children.length);
 
+	let nb_italic = styles.italic;
+	let nb_bold = styles.bold;
+	let nb_underlined = styles.underlined;
+	let nb_colors = styles.colors;
+	let color = styles.color;
+	let att = node.getAttributeNS('*', 'fontStyle');
+	if ((att == 'italic') || (att == 'oblique')) styles.italic++;
+
+	att = node.getAttributeNS('*', 'fontWeight');
+	if (att == 'bold') styles.bold++;
+
+	att = node.getAttributeNS('*', 'textDecoration');
+	if (att == 'underlined') styles.underlined++;
+
+	att = node.getAttributeNS('*', 'color');
+	if ((att != null) && att.length) {
+		styles.colors++;
+		styles.color = att;
+	}
 	for (var i=0; i<children.length; i++) {
 		var t = children.item(i);
 		if (t.nodeName ==='br') {
@@ -208,6 +235,12 @@
 		ttml_dbg_msg("child " + t.nodeName + " txt " + t.textContent);
 		add_text_span(textArea, t.textContent, styles);
 	}
+	styles.italic = nb_italic;
+	styles.bold = nb_bold;
+	styles.underlined = nb_underlined;
+	styles.colors = nb_colors;
+	styles.color = color;
+
 }
 
 let sample_end = 0;
@@ -220,7 +253,7 @@
 	display_area.textContent = '';
 	var body = ttmldoc.getElementsByTagName("body");
 	var samples = ttmldoc.getElementsByTagName("p");
-	var styles = {"italic": 0, "underlined": 0, "bold": 0};
+	var styles = {"italic": 0, "underlined": 0, "bold": 0, "colors": 0, color: null};
 
 	if (samples.length>1) {
 		alert("TTML sample has " + samples.length + " defined, only the last sample will be displayed");

gpac-2.0.0.tar.gz/share/scripts/vout.js -> gpac-2.2.0.tar.gz/share/scripts/vout.js Changed

@@ -3,7 +3,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2020-2021
+ *			Copyright (c) Telecom ParisTech 2020-2022
 *					All rights reserved
 *
 * This file is part of GPAC / vout default ui
@@ -33,21 +33,15 @@
 
 print("Type 'h' in window for command list");
 
-let aout = null
-let vout = null
-
-let i;
-for (i=0; i< session.nb_filters; i++) {
- 	let f = session.get_filter(i);
- 	if (f.type==="aout") aout = f;
- 	else if (f.type==="vout") vout = f;
-}
-
-let speed=0;
+let aout = null;
+let vout = null;
+let speed = 1;
+let win_id = 0;
 let drop=0;
-let paused=0;
-let duration=-1
 let fullscreen = false;
+let paused=0;
+let duration=-1;
+let codec_slow=false;
 
 let audio_only = false;
 let ol_buffer = null;
@@ -66,7 +60,9 @@
 const OL_HELP = 1;
 const OL_STATS = 2;
 const OL_PLAY = 3;
+const OL_AUTH = 4;
 let overlay_type = OL_NONE;
+let overlay_type_bck = OL_NONE;
 
 let brush = new evg.SolidBrush();
 brush.set_color('white');
@@ -79,6 +75,29 @@
 let do_coverage=0;
 if (sys.get_opt('temp', 'vout_cov') == 'yes') do_coverage = 1;
 
+
+if (parent_filter && parent_filter.type=='vout')
+	vout = parent_filter;
+
+function check_filters()
+{
+	if (aout && vout) return;
+	let i;
+	for (i=0; i< session.nb_filters; i++) {
+		let f = session.get_filter(i);
+		if (!aout && (f.type==="aout")) aout = f;
+		else if (!vout && (f.type==="vout")) vout = f;
+	}
+	if (vout) {
+		speed = vout.get_arg('speed');
+		drop = vout.get_arg('drop');
+		fullscreen = vout.get_arg('fullscreen');
+		win_id = vout.get_arg('wid');
+	}
+}
+check_filters();
+
+
 function setup_overlay()
 {
 	let target_width=ol_width;
@@ -106,6 +125,11 @@
 		target_height = Math.floor(disp_size.y/2);
 		task_reschedule = 250;
 		break;
+	case OL_AUTH:
+		target_width = Math.floor(4*disp_size.x/5);
+		target_height = Math.floor(4*disp_size.y/5);
+		task_reschedule = 100;
+		break;
 	default:
 		if (!ol_width)
 				ol_width = Math.floor(disp_size.x/3);
@@ -115,7 +139,7 @@
 	}
 	init_wnd=true;
 
-	if (audio_only) {
+	if (audio_only || !vout.nb_ipid) {
 		target_width = ol_width = disp_size.x;
 		target_height = ol_height = disp_size.y;
 	}
@@ -134,55 +158,117 @@
 	return true;
 }
 
-if (vout) {
-	speed = vout.get_arg('speed');
-	drop = vout.get_arg('drop');
-	fullscreen = vout.get_arg('fullscreen');
-
-	session.post_task( () => {
-		if (session.last_task) {
-			return false;
-		}
-		if (vout.nb_ipid) {
-			audio_only=false;
-			return false;
+session.post_task( () => {
+	if (session.last_task) {
+		return false;
+	}
+	check_filters();
+	if (!vout) return 1000;
+	if (vout.nb_ipid) {
+		audio_only=false;
+		return false;
+	}
+	if (aout) {
+		if (!aout.nb_ipid || !session.connected) {
+			return 100;
 		}
-		if (aout) {
-			if (!aout.nb_ipid || !session.connected) {
-				return 100;
-			}
 
-			if (!audio_only) {
-				overlay_type=OL_PLAY;
-				audio_only=true;
-				toggle_overlay();
-			}
+		if (!audio_only) {
+			overlay_type=OL_PLAY;
+			audio_only=true;
+			toggle_overlay();
 		}
-		return false;
-	}, "check_vout_pids");
-}
+	}
+	return false;
+}, "check_vout_pids");
+
+let last_x=0, last_y=0;
 
 session.set_event_fun( (evt)=> {
 	if (evt.type != GF_FEVT_USER) return 0;
 
+	if ((evt.ui_type == GF_EVENT_CODEC_SLOW) || (evt.ui_type == GF_EVENT_CODEC_OK)) {
+		codec_slow = (evt.ui_type == GF_EVENT_CODEC_SLOW) ? true : false;
+
+		if (overlay_type==OL_AUTH) return 0;
+		print('trigger overlay');
+		ol_visible = false;
+		overlay_type=OL_PLAY;
+		toggle_overlay();
+		update_play();
+		return false;
+	}
+
+	try {
+		if(evt.window != win_id) return true;
+	} catch (e) {
+		return true;
+	}
+
 	switch (evt.ui_type) {
 	case GF_EVENT_MOUSEDOWN:
+		last_x = evt.mouse_x;
+		last_y = evt.mouse_y;
 		break;
 
 	case GF_EVENT_MOUSEUP:
-		if (overlay_type==OL_PLAY) 
+		if ((last_x != evt.mouse_x) || (last_y != evt.mouse_y)) return 0;
+		if (overlay_type==OL_AUTH) return 0;
+
+		if (overlay_type==OL_PLAY) {
 			if (prog_interact(evt)) return 0;
+		}
 		if (ol_visible) {
 			toggle_overlay();
+			return true;
 		} else if (!audio_only) {
 			overlay_type=OL_PLAY;
 			toggle_overlay();
+			return true;
 		}
 		break;
 
 	case GF_EVENT_KEYDOWN:
-		process_keyboard(evt);
-		break;
+		return process_keyboard(evt);
+	case GF_EVENT_TEXTINPUT:
+		if (overlay_type==OL_AUTH) {
+			if (auth_state==0) {
+				if ((evt.char == '\n') || (evt.char == '\r'))
+					auth_state = 1;
+				else if (evt.char == '\b')
+					auth_name = auth_name.slice(0, auth_name.length - 1);
+				else
+					auth_name += ''+evt.char;
+			} else if (auth_state==1) {
+				if ((evt.char == '\n') || (evt.char == '\r')) {
+					auth_state = 2;
+					auth_requests0.done(auth_name, auth_pass);
+					auth_name = '';
+					auth_pass = '';
+					auth_requests.shift();
+					if (auth_requests.length) {
+						auth_state = 0;
+					} else {
+						auth_state = 0;
+						toggle_overlay();
+
+						text.font = 'SERIF';
+						text.fontsize = 20;
+						text.baseline = GF_TEXT_BASELINE_HANGING;
+						text.align = GF_TEXT_ALIGN_LEFT;
+						text.lineSpacing = 20;
+						overlay_type = overlay_type_bck;
+						if (overlay_type) toggle_overlay();
+					}
+				} else if (evt.char == '\b')
+					auth_pass = auth_pass.slice(0, auth_pass.length - 1);
+				else
+					auth_pass += ''+evt.char;
+			}
+			auth_modified = true;
+		}
+		return false;
+
 	case GF_EVENT_SIZE:
 		if (do_coverage) {
 			overlay_type=OL_PLAY;
@@ -204,7 +290,7 @@
 		break;
 	default:
 	}
-	return 0;
+	return false;
 }
 );
 
@@ -220,15 +306,22 @@
 	session.fire_event(evt, src);
 }
 
-
+let interactive_scene=0;
 function check_duration()
 {
 	if (duration!=-1) return (duration>=0) ? true : false;
-	let dur;
-	if (audio_only)
+	let dur=null;
+	if (audio_only) {
 		dur = aout.ipid_props(0, 'Duration');
-	else
+		interactive_scene = aout.ipid_props(0, 'InteractiveScene');
+	} else if (vout.nb_ipid) {
 		dur = vout.ipid_props(0, 'Duration');
+		interactive_scene = vout.ipid_props(0, 'InteractiveScene');
+	}
+	if (interactive_scene==1) {
+		duration = 0;
+		return;
+	}
 	if (dur==null) return;
 	duration = dur.n;
 	duration /= dur.d;
@@ -261,8 +354,13 @@
 	let last_ts_f = vout.last_ts_drop;
 	if (last_ts_f==null) return;
 
+
 	let last_ts = last_ts_f.n;
 	last_ts /= last_ts_f.d;
+	if (audio_only)
+		last_ts -= aout.get_arg('media_offset');
+	else
+		last_ts -= vout.get_arg('media_offset');
 	last_ts += seek_to;	
 	if (last_ts<0) last_ts = 0;
 	else if (last_ts>duration) last_ts = duration-10;
@@ -378,12 +476,16 @@
 	let h, m, s;
 	let last_ts = last_ts_f.n;
 	last_ts /= last_ts_f.d;
+	if (audio_only)
+		last_ts -= aout.get_arg('media_offset');
+	else
+		last_ts -= vout.get_arg('media_offset');
 
 	if (reverse) last_ts = duration - last_ts;
 
 	h = Math.floor(last_ts/3600);
 	m = Math.floor(last_ts/60 - h*60);
-	s = Math.floor(last_ts - h*360) - m*60;
+	s = Math.floor(last_ts - h*3600) - m*60;
 	let str = reverse ? '-' : ' ';
 
 	if (duration>=3600) {
@@ -422,16 +524,18 @@
 		ol_canvas.fill(brush);
 
 		let	progress_path = new evg.Path();
-		let progress = (last_ts_f.n/last_ts_f.d) / duration;
+		let progress = last_ts / duration;
 		brush.set_color('white');
 		progress_path.rectangle(prog_ox - prog_length/2, 9, prog_length*progress, 18, false);
 		ol_canvas.path = progress_path;
 		ol_canvas.fill(brush);
 	}
 
-	if (paused || (speed != 1)) {
-		text.fontsize = 16; 
-		if (paused)
+	if (paused || (speed != 1) || codec_slow) {
+		text.fontsize = 16;
+		if (codec_slow)
+			text.set_text('Codec Too Slow !');
+		else if (paused)
 			text.set_text((paused==2) ? 'Step mode' : 'Paused');
 		else
 			text.set_text('Speed: ' + speed);
@@ -439,7 +543,7 @@
 		mx.translate(0, ol_height/4);
 		ol_canvas.matrix = mx;
 		ol_canvas.path = text;
-		brush.set_color('cyan');
+		brush.set_color(codec_slow ? 'red' : 'cyan');
 		ol_canvas.fill(brush);
 		brush.set_color('white');
 	}
@@ -581,6 +685,8 @@
 			}
 			p = f.ipid_props(0, 'SAR');
 			if (p) str += ' SAR ' + p.n + '/' + p.d;			
+			p = f.ipid_props(0, 'PixelFormat');
+			if (p) str += ' pf ' + p;
 		} else {
 			p = f.ipid_props(0, 'SampleRate');
 			if (p) {
@@ -589,6 +695,8 @@
 				if (p) str += ' ' + p;
 				p = f.ipid_props(0, 'ChannelLayout');
 				if (p) str += ' ' + p;
+				p = f.ipid_props(0, 'AudioFormat');
+				if (p) str += ' fmt ' + p;
 			} 
 		}
 
@@ -685,6 +793,66 @@
 	vout.update('oldata', ol_buffer);
 }
 
+let auth_name="";
+let auth_pass="";
+let auth_state=0;
+let auth_modified = false;
+
+let auth_requests = ;
+
+function update_auth()
+{
+	if (init_wnd) {
+		let pos = '0x0x'+ol_width+'x'+ol_height;
+		vout.update('olwnd', pos);
+		init_wnd=false;
+		progress_bar_path=null;
+		auth_modified = true;
+
+		auth_name = auth_requests0.user;
+		auth_pass = auth_requests0.pass;
+	}
+	if (!auth_modified) return false;
+	auth_modified = false;
+
+	ol_canvas.clearf(1, 1, 1, 1);
+	let str = 'Authentication for ' + auth_requests0.site;
+	str.push(auth_requests0.secure ? "Secured Connection" : "NOT SECURED Connection");
+	if (auth_state) {
+		str.push('Enter password');
+		let p = '';
+		let i = auth_pass.length;
+		while (i) {
+			p+='*';
+			i--;
+		}
+		str.push(p);
+	} else {
+		str.push('Enter user name');
+		str.push(auth_name);
+	}
+	let fs = Math.floor(0.1*ol_height);
+	if (fs > 60) fs=60;
+	text.fontsize = fs;
+	text.lineSpacing = 1.5*fs;
+	text.align = GF_TEXT_ALIGN_CENTER;
+	text.baseline = GF_TEXT_BASELINE_TOP;
+	text.set_text(str);
+
+	let txtdim = text.measure();
+	let mx = new evg.Matrix2D();
+	mx.translate(- txtdim.width/2, -0);
+
+	ol_canvas.matrix = mx;
+	ol_canvas.path = text;
+	brush.set_color('black');
+	ol_canvas.fill(brush);
+	brush.set_color('white');
+
+
+	//we could lock vout to avoid any tearing ...
+	vout.update('oldata', ol_buffer);
+}
 
 function update_overlay()
 {
@@ -699,10 +867,14 @@
 	if (overlay_type==OL_PLAY) {
 		update_play();
 	}
-	//play screen
+	//stats screen
 	if (overlay_type==OL_STATS) {
 		update_stats();
 	}
+	//auth screen
+	if (overlay_type==OL_AUTH) {
+		update_auth();
+	}
 }
 
 let ol_visible=false;
@@ -729,22 +901,25 @@
 	vout.update('oldata', ol_buffer);
 	vout.lock(false);
 	if (!oltask_scheduled) {
-		session.post_task( () => {
-			oltask_scheduled=false;
-			if (audio_only && aout.ipid_props(0, 'eos') ) {
-				//we don't lock vout because the overlay buffer is still valid
-				vout.update('oldata', null);
-				return false;
-			}
-			if (session.last_task) {
-				return false;
-			}
-			update_overlay();
-			if (!ol_visible) return false;
-			if (overlay_type==OL_NONE) return false;
-			oltask_scheduled=true;
-			return task_reschedule;
-		}, "overlay_update");
+		try {
+			session.post_task( () => {
+				oltask_scheduled=false;
+				if (audio_only && aout.ipid_props(0, 'eos') ) {
+					//we don't lock vout because the overlay buffer is still valid
+					vout.update('oldata', null);
+					return false;
+				}
+				if (session.last_task) {
+					return false;
+				}
+				update_overlay();
+				if (!ol_visible) return false;
+				if (overlay_type==OL_NONE) return false;
+				oltask_scheduled=true;
+				return task_reschedule;
+			}, "overlay_update");
+			oltask_scheduled = true;
+		} catch (e) {}
 	}
 }
 
@@ -780,51 +955,63 @@
 
 function process_keyboard(evt)
 {
+	if (interactive_scene==1) return false;
+
+	if (overlay_type==OL_AUTH) {
+		return true;
+	}
+	if(evt.window != win_id) return true;
+
 	switch (evt.keycode) {
 	case GF_KEY_B:
 		if (evt.keymods & GF_KEY_MOD_SHIFT) speed *= 1.2;
 		else speed *= 2;
 		set_speed(speed);
-		return;
+		return true;
 	case GF_KEY_V:
 		if (evt.keymods & GF_KEY_MOD_SHIFT) speed /= 1.2;
 		else speed /= 2;
 		set_speed(speed);
-		return;
+		return true;
 	case GF_KEY_N:
 		speed = 1;
 		set_speed(speed);
-		return;
+		return true;
 	case GF_KEY_SPACE:
 		paused = !paused;
 		set_speed(paused ? 0 : speed);
-		return;
+		return true;
 	case GF_KEY_S:
 		paused = 2;
 		vout.update('step', '1');
 		if (aout) aout.update('speed', '0');
 		check_duration();
-		return;
+		return true;
 	case GF_KEY_RIGHT:
+		if (interactive_scene) return false;
 		do_seek(1, evt.keymods, false);
-		return;
+		return true;
 	case GF_KEY_LEFT:
+		if (interactive_scene) return false;
 		do_seek(-1, evt.keymods, false);
-		return;
+		return true;
 	case GF_KEY_UP:
+		if (interactive_scene) return false;
 		do_seek(1, evt.keymods, true);
-		return;
+		return true;
 	case GF_KEY_DOWN:
+		if (interactive_scene) return false;
 		do_seek(-1, evt.keymods, true);
-		return;
+		return true;
 
 	case GF_KEY_F:
 		if (audio_only) return;
 		fullscreen = !fullscreen;
 		vout.update('fullscreen', ''+fullscreen);
-		return;
+		return true;
 
 	case GF_KEY_H:
+		if (overlay_type==OL_AUTH) break;
 		//hide player
 		if (audio_only && (overlay_type==OL_PLAY)) {
 			toggle_overlay();
@@ -836,8 +1023,9 @@
 			overlay_type=OL_PLAY;
 			toggle_overlay();
 		}
-		return;
+		return true;
 	case GF_KEY_I:
+		if (overlay_type==OL_AUTH) break;
 		//hide player
 		if (audio_only && (overlay_type==OL_PLAY)) {
 			toggle_overlay();
@@ -849,14 +1037,15 @@
 			overlay_type=OL_PLAY;
 			toggle_overlay();
 		}
-		return;
+		return true;
 	case GF_KEY_P:
+		if (overlay_type==OL_AUTH) break;
 		//do not untoggle for audio only
 		if (audio_only) return;
 		overlay_type=OL_PLAY;
 		if (!ol_visible) init_wnd=true;
 		toggle_overlay();
-		return;
+		return true;
 	case GF_KEY_R:
 		if (audio_only) return;
 		rot = vout.get_arg('vrot');
@@ -866,7 +1055,7 @@
 		else if (rot==1) vout.update('vrot', '90');
 		else if (rot==2) vout.update('vrot', '180');
 		else vout.update('vrot', '270');
-		return;
+		return true;
 	case GF_KEY_M:
 		if (audio_only) return;
 		flip = vout.get_arg('vflip');
@@ -880,4 +1069,19 @@
 	default:
 		break;
 	}
+	return false;
 }
+
+session.set_auth_fun( (site, user, pass, secure, auth_cbk) => {
+	overlay_type_bck = overlay_type;
+	overlay_type = OL_AUTH;
+	auth_cbk.site = site;
+	auth_cbk.user = user ? user : "";
+	auth_cbk.pass = pass ? pass : "";
+	auth_cbk.secure = secure;
+	auth_requests.push(auth_cbk);
+
+	if (overlay_type_bck) toggle_overlay();
+	toggle_overlay();
+});
+

gpac-2.0.0.tar.gz/share/scripts/webvtt-renderer.js -> gpac-2.2.0.tar.gz/share/scripts/webvtt-renderer.js Changed

@@ -9,8 +9,8 @@
 var height = rect.height;
 
 //filter-assignable variables - if changing names, also do it in filters/dec_webvtt.c
-var xOffset = 5;
-var yOffset = 5;
+var xOffset = 0;
+var yOffset = 0; //positive towards top
 var fontSize = 20;
 var textColor = "white";
 var fontFamily = "SANS";
@@ -29,27 +29,37 @@
 }
 
 function createTextArea(settingsObj) {
+
 	var t = document.createElement("textArea");
-	t.setAttribute("x", xOffset+settingsObj.xPosition);
-	t.setAttribute("y", yOffset);
+	let x = xOffset + settingsObj.xPosition;
+	let y = -yOffset - settingsObj.linePosition;
+	t.setAttribute("x", x);
+	t.setAttribute("y", y);
 	var w, h;
-	if (settingsObj.fromTop) {
-		t.setAttribute("display-align", "before");
-		h=height-2*yOffset;
-	} else {
-		t.setAttribute("display-align", "after");
-		h = height-2*yOffset-settingsObj.linePosition;
-	}
-	w = settingsObj.size-2*xOffset;
+
+	t.setAttribute("display-align", "after");
+	h=height;
+	w = settingsObj.size;
 	t.setAttribute("height", h);
 	t.setAttribute("width", w);
-	reportMessage("Creating textArea size " + w + " x " + h);
+	reportMessage("Creating textArea size " + x + 'x' + y + '@' + w + "x" + h);
 	
 	t.setAttribute("fill", textColor);
 	t.setAttribute("font-size", fontSize);
 	t.setAttribute("font-family", fontFamily);
 	t.setAttribute("text-align", settingsObj.align);
 	t.setAttribute("line-increment", lineSpaceFactor*fontSize);
+
+/*	if (w < width) {
+		var r = document.createElement("rect");
+		r.setAttribute("height", h);
+		r.setAttribute("width", w);
+		r.setAttribute("x", xOffset+settingsObj.xPosition);
+		r.setAttribute("y", yOffset-5);
+		r.setAttribute("fill", "cyan");
+		cueArea.appendChild(r);
+	}
+*/
 	cueArea.appendChild(t);
 	reportMessage("textArea created: "+t);
 	return t;
@@ -101,43 +111,49 @@
 	}
 
 	// Compute real values
-	if (compositeCueSettings.line !== undefined) {
+	if (typeof compositeCueSettings.line != 'undefined') {
 		if (compositeCueSettings.line.match(/\%/)) {
 			obj.linePosition = parseFloat(compositeCueSettings.line.replace(/\%/ig,""));
 			if (isNaN(obj.linePosition)) {
-				obj.linePosition = nbCues*lineSpaceFactor*fontSize;
+				obj.linePosition = (nbCues + 0.5) * lineSpaceFactor*fontSize;
 			} else {
-				obj.linePosition *= height/100;
+				if (obj.linePosition<0) obj.linePosition=100;
+				else if (obj.linePosition>100) obj.linePosition=100;
+				//convert to vertical translation 
+				let h = height - 3*lineSpaceFactor*fontSize/2;
+				obj.linePosition = h - obj.linePosition*h/100 + lineSpaceFactor*fontSize/2;
 			}
 		} else {
-			obj.linePosition = parseFloat(compositeCueSettings.line)*lineIncrement;
+			obj.linePosition = parseFloat(compositeCueSettings.line);
 			if (isNaN(obj.linePosition)) {
-				obj.linePosition = nbCues*lineSpaceFactor*fontSize;
+				obj.linePosition = (nbCues + 0.5) * lineSpaceFactor*fontSize;
 			} else {
-				if (obj.linePosition > 0) {
-					obj.fromTop = true;
+				let h = (height - 2*fontSize) / lineSpaceFactor*fontSize;
+				obj.linePosition *= lineSpaceFactor*fontSize;
+				if (obj.linePosition >= 0) {
+						obj.linePosition = height - lineSpaceFactor*fontSize - obj.linePosition;
 				} else {
-					obj.fromTop = false;
-					obj.linePosition = -obj.linePosition;
+					obj.linePosition = -obj.linePosition - lineSpaceFactor*fontSize/2;
 				}
 			}
 		}
 	} else {
-		obj.linePosition = nbCues*lineSpaceFactor*fontSize;
+		obj.linePosition = (nbCues + 0.5) * lineSpaceFactor*fontSize;
 	}
-	reportMessage("linePosition: "+obj.linePosition);
-	if (compositeCueSettings.position !== undefined) {
+
+	let position_auto=true;
+	if (typeof compositeCueSettings.position != 'undefined') {
 		obj.xPosition = parseFloat(compositeCueSettings.position.replace(/\%/ig,""));
 		if (isNaN(obj.xPosition)) {
-			obj.xPosition = 50;
+			obj.xPosition = 0;
 		} else {
 			obj.xPosition *= width/100;
+			position_auto = false;
 		}
 	} else {
-		obj.xPosition = 50;
+		obj.xPosition = 0;
 	}
-	reportMessage("xPosition: "+obj.xPosition);
-	if (compositeCueSettings.size !== undefined) {
+	if (typeof compositeCueSettings.size != 'undefined') {
 		obj.size = parseFloat(compositeCueSettings.size.replace(/\%/ig,""));
 		if (isNaN(obj.size)) {
 			obj.size = 100;
@@ -145,28 +161,40 @@
 	} else {
 		obj.size = 100;
 	}
+	if (obj.size==100) position_auto = false;
 	obj.size *= width/100;
-	
-	reportMessage("size: "+obj.size);
-	if (compositeCueSettings.align !== undefined) {
-		if (compositeCueSettings.align === "middle") {
-			obj.align = "center";
-		} else if (compositeCueSettings.align === "left") {
+
+	//default to center
+	if (position_auto) {
+		obj.xPosition = width/2 - obj.size/2;
+	}
+
+	if (typeof compositeCueSettings.align != 'undefined') {
+		if (compositeCueSettings.align === "left") {
 			obj.align = "start";
-		} else if (compositeCueSettings.align === "right") {
-			obj.align = "end";
+			if (position_auto) {
+				obj.xPosition = 0;
+			}
 		} else if (compositeCueSettings.align === "start") {
 			obj.align = "start";
+		} else if (compositeCueSettings.align === "right") {
+			obj.align = "end";
+			if (position_auto) {
+				obj.xPosition = width - obj.size;
+			}
 		} else if (compositeCueSettings.align === "end") {
 			obj.align = "end";
+		/*} else if (compositeCueSettings.align === "middle") {
+			obj.align = "center";
+		*/
 		} else {
 			obj.align = "center";
 		}
 	} else {
 		obj.align = "center";
 	}
-	reportMessage("align: "+obj.align);
-	reportMessage("cue settings parsed: "+obj);
+
+	reportMessage("cue settings parsed: " + JSON.stringify(obj));
 	return obj;
 }
 
@@ -231,7 +259,7 @@
 						stack = stack.slice(0,stackScanDepth);
 					} else {
 						// Tag mismatch!
-						alert("Tag mismatch when parsing WebVTT cue: "+cueText);
+						alert("Tag mismatch when parsing WebVTT cue: "+cueText+ " tag name was " + TagName);
 					}
 				} else {
 					// Opening Tag
@@ -239,9 +267,10 @@
 					// If not, don't allow it (unless the sanitiseCueHTML option is explicitly set to false)
 				
 					if ((	currentToken.substr(1).match(SRTChunkTimestampParser)	||
-							currentToken.match(/^<v\s+^>+>/i)						||
-							currentToken.match(/^<ca-z0-9\-\_\.+>/)				||
-							currentToken.match(/^<(b|i|u|ruby|rt)>/))				) {
+							currentToken.match(/^<(v|lang)\s+^>+>/i)						||
+							currentToken.match(/^<ca-zA-Z0-9\-\_\.+>/)				||
+							currentToken.match(/^<(b|i|u|ruby|ruby|rt)>/))
+					) {
 						
 						var tmpObject = {
 							"token":	currentToken.replace(/<\/>+/ig,"").split(/\s\.+/)0,

gpac-2.0.0.tar.gz/src/Makefile -> gpac-2.2.0.tar.gz/src/Makefile Changed

@@ -2,7 +2,8 @@
 
 vpath %.c $(SRC_PATH)/src
 
-CFLAGS=-I"$(SRC_PATH)/include" $(OPTFLAGS)
+#set libgpac cflags and ldflags before opt flags/libs since local includes/libs are first in LIBGPAC_CFLAGS and LIBGPAC_LDFLAGS
+CFLAGS=-I"$(SRC_PATH)/include" $(LIBGPAC_CFLAGS) $(OPTFLAGS)
 
 ifeq ($(DEBUGBUILD),yes)
 CFLAGS+=-g
@@ -15,10 +16,8 @@
 endif
 
 ## libgpac objects gathering: src/utils
-LIBGPAC_UTILS=utils/os_divers.o utils/os_file.o utils/list.o utils/bitstream.o utils/constants.o utils/error.o utils/alloc.o utils/url.o utils/configfile.o utils/gltools.o utils/gzio.o
-ifeq ($(DISABLE_CORE_TOOLS),no)
-LIBGPAC_UTILS+=utils/sha1.o utils/base_encoding.o utils/math.o utils/os_net.o utils/os_thread.o utils/os_config_init.o utils/cache.o utils/downloader.o utils/xml_parser.o utils/utf.o utils/token.o utils/color.o utils/Remotery.o
-endif
+LIBGPAC_UTILS=utils/os_divers.o utils/os_file.o utils/list.o utils/bitstream.o utils/constants.o utils/error.o utils/alloc.o utils/url.o utils/configfile.o utils/gltools.o utils/gzio.o utils/xml_parser.o
+LIBGPAC_UTILS+=utils/sha1.o utils/sha256.o utils/base_encoding.o utils/math.o utils/os_net.o utils/os_thread.o utils/os_config_init.o utils/cache.o utils/downloader.o utils/utf.o utils/token.o utils/color.o utils/Remotery.o
 
 ifeq ($(DISABLE_PLAYER),no)
 LIBGPAC_UTILS+=utils/uni_bidi.o utils/unicode.o
@@ -149,9 +148,6 @@
 ifeq ($(CONFIG_JS),yes)
 LIBGPAC_QUICKJS=quickjs/cutils.o quickjs/libbf.o quickjs/libregexp.o quickjs/libunicode.o quickjs/quickjs.o quickjs/quickjs-libc.o
 LIBGPAC_JSMODS+=jsmods/core.o jsmods/evg.o jsmods/scene_js.o jsmods/storage.o jsmods/webgl.o jsmods/xhr.o
-ifneq ($(CONFIG_FFMPEG),no)
-JSMODS_CFLAGS+=$(ffmpeg_cflags)
-endif
 endif
 
 
@@ -192,17 +188,12 @@
 LIBGPAC_SCENEMANAGER+=scene_manager/encode_isom.o
 endif
 
-## libgpac objects gathering: src/terminal
-LIBGPAC_TERMINAL=terminal/terminal.o
-
-
 ## libgpac objects gathering: src/compositor
 LIBGPAC_COMPOSITOR=compositor/audio_input.o compositor/audio_mixer.o compositor/audio_render.o compositor/bindable.o compositor/camera.o compositor/compositor.o compositor/compositor_2d.o compositor/compositor_3d.o compositor/compositor_node_init.o compositor/drawable.o compositor/events.o compositor/font_engine.o compositor/hardcoded_protos.o compositor/mesh.o compositor/mesh_collide.o compositor/mesh_tesselate.o compositor/mpeg4_animstream.o compositor/mpeg4_audio.o compositor/mpeg4_background.o compositor/mpeg4_background2d.o compositor/mpeg4_bitmap.o compositor/mpeg4_composite.o compositor/mpeg4_form.o compositor/mpeg4_geometry_2d.o compositor/mpeg4_geometry_3d.o compositor/mpeg4_geometry_ifs2d.o compositor/mpeg4_geometry_ils2d.o compositor/mpeg4_gradients.o compositor/mpeg4_grouping.o compositor/mpeg4_grouping_2d.o compositor/mpeg4_grouping_3d.o compositor/mpeg4_layer_2d.o compositor/mpeg4_layer_3d.o compositor/mpeg4_layout.o compositor/mpeg4_lighting.o compositor/mpeg4_path_layout.o compositor/mpeg4_sensors.o compositor/mpeg4_sound.o compositor/mpeg4_text.o compositor/mpeg4_textures.o compositor/mpeg4_timesensor.o compositor/mpeg4_viewport.o compositor/navigate.o compositor/offscreen_cache.o compositor/svg_base.o compositor/svg_font.o compositor/svg_geometry.o compositor/svg_grouping.o compositor/svg_media.o compositor/svg_paint_servers.o compositor/svg_text.o compositor/texturing.o compositor/texturing_gl.o compositor/visual_manager.o compositor/visual_manager_2d.o compositor/visual_manager_2d_draw.o compositor/visual_manager_3d.o compositor/visual_manager_3d_gl.o compositor/x3d_geometry.o compositor/clock.o compositor/mpeg4_inputsensor.o compositor/mpeg4_mediacontrol.o compositor/media_object.o compositor/mpeg4_mediasensor.o compositor/mpeg4_inline.o compositor/scene_ns.o compositor/object_manager.o compositor/scene.o compositor/svg_external.o compositor/scene_node_init.o
 #LIBGPAC_COMPOSITOR+=compositor/hc_flash_shape.o compositor/svg_filters.o
 
 ifeq ($(DISABLE_PLAYER),yes)
 LIBGPAC_COMPOSITOR=compositor/font_engine.o
-LIBGPAC_TERMINAL=
 endif
 ifeq ($(DISABLE_SCENEGRAPH),yes)
 LIBGPAC_SCENE=scenegraph/vrml_js.o
@@ -219,103 +210,28 @@
 LIBGPAC_LASER=laser/lsr_enc.o laser/lsr_dec.o laser/lsr_tables.o
 endif
 
-## libgpac objects gathering:
-OBJS=$(LIBGPAC_UTILS) $(LIBGPAC_CRYPTO) $(LIBGPAC_SCENE) $(LIBGPAC_IETF) $(LIBGPAC_BIFS) $(LIBGPAC_ISOM) $(LIBGPAC_ODF) $(LIBGPAC_MEDIATOOLS) $(LIBGPAC_SCENEMANAGER) $(LIBGPAC_TERMINAL) $(LIBGPAC_COMPOSITOR) $(LIBGPAC_LASER) $(LIBGPAC_EVG) $(LIBGPAC_FILTERS) $(LIBGPAC_FILTERS_SVC) $(LIBGPAC_FILTERS_OHEVC) $(LIBGPAC_QUICKJS) $(LIBGPAC_JSMODS)
 
 SCENEGRAPH_CFLAGS=
-MEDIATOOLS_CFLAGS=$(JS_FLAGS)
-
-##include static modules and other deps for libgpac
-include ../static.mak
-
-LIBGPAC_FILTERS+=filters/bs_agg.o filters/bs_split.o filters/bsrw.o filters/compose.o filters/dasher.o filters/dec_ac52.o filters/dec_bifs.o filters/dec_faad.o filters/dec_img.o filters/dec_j2k.o filters/dec_laser.o filters/dec_mad.o filters/dec_mediacodec.o filters/dec_nvdec.o filters/dec_nvdec_sdk.o filters/dec_odf.o filters/dec_theora.o filters/dec_ttml.o filters/dec_ttxt.o filters/dec_vorbis.o filters/dec_vtb.o filters/dec_webvtt.o filters/dec_xvid.o filters/decrypt_cenc_isma.o filters/dmx_avi.o filters/dmx_dash.o filters/dmx_gsf.o filters/dmx_m2ts.o filters/dmx_mpegps.o filters/dmx_nhml.o filters/dmx_nhnt.o filters/dmx_ogg.o filters/dmx_saf.o filters/dmx_vobsub.o filters/enc_jpg.o filters/enc_png.o filters/encrypt_cenc_isma.o filters/ff_common.o filters/ff_avf.o filters/ff_dec.o filters/ff_dmx.o filters/ff_enc.o filters/ff_rescale.o filters/ff_mx.o filters/filelist.o filters/hevcmerge.o filters/hevcsplit.o filters/in_dvb4linux.o filters/in_file.o filters/in_http.o filters/in_pipe.o filters/in_route.o filters/in_rtp.o filters/in_rtp_rtsp.o filters/in_rtp_sdp.o filters/in_rtp_signaling.o filters/in_rtp_stream.o filters/in_sock.o filters/inspect.o filters/io_fcryp.o filters/isoffin_load.o filters/isoffin_read.o filters/isoffin_read_ch.o filters/jsfilter.o filters/load_bt_xmt.o filters/load_svg.o filters/load_text.o filters/mux_avi.o filters/mux_gsf.o filters/mux_isom.o filters/mux_ts.o filters/out_audio.o  filters/out_file.o filters/out_http.o filters/out_pipe.o filters/out_route.o filters/out_rtp.o filters/out_rtsp.o filters/out_sock.o filters/out_video.o filters/reframer.o filters/reframe_ac3.o filters/reframe_adts.o filters/reframe_latm.o filters/reframe_amr.o filters/reframe_av1.o filters/reframe_flac.o filters/reframe_h263.o filters/reframe_img.o filters/reframe_mhas.o filters/reframe_mp3.o filters/reframe_mpgvid.o filters/reframe_nalu.o filters/reframe_prores.o filters/reframe_qcp.o filters/reframe_rawvid.o filters/reframe_rawpcm.o filters/reframe_truehd.o filters/resample_audio.o filters/restamp.o  filters/tileagg.o filters/tilesplit.o filters/tssplit.o filters/unit_test_filter.o filters/rewind.o filters/rewrite_adts.o filters/rewrite_mhas.o filters/rewrite_mp4v.o filters/rewrite_nalu.o filters/rewrite_obu.o filters/vflip.o filters/vcrop.o filters/write_generic.o filters/write_nhml.o filters/write_nhnt.o filters/write_qcp.o filters/write_vtt.o ../modules/dektec_out/dektec_video_decl.o
-
+MEDIATOOLS_CFLAGS=
 
-
-FILTERS_CFLAGS+=$(JS_FLAGS)
+LIBGPAC_FILTERS+=filters/bs_agg.o filters/bs_split.o filters/bsrw.o filters/compose.o filters/dasher.o filters/dec_ac52.o filters/dec_bifs.o filters/dec_faad.o filters/dec_img.o filters/dec_j2k.o filters/dec_laser.o filters/dec_mad.o filters/dec_mediacodec.o filters/dec_nvdec.o filters/dec_nvdec_sdk.o filters/dec_odf.o filters/dec_theora.o filters/dec_ttml.o filters/dec_ttxt.o filters/dec_vorbis.o filters/dec_vtb.o filters/dec_webvtt.o filters/dec_xvid.o filters/decrypt_cenc_isma.o filters/dmx_avi.o filters/dmx_dash.o filters/dmx_gsf.o filters/dmx_m2ts.o filters/dmx_mpegps.o filters/dmx_nhml.o filters/dmx_nhnt.o filters/dmx_ogg.o filters/dmx_saf.o filters/dmx_vobsub.o filters/enc_jpg.o filters/enc_png.o filters/encrypt_cenc_isma.o filters/filelist.o filters/hevcmerge.o filters/hevcsplit.o filters/in_dvb4linux.o filters/in_file.o filters/in_http.o filters/in_pipe.o filters/in_route.o filters/in_rtp.o filters/in_rtp_rtsp.o filters/in_rtp_sdp.o filters/in_rtp_signaling.o filters/in_rtp_stream.o filters/in_sock.o filters/inspect.o filters/io_fcryp.o filters/isoffin_load.o filters/isoffin_read.o filters/isoffin_read_ch.o filters/jsfilter.o filters/load_bt_xmt.o filters/load_svg.o filters/load_text.o filters/mux_avi.o filters/mux_gsf.o filters/mux_isom.o filters/mux_ts.o filters/mux_ogg.o filters/out_audio.o  filters/out_file.o filters/out_http.o filters/out_pipe.o filters/out_route.o filters/out_rtp.o filters/out_rtsp.o filters/out_sock.o filters/out_video.o filters/reframer.o filters/reframe_ac3.o filters/reframe_adts.o filters/reframe_latm.o filters/reframe_amr.o filters/reframe_av1.o filters/reframe_flac.o filters/reframe_h263.o filters/reframe_img.o filters/reframe_mhas.o filters/reframe_mp3.o filters/reframe_mpgvid.o filters/reframe_nalu.o filters/reframe_prores.o filters/reframe_qcp.o filters/reframe_rawvid.o filters/reframe_rawpcm.o filters/reframe_truehd.o filters/resample_audio.o filters/restamp.o  filters/tileagg.o filters/tilesplit.o filters/tssplit.o filters/ttml_conv.o filters/unit_test_filter.o filters/rewind.o filters/rewrite_adts.o filters/rewrite_mhas.o filters/rewrite_mp4v.o filters/rewrite_nalu.o filters/rewrite_obu.o filters/vflip.o filters/vcrop.o filters/write_generic.o filters/write_nhml.o filters/write_nhnt.o filters/write_qcp.o filters/write_tx3g.o filters/write_vtt.o ../modules/dektec_out/dektec_video_decl.o filters/dec_opensvc.o filters/unframer.o
+LIBGPAC_FILTERS_FFMPEG=filters/ff_common.o filters/ff_avf.o filters/ff_dec.o filters/ff_dmx.o filters/ff_enc.o filters/ff_rescale.o filters/ff_mx.o filters/ff_bsf.o
 
 ifeq ($(STATIC_MODULES),yes)
 LIBGPAC_FILTERS_OHEVC=filters/dec_openhevc.o
-FILTERS_OHEVC_CFLAGS=$(OHEVC_CFLAGS)
-endif
-
-LIBGPAC_FILTERS_SVC+=filters/dec_opensvc.o
-
-FILTERS_SVC_CFLAGS=$(OSVC_CFLAGS)
-
-ifneq ($(CONFIG_FFMPEG),no)
-FILTERS_CFLAGS+=$(ffmpeg_cflags)
-EXTRALIBS+=$(ffmpeg_lflags)
-endif
-
-ifneq ($(CONFIG_FAAD),no)
-EXTRALIBS+=-lfaad
-ifeq ($(CONFIG_FAAD),local)
-CFLAGS+= -I"$(LOCAL_INC_PATH)"
-endif
-endif
-
-ifneq ($(CONFIG_MAD),no)
-EXTRALIBS+=-lmad
-ifeq ($(CONFIG_MAD),local)
-CFLAGS+= -I"$(LOCAL_INC_PATH)"
-endif
-endif
-
-ifneq ($(CONFIG_XVID),no)
-EXTRALIBS+=-lxvidcore
-ifeq ($(CONFIG_XVID),local)
-CFLAGS+= -I"$(LOCAL_INC_PATH)"
-endif
-endif
-
-ifneq ($(CONFIG_A52),no)
-EXTRALIBS+=-la52
-ifeq ($(CONFIG_A52),local)
-CFLAGS+= -I"$(LOCAL_INC_PATH)"
-endif
-endif
-
-ifneq ($(CONFIG_VORBIS),no)
-EXTRALIBS+=-lvorbis
-endif
-
-ifneq ($(CONFIG_THEORA),no)
-EXTRALIBS+=-ltheora
-endif
-
-ifneq ($(CONFIG_JP2),no)
-EXTRALIBS+=$(JP2_LDFLAGS)
-ifeq ($(CONFIG_JP2),local)
-CFLAGS+= -DOPJ_STATIC -I"$(LOCAL_INC_PATH)/openjpeg"
-else
-CFLAGS+=$(JP2_CFLAGS)
-endif
-endif
-
-ifeq ($(CONFIG_OPENHEVC),yes)
-#EXTRALIBS+=-lopenhevc
-EXTRALIBS+=$(OHEVC_LDFLAGS)
+FILTERS_OHEVC_CFLAGS=$(openhevc_cflags)
 endif
 
-ifeq ($(CONFIG_OPENSVC),yes)
-#EXTRALIBS+=-lOpenSVCDec
-EXTRALIBS+=$(OSVC_LDFLAGS)
-endif
+## libgpac objects gathering:
+OBJS=$(LIBGPAC_UTILS) $(LIBGPAC_CRYPTO) $(LIBGPAC_SCENE) $(LIBGPAC_IETF) $(LIBGPAC_BIFS) $(LIBGPAC_ISOM) $(LIBGPAC_ODF) $(LIBGPAC_MEDIATOOLS) $(LIBGPAC_SCENEMANAGER) $(LIBGPAC_COMPOSITOR) $(LIBGPAC_LASER) $(LIBGPAC_EVG) $(LIBGPAC_FILTERS) $(LIBGPAC_FILTERS_FFMPEG) $(LIBGPAC_FILTERS_OHEVC) $(LIBGPAC_QUICKJS) $(LIBGPAC_JSMODS)
 
-ifeq ($(CONFIG_VTB),yes)
-EXTRALIBS+=$(vtb_ldflags)
-endif
 
-ifneq ($(CONFIG_NGHTTP2),no)
-EXTRALIBS+=$(NGHTTP2_LDFLAGS)
-ifeq ($(CONFIG_NGHTTP2),local)
-CFLAGS+= -I"$(LOCAL_INC_PATH)"
-else
-CFLAGS+=$(NGHTTP2_CFLAGS)
-endif
-endif
+##include static modules and other deps for libgpac
+include ../static.mak
 
+#todo, we may need to trick ld for library path...
+EXTRALIBS+=$(zlib_ldflags) $(opensvc_ldflags) $(ssl_ldflags) $(jpeg_ldflags) $(openjpeg_ldflags) $(png_ldflags) $(mad_ldflags) $(a52_ldflags) $(xvid_ldflags) $(faad_ldflags)
+EXTRALIBS+=$(ffmpeg_ldflags) $(ogg_ldflags) $(vorbis_ldflags) $(theora_ldflags) $(nghttp2_ldflags) $(vtb_ldflags)
 
 
 ##libgpac library output
@@ -339,6 +255,15 @@
 EXTRALIBS+= -lrt
 endif
 
+ALL_LIBS=
+
+ALL_LIBS+=$(LIBGPAC_LDFLAGS) $(EXTRALIBS)
+
+ifeq ($(STATIC_MODULES),yes)
+ifneq ($(CONFIG_OPENHEVC),no)
+ALL_LIBS+=$(openhevc_ldflags)
+endif
+endif
 
 SRCS := $(OBJS:.o=.c)
 
@@ -351,55 +276,103 @@
 scenegraph: CFLAGS += $(SCENEGRAPH_CFLAGS)
 scenegraph: $(LIBGPAC_SCENE)
 .deps/scenegraph/%: CFLAGS += $(SCENEGRAPH_CFLAGS)
-.deps/scenegraph/%: CFLAGS += $(SCENEGRAPH_CFLAGS)
 
 media_tools: CFLAGS += $(MEDIATOOLS_CFLAGS)
 media_tools: $(LIBGPAC_MEDIATOOLS)
 .deps/media_tools/%: CFLAGS += $(MEDIATOOLS_CFLAGS)
-.deps/media_tools/%: CFLAGS += $(MEDIATOOLS_CFLAGS)
 
 compositor: CFLAGS+=$(COMPOSITOR_CFLAGS)
 compositor: $(LIBGPAC_COMPOSITOR)
 .deps/compositor/%: CFLAGS += $(COMPOSITOR_CFLAGS)
-.deps/compositor/%: CFLAGS += $(COMPOSITOR_CFLAGS)
 
 filters: CFLAGS += $(FILTERS_CFLAGS)
 filters: $(LIBGPAC_FILTERS)
 .deps/filters/%: CFLAGS += $(FILTERS_CFLAGS)
-.deps/filters/%: CFLAGS += $(FILTERS_CFLAGS)
+
+filters_ffmpeg: CFLAGS += $(FILTERS_CFLAGS) $(ffmpeg_cflags)
+filters_ffmpeg: $(LIBGPAC_FILTERS_FFMPEG)
+.deps/filters/%: CFLAGS += $(FILTERS_CFLAGS) $(ffmpeg_cflags)
+
 
 filters_ohevc: CFLAGS += $(FILTERS_OHEVC_CFLAGS)
 filters_ohevc: $(LIBGPAC_FILTERS_OHEVC)
 .deps/filters/dec_openhevc.dep: CFLAGS += $(FILTERS_OHEVC_CFLAGS)
 
-filters_svc: CFLAGS += $(FILTERS_SVC_CFLAGS)
-filters_svc: $(LIBGPAC_FILTERS_SVC)
-.deps/filters/dec_opensvc.dep: CFLAGS += $(FILTERS_SVC_CFLAGS)
-
 jsmods: CFLAGS += $(JSMODS_CFLAGS)
 jsmods: $(LIBGPAC_JSMODS)
 .deps/jsmods/%: CFLAGS += $(JSMODS_CFLAGS)
-.deps/jsmods/%: CFLAGS += $(JSMODS_CFLAGS)
+
+jsmods/evg.o: CFLAGS += $(ffmpeg_cflags)
+.deps/jsmods/evg.%: CFLAGS += $(ffmpeg_cflags)
+
+#set cflags for all ext lib
+filters/dec_opensvc.o: CFLAGS += $(opensvc_cflags)
+filters/dec_opensvc.o: filters/dec_opensvc.c
+.deps/filters/dec_opensvc.dep: CFLAGS += $(opensvc_cflags)
+
+filters/dec_j2k.o: CFLAGS += $(openjpeg_cflags)
+filters/dec_j2k.o: filters/dec_j2k.c
+.deps/filters/dec_j2k.dep: CFLAGS += $(openjpeg_cflags)
+
+filters/dec_mad.o: CFLAGS += $(mad_cflags)
+filters/dec_mad.o: filters/dec_mad.c
+
+filters/dec_ac52.o: CFLAGS += $(a52_cflags)
+filters/dec_ac52.o: filters/dec_ac52.c
+
+filters/dec_xvid.o: CFLAGS += $(xvid_cflags)
+filters/dec_xvid.o: filters/dec_xvid.c
+
+filters/dec_faad.o: CFLAGS += $(faad_cflags)
+filters/dec_faad.o: filters/dec_faad.c
+
+filters/dec_faad.o: CFLAGS += $(faad_cflags)
+filters/dec_faad.o: filters/dec_faad.c
+
+filters/dec_theora.o: CFLAGS += $(ogg_cflags) $(theora_cflags)
+filters/dec_theora.o: filters/dec_theora.c
+
+filters/dec_vorbis.o: CFLAGS += $(ogg_cflags) $(vorbis_cflags)
+filters/dec_vorbis.o: filters/dec_vorbis.c
+
+filters/dec_vtb.o: CFLAGS += $(vtb_cflags)
+filters/dec_vtb.o: filters/dec_vtb.c
+
+filters/enc_jpg.o: CFLAGS += $(jpeg_cflags)
+filters/enc_jpg.o: filters/enc_jpg.c
+
+filters/enc_png.o: CFLAGS += $(zlib_cflags) $(png_cflags)
+filters/enc_png.o: filters/enc_png.c
+
+media_tools/img.o: CFLAGS += $(jpeg_cflags) $(zlib_cflags) $(png_cflags)
+media_tools/img.o: media_tools/img.c
+
+utils/downloader.o: CFLAGS += $(nghttp2_cflags) $(ssl_cflags)
+utils/downloader.o: utils/downloader.c
+.deps/utils/downloader.dep: CFLAGS += $(nghttp2_cflags) $(ssl_cflags)
+
+crypto/g_crypt_openssl.o: CFLAGS += $(ssl_cflags)
+crypto/g_crypt_openssl.o: crypto/g_crypt_openssl.c
 
 
-../bin/gcc/$(LIB): $(LIBGPAC_UTILS) $(LIBGPAC_IETF) $(LIBGPAC_BIFS) $(LIBGPAC_ODF) $(LIBGPAC_LASER) $(LIBGPAC_ISOM) $(LIBGPAC_SCENEMANAGER) $(LIBGPAC_TERMINAL) compositor scenegraph media_tools crypto filters filters_ohevc filters_svc jsmods $(OBJS)
+../bin/gcc/$(LIB): $(LIBGPAC_UTILS) $(LIBGPAC_IETF) $(LIBGPAC_BIFS) $(LIBGPAC_ODF) $(LIBGPAC_LASER) $(LIBGPAC_ISOM) $(LIBGPAC_SCENEMANAGER) compositor scenegraph media_tools crypto filters filters_ffmpeg filters_ohevc jsmods $(OBJS)
 #	@echo "OBJS $(OBJS)"
-#	@echo "LIBS $(EXTRALIBS)"
+#	@echo "LIBS $(ALL_LIBS)"
 
 ifeq ($(CONFIG_DARWIN),yes)
 
 	$(LIBTOOL) -s -o ../bin/gcc/libgpac_static.a $(OBJS)
 	$(RANLIB) ../bin/gcc/libgpac_static.a
-ifneq ($(STATICBUILD),yes)
-	$(CC) $(SHFLAGS) $(LD_SONAME) -o $@ $(OBJS) $(EXTRALIBS)  $(LDFLAGS)
+ifneq ($(STATIC_BUILD),yes)
+	$(CC) $(SHFLAGS) $(LD_SONAME) -o $@ $(OBJS) $(ALL_LIBS) $(LDFLAGS)
 endif
 
 else
 
 	$(AR) cr ../bin/gcc/libgpac_static.a $(OBJS)
 	$(RANLIB) ../bin/gcc/libgpac_static.a
-ifneq ($(STATICBUILD),yes)
-	$(CC) $(SHFLAGS) $(LD_SONAME) -o $@ $(OBJS) $(EXTRALIBS)	 $(LDFLAGS)
+ifneq ($(STATIC_BUILD),yes)
+	$(CC) $(SHFLAGS) $(LD_SONAME) -o $@ $(OBJS) $(ALL_LIBS) $(LDFLAGS)
 	mv $@ $@.$(VERSION_SONAME)
 	ln -sf $(notdir $@).$(VERSION_SONAME) $@.$(VERSION_MAJOR)
 	ln -sf $(notdir $@).$(VERSION_SONAME) $@
@@ -408,7 +381,7 @@
 endif
 
 ifeq ($(shell fgrep "Libs.private:" ../gpac.pc 1>&2 2> /dev/null ; echo $$?),1)
-	@echo "Libs.private: -lgpac_static $(EXTRALIBS)" >> ../gpac.pc
+	@echo "Libs.private: -lgpac_static $(ALL_LIBS)" >> ../gpac.pc
 endif
 
 dep:

gpac-2.0.0.tar.gz/src/bifs/bifs_codec.c -> gpac-2.2.0.tar.gz/src/bifs/bifs_codec.c Changed

gpac-2.0.0.tar.gz/src/bifs/field_decode.c -> gpac-2.2.0.tar.gz/src/bifs/field_decode.c Changed

@@ -54,7 +54,7 @@
 
 void BD_CheckSFTimeOffset(GF_BifsDecoder *codec, GF_Node *node, GF_FieldInfo *inf)
 {
-	if (gf_node_get_tag(node) != TAG_ProtoNode) {
+	if (inf->name && (gf_node_get_tag(node) != TAG_ProtoNode)) {
 		if (!stricmp(inf->name, "startTime") || !stricmp(inf->name, "stopTime"))
 			BD_OffsetSFTime(codec, (Double *)inf->far_ptr);
 	} else if (gf_sg_proto_field_is_sftime_offset(node, inf)) {
@@ -205,6 +205,7 @@
 		if (sfcb->buffer) {
 			gf_free(sfcb->buffer);
 			sfcb->buffer = NULL;
+			sfcb->bufferSize = 0;
 		}
 		while (gf_list_count(sfcb->commandList)) {
 			GF_Command *com = (GF_Command*)gf_list_get(sfcb->commandList, 0);
@@ -247,7 +248,7 @@
 		if (!is_mem_com) {
 			GF_Node *old_node = *((GF_Node **) field->far_ptr);
 			if (old_node != NULL) {
-				u32 i, count = gf_list_count(codec->command_buffers);
+				u32 count = gf_list_count(codec->command_buffers);
 				for (i=0; i<count; i++) {
 					CommandBufferItem *cbi = (CommandBufferItem*) gf_list_get(codec->command_buffers, i);
 					if (cbi->node == old_node) {
@@ -301,7 +302,7 @@
 GF_Err BD_DecMFFieldList(GF_BifsDecoder * codec, GF_BitStream *bs, GF_Node *node, GF_FieldInfo *field, Bool is_mem_com)
 {
 	GF_Node *new_node;
-	GF_Err e;
+	GF_Err e=GF_OK;
 	u8 endFlag, qp_local, qp_on, initial_qp;
 	GF_ChildNodeItem *last = NULL;
 	u32 nbF;
@@ -322,15 +323,15 @@
 	while (!endFlag && (codec->LastError>=0)) {
 		if (field->fieldType != GF_SG_VRML_MFNODE) {
 			e = gf_sg_vrml_mf_append(field->far_ptr, field->fieldType, & sffield.far_ptr);
-			if (e) return e;
+			if (e) goto exit;
 			e = gf_bifs_dec_sf_field(codec, bs, node, &sffield, GF_FALSE);
-			if (e) return e;
+			if (e) goto exit;
 		} else {
 			new_node = gf_bifs_dec_node(codec, bs, field->NDTtype);
 			//append
 			if (new_node) {
 				e = gf_node_register(new_node, is_mem_com ? NULL : node);
-				if (e) return e;
+				if (e) goto exit;
 
 				//regular coding
 				if (node) {
@@ -340,7 +341,7 @@
 						//we have a QP in the same scope, remove previous
 						if (qp_on) gf_bifs_dec_qp_remove(codec, GF_FALSE);
 						e = gf_bifs_dec_qp_set(codec, new_node);
-						if (e) return e;
+						if (e) goto exit;
 						qp_on = 1;
 						if (qp_local) qp_local = 2;
 						if (codec->force_keep_qp) {
@@ -360,10 +361,11 @@
 					e = gf_node_list_add_child_last( (GF_ChildNodeItem **)field->far_ptr, new_node, &last);
 				}
 			} else {
-				return codec->LastError;
+				e = codec->LastError;
+				goto exit;
 			}
 		}
-		if (e) return e;
+		if (e) goto exit;
 
 		endFlag = gf_bs_read_int(bs, 1);
 
@@ -381,9 +383,13 @@
 		}
 		nbF += 1;
 	}
+
+exit:
 	/*finally delete the QP if any (local or not) as we get out of this node
 	and reactivate previous one*/
 	if (qp_on) gf_bifs_dec_qp_remove(codec, initial_qp);
+	if (e) return e;
+
 	/*this is for QP 14*/
 	gf_bifs_dec_qp14_set_length(codec, nbF);
 	return GF_OK;
@@ -426,64 +432,71 @@
 			e = gf_bifs_dec_sf_field(codec, bs, node, &sffield, GF_FALSE);
 			if (e) return e;
 		}
-	} else {
-		last = NULL;
-		for (i=0; i<nbFields; i++) {
-			GF_Node *new_node = gf_bifs_dec_node(codec, bs, field->NDTtype);
-			if (new_node) {
-				e = gf_node_register(new_node, is_mem_com ? NULL : node);
-				if (e) return e;
-
-				if (node) {
-					/*special case for QP, register as the current QP*/
-					if (gf_node_get_tag(new_node) == TAG_MPEG4_QuantizationParameter) {
-						qp_local = ((M_QuantizationParameter *)new_node)->isLocal;
-						/*we have a QP in the same scope, remove previous
-						NB: we assume this is the right behavior, the spec doesn't say
-						whether QP is cumulative or not*/
-						if (qp_on) gf_bifs_dec_qp_remove(codec, GF_FALSE);
+		return GF_OK;
+	}
 
-						e = gf_bifs_dec_qp_set(codec, new_node);
-						if (e) return e;
-						qp_on = 1;
-						if (qp_local) qp_local = 2;
-						if (codec->force_keep_qp) {
-							e = gf_node_list_add_child_last(field->far_ptr, new_node, &last);
-							if (e) return e;
-						} else {
-							gf_node_register(new_node, NULL);
-							gf_node_unregister(new_node, node);
-						}
-					} else {
+	e = GF_OK;
+	last = NULL;
+	for (i=0; i<nbFields; i++) {
+		GF_Node *new_node = gf_bifs_dec_node(codec, bs, field->NDTtype);
+		if (new_node) {
+			e = gf_node_register(new_node, is_mem_com ? NULL : node);
+			if (e) goto exit;
+
+			if (node) {
+				/*special case for QP, register as the current QP*/
+				if (gf_node_get_tag(new_node) == TAG_MPEG4_QuantizationParameter) {
+					qp_local = ((M_QuantizationParameter *)new_node)->isLocal;
+					/*we have a QP in the same scope, remove previous
+					NB: we assume this is the right behavior, the spec doesn't say
+					whether QP is cumulative or not*/
+					if (qp_on) gf_bifs_dec_qp_remove(codec, GF_FALSE);
+
+					e = gf_bifs_dec_qp_set(codec, new_node);
+					if (e) goto exit;
+					qp_on = 1;
+					if (qp_local) qp_local = 2;
+					if (codec->force_keep_qp) {
 						e = gf_node_list_add_child_last(field->far_ptr, new_node, &last);
-						if (e) return e;
+						if (e) goto exit;
+					} else {
+						gf_node_register(new_node, NULL);
+						gf_node_unregister(new_node, node);
 					}
+				} else {
+					e = gf_node_list_add_child_last(field->far_ptr, new_node, &last);
+					if (e) goto exit;
 				}
-				/*proto coding*/
-				else if (codec->pCurrentProto) {
-					/*TO DO: what happens if this is a QP node on the interface ?*/
-					e = gf_node_list_add_child_last( (GF_ChildNodeItem **)field->far_ptr, new_node, &last);
-					if (e) return e;
-				}
-			} else {
-				return codec->LastError ? codec->LastError : GF_NON_COMPLIANT_BITSTREAM;
 			}
+			/*proto coding*/
+			else if (codec->pCurrentProto) {
+				/*TO DO: what happens if this is a QP node on the interface ?*/
+				e = gf_node_list_add_child_last( (GF_ChildNodeItem **)field->far_ptr, new_node, &last);
+				if (e)goto exit;
+			}
+		} else {
+			e = codec->LastError ? codec->LastError : GF_NON_COMPLIANT_BITSTREAM;
+			goto exit;
 		}
-		/*according to the spec, the QP applies to the current node itself, not just children.
-		If IsLocal is TRUE remove the node*/
-		if (qp_on && qp_local) {
-			if (qp_local == 2) {
+	}
+
+exit:
+
+	/*according to the spec, the QP applies to the current node itself, not just children.
+	If IsLocal is TRUE remove the node*/
+	if (qp_on && qp_local) {
+		if (qp_local == 2) {
 //				qp_local = 1;
-			} else {
-				//ask to get rid of QP and reactivate if we had a QP when entering the node
-				gf_bifs_dec_qp_remove(codec, initial_qp);
+		} else {
+			//ask to get rid of QP and reactivate if we had a QP when entering the node
+			gf_bifs_dec_qp_remove(codec, initial_qp);
 //				qp_local = 0;
-			}
 		}
 	}
+
 	/*finally delete the QP if any (local or not) as we get out of this node*/
 	if (qp_on) gf_bifs_dec_qp_remove(codec, GF_TRUE);
-	return GF_OK;
+	return e;
 }

gpac-2.0.0.tar.gz/src/bifs/memory_decoder.c -> gpac-2.2.0.tar.gz/src/bifs/memory_decoder.c Changed

@@ -75,14 +75,15 @@
 
 		if (field.fieldType==GF_SG_VRML_SFNODE) {
 			inf->new_node = gf_bifs_dec_node(codec, bs, field.NDTtype);
-			if (codec->LastError) goto err;
+			e = codec->LastError;
 			inf->field_ptr = &inf->new_node;
-			gf_node_register(inf->new_node, NULL);
+			if (inf->new_node)
+				gf_node_register(inf->new_node, NULL);
 		} else {
 			field.far_ptr = inf->field_ptr = gf_sg_vrml_field_pointer_new(inf->fieldType);
 			e = gf_bifs_dec_sf_field(codec, bs, node, &field, GF_TRUE);
-			if (e) goto err;
 		}
+		if (e) goto err;
 		count--;
 	}
 err:
@@ -178,7 +179,12 @@
 	codec->scenegraph->global_qp = NULL;
 
 	if (gf_node_get_tag(node) != TAG_MPEG4_QuantizationParameter) {
-		gf_node_unregister(node, NULL);
+		//if node was just created (num_instances == 0), unregister
+		//otherwise (USE node) don't do anything
+		if (!node->sgprivate->num_instances) {
+			node->sgprivate->num_instances = 1;
+			gf_node_unregister(node, NULL);
+		}
 		return GF_NON_COMPLIANT_BITSTREAM;
 	}
 
@@ -188,7 +194,8 @@
 	codec->scenegraph->global_qp = node;
 
 	/*register TWICE: once for the command, and for the scenegraph globalQP*/
-	node->sgprivate->num_instances = 2;
+	gf_node_register(node, NULL);
+	gf_node_register(node, NULL);
 
 	com = gf_sg_command_new(codec->current_graph, GF_SG_GLOBAL_QUANTIZER);
 	inf = gf_sg_command_field_new(com);
@@ -337,6 +344,7 @@
 	}
 	decfield.fieldIndex = inf->fieldIndex;
 	decfield.fieldType = inf->fieldType;
+	decfield.name = targetField.name;
 
 	if (inf->fieldType==GF_SG_VRML_SFNODE) {
 		decfield.far_ptr = inf->field_ptr = &inf->new_node;

gpac-2.0.0.tar.gz/src/bifs/script_dec.c -> gpac-2.2.0.tar.gz/src/bifs/script_dec.c Changed

@@ -40,6 +40,7 @@
 	GF_List *identifiers;
 	char *new_line;
 	u32 indent;
+	u32 expr_stack_size;
 } ScriptParser;
 
 
@@ -169,6 +170,7 @@
 	e = GF_OK;
 	if (gf_node_get_tag(n) != TAG_MPEG4_Script) return GF_NON_COMPLIANT_BITSTREAM;
 
+	memset(&parser, 0, sizeof(ScriptParser));
 	parser.codec = codec;
 	parser.script = n;
 	parser.bs = bs;
@@ -209,6 +211,10 @@
 		SFS_Space(&parser);
 		SFS_StatementBlock(&parser, GF_TRUE);
 		SFS_Line(&parser);
+		if (codec->LastError) {
+			e = codec->LastError;
+			goto exit;
+		}
 	}
 
 	SFS_Line(&parser);
@@ -418,6 +424,7 @@
 	if (parser->codec->LastError) return;
 	SFS_Expression(parser);
 	if (! gf_bs_read_int(parser->bs, 1)) return;
+	if (parser->codec->LastError) return;
 	SFS_AddString(parser, ",");
 	SFS_CompoundExpression(parser);
 }
@@ -430,12 +437,20 @@
 	}
 }
 
-
+#define MAX_EXPR_STACK	500
 void SFS_Expression(ScriptParser *parser)
 {
 	u32 val = gf_bs_read_int(parser->bs, NUMBITS_EXPR_TYPE);
 	if (parser->codec->LastError) return;
 
+	//limit max expression stack size
+	parser->expr_stack_size++;
+	if (parser->expr_stack_size>MAX_EXPR_STACK) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("BIFS Max stack size %d reached for expressions, not supported\n", MAX_EXPR_STACK))
+		parser->codec->LastError = GF_NON_COMPLIANT_BITSTREAM;
+		return;
+	}
+
 	switch(val) {
 	case ET_CURVED_EXPR:
 		SFS_AddString(parser, "(");
@@ -675,6 +690,7 @@
 		parser->codec->LastError = GF_NON_COMPLIANT_BITSTREAM;
 		break;
 	}
+	parser->expr_stack_size--;
 }
 
 void SFS_NewObject(ScriptParser *parser)
@@ -691,6 +707,7 @@
 {
 	if (parser->codec->LastError) return;
 	SFS_Expression(parser);
+	if (parser->codec->LastError) return;
 	SFS_AddString(parser, "");
 	SFS_CompoundExpression(parser);
 	SFS_AddString(parser, "");
@@ -709,6 +726,7 @@
 {
 	if (parser->codec->LastError) return;
 	SFS_Expression(parser);
+	if (parser->codec->LastError) return;
 	SFS_AddString(parser, ".");
 	SFS_Identifier(parser);
 }
@@ -718,6 +736,7 @@
 {
 	if (parser->codec->LastError) return;
 	SFS_Expression(parser);
+	if (parser->codec->LastError) return;
 	SFS_AddString(parser, ".");
 	SFS_Identifier(parser);
 	SFS_AddString(parser, "(");
@@ -732,6 +751,7 @@
 	val = gf_bs_read_int(parser->bs, 1);
 	while (val) {
 		SFS_Expression(parser);
+		if (parser->codec->LastError) return;
 		val = gf_bs_read_int(parser->bs, 1);
 		if(val) SFS_AddString(parser, ",");
 	}

gpac-2.0.0.tar.gz/src/compositor/audio_input.c -> gpac-2.2.0.tar.gz/src/compositor/audio_input.c Changed

@@ -43,6 +43,9 @@
 	Fixed speed;
 	Bool done;
 	GF_AudioInput *ai = (GF_AudioInput *) callback;
+
+restart:
+
 	/*even if the stream is signaled as finished we must check it, because it may have been restarted by a mediaControl*/
 	if (!ai->stream) return NULL;
 
@@ -67,6 +70,12 @@
 		else
 			ai->input_ifce.is_buffering = gf_mo_is_buffering(ai->stream);
 		*size = 0;
+		if (!ai->stream->odm->state) ai->is_playing = GF_FALSE;
+		return NULL;
+	}
+	if (ai->stream->config_changed) {
+		gf_mo_release_data(ai->stream, 0, -1);
+		*size = 0;
 		return NULL;
 	}
 	ai->need_release = GF_TRUE;
@@ -81,6 +90,11 @@
 
 	gf_mo_get_object_time(ai->stream, &obj_time);
 	obj_time += audio_delay_ms;
+
+	if (ai->compositor->audd<0) obj_time += -ai->compositor->audd;
+	else if (obj_time > (u32) ai->compositor->audd) obj_time -= ai->compositor->audd;
+	else obj_time=0;
+
 	if (ai->compositor->bench_mode) {
 		drift = 0;
 	} else {
@@ -107,31 +121,42 @@
 		}
 	}
 
+	//flush audio (compositor in non-player mode is exiting), don't check drift
+	if (ai->compositor->flush_audio) {
+		drift = 0;
+		audio_delay_ms = 0;
+	}
+
 #ifdef ENABLE_EARLY_FRAME_DETECTION
 	/*too early (silence insertions), skip*/
 	if (drift < 0) {
-		GF_LOG(GF_LOG_INFO, GF_LOG_AUDIO, ("Audio Input audio too early of %d (CTS %u at OTB %u with audio delay %d ms)\n", drift + audio_delay_ms, ts, obj_time, audio_delay_ms));
-		ai->need_release = GF_FALSE;
-		gf_mo_release_data(ai->stream, 0, -1);
-		*size = 0;
-		return NULL;
+		//if not playing, start if audio is due in less than 50ms
+		if (ai->is_playing || (drift < -50)) {
+			GF_LOG(GF_LOG_INFO, GF_LOG_AUDIO, ("Audio Input audio too early of %d (CTS %u at OTB %u with audio delay %d ms)\n", drift + audio_delay_ms, ts, obj_time, audio_delay_ms));
+			ai->need_release = GF_FALSE;
+			gf_mo_release_data(ai->stream, 0, -1);
+			*size = 0;
+			return NULL;
+		}
 	}
 #endif
 	/*adjust drift*/
 	if (audio_delay_ms) {
 		s32 resync_delay = speed > 0 ? FIX2INT(speed * MAX_RESYNC_TIME) : FIX2INT(-speed * MAX_RESYNC_TIME);
+		if (!ai->is_playing) resync_delay = 0;
 		/*CU is way too late, discard and fetch a new one - this usually happen when media speed is more than 1*/
 		if (drift>resync_delay) {
 			GF_LOG(GF_LOG_INFO, GF_LOG_AUDIO, ("Audio Input Audio data too late obj time %d - CTS %d - drift %d ms - resync forced\n", obj_time - audio_delay_ms, ts, drift));
 			gf_mo_release_data(ai->stream, *size, 2);
 			ai->need_release = GF_FALSE;
-			return gf_audio_input_fetch_frame(callback, size, planar_size, audio_delay_ms);
+			//avoid recursion
+			goto restart;
 		}
 		if (ai->stream->odm && ai->stream->odm->ck)
 			resync_delay = ai->stream->odm->ck->audio_delay - drift;
 		else
 			resync_delay = -drift;
-			
+
 		if (resync_delay < 0) resync_delay = -resync_delay;
 
 		if (resync_delay > MIN_DRIFT_ADJUST) {
@@ -139,6 +164,7 @@
 			gf_mo_adjust_clock(ai->stream, drift);
 		}
 	}
+	ai->is_playing = GF_TRUE;
 	return frame;
 }
 
@@ -191,11 +217,14 @@
 
 	gf_mo_get_audio_info(ai->stream, &aifc->samplerate, &aifc->afmt , &aifc->chan, &aifc->ch_layout, &aifc->forced_layout);
 
-	if (!for_recf)
+	if (!for_recf && !ai->stream->config_changed)
 		return aifc->samplerate ? GF_TRUE : GF_FALSE;
 
 	if (aifc->samplerate && aifc->chan && aifc->afmt && ((aifc->chan<=2) || aifc->ch_layout)) {
-		ai->stream->config_changed = GF_FALSE;
+		if (ai->stream->config_changed) {
+			ai->stream->config_changed = GF_FALSE;
+			return GF_FALSE;
+		}
 		return GF_TRUE;
 	}
 	//still not ready !

gpac-2.0.0.tar.gz/src/compositor/audio_mixer.c -> gpac-2.2.0.tar.gz/src/compositor/audio_mixer.c Changed

gpac-2.0.0.tar.gz/src/compositor/audio_render.c -> gpac-2.2.0.tar.gz/src/compositor/audio_render.c Changed

gpac-2.0.0.tar.gz/src/compositor/camera.c -> gpac-2.2.0.tar.gz/src/compositor/camera.c Changed

gpac-2.0.0.tar.gz/src/compositor/clock.c -> gpac-2.2.0.tar.gz/src/compositor/clock.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2017
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file scene part of GPAC / Scene Compositor sub-project
@@ -143,15 +143,18 @@
 	ck->init_timestamp = 0;
 	ck->start_time = 0;
 	ck->has_seen_eos = 0;
-	ck->media_time_at_init = 0;
-	ck->has_media_time_shift = 0;
+	ck->has_media_time_shift = GF_FALSE;
+	//do NOT reset media timestamp mapping once the clock is init
+	//if discontinuities are found the media time mapping will be adjusted then
 	ck->timeline_id++;
 }
 
-void gf_clock_set_time(GF_Clock *ck, u32 TS)
+void gf_clock_set_time(GF_Clock *ck, u64 ref_TS, u32 timescale)
 {
 	if (!ck->clock_init) {
-		ck->init_timestamp = TS;
+		u64 real_ts_ms = gf_timestamp_rescale(ref_TS, timescale, 1000);
+		ck->init_ts_loops = (u32) (real_ts_ms / 0xFFFFFFFFUL);
+		ck->init_timestamp = (u32) (real_ts_ms % 0xFFFFFFFFUL);
 		ck->clock_init = 1;
 		ck->audio_delay = 0;
 		/*update starttime and pausetime even in pause mode*/
@@ -226,18 +229,20 @@
 	return time - ck->audio_delay;
 }
 
-u32 gf_clock_to_media_time(GF_Clock *ck, u32 clock_val)
+u64 gf_clock_to_media_time(GF_Clock *ck, u32 clock_val)
 {
-	u32 t = clock_val;
-	if (ck && ck->has_media_time_shift) {
-		if (t>ck->init_timestamp) t -= ck->init_timestamp;
+	u64 t = ck->init_ts_loops;
+	t *= 0xFFFFFFFFUL;
+	t += clock_val;
+	if (ck->has_media_time_shift) {
+		if (t > ck->media_ts_orig) t -= ck->media_ts_orig;
 		else t=0;
-		t += ck->media_time_at_init;
+		t += ck->media_time_orig;
 	}
 	return t;
 }
 
-u32 gf_clock_media_time(GF_Clock *ck)
+u64 gf_clock_media_time(GF_Clock *ck)
 {
 	u32 t;
 	if (!ck) return 0;
@@ -296,3 +301,46 @@
 	if (ck) ck->audio_delay = ms_delay;
 }
 
+u32 gf_timestamp_to_clocktime(u64 ts, u32 timescale)
+{
+	if (ts==GF_FILTER_NO_TS) return 0;
+	//this happens for direct file loaders calling this (btplay & co)
+	if (!timescale) return 0;
+
+	ts = gf_timestamp_rescale(ts, timescale, 1000);
+	ts = ts % 0xFFFFFFFFUL;
+	return (u32) ts;
+}
+
+u64 gf_clock_time_absolute(GF_Clock *ck)
+{
+	if (!ck->clock_init) return 0;
+	u64 time = ck->init_ts_loops;
+	time *= 0xFFFFFFFFUL;
+	time += gf_clock_time(ck);
+	return time;
+}
+
+
+s32 gf_clock_diff(GF_Clock *ck, u32 ck_time, u32 ts)
+{
+	s64 ts_diff;
+
+	ts_diff = ts;
+	ts_diff -= ck_time;
+	//clock has wrapped around
+	if (ck_time & 0x80000000) {
+		//cts has not yet wrapped around
+		if (! (ts & 0x80000000)) {
+			ts_diff += 0xFFFFFFFFUL;
+		}
+	} else {
+		if (ts & 0x80000000) {
+			ts_diff -= 0xFFFFFFFFUL;
+		}
+	}
+	if (ck->speed<0)
+		ts_diff = -ts_diff;
+
+	return (s32) ts_diff;
+}

gpac-2.0.0.tar.gz/src/compositor/compositor.c -> gpac-2.2.0.tar.gz/src/compositor/compositor.c Changed

@@ -24,7 +24,6 @@
 */
 
 #include <gpac/internal/compositor_dev.h>
-#include <gpac/options.h>
 #include <gpac/utf.h>
 #include <gpac/modules/hardcoded_proto.h>
 #include <gpac/modules/compositor_ext.h>
@@ -430,7 +429,7 @@
 	if (!evt || (evt->type != GF_EVENT_VIDEO_SETUP)) return GF_OK;
 
 	if (!compositor->player && (compositor->passthrough_pfmt != GF_PIXEL_RGB)) {
-		u32 pfmt = compositor->dyn_filter_mode ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
+		u32 pfmt = compositor->forced_alpha ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
 		compositor->passthrough_pfmt = pfmt;
 		compositor->opfmt = pfmt;
 		if (compositor->vout) {
@@ -470,7 +469,7 @@
 		if (!pfmt && compositor->passthrough_txh) pfmt = compositor->passthrough_txh->pixelformat;
 
 		if (!pfmt) {
-			pfmt = compositor->dyn_filter_mode ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
+			pfmt = compositor->forced_alpha ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
 		}
 
 		memset(vi, 0, sizeof(GF_VideoSurface));
@@ -503,7 +502,7 @@
 
 	pfmt = compositor->opfmt;
 	if (!pfmt) {
-		pfmt = compositor->dyn_filter_mode ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
+		pfmt = compositor->forced_alpha ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
 	}
 
 	compositor->passthrough_pfmt = pfmt;
@@ -667,7 +666,7 @@
 		return GF_IO_ERR;
 	}
 
-	sOpt = gf_opts_get_key("Temp", "OSDisp");
+	sOpt = gf_opts_get_key("temp", "window-display");
 	if (sOpt) sscanf(sOpt, "%p", &os_disp);
 
 	compositor->video_out->evt_cbk_hdl = compositor;
@@ -738,14 +737,11 @@
 
 	compositor->init_flags = 0;
 	compositor->os_wnd = NULL;
-	sOpt = gf_opts_get_key("Temp", "OSWnd");
+	sOpt = gf_opts_get_key("temp", "window-handle");
 	if (sOpt) sscanf(sOpt, "%p", &compositor->os_wnd);
-	sOpt = gf_opts_get_key("Temp", "InitFlags");
+	sOpt = gf_opts_get_key("temp", "window-flags");
 	if (sOpt) compositor->init_flags = atoi(sOpt);
 
-	if (compositor->noaudio)
-		compositor->init_flags |= GF_TERM_NO_AUDIO;
-
 	/*force initial for 2D/3D setup*/
 	compositor->msg_type |= GF_SR_CFG_INITIAL_RESIZE;
 	/*set default size if owning output*/
@@ -756,13 +752,15 @@
 	}
 
 	if (!compositor->player)
-		compositor->init_flags = GF_TERM_INIT_HIDE;
+		compositor->init_flags = GF_VOUT_INIT_HIDE;
 
 	if (gf_opts_get_key("temp", "gpac-help")) {
-		compositor->init_flags |= GF_TERM_NO_VIDEO | GF_TERM_NO_AUDIO;
+		gf_opts_set_key("temp", "no-video", "yes");
+		compositor->noaudio = GF_TRUE;
 	}
 
-	if (compositor->init_flags & GF_TERM_NO_VIDEO) {
+	//used for GUI help and in bench mode without vout
+	if (gf_opts_get_bool("temp", "no-video")) {
 		compositor->video_out = &null_vout;
 		compositor->ogl = GF_SC_GLMODE_OFF;
 	} else if (compositor->player || (compositor->drv==GF_SC_DRV_ON) || (compositor->ogl==GF_SC_GLMODE_HYBRID) ){
@@ -1061,6 +1059,7 @@
 
 	gf_sc_lock(compositor, GF_FALSE);
 	gf_mx_del(compositor->mx);
+	if (compositor->reload_url) gf_free(compositor->reload_url);
 	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("Compositor Destroyed\n"));
 }
 
@@ -1334,7 +1333,7 @@
 #endif
 
 		/*default back color is black*/
-		if (! (compositor->init_flags & GF_TERM_WINDOWLESS)) {
+		if (! (compositor->init_flags & GF_VOUT_WINDOWLESS)) {
 			if (compositor->bc) {
 				compositor->back_color = compositor->bc;
 			} else {
@@ -1360,7 +1359,7 @@
 				vb = info.far_ptr;
 		}
 		/*default back color is white*/
-		if (is_svg && ! (compositor->init_flags & GF_TERM_WINDOWLESS)) compositor->back_color = 0xFFFFFFFF;
+		if (is_svg && ! (compositor->init_flags & GF_VOUT_WINDOWLESS)) compositor->back_color = 0xFFFFFFFF;
 
 		/*hack for SVG where size is set in % - negotiate a canvas size*/
 		if (!compositor->has_size_info && w && h && vb) {
@@ -1394,7 +1393,7 @@
 		}
 
 		/*default back color is key color*/
-		if (compositor->init_flags & GF_TERM_WINDOWLESS) {
+		if (compositor->init_flags & GF_VOUT_WINDOWLESS) {
 			if (compositor->ckey) compositor->back_color = compositor->ckey;
 		}
 
@@ -1446,6 +1445,11 @@
 		evt.type = GF_EVENT_SCENE_SIZE;
 		evt.size.width = width;
 		evt.size.height = height;
+		evt.size.orientation = 0;
+		if (compositor->scene && gf_sg_get_root_node(compositor->scene))
+			evt.size.window_id = 1;
+		else
+			evt.size.window_id = 0;
 		gf_sc_send_event(compositor, &evt);
 	}
 	return GF_OK;
@@ -1503,6 +1507,11 @@
 		evt.type = GF_EVENT_SCENE_SIZE;
 		evt.size.width = NewWidth;
 		evt.size.height = NewHeight;
+		evt.size.orientation = 0;
+		if (compositor->scene && gf_sg_get_root_node(compositor->scene))
+			evt.size.window_id = 1;
+		else
+			evt.size.window_id = 0;
 		gf_sc_send_event(compositor, &evt);
 	}
 
@@ -1636,8 +1645,10 @@
 	gf_sc_lock(compositor, 0);
 }
 
+static void gf_sc_set_play_state_internal(GF_Compositor *compositor, u32 PlayState, Bool reset_audio, Bool pause_clocks);
+
 GF_EXPORT
-GF_Err gf_sc_set_option(GF_Compositor *compositor, u32 type, u32 value)
+GF_Err gf_sc_set_option(GF_Compositor *compositor, GF_CompositorOption type, u32 value)
 {
 	GF_Err e;
 	gf_sc_lock(compositor, 1);
@@ -1850,6 +1861,14 @@
 		compositor->multiview_mode = value;
 		break;
 
+	case GF_OPT_HTTP_MAX_RATE:
+	{
+		GF_DownloadManager *dm = gf_filter_get_download_manager(compositor->filter);
+		if (!dm) return GF_SERVICE_ERROR;
+		gf_dm_set_data_rate(dm, value);
+		e = GF_OK;
+		break;
+	}
 
 	default:
 		e = GF_BAD_PARAM;
@@ -1904,7 +1923,7 @@
 }
 
 GF_EXPORT
-u32 gf_sc_get_option(GF_Compositor *compositor, u32 type)
+u32 gf_sc_get_option(GF_Compositor *compositor, GF_CompositorOption type)
 {
 	switch (type) {
 	case GF_OPT_PLAY_STATE:
@@ -2035,6 +2054,7 @@
 	return e;
 }
 
+GF_EXPORT
 GF_Err gf_sc_get_offscreen_buffer(GF_Compositor *compositor, GF_VideoSurface *framebuffer, u32 view_idx, GF_CompositorGrabMode depth_dump_mode)
 {
 	if (!compositor || !framebuffer) return GF_BAD_PARAM;
@@ -2096,8 +2116,13 @@
 		fidx = compositor->current_frame;
 		run_time = compositor->frame_timefidx;
 		fidx = (fidx+1)% GF_SR_FPS_COMPUTE_SIZE;
-		assert(run_time >= compositor->frame_timefidx);
-		run_time -= compositor->frame_timefidx;
+		s64 diff = run_time;
+		diff -= compositor->frame_timefidx;
+		if (diff<0) {
+			diff += 0xFFFFFFFFUL;
+			assert(diff >= 0);
+		}
+		run_time = (u32) diff;
 		frames = GF_SR_FPS_COMPUTE_SIZE-1;
 	}
 
@@ -2452,6 +2477,23 @@
 	}
 }
 
+GF_EXPORT
+void gf_sc_invalidate_next_frame(GF_Compositor *compositor)
+{
+	if (compositor) {
+		//force frame draw type
+		compositor->frame_draw_type = GF_SC_DRAW_FRAME;
+		//reset frame produced flag and run until it is set (backbuffer ready to be swapped)
+		compositor->frame_was_produced = GF_FALSE;
+	}
+}
+
+GF_EXPORT
+Bool gf_sc_frame_was_produced(GF_Compositor *compositor)
+{
+	return compositor ? compositor->frame_was_produced : GF_TRUE;
+}
+
 
 void gf_sc_render_frame(GF_Compositor *compositor)
 {
@@ -2894,6 +2936,9 @@
 				emit_frame = GF_FALSE;
 			else if (compositor->fonts_pending>0)
 				emit_frame = GF_FALSE;
+			else if (compositor->clipframe && (!compositor->visual->frame_bounds.width || !compositor->visual->frame_bounds.height)) {
+				emit_frame = GF_FALSE;
+			}
 			else
 				emit_frame = GF_TRUE;
 
@@ -2909,7 +2954,7 @@
 		flush_time = gf_sys_clock();
 #endif
 
-		if (compositor->init_flags & GF_TERM_INIT_HIDE)
+		if (compositor->init_flags & GF_VOUT_INIT_HIDE)
 			compositor->skip_flush = 1;
 
 		//new frame generated, emit packet
@@ -2922,20 +2967,88 @@
 				compositor->passthrough_pck = NULL;
 				pck_frame_ts = gf_filter_pck_get_cts(pck);
 			} else {
+				u32 offset_x=0, offset_y=0;
+
 				//assign udta of frame interface event when using shared packet, as it is used to test when frame is released
 				compositor->frame_ifce.user_data = compositor;
-				if (compositor->video_out==&raw_vout) {
-					pck = gf_filter_pck_new_shared(compositor->vout, compositor->framebuffer, compositor->framebuffer_size, gf_sc_frame_ifce_done);
-				} else {
-					compositor->frame_ifce.get_plane = gf_sc_frame_ifce_get_plane;
-					compositor->frame_ifce.get_gl_texture = NULL;
-#ifndef GPAC_DISABLE_3D
-					if (compositor->fbo_tx_id) {
-						compositor->frame_ifce.get_gl_texture = gf_sc_frame_ifce_get_gl_texture;
+
+				u32 nb_bpp=0;
+				u32 pf = compositor->passthrough_pfmt;
+				if (compositor->video_out!=&raw_vout)
+					pf = compositor->opfmt;
+				if (!pf && compositor->forced_alpha)
+					pf = GF_PIXEL_RGBA;
+
+				u32 c_w=compositor->display_width, c_h=compositor->display_height;
+				if (compositor->clipframe) {
+					offset_x = compositor->visual->frame_bounds.x + compositor->display_width/2;
+					offset_y = compositor->display_height/2 - compositor->visual->frame_bounds.y;
+					switch (pf) {
+					case GF_PIXEL_ARGB:
+					case GF_PIXEL_RGBA:
+						nb_bpp = 4;
+						break;
+					case GF_PIXEL_RGB:
+					case GF_PIXEL_BGR:
+						nb_bpp = 3;
+						break;
+					}
+					if (nb_bpp) {
+						c_w = compositor->visual->frame_bounds.width;
+						c_h = compositor->visual->frame_bounds.height;
+
+						gf_filter_pid_set_property(compositor->vout, GF_PROP_PID_WIDTH, &PROP_UINT(c_w));
+						gf_filter_pid_set_property(compositor->vout, GF_PROP_PID_HEIGHT, &PROP_UINT(c_h));
+						gf_filter_pid_set_property(compositor->vout, GF_PROP_PID_STRIDE, NULL);
+						gf_filter_pid_set_property(compositor->vout, GF_PROP_PID_STRIDE_UV, NULL);
+
+
+						gf_filter_pid_set_property(compositor->vout, GF_PROP_PID_CROP_POS, &PROP_VEC2I_INT(offset_x, offset_y));
+						gf_filter_pid_set_property(compositor->vout, GF_PROP_PID_ORIG_SIZE, &PROP_VEC2I_INT(compositor->display_width, compositor->display_height));
 					}
+				}
+				if ((c_w==compositor->display_width) && (c_h==compositor->display_height)) {
+					if (compositor->video_out==&raw_vout) {
+						pck = gf_filter_pck_new_shared(compositor->vout, compositor->framebuffer, compositor->framebuffer_size, gf_sc_frame_ifce_done);
+					} else {
+						compositor->frame_ifce.get_plane = gf_sc_frame_ifce_get_plane;
+						compositor->frame_ifce.get_gl_texture = NULL;
+#ifndef GPAC_DISABLE_3D
+						if (compositor->fbo_tx_id) {
+							compositor->frame_ifce.get_gl_texture = gf_sc_frame_ifce_get_gl_texture;
+						}
 #endif
-					compositor->frame_ifce.flags = GF_FRAME_IFCE_BLOCKING;
-					pck = gf_filter_pck_new_frame_interface(compositor->vout, &compositor->frame_ifce, gf_sc_frame_ifce_done);
+						compositor->frame_ifce.flags = GF_FRAME_IFCE_BLOCKING;
+						pck = gf_filter_pck_new_frame_interface(compositor->vout, &compositor->frame_ifce, gf_sc_frame_ifce_done);
+					}
+				} else {
+					u32 j, osize = c_w * c_h * nb_bpp;
+					Bool release_fb=GF_FALSE;
+					u8 *output;
+					u8 *src=NULL;
+					pck = NULL;
+					if (compositor->video_out==&raw_vout) {
+						src = compositor->framebuffer;
+					} else {
+						if (gf_sc_get_screen_buffer(compositor, &compositor->fb, 0) == GF_OK) {
+							src = compositor->fb.video_buffer;
+							release_fb = GF_TRUE;
+						}
+					}
+					if (src) {
+						src += offset_x * nb_bpp + offset_y * nb_bpp * compositor->display_width;
+						pck = gf_filter_pck_new_alloc(compositor->vout, osize, &output);
+						if (output) {
+							for (j=0; j<c_h; j++) {
+								memcpy(output, src, nb_bpp*c_w);
+								output += nb_bpp*c_w;
+								src += nb_bpp * compositor->display_width;
+							}
+						}
+						compositor->frame_ifce.user_data = NULL;
+						if (release_fb)
+							gf_sc_release_screen_buffer(compositor, &compositor->fb);
+					}
 				}
 
 				if (!pck) {
@@ -2956,13 +3069,24 @@
 						frame_ts = compositor->frame_number * compositor->fps.den;
 					}
 					gf_filter_pck_set_cts(pck, frame_ts);
+
+					if (compositor->hint_extra_scene_cts_plus_one) {
+						gf_filter_pck_set_cts(pck, compositor->hint_extra_scene_cts_plus_one-1);
+						compositor->hint_extra_scene_cts_plus_one = 0;
+					}
+					if (compositor->hint_extra_scene_dur_plus_one) {
+						gf_filter_pck_set_duration(pck, compositor->hint_extra_scene_dur_plus_one-1);
+						compositor->hint_extra_scene_dur_plus_one = 0;
+					}
 				}
 			}
 			if (pck_frame_ts) {
 				u64 ts = gf_timestamp_rescale(pck_frame_ts, compositor->passthrough_timescale, 1000);
 				frame_ts = (u32) ts;
 			}
+
 			gf_filter_pck_send(pck);
+
 			gf_sc_ar_update_video_clock(compositor->audio_renderer, frame_ts);
 
 			if (!compositor->player) {
@@ -2992,7 +3116,6 @@
 					res *= compositor->fps.den;
 					res *= 1000;
 					res /= compositor->fps.num;
-					assert(res>=compositor->scene_sampled_clock);
 					compositor->scene_sampled_clock = (u32) res;
 				}
 				GF_LOG(GF_LOG_INFO, GF_LOG_COMPOSE, ("Compositor Send video frame TS %u (%u ms) - next frame scene clock %d ms - passthrough %p\n", frame_ts, (frame_ts*1000)/compositor->fps.num, compositor->scene_sampled_clock, compositor->passthrough_txh));
@@ -3078,8 +3201,14 @@
 				compositor->scene_sampled_clock = (u32) res;
 			}
 
-			if (compositor->check_eos_state && all_tx_done && !has_timed_nodes)
-				compositor->check_eos_state = 2;
+			if (all_tx_done && !has_timed_nodes) {
+				//we were in eos, notify we are done
+				if (compositor->check_eos_state)
+					compositor->check_eos_state = 2;
+				//we were not in eos, force flushing pending audio
+				else
+					compositor->flush_audio = GF_TRUE;
+			}
 		}
 	}
 	compositor->reset_graphics = 0;
@@ -3360,7 +3489,7 @@
 {
 	Bool ret;
 
-	if ( (compositor->interaction_level & GF_INTERACT_INPUT_SENSOR) && (event->type<=GF_EVENT_MOUSEWHEEL)) {
+	if ( (compositor->interaction_level & GF_INTERACT_INPUT_SENSOR) && (event->type <= GF_EVENT_LAST_MOUSE)) {
 		GF_Event evt = *event;
 		gf_sc_input_sensor_mouse_input(compositor, &evt.mouse);
 	}
@@ -3394,8 +3523,17 @@
 
 static Bool gf_sc_on_event_ex(GF_Compositor *compositor , GF_Event *event, Bool from_user)
 {
+	//special case for gui, we may get the callback before the script is initialized even of the scene is created
+	//so we always store it in the config file
+	if ((!compositor || (compositor->player==2)) && (event->type==GF_EVENT_NAVIGATE)) {
+		gf_opts_set_key("temp", "gui_load_urls", event->navigate.to_url);
+		if (compositor && !compositor->root_scene) return GF_FALSE;
+	}
 	/*not assigned yet*/
-	if (!compositor || !compositor->visual || compositor->discard_input_events) return GF_FALSE;
+	if (!compositor || !compositor->visual || compositor->discard_input_events) {
+		return GF_FALSE;
+	}
+
 	/*we're reconfiguring the video output, cancel all messages except GL reconfig (context lost)*/
 	if (compositor->msg_type & GF_SR_IN_RECONFIG) {
 		if (event->type==GF_EVENT_VIDEO_SETUP) {
@@ -3477,6 +3615,21 @@
 				/*remove pending resize notif but not resize requests*/
 				compositor->msg_type &= ~GF_SR_CFG_WINDOWSIZE_NOTIF;
 			}
+			if (compositor->disp_ori != event->size.orientation) {
+				u32 i;
+				compositor->disp_ori = event->size.orientation;
+				for (i=0; i<gf_list_count(compositor->textures); i++) {
+					GF_TextureHandler *txh = gf_list_get(compositor->textures, i);
+					if (!txh || !txh->stream || !txh->stream->odm || !txh->stream->width) continue;
+					gf_mo_update_caps_ex(txh->stream, GF_FALSE);
+					if (txh->stream->odm->parentscene
+						&& txh->stream->odm->parentscene->is_dynamic_scene
+						&& (txh->stream->odm->state==GF_ODM_STATE_PLAY)
+					) {
+						gf_scene_force_size_to_video(txh->stream->odm->parentscene, txh->stream);
+					}
+				}
+			}
 			if (lock_ok) gf_sc_lock(compositor, GF_FALSE);
 		}
 		return GF_FALSE;
@@ -3789,7 +3942,7 @@
 	return GF_TRUE;
 }
 
-
+GF_EXPORT
 Bool gf_sc_has_text_selection(GF_Compositor *compositor)
 {
 	return (compositor->store_text_state==GF_SC_TSEL_FROZEN) ? GF_TRUE : GF_FALSE;
@@ -3939,7 +4092,7 @@
 	gf_mx_v(compositor->evq_mx);
 }
 
-static void sc_cleanup_event_queue(GF_List *evq, GF_Node *node, GF_SceneGraph *sg)
+void sc_cleanup_event_queue(GF_List *evq, GF_Node *node, GF_SceneGraph *sg)
 {
 	u32 i, count = gf_list_count(evq);
 	for (i=0; i<count; i++) {
@@ -4058,14 +4211,39 @@
 	return gf_filter_get_download_manager(compositor->filter);
 }
 
-void gf_sc_sys_frame_pending(GF_Compositor *compositor, Double ts_offset, u32 obj_time, GF_Filter *from_filter)
+void gf_sc_sys_frame_pending(GF_Compositor *compositor, u32 cts, u32 obj_time, GF_Filter *from_filter)
 {
 	if (!compositor->player) {
-		compositor->sys_frames_pending = GF_TRUE;
-		if (from_filter)
-			gf_filter_ask_rt_reschedule(from_filter, 0);
+		if (!compositor->sys_frames_pending) {
+			compositor->sys_frames_pending = GF_TRUE;
+			gf_filter_post_process_task(compositor->filter);
+		}
+		if (!from_filter) return;
+
+		//clock is not realtime but frame base, estimate how fast we generate frames
+		//if last frame time diff is less than 1s, consider the output is not consumed in real-time
+		//and reschedule asap
+		//otherwise reschedule in 1 ms
+		//This is needed to avoid high cpu usage when output is realtime (compositor->vout)
+		u32 fidx = compositor->current_frame;
+		s64 run_time = compositor->frame_timefidx;
+		if (fidx) fidx--;
+		else fidx = GF_SR_FPS_COMPUTE_SIZE-1;
+		run_time -= compositor->frame_timefidx;
+		if (run_time<0)
+			run_time += 0xFFFFFFFFUL;
+		if (run_time<1000) {
+			//request in 1 us (0 would only reschedule filter if pending packets which may not always be the case, cf vtt dec)
+			gf_filter_ask_rt_reschedule(from_filter, 1);
+		} else {
+			gf_filter_ask_rt_reschedule(from_filter, 1000);
+		}
 	} else {
-		u32 wait_ms = (u32) (ts_offset * 1000 - obj_time);
+		u32 wait_ms;
+		if (cts < obj_time) wait_ms = (u32) (0xFFFFFFFFUL + cts - obj_time);
+		else wait_ms = cts - obj_time;
+		if (wait_ms>1000)
+			wait_ms = 1000;
 
 		if (!compositor->ms_until_next_frame || ((s32) wait_ms < compositor->ms_until_next_frame)) {
 			compositor->ms_until_next_frame = (s32) wait_ms;
@@ -4073,9 +4251,41 @@
 		if (from_filter) {
 			gf_filter_ask_rt_reschedule(from_filter, wait_ms*500);
 		}
+		//in player mode, force scene ready as soon as we have a pending frame
+		//otherwise the audio renderer will not increase current time
+		compositor->audio_renderer->scene_ready = GF_TRUE;
+	}
+}
+
+
+Bool gf_sc_check_sys_frame(GF_Scene *scene, GF_ObjectManager *odm, GF_FilterPid *for_pid, GF_Filter *from_filter, u64 cts_in_ms, u32 dur_in_ms)
+{
+	Bool is_early=GF_FALSE;
+	assert(odm);
+
+	if (for_pid)
+		gf_odm_check_buffering(odm, for_pid);
+
+	u32 obj_time = gf_clock_time(odm->ck);
+	if (cts_in_ms > obj_time)
+		is_early = GF_TRUE;
+	else if ((obj_time>0x7FFFFFFF) && (cts_in_ms<0x7FFFFFFF))
+		is_early = GF_TRUE;
+
+	if (is_early) {
+		gf_sc_sys_frame_pending(scene->compositor, (u32)cts_in_ms, obj_time, from_filter);
+		return GF_FALSE;
 	}
+	if (scene->compositor->vfr) {
+		u32 ts = scene->compositor->timescale;
+		if (!ts) ts = scene->compositor->fps.num;
+		scene->compositor->hint_extra_scene_cts_plus_one = 1 + gf_timestamp_rescale(cts_in_ms, 1000, ts);
+		scene->compositor->hint_extra_scene_dur_plus_one = (u32) ( 1 + gf_timestamp_rescale(dur_in_ms, 1000, ts));
+	}
+	return GF_TRUE;
 }
 
+
 Bool gf_sc_check_gl_support(GF_Compositor *compositor)
 {
 #ifdef GPAC_DISABLE_3D
@@ -4095,3 +4305,879 @@
 
 }
 
+GF_EXPORT
+u32 gf_sc_get_time_in_ms(GF_Compositor *sc)
+{
+	if (!sc || !sc->root_scene) return 0;
+	GF_Clock *ck = sc->root_scene->root_od->ck;
+	if (!ck) return 0;
+	return (u32) gf_clock_media_time(ck);
+}
+
+GF_EXPORT
+void gf_sc_switch_quality(GF_Compositor *compositor, Bool up)
+{
+	if (compositor)
+		gf_scene_switch_quality(compositor->root_scene, up);
+}
+
+GF_EXPORT
+void gf_sc_toggle_addons(GF_Compositor *compositor, Bool show_addons)
+{
+	if (!compositor || !compositor->root_scene || !compositor->root_scene->is_dynamic_scene) return;
+#ifndef GPAC_DISABLE_VRML
+	gf_scene_toggle_addons(compositor->root_scene, show_addons);
+#endif
+}
+
+#include <gpac/avparse.h>
+
+GF_EXPORT
+GF_Err gf_sc_set_speed(GF_Compositor *compositor, Fixed speed)
+{
+	GF_Fraction fps;
+	u32 i, j;
+	GF_SceneNamespace *ns;
+	Bool restart = 0;
+	if (!compositor || !speed) return GF_BAD_PARAM;
+
+	u32 scene_time = gf_sc_get_time_in_ms(compositor);
+	if (speed<0) {
+		i=0;
+		while ( (ns = (GF_SceneNamespace*)gf_list_enum(compositor->root_scene->namespaces, &i)) ) {
+			u32 k=0;
+			GF_ObjectManager *odm;
+			if (!ns->owner || !ns->owner->subscene) continue;
+
+			while ( (odm = gf_list_enum(ns->owner->subscene->resources, &k))) {
+				const GF_PropertyValue *p = gf_filter_pid_get_property(odm->pid, GF_PROP_PID_PLAYBACK_MODE);
+				if (!p || (p->value.uint!=GF_PLAYBACK_MODE_REWIND))
+					return GF_NOT_SUPPORTED;
+			}
+		}
+	}
+
+	/*adjust all clocks on all services, if possible*/
+	i=0;
+	while ( (ns = (GF_SceneNamespace*)gf_list_enum(compositor->root_scene->namespaces, &i)) ) {
+		GF_Clock *ck;
+		ns->set_speed = speed;
+		j=0;
+		while (ns->clocks && (ck = (GF_Clock *)gf_list_enum(ns->clocks, &j)) ) {
+			//we will have to reissue a PLAY command since playback direction changed
+			if ( gf_mulfix(ck->speed,speed) < 0)
+				restart = 1;
+			gf_clock_set_speed(ck, speed);
+
+			if (ns->owner) {
+				gf_odm_set_speed(ns->owner, speed, GF_FALSE);
+				if (ns->owner->subscene) {
+					u32 k=0;
+					GF_ObjectManager *odm;
+					GF_Scene *scene = ns->owner->subscene;
+					while ( (odm = gf_list_enum(scene->resources, &k))) {
+						gf_odm_set_speed(odm, speed, GF_FALSE);
+					}
+				}
+			}
+		}
+	}
+
+	if (restart) {
+		if (compositor->root_scene->is_dynamic_scene) {
+			gf_scene_restart_dynamic(compositor->root_scene, scene_time, 0, 0);
+		}
+	}
+
+	if (speed<0)
+		speed = -speed;
+
+	fps = compositor->fps;
+	if (fps.den<1000) {
+		fps.num = fps.num * (u32) (1000 * FIX2FLT(speed));
+		fps.den *= 1000;
+	} else {
+		fps.num = (u32) (fps.num * FIX2FLT(speed));
+	}
+	gf_media_get_reduced_frame_rate(&fps.num, &fps.den);
+	gf_sc_set_fps(compositor, fps);
+	return GF_OK;
+}
+
+GF_EXPORT
+Bool gf_sc_is_supported_url(GF_Compositor *compositor, const char *fileName, Bool use_parent_url)
+{
+	char *parent_url = NULL;
+	if (!compositor || !compositor->root_scene || !compositor->root_scene->root_od || !compositor->root_scene->root_od->scene_ns)
+		return GF_FALSE;
+
+	if (use_parent_url)
+		parent_url = compositor->root_scene->root_od->scene_ns->url;
+	return gf_filter_is_supported_source(compositor->filter, fileName, parent_url);
+}
+
+#include <gpac/network.h>
+/*get rendering option*/
+static u32 gf_sc_get_option_internal(GF_Compositor *compositor, u32 type)
+{
+	if (!compositor) return 0;
+	switch (type) {
+	case GF_OPT_HAS_JAVASCRIPT:
+		return gf_sg_has_scripting();
+	case GF_OPT_IS_FINISHED:
+		return gf_sc_check_end_of_scene(compositor, 0);
+	case GF_OPT_IS_OVER:
+		return gf_sc_check_end_of_scene(compositor, 1);
+	case GF_OPT_MAIN_ADDON:
+		return compositor->root_scene ? compositor->root_scene->main_addon_selected : 0;
+
+	case GF_OPT_PLAY_STATE:
+		if (compositor->step_mode) return GF_STATE_STEP_PAUSE;
+		if (compositor->root_scene) {
+			GF_Clock *ck = compositor->root_scene->root_od->ck;
+			if (!ck) return GF_STATE_PAUSED;
+
+//			if (ck->Buffering) return GF_STATE_PLAYING;
+		}
+		if (compositor->play_state != GF_STATE_PLAYING) return GF_STATE_PAUSED;
+		return GF_STATE_PLAYING;
+	case GF_OPT_CAN_SELECT_STREAMS:
+		return (compositor->root_scene && compositor->root_scene->is_dynamic_scene) ? 1 : 0;
+	case GF_OPT_HTTP_MAX_RATE:
+	{
+		GF_DownloadManager *dm = gf_filter_get_download_manager(compositor->filter);
+		if (!dm) return 0;
+		return gf_dm_get_data_rate(dm);
+	}
+	case GF_OPT_VIDEO_BENCH:
+		return compositor->bench_mode ? GF_TRUE : GF_FALSE;
+	case GF_OPT_ORIENTATION_SENSORS_ACTIVE:
+		return compositor->orientation_sensors_active;
+	default:
+		return gf_sc_get_option(compositor, type);
+	}
+}
+
+GF_EXPORT
+void gf_sc_navigate_to(GF_Compositor *compositor, const char *toURL)
+{
+	if (!compositor) return;
+	if (!toURL && !compositor->root_scene) return;
+
+	if (compositor->reload_url) gf_free(compositor->reload_url);
+	compositor->reload_url = NULL;
+
+	if (toURL) {
+		if (compositor->root_scene && compositor->root_scene->root_od && compositor->root_scene->root_od->scene_ns)
+			compositor->reload_url = gf_url_concatenate(compositor->root_scene->root_od->scene_ns->url, toURL);
+		if (!compositor->reload_url) compositor->reload_url = gf_strdup(toURL);
+	}
+	compositor->reload_state = 1;
+}
+
+
+static GF_Err gf_sc_step_clocks_intern(GF_Compositor *compositor, u32 ms_diff, Bool force_resume_pause)
+{
+	/*only play/pause if connected*/
+	if (!compositor || !compositor->root_scene || !compositor->root_scene->root_od) return GF_BAD_PARAM;
+
+	if (ms_diff) {
+		u32 i, j;
+		GF_SceneNamespace *ns;
+		GF_Clock *ck;
+
+		if (compositor->play_state == GF_STATE_PLAYING) return GF_BAD_PARAM;
+
+		gf_sc_lock(compositor, 1);
+		i = 0;
+		while ((ns = (GF_SceneNamespace*)gf_list_enum(compositor->root_scene->namespaces, &i))) {
+			j = 0;
+			while (ns->clocks && (ck = (GF_Clock *)gf_list_enum(ns->clocks, &j))) {
+				ck->init_timestamp += ms_diff;
+				ck->media_ts_orig += ms_diff;
+				ck->media_time_orig += ms_diff;
+				//make sure we don't touch clock while doing resume/pause below
+				if (force_resume_pause)
+					ck->nb_paused++;
+			}
+		}
+		compositor->step_mode = GF_TRUE;
+		compositor->use_step_mode = GF_TRUE;
+		gf_sc_next_frame_state(compositor, GF_SC_DRAW_FRAME);
+
+		//resume/pause to trigger codecs state change
+		if (force_resume_pause) {
+			mediacontrol_resume(compositor->root_scene->root_od, 0);
+			mediacontrol_pause(compositor->root_scene->root_od);
+
+			//release our safety
+			i = 0;
+			while ((ns = (GF_SceneNamespace*)gf_list_enum(compositor->root_scene->namespaces, &i))) {
+				j = 0;
+				while (ns->clocks && (ck = (GF_Clock *)gf_list_enum(ns->clocks, &j))) {
+					ck->nb_paused--;
+				}
+			}
+		}
+
+		gf_sc_lock(compositor, 0);
+
+	}
+	return GF_OK;
+}
+
+
+static void gf_sc_set_play_state_internal(GF_Compositor *compositor, u32 PlayState, Bool reset_audio, Bool pause_clocks)
+{
+	Bool resume_live = 0;
+	u32 prev_state;
+
+	/*only play/pause if connected*/
+	if (!compositor || !compositor->root_scene) return;
+
+	prev_state = compositor->play_state;
+	compositor->use_step_mode = GF_FALSE;
+
+	if (PlayState==GF_STATE_PLAY_LIVE) {
+		PlayState = GF_STATE_PLAYING;
+		resume_live = 1;
+		if (compositor->play_state == GF_STATE_PLAYING) {
+			compositor->play_state = GF_STATE_PAUSED;
+			mediacontrol_pause(compositor->root_scene->root_od);
+		}
+	}
+
+	/*and if not already paused/playing*/
+	if ((compositor->play_state == GF_STATE_PLAYING) && (PlayState == GF_STATE_PLAYING)) return;
+	if ((compositor->play_state != GF_STATE_PLAYING) && (PlayState == GF_STATE_PAUSED)) return;
+
+	/*pause compositor*/
+	if ((PlayState==GF_STATE_PLAYING) && reset_audio)
+		gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, 0xFF);
+	else
+		gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, PlayState);
+
+	/* step mode specific */
+	if (PlayState==GF_STATE_STEP_PAUSE) {
+		if (prev_state==GF_STATE_PLAYING) {
+			mediacontrol_pause(compositor->root_scene->root_od);
+			compositor->play_state = GF_STATE_PAUSED;
+		} else {
+			u32 diff=1;
+			if (compositor->ms_until_next_frame>0) diff = compositor->ms_until_next_frame;
+			gf_sc_step_clocks_intern(compositor, diff, GF_TRUE);
+		}
+		return;
+	}
+
+	/* nothing to change*/
+	if (compositor->play_state == PlayState) return;
+	compositor->play_state = PlayState;
+
+	if (compositor->root_scene->first_frame_pause_type && (PlayState == GF_STATE_PLAYING))
+		compositor->root_scene->first_frame_pause_type = 0;
+
+	if (!pause_clocks) return;
+
+	if (PlayState != GF_STATE_PLAYING) {
+		mediacontrol_pause(compositor->root_scene->root_od);
+	} else {
+		mediacontrol_resume(compositor->root_scene->root_od, resume_live);
+	}
+
+}
+
+
+
+GF_EXPORT
+u32 gf_sc_play_from_time(GF_Compositor *compositor, u64 from_time, u32 pause_at_first_frame)
+{
+	if (!compositor || !compositor->root_scene || !compositor->root_scene->root_od) return 0;
+	if (compositor->root_scene->root_od->flags & GF_ODM_NO_TIME_CTRL) return 1;
+
+	if (pause_at_first_frame==2) {
+		if (gf_sc_get_option_internal(compositor, GF_OPT_PLAY_STATE) != GF_STATE_PLAYING)
+			pause_at_first_frame = 1;
+		else
+			pause_at_first_frame = 0;
+	}
+
+	//in case we seek in non-player mode, adjust frame number to desired seek time
+	//this is not really precise (we don't take into account seek) but is enough for vout UI
+	if (!compositor->player) {
+		u64 output_ts = gf_timestamp_rescale(from_time, 1000, compositor->fps.num);
+		compositor->frame_number = (u32) (output_ts / compositor->fps.den);
+	}
+
+	/*for dynamic scene OD resources are static and all object use the same clock, so don't restart the root
+	OD, just act as a mediaControl on all playing streams*/
+	if (compositor->root_scene->is_dynamic_scene) {
+
+		/*exit pause mode*/
+		gf_sc_set_play_state_internal(compositor, GF_STATE_PLAYING, 1, 1);
+
+		if (pause_at_first_frame)
+			gf_sc_set_play_state_internal(compositor, GF_STATE_STEP_PAUSE, 0, 0);
+
+		gf_sc_lock(compositor, 1);
+		gf_scene_restart_dynamic(compositor->root_scene, from_time, 0, 0);
+		gf_sc_lock(compositor, 0);
+		return 2;
+	}
+
+	/*pause everything*/
+	gf_sc_set_play_state_internal(compositor, GF_STATE_PAUSED, 0, 1);
+	/*stop root*/
+	gf_odm_stop(compositor->root_scene->root_od, 1);
+	gf_scene_disconnect(compositor->root_scene, 0);
+
+	compositor->root_scene->root_od->media_start_time = from_time;
+
+	gf_odm_start(compositor->root_scene->root_od);
+	gf_sc_set_play_state_internal(compositor, GF_STATE_PLAYING, 0, 1);
+	if (pause_at_first_frame)
+		gf_sc_set_option(compositor, GF_OPT_PLAY_STATE, GF_STATE_STEP_PAUSE);
+	return 2;
+}
+
+GF_EXPORT
+void gf_sc_connect_from_time(GF_Compositor *compositor, const char *URL, u64 startTime, u32 pause_at_first_frame, Bool secondary_scene, const char *parent_path)
+{
+	GF_Scene *scene;
+	GF_ObjectManager *odm;
+	Bool is_self = GF_FALSE;
+	if (!URL || !strlen(URL))
+		is_self = GF_TRUE;
+
+	if (compositor->root_scene) {
+		if (is_self && !compositor->root_scene->root_od->ck) {
+			odm = compositor->root_scene->root_od;
+			odm->media_start_time = startTime;
+			/*render first visual frame and pause*/
+			if (pause_at_first_frame) {
+				gf_sc_set_play_state_internal(compositor, GF_STATE_STEP_PAUSE, 0, 0);
+				compositor->root_scene->first_frame_pause_type = pause_at_first_frame;
+			}
+			return;
+		}
+
+		if (compositor->root_scene->root_od && compositor->root_scene->root_od->scene_ns) {
+			const char *main_url = compositor->root_scene->root_od->scene_ns->url;
+			if (is_self || (main_url && !strcmp(main_url, URL))) {
+				gf_sc_play_from_time(compositor, startTime, pause_at_first_frame);
+				return;
+			}
+		}
+		if (is_self) return;
+		
+		/*disconnect*/
+		gf_sc_disconnect(compositor);
+	}
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Compositor Connecting to %s\n", URL));
+
+	assert(!compositor->root_scene);
+
+	/*create a new scene*/
+	scene = gf_scene_new(compositor, NULL);
+	odm = gf_odm_new();
+	scene->root_od = odm;
+	odm->subscene = scene;
+	//by default all scenes are dynamic, until we get a BIFS attached
+	scene->is_dynamic_scene = GF_TRUE;
+
+	odm->media_start_time = startTime;
+
+	// we are not in compositor:process at this point of time since the compositor thread drives the compositor
+	compositor->root_scene = scene;
+
+	/*render first visual frame and pause*/
+	if (pause_at_first_frame) {
+		gf_sc_set_play_state_internal(compositor, GF_STATE_STEP_PAUSE, 0, 0);
+		scene->first_frame_pause_type = pause_at_first_frame;
+	}
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Compositor root scene created\n", URL));
+
+	if (!strnicmp(URL, "views://", 8)) {
+		gf_scene_generate_views(compositor->root_scene, (char *) URL+8, (char*)parent_path);
+		return;
+	}
+	else if (!strnicmp(URL, "mosaic://", 9)) {
+		gf_scene_generate_mosaic(compositor->root_scene, (char *) URL+9, (char*)parent_path);
+		return;
+	}
+
+	gf_scene_ns_connect_object(scene, odm, (char *) URL, (char*)parent_path, NULL);
+}
+
+GF_EXPORT
+void gf_sc_disconnect(GF_Compositor *compositor)
+{
+	/*resume*/
+	if (compositor->play_state != GF_STATE_PLAYING) gf_sc_set_play_state_internal(compositor, GF_STATE_PLAYING, 1, 1);
+
+	if (compositor->root_scene && compositor->root_scene->root_od) {
+		GF_ObjectManager *root = compositor->root_scene->root_od;
+		gf_sc_lock(compositor, GF_TRUE);
+		compositor->root_scene = NULL;
+		gf_odm_disconnect(root, 2);
+		gf_sc_lock(compositor, GF_FALSE);
+	}
+}
+
+
+#include <gpac/scene_manager.h>
+
+static Bool check_in_scene(GF_Scene *scene, GF_ObjectManager *odm)
+{
+	u32 i;
+	GF_ObjectManager *ptr, *root;
+	if (!scene) return 0;
+	root = scene->root_od;
+	if (odm == root) return 1;
+	scene = root->subscene;
+
+	i=0;
+	while ((ptr = (GF_ObjectManager *)gf_list_enum(scene->resources, &i))) {
+		if (ptr == odm) return 1;
+		if (check_in_scene(ptr->subscene, odm)) return 1;
+	}
+	return 0;
+}
+
+GF_EXPORT
+GF_Err gf_sc_dump_scene_ex(GF_Compositor *compositor, char *rad_name, char **filename, Bool xml_dump, Bool skip_protos, GF_ObjectManager *scene_od)
+{
+#ifndef GPAC_DISABLE_SCENE_DUMP
+	GF_SceneGraph *sg;
+	GF_ObjectManager *odm;
+	GF_SceneDumper *dumper;
+	GF_List *extra_graphs;
+	u32 mode;
+	u32 i;
+	char *ext;
+	GF_Err e;
+
+	if (!compositor || !compositor->root_scene) return GF_BAD_PARAM;
+	if (!scene_od) {
+		if (!compositor->root_scene) return GF_BAD_PARAM;
+		odm = compositor->root_scene->root_od;
+	} else {
+		odm = scene_od;
+		if (! check_in_scene(compositor->root_scene, scene_od))
+			odm = compositor->root_scene->root_od;
+	}
+
+	if (odm->subscene) {
+		if (!odm->subscene->graph) return GF_IO_ERR;
+		sg = odm->subscene->graph;
+		extra_graphs = odm->subscene->extra_scenes;
+	} else {
+		if (!odm->parentscene->graph) return GF_IO_ERR;
+		sg = odm->parentscene->graph;
+		extra_graphs = odm->parentscene->extra_scenes;
+	}
+
+	mode = xml_dump ? GF_SM_DUMP_AUTO_XML : GF_SM_DUMP_AUTO_TXT;
+	/*figure out best dump format based on extension*/
+	ext = odm->scene_ns ? gf_file_ext_start(odm->scene_ns->url) : NULL;
+	if (ext) {
+		char szExt20;
+		strcpy(szExt, ext);
+		strlwr(szExt);
+		if (!strcmp(szExt, ".wrl")) mode = xml_dump ? GF_SM_DUMP_X3D_XML : GF_SM_DUMP_VRML;
+		else if(!strncmp(szExt, ".x3d", 4) || !strncmp(szExt, ".x3dv", 5) ) mode = xml_dump ? GF_SM_DUMP_X3D_XML : GF_SM_DUMP_X3D_VRML;
+		else if(!strncmp(szExt, ".bt", 3) || !strncmp(szExt, ".xmt", 4) || !strncmp(szExt, ".mp4", 4) ) mode = xml_dump ? GF_SM_DUMP_XMTA : GF_SM_DUMP_BT;
+	}
+
+	dumper = gf_sm_dumper_new(sg, rad_name, GF_FALSE, ' ', mode);
+
+	if (!dumper) return GF_IO_ERR;
+	e = gf_sm_dump_graph(dumper, skip_protos, 0);
+	for (i = 0; i < gf_list_count(extra_graphs); i++) {
+		GF_SceneGraph *extra = (GF_SceneGraph *)gf_list_get(extra_graphs, i);
+		gf_sm_dumper_set_extra_graph(dumper, extra);
+		e = gf_sm_dump_graph(dumper, skip_protos, 0);
+	}
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) {
+		gf_sm_dumper_set_extra_graph(dumper, NULL);
+		gf_sm_dump_get_name(dumper);
+	}
+#endif
+
+	if (filename) *filename = gf_strdup(gf_sm_dump_get_name(dumper));
+	gf_sm_dumper_del(dumper);
+	return e;
+#else
+	return GF_NOT_SUPPORTED;
+#endif
+}
+GF_EXPORT
+GF_Err gf_sc_dump_scene(GF_Compositor *compositor, char *rad_name, char **filename, Bool xml_dump, Bool skip_protos)
+{
+	return gf_sc_dump_scene_ex(compositor, rad_name, filename, xml_dump, skip_protos, NULL);
+}
+
+#include <gpac/internal/scenegraph_dev.h>
+
+GF_EXPORT
+GF_Err gf_sc_scene_update(GF_Compositor *compositor, char *type, char *com)
+{
+#ifndef GPAC_DISABLE_SMGR
+	GF_Err e;
+	GF_StreamContext *sc;
+	Bool is_xml = 0;
+	Double time = 0;
+	u32 i, tag;
+	GF_SceneLoader load;
+
+	if (!compositor || !com) return GF_BAD_PARAM;
+
+	if (type && (!stricmp(type, "application/ecmascript") || !stricmp(type, "js")) ) {
+#if defined(GPAC_HAS_QJS) && !defined(GPAC_DISABLE_SVG)
+		u32 tag;
+		GF_Node *root = gf_sg_get_root_node(compositor->root_scene->graph);
+		if (!root) return GF_BAD_PARAM;
+		tag = gf_node_get_tag(root);
+		if (tag >= GF_NODE_RANGE_FIRST_SVG) {
+			if (compositor->root_scene->graph->svg_js) {
+				GF_Err svg_exec_script(struct __tag_svg_script_ctx *svg_js, GF_SceneGraph *sg, const char *com);
+				return svg_exec_script(compositor->root_scene->graph->svg_js, compositor->root_scene->graph, (char *)com);
+			}
+			return GF_NOT_FOUND;
+		}
+		return GF_NOT_SUPPORTED;
+#else
+		return GF_NOT_SUPPORTED;
+#endif
+	}
+
+	if (!type && !strncmp(com, "gpac ", 5)) {
+		com += 5;
+		//new add-on
+		if (compositor->root_scene && !strncmp(com, "add ", 4)) {
+			GF_AssociatedContentLocation addon_info;
+			memset(&addon_info, 0, sizeof(GF_AssociatedContentLocation));
+			addon_info.external_URL = com + 4;
+			addon_info.timeline_id = -100;
+			gf_scene_register_associated_media(compositor->root_scene, &addon_info);
+			return GF_OK;
+		}
+		//new splicing add-on
+		if (compositor->root_scene && !strncmp(com, "splice ", 7)) {
+			char *sep;
+			Double start, end;
+			Bool is_pts = GF_FALSE;
+			GF_AssociatedContentLocation addon_info;
+			memset(&addon_info, 0, sizeof(GF_AssociatedContentLocation));
+			com += 7;
+			if (!strnicmp(com, "pts ", 4)) {
+				is_pts = GF_TRUE;
+				com += 4;
+			}
+			sep = strchr(com, ':');
+			start = 0;
+			end = -1;
+			if (sep) {
+				sep0=0;
+				if (sscanf(com, "%lf-%lf", &start, &end) != 2) {
+					end = -1;
+					sscanf(com, "%lf", &start);
+				}
+				sep0=':';
+				addon_info.external_URL = sep+1;
+			}
+			//splice end, locate first splice with no end set and set it
+			else if (sscanf(com, "%lf", &end)==1) {
+				u32 count = gf_list_count(compositor->root_scene->declared_addons);
+				for (i=0; i<count; i++) {
+					GF_AddonMedia *addon = gf_list_get(compositor->root_scene->declared_addons, i);
+					if (addon->is_splicing && (addon->splice_end<0) ) {
+						addon->splice_end = end;
+						break;
+					}
+				}
+				return GF_OK;
+			} else {
+				//splice now, until end of spliced media
+				addon_info.external_URL = com;
+			}
+			addon_info.is_splicing = GF_TRUE;
+			addon_info.timeline_id = -100;
+			addon_info.splice_start_time = start;
+			addon_info.splice_end_time = end;
+			addon_info.splice_time_pts = is_pts;
+			gf_scene_register_associated_media(compositor->root_scene, &addon_info);
+			return GF_OK;
+		}
+		//select object
+		if (compositor->root_scene && !strncmp(com, "select ", 7)) {
+			u32 idx = atoi(com+7);
+			gf_scene_select_object(compositor->root_scene, gf_list_get(compositor->root_scene->resources, idx));
+			return GF_OK;
+		}
+		return GF_OK;
+	}
+
+	memset(&load, 0, sizeof(GF_SceneLoader));
+	load.localPath = gf_opts_get_key("core", "cache");
+	load.flags = GF_SM_LOAD_FOR_PLAYBACK | GF_SM_LOAD_CONTEXT_READY;
+	load.type = GF_SM_LOAD_BT;
+
+	if (!compositor->root_scene) {
+
+		/*create a new scene*/
+		compositor->root_scene = gf_scene_new(compositor, NULL);
+		compositor->root_scene->root_od = gf_odm_new();
+		compositor->root_scene->root_od->parentscene = NULL;
+		compositor->root_scene->root_od->subscene = compositor->root_scene;
+
+		load.ctx = gf_sm_new(compositor->root_scene->graph);
+	} else if (compositor->root_scene->root_od) {
+		u32 nb_ch = 0;
+		load.ctx = gf_sm_new(compositor->root_scene->graph);
+
+		if (compositor->root_scene->root_od->pid) nb_ch++;
+		if (compositor->root_scene->root_od->extra_pids) nb_ch += gf_list_count(compositor->root_scene->root_od->extra_pids);
+		for (i=0; i<nb_ch; i++) {
+			u32 stream_type, es_id, oti;
+			const GF_PropertyValue *p;
+			GF_FilterPid *pid = compositor->root_scene->root_od->pid;
+			if (i) {
+				GF_ODMExtraPid *xpid = gf_list_get(compositor->root_scene->root_od->extra_pids, i-1);
+				pid = xpid->pid;
+			}
+			p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
+			if (!p) continue;
+			stream_type = p->value.uint;
+			switch (stream_type) {
+			case GF_STREAM_OD:
+			case GF_STREAM_SCENE:
+			case GF_STREAM_PRIVATE_SCENE:
+				p = gf_filter_pid_get_property(pid, GF_PROP_PID_ESID);
+				if (!p)
+					p = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
+				es_id = p ? p->value.uint : 0;
+				p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+				oti = p ? p->value.uint : 1;
+
+				sc = gf_sm_stream_new(load.ctx, es_id, stream_type, oti);
+				if (stream_type==GF_STREAM_PRIVATE_SCENE) sc->streamType = GF_STREAM_SCENE;
+				p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+				sc->timeScale = p ? p->value.uint : 1000;
+				break;
+			}
+		}
+	} else {
+		return GF_BAD_PARAM;
+	}
+	load.ctx->max_node_id = gf_sg_get_max_node_id(compositor->root_scene->graph);
+
+	i=0;
+	while ((comi == ' ') || (comi == '\r') || (comi == '\n') || (comi == '\t')) i++;
+	if (comi=='<') is_xml = 1;
+
+	load.type = is_xml ? GF_SM_LOAD_XMTA : GF_SM_LOAD_BT;
+	time = gf_scene_get_time(compositor->root_scene);
+
+
+	if (type && (!stricmp(type, "application/x-laser+xml") || !stricmp(type, "laser"))) {
+		load.type = GF_SM_LOAD_XSR;
+		time = gf_scene_get_time(compositor->root_scene);
+	}
+	else if (type && (!stricmp(type, "image/svg+xml") || !stricmp(type, "svg")) ) {
+		load.type = GF_SM_LOAD_XSR;
+		time = gf_scene_get_time(compositor->root_scene);
+	}
+	else if (type && (!stricmp(type, "model/x3d+xml") || !stricmp(type, "x3d")) ) load.type = GF_SM_LOAD_X3D;
+	else if (type && (!stricmp(type, "model/x3d+vrml") || !stricmp(type, "x3dv")) ) load.type = GF_SM_LOAD_X3DV;
+	else if (type && (!stricmp(type, "model/vrml") || !stricmp(type, "vrml")) ) load.type = GF_SM_LOAD_VRML;
+	else if (type && (!stricmp(type, "application/x-xmt") || !stricmp(type, "xmt")) ) load.type = GF_SM_LOAD_XMTA;
+	else if (type && (!stricmp(type, "application/x-bt") || !stricmp(type, "bt")) ) load.type = GF_SM_LOAD_BT;
+	else if (gf_sg_get_root_node(compositor->root_scene->graph)) {
+		tag = gf_node_get_tag(gf_sg_get_root_node(compositor->root_scene->graph));
+		if (tag >= GF_NODE_RANGE_FIRST_SVG) {
+			load.type = GF_SM_LOAD_XSR;
+			time = gf_scene_get_time(compositor->root_scene);
+		} else if (tag>=GF_NODE_RANGE_FIRST_X3D) {
+			load.type = is_xml ? GF_SM_LOAD_X3D : GF_SM_LOAD_X3DV;
+		} else {
+			load.type = is_xml ? GF_SM_LOAD_XMTA : GF_SM_LOAD_BT;
+			time = gf_scene_get_time(compositor->root_scene);
+		}
+	}
+
+	e = gf_sm_load_init(&load);
+	if (!e) e = gf_sm_load_string(&load, com, 1);
+	gf_sm_load_done(&load);
+	if (!e) {
+		u32 j, au_count, st_count;
+		st_count = gf_list_count(load.ctx->streams);
+		for (i=0; i<st_count; i++) {
+			sc = (GF_StreamContext*)gf_list_get(load.ctx->streams, i);
+			au_count = gf_list_count(sc->AUs);
+			for (j=0; j<au_count; j++) {
+				GF_AUContext *au = (GF_AUContext *)gf_list_get(sc->AUs, j);
+				e = gf_sg_command_apply_list(compositor->root_scene->graph, au->commands, time);
+				if (e) break;
+			}
+		}
+	}
+	if (!compositor->root_scene->graph_attached) {
+		if (!load.ctx->scene_width || !load.ctx->scene_height) {
+//			load.ctx->scene_width = term->compositor->width;
+//			load.ctx->scene_height = term->compositor->height;
+		}
+		gf_sg_set_scene_size_info(compositor->root_scene->graph, load.ctx->scene_width, load.ctx->scene_height, load.ctx->is_pixel_metrics);
+		gf_scene_attach_to_compositor(compositor->root_scene);
+	}
+	gf_sm_del(load.ctx);
+	return e;
+#else
+	return GF_NOT_SUPPORTED;
+#endif
+}
+
+GF_EXPORT
+void gf_sc_select_service(GF_Compositor *compositor, u32 service_id)
+{
+	if (!compositor || !compositor->root_scene) return;
+#ifndef GPAC_DISABLE_VRML
+	gf_scene_set_service_id(compositor->root_scene, service_id);
+#endif
+}
+
+
+GF_EXPORT
+const char *gf_sc_get_url(GF_Compositor *compositor)
+{
+	if (!compositor || !compositor->root_scene || !compositor->root_scene->root_od || !compositor->root_scene->root_od->scene_ns) return NULL;
+	return compositor->root_scene->root_od->scene_ns->url;
+}
+
+GF_EXPORT
+const void *gf_sc_get_main_pid(GF_Compositor *compositor)
+{
+	if (!compositor || !compositor->root_scene) return NULL;
+	GF_ObjectManager *odm = compositor->root_scene->root_od;
+	if (odm->pid) return odm->pid;
+
+	if (odm->subscene) {
+		GF_ObjectManager *anodm = gf_list_get(odm->subscene->resources, 0);
+		if (!anodm) return NULL;
+		return anodm->pid;
+	}
+	return NULL;
+}
+
+GF_EXPORT
+const char *gf_sc_get_world_info(GF_Compositor *compositor, GF_List *descriptions)
+{
+	GF_Node *info;
+	if (!compositor || !compositor->root_scene || !compositor->root_scene->world_info) return NULL;
+	info = (GF_Node*) compositor->root_scene->world_info;
+
+#ifndef GPAC_DISABLE_SVG
+	if (gf_node_get_tag(info) == TAG_SVG_title) {
+		SVG_Element *elt = (SVG_Element *)info;
+		GF_ChildNodeItem *l = elt->children;
+		while (l) {
+			if (gf_node_get_tag(l->node)==TAG_DOMText) {
+				GF_DOMText *txt = (GF_DOMText *)l->node;
+				return txt->textContent;
+			}
+			l = l->next;
+		}
+	} else
+#endif
+	{
+#ifndef GPAC_DISABLE_VRML
+		M_WorldInfo *wi = (M_WorldInfo *) info;
+		if (descriptions) {
+			u32 i;
+			for (i=0; i<wi->info.count; i++) {
+				gf_list_add(descriptions, wi->info.valsi);
+			}
+		}
+		return wi->title.buffer;
+#endif
+	}
+	return "GPAC";
+}
+
+GF_EXPORT
+GF_Err gf_sc_add_object(GF_Compositor *compositor, const char *url, Bool auto_play)
+{
+	GF_MediaObject *mo=NULL;
+	//this needs refinement
+	SFURL sfurl;
+	MFURL mfurl;
+	if (!url || !compositor->root_scene || !compositor->root_scene->is_dynamic_scene) return GF_BAD_PARAM;
+
+	sfurl.OD_ID = GF_MEDIA_EXTERNAL_ID;
+	sfurl.url = (char *) url;
+	mfurl.count = 1;
+	mfurl.vals = &sfurl;
+	/*only text tracks are supported for now...*/
+	mo = gf_scene_get_media_object(compositor->root_scene, &mfurl, GF_MEDIA_OBJECT_TEXT, 1);
+	if (mo) {
+		/*check if we must deactivate it*/
+		if (mo->odm) {
+			if (mo->num_open && !auto_play) {
+				gf_scene_select_object(compositor->root_scene, mo->odm);
+			}
+		} else {
+			gf_list_del_item(compositor->root_scene->scene_objects, mo);
+			gf_sg_vrml_mf_reset(&mo->URLs, GF_SG_VRML_MFURL);
+			gf_free(mo);
+			mo = NULL;
+		}
+	}
+	return mo ? GF_OK : GF_NOT_SUPPORTED;
+}
+
+
+GF_EXPORT
+Double gf_sc_get_simulation_frame_rate(GF_Compositor *compositor, u32 *nb_frames_drawn)
+{
+	Double fps;
+	if (!compositor) return 0.0;
+	if (nb_frames_drawn) *nb_frames_drawn = compositor->frame_number;
+	fps = compositor->fps.num;
+	fps /= compositor->fps.den;
+	return fps;
+}
+
+GF_EXPORT
+u32 gf_sc_get_elapsed_time_in_ms(GF_Compositor *compositor)
+{
+	u32 i, count;
+	if (!compositor || !compositor->root_scene) return 0;
+
+	count = gf_list_count(compositor->root_scene->namespaces);
+	for (i=0; i<count; i++) {
+		GF_SceneNamespace *sns = gf_list_get(compositor->root_scene->namespaces, i);
+		GF_Clock *ck = gf_list_get(sns->clocks, 0);
+		if (ck) return gf_clock_elapsed_time(ck);
+	}
+	return 0;
+}
+
+GF_EXPORT
+u32 gf_sc_get_current_service_id(GF_Compositor *compositor)
+{
+	SFURL *the_url;
+	GF_MediaObject *mo;
+	if (!compositor || !compositor->root_scene) return 0;
+	if (!compositor->root_scene->is_dynamic_scene) return compositor->root_scene->root_od->ServiceID;
+
+	if (compositor->root_scene->visual_url.OD_ID || compositor->root_scene->visual_url.url)
+		the_url = &compositor->root_scene->visual_url;
+	else
+		the_url = &compositor->root_scene->audio_url;
+
+	mo = gf_scene_find_object(compositor->root_scene, the_url->OD_ID, the_url->url);
+	if (mo && mo->odm) return mo->odm->ServiceID;
+	return 0;
+}

gpac-2.0.0.tar.gz/src/compositor/compositor_2d.c -> gpac-2.2.0.tar.gz/src/compositor/compositor_2d.c Changed

@@ -27,12 +27,10 @@
 
 #include "visual_manager.h"
 #include "nodes_stacks.h"
-#include <gpac/options.h>
 #include "texturing.h"
 
 #include "gl_inc.h"
 
-
 #ifndef GPAC_DISABLE_3D
 void compositor_2d_hybgl_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, u32 is_offscreen_clear)
 {
@@ -41,7 +39,7 @@
 	if (!visual->is_attached) return;
 
 	if (!BackColor && !visual->offscreen && !is_offscreen_clear) {
-		if ( !(visual->compositor->init_flags & GF_TERM_WINDOW_TRANSPARENT)) {
+		if ( !(visual->compositor->init_flags & GF_VOUT_WINDOW_TRANSPARENT)) {
 			BackColor = visual->compositor->back_color & 0x00FFFFFF;
 		}
 	}
@@ -85,6 +83,8 @@
 	if (!compositor->visual->nb_objects_on_canvas_since_last_ogl_flush)
 		goto exit;
 
+	compositor->visual->prev_hybgl_canvas_not_empty = GF_TRUE;
+
 	memset(&a_tr_state, 0, sizeof(GF_TraverseState));
 	a_tr_state.color_mat.identity = 1;
 	a_tr_state.visual = compositor->visual;
@@ -363,7 +363,7 @@
 		GF_Window src_wnd, dst_wnd;
 
 		if (!BackColor && !visual->offscreen) {
-			if ( !(visual->compositor->init_flags & GF_TERM_WINDOW_TRANSPARENT)) {
+			if ( !(visual->compositor->init_flags & GF_VOUT_WINDOW_TRANSPARENT)) {
 				BackColor = visual->compositor->back_color;
 			}
 		}
@@ -636,7 +636,6 @@
 		switch (txh->pixelformat) {
 		case GF_PIXEL_RGB:
 		case GF_PIXEL_BGR:
-		case GF_PIXEL_RGBS:
 		case GF_PIXEL_RGBD:
 //		case GF_PIXEL_RGB_555:
 //		case GF_PIXEL_RGB_565:
@@ -649,7 +648,6 @@
 			break;
 		case GF_PIXEL_ARGB:
 		case GF_PIXEL_RGBA:
-		case GF_PIXEL_RGBAS:
 		case GF_PIXEL_RGBDS:
 			if (hw_caps & GF_VIDEO_HW_HAS_RGBA)
 				use_soft_stretch = GF_FALSE;
@@ -849,7 +847,11 @@
 		e = visual->compositor->video_out->LockBackBuffer(visual->compositor->video_out, &backbuffer, GF_TRUE);
 		if (!e) {
 			u32 push_time = gf_sys_clock();
+#ifndef GPAC_DISABLE_PLAYER
 			e = gf_stretch_bits(&backbuffer, &video_src, &dst_wnd, &src_wnd, alpha, GF_FALSE, tr_state->col_key, ctx->col_mat);
+#else
+			e = GF_NOT_SUPPORTED;
+#endif
 			store_blit_times(txh, push_time);
 			visual->compositor->video_out->LockBackBuffer(visual->compositor->video_out, &backbuffer, GF_FALSE);
 			if (e) {

gpac-2.0.0.tar.gz/src/compositor/compositor_3d.c -> gpac-2.2.0.tar.gz/src/compositor/compositor_3d.c Changed

gpac-2.0.0.tar.gz/src/compositor/drawable.c -> gpac-2.2.0.tar.gz/src/compositor/drawable.c Changed

gpac-2.0.0.tar.gz/src/compositor/events.c -> gpac-2.2.0.tar.gz/src/compositor/events.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -26,7 +26,6 @@
 #include "visual_manager.h"
 #include "nodes_stacks.h"
 #include "mpeg4_grouping.h"
-#include <gpac/options.h>
 #include <gpac/utf.h>
 
 static GF_Node *browse_parent_for_focus(GF_Compositor *compositor, GF_Node *elt, Bool prev_focus);
@@ -44,7 +43,7 @@
 
 static Bool exec_text_selection(GF_Compositor *compositor, GF_Event *event)
 {
-	if (event->type>GF_EVENT_MOUSEMOVE) return GF_FALSE;
+	if (event->type > GF_EVENT_MOUSEMOVE) return GF_FALSE;
 
 	if (compositor->edited_text)
 		return GF_FALSE;
@@ -132,6 +131,7 @@
 }
 
 
+GF_EXPORT
 GF_Err gf_sc_paste_text(GF_Compositor *compositor, const char *text)
 {
 	u16 *conv_buf;
@@ -655,7 +655,7 @@
 
 	cursor_type = GF_CURSOR_NORMAL;
 	/*all mouse events*/
-	if (event->type<=GF_EVENT_MOUSEWHEEL) {
+	if (event->type <= GF_EVENT_LAST_MOUSE) {
 		Fixed X = compositor->hit_world_point.x;
 		Fixed Y = compositor->hit_world_point.y;
 		/*flip back to origin at top-left*/
@@ -785,7 +785,7 @@
 			compositor->sensor_type = cursor_type;
 		}
 	}
-	else if ((event->type>=GF_EVENT_KEYUP) && (event->type<=GF_EVENT_LONGKEYPRESS)) {
+	else if ((event->type >= GF_EVENT_KEYUP) && (event->type <= GF_EVENT_LONGKEYPRESS)) {
 		GF_Node *target;
 		memset(&evt, 0, sizeof(GF_DOM_Event));
 		evt.key_flags = event->key.flags;
@@ -856,8 +856,13 @@
 	/*reset previous composite texture*/
 	if (compositor->prev_hit_appear != compositor->hit_appear) {
 		if (compositor->prev_hit_appear) {
-			compositor_compositetexture_handle_event(compositor, compositor->prev_hit_appear, ev, GF_TRUE);
-			if (!compositor->grabbed_sensor) compositor->prev_hit_appear = NULL;
+			//reset previ appear node to avoid potential recursions
+			GF_Node *hit_appear = compositor->prev_hit_appear;
+			compositor->prev_hit_appear = NULL;
+			compositor_compositetexture_handle_event(compositor, hit_appear, ev, GF_TRUE);
+			//restore if we have a hit
+			if (compositor->grabbed_sensor)
+				compositor->prev_hit_appear = hit_appear;
 		}
 	}
 
@@ -1063,7 +1068,7 @@
 #endif
 
 	/*preprocess text selection and edition*/
-	if ((ev->type<GF_EVENT_MOUSEWHEEL) && (ev->mouse.button==GF_MOUSE_LEFT)) {
+	if ((ev->type < GF_EVENT_LAST_MOUSE_COORDS) && (ev->mouse.button==GF_MOUSE_LEFT)) {
 		if (compositor->text_selection) {
 			if (ev->type==GF_EVENT_MOUSEUP) {
 				if (compositor->store_text_state==GF_SC_TSEL_ACTIVE)
@@ -1884,7 +1889,7 @@
 Bool gf_sc_execute_event(GF_Compositor *compositor, GF_TraverseState *tr_state, GF_Event *ev, GF_ChildNodeItem *children)
 {
 	/*filter mouse events and other events (key...)*/
-	if (ev->type>GF_EVENT_MOUSEWHEEL) {
+	if (ev->type > GF_EVENT_MOUSEWHEEL) {
 		Bool ret = GF_FALSE;
 		/*send text edit*/
 		if (compositor->edited_text) {
@@ -1984,7 +1989,7 @@
 	s32 x=0, y=0;
 	Bool switch_coords = GF_FALSE;
 	Bool ret = GF_FALSE;
-	if (evt->type<=GF_EVENT_MOUSEWHEEL) {
+	if (evt->type <= GF_EVENT_LAST_MOUSE) {
 		if (compositor->sgaze) {
 			compositor->gaze_x = evt->mouse.x;
 			compositor->gaze_y = evt->mouse.y;

gpac-2.0.0.tar.gz/src/compositor/font_engine.c -> gpac-2.2.0.tar.gz/src/compositor/font_engine.c Changed

gpac-2.0.0.tar.gz/src/compositor/hardcoded_protos.c -> gpac-2.2.0.tar.gz/src/compositor/hardcoded_protos.c Changed

@@ -35,7 +35,7 @@
 
 #define CHECK_FIELD(__name, __index, __type) \
 	if (gf_node_get_field(node, __index, &field) != GF_OK) {\
-		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("HardcodedProtos Cannot get field index %d\n", __index));\
+		GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("HardcodedProtos Cannot get field index %d for proto %s\n", __index, __name));\
 		return GF_FALSE; \
 	}\
 	if (field.fieldType != __type) {\
@@ -880,23 +880,10 @@
 }
 
 
-static void TraverseUntransform(GF_Node *node, void *rs, Bool is_destroy)
+void TraverseUntransformEx(GF_Node *node, void *rs, GroupingNode2D *grp)
 {
-	UntransformStack *stack = (UntransformStack *)gf_node_get_private(node);
 	GF_TraverseState *tr_state = (GF_TraverseState *) rs;
 
-	if (is_destroy) {
-		gf_free(stack);
-		return;
-	}
-
-	if (tr_state->traversing_mode==TRAVERSE_SORT) {
-		if (gf_node_dirty_get(node)) {
-			Untransform_GetNode(node, &stack->untr); /*lets place it below*/
-			gf_node_dirty_clear(node, GF_SG_NODE_DIRTY);
-		}
-	}
-
 #ifndef GPAC_DISABLE_3D
 	if (tr_state->visual->type_3d) {
 		GF_Matrix mx_model;
@@ -920,7 +907,7 @@
 			visual_3d_set_viewport(tr_state->visual, tr_state->camera->proj_vp);
 			visual_3d_projection_matrix_modified(tr_state->visual);
 
-			gf_node_traverse_children((GF_Node *)&stack->untr, tr_state);
+			gf_node_traverse_children(node, tr_state);
 
 			gf_mx_copy(tr_state->model_matrix, mx_model);
 			memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera));
@@ -939,7 +926,7 @@
 			tr_state->ray.dir.z = -FIX_ONE;
 			tr_state->visual->compositor->hit_square_dist=0;
 
-			gf_node_traverse_children((GF_Node *)&stack->untr, tr_state);
+			gf_node_traverse_children(node, tr_state);
 
 			gf_mx_copy(tr_state->model_matrix, mx_model);
 			memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera));
@@ -950,7 +937,7 @@
 				tr_state->visual->compositor->hit_square_dist = prev_dist;
 
 		} else {
-			gf_node_traverse_children((GF_Node *)&stack->untr, tr_state);
+			gf_node_traverse_children(node, tr_state);
 
 			gf_mx_copy(tr_state->model_matrix, mx_model);
 			memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera));
@@ -963,12 +950,27 @@
 		gf_mx2d_copy(mx2d_backup, tr_state->transform);
 		gf_mx2d_init(tr_state->transform);
 
-		group_2d_traverse((GF_Node *)&stack->untr, (GroupingNode2D *)stack, tr_state);
+		group_2d_traverse(node, grp, tr_state);
 
 		gf_mx2d_copy(tr_state->transform, mx2d_backup);
+	}
+}
+static void TraverseUntransform(GF_Node *node, void *rs, Bool is_destroy)
+{
+	UntransformStack *stack = (UntransformStack *)gf_node_get_private(node);
+	GF_TraverseState *tr_state = (GF_TraverseState *) rs;
 
-
+	if (is_destroy) {
+		gf_free(stack);
+		return;
+	}
+	if (tr_state->traversing_mode==TRAVERSE_SORT) {
+		if (gf_node_dirty_get(node)) {
+			Untransform_GetNode(node, &stack->untr); /*lets place it below*/
+			gf_node_dirty_clear(node, GF_SG_NODE_DIRTY);
+		}
 	}
+	TraverseUntransformEx((GF_Node *)&stack->untr, tr_state, (GroupingNode2D *)stack);
 }
 
 void compositor_init_untransform(GF_Compositor *compositor, GF_Node *node)

gpac-2.0.0.tar.gz/src/compositor/media_object.c -> gpac-2.2.0.tar.gz/src/compositor/media_object.c Changed

@@ -212,7 +212,7 @@
 {
 	if ((mo->type != GF_MEDIA_OBJECT_VIDEO) && (mo->type!=GF_MEDIA_OBJECT_TEXT)) return GF_FALSE;
 
-	if (mo->config_changed || !mo->width || !mo->height) {
+	if (mo->config_changed || !mo->width || !mo->height || !mo->pixelformat) {
 		gf_mo_update_caps(mo);
 	}
 	if (width) *width = mo->width;
@@ -318,6 +318,34 @@
 				mo->rotate = 0;
 			}
 		}
+		//camera
+		v = gf_filter_pid_get_property(mo->odm->pid, GF_PROP_PID_RAWGRAB);
+		if (v) {
+			//front cam, flip
+			if (v->value.uint==2) {
+				u32 oflip = mo->flip;
+				if (mo->flip & 2) mo->flip &= ~2;
+				else mo->flip |= 2;
+				if (oflip != mo->flip) changed = GF_TRUE;
+			}
+
+			//front or back cam, auto-flip object based on device orientation
+			if (mo->odm->parentscene && mo->odm->parentscene->compositor->disp_ori) {
+				s32 nb_rot = mo->rotate;
+				switch (mo->odm->parentscene->compositor->disp_ori) {
+				case GF_DISPLAY_MODE_LANDSCAPE_INV: nb_rot+=2; break;
+				case GF_DISPLAY_MODE_LANDSCAPE: break;
+				case GF_DISPLAY_MODE_PORTRAIT: nb_rot+=3; break;
+				case GF_DISPLAY_MODE_PORTRAIT_INV: nb_rot+=1; break;
+				default: break;
+				}
+				nb_rot = nb_rot%4;
+				if (nb_rot != mo->rotate) {
+					changed = GF_TRUE;
+					mo->rotate = nb_rot;
+				}
+			}
+		}
 
 		v = gf_filter_pid_get_property(mo->odm->pid, GF_PROP_PID_SAR);
 		if (v) {
@@ -406,7 +434,7 @@
 	} else if (mo->odm->type==GF_STREAM_TEXT) {
 		//nothing to do
 	} else {
-		GF_LOG(GF_LOG_WARNING, GF_LOG_COMPTIME, ("Unknwon scene object type %d\n", mo->odm->type));
+		GF_LOG(GF_LOG_WARNING, GF_LOG_COMPTIME, ("unknown scene object type %d\n", mo->odm->type));
 	}
 
 	if (changed) {
@@ -425,7 +453,7 @@
 	gf_mo_update_caps_ex(mo, GF_FALSE);
 
 }
-static u64 convert_ts_to_ms(GF_MediaObject *mo, u64 ts, u32 timescale, Bool *discard)
+static u32 convert_ts_to_ms(GF_MediaObject *mo, u64 ts, u32 timescale, Bool *discard)
 {
 	if (mo->odm->timestamp_offset) {
 		if (mo->odm->timestamp_offset >= 0) {
@@ -438,7 +466,7 @@
 		}
 	}
 
-	ts = gf_timestamp_rescale(ts, timescale, 1000);
+	ts = gf_timestamp_to_clocktime(ts, timescale);
 	
 	//if addon, translate back into main content timing
 	if (mo->odm->parentscene && mo->odm->parentscene->root_od->addon) {
@@ -450,7 +478,7 @@
 			ts = (u64) res;
 		}
 	}
-	return ts;
+	return (u32) ts;
 }
 
 
@@ -519,7 +547,8 @@
 	s64 diff;
 	Bool skip_resync;
 	u32 timescale=0;
-	u64 pck_ts=0, next_ts=0;
+	u64 ts;
+	u32 pck_ts_ms = 0, next_ts_ms = 0;
 	u32 retry_pull;
 	Bool is_first = GF_FALSE;
 	Bool move_to_next_only = GF_FALSE;
@@ -531,8 +560,11 @@
 	if (ms_until_next) *ms_until_next = mo->ms_until_next;
 	if (outFrame) *outFrame = NULL;
 
-	if (!mo->odm || !mo->odm->pid)
+	if (!mo->odm || !mo->odm->pid) {
+		mo->frame = NULL;
+		mo->frame_ifce = NULL;
 		return NULL;
+	}
 
 	/*if frame locked return it*/
 	if (mo->nb_fetch) {
@@ -565,10 +597,12 @@
 	if (!mo->pck) {
 		mo->pck = gf_filter_pid_get_packet(mo->odm->pid);
 		if (!mo->pck) {
-			if (gf_filter_pid_is_eos(mo->odm->pid)) {
+			if (gf_filter_pid_is_eos(mo->odm->pid) || !mo->odm->state) {
 				if (!mo->is_eos) {
 					mo->is_eos = GF_TRUE;
+#ifndef GPAC_DISABLE_VRML
 					mediasensor_update_timing(mo->odm, GF_TRUE);
+#endif
 					gf_odm_on_eos(mo->odm, mo->odm->pid);
 					gf_odm_signal_eos_reached(mo->odm);
 				}
@@ -578,6 +612,7 @@
 			*eos = mo->is_eos;
 			return NULL;
 		} else {
+			gf_odm_check_clock_mediatime(mo->odm);
 			gf_filter_pck_ref(&mo->pck);
 			gf_filter_pid_drop_packet(mo->odm->pid);
 			check_temi(mo);
@@ -601,7 +636,7 @@
 	/*data = */gf_filter_pck_get_data(mo->pck, size);
 	timescale = gf_filter_pck_get_timescale(mo->pck);
 
-	pck_ts = convert_ts_to_ms(mo, gf_filter_pck_get_cts(mo->pck), timescale, &discard);
+	pck_ts_ms = convert_ts_to_ms(mo, gf_filter_pck_get_cts(mo->pck), timescale, &discard);
 	if (discard) {
 		gf_filter_pck_unref(mo->pck);
 		mo->pck = NULL;
@@ -620,15 +655,17 @@
 
 	while (retry_pull) {
 		retry_pull--;
-		next_ts = 0;
-		if (gf_filter_pid_get_first_packet_cts(mo->odm->pid, &next_ts) ) {
-			next_ts = 1 + convert_ts_to_ms(mo, next_ts, timescale, &discard);
+		next_ts_ms = 0;
+		if (gf_filter_pid_get_first_packet_cts(mo->odm->pid, &ts) ) {
+			next_ts_ms = 1 + convert_ts_to_ms(mo, ts, timescale, &discard);
 			break;
 		} else {
 			if (gf_filter_pid_is_eos(mo->odm->pid)) {
 				if (!mo->is_eos) {
 					*eos = mo->is_eos = GF_TRUE;
+#ifndef GPAC_DISABLE_VRML
 					mediasensor_update_timing(mo->odm, GF_TRUE);
+#endif
 					gf_odm_on_eos(mo->odm, mo->odm->pid);
 					force_decode_mode=0;
 					if (!mo->pck)
@@ -643,7 +680,7 @@
 		gf_filter_pid_try_pull(mo->odm->pid);
 	}
 	if (!retry_pull && (force_decode_mode==1)) {
-		GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d At %d could not force a pull from pid - POTENTIAL blank frame after TS %u\n", mo->odm->ID, gf_clock_time(mo->odm->ck), mo->timestamp));
+		GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d Could not force a pull from pid - POTENTIAL blank frame after TS %u\n", mo->odm->ID, mo->timestamp));
 	}
 
 	/*resync*/
@@ -661,8 +698,8 @@
 		diff_old -= mo->last_fetch_time;
 		if (diff_old < 0) diff_old = -diff_old;
 
-		diff_pck_old = (s32) pck_ts - (s32) old_timebase_time;
-		diff_pck_new = (s32) pck_ts - (s32) obj_time;
+		diff_pck_old = (s32) pck_ts_ms - (s32) old_timebase_time;
+		diff_pck_new = (s32) pck_ts_ms - (s32) obj_time;
 		if (ABS(diff_pck_old) > ABS(diff_pck_new)) {
 			//don't reset discontinuity flag for audio
 			if (resync>GF_MO_FETCH) {
@@ -689,19 +726,19 @@
 				mo->flags |= GF_MO_IN_RESYNC;
 			}
 			else if (mo->flags & GF_MO_IN_RESYNC) {
-				if (next_ts >= 1 + obj_time) {
+				if (next_ts_ms >= 1 + obj_time) {
 					skip_resync = GF_TRUE;
 					mo->flags &= ~GF_MO_IN_RESYNC;
 				}
 			}
-			else if (next_ts && (next_ts < pck_ts) ) {
+			else if (next_ts_ms && (next_ts_ms < pck_ts_ms) ) {
 				skip_resync = GF_TRUE;
 			}
 			//if the next AU is at most 300 ms from the current clock use no drop mode
-			else if (next_ts + 300 >= obj_time) {
+			else if (next_ts_ms + 300 >= obj_time) {
 				skip_resync = GF_TRUE;
-			} else if (next_ts) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d At %u frame TS %u next frame TS %d too late in no-drop mode, enabling drop - resync mode %d\n", mo->odm->ID, obj_time, pck_ts, next_ts, resync));
+			} else if (next_ts_ms) {
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d At %u frame TS %u next frame TS %d too late in no-drop mode, enabling drop - resync mode %d\n", mo->odm->ID, obj_time, pck_ts_ms, next_ts_ms, resync));
 				mo->flags |= GF_MO_IN_RESYNC;
 			}
 		}
@@ -715,22 +752,25 @@
 		//do it only if clock is started or if compositor step mode is set
 		//the time threshold for fetching is given by the caller
 		if ( (gf_clock_is_started(mo->odm->ck) || mo->odm->parentscene->compositor->use_step_mode)
-			&& (mo->timestamp==pck_ts) && next_ts && ( (next_ts <= 1 + obj_time + upload_time_ms) || (next_ts <= 1 + obj_time_orig + upload_time_ms) ) )
-		{
+			&& (mo->timestamp==pck_ts_ms)
+			&& next_ts_ms
+			&& ( (gf_clock_diff(mo->odm->ck, 1 + obj_time + upload_time_ms, next_ts_ms)<0) || (gf_clock_diff(mo->odm->ck, 1 + obj_time_orig + upload_time_ms, next_ts_ms)<0) )
+		) {
 			//drop current and go to next - we use the same loop as regular resync below
 			resync = GF_MO_FETCH_RESYNC;
 			move_to_next_only = GF_TRUE;
-			GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d Switching to CU CTS %u (next %d) now %u\n", mo->odm->ID, pck_ts, next_ts, obj_time));
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d Switching to CU CTS %u (next %d) now %u\n", mo->odm->ID, pck_ts_ms, next_ts_ms, obj_time));
 		}
 	}
 	if (resync!=GF_MO_FETCH) {
 		u32 nb_dropped = 0;
-		while (next_ts) {
+		u32 latest_ts=next_ts_ms;
+		while (next_ts_ms) {
 			if (!move_to_next_only) {
-				if (mo->odm->ck->speed > 0 ? pck_ts >= obj_time : pck_ts <= obj_time )
+				if ( gf_clock_diff(mo->odm->ck, obj_time, pck_ts_ms)>0)
 					break;
 
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d Try to drop frame TS %u next frame TS %u obj time %u\n", mo->odm->ID, pck_ts, next_ts, obj_time));
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d Try to drop frame TS %u next frame TS %u obj time %u\n", mo->odm->ID, pck_ts_ms, next_ts_ms, obj_time));
 
 				//nothing ready yet
 				if ( gf_filter_pid_first_packet_is_empty(mo->odm->pid) ) {
@@ -738,14 +778,14 @@
 				}
 
 				/*figure out closest time*/
-				if (mo->odm->ck->speed > 0 ? next_ts > obj_time : next_ts < obj_time) {
+				if (gf_clock_diff(mo->odm->ck, obj_time, next_ts_ms)>0) {
 					*eos = GF_FALSE;
 					break;
 				}
 
 				nb_dropped ++;
 				if (nb_dropped>=1) {
-					GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d At OTB %u dropped frame TS %u\n", mo->odm->ID, obj_time, pck_ts));
+					GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d At OTB %u dropped frame TS %u\n", mo->odm->ID, obj_time, pck_ts_ms));
 
 					mo->odm->nb_dropped++;
 				}
@@ -754,17 +794,18 @@
 			//delete our packet
 			gf_filter_pck_unref(mo->pck);
 			mo->pck = gf_filter_pid_get_packet(mo->odm->pid);
+			gf_odm_check_clock_mediatime(mo->odm);
 			assert(mo->pck);
 			gf_filter_pck_ref( &mo->pck);
 			check_temi(mo);
 
-			pck_ts = convert_ts_to_ms(mo, gf_filter_pck_get_cts(mo->pck), timescale, &discard);
+			pck_ts_ms = convert_ts_to_ms(mo, gf_filter_pck_get_cts(mo->pck), timescale, &discard);
 			//drop next packet from pid
 			gf_filter_pid_drop_packet(mo->odm->pid);
 
 			if (obj_time != obj_time_orig) {
-				s32 diff_pck_old = (s32) pck_ts - (s32) obj_time;
-				s32 diff_pck_new = (s32) pck_ts - (s32) obj_time_orig;
+				s32 diff_pck_old = (s32) pck_ts_ms - (s32) obj_time;
+				s32 diff_pck_new = (s32) pck_ts_ms - (s32) obj_time_orig;
 
 				if (ABS(diff_pck_old) > ABS(diff_pck_new)) {
 					GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d end of clock discontinuity, moving from old time base %d to new %d\n", mo->odm->ID, obj_time, obj_time_orig));
@@ -773,15 +814,30 @@
 				}
 			}
 
-			next_ts = 0;
-			if (gf_filter_pid_get_first_packet_cts(mo->odm->pid, &next_ts)) {
-				next_ts = convert_ts_to_ms(mo, next_ts, timescale, &discard);
+			next_ts_ms = 0;
+			if (gf_filter_pid_get_first_packet_cts(mo->odm->pid, &ts)) {
+				latest_ts = next_ts_ms = convert_ts_to_ms(mo, ts, timescale, &discard);
 			}
 			if (move_to_next_only)
 				break;
 		}
-	}
 
+		if (latest_ts) {
+			Bool too_slow = GF_FALSE;
+			if (mo->odm->ck->speed>0) {
+				if (latest_ts + 10000 < obj_time)
+					too_slow = GF_TRUE;
+			} else {
+				if (latest_ts > obj_time + 10000)
+					too_slow = GF_TRUE;
+			}
+			if (too_slow != mo->odm->too_slow) {
+				mo->odm->too_slow = too_slow;
+				if (mo->odm->parentscene)
+					gf_scene_notify_event(mo->odm->parentscene, too_slow ? GF_EVENT_CODEC_SLOW : GF_EVENT_CODEC_OK, NULL, NULL, GF_OK, GF_FALSE);
+			}
+		}
+	}
 
 	mo->frame = (char *) gf_filter_pck_get_data(mo->pck, &mo->size);
 	mo->framesize = mo->size - mo->RenderedLength;
@@ -797,16 +853,15 @@
 	}
 	mo->frame_ifce = gf_filter_pck_get_frame_interface(mo->pck);
 
-	diff = (s32) ( (mo->speed >= 0) ? ( (s64) pck_ts - (s64) obj_time) : ( (s64) obj_time - (s64) pck_ts) );
+	diff = gf_clock_diff(mo->odm->ck, obj_time, pck_ts_ms);
 	mo->ms_until_pres = FIX2INT(diff * mo->speed);
 
 	if (mo->is_eos) {
 		diff = 1000*gf_filter_pck_get_duration(mo->pck) / timescale;
 		if (!diff) diff = 100;
 	} else {
-		diff = next_ts ? next_ts : (pck_ts + 1000*gf_filter_pck_get_duration(mo->pck) / timescale);
-		diff = (s32) ( (mo->speed >= 0) ? ( (s64) diff - (s64) obj_time) : ( (s64) obj_time - (s64) diff) );
-
+		if (!next_ts_ms) next_ts_ms = pck_ts_ms + (u32) gf_timestamp_rescale(gf_filter_pck_get_duration(mo->pck), timescale, 1000);
+		diff = gf_clock_diff(mo->odm->ck, obj_time, next_ts_ms);
 		mo->odm->ck->has_seen_eos = GF_FALSE;
 	}
 	mo->ms_until_next = FIX2INT(diff * mo->speed);
@@ -817,16 +872,13 @@
 	if (mo->ms_until_next>500)
 		mo->ms_until_next=500;
 
-	if ((mo->timestamp != pck_ts) || is_first) {
+	if ((mo->timestamp != pck_ts_ms) || is_first) {
 		const GF_PropertyValue *v;
-		u32 media_time;
-		u64 dur = gf_filter_pck_get_duration(mo->pck);
-		dur *= 1000;
-		dur /= timescale;
-		mo->frame_dur = (u32) dur;
+		u64 media_time;
+		mo->frame_dur = (u32) gf_timestamp_rescale(gf_filter_pck_get_duration(mo->pck), timescale, 1000);
 		mo->last_fetch_time = obj_time;
 
-		mo->timestamp = (u32) pck_ts;
+		mo->timestamp = (u32) pck_ts_ms;
 		media_time = gf_clock_to_media_time(mo->odm->ck, mo->timestamp);
 
 		if (mo->odm->media_current_time <= media_time)
@@ -846,7 +898,7 @@
 			mediasensor_update_timing(mo->odm, GF_FALSE);
 #endif
 
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d (%s) At OTB %u fetch frame TS %u size %d (previous TS %u) - %d unit in CB - UTC "LLU" ms - %d ms until CTS is due - %d ms until next frame\n", mo->odm->ID, mo->odm->scene_ns->url, gf_clock_time(mo->odm->ck), pck_ts, mo->framesize, mo->timestamp, gf_filter_pid_get_packet_count(mo->odm->pid), gf_net_get_utc(), mo->ms_until_pres, mo->ms_until_next ));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("ODM%d (%s) At OTB %u fetch frame TS %u size %d (previous TS %u) - %d unit in CB - UTC "LLU" ms - %d ms until CTS is due - %d ms until next frame\n", mo->odm->ID, mo->odm->scene_ns->url, gf_clock_time(mo->odm->ck), pck_ts_ms, mo->framesize, mo->timestamp, gf_filter_pid_get_packet_count(mo->odm->pid), gf_net_get_utc(), mo->ms_until_pres, mo->ms_until_next ));
 
 		v = gf_filter_pck_get_property(mo->pck, GF_PROP_PCK_SENDER_NTP);
 		if (v) {
@@ -865,7 +917,7 @@
 				mo->odm->last_drawn_frame_ntp_diff -= v->value.sint;
 			}
 			gf_filter_release_property(pe);
-			GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d (%s) Frame TS %u NTP diff with sender %d ms\n", mo->odm->ID, mo->odm->scene_ns->url, pck_ts, mo->odm->last_drawn_frame_ntp_diff));
+			GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d (%s) Frame TS %u NTP diff with sender %d ms\n", mo->odm->ID, mo->odm->scene_ns->url, pck_ts_ms, mo->odm->last_drawn_frame_ntp_diff));
 
 			if (mo->odm->parentscene->compositor->ntpsync
 				&& (mo->odm->last_drawn_frame_ntp_diff > (s32) mo->odm->parentscene->compositor->ntpsync)
@@ -1295,6 +1347,8 @@
 
 	if (mo->odm->scene_ns && mo->odm->scene_ns->owner && (mo->odm->scene_ns->owner->flags & GF_ODM_INHERIT_TIMELINE))
 		return;
+	if (mo->odm->parentscene && mo->odm->parentscene->is_dynamic_scene)
+		return;
 
 	gf_odm_set_speed(mo->odm, speed, GF_TRUE);
 }

gpac-2.0.0.tar.gz/src/compositor/mpeg4_animstream.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_animstream.c Changed

gpac-2.0.0.tar.gz/src/compositor/mpeg4_audio.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_audio.c Changed

gpac-2.0.0.tar.gz/src/compositor/mpeg4_bitmap.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_bitmap.c Changed

gpac-2.0.0.tar.gz/src/compositor/mpeg4_composite.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_composite.c Changed

gpac-2.0.0.tar.gz/src/compositor/mpeg4_geometry_3d.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_geometry_3d.c Changed

gpac-2.0.0.tar.gz/src/compositor/mpeg4_grouping_2d.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_grouping_2d.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / Scene Compositor sub-project
@@ -132,6 +132,7 @@
 	GF_Matrix2D mat;
 	u8 is_identity;
 	u8 is_null;
+	u8 is_untransform;
 } Transform2DStack;
 
 static void traverse_transform(GF_Node *node, Transform2DStack *stack, GF_TraverseState *tr_state)
@@ -167,6 +168,7 @@
 	}
 }
 
+void TraverseUntransformEx(GF_Node *node, void *rs, GroupingNode2D *grp);
 
 static void TraverseTransform2D(GF_Node *node, void *rs, Bool is_destroy)
 {
@@ -201,7 +203,19 @@
 		gf_node_dirty_clear(node, GF_SG_NODE_DIRTY);
 		ptr->is_null = (!tr->scale.x || !tr->scale.y) ? 1 : 0;
 	}
-	traverse_transform(node, ptr, tr_state);
+
+	if (ptr->is_untransform) {
+		TraverseUntransformEx(node, tr_state, (GroupingNode2D *)ptr);
+	} else {
+		traverse_transform(node, ptr, tr_state);
+	}
+}
+void transform2d_set_untransform(GF_Node *node)
+{
+	Transform2DStack *stack;
+	if (gf_node_get_tag(node)!=TAG_MPEG4_Transform2D) return;
+	stack = (Transform2DStack *)gf_node_get_private(node);
+	stack->is_untransform = 1;
 }
 
 void compositor_init_transform2d(GF_Compositor *compositor, GF_Node *node)

gpac-2.0.0.tar.gz/src/compositor/mpeg4_inline.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_inline.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2017
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -111,13 +111,18 @@
 				gf_node_dirty_parents(node);
 				gf_mo_event_target_remove_by_node(mo, node);
 
-				/*reset the scene pointer as it may get destroyed*/
+				/*reset the scene pointer as it may get destroyed - unregister from scene object if not done yet*/
 				switch (gf_node_get_tag(node)) {
 				case TAG_MPEG4_Inline:
 #ifndef GPAC_DISABLE_X3D
 				case TAG_X3D_Inline:
 #endif
-					gf_node_set_private(node, NULL);
+					{
+						GF_Scene *subscene = (GF_Scene *)gf_node_get_private(node);
+						if (subscene)
+							gf_list_del_item(subscene->attached_inlines, node);
+						gf_node_set_private(node, NULL);
+					}
 					break;
 				}
 
@@ -176,7 +181,6 @@
 	if (scene->root_od->media_ctrl && scene->root_od->media_ctrl->control->loop) {
 		GF_Clock *ck = gf_odm_get_media_clock(scene->root_od);
 		if (ck->has_seen_eos && !ck->nb_paused) {
-			u32 now = gf_clock_time(ck);
 			u64 dur = scene->duration;
 			if (scene->root_od->media_ctrl->current_seg) {
 				/*only process when all segments are played*/
@@ -187,8 +191,9 @@
 			}
 			else {
 				Double s, e;
-				s = now;
-				s/=1000;
+				u64 now = gf_clock_time_absolute(ck);
+				s = (Double) now;
+				s /= 1000;
 				e = -1;
 				MC_GetRange(scene->root_od->media_ctrl, &s, &e);
 				if ((e>=0) && (e<GF_MAX_FLOAT)) dur = (u32) (e*1000);

gpac-2.0.0.tar.gz/src/compositor/mpeg4_mediacontrol.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_mediacontrol.c Changed

@@ -157,6 +157,8 @@
 	while ((ctrl_od = (GF_ObjectManager*)gf_list_enum(in_scene->resources, &i))) {
 		if (!odm->subscene && !gf_odm_shares_clock(ctrl_od, ck))
 			continue;
+		if (!ctrl_od->ck || !ctrl_od->pid)
+			continue;
 
 		if (ctrl_od->addon && (ctrl_od->addon->addon_type==GF_ADDON_TYPE_MAIN)) {
 			gf_clock_resume(ck);
@@ -203,10 +205,12 @@
 	while ((ctrl_od = (GF_ObjectManager*)gf_list_enum(in_scene->resources, &i))) {
 		if (!odm->subscene && !gf_odm_shares_clock(ctrl_od, ck))
 			continue;
+		if (!ctrl_od->ck || !ctrl_od->pid)
+			continue;
 
 		if (ctrl_od->addon && (ctrl_od->addon->addon_type==GF_ADDON_TYPE_MAIN)) {
 			gf_clock_pause(ck);
-			gf_scene_select_main_addon(in_scene, ctrl_od, GF_TRUE, gf_clock_time(ck) );
+			gf_scene_select_main_addon(in_scene, ctrl_od, GF_TRUE, gf_clock_time_absolute(ck) );
 		}
 
 		if (ctrl_od->subscene) {
@@ -239,7 +243,7 @@
 
 		//dynamic scene with speed direction, we need to re-start everything to issue new PLAY requests
 		if (in_scene->is_dynamic_scene && (gf_mulfix(ck->speed, speed) < 0)) {
-			u32 time = gf_clock_time(ck);
+			u64 time = gf_clock_time_absolute(ck);
 			gf_clock_set_speed(ck, speed);
 
 			//enable main addon
@@ -247,7 +251,7 @@
 				i=0;
 				while ((ctrl_od = (GF_ObjectManager*)gf_list_enum(in_scene->resources, &i))) {
 					if (ctrl_od->addon && (ctrl_od->addon->addon_type==GF_ADDON_TYPE_MAIN)) {
-						gf_scene_select_main_addon(in_scene, ctrl_od, GF_TRUE, gf_clock_time(ck) );
+						gf_scene_select_main_addon(in_scene, ctrl_od, GF_TRUE, time );
 						break;
 					}
 				}
@@ -663,7 +667,7 @@
 	/*synth media, trigger if end of segment run-time*/
 	if (!odm->type || ((odm->type!=GF_STREAM_VISUAL) && (odm->type!=GF_STREAM_AUDIO))) {
 		GF_Clock *ck = gf_odm_get_media_clock(odm);
-		u32 now = gf_clock_time(ck);
+		u64 now = gf_clock_time_absolute(ck);
 		u64 dur = odm->subscene ? odm->subscene->duration : odm->duration;
 		cur = (GF_Segment *)gf_list_get(ctrl->seg, ctrl->current_seg);
 		if (odm->subscene && odm->subscene->needs_restart) return 0;

gpac-2.0.0.tar.gz/src/compositor/mpeg4_mediasensor.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_mediasensor.c Changed

gpac-2.0.0.tar.gz/src/compositor/mpeg4_sensors.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_sensors.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -256,7 +256,7 @@
 
 static Bool OnDiscSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
 {
-	Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
+	Bool is_mouse = (ev->type <= GF_EVENT_LAST_MOUSE) ? 1 : 0;
 	M_DiscSensor *ds = (M_DiscSensor *)sh->sensor;
 	DiscSensorStack *stack = (DiscSensorStack *) gf_node_get_private(sh->sensor);
 
@@ -395,7 +395,7 @@
 
 static Bool OnPlaneSensor2D(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
 {
-	Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
+	Bool is_mouse = (ev->type <= GF_EVENT_LAST_MOUSE) ? 1 : 0;
 	M_PlaneSensor2D *ps = (M_PlaneSensor2D *)sh->sensor;
 	PS2DStack *stack = (PS2DStack *) gf_node_get_private(sh->sensor);
 
@@ -646,7 +646,7 @@
 
 static Bool OnTouchSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
 {
-	Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL);
+	Bool is_mouse = (ev->type <= GF_EVENT_LAST_MOUSE);
 	M_TouchSensor *ts = (M_TouchSensor *)sh->sensor;
 
 	/*this is not specified in VRML, however we consider that a de-enabled sensor will not sent deactivation events*/
@@ -826,7 +826,7 @@
 
 static Bool OnPlaneSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
 {
-	Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
+	Bool is_mouse = (ev->type <= GF_EVENT_LAST_MOUSE) ? 1 : 0;
 	M_PlaneSensor *ps = (M_PlaneSensor *)sh->sensor;
 	PSStack *stack = (PSStack *) gf_node_get_private(sh->sensor);
 
@@ -982,7 +982,7 @@
 
 static Bool OnCylinderSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
 {
-	Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
+	Bool is_mouse = (ev->type <= GF_EVENT_LAST_MOUSE) ? 1 : 0;
 	M_CylinderSensor *cs = (M_CylinderSensor *)sh->sensor;
 	CylinderSensorStack *st = (CylinderSensorStack *) gf_node_get_private(sh->sensor);
 
@@ -1185,7 +1185,7 @@
 
 static Bool OnSphereSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
 {
-	Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
+	Bool is_mouse = (ev->type <= GF_EVENT_LAST_MOUSE) ? 1 : 0;
 	M_SphereSensor *sphere = (M_SphereSensor *)sh->sensor;
 	SphereSensorStack *st = (SphereSensorStack *) gf_node_get_private(sh->sensor);

gpac-2.0.0.tar.gz/src/compositor/mpeg4_text.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_text.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -28,7 +28,6 @@
 #include "mpeg4_grouping.h"
 #include "texturing.h"
 #include <gpac/utf.h>
-#include <gpac/options.h>
 
 #ifndef GPAC_DISABLE_VRML
 
@@ -209,7 +208,8 @@
 	Fixed fontSize, start_x, start_y, line_spacing, tot_width, tot_height, max_scale, maxExtent;
 	u32 size, trim_size;
 	GF_Font *font;
-	Bool horizontal;
+	char szBuf100;
+	Bool horizontal, use_pass = GF_FALSE;
 	GF_TextSpan *trim_tspan = NULL;
 	GF_FontManager *ft_mgr = tr_state->visual->compositor->font_manager;
 	M_FontStyle *fs = (M_FontStyle *)txt->fontStyle;
@@ -228,6 +228,7 @@
 		if (strstr(fs->style.buffer, "ITALIC") || strstr(fs->style.buffer, "italic")) styles |= GF_FONT_ITALIC;
 		if (strstr(fs->style.buffer, "UNDERLINED") || strstr(fs->style.buffer, "underlined")) styles |= GF_FONT_UNDERLINED;
 		if (strstr(fs->style.buffer, "STRIKETHROUGH") || strstr(fs->style.buffer, "strikethrough")) styles |= GF_FONT_STRIKEOUT;
+		if (strstr(fs->style.buffer, "PASSWD") || strstr(fs->style.buffer, "passwd")) use_pass = GF_TRUE;
 	}
 
 	font = gf_font_manager_set_font(ft_mgr, fs ? fs->family.vals : NULL, fs ? fs->family.count : 0, styles);
@@ -257,10 +258,25 @@
 	tot_width = tot_height = 0;
 	for (i=0; i < txt->string.count; i++) {
 		GF_TextSpan *tspan;
+
 		char *str = txt->string.valsi;
 		if (!str) continue;
 
-		tspan = gf_font_manager_create_span(ft_mgr, font, txt->string.valsi, fontSize, GF_FALSE, GF_FALSE, GF_FALSE, NULL, GF_FALSE, styles, (GF_Node*)txt);
+		if (use_pass) {
+			u32 j=0, len = (u32) strlen(str);
+			if (len>=100) len=99;
+			while (j<len) {
+				if (strj == 0x1)
+					szBufj = strj;
+				else
+					szBufj = '*';
+				j++;
+			}
+			szBufj = 0;
+			str = szBuf;
+		}
+
+		tspan = gf_font_manager_create_span(ft_mgr, font, str, fontSize, GF_FALSE, GF_FALSE, GF_FALSE, NULL, GF_FALSE, styles, (GF_Node*)txt);
 		if (!tspan) continue;
 
 		if (horizontal) tspan->flags |= GF_TEXT_SPAN_HORIZONTAL;

gpac-2.0.0.tar.gz/src/compositor/mpeg4_viewport.c -> gpac-2.2.0.tar.gz/src/compositor/mpeg4_viewport.c Changed

gpac-2.0.0.tar.gz/src/compositor/navigate.c -> gpac-2.2.0.tar.gz/src/compositor/navigate.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -25,7 +25,6 @@
 
 #include "nodes_stacks.h"
 #include "visual_manager.h"
-#include <gpac/options.h>
 
 
 #ifndef GPAC_DISABLE_3D
@@ -369,7 +368,7 @@
 	if (!cam->navigate_mode && !(keys & GF_KEY_MOD_ALT) ) return 0;
 	x = y = 0;
 	/*renorm between -1, 1*/
-	if (ev->type<=GF_EVENT_MOUSEWHEEL) {
+	if (ev->type <= GF_EVENT_LAST_MOUSE) {
 		x = gf_divfix( INT2FIX(ev->mouse.x - (s32) compositor->visual->width/2), INT2FIX(compositor->visual->width));
 		y = gf_divfix( INT2FIX(ev->mouse.y - (s32) compositor->visual->height/2), INT2FIX(compositor->visual->height));
 	}
@@ -739,7 +738,7 @@
 
 	x = y = 0;
 	/*renorm between -1, 1*/
-	if (ev->type<=GF_EVENT_MOUSEWHEEL) {
+	if (ev->type <= GF_EVENT_LAST_MOUSE) {
 		x = INT2FIX(ev->mouse.x);
 		y = INT2FIX(ev->mouse.y);
 	}

gpac-2.0.0.tar.gz/src/compositor/object_manager.c -> gpac-2.2.0.tar.gz/src/compositor/object_manager.c Changed

@@ -86,10 +86,10 @@
 	gf_odm_reset_media_control(odm, 0);
 	gf_list_del(odm->ms_stack);
 	gf_list_del(odm->mc_stack);
-#endif
 
 	if (odm->type == GF_STREAM_INTERACT)
 		gf_input_sensor_delete(odm);
+#endif
 
 	if (odm->raw_frame_sema) gf_sema_del(odm->raw_frame_sema);
 
@@ -246,7 +246,9 @@
 		gf_filter_forward_gf_event(odm->parentscene->compositor->filter, &evt, GF_FALSE, GF_TRUE);
 
 		gf_scene_remove_object(odm->parentscene, odm, do_remove);
-		if (odm->subscene) gf_scene_del(odm->subscene);
+		if (odm->subscene) {
+			gf_scene_del(odm->subscene);
+		}
 		gf_odm_del(odm);
 		return;
 	}
@@ -273,7 +275,7 @@
 	//if (odm->type == GF_STREAM_VISUAL) return GF_TRUE;
 
 	if (odm->parentscene && !odm->parentscene->is_dynamic_scene) {
-		return GF_TRUE;
+		return GF_FALSE;
 	}
 
 	if (odm->parentscene && odm->parentscene->root_od->addon) {
@@ -286,7 +288,7 @@
 		GF_ObjectManager *an_odm = gf_list_get(odm->parentscene->resources, i);
 		if (an_odm==odm) continue;
 		if (an_odm->type != odm->type) continue;
-		//same type - if the first one has been autumatically activated, do not activate this one
+		//same type - if the first one has been automatically activated, do not activate this one
 		if (an_odm->state == GF_ODM_STATE_PLAY) return GF_FALSE;
 	}
 	return GF_TRUE;
@@ -359,7 +361,7 @@
 
 	/*restore OD ID */
 	if (odm->media_current_time) {
-		odm->ID = odm->media_current_time;
+		odm->ID = (u32) odm->media_current_time;
 		odm->media_current_time = 0;
 		odm->flags |= GF_ODM_REMOTE_OD;
 	}
@@ -373,7 +375,7 @@
 		assert(odm->subscene->root_od==odm);
 		odm->subscene->is_dynamic_scene = GF_TRUE;
 	} else if (odm->pid) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Terminal Setting up object streams\n"));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Compositor Setting up object streams\n"));
 
 		e = gf_odm_setup_pid(odm, for_pid);
 		if (e) {
@@ -412,6 +414,12 @@
 			odm->buffer_playout_ms = odm->buffer_max_ms = 1; //1 ms
 			odm->buffer_min_ms = 0;
 		}
+		prop = gf_filter_pid_get_property(for_pid ? for_pid : odm->pid, GF_PROP_PID_RAWGRAB);
+		if (prop && prop->value.uint) {
+			odm->buffer_playout_ms = 0;
+			odm->buffer_min_ms = 0;
+			odm->buffer_max_ms = 0;
+		}
 
 		GF_FEVT_INIT(evt, GF_FEVT_BUFFER_REQ, for_pid ? for_pid : odm->pid);
 		evt.buffer_req.max_buffer_us = odm->buffer_max_ms * 1000;
@@ -421,6 +429,10 @@
 
 		if (odm->buffer_min_ms * 1000 > evt.buffer_req.max_playout_us)
 			odm->buffer_min_ms = 0;
+
+		if (gf_filter_pid_is_sparse(for_pid ? for_pid : odm->pid))
+			odm->buffer_min_ms = odm->buffer_max_ms = odm->buffer_playout_ms = 0;
+
 	}
 
 	/*setup mediaobject info except for top-level OD*/
@@ -489,21 +501,29 @@
 	have to wait for an entire image carousel period to start filling the buffers, which is sub-optimal
 	we also force a prefetch for object declared outside the OD stream to make sure we don't loose any data before object declaration and play
 	as can be the case with MPEG2 TS (first video packet right after the PMT) - this should be refined*/
-	else if ( ((odm->flags & GF_ODM_NO_TIME_CTRL) || (odm->flags & GF_ODM_NOT_IN_OD_STREAM)) && gf_odm_should_auto_select(odm) && (odm->parentscene->selected_service_id == odm->ServiceID)) {
-		Bool force_play = GF_FALSE;
+	else if ( ((odm->flags & GF_ODM_NO_TIME_CTRL) || (odm->flags & GF_ODM_NOT_IN_OD_STREAM)) && (odm->parentscene->selected_service_id == odm->ServiceID)) {
 
-		if (odm->state==GF_ODM_STATE_STOP) {
-			odm->flags |= GF_ODM_PREFETCH;
-			force_play = GF_TRUE;
-		}
+		if (gf_odm_should_auto_select(odm)) {
+			Bool force_play = GF_FALSE;
+
+			if (odm->state==GF_ODM_STATE_STOP) {
+				odm->flags |= GF_ODM_PREFETCH;
+				force_play = GF_TRUE;
+			}
 
-		if (force_play) {
-			odm->flags |= GF_ODM_INITIAL_BROADCAST_PLAY;
-			odm->parentscene->selected_service_id = odm->ServiceID;
+			if (force_play) {
+				odm->flags |= GF_ODM_INITIAL_BROADCAST_PLAY;
+				odm->parentscene->selected_service_id = odm->ServiceID;
 
-			GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d Inserted from input service %s - forcing play\n", odm->ID, odm->scene_ns->url));
-			odm->flags &= ~GF_ODM_NOT_SETUP;
+				GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d Inserted from input service %s - forcing play\n", odm->ID, odm->scene_ns->url));
+				odm->flags &= ~GF_ODM_NOT_SETUP;
+				gf_odm_start(odm);
+			}
+		} else {
+			//otherwise issue play/stop to stop the stream
+			//the play is needed because some filters (m2ts demux) start considering the pid is active (for reframers)
 			gf_odm_start(odm);
+			gf_odm_stop(odm, GF_FALSE);
 		}
 	}
 
@@ -572,6 +592,7 @@
 	const GF_PropertyValue *prop;
 	u32 OD_OCR_ID=0;
 	u32 es_id=0;
+	u32 ckid_use_odid = 0;
 
 	/*find the clock for this new channel*/
 	ck = NULL;
@@ -586,6 +607,10 @@
 	}
 #endif
 
+	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_ESID);
+	if (!prop) prop = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
+	if (prop) es_id = prop->value.uint;
+
 	if (odm->ck) {
 		ck = odm->ck;
 		goto clock_setup;
@@ -650,8 +675,10 @@
 	if (!clockID) {
 		if (odm->ID == GF_MEDIA_EXTERNAL_ID) {
 			clockID = (u32) (intptr_t) odm->scene_ns;
+			ckid_use_odid = clockID;
 		} else {
 			clockID = odm->ID;
+			ckid_use_odid = clockID;
 		}
 	}
 
@@ -663,9 +690,6 @@
 		assert(ck_namespace);
 	}
 
-	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_ESID);
-	if (!prop) prop = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
-	if (prop) es_id = prop->value.uint;
 
 	ck = gf_clock_attach(ck_namespace, scene, clockID, es_id, flag);
 	if (!ck) return GF_OUT_OF_MEM;
@@ -673,9 +697,6 @@
 	ck->service_id = odm->ServiceID;
 	clock_inherited = GF_FALSE;
 
-	if (es_id==ck->clock_id)
-		odm->owns_clock = GF_TRUE;
-
 	if (scene->root_od->subscene && scene->root_od->subscene->is_dynamic_scene && !scene->root_od->ck)
 		scene->root_od->ck = ck;
 
@@ -684,6 +705,11 @@
 	odm->ck = ck;
 	odm->clock_inherited = clock_inherited;
 
+	if (es_id==ck->clock_id)
+		odm->owns_clock = GF_TRUE;
+	else if (ckid_use_odid && (ckid_use_odid==ck->clock_id))
+		odm->owns_clock = GF_TRUE;
+
 	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
 	odm->timestamp_offset = prop ? prop->value.longsint : 0;
 	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
@@ -705,10 +731,10 @@
 	GF_PropertyEntry *pe = NULL;
 	const GF_PropertyValue *prop;
 	prop = gf_filter_pid_get_info(pid, GF_PROP_PID_DURATION, &pe);
-	if (prop) {
-		dur = prop->value.lfrac.num;
+	if (prop && prop->value.lfrac.den) {
+		dur = (prop->value.lfrac.num<0) ? -prop->value.lfrac.num : prop->value.lfrac.num;
 		dur *= 1000;
-		if (prop->value.lfrac.den) dur /= prop->value.lfrac.den;
+		dur /= prop->value.lfrac.den;
 	}
 	gf_filter_release_property(pe);
 	
@@ -772,6 +798,14 @@
 		/*reset*/
 		gf_filter_pck_unref(odm->mo->pck);
 		odm->mo->pck = NULL;
+		//reset all textures pointing to this stream
+		u32 i, count = gf_list_count(scene->compositor->textures);
+		for (i=0; i<count; i++) {
+			GF_TextureHandler *txh = (GF_TextureHandler *)gf_list_get(scene->compositor->textures, i);
+			if (!txh || (txh->stream != odm->mo)) break;
+			txh->data = NULL;
+			txh->frame_ifce = NULL;
+		}
 	}
 
 	if (odm->parentscene) {
@@ -810,7 +844,7 @@
 	}
 	/*play from current time*/
 	else {
-		ck_time = gf_clock_media_time(clock);
+		ck_time = (Double) gf_clock_media_time(clock);
 		ck_time /= 1000;
 		start_range_is_clock = 1;
 	}
@@ -830,7 +864,7 @@
 				ck_time = (Double) odm->parentscene->root_od->addon->media_pts;
 				ck_time /= 90000;
 			} else {
-				ck_time = gf_clock_time(clock);
+				ck_time = (Double) gf_clock_time_absolute(clock);
 				ck_time /= 1000;
 			}
 		}
@@ -858,7 +892,7 @@
 	}
 
 	com.play.speed = clock->speed;
-	if (ABS(com.play.speed)>scene->compositor->max_vspeed)
+	if (scene->compositor->max_vspeed && (ABS(com.play.speed) > ABS(scene->compositor->max_vspeed)))
 		com.play.drop_non_ref = GF_TRUE;
 
 #ifndef GPAC_DISABLE_VRML
@@ -875,7 +909,7 @@
 		}
 
 		com.play.speed = FIX2FLT(ctrl->control->mediaSpeed);
-		if (ABS(com.play.speed)>scene->compositor->max_vspeed)
+		if (scene->compositor->max_vspeed && (ABS(com.play.speed) > ABS(scene->compositor->max_vspeed)))
 			com.play.drop_non_ref = GF_TRUE;
 		/*if the channel doesn't control the clock, jump to current time in the controled range, not just the beginning*/
 		if ((ctrl->stream != odm->mo) && (ck_time>com.play.start_range) && (com.play.end_range>com.play.start_range)
@@ -922,16 +956,18 @@
 		}
 	}
 
-	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s PID %s: At OTB %u requesting PLAY from %g to %g (clock init %d) - speed %g\n", odm->ID, odm->scene_ns->url, gf_filter_pid_get_name(odm->pid), gf_clock_time(clock), com.play.start_range, com.play.end_range, clock->clock_init, com.play.speed));
+	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s PID %s: At OTB %u requesting PLAY from %g to %g (clock init %d) - speed %g\n", odm->ID, odm->scene_ns->url, odm->pid ? gf_filter_pid_get_name(odm->pid) : "ROOTSCENE", gf_clock_time(clock), com.play.start_range, com.play.end_range, clock->clock_init, com.play.speed));
 
 
 	if (odm->state != GF_ODM_STATE_PLAY) {
 		odm->state = GF_ODM_STATE_PLAY;
 
-		odm->nb_buffering ++;
-		scene->nb_buffering++;
-		//start buffering
-		gf_clock_buffer_on(odm->ck);
+		if (odm->buffer_max_ms) {
+			odm->nb_buffering++;
+			scene->nb_buffering++;
+			//start buffering
+			gf_clock_buffer_on(odm->ck);
+		}
 
 		odm->has_seen_eos = GF_FALSE;
 
@@ -951,7 +987,7 @@
 				com.base.on_pid = xpid->pid;
 				odm->has_seen_eos = GF_FALSE;
 
-				odm->nb_buffering ++;
+				odm->nb_buffering++;
 				scene->nb_buffering++;
 				//start buffering
 				gf_clock_buffer_on(odm->ck);
@@ -1031,7 +1067,7 @@
 	odm->has_seen_eos = GF_FALSE;
 	odm->state = GF_ODM_STATE_STOP;
 	GF_FEVT_INIT(com, GF_FEVT_STOP, odm->pid)
-	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s PID %s At OTB %u requesting STOP\n", odm->ID, odm->scene_ns->url, gf_filter_pid_get_name(odm->pid), odm->ck ? gf_clock_time(odm->ck) : 0 ));
+	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s PID %s At OTB %u requesting STOP\n", odm->ID, odm->scene_ns->url, odm->pid ? gf_filter_pid_get_name(odm->pid) : "ROOTSCENE", odm->ck ? gf_clock_time(odm->ck) : 0 ));
 
 	gf_filter_pid_send_event(odm->pid, &com);
 	gf_list_del_item(scene->compositor->systems_pids, odm->pid);
@@ -1053,7 +1089,7 @@
 		scene->nb_buffering -= odm->nb_buffering;
 		while (odm->nb_buffering && odm->ck) {
 			gf_clock_buffer_off(odm->ck);
-			odm->nb_buffering --;
+			odm->nb_buffering--;
 		}
 		if (!scene->nb_buffering) {
 			gf_scene_buffering_info(scene, GF_TRUE);
@@ -1233,13 +1269,13 @@
 
 	//cleanup - we need to enter in stop state for broadcast modes
 	if (odm->flags & GF_ODM_NO_TIME_CTRL) {
-		GF_LOG(GF_LOG_WARNING, GF_LOG_COMPTIME, ("ODM%d %s PID %s: no time control available in source filter, will not pause\n", odm->ID, odm->scene_ns->url, gf_filter_pid_get_name(odm->pid)));
+		GF_LOG(GF_LOG_WARNING, GF_LOG_COMPTIME, ("ODM%d %s PID %s: no time control available in source filter, will not pause\n", odm->ID, odm->scene_ns->url, odm->pid ? gf_filter_pid_get_name(odm->pid) : "ROOTSCENE"));
 		return;
 	}
 
 	scene = gf_scene_get_root_scene(scene);
 
-	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s PID %s: At OTB %u requesting PAUSE (clock init %d)\n", odm->ID, odm->scene_ns->url, gf_filter_pid_get_name(odm->pid), gf_clock_time(odm->ck), odm->ck->clock_init ));
+	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s PID %s: At OTB %u requesting PAUSE (clock init %d)\n", odm->ID, odm->scene_ns->url, odm->pid ? gf_filter_pid_get_name(odm->pid) : "ROOTSCENE", gf_clock_time(odm->ck), odm->ck->clock_init ));
 
 	GF_FEVT_INIT(com, GF_FEVT_PAUSE, odm->pid);
 	gf_clock_pause(odm->ck);
@@ -1305,12 +1341,14 @@
 	ctrl = gf_odm_get_mediacontrol(odm);
 #endif
 
-	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s CH%d: At OTB %u requesting RESUME (clock init %d)\n", odm->ID, odm->scene_ns->url, gf_filter_pid_get_name(odm->pid), gf_clock_time(odm->ck), odm->ck->clock_init ));
+	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("ODM%d %s PID %s: At OTB %u requesting RESUME (clock init %d)\n", odm->ID, odm->scene_ns->url, odm->pid ? gf_filter_pid_get_name(odm->pid) : "ROOTSCENE", gf_clock_time(odm->ck), odm->ck->clock_init ));
 
 	GF_FEVT_INIT(com, GF_FEVT_RESUME, odm->pid);
 	com.play.speed = odm->ck->speed;
+#ifndef GPAC_DISABLE_VRML
 	if (ctrl) com.play.speed = ctrl->control->mediaSpeed;
-	if (ABS(com.play.speed)>scene->compositor->max_vspeed)
+#endif
+	if (scene->compositor->max_vspeed && (ABS(com.play.speed) > ABS(scene->compositor->max_vspeed)))
 		com.play.drop_non_ref = GF_TRUE;
 
 	gf_clock_resume(odm->ck);
@@ -1359,8 +1397,9 @@
 
 	GF_FEVT_INIT(com, GF_FEVT_SET_SPEED, odm->pid);
 
+	odm->too_slow = GF_FALSE;
 	com.play.speed = FIX2FLT(speed);
-	if (ABS(com.play.speed)>scene->compositor->max_vspeed)
+	if (scene->compositor->max_vspeed && (ABS(com.play.speed) > ABS(scene->compositor->max_vspeed)))
 		com.play.drop_non_ref = GF_TRUE;
 
 	gf_filter_pid_send_event(odm->pid, &com);
@@ -1453,18 +1492,18 @@
 	}
 }
 
-static Bool odm_update_buffer(GF_Scene *scene, GF_ObjectManager *odm, GF_FilterPid *pid, Bool *signal_eob)
+
+/*DO NOT use get_packet here, we don't want to trigger reconfig*/
+static Bool odm_update_buffer(GF_Scene *scene, GF_ObjectManager *odm, GF_FilterPid *pid, Bool check_full_buffer, Bool *signal_eob)
 {
 	u32 timescale;
-	u64 buffer_duration = gf_filter_pid_query_buffer_duration(pid, GF_FALSE)/1000;
+	u64 buffer_duration = gf_filter_pid_query_buffer_duration(pid, check_full_buffer)/1000;
 	if (odm->ck && ! odm->ck->clock_init) {
 		u64 time;
-		GF_FilterPacket *pck = gf_filter_pid_get_packet(pid);
-		if (!pck) return GF_TRUE;
-		timescale = gf_filter_pck_get_timescale(pck);
+		if (!gf_filter_pid_get_first_packet_cts(pid, &time))
+			return GF_TRUE;
+		timescale = gf_filter_pid_get_timescale(pid);
 
-		time = gf_filter_pck_get_cts(pck);
-		if (time==GF_FILTER_NO_TS) time = gf_filter_pck_get_dts(pck);
 		if (time==GF_FILTER_NO_TS) {
 			//this usually happens with BT/XMT playback
 			GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("No timestamp on first packet, using 0\n"));
@@ -1478,23 +1517,20 @@
 			time-= -odm->timestamp_offset;
 		}
 
-		time *= 1000;
-		time /= timescale;
-		gf_clock_set_time(odm->ck, (u32) time);
+		gf_clock_set_time(odm->ck, time, timescale);
 		odm->media_current_time = 0;
 		if (odm->parentscene) {
 			odm->parentscene->root_od->media_start_time = 0;
 			odm->parentscene->root_od->media_current_time = 0;
 		}
-		gf_odm_check_clock_mediatime(odm);
 
-		if (pck && gf_filter_pck_is_blocking_ref(pck))
+		if (gf_filter_pid_first_packet_is_blocking_ref(pid))
 			odm->blocking_media = GF_TRUE;
 	}
 
 	//TODO abort buffering when errors are found on the input chain !!
 	if (odm->blocking_media || (buffer_duration >= odm->buffer_playout_ms)) {
-		odm->nb_buffering --;
+		odm->nb_buffering--;
 		assert(scene->nb_buffering);
 		scene->nb_buffering--;
 		if (!scene->nb_buffering) {
@@ -1503,7 +1539,7 @@
 		if (odm->ck)
 			gf_clock_buffer_off(odm->ck);
 	} else if (gf_filter_pid_has_seen_eos(pid) ) {
-		odm->nb_buffering --;
+		odm->nb_buffering--;
 		assert(scene->nb_buffering);
 		scene->nb_buffering--;
 		//if eos while buffering, consider the last rebuffer an error
@@ -1522,6 +1558,7 @@
 	return GF_FALSE;
 }
 
+/*DO NOT use get_packet here, we don't want to trigger reconfig*/
 Bool gf_odm_check_buffering(GF_ObjectManager *odm, GF_FilterPid *pid)
 {
 	u32 timescale;
@@ -1529,34 +1566,53 @@
 	GF_Scene *scene;
 	GF_FilterClockType ck_type;
 	u64 clock_reference;
-	GF_FilterPacket *pck;
-	Bool check_disc = GF_TRUE;
+	u64 pck_time = 0;
+	Bool has_pck = GF_FALSE;
+	Bool check_disc = GF_FALSE;
+	Bool check_full_buffer = GF_TRUE;
 
 	assert(odm);
 
-	if (!pid)
+	if (!pid) {
+		check_full_buffer = GF_FALSE;
 		pid = odm->pid;
+	} else {
+		//when a pid is given, this is a non-AV codec (bifs/od, svg, text), try to map media timeline
+		//otherwise we cannot since we don't want to use get_packet here
+		gf_odm_check_clock_mediatime(odm);
+	}
 
 	scene = odm->subscene ? odm->subscene : odm->parentscene;
 	if (!scene) return GF_FALSE;
-	pck = gf_filter_pid_get_packet(pid);
-	ck_type = gf_filter_pid_get_clock_info(pid, &clock_reference, &timescale);
 
-	if (!odm->ck->clock_init && ck_type) {
-		clock_reference *= 1000;
-		clock_reference /= timescale;
-		gf_clock_set_time(odm->ck, (u32) clock_reference);
-		if (odm->parentscene)
-			odm->parentscene->root_od->media_start_time = 0;
+	if (!gf_filter_pid_first_packet_is_empty(pid)) {
+		if (gf_filter_pid_get_first_packet_cts(pid, &pck_time))
+			has_pck = GF_TRUE;
 	}
+	ck_type = gf_filter_pid_get_clock_info(pid, &clock_reference, &timescale);
+
+	if (!odm->ck->clock_init) {
+		if (ck_type) {
+			gf_clock_set_time(odm->ck, clock_reference, timescale);
+			if (odm->parentscene) odm->parentscene->root_od->media_start_time = 0;
+		}
+		else if (has_pck && odm->owns_clock && !odm->ck->clock_init) {
+			gf_clock_set_time(odm->ck, pck_time, gf_filter_pid_get_timescale(pid) );
 
+			if (gf_filter_pid_first_packet_is_blocking_ref(pid)) {
+				odm->blocking_media = GF_TRUE;
+				if (odm->nb_buffering)
+					odm_update_buffer(scene, odm, pid, check_full_buffer, &signal_eob);
+			}
+		}
+	}
 	if (odm->nb_buffering) {
 	 	GF_ODMExtraPid *xpid;
 	 	u32 i=0;
-	 	Bool ret = odm_update_buffer(scene, odm, pid, &signal_eob);
+		Bool ret = odm_update_buffer(scene, odm, pid, check_full_buffer, &signal_eob);
 	 	if (ret) return GF_TRUE;
 		while (odm->nb_buffering && (xpid = gf_list_enum(odm->extra_pids, &i))) {
-			ret = odm_update_buffer(scene, odm, xpid->pid, &signal_eob);
+			ret = odm_update_buffer(scene, odm, xpid->pid, GF_FALSE, &signal_eob);
 			if (ret) return GF_TRUE;
 		}
 	}
@@ -1569,7 +1625,7 @@
 			if (!an_odm->pid) continue;
 
 			if (an_odm->nb_buffering)
-	 			odm_update_buffer(scene, an_odm, an_odm->pid, &signal_eob);
+				odm_update_buffer(scene, an_odm, an_odm->pid, GF_FALSE, &signal_eob);
 		}
 	} else if (!odm->blocking_media && odm->buffer_min_ms && odm->pid && odm->ck && odm->ck->clock_init && !gf_filter_pid_has_seen_eos(odm->pid) ) {
 		u64 buffer_duration = gf_filter_pid_query_buffer_duration(odm->pid, GF_FALSE)/1000;
@@ -1587,31 +1643,31 @@
 
 	if (odm->parentscene && odm->parentscene->root_od->addon)
 		check_disc = GF_FALSE;
+	else if ((odm->type== GF_STREAM_VISUAL) || (odm->type== GF_STREAM_AUDIO))
+		check_disc = GF_TRUE;
+
 	//handle both PCR discontinuities or TS looping when no PCR disc is present/signaled
-	if (pck && check_disc) {
+	if (has_pck && check_disc) {
 		s32 diff=0;
-		u64 pck_time = 0;
 		u32 clock_time = gf_clock_time(odm->ck);
 		s32 diff_to = 0;
+		u64 ckref_orig = clock_reference;
 		if (ck_type) {
-			clock_reference *= 1000;
-			clock_reference /= timescale;
+			clock_reference = gf_timestamp_to_clocktime(clock_reference, timescale);
 			diff = (s32) clock_time + odm->buffer_playout_ms;
 			diff -= (s32) clock_reference;
 			GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("Clock %d (ODM %d) reference found "LLU" ms clock time %d ms - diff %d - type %d\n", odm->ck->clock_id, odm->ID, clock_reference, clock_time, diff, ck_type));
 
 			//if explicit clock discontinuity, mark clock
 			if (ck_type==GF_FILTER_CLOCK_PCR_DISC)
-				odm->ck->ocr_discontinuity_time = (u32) (1+clock_reference);
+				odm->ck->ocr_discontinuity_time = 1 + gf_timestamp_rescale(ckref_orig, timescale, 1000);
 		}
-		pck_time = gf_filter_pck_get_cts(pck);
-		timescale = gf_filter_pck_get_timescale(pck);
+		timescale = gf_filter_pid_get_timescale(pid);
 		if (pck_time != GF_FILTER_NO_TS) {
-			pck_time *= 1000;
-			pck_time /= timescale;
+			pck_time = gf_timestamp_to_clocktime(pck_time, timescale);
 			pck_time += 1;
 			diff = (u32) ((u64) clock_time - pck_time);
-			diff_to = odm->ck->ocr_discontinuity_time ? 500 : 8000;
+			diff_to = (s32) (odm->ck->ocr_discontinuity_time ? 500 : 8000) * ABS(FIX2INT(odm->ck->speed) );
 		}
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Clock %d (ODM %d) pck time %d - clock ref "LLU" clock time %d - diff %d vs %d\n", odm->ck->clock_id, odm->ID, pck_time, clock_reference, clock_time, diff, diff_to));
 
@@ -1629,7 +1685,7 @@
 			if (diff_pck_old_clock > diff_pck_new_clock) {
 				u32 i, count;
 				GF_Scene *in_scene = odm->subscene ? odm->subscene : odm->parentscene;
-				GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("Clock %d (ODM %d) discontinuity detected "LLU" clock time %d - diff %d - type %d - pck time "LLU"\n", odm->ck->clock_id, odm->ID, clock_reference, clock_time, diff, ck_type, pck_time-1));
+				GF_LOG(GF_LOG_WARNING, GF_LOG_COMPTIME, ("Clock %d (ODM %d) discontinuity detected "LLU" clock time %d - diff %d - type %d - pck time "LLU"\n", odm->ck->clock_id, odm->ID, clock_reference, clock_time, diff, ck_type, pck_time-1));
 
 				count = gf_list_count(in_scene->resources);
 				for (i=0; i<count; i++) {
@@ -1638,15 +1694,25 @@
 					an_odm->prev_clock_at_discontinuity_plus_one = 1 + clock_time;
 				}
 				odm->ck->clock_init = GF_FALSE;
-				gf_clock_set_time(odm->ck, odm->ck->ocr_discontinuity_time ? odm->ck->ocr_discontinuity_time - 1 : (u32) clock_reference);
+
+				if (odm->ck->ocr_discontinuity_time)
+					gf_clock_set_time(odm->ck, odm->ck->ocr_discontinuity_time - 1, 1000);
+				else
+					gf_clock_set_time(odm->ck, ckref_orig, timescale);
+
 				odm->ck->ocr_discontinuity_time = 0;
+				//if we had media time mapping, get media time in last clock value and reassign mapping
+				if (odm->ck->has_media_time_shift) {
+					u64 mtime = gf_clock_to_media_time(odm->ck, clock_time);
+					odm->ck->media_time_orig = mtime;
+					odm->ck->media_ts_orig = gf_timestamp_rescale(ckref_orig, timescale, 1000);
+				}
 			}
 		}
 	} else if (ck_type) {
-		clock_reference *= 1000;
-		clock_reference /= timescale;
+		clock_reference = gf_timestamp_rescale(clock_reference, timescale, 1000);
 		if (ck_type==GF_FILTER_CLOCK_PCR_DISC)
-			odm->ck->ocr_discontinuity_time = (u32) (1 + clock_reference);
+			odm->ck->ocr_discontinuity_time = 1 + clock_reference;
 
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPTIME, ("Clock %d (ODM %d) received "LLU" type %d clock time %d no pending packets\n", odm->ck->clock_id, odm->ID, clock_reference, ck_type, gf_clock_time(odm->ck)));
 	}
@@ -1805,7 +1871,7 @@
 	GF_FilterPidStatistics stats;
 	gf_filter_pid_get_statistics(pid, &stats, scalable_addon ? GF_STATS_LOCAL : GF_STATS_LOCAL_INPUTS);
 
-	info->avg_bitrate = stats.avgerage_bitrate;
+	info->avg_bitrate = stats.average_bitrate;
 	info->max_bitrate = stats.max_bitrate;
 	info->nb_dec_frames = stats.nb_processed;
 	info->max_dec_time = stats.max_process_time;
@@ -1824,6 +1890,7 @@
 GF_EXPORT
 GF_Err gf_odm_get_object_info(GF_ObjectManager *odm, GF_MediaInfo *info)
 {
+	GF_FilterPid *gf_filter_pid_first_pid_for_source(GF_FilterPid *pid, GF_Filter *source);
 	const GF_PropertyValue *prop;
 	GF_ObjectManager *an_odm;
 	GF_FilterPid *pid;
@@ -1848,8 +1915,18 @@
 		pid = an_odm->pid;
 	}
 
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode() && pid) {
+		GF_FilterPidStatistics stats;
+		gf_filter_pid_get_statistics(odm->pid, &stats, GF_STATS_SINK);
+		gf_filter_pid_set_rt_stats(pid, 0, 0, 0);
+		gf_filter_pid_share_origin(pid, pid);
+		if (odm->parentscene)
+			gf_filter_pid_first_pid_for_source(pid, odm->parentscene->root_od->scene_ns->source_filter);
+	}
+#endif
+
 	if (odm->subscene && !odm->pid && odm->addon && !gf_list_count(odm->subscene->resources)) {
-		GF_FilterPid *gf_filter_pid_first_pid_for_source(GF_FilterPid *pid, GF_Filter *source);
 		u32 i;
 		for (i=0; i<gf_list_count(odm->parentscene->resources); i++) {
 			GF_ObjectManager *par_odm = gf_list_get(odm->parentscene->resources, i);
@@ -1874,16 +1951,16 @@
 	if (pid) {
 		/*since we don't remove ODs that failed setup, check for clock*/
 		if (odm->ck) {
-			info->current_time = odm->media_current_time;
+			//info->current_time = (Double) odm->media_current_time;
 			info->ntp_diff = odm->last_drawn_frame_ntp_diff;
-			info->current_time = gf_clock_media_time(odm->ck);
+			info->current_time = (Double) gf_clock_media_time(odm->ck);
 
 		}
 		info->current_time /= 1000;
 		info->nb_dropped = odm->nb_dropped;
 	} else if (odm->subscene) {
 		if (odm->subscene->root_od && odm->subscene->root_od->ck) {
-			info->current_time = gf_clock_media_time(odm->subscene->root_od->ck);
+			info->current_time = (Double) gf_clock_media_time(odm->subscene->root_od->ck);
 			info->current_time /= 1000;
 		}
 		info->duration = (Double) (s64)odm->subscene->duration;
@@ -2002,30 +2079,25 @@
 	u64 timestamp;
 	u32 timescale;
 	u32 i;
-	Double media_time, shift;
+	Double media_time;
 	GF_Scene *scene;
 	const GF_PropertyValue *p;
-	GF_PropertyEntry *pe=NULL;
-	if (!odm->owns_clock) return;
-
-	if (odm->ck->has_media_time_shift) return;
+	if (!odm->owns_clock || odm->ck->has_media_time_shift) return;
 
 	timescale = gf_filter_pid_get_timescale(odm->pid);
 	if (!timescale) return;
 
-	p = gf_filter_pid_get_info_str(odm->pid, "time:timestamp", &pe);
-	if (!p) return;
-	timestamp = p->value.longuint;
-	p = gf_filter_pid_get_info_str(odm->pid, "time:media", &pe);
+	GF_FilterPacket *pck = gf_filter_pid_get_packet(odm->pid);
+	if (!pck) return;
+
+	timestamp = gf_filter_pck_get_cts(pck);
+	if (timestamp == GF_FILTER_NO_TS) return;
+	p = gf_filter_pck_get_property(pck, GF_PROP_PCK_MEDIA_TIME);
 	if (!p) return;
-	gf_filter_release_property(pe);
 	media_time = p->value.number;
 
-	shift = (Double) timestamp;
-	shift /= timescale;
-	shift -= ((Double)odm->ck->init_timestamp)/1000;
-	media_time += shift;
-	odm->ck->media_time_at_init = (u32) (media_time * 1000);
+	odm->ck->media_ts_orig = gf_timestamp_rescale(timestamp, timescale, 1000);
+	odm->ck->media_time_orig = (u64) (media_time * 1000);
 	odm->ck->has_media_time_shift = GF_TRUE;
 
 	scene = odm->subscene ? odm->subscene : odm->parentscene;

gpac-2.0.0.tar.gz/src/compositor/scene.c -> gpac-2.2.0.tar.gz/src/compositor/scene.c Changed

@@ -31,7 +31,6 @@
 #include <gpac/network.h>
 #include <gpac/internal/compositor_dev.h>
 #include <gpac/nodes_x3d.h>
-#include <gpac/options.h>
 
 /*SVG properties*/
 #ifndef GPAC_DISABLE_SVG
@@ -43,14 +42,15 @@
 {
 	GF_Scene *scene = (GF_Scene *)_is;
 #if 1
-	u32 ret;
+	u64 ret;
 	GF_Clock *ck;
 	assert(scene);
 	assert(scene->root_od);
 	ck = scene->root_od->ck;
 	if (!ck) return 0.0;
-	ret = gf_clock_time(ck);
-	if (scene->root_od->media_stop_time && (scene->root_od->media_stop_time<ret)) ret = (u32) scene->root_od->media_stop_time;
+	ret = gf_clock_time_absolute(ck);
+	if ((scene->root_od->media_stop_time>0) && ((u64) scene->root_od->media_stop_time<ret))
+		ret = scene->root_od->media_stop_time;
 	return ret/1000.0;
 #else
 	return scene->simulation_time;
@@ -337,6 +337,7 @@
 	SFURL_RESET(scene->audio_url);
 	SFURL_RESET(scene->visual_url);
 	SFURL_RESET(scene->text_url);
+	SFURL_RESET(scene->subs_url);
 	SFURL_RESET(scene->dims_url);
 }
 
@@ -356,6 +357,8 @@
 	gf_list_del(scene->extern_protos);
 #endif
 
+	gf_sc_node_destroy(scene->compositor, NULL, scene->graph);
+
 	/*delete the scene graph*/
 	gf_sg_del(scene->graph);
 
@@ -961,7 +964,7 @@
 		 (OD_ID != GF_MEDIA_EXTERNAL_ID && (obj->OD_ID==OD_ID))
 		 ||
 		 /*dynamic OD scheme - !! obj->OD_ID may different from GF_MEDIA_EXTERNAL_ID when ODs are
-		 directly added to the terminal by the service*/
+		 directly added to the compositor by the service*/
 		 ((OD_ID == GF_MEDIA_EXTERNAL_ID)
 		 /*if object type unknown (media control, media sensor), return first obj matching URL
 		 otherwise check types*/
@@ -1288,10 +1291,49 @@
 
 void gf_scene_force_size_to_video(GF_Scene *scene, GF_MediaObject *mo)
 {
+	const GF_PropertyValue *p;
 	u32 w, h;
-	gf_scene_get_video_size(mo, &w, &h);
+	Bool is_subs_pic = GF_FALSE;
+	//if picture subtitle don't resize unless standalone playback
+	if (gf_list_count(scene->resources)>1) {
+		p = gf_filter_pid_get_property(mo->odm->pid, GF_PROP_PID_ORIG_STREAM_TYPE);
+		if (p && (p->value.uint==GF_STREAM_TEXT)) is_subs_pic = GF_TRUE;
+	}
+	if (!is_subs_pic) {
+		gf_scene_get_video_size(mo, &w, &h);
+		if (w && h) gf_scene_force_size(scene, w, h);
+		return;
+	}
+	//subpic stream, update props
+	w = scene->compositor->scene_width;
+	h = scene->compositor->scene_height;
+
+#ifndef GPAC_DISABLE_VRML
+	M_Transform2D *tr = NULL;
+	tr = (M_Transform2D *) gf_sg_find_node_by_name(scene->graph, "TR_SUBT_IMG");
+	if (!tr) return;
 
-	if (w && h) gf_scene_force_size(scene, w, h);
+	tr->translation.x = 0;
+	p = gf_filter_pid_get_property(mo->odm->pid, GF_PROP_PID_TRANS_X_INV);
+	if (p) {
+		tr->translation.x = -INT2FIX(w/2) + INT2FIX(p->value.sint+mo->width/2);
+	} else {
+		p = gf_filter_pid_get_property(mo->odm->pid, GF_PROP_PID_TRANS_X);
+		if (p) tr->translation.x = INT2FIX(p->value.sint);
+	}
+	tr->translation.x += scene->compositor->subtx;
+
+	tr->translation.y = 0;
+	p = gf_filter_pid_get_property(mo->odm->pid, GF_PROP_PID_TRANS_Y_INV);
+	if (p) {
+		tr->translation.y = INT2FIX( (s32)h/2 - p->value.sint);
+	} else {
+		p = gf_filter_pid_get_property(mo->odm->pid, GF_PROP_PID_TRANS_Y);
+		if (p) tr->translation.y = INT2FIX(p->value.sint);
+	}
+	tr->translation.y += scene->compositor->subty;
+	gf_node_changed((GF_Node *)tr, NULL);
+#endif /*GPAC_DISABLE_VRML*/
 }
 
 #ifndef GPAC_DISABLE_VRML
@@ -1369,7 +1411,13 @@
 			if (!odm->ID)
 				continue;
 
-			if (type==GF_STREAM_TEXT) {
+			//only used to set subtile pictures
+			if (type==GF_STREAM_UNKNOWN) {
+				if (odm->type != GF_STREAM_VISUAL) continue;
+				const GF_PropertyValue *p = gf_filter_pid_get_property(odm->pid, GF_PROP_PID_ORIG_STREAM_TYPE);
+				if (!p || (p->value.uint!=GF_STREAM_TEXT)) continue;
+			}
+			else if (type==GF_STREAM_TEXT) {
 				if (odm->type!=type) continue;
 			}
 			else if (type==GF_STREAM_SCENE) {
@@ -1380,8 +1428,12 @@
 			}
 			else {
 				if (odm->type!=type) continue;
-				//todo: select preferred media format ?
+				if (type==GF_STREAM_VISUAL) {
+					const GF_PropertyValue *p = gf_filter_pid_get_property(odm->pid, GF_PROP_PID_ORIG_STREAM_TYPE);
+					if (p && (p->value.uint!=type)) continue;
+				}
 			}
+			//todo: select preferred media format ?
 
 			if (scene->selected_service_id && (scene->selected_service_id != odm->ServiceID)) {
 				//objects inserted from broadcast may have been played but not yet registered with the scene, we need to force a stop
@@ -1493,7 +1545,7 @@
 		if (url)
 			url->vals = gf_malloc(sizeof(SFURL));
 		if (!url || !url->vals) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_COMPTIME, ("Terminal Failed to allocate VR proto\n"));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_COMPTIME, ("Compositor Failed to allocate VR proto\n"));
 			return NULL;
 		}
 		url->count=1;
@@ -1507,13 +1559,21 @@
 	return node;
 }
 
+void transform2d_set_untransform(GF_Node *node);
 
-static void create_movie(GF_Scene *scene, GF_Node *root, const char *tr_name, const char *texture_name, const char *name_geo)
+static void create_movie(GF_Scene *scene, GF_Node *root, const char *tr_name, const char *texture_name, const char *name_geo, Bool is_untransform)
 {
 	M_MovieTexture *mt;
 	GF_Node *n1, *n2;
 
 	/*create a shape and bitmap node*/
+	if (is_untransform) {
+		n2 = is_create_node(scene->graph, TAG_MPEG4_Transform2D, NULL);
+		transform2d_set_untransform(n2);
+		gf_node_list_add_child( &((GF_ParentNode *)root)->children, n2);
+		gf_node_register(n2, root);
+		root = n2;
+	}
 	n2 = is_create_node(scene->graph, TAG_MPEG4_Transform2D, tr_name);
 	gf_node_list_add_child( &((GF_ParentNode *)root)->children, n2);
 	gf_node_register(n2, root);
@@ -1532,7 +1592,7 @@
 	((M_Appearance *)n2)->texture = (GF_Node *)mt;
 	gf_node_register((GF_Node *)mt, n2);
 
-	if (scene->srd_type) {
+	if (scene->srd_type && !is_untransform) {
 		GF_Node *app = n2;
 
 		if (scene->vr_type) {
@@ -1548,7 +1608,7 @@
 		((M_Material2D *)n2)->filled = GF_TRUE;
 		((M_Appearance *)app)->material = n2;
 		gf_node_register(n2, app);
-	} else if (scene->vr_type) {
+	} else if (scene->vr_type && !is_untransform) {
 		n2 = is_create_node(scene->graph, TAG_MPEG4_Sphere, name_geo);
 		((M_Shape *)n1)->geometry = n2;
 		gf_node_register(n2, n1);
@@ -1586,7 +1646,7 @@
 		gf_node_register(n1, NULL);
 		root = n1;
 
-		if (! scene->root_od->parentscene && !scene->compositor->dyn_filter_mode) {
+		if (! scene->root_od->parentscene && !scene->compositor->forced_alpha) {
 			n2 = is_create_node(scene->graph, TAG_MPEG4_Background2D, "DYN_BACK");
 			gf_node_list_add_child( &((GF_ParentNode *)n1)->children, n2);
 			gf_node_register(n2, n1);
@@ -1641,7 +1701,8 @@
 		gf_node_register(n2, n1);
 		gf_sg_route_new_to_callback(scene->graph, n2, 3/*"hitTexCoord_changed"*/, scene, scene_video_mouse_move);
 
-		create_movie(scene, n1, "TR1", "DYN_VIDEO1", "DYN_GEOM1");
+		create_movie(scene, n1, "TR1", "DYN_VIDEO1", "DYN_GEOM1", GF_FALSE);
+		create_movie(scene, n1, "TR_SUBT_IMG", "DYN_SUBT_IMG", "DYN_GEOM_SUBT_IMG", GF_TRUE);
 
 		if (! scene->vr_type) {
 			M_Transform2D *addon_tr;
@@ -1680,6 +1741,7 @@
 			addon_scene = (M_Inline *) is_create_node(scene->graph, TAG_MPEG4_Inline, "ADDON_SCENE");
 			gf_node_list_add_child( &((GF_ParentNode *)addon_layer)->children, (GF_Node*)addon_scene);
 			gf_node_register((GF_Node *)addon_scene, (GF_Node *)addon_layer);
+
 		}
 		//VR mode, add VR headup
 		else {
@@ -1779,7 +1841,7 @@
 			sprintf(szGeom, "DYN_GEOM%d", i+1);
 			n2 = gf_sg_find_node_by_name(scene->graph, szGeom);
 			if (!n2) {
-				create_movie(scene, n1, szName, szTex, szGeom);
+				create_movie(scene, n1, szName, szTex, szGeom, GF_FALSE);
 			}
 		}
 		assert(max_x>min_x);
@@ -1841,6 +1903,9 @@
 	} else {
 		mt = (M_MovieTexture *) gf_sg_find_node_by_name(scene->graph, "DYN_VIDEO1");
 		set_media_url(scene, &scene->visual_url, (GF_Node*)mt, &mt->url, GF_STREAM_VISUAL);
+
+		mt = (M_MovieTexture *) gf_sg_find_node_by_name(scene->graph, "DYN_SUBT_IMG");
+		set_media_url(scene, &scene->subs_url, (GF_Node*)mt, &mt->url, GF_STREAM_UNKNOWN);
 	}
 
 
@@ -1898,7 +1963,7 @@
 GF_EXPORT
 void gf_scene_set_addon_layout_info(GF_Scene *scene, u32 position, u32 size_factor) {}
 GF_EXPORT
-void gf_scene_select_main_addon(GF_Scene *scene, GF_ObjectManager *odm, Bool set_on, u32 current_clock_time) { }
+void gf_scene_select_main_addon(GF_Scene *scene, GF_ObjectManager *odm, Bool set_on, u64 absolute_clock_time) { }
 
 #endif	/*GPAC_DISABLE_VRML*/
 
@@ -1991,6 +2056,7 @@
 		scene->visual_url.OD_ID = 0;
 		scene->text_url.OD_ID = 0;
 		scene->dims_url.OD_ID = 0;
+		scene->subs_url.OD_ID = 0;
 		scene->force_size_set = 0;
 		//reset clock since we change service IDs, but request a PLAY from the current time
 		if (scene->root_od->ck) {
@@ -2033,10 +2099,19 @@
 	}
 
 
-	if (odm->state) {
-		if (check_odm_deactivate(&scene->audio_url, odm, gf_sg_find_node_by_name(scene->graph, "DYN_AUDIO1")) ) return;
-		if (check_odm_deactivate(&scene->visual_url, odm, gf_sg_find_node_by_name(scene->graph, "DYN_VIDEO1") )) return;
-		if (check_odm_deactivate(&scene->text_url, odm, gf_sg_find_node_by_name(scene->graph, "DYN_TEXT") )) return;
+	//check if we are asking to (de)select one of our active media
+	Bool pre_selected = GF_FALSE;
+	if (check_odm_deactivate(&scene->audio_url, odm, gf_sg_find_node_by_name(scene->graph, "DYN_AUDIO1")) ) pre_selected=GF_TRUE;
+	else if (check_odm_deactivate(&scene->visual_url, odm, gf_sg_find_node_by_name(scene->graph, "DYN_VIDEO1") )) pre_selected=GF_TRUE;
+	else if (check_odm_deactivate(&scene->text_url, odm, gf_sg_find_node_by_name(scene->graph, "DYN_TEXT") )) pre_selected=GF_TRUE;
+	else if (check_odm_deactivate(&scene->subs_url, odm, gf_sg_find_node_by_name(scene->graph, "DYN_SUBT_IMG") )) pre_selected=GF_TRUE;
+	if (pre_selected) {
+		if (odm->state) {
+			gf_odm_stop(odm, GF_FALSE);
+		} else {
+			gf_odm_play(odm);
+		}
+		return;
 	}
 
 
@@ -2120,7 +2195,7 @@
 	}
 }
 
-void gf_scene_select_main_addon(GF_Scene *scene, GF_ObjectManager *odm, Bool set_on, u32 current_clock_time)
+void gf_scene_select_main_addon(GF_Scene *scene, GF_ObjectManager *odm, Bool set_on, u64 absolute_clock_time)
 {
 	GF_DOM_Event devt;
 	M_Inline *dscene = (M_Inline *) gf_sg_find_node_by_name(scene->graph, scene->compositor->dbgpvr ? "ADDON_SCENE" : "PVR_SCENE");
@@ -2144,7 +2219,7 @@
 		//main addon is vod not live, store clock
 		if (! odm->timeshift_depth && !scene->sys_clock_at_main_activation) {
 			scene->sys_clock_at_main_activation = gf_sys_clock();
-			scene->obj_clock_at_main_activation = current_clock_time;
+			scene->obj_clock_at_main_activation = absolute_clock_time;
 		}
 
 
@@ -2161,6 +2236,7 @@
 		odm_activate(&scene->audio_url, gf_sg_find_node_by_name(scene->graph, "DYN_AUDIO1"));
 		odm_activate(&scene->visual_url, gf_sg_find_node_by_name(scene->graph, "DYN_VIDEO1"));
 		odm_activate(&scene->text_url, gf_sg_find_node_by_name(scene->graph, "DYN_TEXT"));
+		odm_activate(&scene->subs_url, gf_sg_find_node_by_name(scene->graph, "DYN_SUBT_IMG"));
 
 		gf_sg_vrml_mf_reset(&dscene->url, GF_SG_VRML_MFURL);
 		gf_node_changed((GF_Node *)dscene, NULL);
@@ -2272,7 +2348,7 @@
 
 				//we're timeshifting through the main addon, activate it
 				if (from_time < -1) {
-					gf_scene_select_main_addon(scene, odm, GF_TRUE, gf_clock_time(ck));
+					gf_scene_select_main_addon(scene, odm, GF_TRUE, gf_clock_time_absolute(ck) );
 
 					/*no timeshift, this is a VoD associated with the live broadcast: get current time*/
 					if (! odm->timeshift_depth) {
@@ -2322,11 +2398,20 @@
 		gf_clock_reset(ck);
 
 		//used by SVG for JSAPIs..;
-		if (!scene->is_dynamic_scene) gf_clock_set_time(ck, 0);
+		if (!scene->is_dynamic_scene) gf_clock_set_time(ck, 0, 1000);
 	} else {
 		GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("Scene Restarting scene from current clock %d\n", gf_clock_time(ck) ));
 	}
 
+	//in case we sent a stop on objects directly (to stop scene), collect stop objects bound to scene
+	if (!scene->compositor->player && !gf_list_count(to_restart)) {
+		i=0;
+		while ((odm = (GF_ObjectManager*)gf_list_enum(scene->resources, &i))) {
+			if ((odm->state == GF_ODM_STATE_STOP) && odm->mo && odm->mo->num_open && gf_odm_shares_clock(odm, ck)) {
+				gf_list_add(to_restart, odm);
+			}
+		}
+	}
 
 	/*restart objects*/
 	i=0;
@@ -2645,7 +2730,7 @@
 	}
 
 	if (!check_buffering && scene) {
-		if (scene->root_od->ID) {
+		if (scene->root_od->pid_id) {
 			initialized = GF_TRUE;
 			if (scene->root_od->parentscene && (scene->root_od->state != GF_ODM_STATE_STOP)) return 0;
 		}
@@ -3031,7 +3116,7 @@
 	if (!addon) {
 		GF_SAFEALLOC(addon, GF_AddonMedia);
 		if (!addon) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_COMPTIME, ("Terminal Failed to allocate media addon\n"));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_COMPTIME, ("Compositor Failed to allocate media addon\n"));
 			return;
 		}
 		addon->timeline_id = addon_info->timeline_id;

gpac-2.0.0.tar.gz/src/compositor/scene_node_init.c -> gpac-2.2.0.tar.gz/src/compositor/scene_node_init.c Changed

gpac-2.0.0.tar.gz/src/compositor/scene_ns.c -> gpac-2.2.0.tar.gz/src/compositor/scene_ns.c Changed

@@ -333,6 +333,9 @@
 			scene->compositor->audio_renderer->scene_ready = GF_FALSE;
 		}
 	}
+	if (gf_filter_pid_is_sparse(pid)) {
+		odm->flags |= GF_ODM_IS_SPARSE;
+	}
 
 	//register PID with ODM, but don't call setup object
 	gf_odm_register_pid(odm, pid, GF_TRUE);
@@ -534,6 +537,8 @@
 	if (frag) frag0 = '#';
 	if (!odm->scene_ns->source_filter) {
 		Bool remove_scene=GF_FALSE;
+		Bool remove_filter=GF_FALSE;
+		GF_Compositor *compositor = scene->compositor;
 		GF_Scene *target_scene = odm->subscene ? NULL : odm->parentscene;
 
 		gf_filter_lock_all(scene->compositor->filter, GF_FALSE);
@@ -549,6 +554,9 @@
 				}
 			}
 		}
+
+		if (compositor->player && !odm->parentscene) remove_filter = GF_TRUE;
+
 		if (odm->mo) odm->mo->connect_state = MO_CONNECT_FAILED;
 		odm->skip_disconnect_state = 1;
 		//prevent scene from being disconnected - this can happen if a script catches the event and triggers a disonnection of the parent scene
@@ -566,6 +574,10 @@
 		} else {
 			gf_filter_post_task(scene->compositor->filter, scene_ns_remove_object, odm, "remove_odm");
 		}
+		if (remove_filter) {
+			gf_filter_remove(compositor->filter);
+			compositor->check_eos_state = 3;
+		}
 		return;
 	}
     //make sure we only connect this filter to ourselves

gpac-2.0.0.tar.gz/src/compositor/texturing.c -> gpac-2.2.0.tar.gz/src/compositor/texturing.c Changed

@@ -24,7 +24,6 @@
 */
 
 #include "texturing.h"
-#include <gpac/options.h>
 
 #include "nodes_stacks.h"
 
@@ -167,7 +166,7 @@
 {
 	if (!txh->is_open) return;
 	gf_sc_texture_release_stream(txh);
-	txh->stream_finished = 0;
+	txh->stream_finished = GF_FALSE;
 	gf_mo_restart(txh->stream);
 }
 
@@ -213,10 +212,12 @@
 
 	if (!txh->stream) {
 		txh->data = NULL;
+		txh->frame_ifce = NULL;
 		return;
 	}
 	if (txh->stream->config_changed) {
 		txh->data = NULL;
+		txh->frame_ifce = NULL;
 	}
 
 	/*already refreshed*/
@@ -308,8 +309,8 @@
 		}
 		return;
 	}
-	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("Texture %p Updated new frame at clock time %d (%d ms) time %u ms\n", txh, gf_clock_time(txh->stream->odm->ck), gf_sys_clock(), ts));
-	txh->stream_finished = 0;
+	GF_LOG(GF_LOG_INFO, GF_LOG_COMPTIME, ("Texture %p Updated new frame at clock time %u (%u ms) time %u ms\n", txh, gf_clock_time(txh->stream->odm->ck), gf_sys_clock(), ts));
+	txh->stream_finished = GF_FALSE;
 	txh->needs_release = 1;
 	txh->last_frame_time = ts;
 	txh->size = size;

gpac-2.0.0.tar.gz/src/compositor/texturing_gl.c -> gpac-2.2.0.tar.gz/src/compositor/texturing_gl.c Changed

gpac-2.0.0.tar.gz/src/compositor/visual_manager.h -> gpac-2.2.0.tar.gz/src/compositor/visual_manager.h Changed

gpac-2.0.0.tar.gz/src/compositor/visual_manager_2d.c -> gpac-2.2.0.tar.gz/src/compositor/visual_manager_2d.c Changed

@@ -267,6 +267,8 @@
 	visual->has_modif = 0;
 	visual->has_overlays = 0;
 
+	memset(&visual->frame_bounds, 0, sizeof(GF_IRect));
+	
 	visual_2d_setup_projection(visual, tr_state);
 	if (!visual->top_clipper.width || !visual->top_clipper.height)
 		return GF_OK;
@@ -375,6 +377,7 @@
 #define ra_is_empty(ra) (!((ra)->count))
 
 /*adds @rc2 to @rc1 - the new @rc1 contains the old @rc1 and @rc2*/
+GF_EXPORT
 void gf_irect_union(GF_IRect *rc1, GF_IRect *rc2)
 {
 	if (!rc1->width || !rc1->height) {
@@ -721,7 +724,8 @@
 		if (!hyb_force_redraw && !hyb_force_background) {
 #ifndef GPAC_DISABLE_3D
 			//force canvas draw
-			visual->nb_objects_on_canvas_since_last_ogl_flush = 1;
+			if ((visual==visual->compositor->visual) && visual->prev_hybgl_canvas_not_empty)
+				visual->nb_objects_on_canvas_since_last_ogl_flush = 1;
 #endif
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("Visual2D No changes found since last frame - skipping redraw\n"));
 			goto exit;
@@ -796,7 +800,8 @@
 		visual->has_modif=0;
 #ifndef GPAC_DISABLE_3D
 		//force canvas flush
-		visual->nb_objects_on_canvas_since_last_ogl_flush = 1;
+		if ((visual==visual->compositor->visual) && visual->prev_hybgl_canvas_not_empty)
+			visual->nb_objects_on_canvas_since_last_ogl_flush = 1;
 #endif
 		goto exit;
 	}
@@ -819,6 +824,13 @@
 
 	visual->draw_node_index = 0;
 
+#ifndef GPAC_DISABLE_3D
+	//consider nothing is drawn on hyblg canvas. If any of the refresh area(s) triggers painting on the canvas
+	//the variable will be set while flushing
+	if (visual==visual->compositor->visual)
+		visual->prev_hybgl_canvas_not_empty = GF_FALSE;
+#endif
+
 	ctx = visual->context;
 	while (ctx && ctx->drawable) {

gpac-2.0.0.tar.gz/src/compositor/visual_manager_2d_draw.c -> gpac-2.2.0.tar.gz/src/compositor/visual_manager_2d_draw.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -27,7 +27,6 @@
 #include "drawable.h"
 #include "nodes_stacks.h"
 #include "texturing.h"
-#include <gpac/options.h>
 
 //#define SKIP_DRAW
 
@@ -55,8 +54,8 @@
 #endif
 	if (! visual->CheckAttached(visual) ) return;
 
-	if (!BackColor && !visual->offscreen && !visual->compositor->dyn_filter_mode) {
-		if ( !(visual->compositor->init_flags & GF_TERM_WINDOW_TRANSPARENT)) {
+	if (!BackColor && !visual->offscreen && !visual->compositor->forced_alpha) {
+		if ( !(visual->compositor->init_flags & GF_VOUT_WINDOW_TRANSPARENT)) {
 			BackColor = visual->compositor->back_color;
 		}
 	}
@@ -86,7 +85,7 @@
 	gf_path_del(cliper);
 }
 
-static void visual_2d_fill_path(GF_VisualManager *visual, DrawableContext *ctx, GF_EVGStencil * stencil, GF_TraverseState *tr_state, Bool is_erase)
+void visual_2d_fill_path(GF_VisualManager *visual, DrawableContext *ctx, GF_EVGStencil * stencil, GF_TraverseState *tr_state, Bool is_erase)
 {
 	Bool has_modif = GF_FALSE;
 	GF_IRect clip;
@@ -129,7 +128,7 @@
 		}
 	}
 #ifndef GPAC_DISABLE_3D
-	if (!is_erase)
+	if (!is_erase && (visual==visual->compositor->visual))
 		visual->nb_objects_on_canvas_since_last_ogl_flush++;
 #endif
 	if (has_modif) {

gpac-2.0.0.tar.gz/src/compositor/visual_manager_3d.c -> gpac-2.2.0.tar.gz/src/compositor/visual_manager_3d.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Compositor sub-project
@@ -28,7 +28,6 @@
 #include "visual_manager.h"
 #include "texturing.h"
 #include "nodes_stacks.h"
-#include <gpac/options.h>
 
 #ifndef GPAC_DISABLE_3D
 
@@ -445,9 +444,9 @@
 			/*if composite visual, clear with alpha = 0*/
 			if (tr_state->visual==tr_state->visual->compositor->visual) {
 				alpha = FIX_ONE;
-				if (tr_state->visual->compositor->init_flags & GF_TERM_WINDOW_TRANSPARENT) {
+				if (tr_state->visual->compositor->init_flags & GF_VOUT_WINDOW_TRANSPARENT) {
 					alpha = 0;
-				} else if (tr_state->visual->compositor->dyn_filter_mode) {
+				} else if (tr_state->visual->compositor->forced_alpha) {
 					alpha = 0;
 				}
 			}
@@ -1963,6 +1962,31 @@
 
 void visual_3d_draw(GF_TraverseState *tr_state, GF_Mesh *mesh)
 {
+	if (mesh && tr_state->visual->compositor->clipframe) {
+		void gf_mx_apply_bbox_4x4(GF_Matrix *mx, GF_BBox *box);
+		GF_Matrix mx;
+		GF_BBox bounds = mesh->bounds;
+		gf_mx_copy(mx, tr_state->camera->modelview);
+		gf_mx_add_matrix(&mx, &tr_state->model_matrix);
+
+		gf_mx_apply_bbox(&mx, &bounds);
+		//get persp-transformed bounds, all coords will be in NDC -1,1
+		gf_mx_apply_bbox_4x4(&tr_state->camera->projection, &bounds);
+
+		GF_Rect rc;
+		rc.x = gf_mulfix(bounds.min_edge.x/2, tr_state->camera->vp.width);
+		rc.y = gf_mulfix(bounds.max_edge.y/2, tr_state->camera->vp.height);
+		rc.width = gf_mulfix(bounds.max_edge.x/2, tr_state->camera->vp.width) - rc.x;
+		rc.height = rc.y - gf_mulfix(bounds.min_edge.y/2, tr_state->camera->vp.height);
+		//no need to apply vp x/y offset, we are already centered
+		GF_IRect irc = gf_rect_pixelize(&rc);
+		if (!tr_state->visual->surf_rect.width) {
+			rc = gf_rect_center(INT2FIX(tr_state->visual->compositor->display_width), INT2FIX((tr_state->visual->compositor->display_height)));
+			tr_state->visual->surf_rect = gf_rect_pixelize(&rc);
+		}
+		gf_irect_intersect(&irc, &tr_state->visual->surf_rect);
+		gf_irect_union(&tr_state->visual->frame_bounds, &irc);
+	}
 	if (mesh->mesh_type) {
 		if (visual_3d_setup_material(tr_state, mesh->mesh_type, NULL)) {
 			visual_3d_mesh_paint(tr_state, mesh);

gpac-2.0.0.tar.gz/src/compositor/visual_manager_3d_gl.c -> gpac-2.2.0.tar.gz/src/compositor/visual_manager_3d_gl.c Changed

gpac-2.0.0.tar.gz/src/crypto/g_crypt.c -> gpac-2.2.0.tar.gz/src/crypto/g_crypt.c Changed

gpac-2.0.0.tar.gz/src/evg/rast_soft.h -> gpac-2.2.0.tar.gz/src/evg/rast_soft.h Changed

gpac-2.0.0.tar.gz/src/evg/stencil.c -> gpac-2.2.0.tar.gz/src/evg/stencil.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / software 2D rasterizer module
@@ -1722,52 +1722,62 @@
 
 u32 get_pix_argb(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(*(pix) & 0xFF, *(pix+1) & 0xFF, *(pix+2) & 0xFF, *(pix+3) & 0xFF);
 }
 u32 get_pix_rgba(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(*(pix+3) & 0xFF, *(pix) & 0xFF, *(pix+1) & 0xFF, *(pix+2) & 0xFF);
 }
+u32 get_pix_grba(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	return GF_COL_ARGB(*(pix+3) & 0xFF, *(pix+1) & 0xFF, *(pix) & 0xFF, *(pix+2) & 0xFF);
+}
 u32 get_pix_abgr(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(*(pix) & 0xFF, *(pix+3) & 0xFF, *(pix+2) & 0xFF, *(pix+1) & 0xFF);
 }
 u32 get_pix_bgra(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(*(pix+3) & 0xFF, *(pix+2) & 0xFF, *(pix+1) & 0xFF, *(pix) & 0xFF);
 }
 u32 get_pix_rgbx(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(0xFF, *(pix) & 0xFF, *(pix+1) & 0xFF, *(pix+2) & 0xFF);
 }
 u32 get_pix_xrgb(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(0xFF, *(pix+1) & 0xFF, *(pix+2) & 0xFF, *(pix+3) & 0xFF);
 }
 u32 get_pix_xbgr(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(0xFF, *(pix+3) & 0xFF, *(pix+2) & 0xFF, *(pix+1) & 0xFF);
 }
 u32 get_pix_bgrx(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(0xFF, *(pix+2) & 0xFF, *(pix+1) & 0xFF, *(pix) & 0xFF);
 }
 u32 get_pix_rgb_24(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(0xFF, *pix & 0xFF, *(pix+1) & 0xFF, *(pix+2) & 0xFF);
 }
+u32 get_pix_gbr_24(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	return GF_COL_ARGB(0xFF, *(pix+1) & 0xFF, *(pix+2) & 0xFF, *pix & 0xFF);
+}
 u32 get_pix_bgr_24(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	return GF_COL_ARGB(0xFF, *(pix+2) & 0xFF, * (pix+1) & 0xFF, *pix & 0xFF);
 }
 u32 get_pix_444(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
@@ -1790,7 +1800,7 @@
 }
 u32 get_pix_565(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	u32 r = (pix0>>3) & 0x1f;
 	u32 g = (pix0)&0x7;
 	g<<=3;
@@ -1798,16 +1808,32 @@
 	u32 b = pix1 & 0x1f;
 	return GF_COL_ARGB(0xFF, (r << 3), (g << 2), (b << 3));
 }
+u32 get_pix_palette_alpha(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u32 val = *pix;
+	if (val >= _this->palette_colors) return GF_COL_ARGB(0xFF, 0xFF, 0xFF, 0xFF);
+	pix = (u8*)_this->palette + val*4;
+	return GF_COL_ARGB(pix_this->pidx_a, pix_this->pidx_r, pix_this->pidx_g, pix_this->pidx_b);
+}
+u32 get_pix_palette(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u32 val = *pix;
+	if (val >= _this->palette_colors) return GF_COL_ARGB(0xFF, 0xFF, 0xFF, 0xFF);
+	pix = (u8*)_this->palette + val*3;
+	return GF_COL_ARGB(0xFF, pix_this->pidx_r, pix_this->pidx_g, pix_this->pidx_b);
+}
 u32 get_pix_grey(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	u8 val = *pix;
 	return GF_COL_ARGB(0xFF, val, val, val);
 }
 u32 get_pix_alphagrey(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
 	u8 a, g;
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	a = *pix;
 	g = *(pix+1);
 	return GF_COL_ARGB(a, g, g, g);
@@ -1815,7 +1841,7 @@
 u32 get_pix_greyalpha(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
 {
 	u8 a, g;
-	char *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
+	u8 *pix = _this->pixels + y * _this->stride + _this->Bpp*x;
 	g = *pix;
 	a = *(pix+1);
 	return GF_COL_ARGB(a, g, g, g);
@@ -1833,6 +1859,10 @@
 #define GET_LE_10BIT_AS_8(_ptr) ( (((u16)(_ptr)1)<<8 | (u16)(_ptr)0 ) >> 2 )
 #define GET_LE_10BIT_AS_16(_ptr) ( (((u16)(_ptr)1)<<8 | (u16)(_ptr)0 ) << 6 )
 
+//#define GET_LE_10BIT_LEFT_AS_8(_ptr) ( (((u16)(_ptr)1)<<8 | (u16)(_ptr)0 ) >> 8 )
+#define GET_LE_10BIT_LEFT_AS_8(_ptr) (_ptr1 )
+#define GET_LE_10BIT_LEFT_AS_16(_ptr) ( (((u16)(_ptr)1)<<8 | (u16)(_ptr)0 ) & 0xFFC0 )
+
 #define GET_BE_10BIT_AS_8(_ptr) ( (*(u16 *)(_ptr)) >> 2 )
 #define GET_BE_10BIT_AS_16(_ptr) ( (*(u16 *)(_ptr)) << 6 )
 
@@ -1841,6 +1871,10 @@
 #define GET_LE_10BIT_AS_8(_ptr) ( (*(u16 *)(_ptr)) >> 2 )
 #define GET_LE_10BIT_AS_16(_ptr) ( (*(u16 *)(_ptr)) << 6 )
 
+#define GET_LE_10BIT_LEFT_AS_8(_ptr) ( (*(u16 *)(_ptr)) >> 8 )
+#define GET_LE_10BIT_LEFT_AS_16(_ptr) ( (*(u16 *)(_ptr)) & 0xFFC0 )
+
+
 #define GET_BE_10BIT_AS_8(_ptr) ( (((u16)(_ptr)0)<<8 | (u16)(_ptr)1 ) >> 2 )
 #define GET_BE_10BIT_AS_16(_ptr) ( (((u16)(_ptr)0)<<8 | (u16)(_ptr)1 ) << 6 )
 
@@ -2046,8 +2080,165 @@
 	u8 luma = (x%2) ? pY3 : pY1;
 	return GF_COL_ARGB(0xFF, luma, u, v);
 }
+u32 get_pix_yuv444_10(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u8 vy, vu, vv;
+	u32 val;
+	u8 *p_src = _this->pixels + y * _this->stride + x*4;
+	val = p_src3; val<<=8;
+	val |= p_src2; val<<=8;
+	val |= p_src1; val<<=8;
+	val |= p_src0;
+
+	vu = (u8) ( ((val>>2) & 0x3FF) >> 2);
+	vy = (u8) ( ((val>>12) & 0x3FF) >> 2);
+	vv = (u8) ( ((val>>22)) >> 2);
 
+	return GF_COL_ARGB(0xFF, vy, vu, vv);
+}
+u64 get_pix_yuv444_10_wide(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u16 vy, vu, vv;
+	u32 val;
+	u8 *p_src = _this->pixels + y * _this->stride + x*4;
+	val = p_src3; val<<=8;
+	val |= p_src2; val<<=8;
+	val |= p_src1; val<<=8;
+	val |= p_src0;
+
+	vu = (u16) ( ((val>>2) & 0x3FF) << 6);
+	vy = (u16) ( ((val>>12) & 0x3FF) << 6);
+	vv = (u16) ( ((val>>22)) << 6);
+	return GF_COLW_ARGB(0xFFFF, vy, vu, vv);
+}
 
+u32 get_pix_v210(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u8 vy, vu, vv;
+	u32 val1, val2;
+	u32 x_offset = x%6;
+	x-=x_offset;
+	u8 *p_src = _this->pixels + y * _this->stride + (x * 16) / 6;
+	if (x_offset>=4) p_src += 8;
+	else if (x_offset>=2) p_src += 4;
+
+	val1 = p_src3; val1<<=8;
+	val1 |= p_src2; val1<<=8;
+	val1 |= p_src1; val1<<=8;
+	val1 |= p_src0;
+
+	if (x_offset==0) {
+		vu = (u8) ( ((val1) & 0x3FF) >> 2);
+		vy = (u8) ( ((val1>>10) & 0x3FF) >> 2);
+		vv = (u8) ( ((val1>>20) & 0x3FF) >> 2);
+	} else {
+		val2 = p_src7; val2<<=8;
+		val2 |= p_src6; val2<<=8;
+		val2 |= p_src5; val2<<=8;
+		val2 |= p_src4;
+
+		if (x_offset==1) {
+			vu = (u8) ( ((val1) & 0x3FF) >> 2);
+			vv = (u8) ( ((val1>>20) & 0x3FF) >> 2);
+			vy = (u8) ( ((val2) & 0x3FF) >> 2);
+		} else if (x_offset==2) {
+			vu = (u8) ( ((val1>>10) & 0x3FF) >> 2);
+			vy = (u8) ( ((val1>>20) & 0x3FF) >> 2);
+			vv = (u8) ( ((val2) & 0x3FF) >> 2);
+		} else if (x_offset==3) {
+			vu = (u8) ( ((val1>>10) & 0x3FF) >> 2);
+			vv = (u8) ( ((val2) & 0x3FF) >> 2);
+			vy = (u8) ( ((val2>>10) & 0x3FF) >> 2);
+		} else if (x_offset==4) {
+			vu = (u8) ( ((val1>>20) & 0x3FF) >> 2);
+			vy = (u8) ( ((val2) & 0x3FF) >> 2);
+			vv = (u8) ( ((val2>>10) & 0x3FF) >> 2);
+		} else {
+			vu = (u8) ( ((val1>>20) & 0x3FF) >> 2);
+			vv = (u8) ( ((val2>>10) & 0x3FF) >> 2);
+			vy = (u8) ( ((val2>>20) & 0x3FF) >> 2);
+		}
+	}
+	return GF_COL_ARGB(0xFF, vy, vu, vv);
+}
+u64 get_pix_v210_wide(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u16 vy, vu, vv;
+	u32 val1, val2;
+	u32 x_offset = x%6;
+	x-=x_offset;
+	u8 *p_src = _this->pixels + y * _this->stride + (x * 16) / 6;
+	if (x_offset>=4) p_src += 8;
+	else if (x_offset>=2) p_src += 4;
+
+	val1 = p_src3; val1<<=8;
+	val1 |= p_src2; val1<<=8;
+	val1 |= p_src1; val1<<=8;
+	val1 |= p_src0;
+
+	if (x_offset==0) {
+		vu = (u16) ( ((val1) & 0x3FF) << 6);
+		vy = (u16) ( ((val1>>10) & 0x3FF) << 6);
+		vv = (u16) ( ((val1>>20) & 0x3FF) << 6);
+	} else {
+		val2 = p_src7; val2<<=8;
+		val2 |= p_src6; val2<<=8;
+		val2 |= p_src5; val2<<=8;
+		val2 |= p_src4;
+
+		if (x_offset==1) {
+			vu = (u16) ( ((val1) & 0x3FF) << 6);
+			vv = (u16) ( ((val1>>20) & 0x3FF) << 6);
+			vy = (u16) ( ((val2) & 0x3FF) << 6);
+		} else if (x_offset==2) {
+			vu = (u16) ( ((val1>>10) & 0x3FF) << 6);
+			vy = (u16) ( ((val1>>20) & 0x3FF) << 6);
+			vv = (u16) ( ((val2) & 0x3FF) << 6);
+		} else if (x_offset==3) {
+			vu = (u16) ( ((val1>>10) & 0x3FF) << 6);
+			vv = (u16) ( ((val2) & 0x3FF) << 6);
+			vy = (u16) ( ((val2>>10) & 0x3FF) << 6);
+		} else if (x_offset==4) {
+			vu = (u16) ( ((val1>>20) & 0x3FF) << 6);
+			vy = (u16) ( ((val2) & 0x3FF) << 6);
+			vv = (u16) ( ((val2>>10) & 0x3FF) << 6);
+		} else {
+			vu = (u16) ( ((val1>>20) & 0x3FF) << 6);
+			vv = (u16) ( ((val2>>10) & 0x3FF) << 6);
+			vy = (u16) ( ((val2>>20) & 0x3FF) << 6);
+		}
+	}
+	return GF_COLW_ARGB(0xFFFF, vy, vu, vv);
+}
+
+u32 get_pix_yuyv_10(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u8 vy, vu, vv;
+	Bool odd = x%2;
+	u8 *p_src = _this->pixels + y * _this->stride + (x/2)*8;
+
+	vu = GET_LE_10BIT_LEFT_AS_8(p_src + _this->off_u);
+	if (odd)
+		vy = GET_LE_10BIT_LEFT_AS_8(p_src + _this->off_y+4);
+	else
+		vy = GET_LE_10BIT_LEFT_AS_8(p_src + _this->off_y);
+	vv = GET_LE_10BIT_LEFT_AS_8(p_src + _this->off_v);
+	return GF_COL_ARGB(0xFF, vy, vu, vv);
+}
+u64 get_pix_yuyv_10_wide(EVG_Texture *_this, u32 x, u32 y, EVGRasterCtx *ctx)
+{
+	u16 vy, vu, vv;
+	u32 odd = x%2;
+	u8 *p_src = _this->pixels + y * _this->stride + (x/2)*8;
+
+	vu = GET_LE_10BIT_LEFT_AS_16(p_src + _this->off_u);
+	if (odd)
+		vy = GET_LE_10BIT_LEFT_AS_16(p_src + _this->off_y+4);
+	else
+		vy = GET_LE_10BIT_LEFT_AS_16(p_src + _this->off_y);
+	vv = GET_LE_10BIT_LEFT_AS_16(p_src + _this->off_v);
+	return GF_COLW_ARGB(0xFFFF, vy, vu, vv);
+}
 u64 default_get_pixel_wide(struct __evg_texture *_this, u32 x, u32 y, EVGRasterCtx *rctx)
 {
 	return evg_col_to_wide( _this->tx_get_pixel(_this, x, y, rctx) );
@@ -2109,7 +2300,13 @@
 		_this->tx_get_pixel = get_pix_565;
 		return;
 	case GF_PIXEL_GREYSCALE:
-		_this->tx_get_pixel = get_pix_grey;
+		if (_this->palette && _this->palette_colors) {
+			if (_this->palette_comp==4)
+				_this->tx_get_pixel = get_pix_palette_alpha;
+			else
+				_this->tx_get_pixel = get_pix_palette;
+		} else
+			_this->tx_get_pixel = get_pix_grey;
 		return;
 	case GF_PIXEL_ALPHAGREY:
 		_this->tx_get_pixel = get_pix_alphagrey;
@@ -2185,9 +2382,58 @@
 		_this->tx_get_pixel = get_pix_rgba;
 		_this->is_transparent = 1;
 		break;
+	case GF_PIXEL_UYVA444_PACK:
+		_this->tx_get_pixel = get_pix_grba;
+		_this->is_transparent = 1;
+		break;
 	case GF_PIXEL_YUV444_PACK:
 		_this->tx_get_pixel = get_pix_rgb_24;
 		break;
+	case GF_PIXEL_VYU444_PACK:
+		_this->tx_get_pixel = get_pix_gbr_24;
+		break;
+	case GF_PIXEL_YUV444_10_PACK:
+		_this->tx_get_pixel = get_pix_yuv444_10;
+		_this->tx_get_pixel_wide = get_pix_yuv444_10_wide;
+		_this->is_wide = 1;
+		break;
+	case GF_PIXEL_V210:
+		_this->tx_get_pixel = get_pix_v210;
+		_this->tx_get_pixel_wide = get_pix_v210_wide;
+		_this->is_wide = 1;
+		break;
+	case GF_PIXEL_YUYV_10:
+		_this->off_y=0;
+		_this->off_u=2;
+		_this->off_v=4;
+		_this->tx_get_pixel = get_pix_yuyv_10;
+		_this->tx_get_pixel_wide = get_pix_yuyv_10_wide;
+		_this->is_wide = 1;
+		break;
+	case GF_PIXEL_YVYU_10:
+		_this->off_y=0;
+		_this->off_u=4;
+		_this->off_v=2;
+		_this->tx_get_pixel = get_pix_yuyv_10;
+		_this->tx_get_pixel_wide = get_pix_yuyv_10_wide;
+		_this->is_wide = 1;
+		break;
+	case GF_PIXEL_UYVY_10:
+		_this->off_y=2;
+		_this->off_u=0;
+		_this->off_v=4;
+		_this->tx_get_pixel = get_pix_yuyv_10;
+		_this->tx_get_pixel_wide = get_pix_yuyv_10_wide;
+		_this->is_wide = 1;
+		break;
+	case GF_PIXEL_VYUY_10:
+		_this->off_y=2;
+		_this->off_u=4;
+		_this->off_v=2;
+		_this->tx_get_pixel = get_pix_yuyv_10;
+		_this->tx_get_pixel_wide = get_pix_yuyv_10_wide;
+		_this->is_wide = 1;
+		break;
 	default:
 		return;
 	}
@@ -2250,6 +2496,8 @@
 
 	_this->pixels = NULL;
 	_this->is_yuv = GF_FALSE;
+	_this->palette = NULL;
+	_this->palette_colors = 0;
 
 	switch (pixelFormat) {
 	case GF_PIXEL_ARGB:
@@ -2304,14 +2552,39 @@
 		if (!stride)
 			stride = 4 * width;
 		break;
+
+	case GF_PIXEL_YUYV_10:
+	case GF_PIXEL_YVYU_10:
+	case GF_PIXEL_UYVY_10:
+	case GF_PIXEL_VYUY_10:
+		_this->is_yuv = GF_TRUE;
+		_this->Bpp = 2;
+		if (!stride)
+			stride = 4 * width;
+		break;
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
+		_this->Bpp = 4;
+		_this->is_yuv = GF_TRUE;
+		break;
+	case GF_PIXEL_YUV444_10_PACK:
 		_this->Bpp = 4;
 		_this->is_yuv = GF_TRUE;
 		break;
 	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
 		_this->Bpp = 3;
 		_this->is_yuv = GF_TRUE;
 		break;
+	case GF_PIXEL_V210:
+		_this->Bpp = 2;
+		_this->is_yuv = GF_TRUE;
+		if (!stride) {
+			stride = width;
+			while (stride % 48) stride++;
+			stride = stride * 16 / 6; //4 x 32 bits to represent 6 pixels
+		}
+		break;
 	default:
 		return GF_NOT_SUPPORTED;
 	}
@@ -2343,6 +2616,64 @@
 }
 
 GF_EXPORT
+GF_Err gf_evg_stencil_set_palette(GF_EVGStencil *stencil, const u8 *palette, u32 pix_fmt, u32 nb_cols)
+{
+	EVG_Texture *_this = (EVG_Texture *) stencil;
+	if (!_this || (_this->type != GF_STENCIL_TEXTURE) || !palette || !nb_cols)
+		return GF_BAD_PARAM;
+	if (_this->pixel_format != GF_PIXEL_GREYSCALE) return GF_BAD_PARAM;
+	_this->palette = palette;
+	_this->palette_colors = nb_cols;
+	_this->palette_pfmt = pix_fmt;
+	switch (pix_fmt) {
+	case GF_PIXEL_RGB:
+		_this->palette_comp = 3;
+		_this->pidx_r=0;
+		_this->pidx_g=1;
+		_this->pidx_b=2;
+		break;
+	case GF_PIXEL_BGR:
+		_this->palette_comp = 3;
+		_this->pidx_r=2;
+		_this->pidx_g=1;
+		_this->pidx_b=0;
+		break;
+	case GF_PIXEL_RGBA:
+		_this->palette_comp = 4;
+		_this->pidx_r=0;
+		_this->pidx_g=1;
+		_this->pidx_b=2;
+		_this->pidx_a=3;
+		break;
+	case GF_PIXEL_ARGB:
+		_this->palette_comp = 4;
+		_this->pidx_r=1;
+		_this->pidx_g=2;
+		_this->pidx_b=3;
+		_this->pidx_a=0;
+		break;
+	case GF_PIXEL_ABGR:
+		_this->palette_comp = 4;
+		_this->pidx_r=3;
+		_this->pidx_g=2;
+		_this->pidx_b=1;
+		_this->pidx_a=0;
+		break;
+	case GF_PIXEL_BGRA:
+		_this->palette_comp = 4;
+		_this->pidx_r=2;
+		_this->pidx_g=1;
+		_this->pidx_b=0;
+		_this->pidx_a=3;
+		break;
+	default:
+		_this->palette = NULL;
+		_this->palette_colors = 0;
+		return GF_NOT_SUPPORTED;
+	}
+	return GF_OK;
+}
+GF_EXPORT
 GF_Err gf_evg_stencil_get_texture_planes(GF_EVGStencil *stencil, u8 **pY_or_RGB, u8 **pU, u8 **pV, u8 **pA, u32 *stride, u32 *stride_uv)
 {
 	EVG_Texture *_this = (EVG_Texture *) stencil;
@@ -2536,6 +2867,15 @@
 	return gf_evg_stencil_get_pixel_intern((EVG_Texture *)st, x, y, GF_TRUE);
 }
 
+u32 gf_evg_stencil_get_pixel_fast(GF_EVGStencil *st, s32 x, s32 y)
+{
+	return ((EVG_Texture *)st)->tx_get_pixel((EVG_Texture *)st, x, y, NULL);
+}
+u64 gf_evg_stencil_get_pixel_wide_fast(GF_EVGStencil *st, s32 x, s32 y)
+{
+	return ((EVG_Texture *)st)->tx_get_pixel_wide((EVG_Texture *)st, x, y, NULL);
+}
+
 
 
 static u64 gf_evg_stencil_get_pixel_wide_intern(EVG_Texture *_this, s32 x, s32 y, Bool want_yuv)

gpac-2.0.0.tar.gz/src/evg/surface.c -> gpac-2.2.0.tar.gz/src/evg/surface.c Changed

@@ -275,6 +275,22 @@
 		surf->idx_g=1;
 		surf->idx_b=2;
 		break;
+	case GF_PIXEL_UYVA444_PACK:
+		surf->idx_a=3;
+		surf->idx_r=1;
+		surf->idx_g=0;
+		surf->idx_b=2;
+		break;
+	case GF_PIXEL_YUV444_PACK:
+		surf->idx_r=0;
+		surf->idx_g=1;
+		surf->idx_b=2;
+		break;
+	case GF_PIXEL_VYU444_PACK:
+		surf->idx_r=1;
+		surf->idx_g=2;
+		surf->idx_b=0;
+		break;
 	case GF_PIXEL_BGRA:
 		surf->idx_a=3;
 		surf->idx_r=2;
@@ -383,13 +399,22 @@
 		surf->not_8bits = GF_TRUE;
 		break;
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 		surf->is_transparent = GF_TRUE;
 		BPP = 4;
 		break;
+	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
+		BPP = 3;
+		break;
 	default:
 		return GF_NOT_SUPPORTED;
 	}
 	if (!pitch_x) pitch_x = BPP;
+	if (!pitch_y) {
+		gf_pixel_get_size_info(pixelFormat, width, height, NULL, &pitch_y, NULL, NULL, NULL);
+	}
+
 	surf->pitch_x = pitch_x;
 	surf->pitch_y = pitch_y;
 	if (!surf->raster_ctx.stencil_pix_run || (surf->width != width)) {
@@ -578,7 +603,12 @@
 		return evg_surface_clear_yuv444p_10(surf, clear, color);
 
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 		return evg_surface_clear_argb(surf, clear, gf_evg_argb_to_ayuv(surf, color) );
+
+	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
+		return evg_surface_clear_rgb(surf, clear, gf_evg_argb_to_ayuv(surf, color) );
 	default:
 		return GF_BAD_PARAM;
 	}
@@ -760,6 +790,7 @@
 		}
 		break;
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 		surf->yuv_type = EVG_YUV;
 	case GF_PIXEL_ARGB:
 	case GF_PIXEL_RGBA:
@@ -801,6 +832,9 @@
 		}
 		break;
 
+	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
+		surf->yuv_type = EVG_YUV;
 	case GF_PIXEL_RGB:
 	case GF_PIXEL_BGR:
 		if (use_const) {

gpac-2.0.0.tar.gz/src/export.cpp -> gpac-2.2.0.tar.gz/src/export.cpp Changed

@@ -101,6 +101,8 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_parse_frac) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_gmtime) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_strnistr) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_getch) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_read_line_input) )
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_log_modify_tools_levels) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_log_set_tools_levels) )
@@ -118,6 +120,8 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_log) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_log_va_list) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_log_lt) )
+#else
+#pragma comment (linker, EXPORT_SYMBOL(gf_log_check_error) )
 #endif
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_fsize) )
@@ -273,8 +277,11 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_bs_write_byte) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_bs_write_u16_le) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_bs_write_u32_le) )
-
 #pragma comment (linker, EXPORT_SYMBOL(gf_bs_enable_emulation_byte_removal ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_bs_get_emulation_byte_removed ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_bs_read_utf8 ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_bs_write_utf8 ) )
+
 
 /* Thread */
 #pragma comment (linker, EXPORT_SYMBOL(gf_th_new) )
@@ -318,8 +325,6 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_sk_get_remote_address) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sk_setup_multicast) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sk_is_multicast_address) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_sk_send_wait) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_sk_receive_wait) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sk_receive_no_select) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sk_set_usec_wait) )
 
@@ -329,6 +334,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_url_free) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_url_get_resource_name) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_url_to_fs_path) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_url_is_relative) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_utc_time_since_1970) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_net_get_ntp) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_net_get_ntp_ts) )
@@ -344,6 +350,8 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_ntohl) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_ntohs) )
 
+#pragma comment (linker, EXPORT_SYMBOL(gf_blob_register) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_blob_unregister) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_blob_get) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_blob_release) )
 
@@ -353,20 +361,17 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_net_get_timezone) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_net_has_ipv6) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_net_is_ipv6) )
-
-#ifndef GPAC_DISABLE_CORE_TOOLS
 #pragma comment (linker, EXPORT_SYMBOL(gf_base64_encode) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_base64_decode) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_base16_encode) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_base16_decode) )
-#endif
-
 #pragma comment (linker, EXPORT_SYMBOL(gf_bin128_parse) )
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_token_get) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_token_get_line) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_token_find) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_token_get_strip) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_token_find_word) )
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_cfg_new) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_cfg_force_new) )
@@ -394,6 +399,9 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_opts_get_int) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_opts_get_filename) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_opts_default_shared_directory) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_opts_save) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_creds_check_password) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_creds_check_membership) )
 
 
 #ifndef GPAC_DISABLE_PLAYER
@@ -427,7 +435,6 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_lang_get_3cc) )
 
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
 #pragma comment (linker, EXPORT_SYMBOL(gf_dm_new) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dm_sess_new) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dm_sess_new_simple) )
@@ -490,7 +497,6 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_xml_dom_get_root_idx) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_xml_dom_detach_root) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_xml_parse_bit_sequence) )
-#endif
 
 #ifndef GPAC_DISABLE_SVG
 #pragma comment (linker, EXPORT_SYMBOL(gf_dom_get_key_name) )
@@ -522,6 +528,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_v2d_len) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_v2d_from_polar) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_v2d_distance) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_irect_union) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rect_union) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rect_center) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rect_overlaps) )
@@ -583,6 +590,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_mx_perspective) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mx_lookat) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mx_apply_bbox) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_mx_apply_bbox_4x4) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mx_add_matrix_4x4) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mx_inverse_4x4) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mx_apply_vec_4x4) )
@@ -915,6 +923,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_apple_get_tag) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_apple_enum_tag) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_wma_enum_tag) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_isom_enum_udta_keys) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_get_media_data_size) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_get_omadrm_info) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_is_omadrm_media) )
@@ -969,7 +978,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_get_unused_box_bytes) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_get_clean_aperture) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_dovi_config_get) )
-
+#pragma comment (linker, EXPORT_SYMBOL(gf_isom_opus_config_get_desc) )
 
 # ifndef GPAC_DISABLE_ISOM_DUMP
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_dump) )
@@ -1142,6 +1151,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_remove_meta_xml) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_apple_set_tag) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_wma_set_tag) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_isom_set_qt_key) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_get_next_alternate_group_id) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_set_ipod_compatible) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_is_inplace_rewrite) )
@@ -1164,6 +1174,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_set_progress_callback) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_apply_box_patch) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_ac3_config_new) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_isom_ac3_config_update) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_box_write) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_box_size) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_isom_tmcd_config_new) )
@@ -1339,8 +1350,8 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtsp_get_session_ip) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtsp_get_remote_address) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtsp_get_session_port) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_rtsp_use_tls) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtsp_session_write_interleaved) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_rtsp_http_tunnel_start) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_new) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_del) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_setup_transport) )
@@ -1357,6 +1368,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_decode_rtp) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_decode_rtcp) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_send_rtcp_report) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_rtp_set_loss_rate) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_send_bye) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_send_packet) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_rtp_is_unicast) )
@@ -1436,7 +1448,6 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_import_chapters_file) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_change_pl) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_change_color) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_media_nalu_next_start_code_bs) )
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_split_svc) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_merge_svc) )
@@ -1449,14 +1460,15 @@
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_inspect_dump_nalu) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_inspect_dump_obu) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_inspect_dump_opus) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_inspect_dump_prores) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_inspect_format_timecode) )
 
-
 #ifndef GPAC_DISABLE_ISOM_WRITE
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_change_par) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_remove_non_rap) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_update_bitrate) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_media_isom_apply_qt_key) )
 #endif
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_media_nal_rewrite_samples) )
@@ -1517,10 +1529,12 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_crypt_encrypt) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_crypt_set_key) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_crypt_set_IV) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_crypt_get_IV) )
 #endif GPAC_DISABLE_CRYPTO
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_sha1_csum) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sha1_file) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sha256_csum) )
 
 #ifndef GPAC_DISABLE_AV_PARSERS
 #pragma comment (linker, EXPORT_SYMBOL(gf_m4v_parser_new) )
@@ -1546,8 +1560,12 @@
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_ac3_parser_bs) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_eac3_parser_bs) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_ac3_get_channels) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_eac3_parser) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_ac3_get_total_channels) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_ac3_get_surround_channels) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_ac3_get_bitrate) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_eac3_get_chan_loc_count) )
+
 #ifndef GPAC_DISABLE_OGG
 #pragma comment (linker, EXPORT_SYMBOL(gf_vorbis_parse_header) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_vorbis_check_frame) )
@@ -1893,67 +1911,31 @@
 
 #ifdef GPAC_HAS_QJS
 #pragma comment (linker, EXPORT_SYMBOL(gf_sg_js_get_node) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_js_delete_runtime) )
 #endif
 
 
 #ifndef GPAC_DISABLE_PLAYER
-/*terminal.h exports*/
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_new) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_del) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_connect) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_disconnect) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_navigate_to) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_play_from_time) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_set_option) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_option) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_framerate) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_time_in_ms) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_elapsed_time_in_ms) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_viewpoint) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_set_viewpoint) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_root_object) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_object_count) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_object) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_object_subscene_type) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_select_object) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_select_service) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_find_service) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_toggle_addons) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_object_info) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_download_info) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_channel_net_info) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_world_info) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_dump_scene) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_set_size) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_user_event) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_connect_from_time) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_add_object) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_is_supported_url) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_simulation_frame_rate) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_service_info) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_text_selection) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_paste_text) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_url) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_connect_with_path) )
+//compositor exports
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_disconnect) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_navigate_to) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_play_from_time) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_time_in_ms) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_select_service) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_toggle_addons) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_url) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_main_pid) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_world_info) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_current_service_id) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_dump_scene) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_simulation_frame_rate) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_connect_from_time) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_is_supported_url) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mo_register) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mo_unregister) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_mo_get_scenegraph) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_send_event) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_switch_quality) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_visual_output_size) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_scene_update) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_process_step) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_screen_buffer) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_release_screen_buffer) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_offscreen_buffer) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_set_speed) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_get_current_service_id) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_print_graph) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_is_type_supported) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_term_print_stats) )
-
-/*terminal_dev exports*/
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_switch_quality) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_scene_update) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_set_speed) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_scene_new) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_scene_del) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_scene_get_time) )
@@ -1975,10 +1957,6 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_scene_resume_live) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_scene_set_timeshift_depth) )
 
-#endif
-
-#ifndef GPAC_DISABLE_PLAYER
-/*compositor.h exports*/
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_load) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_unload) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_set_fps) )
@@ -2004,7 +1982,11 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_is_over) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_navigation_supported) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_on_event) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_has_text_selection) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_selected_text) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_paste_text) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_add_object) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_offscreen_buffer) )
 
 
 #ifndef GPAC_DISABLE_SVG
@@ -2041,7 +2023,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_font_manager_create_span) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_font_manager_refresh_span_bounds) )
 
-#pragma comment (linker, EXPORT_SYMBOL(gf_sc_connect_from_time_ex) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_sc_connect_from_time) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_disconnect) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_send_event) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_sc_get_downloader) )
@@ -2135,11 +2117,9 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_laser_encoder_get_rap) )
 #endif /*GPAC_DISABLE_LASER*/
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
 /*download.h exports*/
 #pragma comment (linker, EXPORT_SYMBOL(gf_dm_wget) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dm_wget_with_cache) )
-#endif
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
 /*to be removed once TS fragmenter is moved to libgpac */
@@ -2195,13 +2175,12 @@
 #endif
 
 /* dvb_mpe.h */
-#ifdef GPAC_ENST_PRIVATE
+#ifdef GPAC_ENABLE_MPE
 #pragma comment (linker, EXPORT_SYMBOL(gf_dvb_mpe_section_del) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dvb_mpe_init) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dvb_mpe_section_new) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dvb_mpe_shutdown) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_dvb_get_freq_from_url) )
-#pragma comment (linker, EXPORT_SYMBOL(gf_m2ts_print_mpe_info) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_dvb_mpe_print_info) )
 #endif
 
 #ifndef GPAC_DISABLE_DASH_CLIENT
@@ -2285,6 +2264,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_dash_get_utc_drift_estimate) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dash_set_algo) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dash_set_route_ast_shift) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_dash_set_suggested_presentation_delay) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dash_ignore_xlink) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dash_group_get_num_components) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_dash_all_groups_done) )
@@ -2419,6 +2399,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_load_source) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_load_destination) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_post_user_task ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_fs_post_user_task_main ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_abort ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_is_last_task ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_in_final_flush) )
@@ -2450,6 +2431,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_is_supported_source) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_set_filter_creation_callback) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_fs_get_rt_udta) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_fs_set_external_gl_provider) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_send_update ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_get_arg ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_get_arg_str ) )
@@ -2502,6 +2484,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_connect_destination ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_load_filter ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_is_supported_source ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_url_is_filter) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_get_output_buffer_max ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_make_sticky ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_hint_single_clock ) )
@@ -2529,6 +2512,10 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_is_sink ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_is_source ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_tag_subsession ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_has_connect_errors ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_is_temporary ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_meta_set_instances ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_meta_get_instances ) )
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pck_discard ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pck_ref ) )
@@ -2613,6 +2600,7 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_set_eos ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_enum_properties ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_would_block ) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_is_sparse ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_query_buffer_duration ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_has_seen_eos ) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_eos_received ) )
@@ -2662,6 +2650,8 @@
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_is_playing) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_ignore_blocking) )
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_get_next_ts) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_has_decoder) )
+#pragma comment (linker, EXPORT_SYMBOL(gf_filter_pid_set_rt_stats) )
 
 
 #pragma comment (linker, EXPORT_SYMBOL(gf_filter_bind_dash_algo_callbacks) )

gpac-2.0.0.tar.gz/src/filter_core/filter.c -> gpac-2.2.0.tar.gz/src/filter_core/filter.c Changed

@@ -31,6 +31,7 @@
 {
 	gf_free(p);
 }
+
 void gf_filterpacket_del(void *p)
 {
 	GF_FilterPacket *pck=(GF_FilterPacket *)p;
@@ -40,48 +41,98 @@
 
 static void gf_filter_parse_args(GF_Filter *filter, const char *args, GF_FilterArgType arg_type, Bool for_script);
 
-const char *gf_fs_path_escape_colon(GF_FilterSession *sess, const char *path)
+const char *gf_fs_path_escape_colon_ex(GF_FilterSession *sess, const char *path, Bool *needs_escape, Bool for_source)
 {
 	const char *res;
+	char szEsc6;
+	if (needs_escape) *needs_escape = GF_FALSE;
 	if (!path) return NULL;
-	if (sess->sep_args != ':')
-		return strchr(path, sess->sep_args);
+	if (sess->sep_args != ':') {
+		res = strchr(path, sess->sep_args);
+	} else {
 
-	res = gf_url_colon_suffix(path, sess->sep_name);
-	//if path is one of this proto, check if we have a port specified
-	if (!strncmp(path, "tcp://", 6)
-		|| !strncmp(path, "udp://", 6)
-		|| !strncmp(path, "tcpu://", 7)
-		|| !strncmp(path, "udpu://", 7)
-		|| !strncmp(path, "rtp://", 6)
-		|| !strncmp(path, "route://", 8)
-	) {
-		char *sep2 = res ? strchr(res+1, ':') : NULL;
-		char *sep3 = res ? strchr(res+1, '/') : NULL;
-		if (sep2 && sep3 && (sep2>sep3)) {
-			sep2 = strchr(sep3, ':');
-		}
-		if (sep2 || sep3 || res) {
-			u32 port = 0;
-			if (sep2) {
-				sep20 = 0;
-				if (sep3) sep30 = 0;
-			}
-			else if (sep3) sep30 = 0;
-			if (sscanf(res+1, "%d", &port)==1) {
-				char szPort20;
-				snprintf(szPort, 20, "%d", port);
-				if (strcmp(res+1, szPort))
-					port = 0;
-			}
-			if (sep2) sep20 = ':';
-			if (sep3) sep30 = '/';
+		res = gf_url_colon_suffix(path, sess->sep_name);
+		//if path is one of this proto, check if we have a port specified
+		if (!strncmp(path, "tcp://", 6)
+			|| !strncmp(path, "udp://", 6)
+			|| !strncmp(path, "tcpu://", 7)
+			|| !strncmp(path, "udpu://", 7)
+			|| !strncmp(path, "rtp://", 6)
+			|| !strncmp(path, "route://", 8)
+		) {
+			char *sep2 = res ? strchr(res+1, ':') : NULL;
+			char *sep3 = res ? strchr(res+1, '/') : NULL;
+			if (sep2 && sep3 && (sep2>sep3)) {
+				sep2 = strchr(sep3, ':');
+			}
+			if (sep2 || sep3 || res) {
+				u32 port = 0;
+				if (sep2) {
+					sep20 = 0;
+					if (sep3) sep30 = 0;
+				}
+				else if (sep3) sep30 = 0;
+				if (sscanf(res+1, "%d", &port)==1) {
+					char szPort20;
+					snprintf(szPort, 20, "%d", port);
+					if (strcmp(res+1, szPort))
+						port = 0;
+				}
+				if (sep2) sep20 = ':';
+				if (sep3) sep30 = '/';
 
-			if (port) res = sep2;
+				if (port) res = sep2;
+			}
+		}
+	}
+	if (!res) return NULL;
+	//double sep, allways consider this is a forced escape
+	if (res1==sess->sep_args) return res;
+
+	sprintf(szEsc, "%cgpac", sess->sep_args);
+	//if we have an explicit :gpac: separator, don't further analyze what is before
+	char *sep = strstr(path, szEsc);
+	if (sep && ((sep5==sess->sep_args) || (sep5==0)))
+		return sep;
+	//for local files, check if file/dir exists for each ':' specified
+	//this allows for file path with ':' 
+	if (!strncmp(path, "file://", 7) || !strstr(path, "://")) {
+		sep = (char*)res;
+		while (1) {
+			if (sep) sep0 = 0;
+			Bool ok;
+			//for source check if file exists
+			if (for_source) {
+				char *frag = strrchr(path, '#');
+				if (frag) frag0 = 0;
+				ok = gf_file_exists(path);
+				if (frag) frag0 = '#';
+			}
+			//for dest check if target dir exists
+			else {
+				char *frag = strrchr(path, '/');
+				if (frag) frag0 = 0;
+				ok = gf_dir_exists(path);
+				if (frag) frag0 = '/';
+			}
+			//file/dir exists and has ':' in its name, we will need to escape options
+			if (ok && needs_escape && strchr(path, sess->sep_args))
+				*needs_escape = GF_TRUE;
+			if (sep) sep0 = sess->sep_args;
+			if (ok) {
+				return sep;
+			}
+			if (!sep) break;
+			sep = strchr(sep+1, sess->sep_args);
 		}
 	}
 	return res;
 }
+const char *gf_fs_path_escape_colon(GF_FilterSession *sess, const char *path)
+{
+	return gf_fs_path_escape_colon_ex(sess, path, NULL, GF_FALSE);
+
+}
 
 static const char *gf_filter_get_args_stripped(GF_FilterSession *fsess, const char *in_args, Bool is_dst)
 {
@@ -166,6 +217,7 @@
 - FID: will be inherited from last explicit filter in the chain
 - SID: is cloned during the resolution while loading the filter chain
 - TAG: TAG is never inherited
+- RSID: requesting sourceID on target filters is is never inherited
 - local options: by definition these options only apply to the loaded filter, and are never inherited
 - user-assigned PID properties on destination (they only apply after the destination, not in the new chain).
 
@@ -197,6 +249,12 @@
 		}
 		else if (!strncmp(in_args, "FS", 2) && (in_args2==fsess->sep_name)) {
 		}
+		else if (!strncmp(in_args, "RSID", 4) && (!in_args4 || (in_args4==fsess->sep_args))) {
+		}
+		else if (!strncmp(in_args, "FBT", 2) && (in_args3==fsess->sep_name)) {
+		}
+		else if (!strncmp(in_args, "FBU", 2) && (in_args3==fsess->sep_name)) {
+		}
 		else if (!is_src && (in_args0==fsess->sep_frag)) {
 
 		} else {
@@ -239,6 +297,10 @@
 	filter->max_extra_pids = freg->max_extra_pids;
 	filter->dynamic_filter = is_dynamic_filter ? 1 : 0;
 
+#ifdef GPAC_HAS_QJS
+	filter->jsval = JS_UNDEFINED;
+#endif
+
 	if (fsess->use_locks) {
 		snprintf(szName, 200, "Filter%sPackets", filter->freg->name);
 		filter->pcks_mx = gf_mx_new(szName);
@@ -419,7 +481,24 @@
 		}
 	}
 	if (filter) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Created filter register %s args %s\n", freg->name, filter->orig_args ? filter->orig_args : "none"));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Created filter register %s (%p) args %s\n", freg->name, filter, filter->orig_args ? filter->orig_args : "none"));
+	}
+
+	if ((freg->flags & GF_FS_REG_SINGLE_THREAD) && gf_list_count(filter->session->threads)) {
+		u32 count = gf_list_count(filter->session->threads);
+		GF_SessionThread *ft;
+		u32 idx=0;
+		u32 min_th_assigned = 0;
+		for (i=0; i<count; i++) {
+			ft = gf_list_get(filter->session->threads, i);
+			if (!idx || (min_th_assigned>ft->nb_filters_pinned)) {
+				idx = i+1;
+				min_th_assigned = ft->nb_filters_pinned;
+			}
+		}
+		ft = gf_list_get(filter->session->threads, idx-1);
+		safe_int_inc(&ft->nb_filters_pinned);
+		filter->restrict_th_idx = idx;
 	}
 	return filter;
 }
@@ -430,6 +509,13 @@
 
 	gf_filter_parse_args(filter, args, arg_type, GF_FALSE);
 
+	if (filter->removed) {
+		if (!(filter->freg->flags & (GF_FS_REG_TEMP_INIT|GF_FS_REG_META))) {
+			filter->finalized = GF_TRUE;
+			return GF_OK;
+		}
+	}
+
 	if (filter->freg->initialize) {
 		GF_Err e;
 		FSESS_CHECK_THREAD(filter)
@@ -605,11 +691,19 @@
 	if (filter->instance_help)
 		gf_free(filter->instance_help);
 
+	if (filter->meta_instances)
+		gf_free(filter->meta_instances);
+
 #ifdef GPAC_HAS_QJS
 	if (filter->iname)
 		gf_free(filter->iname);
 #endif
 
+	if (filter->restrict_th_idx) {
+		GF_SessionThread *ft = gf_list_get(filter->session->threads, filter->restrict_th_idx-1);
+		safe_int_dec(&ft->nb_filters_pinned);
+	}
+
 	if (filter->freg && (filter->freg->flags & GF_FS_REG_CUSTOM)) {
 		//external custom filters
 		if (! (filter->freg->flags & GF_FS_REG_SCRIPT) && filter->forced_caps) {
@@ -931,12 +1025,35 @@
 	}
 }
 
-static GF_PropertyValue gf_filter_parse_prop_solve_env_var(GF_Filter *filter, u32 type, const char *name, const char *value, const char *enum_values)
+Bool filter_solve_gdocs(const char *url, char szPathGF_MAX_PATH)
+{
+	char *path;
+#ifdef WIN32
+	path = getenv("HOMEPATH");
+#elif defined(GPAC_CONFIG_ANDROID) || defined(GPAC_CONFIG_IOS)
+	path = (char *) gf_opts_get_key("core", "docs-dir");
+#else
+	path = getenv("HOME");
+#endif
+
+	if (path && path0) {
+		strcpy(szPath, path);
+		u32 len = (u32) strlen(szPath);
+		if ((szPathlen-1=='/') || (szPathlen-1=='\\'))
+			szPathlen-1=0;
+
+		strcat(szPath, url+6);
+		return GF_TRUE;
+	}
+	return GF_FALSE;
+}
+
+GF_PropertyValue gf_filter_parse_prop_solve_env_var(GF_FilterSession *fs, GF_Filter *f, u32 type, const char *name, const char *value, const char *enum_values)
 {
 	char szPathGF_MAX_PATH;
 	GF_PropertyValue argv;
 
-	if (!value) return gf_props_parse_value(type, name, NULL, enum_values, filter->session->sep_list);
+	if (!value) return gf_props_parse_value(type, name, NULL, enum_values, fs->sep_list);
 
 
 	if (!strnicmp(value, "$GSHARE", 7)) {
@@ -947,6 +1064,13 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Failed to query GPAC shared resource directory location\n"));
 		}
 	}
+	else if (!strnicmp(value, "$GDOCS", 6)) {
+		if (filter_solve_gdocs(value, szPath)) {
+			value = szPath;
+		} else {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Failed to query GPAC user document directory location\n"));
+		}
+	}
 	else if (!strnicmp(value, "$GJS", 4)) {
 		Bool gf_fs_solve_js_script(char *szPath, const char *file_name, const char *file_ext);
 
@@ -963,14 +1087,14 @@
 	else if (!strnicmp(value, "$GUA", 4)) {
 		value = gf_opts_get_key("core", "user-agent");
 		if (!value) value = "GPAC " GPAC_VERSION;
-	} else if (strstr(value, "$GINC(")) {
+	} else if (f && strstr(value, "$GINC(")) {
 		char *a_value = gf_strdup(value);
-		filter_translate_autoinc(filter, a_value);
-		argv = gf_props_parse_value(type, name, a_value, enum_values, filter->session->sep_list);
+		filter_translate_autoinc(f, a_value);
+		argv = gf_props_parse_value(type, name, a_value, enum_values, fs->sep_list);
 		gf_free(a_value);
 		return argv;
 	}
-	argv = gf_props_parse_value(type, name, value, enum_values, filter->session->sep_list);
+	argv = gf_props_parse_value(type, name, value, enum_values, fs->sep_list);
 	return argv;
 }
 
@@ -1003,7 +1127,7 @@
 			if (!is_sync_call) return GF_TRUE;
 		}
 
-		argv = gf_filter_parse_prop_solve_env_var(filter, a->arg_type, a->arg_name, arg_value, a->min_max_enum);
+		argv = gf_filter_parse_prop_solve_env_var(filter->session, filter, a->arg_type, a->arg_name, arg_value, a->min_max_enum);
 
 		if (argv.type != GF_PROP_FORBIDEN) {
 			GF_Err e = GF_OK;
@@ -1041,9 +1165,14 @@
 
 			GF_List *flist = gf_list_new();
 			if (arg->recursive & GF_FILTER_UPDATE_UPSTREAM) {
+				gf_mx_p(task->filter->tasks_mx);
 				for (i=0; i<task->filter->num_output_pids; i++) {
+					u32 j;
 					GF_FilterPid *pid = gf_list_get(task->filter->output_pids, i);
-					if (gf_list_find(flist, pid->filter)<0) gf_list_add(flist, pid->filter);
+					for (j=0; j<pid->num_destinations; j++) {
+						GF_FilterPidInst *pidi = gf_list_get(pid->destinations, j);
+						if (gf_list_find(flist, pidi->filter)<0) gf_list_add(flist, pidi->filter);
+					}
 				}
 				for (i=0; i<gf_list_count(flist); i++) {
 					GF_Filter *a_f = gf_list_get(flist, i);
@@ -1051,7 +1180,7 @@
 					gf_fs_send_update(task->filter->session, NULL, a_f, arg->name, arg->val, GF_FILTER_UPDATE_UPSTREAM);
 				}
 				gf_list_reset(flist);
-
+				gf_mx_v(task->filter->tasks_mx);
 			}
 			if (arg->recursive & GF_FILTER_UPDATE_DOWNSTREAM) {
 				gf_mx_p(task->filter->tasks_mx);
@@ -1079,7 +1208,7 @@
 	gf_free(arg);
 }
 
-static const char *gf_filter_load_arg_config(GF_Filter *filter, const char *sec_name, const char *arg_name, const char *arg_val)
+static const char *gf_filter_load_arg_config(GF_Filter *filter, const char *sec_name, const char *arg_name, const char *arg_val, Bool first_arg)
 {
 	char szArg101;
 	Bool gf_sys_has_filter_global_args();
@@ -1091,7 +1220,9 @@
 		u32 alen = (u32) strlen(arg_name);
 		u32 i, nb_args = gf_sys_get_argc();
 		for (i=0; i<nb_args; i++) {
+			u32 len;
 			u32 flen = 0;
+			u32 is_ok, loc_alen;
 			const char *per_filter, *sep2, *sep;
 			const char *o_arg, *arg = gf_sys_get_arg(i);
 			if (arg0!='-') continue;
@@ -1116,18 +1247,42 @@
 				arg += flen;
 			}
 
+			if (sep) {
+				len = (u32) (sep - (arg));
+			} else {
+				len = (u32) strlen(arg);
+			}
+			is_ok = 0;
 			if (!strncmp(arg, arg_name, alen)) {
-				u32 len=0;
-				if (sep) {
-					len = (u32) (sep - (arg));
-				} else {
-					len = (u32) strlen(arg);
+				if (len == alen) is_ok = 1;
+				loc_alen = alen;
+			} else if (first_arg && sep) {
+				if (!strncmp(arg, "FBT", len)) {
+					GF_PropertyValue ap = gf_props_parse_value(GF_PROP_UINT, "FBT", sep+1, NULL, filter->session->sep_list);
+					filter->pid_buffer_max_us = ap.value.uint;
+					is_ok = 2;
+					loc_alen=3;
+				}
+				else if (!strncmp(arg, "FBU", len)) {
+					GF_PropertyValue ap = gf_props_parse_value(GF_PROP_UINT, "FBU", sep+1, NULL, filter->session->sep_list);
+					filter->pid_buffer_max_units = ap.value.uint;
+					is_ok = 2;
+					loc_alen=3;
 				}
-				if (len != alen) continue;
-				strncpy(szArg, o_arg, 100);
-				szArg MIN(flen + alen, 100) = 0;
-				gf_fs_push_arg(session, szArg, GF_TRUE, GF_ARGTYPE_LOCAL, NULL);
+				else if (!strncmp(arg, "FBD", len)) {
+					GF_PropertyValue ap = gf_props_parse_value(GF_PROP_UINT, "FBD", sep+1, NULL, filter->session->sep_list);
+					filter->pid_decode_buffer_max_us = ap.value.uint;
+					is_ok = 2;
+					loc_alen=3;
+				}
+			}
+			if (!is_ok) continue;
+
+			strncpy(szArg, o_arg, 100);
+			szArg MIN(flen + loc_alen, 100) = 0;
+			gf_fs_push_arg(session, szArg, GF_TRUE, GF_ARGTYPE_LOCAL, NULL, NULL);
 
+			if (is_ok==1) {
 				if (sep) return sep+1;
 				//no arg value means boolean true
 				else return "true";
@@ -1140,7 +1295,26 @@
 	if (opt)
 		return opt;
 
-	//ifce (used by socket and keep MP4Client behavior: some options are set in MP4Client main apply them
+	if (first_arg) {
+		GF_PropertyValue ap;
+		opt = gf_opts_get_key(sec_name, "FBT");
+		if (opt) {
+			ap = gf_props_parse_value(GF_PROP_UINT, "FBT", opt, NULL, filter->session->sep_list);
+			filter->pid_buffer_max_us = ap.value.uint;
+		}
+		opt = gf_opts_get_key(sec_name, "FBU");
+		if (opt) {
+			ap = gf_props_parse_value(GF_PROP_UINT, "FBU", opt, NULL, filter->session->sep_list);
+			filter->pid_buffer_max_units = ap.value.uint;
+		}
+		opt = gf_opts_get_key(sec_name, "FBD");
+		if (opt) {
+			ap = gf_props_parse_value(GF_PROP_UINT, "FBD", opt, NULL, filter->session->sep_list);
+			filter->pid_decode_buffer_max_us = ap.value.uint;
+		}
+	}
+	
+	//ifce (used by socket and other filters), use core default
 	if (!strcmp(arg_name, "ifce")) {
 		opt = gf_opts_get_key("core", "ifce");
 		if (opt)
@@ -1286,6 +1460,7 @@
 		Bool absolute_url = GF_FALSE;
 		Bool internal_url = GF_FALSE;
 		Bool internal_arg = GF_FALSE;
+		char *xml_start = NULL;
 		char *sep = NULL;
 
 		//look for our arg separator - if arg0 is also a separator, consider the entire string until next double sep as the parameter
@@ -1312,6 +1487,24 @@
 
 		if (!opaque_arg) {
 			//we don't use gf_fs_path_escape_colon here because we also analyse whether the URL is internal or not, and we don't want to do that on each arg
+			if (sep) {
+				//escape XML inputs: simply search for ">:" (: being the arg sep), if not found consider the entire string the arg value
+				xml_start = strchr(args, '<');
+				if (xml_start && (xml_start<sep)) {
+					char szEnd3;
+					szEnd0 = '>';
+					szEnd1 = filter->session->sep_args;
+					szEnd2 = 0;
+					char *xml_end = strstr(xml_start, szEnd);
+					if (!xml_end) {
+						len = (u32) strlen(args);
+						sep = NULL;
+					} else {
+						sep = xml_end+1;
+						len = (u32) (sep-args);
+					}
+				}
+			}
 
 			if (filter->session->sep_args == ':') {
 				if (sep && !strncmp(args, szSrc, 4) && !strncmp(args+4, "gcryp://", 8)) {
@@ -1352,7 +1545,11 @@
 							if (sep2 && sep3 && (sep2>sep3)) {
 								sep2 = strchr(sep3, ':');
 							}
-							if (sep2 || sep3 || sep) {
+							//if in the form scheme://FOO/:, don't inspect FOO. This allows escaping port nmber or IPv6 double colon
+							if (sep3 && ((sep31==':') || (sep31==0)) ) {
+								sep = sep3+1;
+								if (!sep0) sep = NULL;
+							} else if (sep2 || sep3 || sep) {
 								u32 port = 0;
 								if (sep2) {
 									sep20 = 0;
@@ -1475,6 +1672,7 @@
 			}
 			if (sep) {
 				escaped = (sep1 == filter->session->sep_args) ? NULL : strstr(sep, szEscape);
+				if (escaped && xml_start && (escaped>xml_start)) escaped = NULL;
 				if (escaped) {
 					sep = escaped;
 				}
@@ -1528,27 +1726,11 @@
 		}
 
 
-		//escape some XML inputs
 		if (sep) {
-			char *xml_start = strchr(args, '<');
 			len = (u32) (sep-args);
-			if (xml_start) {
-				u32 xlen = (u32) (xml_start-args);
-				if ((xlen < len) && (argslen-1 != '>')) {
-					while (1) {
-						sep = strchr(sep+1, filter->session->sep_args);
-						if (!sep) {
-							len = (u32) strlen(args);
-							break;
-						}
-						len = (u32) (sep-args);
-						if (argslen-1 != '>') break;
-					}
-				}
-
-			}
+		} else {
+			len = (u32) strlen(args);
 		}
-		else len = (u32) strlen(args);
 
 		if (len>=alloc_len) {
 			alloc_len = len+1;
@@ -1591,15 +1773,21 @@
 				is_my_arg = GF_TRUE;
 				reverse_bool = GF_TRUE;
 			}
-			//little optim here, if no value check for enums
-			else if (!value && a->min_max_enum && strchr(a->min_max_enum, '|') ) {
-				char *arg_found = strstr(a->min_max_enum, szArg);
-				if (arg_found) {
-					char c = arg_foundstrlen(szArg);
-					if (!c || (c=='|')) {
-						is_my_arg = GF_TRUE;
-						value = szArg;
+			//little optim here, if no value check if argument nale is exactly one of the possible enums
+			else if (!value && a->min_max_enum && strchr(a->min_max_enum, '|') && strstr(a->min_max_enum, szArg)) {
+				const char *enums = a->min_max_enum;
+				while (enums) {
+					if (!strncmp(enums, szArg, len)) {
+						char c = enumslen;
+						if (!c || (c=='|')) {
+							is_my_arg = GF_TRUE;
+							value = szArg;
+							break;
+						}
 					}
+					char *enext = strchr(enums, '|');
+					if (!enext) break;
+					enums=enext+1;
 				}
 			}
 
@@ -1614,7 +1802,7 @@
 				GF_PropertyValue argv;
 				found=GF_TRUE;
 
-				argv = gf_filter_parse_prop_solve_env_var(filter, (a->flags & GF_FS_ARG_META) ? GF_PROP_STRING : a->arg_type, a->arg_name, value, a->min_max_enum);
+				argv = gf_filter_parse_prop_solve_env_var(filter->session, filter, (a->flags & GF_FS_ARG_META) ? GF_PROP_STRING : a->arg_type, a->arg_name, value, a->min_max_enum);
 
 				if (reverse_bool && (argv.type==GF_PROP_BOOL))
 					argv.value.boolean = !argv.value.boolean;
@@ -1634,6 +1822,7 @@
 				break;
 			}
 		}
+		GF_Filter *meta_filter = NULL;
 		if (!strlen(szArg)) {
 			found = GF_TRUE;
 		} else if (!found) {
@@ -1678,6 +1867,26 @@
 				found = GF_TRUE;
 				internal_arg = GF_TRUE;
 			}
+			//filter sources
+			else if (!strcmp("RSID", szArg)) {
+				filter->require_source_id = GF_TRUE;
+				found = GF_TRUE;
+				internal_arg = GF_TRUE;
+			}
+			//per-filter buffer times
+			else if (!strcmp("FBT", szArg)) {
+				if (arg_type!=GF_FILTER_ARG_INHERIT)
+					filter->pid_buffer_max_us = atoi(value);
+				found = GF_TRUE;
+				internal_arg = GF_TRUE;
+			}
+			//per-filter buffer units
+			else if (!strcmp("FBU", szArg)) {
+				if (arg_type!=GF_FILTER_ARG_INHERIT)
+					filter->pid_buffer_max_units = atoi(value);
+				found = GF_TRUE;
+				internal_arg = GF_TRUE;
+			}
 			//internal options, nothing to do here
 			else if (
 				//generic encoder load
@@ -1686,6 +1895,8 @@
 				|| !strcmp("gfreg", szArg)
 				//non inherited options
 				|| !strcmp("gfloc", szArg)
+				//sep
+				|| !strcmp("gpac", szArg)
 			) {
 				found = GF_TRUE;
 				internal_arg = GF_TRUE;
@@ -1705,6 +1916,12 @@
 				found = GF_TRUE;
 				internal_arg = GF_TRUE;
 			}
+			//temporary filter
+			else if (!strcmp("_GFTMP", szArg)) {
+				filter->removed = GF_TRUE;
+				found = GF_TRUE;
+				internal_arg = GF_TRUE;
+			}
 			//allow direct copy
 			else if (!strcmp("nomux", szArg)) {
 				//only apply fo explicit sink, not dynamic and no multi-sink target
@@ -1719,6 +1936,7 @@
 				internal_arg = GF_TRUE;
 			}
 			else if (!value && gf_file_exists(szArg)) {
+				internal_arg = GF_TRUE;
 				if (!for_script && (argfile_level<5) ) {
 					char szLine2001;
 					FILE *arg_file = gf_fopen(szArg, "rt");
@@ -1730,6 +1948,13 @@
 						res_line = gf_fgets(szLine, 2000, arg_file);
 						if (!res_line) break;
 						llen = (u32) strlen(szLine);
+						//make sure we have a legal UTF8 file
+						if (! gf_utf8_is_legal(szLine, llen)) {
+							GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Filter argument file \"%s\" is not a valid UTF-8 file, ignoring\n", szArg));
+							internal_arg = GF_FALSE;
+							break;
+						}
+
 						while (llen && strchr(" \n\r\t", szLinellen-1)) {
 							szLinellen-1=0;
 							llen--;
@@ -1749,7 +1974,6 @@
 				} else if (!for_script) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Filter argument file has too many nested levels of sub-files, maximum allowed is 5\n"));
 				}
-				internal_arg = GF_TRUE;
 			}
 			else if (has_meta_args && filter->freg->update_arg) {
 				GF_Err e = GF_OK;
@@ -1758,14 +1982,21 @@
 					FSESS_CHECK_THREAD(filter)
 					e = filter->freg->update_arg(filter, szArg, &argv);
 					if (argv.value.string) gf_free(argv.value.string);
+					//opaque arg not found for meta, report it
+					if ((e==GF_NOT_FOUND) && opaque_arg) {
+						opaque_arg = GF_FALSE;
+						found = GF_FALSE;
+					}
 				}
-				if (!(filter->freg->flags&GF_FS_REG_SCRIPT) && (e==GF_OK) )
+				if (!(filter->freg->flags&GF_FS_REG_SCRIPT) && (e==GF_OK) ) {
 					found = GF_TRUE;
+					meta_filter = filter;
+				}
 			}
 		}
 
 		if (!internal_arg && !opaque_arg && !opts_optional)
-			gf_fs_push_arg(filter->session, szArg, found, GF_ARGTYPE_LOCAL, NULL);
+			gf_fs_push_arg(filter->session, szArg, found, GF_ARGTYPE_LOCAL, meta_filter, NULL);
 
 skip_arg:
 		if (escaped) {
@@ -1784,6 +2015,7 @@
 
 static void gf_filter_parse_args(GF_Filter *filter, const char *args, GF_FilterArgType arg_type, Bool for_script)
 {
+	Bool first = GF_TRUE;
 	u32 i=0;
 	char szSecName200;
 	char szEscape7;
@@ -1829,11 +2061,12 @@
 			continue;
 		}
 
-		def_val = gf_filter_load_arg_config(filter, szSecName, a->arg_name, a->arg_default_val);
+		def_val = gf_filter_load_arg_config(filter, szSecName, a->arg_name, a->arg_default_val, first);
+		first = GF_FALSE;
 
 		if (!def_val) continue;
 
-		argv = gf_filter_parse_prop_solve_env_var(filter, a->arg_type, a->arg_name, def_val, a->min_max_enum);
+		argv = gf_filter_parse_prop_solve_env_var(filter->session, filter, a->arg_type, a->arg_name, def_val, a->min_max_enum);
 
 		if (argv.type != GF_PROP_FORBIDEN) {
 			if (!for_script && (a->offset_in_private>=0)) {
@@ -1910,9 +2143,9 @@
 	}
 }
 
-static GF_FilterPidInst *filter_relink_get_upper_pid(GF_FilterPidInst *cur_pidinst, Bool *needs_flush)
+static GF_FilterPidInst *filter_relink_get_upper_pid(GF_FilterPidInst *src_pidinst, Bool *needs_flush)
 {
-	GF_FilterPidInst *pidinst = cur_pidinst;
+	GF_FilterPidInst *pidinst = src_pidinst;
 	*needs_flush = GF_FALSE;
 	//locate the true destination
 	while (1) {
@@ -1926,8 +2159,12 @@
 		//we have a fan-out, we cannot replace the filter graph after that point
 		//this would affect the other branches of the upper graph
 		if (opid->num_destinations != 1) break;
-		pidinst = gf_list_get(opid->destinations, 0);
+		GF_FilterPidInst *cur_pidinst = gf_list_get(opid->destinations, 0);
+		//target is sink, abort if not direct target of the pid instance we want to remove - this prevents replacing muxer
+		if ((pidinst != src_pidinst) && (cur_pidinst->filter->num_output_pids==0))
+			break;
 
+		pidinst = cur_pidinst;
 		if (gf_fq_count(pidinst->packets))
 			(*needs_flush) = GF_TRUE;
 	}
@@ -2005,10 +2242,24 @@
 		}
 		gf_mx_v(cur_filter->tasks_mx);
 		cur_filter = an_inpid->pid->filter;
+
+		if (!cur_filter->dynamic_filter) {
+			break;
+		}
 	}
 
 	if (!link_from_pid) {
 		gf_fs_check_graph_load(cur_filter->session, GF_FALSE);
+
+		if (from_pidinst->pid->num_destinations==1) {
+			GF_FilterEvent evt;
+			GF_FilterPid *ipid = (GF_FilterPid *) from_pidinst;
+			GF_FEVT_INIT(evt, GF_FEVT_PLAY, ipid);
+			gf_filter_pid_send_event_internal(ipid, &evt, GF_TRUE);
+			GF_FEVT_INIT(evt, GF_FEVT_STOP, ipid);
+			gf_filter_pid_send_event_internal(ipid, &evt, GF_TRUE);
+		}
+		gf_fs_post_task(cur_filter->session, gf_filter_pid_disconnect_task, from_pidinst->filter, from_pidinst->pid, "pidinst_disconnect", NULL);
 		return;
 	}
 	//detach the pidinst, and relink from the new input pid
@@ -2018,7 +2269,7 @@
 void gf_filter_renegociate_output_dst(GF_FilterPid *pid, GF_Filter *filter, GF_Filter *filter_dst, GF_FilterPidInst *dst_pidi, GF_FilterPidInst *src_pidi)
 {
 	Bool is_new_chain = GF_TRUE;
-	GF_Filter *new_f;
+	GF_Filter *new_f, *src_f;
 	Bool reconfig_only = src_pidi ? GF_FALSE: GF_TRUE;
 
 	assert(filter);
@@ -2028,9 +2279,14 @@
 		return;
 	}
 
+	src_f = src_pidi ? src_pidi->pid->filter : pid->pid->filter;
+
 	//try to load filters to reconnect output pid
 	//we pass the source pid if given, so that we are sure the active property set is used to match the caps
-	if (!reconfig_only && gf_filter_pid_caps_match(src_pidi ? (GF_FilterPid *)src_pidi : pid, filter_dst->freg, filter_dst, NULL, NULL, NULL, -1)) {
+	if (!reconfig_only
+		&& (gf_list_find(src_f->blacklisted, (void*)filter_dst->freg)<0)
+		&& gf_filter_pid_caps_match(src_pidi ? (GF_FilterPid *)src_pidi : pid, filter_dst->freg, filter_dst, NULL, NULL, NULL, -1)
+	) {
 		GF_FilterPidInst *a_dst_pidi;
 		new_f = pid->filter;
 		assert(pid->num_destinations==1);
@@ -2042,6 +2298,7 @@
 		is_new_chain = GF_FALSE;
 
 		//we will reassign packets from that pid instance to the new connection
+		assert(!filter_dst->swap_pidinst_dst);
 		filter_dst->swap_pidinst_dst = a_dst_pidi;
 
 		src_pidi->filter->removed = 2;
@@ -2103,6 +2360,8 @@
 		if (is_new_chain) {
 			//signal a stream reset is pending to prevent filter entering endless loop
 			safe_int_inc(&dst_pidi->filter->stream_reset_pending);
+			assert(!new_f->swap_pidinst_dst);
+			assert(!new_f->swap_pidinst_src);
 			//keep track of the pidinst being detached in the target filter
 			new_f->swap_pidinst_dst = dst_pidi;
 			//keep track of the pidinst being detached from the source filter
@@ -2184,16 +2443,6 @@
 	return GF_TRUE;
 }
 
-void gf_filter_reconfigure_output_task(GF_FSTask *task)
-{
-	GF_Filter *filter = task->filter;
-	GF_FilterPid *pid;
-	assert(filter->num_output_pids==1);
-	pid = gf_list_get(filter->output_pids, 0);
-	gf_filter_reconf_output(filter, pid);
-}
-
-
 static void gf_filter_renegociate_output(GF_Filter *filter, Bool force_afchain_insert)
 {
 	u32 i, j;
@@ -2252,17 +2501,10 @@
 							continue;
 						filter_dst = pidi->filter;
 
-						if (filter_dst->freg->reconfigure_output) {
-							assert(!filter_dst->caps_negociate);
-							filter_dst->caps_negociate = pid->caps_negociate;
-							safe_int_inc(&filter_dst->caps_negociate->reference_count);
+						//prevent filter from unloading in case we have to disconnect the pid
+						if (!filter_dst->sticky) filter_dst->sticky = 2;
+						gf_filter_renegociate_output_dst(pid, filter, filter_dst, pidi, NULL);
 
-							gf_fs_post_task(filter->session, gf_filter_reconfigure_output_task, filter_dst, NULL, "filter reconfigure output", NULL);
-						} else {
-							//disconnect pid, but prevent filter from unloading
-							if (!filter_dst->sticky) filter_dst->sticky = 2;
-							gf_filter_renegociate_output_dst(pid, filter, filter_dst, pidi, NULL);
-						}
 					}
 				}
 				//we are disconnected (unload of a previous adaptation filter)
@@ -2449,7 +2691,7 @@
 		}
 		gf_mx_v(filter->tasks_mx);
 		filter->session->last_process_error = out_e;
-		filter->disabled = GF_TRUE;
+		filter->disabled = GF_FILTER_DISABLED;
 	}
 }
 
@@ -2462,7 +2704,7 @@
 	assert(task->filter);
 	assert(filter->freg);
 	assert(filter->freg->process);
-	task->can_swap = GF_TRUE;
+	task->can_swap = 1;
 
 	filter->schedule_next_time = 0;
 
@@ -2574,6 +2816,7 @@
 
 	filter->in_process_callback = GF_FALSE;
 	gf_rmt_end();
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s process done\n", filter->name));
 
 	//flush all pending pid init requests following the call to init
 	if (filter->has_pending_pids) {
@@ -2659,12 +2902,14 @@
 				filter->pending_packets = 0;
 		}
 		task->requeue_request = GF_TRUE;
+		task->can_swap = 2;
 		assert(filter->process_task_queued);
 	}
 	else {
 		assert (!filter->schedule_next_time);
 		gf_filter_check_pending_tasks(filter, task);
 		if (task->requeue_request) {
+			task->can_swap = 2;
 			assert(filter->process_task_queued);
 		}
 	}
@@ -2827,12 +3072,12 @@
 
 	if (use_direct_dispatch) {
 		safe_int_inc(&filter->process_task_queued);
-		gf_fs_post_task_ex(filter->session, gf_filter_process_task, filter, NULL, "process", NULL, GF_FALSE, GF_FALSE, GF_TRUE);
+		gf_fs_post_task_ex(filter->session, gf_filter_process_task, filter, NULL, "process", NULL, GF_FALSE, GF_FALSE, GF_TRUE, TASK_TYPE_NONE);
 	} else if (safe_int_inc(&filter->process_task_queued) <= 1) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s added to scheduler\n", filter->freg->name));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s added to scheduler\n", filter->name));
 		gf_fs_post_task(filter->session, gf_filter_process_task, filter, NULL, "process", NULL);
 	} else {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s skip post process task\n", filter->freg->name));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s skip post process task\n", filter->name));
 		assert(filter->session->run_status
 		 		|| filter->session->in_final_flush
 		 		|| filter->disabled
@@ -2856,6 +3101,8 @@
 void gf_filter_ask_rt_reschedule(GF_Filter *filter, u32 us_until_next)
 {
 	u64 next_time;
+	if (filter->removed) return;
+
 	if (!filter->in_process_callback) {
 		if (filter->session->direct_mode) return;
 		if (filter->session->in_final_flush) {
@@ -2937,7 +3184,7 @@
 	//detach all input pids
 	while (gf_list_count(f->input_pids)) {
 		GF_FilterPidInst *pidinst = gf_list_pop_back(f->input_pids);
-		pidinst->filter = NULL;
+		gf_filter_instance_detach_pid(pidinst);
 	}
 	//detach all output pids
 	while (gf_list_count(f->output_pids)) {
@@ -2966,8 +3213,8 @@
 	}
 
 	if (st->do_disconnect) {
-		//post setup°failure task ON THE FILTER, otherwise we might end up having 2 threads on the active filter
-		gf_fs_post_task(st->filter->session, gf_filter_setup_failure_task, st->filter, NULL, "setup_failure", st);
+		//post setup_failure task ON THE FILTER, otherwise we might end up having 2 threads on the active filter
+		gf_fs_post_task_class(st->filter->session, gf_filter_setup_failure_task, st->filter, NULL, "setup_failure", st, TASK_TYPE_SETUP);
 	} else {
 		gf_free(st);
 	}
@@ -2988,50 +3235,70 @@
 		filter->removed = 1;
 	}
 	if (filter->on_setup_error_filter) {
-		gf_fs_post_task(filter->session, gf_filter_setup_failure_notify_task, filter->on_setup_error_filter, NULL, "setup_failure_notify", stack);
+		gf_fs_post_task_class(filter->session, gf_filter_setup_failure_notify_task, filter->on_setup_error_filter, NULL, "setup_failure_notify", stack, TASK_TYPE_SETUP);
 	} else if (force_disconnect) {
-		//post setup°failure task ON THE FILTER, otherwise we might end up having 2 threads on the active filter
-		gf_fs_post_task(filter->session, gf_filter_setup_failure_task, filter, NULL, "setup_failure", stack);
+		//post setup_failure task ON THE FILTER, otherwise we might end up having 2 threads on the active filter
+		gf_fs_post_task_class(filter->session, gf_filter_setup_failure_task, filter, NULL, "setup_failure", stack, TASK_TYPE_SETUP);
 	}
 }
 
 GF_EXPORT
 void gf_filter_setup_failure(GF_Filter *filter, GF_Err reason)
 {
-
+	GF_FilterPidInst *pidinst;
+	GF_Filter *sfilter;
+	GF_Filter *notif_filter;
 	if (filter->in_connect_err) {
 		filter->in_connect_err = reason;
 		return;
 	}
+	notif_filter = filter;
 
+	//special cases for demux filters, if the source has a setup error callback and
+	//was not notified, use the source filter
+	pidinst = (filter->num_input_pids==1) ? gf_list_get(filter->input_pids, 0) : NULL;
+	sfilter = pidinst ? pidinst->pid->filter : NULL;
+	if (sfilter && sfilter->on_setup_error && !sfilter->setup_notified) {
+		notif_filter = sfilter;
+	}
 	//filter was already connected, trigger removal of all pid instances
-	if (filter->num_input_pids) {
+	else if (filter->num_input_pids) {
 		gf_filter_reset_pending_packets(filter);
 		filter->removed = 1;
 		gf_mx_p(filter->tasks_mx);
+
 		while (filter->num_input_pids) {
-			GF_FilterPidInst *pidinst = gf_list_get(filter->input_pids, 0);
-			GF_Filter *sfilter = pidinst->pid->filter;
-			gf_list_del_item(filter->input_pids, pidinst);
-			pidinst->filter = NULL;
+			GF_FilterPidInst *a_pidi = gf_list_get(filter->input_pids, 0);
+			GF_Filter *a_filter = a_pidi->pid->filter;
+
+			gf_list_del_item(filter->input_pids, a_pidi);
+
+			gf_filter_instance_detach_pid(a_pidi);
+
 			filter->num_input_pids = gf_list_count(filter->input_pids);
 			if (!filter->num_input_pids)
 				filter->single_source = NULL;
 
 			//post a pid_delete task to also trigger removal of the filter if needed
-			gf_fs_post_task(filter->session, gf_filter_pid_inst_delete_task, sfilter, pidinst->pid, "pid_inst_delete", pidinst);
+			gf_fs_post_task(filter->session, gf_filter_pid_inst_delete_task, a_filter, a_pidi->pid, "pid_inst_delete", a_pidi);
 		}
 		gf_mx_v(filter->tasks_mx);
 		if (reason)
 			filter->session->last_connect_error = reason;
-		return;
 	}
 
 	//don't accept twice a notif
-	if (filter->setup_notified) return;
-	filter->setup_notified = GF_TRUE;
+	if (notif_filter->setup_notified) return;
+	notif_filter->setup_notified = GF_TRUE;
 
-	gf_filter_notification_failure(filter, reason, GF_TRUE);
+	GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Filter %s failed to setup: %s\n", notif_filter->name, gf_error_to_string(reason)));
+
+	gf_filter_notification_failure(notif_filter, reason, GF_TRUE);
+	//if we used the source, also send a notif failure on the filter (to trigger removal)
+	if (notif_filter != filter) {
+		filter->setup_notified = GF_TRUE;
+		gf_filter_notification_failure(filter, reason, GF_TRUE);
+	}
 }
 
 //#define DUMP_TASKS
@@ -3060,7 +3327,7 @@
 
 	if (count!=1) {
 		task->requeue_request = GF_TRUE;
-		task->can_swap = GF_TRUE;
+		task->can_swap = 1;
 #if !defined(GPAC_DISABLE_LOG) && defined DUMP_TASKS
 		if (gf_log_tool_level_on(GF_LOG_FILTER, GF_LOG_DEBUG) ) {
 			gf_fq_enum(f->tasks, task_postponed_log, NULL);
@@ -3091,7 +3358,7 @@
 	//detach all input pids
 	while (gf_list_count(f->input_pids)) {
 		GF_FilterPidInst *pidinst = gf_list_pop_back(f->input_pids);
-		pidinst->filter = NULL;
+		gf_filter_instance_detach_pid(pidinst);
 	}
 	gf_mx_v(f->tasks_mx);
 
@@ -3102,13 +3369,15 @@
 
 void gf_filter_post_remove(GF_Filter *filter)
 {
+	//session about to be destroy, don't post task
+	if (filter->session->run_status==GF_EOS) return;
 	assert(!filter->swap_pidinst_dst);
 	assert(!filter->swap_pidinst_src);
 	assert(!filter->finalized);
 	filter->finalized = GF_TRUE;
 
 	//post remove task ON THE FILTER, otherwise we might end up having 2 threads on the active filter
-	gf_fs_post_task_ex(filter->session, gf_filter_remove_task, filter, NULL, "filter_destroy", NULL, GF_FALSE, filter->session->force_main_thread_tasks, GF_FALSE);
+	gf_fs_post_task_ex(filter->session, gf_filter_remove_task, filter, NULL, "filter_destroy", NULL, GF_FALSE, filter->session->force_main_thread_tasks, GF_FALSE, TASK_TYPE_NONE);
 }
 
 static void gf_filter_tag_remove(GF_Filter *filter, GF_Filter *source_filter, GF_Filter *until_filter, Bool keep_end_connections)
@@ -3148,6 +3417,15 @@
 		GF_FilterPid *pid = gf_list_get(filter->output_pids, i);
 		pid->has_seen_eos = GF_TRUE;
 		nb_inst = pid->num_destinations;
+		//happens if the pid was disconnected
+		if (!nb_inst && !mark_only && pid->not_connected) {
+			gf_list_rem(filter->output_pids, i);
+			i--;
+			count--;
+			filter->num_output_pids = gf_list_count(filter->output_pids);
+			gf_filter_pid_del(pid);
+			continue;
+		}
 		for (j=0; j<nb_inst; j++) {
 			GF_FilterPidInst *pidi = gf_list_get(pid->destinations, j);
 			gf_filter_tag_remove(pidi->filter, filter, until_filter, keep_end_connections);
@@ -3203,9 +3481,19 @@
 			}
 		}
 	}
-	if (keep_end_connections) return;
-
 	gf_mx_p(filter->tasks_mx);
+
+	if (!filter->num_output_pids && !filter->num_input_pids) {
+		gf_filter_post_remove(filter);
+		gf_mx_v(filter->tasks_mx);
+		return;
+	}
+
+	if (keep_end_connections) {
+		gf_mx_v(filter->tasks_mx);
+		return;
+	}
+
 	//check all pids connected to this filter, ensure their owner is only connected to this filter
 	for (i=0; i<filter->num_input_pids; i++) {
 		GF_FilterPid *pid;
@@ -3246,18 +3534,33 @@
 		GF_FilterPidInst *pidi = gf_list_get(filter->input_pids, i);
 		//fanout, only disconnect this pid instance
 		if (pidi->pid->num_destinations>1) {
-			//post disconnect
+			//post STOP and disconnect
+			GF_FilterEvent fevt;
+			GF_FEVT_INIT(fevt, GF_FEVT_STOP, (GF_FilterPid *) pidi);
+			gf_filter_pid_send_event((GF_FilterPid *) pidi, &fevt);
+
 			gf_fs_post_task(filter->session, gf_filter_pid_disconnect_task, filter, pidi->pid, "pidinst_disconnect", NULL);
 		}
 		//this is a source for the chain
 		else if (!pidi->pid->filter->num_input_pids) {
 			gf_filter_remove_internal(pidi->pid->filter, NULL, GF_FALSE);
 		}
-		//otherwise walk down the chain
-		else {
+		//otherwise walk down the chain if we have one-to-one
+		else if (pidi->pid->filter->num_output_pids==1) {
 			gf_filter_remove(pidi->pid->filter);
+		} else {
+			GF_FilterEvent fevt;
+			//source filter still active, mark output pid as not connected, send a stop and post disconnect
+			assert(pidi->pid->num_destinations==1);
+			pidi->pid->not_connected=1;
+			pidi->pid->filter->num_out_pids_not_connected++;
+			GF_FEVT_INIT(fevt, GF_FEVT_STOP, (GF_FilterPid *) pidi);
+			fevt.play.initial_broadcast_play = 2;
+			gf_filter_pid_send_event((GF_FilterPid *) pidi, &fevt);
+			gf_fs_post_task(filter->session, gf_filter_pid_disconnect_task, filter, pidi->pid, "pidinst_disconnect", NULL);
 		}
 	}
+	filter->sticky = 0;
 	gf_mx_v(filter->tasks_mx);
 }
 
@@ -3289,6 +3592,7 @@
 {
 	u32 i;
 	char *src_url=NULL;
+	char *src_args=NULL;
 	GF_Filter *target_filter=NULL;
 	GF_Err e;
 	const GF_FilterArgs *src_arg=NULL;
@@ -3297,6 +3601,8 @@
 		GF_FilterPacket *pck = gf_list_pop_front(filter->postponed_packets);
 		gf_filter_packet_destroy(pck);
 	}
+	gf_list_del(filter->postponed_packets);
+	filter->postponed_packets = NULL;
 
 	while (gf_list_count(filter->output_pids)) {
 		GF_FilterPid *pid = gf_list_pop_back(filter->output_pids);
@@ -3343,7 +3649,25 @@
 
 	target_filter = filter->target_filter;
 	filter->finalized = GF_FALSE;
-	gf_fs_load_source_dest_internal(filter->session, src_url, NULL, NULL, &e, filter, filter->target_filter ? filter->target_filter : filter->dst_filter, GF_TRUE, filter->no_dst_arg_inherit, NULL);
+
+	//reload using same args
+	src_args = NULL;
+	if (filter->src_args) {
+		src_args = filter->src_args;
+		filter->src_args = NULL;
+	}
+	else if (filter->orig_args) {
+		src_args = filter->orig_args;
+		filter->orig_args = NULL;
+	}
+	if (filter->orig_args) {
+		gf_free(filter->orig_args);
+		filter->orig_args = NULL;
+	}
+
+	gf_fs_load_source_dest_internal(filter->session, src_url, src_args, NULL, &e, filter, filter->target_filter ? filter->target_filter : filter->dst_filter, GF_TRUE, filter->no_dst_arg_inherit, NULL, NULL);
+	if (src_args) gf_free(src_args);
+
 	//we manage to reassign an input registry
 	if (e==GF_OK) {
 		gf_free(src_url);
@@ -3431,11 +3755,40 @@
 {
 	GF_Err e;
 	Bool is_supported = GF_FALSE;
-	gf_fs_load_source_dest_internal(filter->session, url, NULL, parent_url, &e, NULL, filter, GF_TRUE, GF_TRUE, &is_supported);
+	gf_fs_load_source_dest_internal(filter->session, url, NULL, parent_url, &e, NULL, filter, GF_TRUE, GF_TRUE, &is_supported, NULL);
 	return is_supported;
 }
 
 GF_EXPORT
+Bool gf_filter_url_is_filter(GF_Filter *filter, const char *url, Bool *act_as_source)
+{
+	char *sep = strchr(url, filter->session->sep_args);
+	u32 len = (u32) ( sep ? (sep - url - 1) : strlen(url) );
+	u32 i, count = gf_list_count(filter->session->registry);
+	for (i=0; i<count; i++) {
+		const GF_FilterRegister *freg = gf_list_get(filter->session->registry, i);
+		if (!freg) continue;
+		u32 flen = (u32) strlen(freg->name);
+		if ((len!=flen) || strncmp(freg->name, url, len)) continue;
+
+		if (act_as_source) {
+			if (freg->flags & GF_FS_REG_ACT_AS_SOURCE)
+				*act_as_source = GF_TRUE;
+			i=0;
+			while (freg->args && freg->argsi.arg_name) {
+				if (!strcmp(freg->argsi.arg_name, "src")) {
+					*act_as_source = GF_TRUE;
+					break;
+				}
+				i++;
+			}
+		}
+		return GF_TRUE;
+	}
+	return GF_FALSE;
+}
+
+GF_EXPORT
 GF_Filter *gf_filter_connect_source(GF_Filter *filter, const char *url, const char *parent_url, Bool inherit_args, GF_Err *err)
 {
 	GF_Filter *filter_src;
@@ -3448,7 +3801,7 @@
 
 	args = inherit_args ? gf_filter_get_dst_args(filter) : NULL;
 	if (args) {
-		char *rem_opts = {"FID", "SID", "N", "clone", NULL};
+		char *rem_opts = {"FID", "SID", "N", "RSID", "clone", NULL};
 		char szSep10;
 		char *loc_args;
 		u32 opt_idx;
@@ -3492,7 +3845,11 @@
 		}
 	}
 
-	filter_src = gf_fs_load_source_dest_internal(filter->session, url, NULL, parent_url, err, NULL, filter, GF_TRUE, GF_TRUE, NULL);
+	if (gf_filter_url_is_filter(filter, url, NULL)) {
+		filter_src = gf_fs_load_filter(filter->session, url, err);
+	} else {
+		filter_src = gf_fs_load_source_dest_internal(filter->session, url, NULL, parent_url, err, NULL, filter, GF_TRUE, GF_TRUE, NULL, NULL);
+	}
 	if (full_args) gf_free(full_args);
 
 	if (!filter_src) return NULL;
@@ -3509,7 +3866,7 @@
 GF_Filter *gf_filter_connect_destination(GF_Filter *filter, const char *url, GF_Err *err)
 {
 	if (!filter) return NULL;
-	return gf_fs_load_source_dest_internal(filter->session, url, NULL, NULL, err, NULL, filter, GF_FALSE, GF_FALSE, NULL);
+	return gf_fs_load_source_dest_internal(filter->session, url, NULL, NULL, err, NULL, filter, GF_FALSE, GF_FALSE, NULL, NULL);
 }
 
 
@@ -3706,7 +4063,7 @@
 		p = gf_filter_pid_get_property_first(pid, GF_PROP_PID_DURATION);
 		if (p && p->value.lfrac.den) {
 			evt->play.start_range *= -100;
-			evt->play.start_range *= p->value.lfrac.num;
+			evt->play.start_range *= (p->value.lfrac.num<0) ? -p->value.lfrac.num : p->value.lfrac.num;
 			evt->play.start_range /= 100 * p->value.lfrac.den;
 		}
 	}
@@ -3858,14 +4215,19 @@
 					}
 				}
 			} else if (score==GF_FPROBE_EXT_MATCH) {
-				if (a_mime && ext_len && strstr(a_mime, tmp_ext)) {
-					ext_not_trusted = GF_FALSE;
-					probe_mime = NULL;
-					break;
+				if (a_mime && ext_len) {
+					char *has_ext = strstr(a_mime, tmp_ext);
+					if (has_ext && (has_ext>a_mime) && (has_ext-1 != '|')) has_ext = NULL;
+					if (has_ext && (has_extext_len!=',') && (has_extext_len!='|')) has_ext = NULL;
+					if (has_ext) {
+						ext_not_trusted = GF_FALSE;
+						probe_mime = NULL;
+						break;
+					}
 				}
 			} else {
 				if (a_mime) {
-					GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Data Prober (filter %s) detected format is%s mime %s\n", freg->name, (score==GF_FPROBE_SUPPORTED) ? "" : "maybe", a_mime));
+					GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Data Prober (filter %s) detected format is%s mime %s\n", freg->name, (score==GF_FPROBE_SUPPORTED) ? "" : " maybe", a_mime));
 				}
 				if (a_mime && (score > max_score)) {
 					probe_mime = a_mime;
@@ -4084,6 +4446,7 @@
 #ifndef GPAC_DISABLE_3D
 	GF_Err e;
 	if (filter->removed || filter->finalized) return;
+	if (filter->session->ext_gl_callback) return;
 
 	if (do_register) {
 		if (gf_list_find(filter->session->gl_providers, filter)<0)
@@ -4122,11 +4485,11 @@
 }
 
 GF_EXPORT
-GF_Err gf_filter_set_active_opengl_context(GF_Filter *filter)
+GF_Err gf_filter_set_active_opengl_context(GF_Filter *filter, Bool do_activate)
 {
 #ifndef GPAC_DISABLE_3D
 	if (filter->finalized || filter->removed) return GF_OK;
-	return gf_fs_set_gl(filter->session);
+	return gf_fs_set_gl(filter->session, do_activate);
 #else
 	return GF_NOT_SUPPORTED;
 #endif
@@ -4281,7 +4644,7 @@
 	return GF_OK;
 }
 
-void gf_filter_report_meta_option(GF_Filter *filter, const char *arg, Bool was_found)
+void gf_filter_report_meta_option(GF_Filter *filter, const char *arg, Bool was_found, const char *sub_opt_name)
 {
 	if (!filter->session || filter->removed || filter->finalized) return;
 	if (filter->orig_args) {
@@ -4296,7 +4659,7 @@
 	//meta filters may report unused options set when setting up the filter, and not specified
 	//at prompt, ignore them
 	//the argtype will be ignored here
-	gf_fs_push_arg(filter->session, arg, was_found, GF_ARGTYPE_META_REPORTING, filter);
+	gf_fs_push_arg(filter->session, arg, was_found, GF_ARGTYPE_META_REPORTING, filter, sub_opt_name);
 	gf_mx_v(filter->session->filters_mx);
 }
 
@@ -4448,6 +4811,10 @@
 			} else {
 				res = gf_filter_has_out_caps(f->freg->caps, f->freg->nb_caps);
 			}
+			if (res) {
+				if (gf_filter_in_parent_chain(f, filter))
+					res = GF_FALSE;
+			}
 		}
 		gf_mx_v(f->tasks_mx);
 		if (res)
@@ -4479,12 +4846,16 @@
 }
 
 GF_EXPORT
-GF_Err gf_filter_reconnect_output(GF_Filter *filter)
+GF_Err gf_filter_reconnect_output(GF_Filter *filter, GF_FilterPid *for_pid)
 {
 	u32 i;
 	if (!filter) return GF_BAD_PARAM;
+	if (for_pid) {
+		if (PID_IS_INPUT(for_pid)) return GF_BAD_PARAM;
+	}
 	for (i=0; i<filter->num_output_pids; i++) {
 		GF_FilterPid *pid = gf_list_get(filter->output_pids, i);
+		if (for_pid && (pid != for_pid)) continue;
 		gf_filter_pid_post_init_task(filter, pid);
 	}
 	return GF_OK;
@@ -4641,7 +5012,7 @@
 		GF_FilterPid *pid = gf_list_get(filter->output_pids, i);
 		gf_filter_pid_set_eos(pid);
 	}
-	filter->disabled = 1;
+	filter->disabled = GF_FILTER_DISABLED;
 	gf_mx_v(filter->tasks_mx);
 }
 
@@ -4698,7 +5069,6 @@
 		safe_int_inc(&filter->nb_main_thread_forced);
 	else
 		safe_int_dec(&filter->nb_main_thread_forced);
-
 }
 
 GF_EXPORT
@@ -4734,3 +5104,30 @@
 		filter->subsource_id = 1 + source_id;
 	return GF_OK;
 }
+
+GF_EXPORT
+Bool gf_filter_has_connect_errors(GF_Filter *filter)
+{
+	if (filter && filter->session->last_connect_error) return GF_TRUE;
+	return GF_FALSE;
+}
+
+GF_EXPORT
+Bool gf_filter_is_temporary(GF_Filter *filter)
+{
+	return filter ? filter->removed : GF_FALSE;
+}
+
+GF_EXPORT
+void gf_filter_meta_set_instances(GF_Filter *filter, const char *instance_names_list)
+{
+	if (!filter) return;
+	if (filter->meta_instances) gf_free(filter->meta_instances);
+	filter->meta_instances = gf_strdup(instance_names_list);
+}
+
+GF_EXPORT
+const char *gf_filter_meta_get_instances(GF_Filter *filter)
+{
+	return filter ? filter->meta_instances : NULL;
+}

gpac-2.0.0.tar.gz/src/filter_core/filter_pck.c -> gpac-2.2.0.tar.gz/src/filter_core/filter_pck.c Changed

@@ -249,7 +249,7 @@
 	p = gf_filter_pid_get_property(ref->pid, GF_PROP_PID_PIXFMT);
 	pf = p ? p->value.uint : 0;
 	//not supported
-	if (!w || !h || !pf) {
+	if (!w || !h || !pf || !ref->frame_ifce->get_plane) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Missing width/height/pf in frame interface cloning, not supported\n"));
 		return NULL;
 	}
@@ -412,7 +412,7 @@
 	GF_FilterPacket *pck = gf_filter_pck_new_alloc_internal(pid, data_size, data);
 	if (pck && destruct) {
 		pck->destructor = destruct;
-		if (pid->filter->freg->flags & GF_FS_REG_MAIN_THREAD)
+		if (pid->filter->nb_main_thread_forced)
 			pck->info.flags |= GF_PCKF_FORCE_MAIN;
 	}
 	return pck;
@@ -446,7 +446,7 @@
 	}
 	gf_filter_pck_reset_props(pck, pid);
 
-	if (destruct && (pid->filter->freg->flags & GF_FS_REG_MAIN_THREAD))
+	if (destruct && pid->filter->nb_main_thread_forced)
 		pck->info.flags |= GF_PCKF_FORCE_MAIN;
 
 	assert(pck->pid);
@@ -520,6 +520,7 @@
 	pck->destructor = destruct;
 	pck->frame_ifce = frame_ifce;
 	pck->filter_owns_mem = 2;
+	//GL frame interface must be processed by main thread
 	if (frame_ifce && frame_ifce->get_gl_texture)
 		pck->info.flags |= GF_PCKF_FORCE_MAIN;
 	return pck;
@@ -861,16 +862,6 @@
 		return GF_BAD_PARAM;
 	}
 
-	if (pid->discard_input_packets) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s reset pending, discarding input packet\n", pid->filter->name, pid->name));
-		safe_int_inc(&pck->reference_count);
-		assert(pck->reference_count);
-		if (safe_int_dec(&pck->reference_count) == 0) {
-			gf_filter_packet_destroy(pck);
-		}
-		return GF_OK;
-	}
-
 	is_cmd_pck = (pck->info.flags & GF_PCK_CMD_MASK);
 
 	//special case for source filters (no input pids), mark as playing once we have a packet sent
@@ -947,7 +938,11 @@
 		}
 	}
 
-	if (pid->filter->out_pid_connection_pending || pid->filter->has_pending_pids || pid->init_task_pending) {
+	if (pid->filter->out_pid_connection_pending
+		|| pid->filter->has_pending_pids
+		|| pid->init_task_pending
+		|| (from_filter && pid->filter->postponed_packets)
+	) {
 		GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Filter %s PID %s connection pending, queuing packet\n", pck->pid->filter->name, pck->pid->name));
 		if (!pid->filter->postponed_packets) pid->filter->postponed_packets = gf_list_new();
 		gf_list_add(pid->filter->postponed_packets, pck);
@@ -1066,7 +1061,8 @@
 			else if ((u32) duration < pid->min_pck_duration) pid->min_pck_duration = (u32) duration;
 		}
 
-		if (!pck->info.duration && pid->min_pck_duration)
+		//set duration if pid is not sparse. If sparse (text & co) don't set it because we will likely get it wrong
+		if (!pid->is_sparse && !pck->info.duration && pid->min_pck_duration)
 			pck->info.duration = (u32) duration;
 
 		//may happen if we don't have DTS, only CTS signaled and B-frames
@@ -1083,15 +1079,15 @@
 			u8 bend = (pck->info.flags & GF_PCKF_BLOCK_END) ? 1 : 0;
 
 			if ((pck->info.dts != GF_FILTER_NO_TS) && (pck->info.cts != GF_FILTER_NO_TS) ) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet DTS "LLU" CTS "LLU" SAP %d seek %d duration %d S/E %d/%d\n", pck->pid->filter->name, pck->pid->name, pck->info.dts, pck->info.cts, sap_type, seek, pck->info.duration, bstart, bend));
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet DTS "LLU" CTS "LLU" SAP %d seek %d duration %d S/E %d/%d size %u\n", pck->pid->filter->name, pck->pid->name, pck->info.dts, pck->info.cts, sap_type, seek, pck->info.duration, bstart, bend, pck->data_length));
 			}
 			else if ((pck->info.cts != GF_FILTER_NO_TS) ) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet CTS "LLU" SAP %d seek %d duration %d S/E %d/%d\n", pck->pid->filter->name, pck->pid->name, pck->info.cts, sap_type, seek, pck->info.duration, bstart, bend));
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet CTS "LLU" SAP %d seek %d duration %d S/E %d/%d size %u\n", pck->pid->filter->name, pck->pid->name, pck->info.cts, sap_type, seek, pck->info.duration, bstart, bend, pck->data_length));
 			}
 			else if ((pck->info.dts != GF_FILTER_NO_TS) ) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet DTS "LLU" SAP %d seek %d duration %d S/E %d/%d\n", pck->pid->filter->name, pck->pid->name, pck->info.dts, sap_type, seek, pck->info.duration, bstart, bend));
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet DTS "LLU" SAP %d seek %d duration %d S/E %d/%d size %u\n", pck->pid->filter->name, pck->pid->name, pck->info.dts, sap_type, seek, pck->info.duration, bstart, bend, pck->data_length));
 			} else {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet no DTS/PTS SAP %d seek %d duration %d S/E %d/%d\n", pck->pid->filter->name, pck->pid->name, sap_type, seek, pck->info.duration, bstart, bend));
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s sent packet no DTS/PTS SAP %d seek %d duration %d S/E %d/%d size %u\n", pck->pid->filter->name, pck->pid->name, sap_type, seek, pck->info.duration, bstart, bend, pck->data_length));
 			}
 		}
 #endif
@@ -1110,7 +1106,7 @@
 
 	assert(pck->pid);
 	count = pck->pid->num_destinations;
-	//check if processing this packet must be done on main thread (OpenGL interface or source filter asked fo this) 
+	//check if processing this packet must be done on main thread (OpenGL interface or source filter asked for this)
 	Bool force_main_thread = (pck->info.flags & GF_PCKF_FORCE_MAIN) ? GF_TRUE : GF_FALSE;
 
 	for (i=0; i<count; i++) {
@@ -1179,6 +1175,8 @@
 
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Dispatching packet from filter %s to filter %s - %d packet in PID %s buffer ("LLU" us buffer)\n", pid->filter->name, dst->filter->name, gf_fq_count(dst->packets), pid->name, dst->buffer_duration ));
 
+		u64 us_duration = 0;
+
 		if (cktype) {
 			safe_int_inc(&dst->filter->pending_packets);
 			gf_fq_add(dst->packets, inst);
@@ -1187,7 +1185,7 @@
 			if (pck->info.flags & GF_PCKF_BLOCK_START) {
 				//missed end of previous, aggregate all before excluding this packet
 				if (!dst->last_block_ended) {
-					GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s: Missed end of block signaling but got start of block - queuing for potential reaggregation\n", pid->filter->name));
+					GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s: Missed end of block signaling but got start of block - performing reaggregation\n", pid->filter->name));
 
 					//post process task if we have been reaggregating a packet
 					post_task = gf_filter_aggregate_packets(dst);
@@ -1212,8 +1210,8 @@
 						dst->nb_reagg_pck++;
 
 					if (pck->info.duration && timescale) {
-						duration = gf_timestamp_rescale(pck->info.duration, timescale, 1000000);
-						safe_int64_add(&dst->buffer_duration, duration);
+						us_duration = gf_timestamp_rescale(pck->info.duration, timescale, 1000000);
+						safe_int64_add(&dst->buffer_duration, us_duration);
 					}
 					inst->pck->info.flags |= GF_PCKF_BLOCK_START;
 					safe_int_inc(&dst->filter->pending_packets);
@@ -1278,23 +1276,23 @@
 			}
 
 		} else {
-			duration=0;
+			u32 pck_dur=0;
 			//store start of block info
 			if (pck->info.flags & GF_PCKF_BLOCK_START) {
 				dst->first_block_started = GF_TRUE;
-				duration = pck->info.duration;
+				pck_dur = pck->info.duration;
 			}
 			if (pck->info.flags & GF_PCKF_BLOCK_END) {
 				//we didn't get a start for this end of block use the packet duration
 				if (!dst->first_block_started) {
-					duration=pck->info.duration;
+					pck_dur=pck->info.duration;
 				}
 				dst->first_block_started = GF_FALSE;
 			}
 
-			if (duration && timescale) {
-				duration = gf_timestamp_rescale(duration, timescale, 1000000);
-				safe_int64_add(&dst->buffer_duration, duration);
+			if (pck_dur && timescale) {
+				us_duration = gf_timestamp_rescale(pck_dur, timescale, 1000000);
+				safe_int64_add(&dst->buffer_duration, us_duration);
 			}
 			safe_int_inc(&dst->filter->pending_packets);
 //
@@ -1311,6 +1309,12 @@
 			//will be updated during packet drop of target
 			if (pid->nb_buffer_unit < nb_pck) pid->nb_buffer_unit = nb_pck;
 			if ((s64) pid->buffer_duration < dst->buffer_duration) pid->buffer_duration = dst->buffer_duration;
+			//if computed duration of packet is larger than pid max_buffer_time, update
+			//this is to make sure playback at speed > 1 won't trigger blocking state
+			//otherwise we would have max_buffer_time=1ms (default) and a single AU dispatched would block unless speed is AU_DUR_ms/1ms ...
+			if (us_duration && pid->max_buffer_time && (pid->max_buffer_time<us_duration))
+				pid->max_buffer_time = us_duration;
+				
 			gf_mx_v(pid->filter->tasks_mx);
 
 			//post process task
@@ -1332,10 +1336,10 @@
 	assert(pck->reference_count);
 	if (safe_int_dec(&pck->reference_count) == 0) {
 		if (!nb_dispatch) {
-			if (nb_discard) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("All PID destinations on filter %s are in discard mode - discarding\n", pid->filter->name));
+			if (count) {
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("All destinations of PID %s:%s are in discard mode - discarding\n", pid->filter->name, pid->name));
 			} else {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("No PID destination on filter %s for packet - discarding\n", pid->filter->name));
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("PID %s:%s has no destination for packet - discarding\n", pid->filter->name, pid->name));
 			}
 		}
 		gf_filter_packet_destroy(pck);
@@ -1442,6 +1446,7 @@
 const u8 *gf_filter_pck_get_data(GF_FilterPacket *pck, u32 *size)
 {
 	assert(pck);
+	assert(pck->pck);
 	assert(size);
 	//get true packet pointer
 	pck=pck->pck;

gpac-2.0.0.tar.gz/src/filter_core/filter_pid.c -> gpac-2.2.0.tar.gz/src/filter_core/filter_pid.c Changed

@@ -27,6 +27,8 @@
 #include <gpac/constants.h>
 #include <gpac/bitstream.h>
 
+static void free_evt(GF_FilterEvent *evt);
+
 static void pcki_del(GF_FilterPacketInstance *pcki)
 {
 	assert(pcki->pck->reference_count);
@@ -133,7 +135,6 @@
 
 	//unblock pid
 	if (pid->would_block) {
-		assert(pid->would_block);
 		safe_int_dec(&pid->would_block);
 
 		assert(pid->filter->would_block);
@@ -215,15 +216,41 @@
 	p = gf_filter_pid_get_property_first(pid, GF_PROP_PID_STREAM_TYPE);
 	if (p) mtype = p->value.uint;
 
+	Bool was_sparse = pid->is_sparse;
+	p = gf_filter_pid_get_property_first(pid, GF_PROP_PID_SPARSE);
+	if (p) {
+		pid->is_sparse = p->value.boolean;
+	} else {
+		u32 otype = mtype;
+		p = gf_filter_pid_get_property_first(pid, GF_PROP_PID_ORIG_STREAM_TYPE);
+		if (p) otype = p->value.uint;
+		switch (otype) {
+		case GF_STREAM_AUDIO:
+		case GF_STREAM_VISUAL:
+		case GF_STREAM_FILE:
+			pid->is_sparse = GF_FALSE;
+			break;
+		default:
+			pid->is_sparse = GF_TRUE;
+			break;
+		}
+	}
+	if (was_sparse && !pid->is_sparse)
+		safe_int_dec(&pid->filter->nb_sparse_pids);
+	else if (!was_sparse && pid->is_sparse)
+		safe_int_inc(&pid->filter->nb_sparse_pids);
+
+
 	pid->stream_type = mtype;
 	pid->codecid = codecid;
 
+	u32 buffer_us = pid->filter->pid_buffer_max_us ? pid->filter->pid_buffer_max_us : pid->filter->session->default_pid_buffer_max_us;
 	if (pid->user_max_buffer_time) {
-		pid->max_buffer_time = pid->user_max_buffer_time;
+		pid->max_buffer_time = MAX(pid->user_max_buffer_time, buffer_us);
 		pid->max_buffer_unit = 0;
 	} else {
-		pid->max_buffer_time = pid->filter->session->default_pid_buffer_max_us;
-		pid->max_buffer_unit = pid->filter->session->default_pid_buffer_max_units;
+		pid->max_buffer_time = buffer_us;
+		pid->max_buffer_unit = pid->filter->pid_buffer_max_units ? pid->filter->pid_buffer_max_units : pid->filter->session->default_pid_buffer_max_units;
 	}
 	pid->raw_media = GF_FALSE;
 
@@ -247,12 +274,6 @@
 		return;
 	}
 
-	if (pid->user_max_buffer_time) {
-		pid->max_buffer_time = pid->user_max_buffer_time;
-		pid->max_buffer_unit = 0;
-	}
-
-
 	//output is a decoded raw stream: if some input has same type but different codecid this is a decoder
 	//set input buffer size
 	gf_mx_p(pid->filter->tasks_mx);
@@ -269,15 +290,16 @@
 
 		//same stream type but changing format type: this is a decoder input pid, set buffer req
 		if ((mtype==i_type) && (codecid != i_codecid)) {
+
+			buffer_us = pid->filter->pid_decode_buffer_max_us ? pid->filter->pid_decode_buffer_max_us : pid->filter->session->decoder_pid_buffer_max_us;
 			//default decoder buffer
-			if (pidi->pid->user_max_buffer_time)
-				pidi->pid->max_buffer_time = pidi->pid->user_max_buffer_time;
-			else
-				pidi->pid->max_buffer_time = pidi->pid->filter->session->decoder_pid_buffer_max_us;
+			pidi->pid->max_buffer_time = MAX(pidi->pid->user_max_buffer_time, buffer_us);
 			pidi->pid->max_buffer_unit = 0;
 
-
-			if (mtype==GF_STREAM_VISUAL) {
+			//composition buffer
+			if (pid->filter->pid_buffer_max_units) {
+				pid->max_buffer_unit = pid->filter->pid_buffer_max_units;
+			} else if (mtype==GF_STREAM_VISUAL) {
 				pid->max_buffer_unit = 4;
 			} else if (mtype==GF_STREAM_AUDIO) {
 				pid->max_buffer_unit = 20;
@@ -395,20 +417,29 @@
 		gf_mx_v(filter->tasks_mx);
 		return;
 	}
-	//no more destinations on pid, destroy it
+	//no more destinations on pid, unblock if blocking
 	if (pid->would_block) {
 		assert(pid->filter->would_block);
 		safe_int_dec(&pid->filter->would_block);
 	}
-	
-	gf_list_del_item(filter->output_pids, pid);
-	filter->num_output_pids = gf_list_count(filter->output_pids);
-	gf_filter_pid_del(pid);
 
-	//no more pids on filter, destroy it
-	if (!gf_list_count(filter->output_pids) && !gf_list_count(filter->input_pids) && !filter->finalized) {
-		gf_filter_post_remove(filter);
+	//we cannot remove an output pid since the filter may still check status on that pid or try to dispatch packets
+	//removal/destruction must come from the filter
+	//we only count the number of output pids that have been internally discarded by this function, and trigger filter removal if last
+	pid->removed = GF_TRUE;
+
+	//filter still active and has no input, check if there are no more output pids valid. If so, remove filter
+	if (!gf_list_count(filter->input_pids) && !filter->finalized) {
+		u32 i, nb_opid_rem=0;
+		for (i=0; i<filter->num_output_pids; i++) {
+			GF_FilterPid *apid = gf_list_get(filter->output_pids, i);
+			if (apid->removed) nb_opid_rem++;
+		}
+		if (gf_list_count(filter->output_pids)==nb_opid_rem) {
+			gf_filter_post_remove(filter);
+		}
 	}
+
 	gf_mx_v(filter->tasks_mx);
 }
 
@@ -500,8 +531,8 @@
 	if (filter->swap_needs_init) {
 		//we are in detach state, the packet queue of the old PID is never read
 		assert(filter->swap_pidinst_dst && filter->swap_pidinst_dst->detach_pending);
-		//we are in pending stete, the origin of the old PID is never dispatching
-		assert(dst->pid && dst->pid->filter && dst->pid->filter->out_pid_connection_pending);
+		//we are in pending state, the origin of the old PID is never dispatching
+//		assert(dst->pid && dst->pid->filter && dst->pid->filter->out_pid_connection_pending);
 		//we can therefore swap the packet queues safely and other important info
 	}
 	//otherwise we actually swap the pid instance on the same PID
@@ -511,6 +542,7 @@
 			gf_list_del_item(dst->pid->destinations, src);
 		if (gf_list_find(dst->pid->destinations, dst)<0)
 			gf_list_add(dst->pid->destinations, dst);
+		dst->pid->num_destinations = gf_list_count(dst->pid->destinations);
 		if (gf_list_find(dst->filter->input_pids, dst)<0) {
 			gf_list_add(dst->filter->input_pids, dst);
 			dst->filter->num_input_pids = gf_list_count(dst->filter->input_pids);
@@ -568,10 +600,14 @@
 		src->force_reconfig = GF_TRUE;
 		src->props = NULL;
 		if (prev_dst_props) {
-			gf_props_merge_property(dst->props, prev_dst_props, NULL, NULL);
-			assert(prev_dst_props->reference_count);
-			if (safe_int_dec(&prev_dst_props->reference_count) == 0) {
-				gf_props_del(prev_dst_props);
+			if (dst->props) {
+				gf_props_merge_property(dst->props, prev_dst_props, NULL, NULL);
+				assert(prev_dst_props->reference_count);
+				if (safe_int_dec(&prev_dst_props->reference_count) == 0) {
+					gf_props_del(prev_dst_props);
+				}
+			} else {
+				dst->props = prev_dst_props;
 			}
 		}
 
@@ -616,14 +652,55 @@
 	
 	if (filter->swap_pidinst_src) {
 		src = filter->swap_pidinst_src;
+		assert(!src->filter->swap_pidinst_dst);
 		src->filter->swap_pidinst_dst = filter->swap_pidinst_dst;
 		gf_fs_post_task(filter->session, gf_filter_pid_inst_swap_delete_task, src->filter, src->pid, "pid_inst_delete", src);
 	}
 }
 
-static void task_canceled(GF_FSTask *task)
+//check all packets scheduled on main thread, unflag dest filter nb_main_thread_forced and set dest to NULL
+//we must do that because the packets may be destroyed after the pid instance is detached
+//so the destination filter would be NULL by then
+void gf_filter_instance_detach_pid(GF_FilterPidInst *pidinst)
 {
+	u32 i, count;
+	if (!pidinst->filter) return;
+
+	count = gf_fq_count(pidinst->packets);
+	for (i=0; i<count; i++) {
+		GF_FilterPacketInstance *pcki = gf_fq_get(pidinst->packets, i);
+		if (!pcki) break;
+		if (pcki->pck->info.flags & GF_PCKF_FORCE_MAIN) {
+			assert(pidinst->filter->nb_main_thread_forced);
+			safe_int_dec(&pidinst->filter->nb_main_thread_forced);
+		}
+	}
+	count = gf_list_count(pidinst->pck_reassembly);
+	for (i=0; i<count; i++) {
+		GF_FilterPacketInstance *pcki = gf_list_get(pidinst->pck_reassembly, i);
+		if (!pcki) break;
+		if (pcki->pck->info.flags & GF_PCKF_FORCE_MAIN) {
+			assert(pidinst->filter->nb_main_thread_forced);
+			safe_int_dec(&pidinst->filter->nb_main_thread_forced);
+		}
+	}
+	pidinst->filter = NULL;
+}
 
+void task_canceled(GF_FSTask *task)
+{
+	if (task->class_type==TASK_TYPE_EVENT) {
+		GF_FilterEvent *evt = task->udta;
+		free_evt(evt);
+	}
+	else if (task->class_type==TASK_TYPE_SETUP) {
+		gf_free(task->udta);
+	}
+	else if (task->class_type==TASK_TYPE_USER) {
+		gf_free(task->udta);
+		gf_free((char *)task->log_name);
+		task->log_name = NULL;
+	}
 }
 
 
@@ -637,7 +714,9 @@
 {
 	u32 i, count;
 	GF_Err e;
+	Bool refire_events=GF_FALSE;
 	Bool new_pid_inst=GF_FALSE;
+	Bool remove_filter=GF_FALSE;
 	GF_FilterPidInst *pidinst=NULL;
 	GF_Filter *alias_orig = NULL;
 
@@ -671,9 +750,14 @@
 				//and treat as new pid inst
 				if (ctype == GF_PID_CONF_CONNECT) {
 					new_pid_inst=GF_TRUE;
+					if (!pid->filter->nb_pids_playing && (pidinst->is_playing || pidinst->is_paused))
+						refire_events = GF_TRUE;
 				}
 				assert(pidinst->detach_pending);
 				safe_int_dec(&pidinst->detach_pending);
+				//revert temp sticky flag
+				if (filter->sticky == 2)
+					filter->sticky = 0;
 				break;
 			}
 			pidinst=NULL;
@@ -776,6 +860,9 @@
 		if (new_pid_inst) {
 			GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Filter %s (%p) PID %s (%p) (%d fan-out) connected to filter %s (%p)\n", pid->filter->name, pid->filter, pid->name, pid, pid->num_destinations, filter->name, filter));
 		}
+		//reset blacklist on source if connect OK - this is required when reconfiguring multiple times to the same filter, eg
+		//jpeg->raw->jpeg, the first jpeg->raw would blacklist jpeg dec from source, preventing resolution to work at raw->jpeg switch
+		gf_list_reset(pidinst->pid->filter->blacklisted);
 	}
 	//failure on reconfigure, try reloading a filter chain
 	else if ((ctype==GF_PID_CONF_RECONFIG) && (e != GF_FILTER_NOT_SUPPORTED)) {
@@ -785,6 +872,7 @@
 			filter->session->last_connect_error = e;
 		} else {
 			GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Failed to reconfigure PID %s:%s in filter %s: %s, reloading filter graph\n", pid->filter->name, pid->name, filter->name, gf_error_to_string(e) ));
+			gf_list_add(pid->filter->blacklisted, (void *) filter->freg);
 			gf_filter_relink_dst(pidinst);
 		}
 	} else {
@@ -802,7 +890,7 @@
 		gf_list_del_item(pidinst->pid->destinations, pidinst);
 		pidinst->pid->num_destinations = gf_list_count(pidinst->pid->destinations);
 		//detach filter from pid instance
-		pidinst->filter = NULL;
+		gf_filter_instance_detach_pid(pidinst);
 		gf_mx_v(pidinst->pid->filter->tasks_mx);
 
 		//if connect and error, direct delete of pid
@@ -876,6 +964,9 @@
 						GF_FEVT_INIT(evt, GF_FEVT_CONNECT_FAIL, pid);
 						gf_filter_pid_send_event_internal(pid, &evt, GF_TRUE);
 					}
+					if (!filter->num_input_pids && !filter->num_output_pids) {
+						remove_filter = GF_TRUE;
+					}
 				}
 			} else if (filter->has_out_caps) {
 				Bool unload_filter = GF_TRUE;
@@ -888,6 +979,7 @@
 				while (gf_list_count(filter->input_pids)) {
 					GF_FilterPidInst *a_pidinst = gf_list_pop_back(filter->input_pids);
 					FSESS_CHECK_THREAD(filter)
+					filter->num_input_pids--;
 					filter->freg->configure_pid(filter, (GF_FilterPid *) a_pidinst, GF_TRUE);
 
 					gf_filter_pid_post_init_task(a_pidinst->pid->filter, a_pidinst->pid);
@@ -999,7 +1091,7 @@
 		pidinst->pid->num_pidinst_del_pending ++;
 		gf_list_del_item(pidinst->pid->destinations, pidinst);
 		pidinst->pid->num_destinations = gf_list_count(pidinst->pid->destinations);
-		pidinst->filter = NULL;
+		gf_filter_instance_detach_pid(pidinst);
 		gf_mx_v(pidinst->pid->filter->tasks_mx);
 
 		//disconnected the last input, flag as removed
@@ -1017,6 +1109,22 @@
 		assert(pid->filter->out_pid_connection_pending);
 		if (safe_int_dec(&pid->filter->out_pid_connection_pending) == 0) {
 
+			//we must resent play/pause events when a new pid is reattached to an old pid instance
+			//in case one of the injected filter(s) monitors play state of the pids (eg reframers)
+			if (refire_events) {
+				GF_FilterEvent evt;
+				if (pidinst->is_playing) {
+					pidinst->is_playing = GF_FALSE;
+					GF_FEVT_INIT(evt, GF_FEVT_PLAY, (GF_FilterPid*)pidinst);
+					gf_filter_pid_send_event((GF_FilterPid *)pidinst, &evt);
+				}
+				if (pidinst->is_paused) {
+					pidinst->is_paused = GF_FALSE;
+					GF_FEVT_INIT(evt, GF_FEVT_PAUSE, (GF_FilterPid*)pidinst);
+					gf_filter_pid_send_event((GF_FilterPid *)pidinst, &evt);
+				}
+			}
+
 			if (e==GF_OK) {
 				//postponed packets dispatched by source while setting up PID, flush through process()
 				//pending packets (not yet consumed but in PID buffer), start processing
@@ -1025,6 +1133,8 @@
 				}
 			}
 		}
+		if (remove_filter && !filter->sticky)
+			gf_filter_post_remove(filter);
 	}
 	//once all pid have been (re)connected, update any internal caps
 	gf_filter_pid_update_caps(pid);
@@ -1106,6 +1216,8 @@
 		while (gf_filter_pid_get_packet((GF_FilterPid *) pidi)) {
 			gf_filter_pid_drop_packet((GF_FilterPid *) pidi);
 		}
+		//move back to regular discard
+		pidi->discard_inputs = 1;
 	}
 }
 void gf_filter_pid_disconnect_task(GF_FSTask *task)
@@ -1350,6 +1462,8 @@
 	if (pent) {
 		u32 matched=0;
 		u32 type=0;
+		u32 ptype = pent->prop.value.uint;
+
 		if (!strnicmp(frag_name, "audio", 5)) {
 			matched=5;
 			type=GF_STREAM_AUDIO;
@@ -1365,13 +1479,29 @@
 		} else if (!strnicmp(frag_name, "text", 4)) {
 			matched=4;
 			type=GF_STREAM_TEXT;
+		} else {
+			//frag name is a 4CC, check if we have an isom handler set
+			//if same 4CC consider we have a match
+			if (strlen(frag_name)==4) {
+				pent = gf_filter_pid_get_property_entry(src_pid, GF_PROP_PID_ISOM_HANDLER);
+				if (pent && (pent->prop.value.uint == gf_4cc_parse(frag_name)) ) {
+					matched=4;
+					type = ptype;
+				}
+			}
+		}
+		//stream is encrypted and desired type is not, get original stream type
+		if ((ptype == GF_STREAM_ENCRYPTED) && type && (type != GF_STREAM_ENCRYPTED) ) {
+			pent = gf_filter_pid_get_property_entry(src_pid, GF_PROP_PID_ORIG_STREAM_TYPE);
+			if (pent) ptype = pent->prop.value.uint;
 		}
+
 		if (matched &&
-			( (!is_neg && (type != pent->prop.value.uint)) || (is_neg && (type == pent->prop.value.uint)) )
+			( (!is_neg && (type != ptype)) || (is_neg && (type == ptype)) )
 		) {
 			//special case: if we request a non-file stream but the pid is a file, we will need a demux to
 			//move from file to A/V/... streams, so we accept any #MEDIA from file streams
-			if (pent->prop.value.uint == GF_STREAM_FILE) {
+			if (ptype == GF_STREAM_FILE) {
 				*prop_not_found = GF_TRUE;
 				return GF_TRUE;
 			}
@@ -1390,7 +1520,13 @@
 				pent = gf_filter_pid_get_property_entry(src_pid, GF_PROP_PID_STREAM_TYPE);
 				if (pent && pent->prop.value.uint==type) {
 					idx--;
-					if (!idx) {
+					if (!idx
+						//special case if single output of source, consider it a match
+						//this is needed for cases where intermediate filters are single-pid:
+						//mp4dmx @#video1 @ f1 @ f2 @ f3 @@0#video2 @f4 @f5 @f6
+						//filters f2 and f5 will only output a single pid
+						|| ((count_pid==1) && !src_pid->filter->max_extra_pids)
+					) {
 						if (p==src_pid) return GF_TRUE;
 						break;
 					}
@@ -2280,6 +2416,13 @@
 				//we found a property of that type , check if equal equal
 				prop_equal = gf_props_equal(&in_cap->val, &an_out_cap->val);
 				if ((in_cap->flags & GF_CAPFLAG_EXCLUDED) && !(an_out_cap->flags & GF_CAPFLAG_EXCLUDED) ) {
+					//special case for excluded output caps marked for loaded filter only and optional:
+					//always consider no match, the actual pid link resolving will sort this out
+					//this fixes a bug in reframer -> ffdec links: since ffdec only specifies excluded GF_CODEC_ID caps,
+					//not doing so will always force reframer->ufnalu->rfnalu->ffdec
+					if (an_out_cap->flags & (GF_CAPFLAG_OPTIONAL|GF_CAPFLAG_LOADED_FILTER))
+						prop_equal = GF_FALSE;
+
 					//prop type matched, output includes it and input excludes it: no match, don't look any further
 					if (prop_equal) {
 						matched = GF_FALSE;
@@ -2332,7 +2475,7 @@
 					bundles_cap_foundcur_dst_bundle = cap_loaded_filter_only ? 2 : 1;
 
 				nb_matched++;
-			} else if (!nb_matched && !prop_found && (an_out_cap->flags & GF_CAPFLAG_EXCLUDED) && (cur_dst_bundle<nb_in_bundles) ) {
+			} else if (!nb_matched && !prop_found && (an_out_cap->flags & (GF_CAPFLAG_EXCLUDED|GF_CAPFLAG_OPTIONAL)) && (cur_dst_bundle<nb_in_bundles) ) {
 				if (!bundles_cap_foundcur_dst_bundle)
 					bundles_cap_foundcur_dst_bundle = cap_loaded_filter_only ? 2 : 1;
 
@@ -2356,8 +2499,9 @@
 					bundles_in_okk |= 1<<2;
 			}
 		}
+
 		//not matched and not excluded, skip until next bundle
-		if (!nb_matched && !(out_cap->flags & GF_CAPFLAG_EXCLUDED)) {
+		if (!nb_matched && !(out_cap->flags & (GF_CAPFLAG_EXCLUDED|GF_CAPFLAG_OPTIONAL))) {
 			all_caps_matched = GF_FALSE;
 		}
 	}
@@ -3061,6 +3205,8 @@
 		//the initial resolution was done, unless the edge is marked as loaded destination filter only in which case
 		//we accept connection
 		if ((dst->bundle_idx_at_resolution>=0)
+			//if dest is a mux, don't check bundle idx
+			&& !dst->max_extra_pids
 			&& !(edge->loaded_filter_only & EDGE_LOADED_DEST_ONLY)
 			&& (edge->dst_cap_idx !=dst->bundle_idx_at_resolution)
 		) {
@@ -3245,6 +3391,8 @@
 	GF_FilterSession *fsess = pid->filter->session;
 	GF_List *filter_chain;
 	u32 i, count;
+	char *gfloc = NULL;
+	char gfloc_c=0;
 	char prefRegister1001;
 	char szForceReg20;
 	Bool reconfigurable_only;
@@ -3386,6 +3534,16 @@
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Solved %sfilter chain from filter %s PID %s to filter %s - dumping chain:\n", reconfigurable_only_type ? "adaptation " : "", pid->filter->name, pid->name, dst->freg->name));
 		}
 #endif
+		char szLocSep8;
+		sprintf(szLocSep, "gfloc%c", fsess->sep_args);
+		gfloc = strstr(args, "gfloc");
+		if (gfloc) {
+			if ((gfloc>args) && (gfloc-1==fsess->sep_args))
+				gfloc --;
+
+			gfloc_c = gfloc0;
+			gfloc0 = 0;
+		}
 		prev_af = NULL;
 		for (i=0; i<count; i++) {
 			GF_Filter *af;
@@ -3453,21 +3611,27 @@
 			af = gf_filter_new(fsess, freg, args, dst_args, pid->filter->no_dst_arg_inherit ? GF_FILTER_ARG_INHERIT_SOURCE_ONLY : GF_FILTER_ARG_INHERIT, NULL, NULL, GF_TRUE);
 			if (!af) goto exit;
 			af->subsession_id = dst->subsession_id;
-			//destination is sink, check if af is a mux (output cap type STREAM=FILE present
+			//destination is sink, check if af is a mux (output cap type STREAM=FILE present)
 			//if not, copy subsource_id from pid
 			Bool af_is_mux = GF_FALSE;
 			if (dst_is_sink) {
 				for (u32 cidx=0; cidx<freg->nb_caps; cidx++) {
-					const GF_FilterCapability *cap = &freg->capscidx;
-					if (!(cap->flags & GF_CAPFLAG_IN_BUNDLE)) continue;
-					if (!(cap->flags & GF_CAPFLAG_OUTPUT)) continue;
-					if (cap->flags & GF_CAPFLAG_EXCLUDED) continue;
-					if (cap->code!=GF_PROP_PID_STREAM_TYPE) continue;
-					if (cap->val.value.uint!=GF_STREAM_FILE) break;
+					const GF_FilterCapability *a_cap = &freg->capscidx;
+					if (!(a_cap->flags & GF_CAPFLAG_IN_BUNDLE)) continue;
+					if (!(a_cap->flags & GF_CAPFLAG_OUTPUT)) continue;
+					if (a_cap->flags & GF_CAPFLAG_EXCLUDED) continue;
+					if (a_cap->code!=GF_PROP_PID_STREAM_TYPE) continue;
+					if (a_cap->val.value.uint!=GF_STREAM_FILE) break;
 					af_is_mux = GF_TRUE;
 				}
 			}
-			af->subsource_id = af_is_mux ? 0 : pid->filter->subsource_id;
+			if (af_is_mux)
+				af->subsource_id = 0;
+			else if (pid->filter->subsource_id)
+				af->subsource_id = pid->filter->subsource_id;
+			//if subsource not set, force to 1 (we know this af is not a mux)
+			else
+				af->subsource_id = 1;
 
 			if (!af->forced_caps) {
 				//remember our target cap bundle on that filter
@@ -3531,6 +3695,8 @@
 	}
 
 exit:
+	if (gfloc) gfloc0 = gfloc_c;
+
 	gf_list_del(filter_chain);
 	return chain_input;
 }
@@ -3557,6 +3723,51 @@
 	return chain_len;
 }
 
+
+GF_List *gf_filter_pid_compute_link(GF_FilterPid *pid, GF_Filter *dst)
+{
+	GF_FilterSession *fsess = pid->filter->session;
+	GF_List *filter_chain;
+	char prefRegister1001;
+	char szForceReg20;
+
+	if (!fsess->max_resolve_chain_len) return NULL;
+	if (!dst) return NULL;
+
+	filter_chain = gf_list_new();
+
+	s32 dst_bundle_idx=-1;
+	if (gf_filter_pid_caps_match(pid, dst->freg, dst, NULL, &dst_bundle_idx, pid->filter->dst_filter, -1)) {
+		gf_list_add(filter_chain, (void*)dst->freg);
+		if ((dst_bundle_idx<0) || ((u32) dst_bundle_idx>=dst->freg->nb_caps))
+			dst_bundle_idx=0;
+
+		gf_list_add(filter_chain, (void*)&dst->freg->capsdst_bundle_idx);
+		return filter_chain;
+	}
+
+	sprintf(szForceReg, "gfreg%c", pid->filter->session->sep_name);
+	prefRegister0=0;
+	//look for reg given in
+	concat_reg(pid->filter->session, prefRegister, szForceReg, pid->filter->orig_args ? pid->filter->orig_args : pid->filter->src_args);
+	concat_reg(pid->filter->session, prefRegister, szForceReg, pid->filter->dst_args);
+	concat_reg(pid->filter->session, prefRegister, szForceReg, dst->src_args);
+	concat_reg(pid->filter->session, prefRegister, szForceReg, dst->dst_args);
+
+	gf_mx_p(fsess->links_mx);
+	gf_filter_pid_resolve_link_dijkstra(pid, dst, prefRegister, GF_FALSE, filter_chain);
+	gf_mx_v(fsess->links_mx);
+	if (!gf_list_count(filter_chain)) {
+		gf_list_del(filter_chain);
+		return NULL;
+	}
+	gf_list_add(filter_chain, (void *)dst->freg);
+	if (dst->freg->nb_caps)
+		gf_list_add(filter_chain, (void*)&dst->freg->caps0);
+	return filter_chain;
+}
+
+
 static void gf_filter_pid_set_args_internal(GF_Filter *filter, GF_FilterPid *pid, char *args, Bool use_default_seps, u32 argfile_level)
 {
 	char sep_args, sep_frag, sep_name, sep_list;
@@ -3598,21 +3809,17 @@
 		}
 		if (sep) {
 			char *xml_start = strchr(args, '<');
-			u32 len = (u32) (sep-args);
-			if (xml_start) {
-				u32 xlen = (u32) (xml_start-args);
-				if ((xlen < len) && (argslen-1 != '>')) {
-					while (1) {
-						sep = strchr(sep+1, sep_args);
-						if (!sep) {
-							break;
-						}
-						len = (u32) (sep-args);
-						if (argslen-1 == '>')
-							break;
-					}
+			if (xml_start && (xml_start<sep)) {
+				char szEnd3;
+				szEnd0 = '>';
+				szEnd1 = filter->session->sep_args;
+				szEnd2 = 0;
+				char *xml_end = strstr(xml_start, szEnd);
+				if (!xml_end) {
+					sep = NULL;
+				} else {
+					sep = xml_end+1;
 				}
-
 			}
 		}
 
@@ -3762,7 +3969,30 @@
 					gf_bs_del(bs);
 				}
 				gf_props_reset_single(&a_p);
-			} else {
+			}
+			//parse codecID
+			else if (p4cc == GF_PROP_PID_CODECID) {
+				//only for explicit filters
+				if (filter->dynamic_filter) goto skip_arg;
+				u32 cid = gf_codecid_parse(value);
+				if (cid) {
+					p.type = GF_PROP_UINT;
+					p.value.uint = cid;
+				}
+			}
+			//parse streamtype
+			else if (p4cc == GF_PROP_PID_STREAM_TYPE) {
+				//only for explicit filters
+				if (filter->dynamic_filter) goto skip_arg;
+				u32 st = gf_stream_type_by_name(value);
+				if (st!=GF_STREAM_UNKNOWN) {
+					p.type = GF_PROP_UINT;
+					p.value.uint = st;
+				}
+			}
+			//pix formats and others are parsed as specific prop types
+
+			if (p.type == GF_PROP_FORBIDEN) {
 				p = gf_props_parse_value(prop_type, name, value, NULL, sep_list);
 			}
 
@@ -4077,6 +4307,7 @@
 	GF_FilterPid *pid = task->pid;
 	GF_Filter *dynamic_filter_clone = NULL;
 	Bool filter_found_but_pid_excluded = GF_FALSE;
+	Bool possible_link_found_implicit_mode = GF_FALSE;
 	u32 pid_is_file = 0;
 	const char *filter_id;
 
@@ -4090,7 +4321,7 @@
 	//swap pid is pending on the possible destination filter
 	if (filter->swap_pidinst_src || filter->swap_pidinst_dst) {
 		task->requeue_request = GF_TRUE;
-		task->can_swap = GF_TRUE;
+		task->can_swap = 1;
 		return;
 	}
 	if (filter->caps_negociate) {
@@ -4113,14 +4344,21 @@
 			pid_is_file = 1;
 	}
 
-	//since we may have inserted filters in the middle (demuxers typically), get the last explicitly
-	//loaded ID in the chain
-	filter_id = gf_filter_last_id_in_chain(filter, GF_FALSE);
-	if (!filter_id && filter->cloned_from)
-		filter_id = gf_filter_last_id_in_chain(filter->cloned_from, GF_FALSE);
+	//get filter ID:
+	//this is a source - since we may have inserted filters in the middle (demuxers typically), get the last explicitly loaded ID in the chain
+	if (filter->subsource_id) {
+		filter_id = gf_filter_last_id_in_chain(filter, GF_FALSE);
+		if (!filter_id && filter->cloned_from)
+			filter_id = gf_filter_last_id_in_chain(filter->cloned_from, GF_FALSE);
+	}
+	//this is a sink or a mux - only use ID if defined on filter whether explicitly loaded or not ( some filters e.g. dasher,flist will self-assign an ID)
+	else {
+		//if clone use ID from clone otherwise linking will likely fail
+		filter_id = filter->cloned_from ? filter->cloned_from->id : filter->id;
+	}
 
 	//we lock the instantiated filter list for the entire resolution process
-	//we must unlock this mutex before calling locking a filter mutex (->tasks_mx)
+	//we must unlock this mutex before calling lock on a filter mutex (->tasks_mx)
 	//either directly or in functions calling it (e.g. gf_filter_in_parent_chain)
 	//in case another thread is reconfiguring a filter fA:
 	//- fA would have tasks_mx locked, and could be waiting for session->filters_mx to insert a new filter (inserting a filter chain)
@@ -4238,6 +4476,20 @@
 			}
 		}
 
+		//check we are not already connected to this filter - we need this in case destination links/filters lists are reset
+		if (pid->num_destinations) {
+			u32 j;
+			Bool already_linked = GF_FALSE;
+			for (j=0; j<pid->num_destinations; j++) {
+				GF_FilterPidInst *pidi = gf_list_get(pid->destinations, j);
+				if (pidi->filter == filter_dst) {
+					already_linked=GF_TRUE;
+					break;
+				}
+			}
+			if (already_linked) continue;
+		}
+
 		//we already linked to this one
 		if (gf_list_find(linked_dest_filters, filter_dst)>=0) {
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("PID %s already linked to filter %s\n", pid->name, filter_dst->name));
@@ -4256,6 +4508,9 @@
 			} else {
 				filter_dst->in_link_resolution = 0;
 				pid->filter->dst_filter = filter_dst;
+				//for mux->output case, the filter ID may be NULL but we still want to link
+				if (!num_pass && !filter->subsource_id)
+					ignore_source_ids = GF_TRUE;
 			}
 		}
 
@@ -4331,7 +4586,7 @@
 			//dst was not set, we may try to connect to this filter if it allows several input
 			//this is typically the case for muxers instantiated dynamically
 			if (!filter_dst->max_extra_pids) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("PID %s has explicit dest %s matching but no extra pid possible\n", pid->name, filter_dst->name));
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("PID %s has explicit dest %s (%p) matching but no extra pid possible\n", pid->name, filter_dst->name, filter_dst));
 				continue;
 			}
 		}
@@ -4461,7 +4716,14 @@
 						continue;
 					}
 				}
-				use_explicit_link = GF_TRUE;
+				//if we are a dynamic filter linking to a destination filter without ID (no link directive) and
+				//implicit mode is used, use implicit linking
+				//otherwise force explicit linking
+				//this avoids that dyn filters loaded for a link targeting an implicitly link filter link to a later filter:
+				//avsource enc_v @ FX output
+				//if enc_v loads a filter FA to connect to FX, we don't want FA->output
+				if (!filter->dynamic_filter || filter_dst->id || !(filter->session->flags & GF_FS_FLAG_IMPLICIT_MODE))
+					use_explicit_link = GF_TRUE;
 			}
 			//if no source ID on the dst filter, this means the dst filter accepts any possible connections from out filter
 			//unless prevented for this pid
@@ -4595,11 +4857,17 @@
 				} else {
 					//register as possible destination link. If a filter already registered is a destination of this possible link
 					//only the possible link will be kept
-					add_possible_link_destination(possible_linked_resolutions, filter_dst);
+					if (!possible_link_found_implicit_mode)
+						add_possible_link_destination(possible_linked_resolutions, filter_dst);
 
-					//implicit link mode: if possible destination is not a sink, stop checking
+					//implicit link mode: if possible destination is not a sink, stop checking for possible links
+					//continue however first pass in case we have a direct match with a dynamic filter, eg:
+					//tiled_input.mpd -> compositor -> ...
+					//the first pid will resolve to dashin + tileagg
+					//the second pid from dashin must link to tileagg, but if we stop the pass 0 loop
+					//it would link to compositor with a new tileagg filter
 					if (!use_explicit_link && (filter->session->flags & GF_FS_FLAG_IMPLICIT_MODE) && !is_sink) {
-						break;
+						possible_link_found_implicit_mode = GF_TRUE;
 					}
 				}
 				continue;
@@ -4702,7 +4970,7 @@
 			gf_list_add(loaded_filters, new_f);
 		}
 
-		if (!(filter_dst->freg->flags & GF_FS_REG_ALLOW_CYCLIC)) {
+		if (!(filter_dst->freg->flags & (GF_FS_REG_ALLOW_CYCLIC|GF_FS_REG_SCRIPT|GF_FS_REG_CUSTOM))) {
 			assert(pid->pid->filter->freg != filter_dst->freg);
 		}
 
@@ -4816,11 +5084,16 @@
 		assert(pid->init_task_pending);
 		safe_int_dec(&pid->init_task_pending);
 		gf_mx_v(filter->session->filters_mx);
-		pid->filter->disabled = GF_FALSE;
+		pid->filter->disabled = GF_FILTER_ENABLED;
 		gf_list_del(linked_dest_filters);
 gf_list_del(force_link_resolutions);
 gf_list_del(possible_linked_resolutions);
 		gf_fs_check_graph_load(filter->session, GF_FALSE);
+		if (pid->not_connected) {
+			pid->not_connected = 0;
+			assert(pid->filter->num_out_pids_not_connected);
+			pid->filter->num_out_pids_not_connected--;
+		}
 		return;
 	}
 
@@ -4881,8 +5154,18 @@
 gf_list_del(possible_linked_resolutions);
 	gf_mx_v(filter->session->filters_mx);
 
-
+	if (pid->num_destinations && !pid->not_connected) {
+		assert(pid->init_task_pending);
+		safe_int_dec(&pid->init_task_pending);
+		return;
+	}
 	filter->num_out_pids_not_connected ++;
+	//remove sparse info
+	if (pid->is_sparse) {
+		assert(filter->nb_sparse_pids);
+		safe_int_dec(&filter->nb_sparse_pids);
+		pid->is_sparse = 0;
+	}
 
 	GF_FilterEvent evt;
 	if (filter_found_but_pid_excluded) {
@@ -4910,9 +5193,11 @@
 		pid->not_connected = 1;
 	}
 	GF_FEVT_INIT(evt, GF_FEVT_PLAY, pid);
+	evt.play.initial_broadcast_play = 2;
 	gf_filter_pid_send_event_internal(pid, &evt, GF_TRUE);
 
 	GF_FEVT_INIT(evt, GF_FEVT_STOP, pid);
+	evt.play.initial_broadcast_play = 2;
 	gf_filter_pid_send_event_internal(pid, &evt, GF_TRUE);
 
 	gf_filter_pid_set_eos(pid);
@@ -4920,7 +5205,7 @@
 		&& !parent_chain_has_dyn_pids(pid->filter)
 		&& (pid->filter->num_out_pids_not_connected == pid->filter->num_output_pids)
 	) {
-		pid->filter->disabled = GF_TRUE;
+		pid->filter->disabled = GF_FILTER_DISABLED;
 
 		if (can_reassign_filter) {
 			gf_filter_setup_failure(pid->filter, GF_FILTER_NOT_FOUND);
@@ -4940,26 +5225,28 @@
 {
 	assert(pid->pid);
 	assert(pid->filter != filter);
-	if (!(filter->freg->flags & GF_FS_REG_ALLOW_CYCLIC)) {
+	if (!(filter->freg->flags & (GF_FS_REG_ALLOW_CYCLIC|GF_FS_REG_SCRIPT|GF_FS_REG_CUSTOM))) {
 		assert(pid->filter->freg != filter->freg);
 	}
 	assert(filter->freg->configure_pid);
 	safe_int_inc(&filter->session->pid_connect_tasks_pending);
 	safe_int_inc(&filter->in_pid_connection_pending);
-	gf_fs_post_task_ex(filter->session, gf_filter_pid_connect_task, filter, pid, "pid_connect", NULL, GF_TRUE, GF_FALSE, GF_FALSE);
+	gf_fs_post_task_ex(filter->session, gf_filter_pid_connect_task, filter, pid, "pid_connect", NULL, GF_TRUE, GF_FALSE, GF_FALSE, TASK_TYPE_NONE);
 }
 
 
 void gf_filter_pid_post_init_task(GF_Filter *filter, GF_FilterPid *pid)
 {
-	Bool force_main_thread=GF_FALSE;
+//	Bool force_main_thread=GF_FALSE;
 	if (pid->init_task_pending) return;
 
 	safe_int_inc(&pid->init_task_pending);
-	if (filter->session->force_main_thread_tasks)
-		force_main_thread = GF_TRUE;
+//	if (filter->session->force_main_thread_tasks)
+	//force pid_init on main thread to avoid concurrent graph resolutions. While it works well for simple cases, it is problematic
+	//for complex chains involving a lot of filters (typically gui loading icons)
+	Bool force_main_thread = GF_TRUE;
 
-	gf_fs_post_task_ex(filter->session, gf_filter_pid_init_task, filter, pid, "pid_init", NULL, GF_FALSE, force_main_thread, GF_FALSE);
+	gf_fs_post_task_ex(filter->session, gf_filter_pid_init_task, filter, pid, "pid_init", NULL, GF_FALSE, force_main_thread, GF_FALSE, TASK_TYPE_NONE);
 }
 
 GF_EXPORT
@@ -5696,39 +5983,8 @@
 	return is_internal;
 }
 
-GF_EXPORT
-GF_FilterPacket *gf_filter_pid_get_packet(GF_FilterPid *pid)
+static Bool filter_pck_check_prop_change(GF_FilterPidInst *pidinst, GF_FilterPacketInstance *pcki, Bool do_notif)
 {
-	GF_FilterPacketInstance *pcki;
-	GF_FilterPidInst *pidinst = (GF_FilterPidInst *)pid;
-	if (PID_IS_OUTPUT(pid)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Attempt to fetch a packet on an output PID in filter %s\n", pid->filter->name));
-		return NULL;
-	}
-	if (pidinst->discard_packets || pidinst->detach_pending) {
-		pidinst->filter->nb_pck_io++;
-		return NULL;
-	}
-
-	pcki = (GF_FilterPacketInstance *)gf_fq_head(pidinst->packets);
-	//no packets
-	if (!pcki) {
-		if (!pidinst->pid || !pidinst->pid->filter) return NULL;
-		if (pidinst->pid->filter->disabled) {
-			pidinst->is_end_of_stream = pidinst->pid->has_seen_eos = GF_TRUE;
-		}
-		if (!pidinst->is_end_of_stream && pidinst->pid->filter->would_block)
-			gf_filter_pid_check_unblock(pidinst->pid);
-		pidinst->filter->nb_pck_io++;
-		return NULL;
-	}
-	assert(pcki->pck);
-
-	if (gf_filter_pid_filter_internal_packet(pidinst, pcki)) {
-		return gf_filter_pid_get_packet(pid);
-	}
-	pcki->pid->is_end_of_stream = GF_FALSE;
-
 	if ( (pcki->pck->info.flags & GF_PCKF_PROPS_CHANGED) && !pcki->pid_props_change_done) {
 		GF_Err e;
 		Bool skip_props = GF_FALSE;
@@ -5758,24 +6014,73 @@
 				//it may happen that pid_configure for destination was called after packet being dispatched, in
 				//which case we are already properly configured
 				skip_props = GF_TRUE;
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s was already configured with the last property set, ignoring reconfigure\n", pidinst->pid->filter->name, pidinst->pid->name));
+				if (do_notif) {
+					GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s was already configured with the last property set, ignoring reconfigure\n", pidinst->pid->filter->name, pidinst->pid->name));
+				}
 			}
 		}
 		if (!skip_props) {
-			GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Filter %s PID %s property changed at this packet, triggering reconfigure\n", pidinst->pid->filter->name, pidinst->pid->name));
+			if (do_notif) {
+				GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Filter %s PID %s property changed at this packet, triggering reconfigure\n", pidinst->pid->filter->name, pidinst->pid->name));
+
+				assert(pidinst->filter->freg->configure_pid);
+			}
 
-			assert(pidinst->filter->freg->configure_pid);
 			//reset the blacklist whenever reconfiguring, since we may need to reload a new filter chain
 			//in which a previously blacklisted filter (failing (re)configure for previous state) could
 			//now work, eg moving from formatA to formatB then back to formatA
 			gf_list_reset(pidinst->filter->blacklisted);
 
-			e = gf_filter_pid_configure(pidinst->filter, pidinst->pid, GF_PID_CONF_RECONFIG);
-			if (e != GF_OK) return NULL;
-			if (pidinst->pid->caps_negociate)
-				return NULL;
+			if (do_notif) {
+				e = gf_filter_pid_configure(pidinst->filter, pidinst->pid, GF_PID_CONF_RECONFIG);
+				if (e != GF_OK) return GF_TRUE;
+				if (pidinst->pid->caps_negociate)
+					return GF_TRUE;
+			}
 		}
 	}
+	return GF_FALSE;
+}
+
+GF_EXPORT
+GF_FilterPacket *gf_filter_pid_get_packet(GF_FilterPid *pid)
+{
+	GF_FilterPacketInstance *pcki;
+	GF_FilterPidInst *pidinst = (GF_FilterPidInst *)pid;
+
+	if (PID_IS_OUTPUT(pid)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Attempt to fetch a packet on an output PID in filter %s\n", pid->filter->name));
+		return NULL;
+	}
+	if (pidinst->discard_packets || pidinst->detach_pending) {
+		pidinst->filter->nb_pck_io++;
+		return NULL;
+	}
+
+restart:
+	pcki = (GF_FilterPacketInstance *)gf_fq_head(pidinst->packets);
+	//no packets
+	if (!pcki) {
+		if (!pidinst->pid || !pidinst->pid->filter || !pidinst->filter) return NULL;
+		if (pidinst->pid->filter->disabled) {
+			pidinst->is_end_of_stream = pidinst->pid->has_seen_eos = GF_TRUE;
+		}
+		if (!pidinst->is_end_of_stream && pidinst->pid->filter->would_block)
+			gf_filter_pid_check_unblock(pidinst->pid);
+		pidinst->filter->nb_pck_io++;
+		return NULL;
+	}
+	assert(pcki->pck);
+
+	if (gf_filter_pid_filter_internal_packet(pidinst, pcki)) {
+		//avoid recursion
+		goto restart;
+	}
+	pcki->pid->is_end_of_stream = GF_FALSE;
+
+	if (filter_pck_check_prop_change(pidinst, pcki, GF_TRUE))
+		return NULL;
+
 	if ( (pcki->pck->info.flags & GF_PCKF_INFO_CHANGED) && !pcki->pid_info_change_done) {
 		Bool res=GF_FALSE;
 
@@ -5804,6 +6109,35 @@
 	return (GF_FilterPacket *)pcki;
 }
 
+static GF_FilterPacketInstance *gf_filter_pid_probe_next_packet(GF_FilterPidInst *pidinst)
+{
+	u32 i=0;
+	//get first packet that is not an internal command
+	//if packet is a clock, consume it
+	while (1) {
+		GF_FilterPacketInstance *pcki = (GF_FilterPacketInstance *)gf_fq_get(pidinst->packets, i);
+		if (!pcki) break;
+		i++;
+
+		u32 ctype = (pcki->pck->info.flags & GF_PCK_CMD_MASK);
+		if (ctype == GF_PCK_CMD_PID_EOS ) {
+			break;
+		} else if (ctype == GF_PCK_CMD_PID_REM) {
+			break;
+		}
+		ctype = (pcki->pck->info.flags & GF_PCK_CKTYPE_MASK) >> GF_PCK_CKTYPE_POS;
+
+		if (ctype) {
+			if (pcki->pid->handles_clock_references) return NULL;
+
+			gf_filter_pid_filter_internal_packet(pidinst, pcki);
+			return gf_filter_pid_probe_next_packet(pidinst);
+		}
+		return pcki;
+	}
+	return NULL;
+}
+
 GF_EXPORT
 Bool gf_filter_pid_get_first_packet_cts(GF_FilterPid *pid, u64 *cts)
 {
@@ -5815,20 +6149,20 @@
 	}
 	if (pidinst->discard_packets) return GF_FALSE;
 
-	pcki = (GF_FilterPacketInstance *)gf_fq_head(pidinst->packets);
+	pcki = gf_filter_pid_probe_next_packet(pidinst);
 	//no packets
 	if (!pcki) {
 		return GF_FALSE;
 	}
 	assert(pcki->pck);
-
-	if (gf_filter_pid_filter_internal_packet(pidinst, pcki)) {
-		return gf_filter_pid_get_first_packet_cts(pid, cts);
-	}
-
 	if (pidinst->requires_full_data_block && !(pcki->pck->info.flags & GF_PCKF_BLOCK_END))
 		return GF_FALSE;
-	*cts = pcki->pck->info.cts;
+
+	GF_PropertyMap *map = gf_list_get(pidinst->pid->properties, 0);
+	if (map)
+		*cts = gf_timestamp_rescale(pcki->pck->info.cts, pcki->pck->pid_props->timescale, map->timescale);
+	else
+		*cts = pcki->pck->info.cts;
 	return GF_TRUE;
 }
 
@@ -5843,21 +6177,38 @@
 	}
 	if (pidinst->discard_packets) return GF_TRUE;
 
-	pcki = (GF_FilterPacketInstance *)gf_fq_head(pidinst->packets);
+	pcki = gf_filter_pid_probe_next_packet(pidinst);
 	//no packets
 	if (!pcki) {
 		return GF_TRUE;
 	}
 	assert(pcki->pck);
 
-	if (pcki->pck->info.flags & (GF_PCK_CMD_MASK|GF_PCK_CKTYPE_MASK)) {
-		return GF_TRUE;
-	}
 	if (pidinst->requires_full_data_block && !(pcki->pck->info.flags & GF_PCKF_BLOCK_END))
 		return GF_TRUE;
 	return (pcki->pck->data_length || pcki->pck->frame_ifce) ? GF_FALSE : GF_TRUE;
 }
 
+GF_EXPORT
+Bool gf_filter_pid_first_packet_is_blocking_ref(GF_FilterPid *pid)
+{
+	GF_FilterPacketInstance *pcki;
+	GF_FilterPidInst *pidinst = (GF_FilterPidInst *)pid;
+	if (PID_IS_OUTPUT(pid)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Attempt to read packet CTS on an output PID in filter %s\n", pid->filter->name));
+		return GF_FALSE;
+	}
+	if (pidinst->discard_packets) return GF_FALSE;
+
+	pcki = gf_filter_pid_probe_next_packet(pidinst);
+	//no packets
+	if (!pcki) {
+		return GF_FALSE;
+	}
+	assert(pcki->pck);
+	return gf_filter_pck_is_blocking_ref(pcki->pck);
+}
+
 
 static void gf_filter_pidinst_update_stats(GF_FilterPidInst *pidi, GF_FilterPacket *pck)
 {
@@ -5977,7 +6328,7 @@
 	pcki = gf_fq_pop(pidinst->packets);
 
 	if (!pcki) {
-		if (pidinst->filter && !pidinst->filter->finalized) {
+		if (pidinst->filter && !pidinst->filter->finalized && !pidinst->discard_packets) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_FILTER, ("Attempt to discard a packet already discarded in filter %s\n", pid->filter->name));
 		}
 		return;
@@ -5990,10 +6341,12 @@
 	if (pck->pid_props)
 		timescale = pck->pid_props->timescale;
 
-	if (pck->info.flags & GF_PCKF_FORCE_MAIN) {
+	//if not detached, undo main_thread flag - cf gf_filter_instance_detach_pid
+	if (pidinst->filter && (pck->info.flags & GF_PCKF_FORCE_MAIN)) {
 		assert(pidinst->filter->nb_main_thread_forced);
 		safe_int_dec(&pidinst->filter->nb_main_thread_forced);
 	}
+
 	gf_filter_pidinst_update_stats(pidinst, pck);
 	if (timescale && (pck->info.cts!=GF_FILTER_NO_TS)) {
 		pidinst->last_ts_drop.num = pck->info.cts;
@@ -6189,8 +6542,10 @@
 Bool gf_filter_pid_would_block(GF_FilterPid *pid)
 {
 	Bool would_block=GF_FALSE;
+	Bool result=GF_FALSE;
+#ifdef DEBUG_BLOCKMODE
 	Bool blockmode_broken=GF_FALSE;
-
+#endif
 	if (PID_IS_INPUT(pid)) {
 		return GF_FALSE;
 	}
@@ -6204,23 +6559,42 @@
 		if (pid->nb_buffer_unit * GF_FILTER_SPEED_SCALER >= pid->max_buffer_unit * pid->playback_speed_scaler) {
 			would_block = GF_TRUE;
 		}
+#ifdef DEBUG_BLOCKMODE
 		if ((pid->num_destinations==1) && !pid->filter->blockmode_broken && ( (pid->nb_buffer_unit * GF_FILTER_SPEED_SCALER > 100 * pid->max_buffer_unit * pid->playback_speed_scaler) ) ) {
 			blockmode_broken = GF_TRUE;
 		}
+#endif
 	} else if (pid->max_buffer_time) {
 		if (pid->buffer_duration * GF_FILTER_SPEED_SCALER > pid->max_buffer_time * pid->playback_speed_scaler) {
 			would_block = GF_TRUE;
 		}
+#ifdef DEBUG_BLOCKMODE
 		if ((pid->num_destinations==1) && !pid->filter->blockmode_broken && (pid->buffer_duration * GF_FILTER_SPEED_SCALER > 100 * pid->max_buffer_time * pid->playback_speed_scaler) ) {
 			blockmode_broken = GF_TRUE;
 		}
+#endif
 	}
+
+#ifdef DEBUG_BLOCKMODE
 	if (blockmode_broken) {
-		//don't throw a warning since some filters may dispatch a large burst of packets (eg isom muxer)
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_FILTER, ("Filter %s PID %s block mode not respected: %u units "LLU" us vs %u max units "LLU" max buffer\n", pid->pid->filter->name, pid->pid->name, pid->nb_buffer_unit, pid->buffer_duration, pid->max_buffer_unit, pid->max_buffer_time));
+		GF_LOG(GF_LOG_WARNING, GF_LOG_FILTER, ("Filter %s PID %s block mode not respected: %u units "LLU" us vs %u max units "LLU" max buffer\n", pid->pid->filter->name, pid->pid->name, pid->nb_buffer_unit, pid->buffer_duration, pid->max_buffer_unit, pid->max_buffer_time));
 
 		pid->filter->blockmode_broken = GF_TRUE;
 	}
+#endif
+
+	result = would_block;
+	//if PID is sparse and filter has more than one active output:
+	//- force the pid to move to blocking state
+	//- return the true status so that filters checking gf_filter_pid_would_block will dispatch frame if any
+	//
+	//This avoids considering a demux filter (with e.g., AV+text) as non-blocking when all its non-sparse PIDs are blocked
+	if (!pid->would_block && pid->is_sparse && !pid->not_connected
+		&& (pid->filter->num_output_pids > 1+pid->filter->num_out_pids_not_connected)
+		//don't do this if only sparse pids are connected
+		&& (pid->filter->nb_sparse_pids + pid->filter->num_out_pids_not_connected < pid->filter->num_output_pids)
+	)
+		would_block = GF_TRUE;
 
 	if (would_block && !pid->would_block) {
 		safe_int_inc(&pid->would_block);
@@ -6239,7 +6613,14 @@
 	}
 	assert(pid->filter->would_block <= pid->filter->num_output_pids);
 	gf_mx_v(pid->filter->tasks_mx);
-	return would_block;
+	return result;
+}
+
+GF_EXPORT
+Bool gf_filter_pid_is_sparse(GF_FilterPid *pid)
+{
+	if (!pid) return GF_FALSE;
+	return pid->pid->is_sparse;
 }
 
 static u64 gf_filter_pid_query_buffer_duration_internal(GF_FilterPid *pid, Bool check_pid_full, Bool force_update)
@@ -6255,21 +6636,32 @@
 		if (!pidinst->pid) return 0;
 		filter = pidinst->pid->filter;
 		if (check_pid_full) {
-			Bool buffer_full = GF_FALSE;
-
-			if (pidinst->pid->max_buffer_unit && (pidinst->pid->max_buffer_unit<=pidinst->pid->nb_buffer_unit))
-				buffer_full = GF_TRUE;
-
-			if (pidinst->pid->max_buffer_time && (pidinst->pid->max_buffer_time<=pidinst->pid->buffer_duration))
-				buffer_full = GF_TRUE;
+			u32 buffer_full = GF_FALSE;
+			Bool buffer_valid = GF_FALSE;
 
-			if (!buffer_full)
-				return 0;
+			if (pidinst->pid->max_buffer_unit) {
+				buffer_valid = GF_TRUE;
+				if (pidinst->pid->max_buffer_unit<=pidinst->pid->nb_buffer_unit)
+					buffer_full = GF_TRUE;
+			}
+			if (pidinst->pid->max_buffer_time) {
+				buffer_valid = GF_TRUE;
+				if (pidinst->pid->max_buffer_time<=pidinst->pid->buffer_duration)
+					buffer_full = GF_TRUE;
+			}
+
+			if (buffer_valid) {
+				if (!buffer_full) {
+					return 0;
+				}
+				if (pidinst->pid->max_buffer_unit<=pidinst->pid->nb_buffer_unit)
+					return GF_FILTER_NO_TS;
+			}
 		}
 
 		//this is a very costly recursive call until each source, and is likely to be an overkill
 		//if many PIDs (large tiling configurations for example)
-		//we cache the last computed value and only update every 10ms
+		//we cache the last computed value and only update every 10 ms
 		if (!force_update && (pidinst->filter->last_schedule_task_time - pidinst->last_buf_query_clock < 10000)) {
 			return pidinst->last_buf_query_dur;
 		}
@@ -6279,7 +6671,7 @@
 		gf_mx_p(filter->tasks_mx);
 		count = filter->num_input_pids;
 		for (i=0; i<count; i++) {
-			u64 dur = gf_filter_pid_query_buffer_duration_internal( gf_list_get(filter->input_pids, i), 0, force_update);
+			u64 dur = gf_filter_pid_query_buffer_duration_internal( gf_list_get(filter->input_pids, i), GF_FALSE, force_update);
 			if (dur > duration)
 				duration = dur;
 
@@ -6310,7 +6702,7 @@
 			count2 = pidinst->filter->num_output_pids;
 			for (j=0; j<count2; j++) {
 				GF_FilterPid *pid_n = gf_list_get(pidinst->filter->output_pids, i);
-				u64 dur = gf_filter_pid_query_buffer_duration_internal(pid_n, 0, GF_FALSE);
+				u64 dur = gf_filter_pid_query_buffer_duration_internal(pid_n, GF_FALSE, GF_FALSE);
 				if (dur > max_dur ) max_dur = dur;
 			}
 		}
@@ -6394,22 +6786,25 @@
 {
 	GF_FilterPidInst *pidi = (GF_FilterPidInst *)task->udta;
 	GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Filter %s input PID %s (from %s) resetting buffer\n", task->filter->name, pidi->pid->name, pidi->pid->filter->name ));
-	assert(pidi->pid->discard_input_packets);
 
 	if (had_eos) *had_eos = GF_FALSE;
-	
+
+	//aggregate any pending packet
+	gf_filter_aggregate_packets(pidi);
+
+	//trash packets without checking for internal commands except EOS any pending packet
 	while (gf_fq_count(pidi->packets)) {
 		GF_FilterPacketInstance *pcki = gf_fq_head(pidi->packets);
 		if ( (pcki->pck->info.flags & GF_PCK_CMD_MASK) == GF_PCK_CMD_PID_EOS) {
 			if (had_eos)
 				*had_eos = GF_TRUE;
 		}
+		//check props change otherwise we could accumulate pid properties no longer valid
+		filter_pck_check_prop_change(pidi, pcki, GF_FALSE);
+
 		gf_filter_pid_drop_packet((GF_FilterPid *) pidi);
 	}
-	while (gf_list_count(pidi->pck_reassembly)) {
-		GF_FilterPacketInstance *pcki = gf_list_pop_back(pidi->pck_reassembly);
-		pcki_del(pcki);
-	}
+
 	gf_filter_pidinst_reset_stats(pidi);
 
 	assert(pidi->discard_packets);
@@ -6421,6 +6816,7 @@
 	pidi->buffer_duration = 0;
 	pidi->nb_eos_signaled = 0;
 	pidi->pid->has_seen_eos = GF_FALSE;
+	pidi->last_clock_type = 0;
 
 	assert(pidi->pid->filter->stream_reset_pending);
 	safe_int_dec(& pidi->pid->filter->stream_reset_pending );
@@ -6428,8 +6824,8 @@
 	pidi->pid->nb_buffer_unit = 0;
 	pidi->pid->buffer_duration = 0;
 	gf_filter_pid_check_unblock(pidi->pid);
-	safe_int_dec(& pidi->pid->discard_input_packets );
 }
+
 static void gf_filter_pid_reset_task(GF_FSTask *task)
 {
 	gf_filter_pid_reset_task_ex(task, NULL);
@@ -6570,7 +6966,7 @@
 	//if some pids are still detached, wait for the connection before processing this event
 	if (f->detached_pid_inst) {
 		TASK_REQUEUE(task)
-		task->can_swap = GF_TRUE;
+		task->can_swap = 1;
 		return;
 	}
 
@@ -6589,9 +6985,11 @@
 		case GF_FEVT_PLAY:
 		case GF_FEVT_SOURCE_SEEK:
 			for_pidi->is_playing = GF_TRUE;
+			for_pidi->play_queued = 0;
 			break;
 		case GF_FEVT_STOP:
 			for_pidi->is_playing = GF_FALSE;
+			for_pidi->stop_queued = 0;
 			break;
 		case GF_FEVT_PAUSE:
 			for_pidi->is_paused = GF_TRUE;
@@ -6610,6 +7008,15 @@
 		if (pid->num_destinations && !for_pidi
 			&& ((evt->base.type==GF_FEVT_PLAY) || (evt->base.type==GF_FEVT_STOP) || (evt->base.type==GF_FEVT_CONNECT_FAIL))
 		) {
+			//we incremented discard counter in gf_filter_pid_send_event_internal for stop, decrement
+			//this typically happen when pid has 2 destinations, one OK and the other one failed to configure
+			if (evt->base.type==GF_FEVT_STOP) {
+				for (i=0; i<pid->num_destinations; i++) {
+					for_pidi = gf_list_get(pid->destinations, i);
+					if (for_pidi->discard_packets)
+						safe_int_dec(&for_pidi->discard_packets);
+				}
+			}
 			free_evt(evt);
 			return;
 		}
@@ -6639,12 +7046,15 @@
 			evt->base.on_pid->user_max_playout_time = evt->buffer_req.max_playout_us;
 			evt->base.on_pid->user_min_playout_time = evt->buffer_req.min_playout_us;
 			evt->base.on_pid->max_buffer_unit = 0;
+			evt->base.on_pid->user_buffer_forced = evt->buffer_req.pid_only;
 			//update blocking state
 			if (evt->base.on_pid->would_block)
 				gf_filter_pid_check_unblock(evt->base.on_pid);
 			else
 				gf_filter_pid_would_block(evt->base.on_pid);
 			canceled = GF_TRUE;
+		} else {
+			evt->base.on_pid->user_buffer_forced = GF_FALSE;
 		}
 	} else if (evt->base.on_pid && (evt->base.type == GF_FEVT_PLAY)
 		&& (evt->base.on_pid->pid->is_playing || (((GF_FilterPid *) evt->base.on_pid->pid)->not_connected==2))
@@ -6677,11 +7087,8 @@
 			//undo this
 			if (pidi->discard_packets) {
 				safe_int_dec(&pidi->discard_packets);
-				assert(pidi->pid->discard_input_packets);
-				safe_int_dec(& pidi->pid->discard_input_packets );
 			}
 		}
-
 		if (!evt->base.on_pid->pid->is_playing) {
 			if ((f->num_input_pids==f->num_output_pids) && (f->num_input_pids==1)) {
 				gf_filter_pid_set_discard(gf_list_get(f->input_pids, 0), GF_TRUE);
@@ -6693,12 +7100,18 @@
 		free_evt(evt);
 		return;
 	}
-	//do not allow pause/resume if already paused
-	else if (nb_paused && ((evt->base.type == GF_FEVT_PAUSE) || (evt->base.type == GF_FEVT_RESUME)) ) {
+	//do not allow pause if already paused
+	else if ((nb_paused>1) && (evt->base.type == GF_FEVT_PAUSE) ) {
 		GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Filter %s PID %s event %s but PID is already paused, discarding\n", f->name, evt->base.on_pid->name, gf_filter_event_name(evt->base.type)));
 		free_evt(evt);
 		return;
 	}
+	//do not allow resume if some instances are still paused
+	else if (nb_paused && (evt->base.type == GF_FEVT_RESUME) ) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_FILTER, ("Filter %s PID %s event %s but some PID instances are still paused, discarding\n", f->name, evt->base.on_pid->name, gf_filter_event_name(evt->base.type)));
+		free_evt(evt);
+		return;
+	}
 	//cancel connect failure if some destinations are successfully connected
 	else if ((evt->base.type==GF_FEVT_CONNECT_FAIL) && evt->base.on_pid->is_playing) {
 		free_evt(evt);
@@ -6740,6 +7153,7 @@
 		Bool do_reset = GF_TRUE;
 		GF_FilterPidInst *p = (GF_FilterPidInst *) evt->base.on_pid;
 		GF_FilterPid *pid = p->pid;
+		gf_mx_p(pid->filter->tasks_mx);
 		//we need to force a PID reset when the first PLAY is > 0, since some filters may have dispatched packets during the initialization
 		//phase
 		if (evt->base.type==GF_FEVT_PLAY) {
@@ -6764,23 +7178,26 @@
 		}
 		for (i=0; i<pid->num_destinations && do_reset; i++) {
 			GF_FilterPidInst *pidi = gf_list_get(pid->destinations, i);
+			pidi->last_clock_type = 0;
 
 			if (!pidi->discard_packets) {
 				safe_int_inc(&pidi->discard_packets);
-				safe_int_inc(& pid->discard_input_packets );
 			}
 
 			safe_int_inc(& pid->filter->stream_reset_pending );
 
-			assert(pid->discard_input_packets);
+			gf_mx_v(pid->filter->tasks_mx);
 
 			//post task on destination filter
 			if (evt->base.type==GF_FEVT_STOP)
 				gf_fs_post_task(pidi->filter->session, gf_filter_pid_reset_stop_task, pidi->filter, NULL, "reset_stop_pid", pidi);
 			else
 				gf_fs_post_task(pidi->filter->session, gf_filter_pid_reset_task, pidi->filter, NULL, "reset_pid", pidi);
+
+			gf_mx_p(pid->filter->tasks_mx);
 		}
 		pid->nb_reaggregation_pending = 0;
+		gf_mx_v(pid->filter->tasks_mx);
 	}
 	
 	gf_mx_p(f->tasks_mx);
@@ -6845,6 +7262,7 @@
 		gf_mx_v(f->tasks_mx);
 		return;
 	}
+
 	if (!task->pid) dispatched_filters = gf_list_new();
 
 	//otherwise forward event to each input PID
@@ -6864,7 +7282,6 @@
 		//mark pid instance as about to be reset to avoid processing PID destroy task before
 		if ((evt->base.type == GF_FEVT_STOP) || (evt->base.type==GF_FEVT_SOURCE_SEEK)) {
 			safe_int_inc(&pid_inst->discard_packets);
-			safe_int_inc(& pid_inst->pid->discard_input_packets );
 		}
 
 		an_evt = dup_evt(evt);
@@ -6872,7 +7289,7 @@
 
 		safe_int_inc(&pid->filter->num_events_queued);
 		
-		gf_fs_post_task(pid->filter->session, gf_filter_pid_send_event_downstream, pid->filter, task->pid ? (GF_FilterPid *) pid_inst : NULL, "downstream_event", an_evt);
+		gf_fs_post_task_class(pid->filter->session, gf_filter_pid_send_event_downstream, pid->filter, task->pid ? (GF_FilterPid *) pid_inst : NULL, "downstream_event", an_evt, TASK_TYPE_EVENT);
 	}
 	gf_mx_v(f->tasks_mx);
 	if (dispatched_filters) gf_list_del(dispatched_filters);
@@ -6902,7 +7319,7 @@
 
 				an_evt = dup_evt(evt);
 				an_evt->base.on_pid = (GF_FilterPid *)pidi;
-				gf_fs_post_task(pidi->filter->session, gf_filter_pid_send_event_upstream, pidi->filter, NULL, "upstream_event", an_evt);
+				gf_fs_post_task_class(pidi->filter->session, gf_filter_pid_send_event_upstream, pidi->filter, NULL, "upstream_event", an_evt, TASK_TYPE_EVENT);
 			}
 		}
 	}
@@ -6943,7 +7360,7 @@
 
 				up_evt = dup_evt(an_evt);
 				up_evt->base.on_pid = (GF_FilterPid *)pidi;
-				gf_fs_post_task(pidi->filter->session, gf_filter_pid_send_event_upstream, pidi->filter, NULL, "upstream_event", up_evt);
+				gf_fs_post_task_class(pidi->filter->session, gf_filter_pid_send_event_upstream, pidi->filter, NULL, "upstream_event", up_evt, TASK_TYPE_EVENT);
 			}
 		}
 		free_evt(an_evt);
@@ -6955,19 +7372,61 @@
 		|| (evt->base.type == GF_FEVT_PLAY)
 		|| (evt->base.type==GF_FEVT_SOURCE_SEEK)
 	) {
-		u32 i;
+		u32 i, nb_playing=0;
+		Bool do_reset = GF_TRUE;
 		gf_mx_p(pid->pid->filter->tasks_mx);
+
 		for (i=0; i<pid->pid->num_destinations; i++) {
 			GF_FilterPidInst *pidi = gf_list_get(pid->pid->destinations, i);
+			if (pidi->is_playing || pidi->play_queued) nb_playing++;
+			if (pidi->stop_queued) nb_playing--;
+
+			//pre-check pid instance play state
+			if (pidi == (GF_FilterPidInst *)evt->base.on_pid) {
+				//if STOP and pid instance already stop, silently discard
+				if ((evt->base.type == GF_FEVT_STOP) && !pidi->is_playing && !pidi->play_queued) {
+					gf_mx_v(pid->pid->filter->tasks_mx);
+					return;
+				}
+				//if PLAY and pid instance already playing, silently discard
+				else if ((evt->base.type == GF_FEVT_PLAY) && pidi->is_playing && !pidi->stop_queued) {
+					gf_mx_v(pid->pid->filter->tasks_mx);
+					return;
+				}
+			}
+		}
+		//do not set discard_packets flag on pid instance when:
+		//- pid has at least one active output and we play one
+		//- pid has more than one active output and we stop one
+		if (evt->base.type == GF_FEVT_STOP) {
+			if (nb_playing>1)
+				do_reset = GF_FALSE;
+
+			if (PID_IS_INPUT(pid)) {
+				((GF_FilterPidInst*)evt->base.on_pid)->stop_queued = 1;
+			}
+		} else {
+			if (nb_playing)
+				do_reset = GF_FALSE;
+			if (PID_IS_INPUT(pid)) {
+				((GF_FilterPidInst*)evt->base.on_pid)->play_queued = 1;
+			}
+		}
+
+		for (i=0; i<pid->pid->num_destinations; i++) {
+			GF_FilterPidInst *pidi = gf_list_get(pid->pid->destinations, i);
+
+			if (!do_reset && (pidi != (GF_FilterPidInst*)evt->base.on_pid))
+				continue;
+
 			if (evt->base.type == GF_FEVT_PLAY) {
 				pidi->is_end_of_stream = GF_FALSE;
-//				gf_filter_pid_clear_eos(pid, GF_FALSE);
 			} else {
 				//flag pid instance to discard all packets (cf above note)
 				safe_int_inc(&pidi->discard_packets);
-				safe_int_inc(& pidi->pid->discard_input_packets );
 			}
 		}
+
 		gf_mx_v(pid->pid->filter->tasks_mx);
 	}
 
@@ -6977,7 +7436,7 @@
 		an_evt->base.on_pid = evt->base.on_pid->pid;
 		safe_int_inc(&target_pid->pid->filter->num_events_queued);
 	}
-	gf_fs_post_task(pid->pid->filter->session, gf_filter_pid_send_event_downstream, pid->pid->filter, target_pid, "downstream_event", an_evt);
+	gf_fs_post_task_class(pid->pid->filter->session, gf_filter_pid_send_event_downstream, pid->pid->filter, target_pid, "downstream_event", an_evt, TASK_TYPE_EVENT);
 }
 
 GF_EXPORT
@@ -7025,9 +7484,9 @@
 		safe_int_inc(&evt->base.on_pid->filter->num_events_queued);
 	}
 	if (upstream)
-		gf_fs_post_task(filter->session, gf_filter_pid_send_event_upstream, filter, evt->base.on_pid, "upstream_event", an_evt);
+		gf_fs_post_task_class(filter->session, gf_filter_pid_send_event_upstream, filter, evt->base.on_pid, "upstream_event", an_evt, TASK_TYPE_EVENT);
 	else
-		gf_fs_post_task(filter->session, gf_filter_pid_send_event_downstream, filter, evt->base.on_pid, "downstream_event", an_evt);
+		gf_fs_post_task_class(filter->session, gf_filter_pid_send_event_downstream, filter, evt->base.on_pid, "downstream_event", an_evt, TASK_TYPE_EVENT);
 }
 
 
@@ -7076,7 +7535,7 @@
 {
 	if (!pidi->pid) return;
 
-	stats->avgerage_bitrate += pidi->avg_bit_rate;
+	stats->average_bitrate += pidi->avg_bit_rate;
 	if (!stats->first_process_time || (stats->first_process_time > pidi->first_frame_time))
 		stats->first_process_time = pidi->first_frame_time;
 	if (stats->last_process_time < pidi->last_pck_fetch_time)
@@ -7109,6 +7568,13 @@
 
 	if (stats->buffer_time < pidi->pid->buffer_duration)
 		stats->buffer_time = pidi->pid->buffer_duration;
+
+	if (pidi->last_rt_report) {
+		stats->last_rt_report = pidi->last_rt_report;
+		stats->rtt = pidi->rtt;
+		stats->jitter = pidi->jitter;
+		stats->loss_rate = pidi->loss_rate;
+	}
 }
 
 static void filter_pid_collect_stats(GF_List *pidi_list, GF_FilterPidStatistics *stats)
@@ -7132,7 +7598,10 @@
 		for (j=0; j<pid->num_destinations; j++) {
 			GF_Filter *res;
 			GF_FilterPidInst *pidi = gf_list_get(pid->destinations, j);
-			if (pidi->is_decoder_input) return pidi->filter;
+			if (( (pidi->is_decoder_input || pid->user_buffer_forced) && locate_decoder)
+				|| (pidi->is_encoder_input && !locate_decoder)
+			)
+				return pidi->filter;
 			res = filter_locate_enc_dec_sink(pidi->filter, locate_decoder);
 			if (res) return res;
 		}
@@ -7148,7 +7617,9 @@
 	for (i=0; i<filter->num_input_pids; i++) {
 		GF_Filter *res;
 		GF_FilterPidInst *pidi = gf_list_get(filter->input_pids, i);
-		if (pidi->is_decoder_input) {
+		if ((pidi->is_decoder_input && locate_decoder)
+			|| (pidi->is_encoder_input && !locate_decoder)
+		) {
 			gf_mx_v(filter->tasks_mx);
 			return filter;
 		}
@@ -7162,7 +7633,24 @@
 	return NULL;
 }
 
+static GF_Filter *filter_locate_sink(GF_Filter *filter)
+{
+	u32 i, j;
 
+	if (!filter->num_output_pids) {
+		return filter;
+	}
+	for (i=0; i<filter->num_output_pids; i++) {
+		GF_FilterPid *pid = gf_list_get(filter->output_pids, i);
+		for (j=0; j<pid->num_destinations; j++) {
+			GF_Filter *res;
+			GF_FilterPidInst *pidi = gf_list_get(pid->destinations, j);
+			res = filter_locate_sink(pidi->filter);
+			if (res) return res;
+		}
+	}
+	return NULL;
+}
 GF_EXPORT
 GF_Err gf_filter_pid_get_statistics(GF_FilterPid *pid, GF_FilterPidStatistics *stats, GF_FilterPidStatsLocation location)
 {
@@ -7201,6 +7689,9 @@
 	case GF_STATS_DECODER_SINK:
 		filter = filter_locate_enc_dec_sink(pidi->pid->filter, for_decoder);
 		break;
+	case GF_STATS_SINK:
+		filter = filter_locate_sink(pidi->pid->filter);
+		break;
 	}
 	if (!filter) {
 		return GF_NOT_FOUND;
@@ -7406,7 +7897,7 @@
 	if (PID_IS_INPUT(pid)) {
 		u32 k;
 		GF_Filter *dst = pid->filter->cap_dst_filter;
-		//the first entry in destination filters may be the fnal destination and won't hold any caps query
+		//the first entry in destination filters may be the final destination and won't hold any caps query
 		//we therefore use the last entry which points to the next filter in the chain
 		if (!dst) dst = gf_list_last(pid->filter->destination_filters);
 		if (!dst) dst = gf_list_get(pid->filter->destination_links, 0);
@@ -7465,6 +7956,17 @@
 			if (a_filter->forced_capsi.code==prop_4cc)
 				return &a_filter->forced_capsi.val;
 		}
+		//not found, check if dst filter is alread linked to a dest - may happen when loading muxes with different chain length:
+		//-i obu -i mp4a -o file.ts
+		//the link fin->mp4dmx->m2tsmx->file.ts is solved before fin->rfav1->ufobu->m2tsmx->ts
+		a_filter = a_filter->dst_filter;
+		while (a_filter) {
+			for (i=0; i<a_filter->nb_forced_caps; i++) {
+				if (a_filter->forced_capsi.code==prop_4cc)
+					return &a_filter->forced_capsi.val;
+			}
+			a_filter = a_filter->dst_filter;
+		}
 	}
 
 	return NULL;
@@ -7487,12 +7989,14 @@
 GF_Err gf_filter_pid_resolve_file_template_ex(GF_FilterPid *pid, char szTemplateGF_MAX_PATH, char szFinalNameGF_MAX_PATH, u32 file_idx, const char *file_suffix, const char *filename)
 {
 	u32 k;
+	GF_FilterPacket *pck;
 	char szFormat30, szTemplateValGF_MAX_PATH, szPropValGF_PROP_DUMP_ARG_SIZE;
 	char *name = szTemplate;
 	if (!strchr(szTemplate, '$')) {
 		strcpy(szFinalName, szTemplate);
 		return GF_OK;
 	}
+	pck = gf_filter_pid_get_packet(pid);
 	
 	k = 0;
 	while (name0) {
@@ -7587,6 +8091,9 @@
 			} else {
 				prop_4cc = GF_4CC(name5,name6,name7,name8);
 				prop_val = gf_filter_pid_get_property_first(pid, prop_4cc);
+				if (!prop_val && pck) {
+					prop_val = gf_filter_pck_get_property(pck, prop_4cc);
+				}
 				if (!prop_val) {
 					GF_LOG(GF_LOG_WARNING, GF_LOG_FILTER, ("Filter no pid property of type %s\n", name+5));
 					is_ok = GF_FALSE;
@@ -7594,25 +8101,30 @@
 			}
 		} else if (!strncmp(name, "pname=", 6)) {
 			prop_val = gf_filter_pid_get_property_str_first(pid, name+6);
+			if (!prop_val && pck) {
+				prop_val = gf_filter_pck_get_property_str(pck, name+6);
+			}
 			if (!prop_val) {
 				GF_LOG(GF_LOG_WARNING, GF_LOG_FILTER, ("Filter no pid property named %s\n", name+6));
 				is_ok = GF_FALSE;
 			}
-		} else if (!strncmp(name, "Number", 6)) {
+		}
+		//DASH reserved
+		else if (!strcmp(name, "Number")) {
 			do_skip = GF_TRUE;
-		} else if (!strncmp(name, "Time", 4)) {
+		} else if (!strcmp(name, "Time")) {
 			do_skip = GF_TRUE;
-		} else if (!strncmp(name, "RepresentationID", 16)) {
+		} else if (!strcmp(name, "RepresentationID")) {
 			do_skip = GF_TRUE;
-		} else if (!strncmp(name, "Bandwidth", 9)) {
+		} else if (!strcmp(name, "Bandwidth")) {
 			do_skip = GF_TRUE;
-		} else if (!strncmp(name, "SubNumber", 9)) {
+		} else if (!strcmp(name, "SubNumber")) {
 			do_skip = GF_TRUE;
-		} else if (!strncmp(name, "Init", 4)) {
+		} else if (!strncmp(name, "Init", 4) && (name4=='=')) {
 			do_skip = GF_TRUE;
-		} else if (!strncmp(name, "XInit", 4)) {
+		} else if (!strncmp(name, "XInit", 5) && (name5=='=')) {
 			do_skip = GF_TRUE;
-		} else if (!strncmp(name, "Path", 4)) {
+		} else if (!strncmp(name, "Path", 4) && (name4=='=')) {
 			do_skip = GF_TRUE;
 		} else {
 			char *next_eq = strchr(name, '=');
@@ -7622,15 +8134,39 @@
 				//not matching, try with name
 				if (!prop_4cc) {
 					prop_val = gf_filter_pid_get_property_str_first(pid, name);
-					if (!prop_val) {
-						GF_LOG(GF_LOG_WARNING, GF_LOG_FILTER, ("Filter Unrecognized template %s\n", name));
-						is_ok = GF_FALSE;
-					}
+					if (!prop_val && pck)
+						prop_val = gf_filter_pck_get_property_str(pck, name);
 				} else {
 					prop_val = gf_filter_pid_get_property_first(pid, prop_4cc);
-					if (!prop_val) {
-						is_ok = GF_FALSE;
+					if (!prop_val && pck)
+						prop_val = gf_filter_pck_get_property(pck, prop_4cc);
+				}
+
+				if (!prop_val && pck) {
+					if (!strcmp(name, "cts")) {
+						prop_val_patched.type = GF_PROP_LUINT;
+						prop_val_patched.value.longuint = gf_filter_pck_get_cts(pck);
+						prop_val = &prop_val_patched;
+					} else if (!strcmp(name, "dts")) {
+						prop_val_patched.type = GF_PROP_LUINT;
+						prop_val_patched.value.longuint = gf_filter_pck_get_dts(pck);
+						prop_val = &prop_val_patched;
+					} else if (!strcmp(name, "dur")) {
+						prop_val_patched.type = GF_PROP_UINT;
+						prop_val_patched.value.uint = gf_filter_pck_get_duration(pck);
+						prop_val = &prop_val_patched;
+					} else if (!strcmp(name, "sap")) {
+						prop_val_patched.type = GF_PROP_UINT;
+						prop_val_patched.value.uint = gf_filter_pck_get_sap(pck);
+						prop_val = &prop_val_patched;
+					}
+				}
+
+				if (!prop_val) {
+					if (!prop_4cc) {
+						GF_LOG(GF_LOG_WARNING, GF_LOG_FILTER, ("Filter Unrecognized template %s\n", name));
 					}
+					is_ok = GF_FALSE;
 				}
 			} else {
 				u32 i, len = (u32) (next_sep ? 1+(next_sep - name) : strlen(name) );
@@ -8067,3 +8603,42 @@
 	}
 	return GF_OK;
 }
+
+GF_EXPORT
+Bool gf_filter_pid_has_decoder(GF_FilterPid *pid)
+{
+	u32 i;
+	if (PID_IS_OUTPUT(pid)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Attempt to query decoder presence on output PID %s in filter %s\n", pid->pid->name, pid->filter->name));
+		return GF_FALSE;
+	}
+	if (pid->pid->nb_decoder_inputs)
+		return GF_TRUE;
+	gf_mx_p(pid->pid->filter->tasks_mx);
+	for (i=0; i<pid->pid->filter->num_input_pids; i++) {
+		GF_FilterPidInst *pidi = gf_list_get(pid->pid->filter->input_pids, i);
+		if (gf_filter_pid_has_decoder((GF_FilterPid *) pidi)) {
+			gf_mx_v(pid->pid->filter->tasks_mx);
+			return GF_TRUE;
+		}
+	}
+	gf_mx_v(pid->pid->filter->tasks_mx);
+	return GF_FALSE;
+}
+
+GF_EXPORT
+GF_Err gf_filter_pid_set_rt_stats(GF_FilterPid *pid, u32 rtt_ms, u32 jitter_us, u32 loss_rate)
+{
+	GF_FilterPidInst *pidi;
+	if (PID_IS_OUTPUT(pid)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Attempt to set real-time stats on output PID %s in filter %s\n", pid->pid->name, pid->filter->name));
+		return GF_BAD_PARAM;
+	}
+	pidi = (GF_FilterPidInst*)pid;
+	pidi->last_rt_report = gf_sys_clock_high_res();
+	pidi->rtt = rtt_ms;
+	pidi->jitter = jitter_us;
+	pidi->loss_rate = loss_rate;
+	return GF_OK;
+}
+

gpac-2.0.0.tar.gz/src/filter_core/filter_props.c -> gpac-2.2.0.tar.gz/src/filter_core/filter_props.c Changed

@@ -283,25 +283,60 @@
 		break;
 	case GF_PROP_VEC2I:
 		if (!value || (sscanf(value, "%dx%d", &p.value.vec2i.x, &p.value.vec2i.y) != 2)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec2i arg %s - using {0,0}\n", value, name));
-			p.value.vec2i.x = p.value.vec2i.y = 0;
+			//allow following keywords for video resolution
+			if (value && !strcmp(value, "720")) {
+				p.value.vec2i.x = 1280;
+				p.value.vec2i.y = 720;
+			} else if (value && (!strcmp(value, "1080") || !stricmp(value, "hd")) ) {
+				p.value.vec2i.x = 1920;
+				p.value.vec2i.y = 1080;
+			} else if (value && !strcmp(value, "360") ) {
+				p.value.vec2i.x = 640;
+				p.value.vec2i.y = 360;
+			} else if (value && !strcmp(value, "480") ) {
+				p.value.vec2i.x = 640;
+				p.value.vec2i.y = 480;
+			} else if (value && !strcmp(value, "576") ) {
+				p.value.vec2i.x = 720;
+				p.value.vec2i.y = 576;
+			} else if (value && !stricmp(value, "2k") ) {
+				p.value.vec2i.x = 2048;
+				p.value.vec2i.y = 1080;
+			} else if (value && (!strcmp(value, "2160") || !stricmp(value, "4k")) ) {
+				p.value.vec2i.x = 3840;
+				p.value.vec2i.y = 2160;
+			} else if (value && (!strcmp(value, "4320") || !stricmp(value, "8k")) ) {
+				p.value.vec2i.x = 7680;
+				p.value.vec2i.y = 4320;
+			} else {
+				if (value && strcmp(value, "0x0") && strcmp(value, "0")) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec2i arg %s - using {0,0}\n", value, name));
+				}
+				p.value.vec2i.x = p.value.vec2i.y = 0;
+			}
 		}
 		break;
 	case GF_PROP_VEC2:
 		if (!value || (sscanf(value, "%lgx%lg", &p.value.vec2.x, &p.value.vec2.y) != 2)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec2 arg %s - using {0,0}\n", value, name));
+			if (value && strcmp(value, "0x0") && strcmp(value, "0")) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec2 arg %s - using {0,0}\n", value, name));
+			}
 			p.value.vec2.x = p.value.vec2.y = 0;
 		}
 		break;
 	case GF_PROP_VEC3I:
 		if (!value || (sscanf(value, "%dx%dx%d", &p.value.vec3i.x, &p.value.vec3i.y, &p.value.vec3i.z) != 3)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec3i arg %s - using {0,0,0}\n", value, name));
+			if (value && strcmp(value, "0x0x0") && strcmp(value, "0")) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec3i arg %s - using {0,0,0}\n", value, name));
+			}
 			p.value.vec3i.x = p.value.vec3i.y = p.value.vec3i.z = 0;
 		}
 		break;
 	case GF_PROP_VEC4I:
 		if (!value || (sscanf(value, "%dx%dx%dx%d", &p.value.vec4i.x, &p.value.vec4i.y, &p.value.vec4i.z, &p.value.vec4i.w) != 4)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec4i arg %s - using {0,0,0}\n", value, name));
+			if (value && strcmp(value, "0x0x0x0") && strcmp(value, "0")) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec4i arg %s - using {0,0,0}\n", value, name));
+			}
 			p.value.vec4i.x = p.value.vec4i.y = p.value.vec4i.z = p.value.vec4i.w = 0;
 		}
 		break;
@@ -320,7 +355,6 @@
 			}
 		} else if (value && !strnicmp(value, "bxml@", 5) ) {
 			GF_Err e;
-#ifndef GPAC_DISABLE_CORE_TOOLS
 			GF_DOMParser *dom = gf_xml_dom_new();
 			e = gf_xml_dom_parse(dom, value+5, NULL, NULL);
 			if (e) {
@@ -338,10 +372,6 @@
 				}
 			}
 			gf_xml_dom_del(dom);
-#else
-			e = GF_NOT_SUPPORTED;
-			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Failed to binarize XML file %s: %s\n", value+5, gf_error_to_string(e) ));
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
 		} else {
 			p.value.string = value ? gf_strdup(value) : NULL;
 		}
@@ -370,7 +400,6 @@
 			}
 		} else if (!strnicmp(value, "bxml@", 5) ) {
 			GF_Err e;
-#ifndef GPAC_DISABLE_CORE_TOOLS
 			GF_DOMParser *dom = gf_xml_dom_new();
 			e = gf_xml_dom_parse(dom, value+5, NULL, NULL);
 			if (e) {
@@ -386,10 +415,6 @@
 				}
 			}
 			gf_xml_dom_del(dom);
-#else
-			e = GF_NOT_SUPPORTED;
-			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Failed to binarize XML file %s: %s\n", value+5, gf_error_to_string(e) ));
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
 		} else if (!strnicmp(value, "file@", 5) ) {
 			GF_Err e = gf_file_load_data(value+5, (u8 **) &p.value.data.ptr, &p.value.data.size);
 			if (e) {
@@ -398,7 +423,6 @@
 				p.value.data.size=0;
 			}
 		} else if (!strnicmp(value, "b64@", 4) ) {
-#ifndef GPAC_DISABLE_CORE_TOOLS
 			u8 *b64 = (u8 *)value + 5;
 			u32 size = (u32) strlen(b64);
 			p.value.data.ptr = gf_malloc(sizeof(char) * size);
@@ -414,10 +438,6 @@
 				p.value.data.size = 0;
 				p.type=GF_PROP_FORBIDEN;
 			}
-#else
-			GF_Err e = GF_NOT_SUPPORTED;
-			GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Failed to binarize XML file %s: %s\n", value+5, gf_error_to_string(e) ));
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
 		} else {
 			p.value.data.size = (u32) strlen(value);
 			if (p.value.data.size)
@@ -528,7 +548,10 @@
 			} else {
 				s32 v1=0, v2=0;
 				if (sscanf(szV, "%dx%d", &v1, &v2) != 2) {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec2i arg %s%d - using {0,0}\n", value, name, p.value.v2i_list.nb_items));
+					if (strcmp(value, "0x0") && strcmp(value, "0")) {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Wrong argument value %s for vec2i arg %s%d - using {0,0}\n", value, name, p.value.v2i_list.nb_items));
+					}
+					v1 = v2 = 0;
 				}
 				p.value.v2i_list.vals = gf_realloc(p.value.v2i_list.vals, (p.value.v2i_list.nb_items+1) * sizeof(GF_PropVec2i));
 				p.value.v2i_list.valsp.value.v2i_list.nb_items.x = v1;
@@ -934,7 +957,7 @@
 }
 #endif
 
-static void gf_props_assign_value(GF_PropertyEntry *prop, const GF_PropertyValue *value, Bool is_old_prop)
+static GF_Err gf_props_assign_value(GF_PropertyEntry *prop, const GF_PropertyValue *value, Bool is_old_prop)
 {
 	char *src_ptr;
 	//remember source pointer
@@ -949,6 +972,7 @@
 
 	if (prop->prop.type == GF_PROP_STRING) {
 		prop->prop.value.string = value->value.string ? gf_strdup(value->value.string) : NULL;
+		if (value->value.string && !prop->prop.value.string) return GF_OUT_OF_MEM;
 	} else if (prop->prop.type == GF_PROP_STRING_NO_COPY) {
 		prop->prop.value.string = value->value.string;
 		prop->prop.type = GF_PROP_STRING;
@@ -958,6 +982,10 @@
 		if (prop->alloc_size < value->value.data.size) {
 			prop->alloc_size = value->value.data.size;
 			prop->prop.value.data.ptr = gf_realloc(prop->prop.value.data.ptr, sizeof(char) * value->value.data.size);
+			if (!prop->prop.value.data.ptr) {
+				prop->alloc_size = 0;
+				return GF_OUT_OF_MEM;
+			}
 			assert(prop->alloc_size);
 		}
 		memcpy(prop->prop.value.data.ptr, value->value.data.ptr, value->value.data.size);
@@ -974,15 +1002,31 @@
 		else if (prop->prop.type == GF_PROP_SINT_LIST) it_size = sizeof(s32);
 		else if (prop->prop.type == GF_PROP_VEC2I_LIST) it_size = sizeof(GF_PropVec2i);
 		prop->prop.value.uint_list.vals = gf_malloc(it_size * value->value.uint_list.nb_items);
-		if (value->value.uint_list.nb_items)
-			memcpy(prop->prop.value.uint_list.vals, value->value.uint_list.vals, it_size * value->value.uint_list.nb_items);
+		if (!value->value.uint_list.nb_items) return GF_OUT_OF_MEM;
+		memcpy(prop->prop.value.uint_list.vals, value->value.uint_list.vals, it_size * value->value.uint_list.nb_items);
 		prop->prop.value.uint_list.nb_items = value->value.uint_list.nb_items;
 	}
+	else if (prop->prop.type == GF_PROP_STRING_LIST_COPY) {
+		u32 i;
+		prop->prop.type = GF_PROP_STRING_LIST;
+		prop->prop.value.string_list.nb_items = value->value.string_list.nb_items;
+		prop->prop.value.string_list.vals = gf_malloc(sizeof(char*)*value->value.string_list.nb_items);
+		if (!prop->prop.value.string_list.vals) return GF_OUT_OF_MEM;
+		memset(prop->prop.value.string_list.vals, 0, sizeof(char*)*value->value.string_list.nb_items);
+		for (i=0; i<prop->prop.value.string_list.nb_items; i++) {
+			if (value->value.string_list.valsi) {
+				prop->prop.value.string_list.valsi = gf_strdup(value->value.string_list.valsi);
+				if (!prop->prop.value.string_list.valsi) return GF_OUT_OF_MEM;
+			}
+		}
+	}
+	return GF_OK;
 }
 
 GF_Err gf_props_insert_property(GF_PropertyMap *map, u32 hash, u32 p4cc, const char *name, char *dyn_name, const GF_PropertyValue *value)
 {
 	GF_PropertyEntry *prop;
+	GF_Err e;
 #if GF_PROPS_HASHTABLE_SIZE
 	u32 i, count;
 #endif
@@ -1028,7 +1072,11 @@
 		prop->name_alloc=GF_TRUE;
 	}
 
-	gf_props_assign_value(prop, value, GF_FALSE);
+	e = gf_props_assign_value(prop, value, GF_FALSE);
+	if (e) {
+		gf_props_del_property(prop);
+		return e;
+	}
 
 #if GF_PROPS_HASHTABLE_SIZE
 	return gf_list_add(map->hash_tablehash, prop);
@@ -1315,7 +1363,7 @@
 	{ GF_PROP_PID_UNFRAMED, "Unframed", "The media data is not framed, i.e. each packet is not a complete AU/frame or is not in internal format (e.g. annexB for avc/hevc, adts for aac)", GF_PROP_BOOL},
 	{ GF_PROP_PID_UNFRAMED_FULL_AU, "UnframedAU", "The unframed media still has correct AU boundaries: one packet is one full AU, but the packet format might not be the internal one (e.g. annexB for avc/hevc, adts for aac)", GF_PROP_BOOL},
 	{ GF_PROP_PID_UNFRAMED_LATM, "LATM", "Media is unframed AAC in LATM format", GF_PROP_BOOL},
-	{ GF_PROP_PID_DURATION, "Duration", "Media duration", GF_PROP_FRACTION64},
+	{ GF_PROP_PID_DURATION, "Duration", "Media duration (a negative value means an estimated duration based on rate)", GF_PROP_FRACTION64},
 	{ GF_PROP_PID_NB_FRAMES, "NumFrames", "Number of frames in the stream", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_FRAME_OFFSET, "FrameOffset", "Index of first frame in the stream (used for reporting)", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_FRAME_SIZE, "ConstantFrameSize", "Size of the frames for constant frame size streams", GF_PROP_UINT},
@@ -1352,11 +1400,13 @@
 	{ GF_PROP_PID_WIDTH_MAX, "MaxWidth", "Maximum width (video / text / graphics) of all enhancement layers", GF_PROP_UINT},
 	{ GF_PROP_PID_HEIGHT_MAX, "MaxHeight", "Maximum height (video / text / graphics) of all enhancement layers", GF_PROP_UINT},
 	{ GF_PROP_PID_ZORDER, "ZOrder", "Z-order of the video, from 0 (first) to max int (last)", GF_PROP_SINT},
-	{ GF_PROP_PID_TRANS_X, "TransX", "Horizontal translation of the video", GF_PROP_SINT},
-	{ GF_PROP_PID_TRANS_Y, "TransY", "Vertical translation of the video", GF_PROP_SINT},
+	{ GF_PROP_PID_TRANS_X, "TransX", "Horizontal translation of the video (positive towards right)", GF_PROP_SINT},
+	{ GF_PROP_PID_TRANS_Y, "TransY", "Vertical translation of the video (positive towards up)", GF_PROP_SINT},
+	{ GF_PROP_PID_TRANS_X_INV, "TransXRight", "Horizontal offset of the video from right (positive towards right), for cases where reference width is unknown", GF_PROP_SINT},
+	{ GF_PROP_PID_TRANS_Y_INV, "TransYTop", "Vertical translation of the video (0 is top, positive towards down), for cases where reference height is unknown", GF_PROP_SINT},
 	{ GF_PROP_PID_HIDDEN, "Hidden", "PID is hidden in visual/audio rendering", GF_PROP_BOOL},
 
-	{ GF_PROP_PID_CROP_POS, "CropOrigin", "Position in source window, X,Y indicates coord in source", GF_PROP_VEC2I},
+	{ GF_PROP_PID_CROP_POS, "CropOrigin", "Position in source window, X,Y indicate coordinates in source (0,0 for top-left)", GF_PROP_VEC2I},
 	{ GF_PROP_PID_ORIG_SIZE, "OriginalSize", "Original resolution of video", GF_PROP_VEC2I},
 	{ GF_PROP_PID_SRD, "SRD", "Position and size of the video in the referential given by SRDRef", GF_PROP_VEC4I},
 	{ GF_PROP_PID_SRD_REF, "SRDRef", "Width and Height of the SRD referential", GF_PROP_VEC2I},
@@ -1365,7 +1415,7 @@
 	"- Dx,Dy,Dw,Dh: Position and Size of the input video in the reconstructed output, expressed in the output referential given by `SRDRef`", GF_PROP_UINT_LIST},
 
 	{ GF_PROP_PID_ALPHA, "Alpha", "Video in this PID is an alpha map", GF_PROP_BOOL},
-	{ GF_PROP_PID_MIRROR, "Mirror", "Mirror mode (0: no mirror, 1: along Y-axis, 2: along X-axis)", GF_PROP_UINT},
+	{ GF_PROP_PID_MIRROR, "Mirror", "Mirror mode (as bit mask with flags 0: no mirror, 1: along Y-axis, 2: along X-axis)", GF_PROP_UINT},
 	{ GF_PROP_PID_ROTATE, "Rotate", "Video rotation as value*90 degree anti-clockwise", GF_PROP_UINT},
 	{ GF_PROP_PID_CLAP_W, "ClapW", "Width of clean aperture in luma pixels", GF_PROP_FRACTION},
 	{ GF_PROP_PID_CLAP_H, "ClapH", "Height of clean aperture in luma pixels", GF_PROP_FRACTION},
@@ -1397,8 +1447,6 @@
 	{ GF_PROP_SERVICE_WIDTH, "ServiceWidth", "Display width of service", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_SERVICE_HEIGHT, "ServiceHeight", "Display height of service", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_CAROUSEL_RATE, "CarouselRate", "Repeat rate in ms for systems carousel data", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
-	{ GF_PROP_PID_UTC_TIME, "UTC", "UTC date and time of PID", GF_PROP_LUINT, GF_PROP_FLAG_GSF_REM},
-	{ GF_PROP_PID_UTC_TIMESTAMP, "UTCTimestamp", "Timestamp corresponding to UTC date and time", GF_PROP_LUINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_AUDIO_VOLUME, "AudioVolume", "Volume of audio", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_AUDIO_PAN, "AudioPan", "Balance/Pan of audio", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_AUDIO_PRIORITY, "AudioPriority", "Audio thread priority", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
@@ -1415,8 +1463,9 @@
 	{ GF_PROP_PID_OMA_CLEAR_LEN, "PlaintextLen", "OMA size of plaintext data", GF_PROP_LUINT},
 	{ GF_PROP_PID_CRYPT_INFO, "CryptInfo", "URL (local file only) of crypt info file for this PID, use `clear` to force passthrough", GF_PROP_STRING, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_DECRYPT_INFO, "DecryptInfo", "URL (local file only) of crypt info file for this PID - see decrypter help", GF_PROP_STRING, GF_PROP_FLAG_GSF_REM},
-	{ GF_PROP_PCK_SENDER_NTP, "SenderNTP", "NTP time at sender side or grabber side", GF_PROP_LUINT, GF_PROP_FLAG_PCK | GF_PROP_FLAG_GSF_REM},
-	{ GF_PROP_PCK_RECEIVER_NTP, "ReceiverNTP", "Receiver NTP time (usually associated with the sender NTP property)", GF_PROP_LUINT, GF_PROP_FLAG_PCK | GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PCK_SENDER_NTP, "SenderNTP", "NTP 64 bits timestamp at sender side or grabber side", GF_PROP_LUINT, GF_PROP_FLAG_PCK | GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PCK_RECEIVER_NTP, "ReceiverNTP", "Receiver NTP (64 bits timestamp) usually associated with the sender NTP property", GF_PROP_LUINT, GF_PROP_FLAG_PCK | GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PCK_UTC_TIME, "UTC", "UTC timestamp (in milliseconds) of parent packet", GF_PROP_LUINT, GF_PROP_FLAG_PCK | GF_PROP_FLAG_GSF_REM},
 
 	{ GF_PROP_PID_ENCRYPTED, "Encrypted", "Packets for the stream are by default encrypted (however the encryption state is carried in packet crypt flags) - changes are signaled through PID info change (no reconfigure)", GF_PROP_BOOL},
 	{ GF_PROP_PID_OMA_PREVIEW_RANGE, "OMAPreview", "OMA Preview range ", GF_PROP_LUINT},
@@ -1438,6 +1487,7 @@
 	{ GF_PROP_PCK_FILESUF, "FileSuffix", "File suffix name, replacement for $FS$ in tile templates", GF_PROP_STRING, GF_PROP_FLAG_PCK},
 	{ GF_PROP_PCK_EODS, "EODS", "End of DASH segment", GF_PROP_BOOL, GF_PROP_FLAG_PCK},
 	{ GF_PROP_PCK_CUE_START, "CueStart", "Set on packets marking the beginning of a DASH/HLS segment for cue-driven segmentation - see dasher help", GF_PROP_BOOL, GF_PROP_FLAG_PCK},
+	{ GF_PROP_PCK_MEDIA_TIME, "MediaTime", "Corresponding media time of the parent packet (0 being the origin)", GF_PROP_DOUBLE, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_MAX_FRAME_SIZE, "MaxFrameSize", "Max size of frame in stream - changes are signaled through PID info change (no reconfigure)", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_AVG_FRAME_SIZE, "AvgFrameSize", "Average size of frame in stream (ISOBMFF only, static property)", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_MAX_TS_DELTA, "MaxTSDelta", "Maximum DTS delta between frames (ISOBMFF only, static property)", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
@@ -1461,6 +1511,7 @@
 	{ GF_PROP_PID_AS_ID, "ASID", "ID of parent DASH AS", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_MUX_SRC, "MuxSrc", "Name of mux source(s), set by dasher to direct its outputs", GF_PROP_STRING, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_DASH_MODE, "DashMode", "DASH mode to be used by multiplexer if any, set by dasher. 0 is no DASH, 1 is regular DASH, 2 is VoD", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PID_FORCE_SEG_SYNC, "SegSync", "Indicate segment must be completely flushed before sending segment/fragment size events", GF_PROP_BOOL, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_DASH_DUR, "DashDur", "DASH target segment duration in seconds", GF_PROP_FRACTION, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_DASH_MULTI_PID, NULL, "Pointer to the GF_List of input PIDs for multi-stsd entries segments, set by dasher", GF_PROP_POINTER, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_DASH_MULTI_PID_IDX, NULL, "1-based index of PID in the multi PID list, set by dasher", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
@@ -1493,6 +1544,7 @@
 	{ GF_PROP_PID_DASH_PERIOD_START, "DFPStart", "Value of active period start time in forward mode", GF_PROP_LUINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_HLS_KMS, "HLSKey", "URI, KEYFORMAT and KEYFORMATVERSIONS for HLS full segment encryption creation, Key URI otherwise ( decoding and sample-AES)", GF_PROP_STRING},
 	{ GF_PROP_PID_HLS_IV, "HLSIV", "Init Vector for HLS decode", GF_PROP_DATA},
+	{ GF_PROP_PID_CLEARKEY_URI, "CKUrl", "URL for ClearKey licence server", GF_PROP_STRING},
 
 	{ GF_PROP_PID_COLR_PRIMARIES, "ColorPrimaries", "Color primaries", GF_PROP_CICP_COL_PRIM, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_COLR_TRANSFER, "ColorTransfer", "Color transfer characteristics", GF_PROP_CICP_COL_TFC, GF_PROP_FLAG_GSF_REM},
@@ -1502,6 +1554,7 @@
 	{ GF_PROP_PID_COLR_CHROMALOC, "ChromaLoc", "Chroma location (see ISO/IEC 23001-8 / 23091-2)", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_CONTENT_LIGHT_LEVEL, "ContentLightLevel", "Content light level, payload of clli box (see ISO/IEC 14496-12), can be set as a list of 2 integers in fragment declaration (e.g. \"=max_cll,max_pic_avg_ll\")", GF_PROP_DATA, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_MASTER_DISPLAY_COLOUR, "MasterDisplayColour", "Master display colour info, payload of mdcv box (see ISO/IEC 14496-12), can be set as a list of 10 integers in fragment declaration (e.g. \"=dpx0,dpy0,dpx1,dpy1,dpx2,dpy2,wpx,wpy,max,min\")", GF_PROP_DATA, GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PID_ICC_PROFILE, "ICC", "ICC profile (see ISO 15076-1 or ICC.1)", GF_PROP_DATA, GF_PROP_FLAG_GSF_REM},
 
 	{ GF_PROP_PID_SRC_MAGIC, "SrcMagic", "Magic number to store in the track, only used by importers", GF_PROP_LUINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_MUX_INDEX, "MuxIndex", "Target track index in destination file, stored by lowest value first (not set by demultiplexers)", GF_PROP_LUINT, GF_PROP_FLAG_GSF_REM},
@@ -1516,7 +1569,7 @@
 
 	{ GF_PROP_PCK_INIT, "InitSeg", "Set to true if packet is a complete DASH init segment file", GF_PROP_BOOL, GF_PROP_FLAG_PCK},
 
-	{ GF_PROP_PID_RAWGRAB, "RawGrab", "PID is a raw media grabber (webcam, microphone, etc...)", GF_PROP_BOOL, GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PID_RAWGRAB, "RawGrab", "PID is a raw media grabber (webcam, microphone, etc...). Value 2 is used for front camera", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_KEEP_AFTER_EOS, "KeepAfterEOS", "PID must be kept alive after EOS (LASeR and BIFS)", GF_PROP_BOOL, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_COVER_ART, "CoverArt", "PID cover art image data. If associated data is NULL, the data is carried in the PID", GF_PROP_DATA, GF_PROP_FLAG_GSF_REM},
 
@@ -1540,9 +1593,13 @@
 	{ GF_PROP_PID_EQR_CLAMP, "EQRClamp", "Clamping of frame for EQR as 0.32 fixed point (x is top, y is bottom, z is left and w is right)", GF_PROP_VEC4I, GF_PROP_FLAG_GSF_REM},
 
 	{ GF_PROP_PID_SCENE_NODE, "SceneNode", "PID is a scene node decoder (AFX BitWrapper in BIFS)", GF_PROP_BOOL, 0},
-	{ GF_PROP_PID_ORIG_CRYPT_SCHEME, "OrigCryptoScheme", "Original crypto scheme on a decrypted PID", GF_PROP_UINT, 0},
+	{ GF_PROP_PID_ORIG_CRYPT_SCHEME, "OrigCryptoScheme", "Original crypto scheme on a decrypted PID", GF_PROP_4CC, 0},
 	{ GF_PROP_PID_TIMESHIFT_SEGS, "TSBSegs", "Time shift in number of segments for HAS streams, only set by dashin and dasher filters", GF_PROP_UINT, GF_PROP_FLAG_GSF_REM},
 	{ GF_PROP_PID_IS_MANIFEST, "IsManifest", "PID is a HAS manifest", GF_PROP_BOOL, GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PID_SPARSE, "Sparse", "PID has potentially empty times between packets", GF_PROP_BOOL, GF_PROP_FLAG_GSF_REM},
+
+	{ GF_PROP_PID_CHAP_TIMES, "ChapTimes", "Chapter start times", GF_PROP_UINT_LIST, GF_PROP_FLAG_GSF_REM},
+	{ GF_PROP_PID_CHAP_NAMES, "ChapNames", "Chapter names", GF_PROP_STRING_LIST, GF_PROP_FLAG_GSF_REM},
 
 	{ GF_PROP_PCK_SKIP_BEGIN, "SkipBegin", "Amount of media to skip from beginning of packet in PID timescale", GF_PROP_UINT, GF_PROP_FLAG_PCK},
 	{ GF_PROP_PCK_SKIP_PRES, "SkipPres", "Packet and any following with CTS greater than this packet shall not be presented (used by reframer to create edit lists)", GF_PROP_BOOL, GF_PROP_FLAG_PCK},
@@ -1816,6 +1873,7 @@
 	return dump;
 }
 
+
 GF_EXPORT
 const char *gf_props_dump(u32 p4cc, const GF_PropertyValue *att, char dumpGF_PROP_DUMP_ARG_SIZE, u32 dump_data_mode)
 {
@@ -1831,6 +1889,31 @@
 		else if (att->value.uint == GF_PLAYBACK_MODE_REWIND) return "rewind";
 		else if (att->value.uint == GF_PLAYBACK_MODE_FASTFORWARD) return "forward";
 		else return "none";
+
+
+	case GF_PROP_PCK_SENDER_NTP:
+	case GF_PROP_PCK_RECEIVER_NTP:
+	case GF_PROP_PCK_UTC_TIME:
+	{
+		u64 time = (p4cc==GF_PROP_PCK_UTC_TIME) ? att->value.longuint : gf_net_ntp_to_utc(att->value.longuint);
+		time_t gtime;
+		struct tm *t;
+		u32 sec;
+		u32 ms;
+		gtime = time / 1000;
+		sec = (u32)(time / 1000);
+		ms = (u32)(time - ((u64)sec) * 1000);
+
+		t = gf_gmtime(&gtime);
+		sec = t->tm_sec;
+		//see issue #859, no clue how this happened...
+		if (sec > 60)
+			sec = 60;
+		snprintf(dump, GF_PROP_DUMP_ARG_SIZE-1, "%d-%02d-%02dT%02d:%02d:%02d.%03dZ", 1900 + t->tm_year, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, sec, ms);
+		dumpGF_PROP_DUMP_ARG_SIZE-1=0;
+	}
+		return dump;
+
 	default:
 		if (att->type==GF_PROP_UINT) {
 			u32 type = gf_props_4cc_get_type(p4cc);

gpac-2.0.0.tar.gz/src/filter_core/filter_register.c -> gpac-2.2.0.tar.gz/src/filter_core/filter_register.c Changed

@@ -38,6 +38,7 @@
 const GF_FilterRegister *ffsws_register(GF_FilterSession *session);
 const GF_FilterRegister *ffmx_register(GF_FilterSession *session);
 const GF_FilterRegister *ffavf_register(GF_FilterSession *session);
+const GF_FilterRegister *ffbsf_register(GF_FilterSession *session);
 const GF_FilterRegister *inspect_register(GF_FilterSession *session);
 const GF_FilterRegister *probe_register(GF_FilterSession *session);
 const GF_FilterRegister *compose_filter_register(GF_FilterSession *session);
@@ -104,6 +105,7 @@
 const GF_FilterRegister *avimux_register(GF_FilterSession *session);
 const GF_FilterRegister *aout_register(GF_FilterSession *session);
 const GF_FilterRegister *m4vmx_register(GF_FilterSession *session);
+const GF_FilterRegister *vc1mx_register(GF_FilterSession *session);
 const GF_FilterRegister *resample_register(GF_FilterSession *session);
 #if !defined(GPAC_CONFIG_ANDROID)
 const GF_FilterRegister *vout_register(GF_FilterSession *session);
@@ -163,6 +165,17 @@
 const GF_FilterRegister *cryptfin_register(GF_FilterSession *session);
 const GF_FilterRegister *cryptfout_register(GF_FilterSession *session);
 const GF_FilterRegister *restamp_register(GF_FilterSession *session);
+const GF_FilterRegister *oggmux_register(GF_FilterSession *session);
+const GF_FilterRegister *vtt2tx3g_register(GF_FilterSession *session);
+const GF_FilterRegister *rfsrt_register(GF_FilterSession *session);
+const GF_FilterRegister *ttxtuf_register(GF_FilterSession *session);
+const GF_FilterRegister *tx3g2srt_register(GF_FilterSession *session);
+const GF_FilterRegister *tx3g2vtt_register(GF_FilterSession *session);
+const GF_FilterRegister *tx3g2ttml_register(GF_FilterSession *session);
+const GF_FilterRegister *ttmlconv_register(GF_FilterSession *session);
+const GF_FilterRegister *ttmlconv2_register(GF_FilterSession *session);
+const GF_FilterRegister *unframer_register(GF_FilterSession *session);
+const GF_FilterRegister *writeuf_register(GF_FilterSession *session);
 
 void gf_fs_reg_all(GF_FilterSession *fsess, GF_FilterSession *a_sess)
 {
@@ -239,6 +252,7 @@
 	gf_fs_add_filter_register(fsess, avimux_register(a_sess) );
 	gf_fs_add_filter_register(fsess, aout_register(a_sess) );
 	gf_fs_add_filter_register(fsess, m4vmx_register(a_sess) );
+	gf_fs_add_filter_register(fsess, vc1mx_register(a_sess) );
 	gf_fs_add_filter_register(fsess, resample_register(a_sess) );
 #if !defined(GPAC_CONFIG_ANDROID)
 	gf_fs_add_filter_register(fsess, vout_register(a_sess) );
@@ -283,6 +297,14 @@
 	gf_fs_add_filter_register(fsess, bsrw_register(a_sess));
 	gf_fs_add_filter_register(fsess, bs_split_register(a_sess));
 	gf_fs_add_filter_register(fsess, bs_agg_register(a_sess));
+	gf_fs_add_filter_register(fsess, ttxtuf_register(a_sess));
+	gf_fs_add_filter_register(fsess, tx3g2srt_register(a_sess));
+	gf_fs_add_filter_register(fsess, tx3g2vtt_register(a_sess));
+	gf_fs_add_filter_register(fsess, tx3g2ttml_register(a_sess));
+	gf_fs_add_filter_register(fsess, vtt2tx3g_register(a_sess) );
+	gf_fs_add_filter_register(fsess, rfsrt_register(a_sess) );
+	gf_fs_add_filter_register(fsess, ttmlconv_register(a_sess) );
+	gf_fs_add_filter_register(fsess, ttmlconv2_register(a_sess) );
 
 	gf_fs_add_filter_register(fsess, ffdmx_register(a_sess) );
 	gf_fs_add_filter_register(fsess, ffdec_register(a_sess) );
@@ -291,6 +313,7 @@
 	gf_fs_add_filter_register(fsess, ffenc_register(a_sess) );
 	gf_fs_add_filter_register(fsess, ffmx_register(a_sess) );
 	gf_fs_add_filter_register(fsess, ffavf_register(a_sess) );
+	gf_fs_add_filter_register(fsess, ffbsf_register(a_sess) );
 
 	gf_fs_add_filter_register(fsess, jsfilter_register(a_sess) );
 	gf_fs_add_filter_register(fsess, routeout_register(a_sess) );
@@ -298,6 +321,10 @@
 	gf_fs_add_filter_register(fsess, cryptfin_register(a_sess) );
 	gf_fs_add_filter_register(fsess, cryptfout_register(a_sess) );
 	gf_fs_add_filter_register(fsess, restamp_register(a_sess) );
+	gf_fs_add_filter_register(fsess, oggmux_register(a_sess) );
+
+	gf_fs_add_filter_register(fsess, unframer_register(a_sess) );
+	gf_fs_add_filter_register(fsess, writeuf_register(a_sess) );
 
 #if !defined(GPAC_CONFIG_IOS) && !defined(GPAC_CONFIG_ANDROID) && !defined(GPAC_HAVE_DTAPI) && !defined(WIN32) 
 	gf_fs_add_filter_register(fsess, dtout_register(a_sess) );

gpac-2.0.0.tar.gz/src/filter_core/filter_session.c -> gpac-2.2.0.tar.gz/src/filter_core/filter_session.c Changed

@@ -29,6 +29,8 @@
 #ifndef GPAC_DISABLE_3D
 #include <gpac/modules/video_out.h>
 #endif
+#include <gpac/module.h>
+
 //#define CHECK_TASK_LIST_INTEGRITY
 
 #ifndef GPAC_DISABLE_PLAYER
@@ -127,12 +129,11 @@
 			}
 			blacklist = fname+len;
 		}
+		if (is_whitelist) match = !match;
+
 		if (match) {
-			if (!is_whitelist)
-				return;
-		} else {
-			if (is_whitelist)
-				return;
+			if (freg->register_free) freg->register_free(fsess, (GF_FilterRegister *)freg);
+			return;
 		}
 	}
 	//except for meta filters, don't accept a filter with input caps but no output caps
@@ -143,6 +144,7 @@
 		&& gf_filter_has_in_caps(freg->caps, freg->nb_caps)
 	) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Filter %s missing configure_pid function but has input capabilities - ignoring\n", freg->name));
+		if (freg->register_free) freg->register_free(fsess, (GF_FilterRegister *)freg);
 		return;
 	}
 
@@ -161,7 +163,7 @@
 {
 	GF_FilterSession *fs = (GF_FilterSession *)ptr;
 	if (evt->type==GF_EVENT_QUIT) {
-		gf_fs_abort(fs, GF_FS_FLUSH_FAST);
+		gf_fs_abort(fs, (evt->message.error) ? GF_FS_FLUSH_NONE : GF_FS_FLUSH_FAST);
 	}
 	if (evt->type==GF_EVENT_MESSAGE) {
 		if (evt->message.error) {
@@ -174,10 +176,41 @@
 	}
 
 #ifdef GPAC_HAS_QJS
-	if (fs->on_evt_task)
-		return jsfs_on_event(fs, evt);
+	if (fs->on_evt_task && jsfs_on_event(fs, evt))
+		return GF_TRUE;
 #endif
-	return 0;
+
+	if (evt->type==GF_EVENT_AUTHORIZATION) {
+#ifdef GPAC_HAS_QJS
+		if (fs->on_auth_task && jsfs_on_auth(fs, evt))
+			return GF_TRUE;
+#endif
+
+		if (gf_sys_is_test_mode()) {
+			return GF_FALSE;
+		}
+		assert( evt->type == GF_EVENT_AUTHORIZATION);
+		assert( evt->auth.user);
+		assert( evt->auth.password);
+		assert( evt->auth.site_url);
+
+		fprintf(stderr, "**** Authorization required for site %s %s ****\n", evt->auth.site_url, evt->auth.secure ? "(secure)" : "- NOT SECURE");
+		fprintf(stderr, "login : ");
+		if (!gf_read_line_input(evt->auth.user, 50, 1))
+			return GF_FALSE;
+		fprintf(stderr, "\npassword: ");
+		if (!gf_read_line_input(evt->auth.password, 50, 0))
+			return GF_FALSE;
+		fprintf(stderr, "*********\n");
+
+		if (evt->auth.on_usr_pass) {
+			evt->auth.on_usr_pass(evt->auth.async_usr_data, evt->auth.user, evt->auth.password, GF_FALSE);
+			evt->auth.password0 = 0;
+		}
+		return GF_TRUE;
+	}
+
+	return GF_FALSE;
 }
 
 
@@ -368,9 +401,9 @@
 
 	fsess->run_status = GF_EOS;
 	fsess->nb_threads_stopped = 1+nb_threads;
-	fsess->default_pid_buffer_max_us = 1000;
-	fsess->decoder_pid_buffer_max_us = 1000000;
-	fsess->default_pid_buffer_max_units = 1;
+	fsess->default_pid_buffer_max_us = gf_opts_get_int("core", "buffer-gen");
+	fsess->decoder_pid_buffer_max_us = gf_opts_get_int("core", "buffer-dec");
+	fsess->default_pid_buffer_max_units = gf_opts_get_int("core", "buffer-units");
 	fsess->max_resolve_chain_len = 6;
 	fsess->auto_inc_nums = gf_list_new();
 
@@ -396,7 +429,7 @@
 			if ((arg1!='-') && (arg1!='+')) continue;
 			char *sep = strchr(arg, '=');
 			if (sep) sep0 = 0;
-			gf_fs_push_arg(fsess, arg+2, GF_FALSE, (arg1=='-') ? GF_ARGTYPE_GLOBAL : GF_ARGTYPE_META, NULL);
+			gf_fs_push_arg(fsess, arg+2, GF_FALSE, (arg1=='-') ? GF_ARGTYPE_GLOBAL : GF_ARGTYPE_META, NULL, NULL);
 
 			//force indexing in reframers when dash template with bandwidth is used
 			if (sep && !strcmp(arg+2, "template") && strstr(sep+1, "$Bandwidth$")) {
@@ -416,7 +449,7 @@
 	return fsess;
 }
 
-void gf_fs_push_arg(GF_FilterSession *session, const char *szArg, Bool was_found, GF_FSArgItemType type, GF_Filter *meta_filter)
+void gf_fs_push_arg(GF_FilterSession *session, const char *szArg, Bool was_found, GF_FSArgItemType type, GF_Filter *meta_filter, const char *sub_opt_name)
 {
 	u32 meta_len = meta_filter ? (u32) strlen(meta_filter->freg->name) : 0;
 	Bool create_if_not_found = GF_TRUE;
@@ -424,69 +457,66 @@
 		return;
 
 	//ignore any meta argument reported (found or not) that is not already present
-	if (type==GF_ARGTYPE_META_REPORTING) {
+	//if sub_opt_name, we must create an entry
+	if (!sub_opt_name && (type==GF_ARGTYPE_META_REPORTING)) {
 		create_if_not_found = GF_FALSE;
 	}
-	if (!was_found) {
-		Bool afound = GF_FALSE;
-		u32 k, acount;
-		if (!session->parsed_args) session->parsed_args = gf_list_new();
-		acount = gf_list_count(session->parsed_args);
-		for (k=0; k<acount; k++) {
-			GF_FSArgItem *ai = gf_list_get(session->parsed_args, k);
-			if (!strcmp(ai->argname, szArg)) {
-				afound = GF_TRUE;
-				break;
-			}
-			if (meta_len
-				&& !strncmp(ai->argname, meta_filter->freg->name, meta_len)
-				&& ((ai->argnamemeta_len==':') || (ai->argnamemeta_len=='@'))
-				&& !strcmp(ai->argname+meta_len+1, szArg)
-			) {
-				afound = GF_TRUE;
-				break;
-			}
-		}
-		if (!afound && create_if_not_found) {
-			GF_FSArgItem *ai;
-			GF_SAFEALLOC(ai, GF_FSArgItem);
-			if (ai) {
-				ai->argname = gf_strdup(szArg);
-				ai->type = type;
-				gf_list_add(session->parsed_args, ai );
-			}
+	if (!session->parsed_args) session->parsed_args = gf_list_new();
+
+	u32 k, acount = gf_list_count(session->parsed_args);
+	GF_FSArgItem *ai=NULL;
+	for (k=0; k<acount; k++) {
+		ai = gf_list_get(session->parsed_args, k);
+		if (!strcmp(ai->argname, szArg))
+			break;
+
+		if (meta_len
+			&& !strncmp(ai->argname, meta_filter->freg->name, meta_len)
+			&& ((ai->argnamemeta_len==':') || (ai->argnamemeta_len=='@'))
+			&& !strcmp(ai->argname+meta_len+1, szArg)
+		) {
+			break;
 		}
-	} else {
-		u32 k, acount;
-		Bool found = GF_FALSE;
-		if (!session->parsed_args) session->parsed_args = gf_list_new();
-		acount = gf_list_count(session->parsed_args);
-		for (k=0; k<acount; k++) {
-			GF_FSArgItem *ai = gf_list_get(session->parsed_args, k);
-			if (!strcmp(ai->argname, szArg)) {
-				ai->found = was_found;
-				found = GF_TRUE;
-				break;
-			}
-			if (meta_len
-				&& !strncmp(ai->argname, meta_filter->freg->name, meta_len)
-				&& ((ai->argnamemeta_len==':') || (ai->argnamemeta_len=='@'))
-				&& !strcmp(ai->argname+meta_len+1, szArg)
-			) {
-				ai->found = was_found;
-				found = GF_TRUE;
-				break;
+		ai = NULL;
+	}
+	if (!ai && create_if_not_found) {
+		GF_SAFEALLOC(ai, GF_FSArgItem);
+		if (ai) {
+			ai->argname = gf_strdup(szArg);
+			ai->type = type;
+			if ((type==GF_ARGTYPE_META_REPORTING) && meta_filter) {
+				ai->meta_filter = meta_filter->freg->name;
+				ai->meta_opt = sub_opt_name;
 			}
+			gf_list_add(session->parsed_args, ai );
 		}
-		if (!found && create_if_not_found) {
-			GF_FSArgItem *ai;
-			GF_SAFEALLOC(ai, GF_FSArgItem);
-			if (ai) {
-				ai->argname = gf_strdup(szArg);
-				ai->type = type;
-				ai->found = GF_TRUE;
-				gf_list_add(session->parsed_args, ai );
-			}
+	}
+	if (!ai) return;
+
+	if (type==GF_ARGTYPE_META_REPORTING) {
+		//meta option declared as true by default at init but notified as not found
+		if (ai->meta_state==3) {
+			ai->meta_state = 0;
+			if (!was_found) ai->opt_found = 0;
+		}
+		if (!ai->meta_state) {
+			ai->opt_found = 0;
+			ai->meta_state = 1;
+			if (!ai->meta_filter) {
+				ai->meta_filter = meta_filter->freg->name;
+				ai->meta_opt = sub_opt_name;
+			}
+		}
+		if (was_found)
+			ai->meta_state = 2;
+	} else if (was_found && !ai->meta_state) {
+		ai->opt_found = 1;
+		//initial declaration from filter setup: meta args are declared as true by default
+		if (type==GF_ARGTYPE_LOCAL) {
+			//forbid further meta state change
+			ai->meta_state = 1;
+			//meta option, mark as not found
+			if (meta_filter) ai->meta_state = 3;
 		}
 	}
 }
@@ -647,7 +677,7 @@
 
 
 GF_EXPORT
-Bool gf_fs_enum_unmapped_options(GF_FilterSession *fsess, u32 *idx, char **argname, u32 *argtype)
+Bool gf_fs_enum_unmapped_options(GF_FilterSession *fsess, u32 *idx, const char **argname, u32 *argtype, const char **meta_filter, const char **meta_sub_opt)
 {
 	if (!fsess || !fsess->parsed_args) return GF_FALSE;
 	u32 i, count = gf_list_count(fsess->parsed_args);
@@ -655,14 +685,23 @@
 	for (i=*idx; i<count; i++) {
 		GF_FSArgItem *ai = gf_list_get(fsess->parsed_args, i);
 		(*idx)++;
-		if (ai->found) continue;
+		if (ai->opt_found || (ai->meta_state==2)) continue;
 		if (argname) *argname = ai->argname;
 		if (argtype) *argtype = ai->type;
+		if (meta_filter) *meta_filter = ai->meta_filter;
+		if (meta_sub_opt) *meta_sub_opt = ai->meta_opt;
 		return GF_TRUE;
 	}
 	return GF_FALSE;
 }
 
+void task_canceled(GF_FSTask *task);
+static void gf_task_del(void *p)
+{
+	GF_FSTask *t = (GF_FSTask *) p;
+	task_canceled(t);
+	gf_free(p);
+}
 
 GF_EXPORT
 void gf_fs_del(GF_FilterSession *fsess)
@@ -760,14 +799,14 @@
 	}
 
 	if (fsess->tasks)
-		gf_fq_del(fsess->tasks, gf_void_del);
+		gf_fq_del(fsess->tasks, gf_task_del);
 
 	if (fsess->tasks_reservoir)
 		gf_fq_del(fsess->tasks_reservoir, gf_void_del);
 
 	if (fsess->threads) {
 		if (fsess->main_thread_tasks)
-			gf_fq_del(fsess->main_thread_tasks, gf_void_del);
+			gf_fq_del(fsess->main_thread_tasks, gf_task_del);
 
 		while (gf_list_count(fsess->threads)) {
 			GF_SessionThread *sess_th = gf_list_pop_back(fsess->threads);
@@ -872,7 +911,7 @@
 }
 #endif
 
-void gf_fs_post_task_ex(GF_FilterSession *fsess, gf_fs_task_callback task_fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta, Bool is_configure, Bool force_main_thread, Bool force_direct_call)
+void gf_fs_post_task_ex(GF_FilterSession *fsess, gf_fs_task_callback task_fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta, Bool is_configure, Bool force_main_thread, Bool force_direct_call, u32 class_type)
 {
 	GF_FSTask *task;
 	Bool notified = GF_FALSE;
@@ -940,6 +979,7 @@
 	task->run_task = task_fun;
 	task->log_name = log_name;
 	task->udta = udta;
+	task->class_type = class_type;
 
 	if (filter && is_configure) {
 		if (filter->freg->flags & GF_FS_REG_CONFIGURE_MAIN_THREAD)
@@ -1007,7 +1047,12 @@
 
 void gf_fs_post_task(GF_FilterSession *fsess, gf_fs_task_callback task_fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta)
 {
-	gf_fs_post_task_ex(fsess, task_fun, filter, pid, log_name, udta, GF_FALSE, GF_FALSE, GF_FALSE);
+	gf_fs_post_task_ex(fsess, task_fun, filter, pid, log_name, udta, GF_FALSE, GF_FALSE, GF_FALSE, TASK_TYPE_NONE);
+}
+
+void gf_fs_post_task_class(GF_FilterSession *fsess, gf_fs_task_callback task_fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta, u32 class_id)
+{
+	gf_fs_post_task_ex(fsess, task_fun, filter, pid, log_name, udta, GF_FALSE, GF_FALSE, GF_FALSE, class_id);
 }
 
 Bool gf_fs_check_filter_register_cap_ex(const GF_FilterRegister *f_reg, u32 incode, GF_PropertyValue *cap_input, u32 outcode, GF_PropertyValue *cap_output, Bool exact_match_only, Bool out_cap_excluded)
@@ -1088,7 +1133,7 @@
 	szCodec1 = fsess->sep_name;
 	szCodec2 = 0;
 
-	cid = strstr(args, szCodec);
+	cid = args ? strstr(args, szCodec) : NULL;
 	if (!cid) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_FILTER, ("Missing codec identifier in \"enc\" definition: %s\n", args ? args : "no arguments"));
 		return NULL;
@@ -1445,6 +1490,7 @@
 				}
 				if (!task) {
 					task = gf_fq_pop(fsess->tasks);
+					//if task is blocking, don't use it, let a secondary thread deal with it
 					if (task && task->blocking) {
 						gf_fq_add(fsess->tasks, task);
 						task = NULL;
@@ -1565,6 +1611,20 @@
 		}
 		current_filter = task->filter;
 
+		if (current_filter && current_filter->restrict_th_idx && (thid != current_filter->restrict_th_idx)) {
+			//reschedule task to secondary list
+			if (!task->notified) {
+				task->notified = GF_TRUE;
+				safe_int_inc(&fsess->tasks_pending);
+			}
+			gf_fq_add(fsess->tasks, task);
+			gf_fs_sema_io(fsess, GF_TRUE, GF_FALSE);
+			current_filter = NULL;
+			continue;
+		}
+
+		assert(!current_filter || !current_filter->restrict_th_idx || (thid == current_filter->restrict_th_idx));
+
 		//this is a crude way of scheduling the next task, we should
 		//1- have a way to make sure we will not repost after a time-consuming task
 		//2- have a way to wait for the given amount of time rather than just do a sema_wait/notify in loop
@@ -1794,7 +1854,7 @@
 		if (task->filter)
 			task->filter->last_schedule_task_time = task_time;
 
-		task->can_swap = GF_FALSE;
+		task->can_swap = 0;
 		task->requeue_request = GF_FALSE;
 		task->run_task(task);
 		requeue = task->requeue_request;
@@ -1811,13 +1871,24 @@
 
 		//source task was current filter, pop the filter task list
 		if (current_filter) {
+			Bool last_task = GF_FALSE;
 			current_filter->nb_tasks_done++;
 			current_filter->time_process += task_time;
 			consecutive_filter_tasks++;
 
 			gf_mx_p(current_filter->tasks_mx);
+			if (gf_fq_count(current_filter->tasks)==1) {
+				//if task is set to immediate reschedule, don't consider this is the last task
+				//and check consecutive_filter_tasks - this will keep the active filter running
+				//when the last task is a process task and the filter is not blocking
+				//FIXME: commented out as this breaks ssome tests, needs further checking
+				//if (task->can_swap!=2)
+				{
+					last_task = GF_TRUE;
+				}
+			}
 			//if last task
-			if ( (gf_fq_count(current_filter->tasks)==1)
+			if ( last_task
 				//if requeue request and stream reset pending (we must exit the filter task loop for the reset task to pe processed)
 				|| (requeue && current_filter->stream_reset_pending)
 				//or requeue request and pid swap pending (we must exit the filter task loop for the swap task to pe processed)
@@ -1926,6 +1997,12 @@
 				//main thread
 				if (task->filter && (task->filter->freg->flags & GF_FS_REG_MAIN_THREAD)) {
 					gf_fq_add(fsess->main_thread_tasks, task);
+
+					//FIXME, we sometimes miss a sema notfiy resulting in secondary tasks being locked
+					//until we find the cause, notify secondary sema if non-main-thread tasks are scheduled and we are the only task in main
+					if (use_main_sema && (thid==0) && fsess->threads && (gf_fq_count(fsess->main_thread_tasks)==1) && gf_fq_count(fsess->tasks)) {
+						gf_fs_sema_io(fsess, GF_TRUE, GF_FALSE);
+					}
 				} else {
 					gf_fq_add(fsess->tasks, task);
 				}
@@ -2063,7 +2140,7 @@
 
 	task->pid->filter->freg->process_event(task->pid->filter, &evt);
 	gf_filter_pid_set_eos(task->pid);
-	task->pid->filter->disabled = GF_TRUE;
+	task->pid->filter->disabled = GF_FILTER_DISABLED;
 	safe_int_dec(&task->pid->filter->abort_pending);
 
 }
@@ -2100,7 +2177,8 @@
 
 		if (!filter->num_input_pids) {
 			u32 j, k, l;
-			filter->disabled = GF_TRUE;
+			if (!filter->disabled)
+				filter->disabled = GF_FILTER_DISABLED;
 			for (j=0; j<filter->num_output_pids; j++) {
 				const GF_PropertyValue *p;
 				GF_FilterPid *pid = gf_list_get(filter->output_pids, j);
@@ -2148,7 +2226,7 @@
 					gf_mx_p(filter->tasks_mx);
 					//no filter_abort pending, disable the filter
 					if (force_disable)
-						pidi->filter->disabled = GF_TRUE;
+						pidi->filter->disabled = GF_FILTER_DISABLED;
 				}
 			}
 		}
@@ -2167,6 +2245,8 @@
 						GF_FilterPid *pid = gf_list_get(pidi->pid->filter->input_pids, k);
 						GF_FEVT_INIT(evt, GF_FEVT_STOP, pid);
 						gf_filter_pid_send_event(pid, &evt);
+						//and force pid to be in eos, since we do a fast flush EOS may not be dispatched by input filter(s)
+						gf_filter_pid_set_eos(pid->pid);
 					}
 					gf_mx_v(pidi->pid->filter->tasks_mx);
 				}
@@ -2174,6 +2254,8 @@
 				else {
 					GF_FEVT_INIT(evt, GF_FEVT_STOP, (GF_FilterPid *) pidi);
 					gf_filter_pid_send_event((GF_FilterPid *) pidi, &evt);
+					//and force pid to be in eos, since we do a fast flush EOS may not be dispatched by input filter(s)
+					gf_filter_pid_set_eos(pidi->pid);
 				}
 			}
 		}
@@ -2546,6 +2628,8 @@
 		GF_Filter *f = gf_list_get(fsess->filters, i);
 		//only dump not connected ones
 		if (f->num_input_pids || f->num_output_pids || f->multi_sink_target || f->nb_tasks_done) continue;
+		if (f->disabled==GF_FILTER_DISABLED_HIDE) continue;
+
 		if (ignore_sinks) {
 			Bool has_outputs;
 			if (f->forced_caps)
@@ -2606,6 +2690,7 @@
 		GF_Filter *f = gf_list_get(fsess->filters, i);
 		if (f->multi_sink_target) continue;
 		if (gf_list_find(filters_done, f)>=0) continue;
+		if (f->disabled==GF_FILTER_DISABLED_HIDE) continue;
 		if (!has_undefined) {
 			has_undefined = GF_TRUE;
 			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Filters in unknown connection state:\n"));
@@ -2621,13 +2706,13 @@
 void gf_fs_print_unused_args(GF_FilterSession *fsess, const char *ignore_args)
 {
 	u32 idx = 0;
-	char *argname;
+	const char *argname;
 	u32 argtype;
 
 	while (1) {
 		Bool found = GF_FALSE;
 		const char *loc_arg;
-		if (gf_fs_enum_unmapped_options(fsess, &idx, &argname, &argtype)==GF_FALSE)
+		if (gf_fs_enum_unmapped_options(fsess, &idx, &argname, &argtype, NULL, NULL)==GF_FALSE)
 			break;
 
 		loc_arg = ignore_args;
@@ -2855,7 +2940,9 @@
 	return NULL;
 }
 
-GF_Filter *gf_fs_load_source_dest_internal(GF_FilterSession *fsess, const char *url, const char *user_args, const char *parent_url, GF_Err *err, GF_Filter *filter, GF_Filter *dst_filter, Bool for_source, Bool no_args_inherit, Bool *probe_only)
+Bool filter_solve_gdocs(const char *url, char szPathGF_MAX_PATH);
+
+GF_Filter *gf_fs_load_source_dest_internal(GF_FilterSession *fsess, const char *url, const char *user_args, const char *parent_url, GF_Err *err, GF_Filter *filter, GF_Filter *dst_filter, Bool for_source, Bool no_args_inherit, Bool *probe_only, const GF_FilterRegister **probe_reg)
 {
 	GF_FilterProbeScore score = GF_FPROBE_NOT_SUPPORTED;
 	GF_FilterRegister *candidate_freg=NULL;
@@ -2864,6 +2951,7 @@
 	u32 i, count, user_args_len, arg_type;
 	char szForceReg20;
 	char szMime50;
+	char szForceExt20;
 	GF_Err e;
 	const char *force_freg = NULL;
 	char *sURL, *mime_type, *args, *sep;
@@ -2877,6 +2965,7 @@
 	}
 	if (err) *err = GF_OK;
 
+	szForceExt0 = 0;
 	mime_type = NULL;
 	//destination, extract mime from arguments
 	if (!for_source) {
@@ -2892,12 +2981,27 @@
 			if (sep) sep0 = 0;
 			mime_type = szMime;
 		}
+		sprintf(szForceExt, "%cext=", fsess->sep_args);
+		char *ext = strstr(url, szForceExt);
+		if (ext) {
+			ext+=5;
+			snprintf(szForceExt, 19, "test.%s", ext);
+			szForceExt19=0;
+			ext = strchr(szForceExt, fsess->sep_args);
+			if (ext) ext0 = 0;
+		}
 	}
 	sURL = NULL;
 	if (filter) {
 		sURL = (char *) url;
 	} else {
+		char szSolvedPathGF_MAX_PATH;
 		Bool is_local;
+
+		if (!strncmp(url, "$GDOCS", 6)) {
+			if (filter_solve_gdocs(url, szSolvedPath))
+				url = szSolvedPath;
+		}
 		/*used by GUIs scripts to skip URL concatenation*/
 		if (!strncmp(url, "gpac://", 7)) sURL = gf_strdup(url+7);
 		/*opera-style localhost URLs*/
@@ -2970,7 +3074,8 @@
 			if (sep) sep0 = fsess->sep_args;
 		}
 	}
-	sep = (char *)gf_fs_path_escape_colon(fsess, sURL);
+	Bool needs_escape;
+	sep = (char *)gf_fs_path_escape_colon_ex(fsess, sURL, &needs_escape, for_source);
 
 	sprintf(szForceReg, "gfreg%c", fsess->sep_name);
 	force_freg = NULL;
@@ -3021,6 +3126,8 @@
 			continue;
 
 		s = freg->probe_url(sURL, mime_type);
+		if (szForceExt0 && (s==GF_FPROBE_NOT_SUPPORTED))
+			s = freg->probe_url(szForceExt, mime_type);
 		/* destination meta filter: change GF_FPROBE_SUPPORTED to GF_FPROBE_MAYBE_SUPPORTED for internal mux formats
 		in order to avoid always giving the hand to the meta filter*/
 		if (!for_source && (s == GF_FPROBE_SUPPORTED) && (freg->flags & GF_FS_REG_META)) {
@@ -3039,6 +3146,8 @@
 	}
 	if (probe_only) {
 		*probe_only = candidate_freg ? GF_TRUE : GF_FALSE;
+		if (probe_reg) *probe_reg = candidate_freg;
+
 		if (free_url)
 			gf_free(sURL);
 		if (err) *err = GF_OK;
@@ -3060,19 +3169,33 @@
 	if (sep) sep0 = fsess->sep_args;
 
 	user_args_len = user_args ? (u32) strlen(user_args) : 0;
-	args = gf_malloc(sizeof(char)*(5+strlen(sURL) + (user_args_len ? user_args_len + 8/*for potential :gpac: */ :0) ) );
-
+	args = gf_malloc(sizeof(char)*5);
+	
 	sprintf(args, "%s%c", for_source ? "src" : "dst", fsess->sep_name);
-	strcat(args, sURL);
+	//path is using ':' and has options specified, inject :gpac before first option
+	if (sep && needs_escape) {
+		sep0=0;
+		gf_dynstrcat(&args, sURL, NULL);
+		gf_dynstrcat(&args, ":gpac", NULL);
+		sep0 = fsess->sep_args;
+		gf_dynstrcat(&args, sep, NULL);
+	} else {
+		gf_dynstrcat(&args, sURL, NULL);
+	}
+	//path is using ':' and has no specified, inject :gpac: at end
+	if (needs_escape && !sep && !user_args_len)
+		gf_dynstrcat(&args, ":gpac:", NULL);
+
 	if (user_args_len) {
-		if (fsess->sep_args==':') strcat(args, ":gpac:");
+		if (fsess->sep_args==':')
+			gf_dynstrcat(&args, ":gpac:", NULL);
 		else {
 			char szSep2;
 			szSep0 = fsess->sep_args;
 			szSep1 = 0;
-			strcat(args, szSep);
+			gf_dynstrcat(&args, szSep, NULL);
 		}
-		strcat(args, user_args);
+		gf_dynstrcat(&args, user_args, NULL);
 	}
 
 	e = GF_OK;
@@ -3122,6 +3245,8 @@
 			//to remember our connection target
 			filter->target_filter = dst_filter;
 		}
+		if (dst_filter)
+			filter->subsession_id = dst_filter->subsession_id;
 	} else {
 		gf_free(args);
 	}
@@ -3135,13 +3260,13 @@
 GF_EXPORT
 GF_Filter *gf_fs_load_source(GF_FilterSession *fsess, const char *url, const char *args, const char *parent_url, GF_Err *err)
 {
-	return gf_fs_load_source_dest_internal(fsess, url, args, parent_url, err, NULL, NULL, GF_TRUE, GF_FALSE, NULL);
+	return gf_fs_load_source_dest_internal(fsess, url, args, parent_url, err, NULL, NULL, GF_TRUE, GF_FALSE, NULL, NULL);
 }
 
 GF_EXPORT
 GF_Filter *gf_fs_load_destination(GF_FilterSession *fsess, const char *url, const char *args, const char *parent_url, GF_Err *err)
 {
-	return gf_fs_load_source_dest_internal(fsess, url, args, parent_url, err, NULL, NULL, GF_FALSE, GF_FALSE, NULL);
+	return gf_fs_load_source_dest_internal(fsess, url, args, parent_url, err, NULL, NULL, GF_FALSE, GF_FALSE, NULL, NULL);
 }
 
 
@@ -3231,6 +3356,7 @@
 	Bool has_output, has_input;
 
 	if (!js_filter) {
+		if (!filter_name) return;
 		js_filter = gf_fs_load_filter(session, filter_name, &e);
 		if (!js_filter) return;
 	} else {
@@ -3356,20 +3482,14 @@
 		if (filter_name && strcmp(src->freg->name, filter_name))
 			continue;
 
-		if (!src->nb_edges) {
-			if (print_fn)
-				print_fn(stderr, 1, "%s: no sources\n", src->freg->name);
-			else {
-				GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s: no sources\n", src->freg->name));
-			}
-			continue;
-		}
 		found = GF_TRUE;
 		if (print_fn)
-			print_fn(stderr, 1, "%s sources:", src->freg->name);
+			print_fn(stderr, 1, "%s sources:%s", src->freg->name, src->nb_edges ? "" : " none");
 		else {
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s sources:", src->freg->name));
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s sources:%s", src->freg->name, src->nb_edges ? "" : " none"));
 		}
+		if (!src->nb_edges)
+			continue;
 
 		for (j=0; j<src->nb_edges; j++) {
 			if (gf_list_find(done, (void *) src->edgesj.src_reg->freg->name)<0) {
@@ -3412,6 +3532,7 @@
 	}
 
 	if (found && filter_name) {
+		u32 nb_sinks=0;
 		if (print_fn)
 			print_fn(stderr, 1, "%s sinks:", filter_name);
 		else {
@@ -3429,6 +3550,7 @@
 				if (strcmp(src->edgesj.src_reg->freg->name, filter_name)) continue;
 
 				if (gf_list_find(done, (void *) src->freg->name)<0) {
+					nb_sinks++;
 					if (print_fn)
 						print_fn(stderr, 0, " %s", src->freg->name);
 					else {
@@ -3461,9 +3583,9 @@
 			gf_list_reset(done);
 		}
 		if (print_fn)
-			print_fn(stderr, 1, " \n");
+			print_fn(stderr, 1, "%s\n", nb_sinks ? " " : " none");
 		else {
-			GF_LOG(GF_LOG_INFO, GF_LOG_APP, (" \n"));
+			GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s\n", nb_sinks ? " " : " none"));
 		}
 	}
 
@@ -3528,14 +3650,17 @@
 	}
 }
 
-static Bool gf_fsess_get_user_pass(void *usr_cbk, const char *site_url, char *usr_name, char *password)
+static Bool gf_fsess_get_user_pass(void *usr_cbk, Bool secure, const char *site_url, char *usr_name, char *password, gf_dm_on_usr_pass async_pass, void *async_udta)
 {
 	GF_Event evt;
 	GF_FilterSession *fsess = (GF_FilterSession *)usr_cbk;
 	evt.type = GF_EVENT_AUTHORIZATION;
+	evt.auth.secure = secure;
 	evt.auth.site_url = site_url;
 	evt.auth.user = usr_name;
 	evt.auth.password = password;
+	evt.auth.on_usr_pass = async_pass;
+	evt.auth.async_usr_data = async_udta;
 	return gf_fs_forward_gf_event(fsess, &evt, GF_FALSE, GF_FALSE);
 }
 
@@ -3613,7 +3738,7 @@
 #endif
 } GF_UserTask;
 
-static void do_fs_user_task(GF_FSTask *task, Bool free_log_name)
+static void gf_fs_user_task(GF_FSTask *task)
 {
 	u32 reschedule_ms=0;
 	GF_UserTask *utask = (GF_UserTask *)task->udta;
@@ -3635,25 +3760,16 @@
 		gf_free(utask);
 		task->udta = NULL;
 		//we duplicated the name for user tasks
-		if (free_log_name)
-			gf_free((char *) task->log_name);
+		gf_free((char *) task->log_name);
 		task->requeue_request = GF_FALSE;
 	} else {
+		assert(task->requeue_request);
 		task->schedule_next_time = gf_sys_clock_high_res() + 1000*reschedule_ms;
 	}
 }
-static void gf_fs_user_task(GF_FSTask *task)
-{
-	do_fs_user_task(task, GF_FALSE);
-}
-static void gf_fs_user_task_free_log(GF_FSTask *task)
-{
-	do_fs_user_task(task, GF_TRUE);
-}
 
 
-GF_EXPORT
-GF_Err gf_fs_post_user_task(GF_FilterSession *fsess, Bool (*task_execute) (GF_FilterSession *fsess, void *callback, u32 *reschedule_ms), void *udta_callback, const char *log_name)
+static GF_Err gf_fs_post_user_task_internal(GF_FilterSession *fsess, Bool (*task_execute) (GF_FilterSession *fsess, void *callback, u32 *reschedule_ms), void *udta_callback, const char *log_name, Bool force_main)
 {
 	GF_UserTask *utask;
 	char *_log_name;
@@ -3665,11 +3781,23 @@
 	utask->task_execute = task_execute;
 	//dup mem for user task
 	_log_name = gf_strdup(log_name ? log_name : "user_task");
-	gf_fs_post_task_ex(fsess, gf_fs_user_task_free_log, NULL, NULL, _log_name, utask, GF_FALSE, fsess->force_main_thread_tasks, GF_FALSE);
+	gf_fs_post_task_ex(fsess, gf_fs_user_task, NULL, NULL, _log_name, utask, GF_FALSE, force_main, GF_FALSE, TASK_TYPE_USER);
 	return GF_OK;
 }
 
 GF_EXPORT
+GF_Err gf_fs_post_user_task(GF_FilterSession *fsess, Bool (*task_execute) (GF_FilterSession *fsess, void *callback, u32 *reschedule_ms), void *udta_callback, const char *log_name)
+{
+	return gf_fs_post_user_task_internal(fsess, task_execute, udta_callback, log_name, fsess->force_main_thread_tasks);
+}
+
+GF_EXPORT
+GF_Err gf_fs_post_user_task_main(GF_FilterSession *fsess, Bool (*task_execute) (GF_FilterSession *fsess, void *callback, u32 *reschedule_ms), void *udta_callback, const char *log_name)
+{
+	return gf_fs_post_user_task_internal(fsess, task_execute, udta_callback, log_name, GF_TRUE);
+}
+
+GF_EXPORT
 GF_Err gf_filter_post_task(GF_Filter *filter, Bool (*task_execute) (GF_Filter *filter, void *callback, u32 *reschedule_ms), void *udta, const char *task_name)
 {
 	GF_UserTask *utask;
@@ -3679,7 +3807,15 @@
 	utask->callback = udta;
 	utask->task_execute_filter = task_execute;
 	utask->fsess = filter->session;
-	gf_fs_post_task(filter->session, gf_fs_user_task, filter, NULL, task_name ? task_name : "user_task", utask);
+	char *_log_name=NULL;
+	if (task_name) {
+		_log_name = gf_strdup(task_name);
+	} else {
+		gf_dynstrcat(&_log_name, filter->name, NULL);
+		gf_dynstrcat(&_log_name, "_task", NULL);
+	}
+
+	gf_fs_post_task_class(filter->session, gf_fs_user_task, filter, NULL, _log_name, utask, TASK_TYPE_USER);
 	return GF_OK;
 }
 
@@ -3923,6 +4059,12 @@
 	const char *sOpt;
 	void *os_disp_handler;
 
+	if (session->ext_gl_callback) {
+		e = session->ext_gl_callback(session->ext_gl_udta, GF_TRUE);
+		if (e==GF_OK) gf_opengl_init();
+		return e;
+	}
+
 	if (!session->nb_gl_filters) return GF_OK;
 	if (gf_list_count(session->gl_providers)) return GF_OK;
 
@@ -3943,10 +4085,10 @@
 	session->gl_driver->evt_cbk_hdl = session;
 
 	os_disp_handler = NULL;
-	sOpt = gf_opts_get_key("Temp", "OSDisp");
+	sOpt = gf_opts_get_key("temp", "window-display");
 	if (sOpt) sscanf(sOpt, "%p", &os_disp_handler);
 
-	e = session->gl_driver->Setup(session->gl_driver, NULL, os_disp_handler, GF_TERM_INIT_HIDE);
+	e = session->gl_driver->Setup(session->gl_driver, NULL, os_disp_handler, GF_VOUT_INIT_HIDE);
 	if (e!=GF_OK) {
 		GF_LOG(GF_LOG_WARNING, GF_LOG_FILTER, ("Failed to setup Video Driver %s!\n", session->gl_driver->module_name));
 		gf_modules_close_interface((GF_BaseInterface *)session->gl_driver);
@@ -3971,9 +4113,13 @@
 	return GF_OK;
 }
 
-GF_Err gf_fs_set_gl(GF_FilterSession *session)
+GF_Err gf_fs_set_gl(GF_FilterSession *session, Bool do_activate)
 {
 	GF_Event evt;
+	if (session->ext_gl_callback) {
+		return session->ext_gl_callback(session->ext_gl_udta, do_activate);
+	}
+
 	if (!session->gl_driver) return GF_BAD_PARAM;
 	memset(&evt, 0, sizeof(GF_Event));
 	evt.type = GF_EVENT_SET_GL;
@@ -3983,6 +4129,7 @@
 GF_VideoOutput *gf_filter_claim_opengl_provider(GF_Filter *filter)
 {
 	if (!filter || !filter->session || !filter->session->gl_driver) return NULL;
+	if (filter->session->ext_gl_callback) return NULL;
 
 	if (! (filter->session->gl_driver->hw_caps & GF_VIDEO_HW_INTERNAL))
 		return NULL;
@@ -3996,6 +4143,7 @@
 Bool gf_filter_unclaim_opengl_provider(GF_Filter *filter, GF_VideoOutput * video_out)
 {
 	if (!filter || !video_out) return GF_FALSE;
+	if (filter->session->ext_gl_callback) return GF_FALSE;
 
 	if (! (video_out->hw_caps & GF_VIDEO_HW_INTERNAL))
 		return GF_FALSE;
@@ -4061,7 +4209,7 @@
 {
 	GF_Err e;
 	Bool is_supported = GF_FALSE;
-	gf_fs_load_source_dest_internal(session, url, NULL, parent_url, &e, NULL, NULL, GF_TRUE, GF_TRUE, &is_supported);
+	gf_fs_load_source_dest_internal(session, url, NULL, parent_url, &e, NULL, NULL, GF_TRUE, GF_TRUE, &is_supported, NULL);
 	return is_supported;
 }
 
@@ -4132,7 +4280,15 @@
 	return session->rt_udta;
 }
 
-
+GF_EXPORT
+GF_Err gf_fs_set_external_gl_provider(GF_FilterSession *session, gf_fs_gl_activate on_gl_activate, void *udta)
+{
+	if (!session || !on_gl_activate || session->ext_gl_callback) return GF_BAD_PARAM;
+	if (gf_list_count(session->filters)) return GF_BAD_PARAM;
+	session->ext_gl_udta = udta;
+	session->ext_gl_callback = on_gl_activate;
+	return GF_OK;
+}
 #ifdef GF_FS_ENABLE_LOCALES
 
 static Bool fsess_find_res(GF_FSLocales *loc, char *parent, char *path, char *relocated_path, char *localized_rel_path)

gpac-2.0.0.tar.gz/src/filter_core/filter_session.h -> gpac-2.2.0.tar.gz/src/filter_core/filter_session.h Changed

@@ -29,7 +29,6 @@
 #include <gpac/list.h>
 #include <gpac/thread.h>
 #include <gpac/filters.h>
-#include <gpac/user.h>
 
 #ifdef GPAC_HAS_QJS
 #include "../scenegraph/qjs_common.h"
@@ -283,7 +282,8 @@
 	//decrementing the counter
 	Bool notified;
 	Bool requeue_request;
-	Bool can_swap;
+	//if set, task can be pushed back in filter task list. If set to 2, filter is kept for scheduling event if mast task
+	u32 can_swap;
 	Bool blocking;
 	Bool force_main;
 
@@ -295,13 +295,31 @@
 	GF_FilterPid *pid;
 	const char *log_name;
 	void *udta;
+	u32 class_type;
 };
 
 void gf_fs_post_task(GF_FilterSession *fsess, gf_fs_task_callback fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta);
+
+//task type used to free up resources when a filter task is being canceled (configure error)
+typedef enum
+{
+	//no free required
+	TASK_TYPE_NONE=0,
+	//task udta is a GF_FilterEvent
+	TASK_TYPE_EVENT,
+	//task udta is a struct _gf_filter_setup_failure (simple free needed)
+	TASK_TYPE_SETUP,
+	//task udta is a GF_UserTask structure (simple free needed), and task logname shall be freed
+	TASK_TYPE_USER,
+} GF_TaskClassType;
+
+
 /* extended version of gf_fs_post_task
 force_direct_call shall only be true for gf_filter_process_task
 */
-void gf_fs_post_task_ex(GF_FilterSession *fsess, gf_fs_task_callback task_fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta, Bool is_configure, Bool force_main_thread, Bool force_direct_call);
+void gf_fs_post_task_ex(GF_FilterSession *fsess, gf_fs_task_callback task_fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta, Bool is_configure, Bool force_main_thread, Bool force_direct_call, GF_TaskClassType class_type);
+
+void gf_fs_post_task_class(GF_FilterSession *fsess, gf_fs_task_callback task_fun, GF_Filter *filter, GF_FilterPid *pid, const char *log_name, void *udta, GF_TaskClassType class_type);
 
 void gf_filter_pid_send_event_downstream(GF_FSTask *task);
 
@@ -312,7 +330,8 @@
 	GF_Thread *th;
 	struct __gf_filter_session *fsess;
 	u32 th_id;
-	
+	u32 nb_filters_pinned;
+
 	Bool has_seen_eot; //set when no more tasks in global queue
 
 	u64 nb_tasks;
@@ -330,17 +349,19 @@
 	GF_ARGTYPE_LOCAL = 0, //:arg syntax
 	GF_ARGTYPE_GLOBAL, //--arg syntax
 	GF_ARGTYPE_META, //old -+arg syntax
-	GF_ARGTYPE_META_REPORTING
+	GF_ARGTYPE_META_REPORTING,
 } GF_FSArgItemType;
 
 typedef struct
 {
 	char *argname;
 	GF_FSArgItemType type;
-	Bool found;
+	const char *meta_filter, *meta_opt;
+	u8 opt_found;
+	u8 meta_state;
 } GF_FSArgItem;
 
-void gf_fs_push_arg(GF_FilterSession *session, const char *szArg, Bool was_found, GF_FSArgItemType type, GF_Filter *meta_filter);
+void gf_fs_push_arg(GF_FilterSession *session, const char *szArg, Bool was_found, GF_FSArgItemType type, GF_Filter *meta_filter, const char *sub_opt_name);
 
 enum
 {
@@ -359,7 +380,7 @@
 	Bool direct_mode;
 	volatile u32 tasks_in_process;
 	Bool requires_solved_graph;
-	//non blicking session mode:
+	//non blocking session mode:
 	//0: session is blocking
 	//1: session is non-blocking and first call to gf_fs_run (extra threads not started)
 	//2: session is non-blocking and not first call to gf_fs_run (extra threads started)
@@ -436,8 +457,11 @@
 	u32 in_event_listener;
 
 	GF_DownloadManager *download_manager;
+
+#ifndef GPAC_DISABLE_PLAYER
 	struct _gf_ft_mgr *font_manager;
-	
+#endif
+
 	u32 default_pid_buffer_max_us, decoder_pid_buffer_max_us;
 	u32 default_pid_buffer_max_units;
 
@@ -479,13 +503,16 @@
 #ifdef GPAC_HAS_QJS
 	struct JSContext *js_ctx;
 	GF_List *jstasks;
-	struct __jsfs_task *new_f_task, *del_f_task, *on_evt_task;
+	struct __jsfs_task *new_f_task, *del_f_task, *on_evt_task, *on_auth_task;
 #endif
 
 	gf_fs_on_filter_creation on_filter_create_destroy;
 	void *rt_udta;
 	Bool force_main_thread_tasks;
 
+	void *ext_gl_udta;
+	gf_fs_gl_activate ext_gl_callback;
+
 #ifdef GF_FS_ENABLE_LOCALES
 	GF_List *uri_relocators;
 	GF_FSLocales locales;
@@ -496,6 +523,7 @@
 void jsfs_on_filter_created(GF_Filter *new_filter);
 void jsfs_on_filter_destroyed(GF_Filter *del_filter);
 Bool jsfs_on_event(GF_FilterSession *session, GF_Event *evt);
+Bool jsfs_on_auth(GF_FilterSession *session, GF_Event *evt);
 #endif
 
 void gf_fs_reg_all(GF_FilterSession *fsess, GF_FilterSession *a_sess);
@@ -509,7 +537,7 @@
 
 #ifndef GPAC_DISABLE_3D
 GF_Err gf_fs_check_gl_provider(GF_FilterSession *session);
-GF_Err gf_fs_set_gl(GF_FilterSession *session);
+GF_Err gf_fs_set_gl(GF_FilterSession *session, Bool do_activate);
 #endif
 
 typedef enum
@@ -532,6 +560,16 @@
 	GF_FILTER_CLONE_PROBE,
 } GF_FilterCloneType;
 
+
+typedef enum
+{
+	GF_FILTER_ENABLED = 0,
+	GF_FILTER_DISABLED,
+	GF_FILTER_DISABLED_HIDE,
+} GF_FilterDisableType;
+
+//#define DEBUG_BLOCKMODE
+
 struct __gf_filter
 {
 	const GF_FilterRegister *freg;
@@ -554,6 +592,7 @@
 
 	//indicates the max number of additional input PIDs - muxers and scalable filters typically set this to (u32) -1
 	u32 max_extra_pids;
+	volatile u32 nb_sparse_pids;
 
 	u32 subsession_id, subsource_id;
 
@@ -580,13 +619,13 @@
 	volatile Bool scheduled_for_next_task;
 	//set to true when the filter is being processed by a thread
 	volatile Bool in_process;
-	u32 process_th_id;
+	u32 process_th_id, restrict_th_idx;
 	//user data for the filter implementation
 	void *filter_udta;
 
 	Bool has_out_caps;
 
-	Bool disabled;
+	GF_FilterDisableType disabled;
 	//set to true before calling filter process() callback, and reset to false right after
 	Bool in_process_callback;
 	Bool no_probe;
@@ -682,8 +721,14 @@
 #endif
 
 	volatile u32 would_block; //concurrent inc/dec
+#ifdef DEBUG_BLOCKMODE
 	//sets once broken blocking mode has been detected
 	Bool blockmode_broken;
+#endif
+
+	//per-filter buffer options
+	u32 pid_buffer_max_us, pid_buffer_max_units, pid_decode_buffer_max_us;
+
 	//requested by a filter to disable blocking
 	Bool prevent_blocking;
 
@@ -798,6 +843,8 @@
 	//typically helps for tiling case with hundreds of tiles
 	GF_Filter *single_source;
 
+	char *meta_instances;
+
 #ifdef GPAC_HAS_QJS
 	char *iname;
 	JSValue jsval;
@@ -814,7 +861,7 @@
 
 GF_Err gf_filter_new_finalize(GF_Filter *filter, const char *args, GF_FilterArgType arg_type);
 
-GF_Filter *gf_fs_load_source_dest_internal(GF_FilterSession *fsess, const char *url, const char *args, const char *parent_url, GF_Err *err, GF_Filter *filter, GF_Filter *dst_filter, Bool for_source, Bool no_args_inherit, Bool *probe_only);
+GF_Filter *gf_fs_load_source_dest_internal(GF_FilterSession *fsess, const char *url, const char *args, const char *parent_url, GF_Err *err, GF_Filter *filter, GF_Filter *dst_filter, Bool for_source, Bool no_args_inherit, Bool *probe_only, const GF_FilterRegister **probe_reg);
 
 void gf_filter_pid_inst_delete_task(GF_FSTask *task);
 
@@ -829,6 +876,8 @@
 
 void gf_filter_reset_pending_packets(GF_Filter *filter);
 
+void gf_filter_instance_detach_pid(GF_FilterPidInst *pidi);
+
 typedef struct
 {
 	char *name;
@@ -837,6 +886,7 @@
 	GF_EventPropagateType recursive;
 } GF_FilterUpdate;
 
+
 //structure for input pids, in order to handle fan-outs of a pid into several filters
 struct __gf_filter_pid_inst
 {
@@ -883,6 +933,7 @@
 	u64 first_frame_time;
 	Bool is_end_of_stream;
 	Bool is_playing, is_paused;
+	u8 play_queued, stop_queued;
 	
 	volatile u32 nb_eos_signaled;
 
@@ -909,6 +960,16 @@
 
 	u64 last_buf_query_clock;
 	u64 last_buf_query_dur;
+
+	/*! last RT info update time - input pid only */
+	u64 last_rt_report;
+	/*! estimated round-trip time in ms - input pid only */
+	u32 rtt;
+	/*! estimated interarrival jitter in microseconds - input pid only */
+	u32 jitter;
+	/*! loss rate in per-thousand - input pid only */
+	u32 loss_rate;
+
 };
 
 struct __gf_filter_pid
@@ -928,7 +989,6 @@
 	Bool not_connected_ok;
 	Bool removed;
 	Bool direct_dispatch;
-	volatile u32 discard_input_packets;
 	volatile u32 init_task_pending;
 	volatile Bool props_changed_since_connect;
 	//number of shared packets (shared, frame interfaces or reference) still out there
@@ -952,6 +1012,9 @@
 	u64 buffer_duration;
 	//true if the pid carries raw media
 	Bool raw_media;
+	//true if pid is sparse (may not have data for a long time)
+	//a sparse pid always triggers blocking if parent filter has more than one output
+	Bool is_sparse;
 	//for stats only
 	u32 stream_type, codecid;
 
@@ -982,6 +1045,7 @@
 	GF_Filter *caps_dst_filter;
 
 	Bool ext_not_trusted;
+	Bool user_buffer_forced;
 
 	Bool require_source_id;
 	//only used in filter_check_caps
@@ -1112,6 +1176,7 @@
 
 //get next option after path, NULL if not found
 const char *gf_fs_path_escape_colon(GF_FilterSession *sess, const char *path);
+const char *gf_fs_path_escape_colon_ex(GF_FilterSession *sess, const char *path, Bool *needs_escape, Bool for_source);
 
 void gf_fs_check_graph_load(GF_FilterSession *fsess, Bool for_load);
 
@@ -1124,6 +1189,10 @@
 
 Bool gf_filter_update_arg_apply(GF_Filter *filter, const char *arg_name, const char *arg_value, Bool is_sync_call);
 
+
+GF_List *gf_filter_pid_compute_link(GF_FilterPid *pid, GF_Filter *dst);
+
+GF_PropertyValue gf_filter_parse_prop_solve_env_var(GF_FilterSession *fs, GF_Filter *f, u32 type, const char *name, const char *value, const char *enum_values);
 #endif //_GF_FILTER_SESSION_H_

gpac-2.0.0.tar.gz/src/filter_core/filter_session_js.c -> gpac-2.2.0.tar.gz/src/filter_core/filter_session_js.c Changed

@@ -30,6 +30,7 @@
 
 #ifdef GPAC_HAS_QJS
 
+static GF_Err gf_fs_load_script_ex(GF_FilterSession *fs, const char *jsfile, JSContext *in_ctx, GF_Filter *for_filter);
 
 
 static JSClassID fs_class_id;
@@ -37,6 +38,11 @@
 {
 	JSValue fun;
 	JSValue _obj;
+
+	//for event callback, we allow 2 user-defined functions
+	JSValue fun2;
+	JSValue _obj2;
+
 	u32 type;
 	JSContext *ctx;
 } JSFS_Task;
@@ -50,6 +56,10 @@
 			JSFS_Task *task = gf_list_get(fs->jstasks, i);
 JS_MarkValue(rt, task->fun, mark_func);
 JS_MarkValue(rt, task->_obj, mark_func);
+ if (!JS_IsUndefined(task->_obj2)) {
+				JS_MarkValue(rt, task->fun2, mark_func);
+				JS_MarkValue(rt, task->_obj2, mark_func);
+			}
 		}
 		gf_fs_lock_filters(fs, GF_TRUE);
 		count = gf_list_count(fs->filters);
@@ -281,6 +291,15 @@
 	return JS_UNDEFINED;
 }
 
+Bool gf_sys_enable_remotery(Bool start, Bool is_shutdown);
+
+static JSValue jsfs_enable_rmt(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	GF_FilterSession *fs = JS_GetOpaque(this_val, fs_class_id);
+ if (!fs) return GF_JS_EXCEPTION(ctx);
+	gf_sys_enable_remotery(GF_TRUE, GF_FALSE);
+	return JS_UNDEFINED;
+}
 
 static JSValue jsfs_rmt_send(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
@@ -297,7 +316,6 @@
 
 void jsfs_on_filter_created(GF_Filter *new_filter)
 {
-	new_filter->jsval = JS_UNDEFINED;
 	if (!new_filter->session->new_f_task) return;
 	jsfs_exec_task_custom(new_filter->session->new_f_task, NULL, new_filter, NULL);
 }
@@ -325,6 +343,8 @@
 Bool jsfs_on_event(GF_FilterSession *fs, GF_Event *evt)
 {
 	GF_FilterEvent fevt;
+	Bool pass2=GF_FALSE;
+	JSValue fun, obj;
 	JSValue js_init_evt_obj(JSContext *ctx, const GF_FilterEvent *evt);
 
 	JSValue arg, ret;
@@ -336,9 +356,13 @@
 	fevt.user_event.event = *evt;
 	fevt.base.type = GF_FEVT_USER;
 
-	arg = js_init_evt_obj(fs->on_evt_task->ctx, &fevt);
+	fun = fs->on_evt_task->fun;
+	obj = fs->on_evt_task->_obj;
 
-	ret = JS_Call(fs->on_evt_task->ctx, fs->on_evt_task->fun, fs->on_evt_task->_obj, 1, &arg);
+
+retry:
+	arg = js_init_evt_obj(fs->on_evt_task->ctx, &fevt);
+	ret = JS_Call(fs->on_evt_task->ctx, fun, obj, 1, &arg);
 	JS_SetOpaque(arg, NULL);
 	JS_FreeValue(fs->on_evt_task->ctx, arg);
 
@@ -353,11 +377,113 @@
 		evt->clipboard.text = NULL;
 	}
 	JS_FreeValue(fs->on_evt_task->ctx, ret);
+	if (!pass2 && !res && !JS_IsUndefined(fs->on_evt_task->_obj2)) {
+		pass2 = GF_TRUE;
+		fun = fs->on_evt_task->fun2;
+		obj = fs->on_evt_task->_obj2;
+		goto retry;
+	}
 	js_std_loop(fs->on_evt_task->ctx);
 	gf_js_lock(fs->on_evt_task->ctx, GF_FALSE);
 	return res;
 }
 
+typedef struct
+{
+	void (*on_usr_pass)(void *usr_cbk, const char *usr_name, const char *password, Bool store_info);
+	void *async_usr_data;
+} JSFAuthContext;
+
+static JSClassID jsf_auth_class_id;
+static void jsf_auth_finalizer(JSRuntime *rt, JSValue val)
+{
+	JSFAuthContext *actx = JS_GetOpaque(val, jsf_auth_class_id);
+ if (!actx) return;
+
+	if (actx->on_usr_pass) {
+		actx->on_usr_pass(actx->async_usr_data, NULL, NULL, GF_FALSE);
+	}
+ gf_free(actx);
+}
+static JSClassDef jsf_auth_class = {
+ "AsyncAuth",
+ .finalizer = jsf_auth_finalizer
+};
+
+static JSValue js_auth_done(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	JSFAuthContext *actx = JS_GetOpaque(this_val, jsf_auth_class_id);
+	Bool store = GF_FALSE;
+	if (!actx) return GF_JS_EXCEPTION(ctx);
+	const char *user, *pass;
+
+	user = argc ? JS_ToCString(ctx, argv0) : NULL;
+	pass = (argc>1) ? JS_ToCString(ctx, argv1) : NULL;
+	if (argc==3)
+		store = JS_ToBool(ctx, argv2);
+
+	if (!user || !user0 || !pass || !pass0)
+		actx->on_usr_pass(actx->async_usr_data, NULL, NULL, GF_FALSE);
+	else
+		actx->on_usr_pass(actx->async_usr_data, user, pass, store);
+
+	//callback done, set to null. If object gets destroyed without the done() being called, we will callback with failure
+	actx->on_usr_pass = NULL;
+	if (user) JS_FreeCString(ctx, user);
+	if (pass) JS_FreeCString(ctx, pass);
+	return JS_UNDEFINED;
+}
+
+static const JSCFunctionListEntry jsf_auth_funcs = {
+	JS_CFUNC_DEF("done", 0, js_auth_done),
+};
+
+
+Bool jsfs_on_auth(GF_FilterSession *fs, GF_Event *evt)
+{
+	JSValue args5, ret, obj;
+	Bool res = GF_TRUE;
+	JSContext *ctx;
+	assert(fs->on_auth_task);
+	ctx = fs->on_auth_task->ctx;
+	gf_js_lock(ctx, GF_TRUE);
+
+	JSFAuthContext *actx;
+	GF_SAFEALLOC(actx, JSFAuthContext);
+	if (!actx) {
+		gf_js_lock(ctx, GF_FALSE);
+		return GF_FALSE;
+	}
+	actx->on_usr_pass = evt->auth.on_usr_pass;
+	actx->async_usr_data = evt->auth.async_usr_data;
+	obj = JS_NewObjectClass(ctx, jsf_auth_class_id);
+	JS_SetOpaque(obj, actx);
+
+	args0 = JS_NewString(ctx, evt->auth.site_url);
+	args1 = JS_NewString(ctx, evt->auth.user);
+	args2 = JS_NewString(ctx, evt->auth.password);
+	args3 = JS_NewBool(ctx, evt->auth.secure);
+	args4 = obj;
+
+	ret = JS_Call(ctx, fs->on_auth_task->fun, fs->on_auth_task->_obj, 5, args);
+
+	JS_FreeValue(ctx, args0);
+	JS_FreeValue(ctx, args1);
+	JS_FreeValue(ctx, args2);
+	JS_FreeValue(ctx, args3);
+	JS_FreeValue(ctx, args4);
+
+	if (JS_IsException(ret)) {
+		js_dump_error(ctx);
+		res = GF_FALSE;
+	}
+	JS_FreeValue(ctx, ret);
+
+	js_std_loop(ctx);
+	gf_js_lock(ctx, GF_FALSE);
+	return res;
+}
+
 
 static JSValue jsfs_set_fun_callback(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, u32 cbk_type)
 {
@@ -378,6 +504,8 @@
 		task = fs->del_f_task;
 	} else if (cbk_type==4) {
 		task = fs->on_evt_task;
+	} else if (cbk_type==5) {
+		task = fs->on_auth_task;
 	} else {
 		count = gf_list_count(fs->jstasks);
 		for (i=0; i<count; i++) {
@@ -390,6 +518,10 @@
 		if (task) {
 			JS_FreeValue(ctx, task->fun);
 			JS_FreeValue(ctx, task->_obj);
+			if (!JS_IsUndefined(task->_obj2)) {
+				JS_FreeValue(ctx, task->fun2);
+				JS_FreeValue(ctx, task->_obj2);
+			}
 			gf_list_del_item(fs->jstasks, task);
 			gf_free(task);
 		}
@@ -401,19 +533,30 @@
 			fs->del_f_task = NULL;
 		else if (cbk_type == 4)
 			fs->on_evt_task = NULL;
+		else if (cbk_type == 5)
+			fs->on_auth_task = NULL;
 
 		return JS_UNDEFINED;
 	}
 
 	if (task) {
-		JS_FreeValue(ctx, task->fun);
-		JS_FreeValue(ctx, task->_obj);
+		if ((cbk_type == 4) && JS_IsUndefined(task->fun2)) {
+			task->fun2 = task->fun;
+			task->_obj2 = task->_obj;
+			task->fun = JS_UNDEFINED;
+			task->_obj = JS_UNDEFINED;
+		} else {
+			JS_FreeValue(ctx, task->fun);
+			JS_FreeValue(ctx, task->_obj);
+		}
 	} else {
 		GF_SAFEALLOC(task, JSFS_Task);
 		if (!task) return GF_JS_EXCEPTION(ctx);
 		gf_list_add(fs->jstasks, task);
 		task->type = cbk_type;
 		task->ctx = ctx;
+		task->fun2 = JS_UNDEFINED;
+		task->_obj2 = JS_UNDEFINED;
 	}
 	task->fun = JS_DupValue(ctx, argv0);
 	task->_obj = JS_DupValue(ctx, this_val);
@@ -432,6 +575,8 @@
 		fs->del_f_task = task;
 	else if (cbk_type == 4)
 		fs->on_evt_task = task;
+	else if (cbk_type == 5)
+		fs->on_auth_task = task;
 return JS_UNDEFINED;
 }
 
@@ -451,6 +596,10 @@
 {
 	return jsfs_set_fun_callback(ctx, this_val, argc, argv, 4);
 }
+static JSValue jsfs_set_auth_fun(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	return jsfs_set_fun_callback(ctx, this_val, argc, argv, 5);
+}
 
 enum
 {
@@ -760,64 +909,59 @@
 	return ret;
 }
 
-static JSValue jsff_all_args(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+static void get_filter_args(JSContext *ctx, GF_FilterSession *fs, const GF_FilterRegister *freg, GF_Filter *f_inst, Bool val_only, JSValue array)
 {
 	u32 idx, a_idx;
-	JSValue res;
-	Bool val_only = GF_TRUE;
 	const GF_FilterArgs *args;
-	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
-	if (!f)
-		return GF_JS_EXCEPTION(ctx);
-
-	if (argc && JS_IsBool(argv0) && JS_ToBool(ctx, argv0))
-		val_only = GF_FALSE;
 
-	res = JS_NewArray(ctx);
 	idx=0;
 	a_idx=0;
-	args = f->instance_args ? f->instance_args : f->freg->args;
+	args = (f_inst && f_inst->instance_args) ? f_inst->instance_args : freg->args;
+
 	while (args && argsidx.arg_name) {
 		const GF_FilterArgs *arg = &argsidx;
 		GF_PropertyValue p;
 		JSValue aval;
-		if (arg->flags & GF_FS_ARG_HINT_HIDE) {
+		if ((arg->flags & GF_FS_ARG_HINT_HIDE)
+			|| !strcmp(arg->arg_name, "*")
+		) {
 			idx++;
 			continue;
 		}
 
 		aval = JS_NewObject(ctx);
 		JS_SetPropertyStr(ctx, aval, "name", JS_NewString(ctx, arg->arg_name) );
-		if (f->instance_args) {
+		JS_SetPropertyStr(ctx, aval, "type", JS_NewString(ctx, gf_props_get_type_name(arg->arg_type)) );
+		if (f_inst && f_inst->instance_args) {
 			char szArgName100;
 			char *arg_start;
-			snprintf(szArgName, 100, "%c%s%c", f->session->sep_args, arg->arg_name, f->session->sep_name);
-			arg_start = f->orig_args ? strstr(f->orig_args, szArgName) : NULL;
+			snprintf(szArgName, 100, "%c%s%c", f_inst->session->sep_args, arg->arg_name, f_inst->session->sep_name);
+			arg_start = f_inst->orig_args ? strstr(f_inst->orig_args, szArgName) : NULL;
 			if (arg_start) {
 				char *arg_end;
 				arg_start += strlen(szArgName);
 				arg_start = gf_strdup(arg_start);
-				arg_end = strchr(arg_start, f->session->sep_args);
+				arg_end = strchr(arg_start, fs->sep_args);
 				if (arg_end) arg_end0 = 0;
 				JS_SetPropertyStr(ctx, aval, "value", JS_NewString(ctx, arg_start) );
 				gf_free(arg_start);
 			} else {
-				snprintf(szArgName, 100, "%c%s", f->session->sep_args, arg->arg_name);
-				arg_start = f->orig_args ? strstr(f->orig_args, szArgName) : NULL;
+				snprintf(szArgName, 100, "%c%s", fs->sep_args, arg->arg_name);
+				arg_start = f_inst->orig_args ? strstr(f_inst->orig_args, szArgName) : NULL;
 				if (arg_start && (arg->arg_type==GF_PROP_BOOL)) {
 					p.type = GF_PROP_BOOL;
 					p.value.boolean = GF_TRUE;
 					JS_SetPropertyStr(ctx, aval, "value", jsf_NewProp(ctx, &p) );
 				} else {
-					snprintf(szArgName, 100, "%c%c%s", f->session->sep_args, f->session->sep_neg, arg->arg_name);
-					arg_start = f->orig_args ? strstr(f->orig_args, szArgName) : NULL;
+					snprintf(szArgName, 100, "%c%c%s", fs->sep_args, fs->sep_neg, arg->arg_name);
+					arg_start = f_inst->orig_args ? strstr(f_inst->orig_args, szArgName) : NULL;
 					if (arg_start && (arg->arg_type==GF_PROP_BOOL)) {
 						p.type = GF_PROP_BOOL;
 						p.value.boolean = GF_FALSE;
 						JS_SetPropertyStr(ctx, aval, "value", jsf_NewProp(ctx, &p) );
 					} else {
 						if (arg->arg_default_val) {
-							gf_props_parse_value(arg->arg_type, arg->arg_name, arg->arg_default_val, arg->min_max_enum, f->session->sep_list);
+							gf_props_parse_value(arg->arg_type, arg->arg_name, arg->arg_default_val, arg->min_max_enum, f_inst->session->sep_list);
 							JS_SetPropertyStr(ctx, aval, "value", jsf_NewProp(ctx, &p) );
 						} else {
 							JS_SetPropertyStr(ctx, aval, "value", JS_NULL);
@@ -825,10 +969,17 @@
 					}
 				}
 			}
-		} else {
-			gf_filter_get_arg(f, arg->arg_name, &p);
+		} else if (f_inst) {
+			gf_filter_get_arg(f_inst, arg->arg_name, &p);
+			JS_SetPropertyStr(ctx, aval, "value", jsf_NewProp(ctx, &p) );
+		} else if (arg->arg_default_val) {
+			p = gf_filter_parse_prop_solve_env_var(fs, NULL, arg->arg_type, arg->arg_name, arg->arg_default_val, arg->min_max_enum);
 			JS_SetPropertyStr(ctx, aval, "value", jsf_NewProp(ctx, &p) );
+			gf_props_reset_single(&p);
+		} else {
+			JS_SetPropertyStr(ctx, aval, "value", JS_NULL);
 		}
+
 		if (!val_only) {
 			if (arg->arg_desc)
 				JS_SetPropertyStr(ctx, aval, "desc", JS_NewString(ctx, arg->arg_desc) );
@@ -845,13 +996,182 @@
 				JS_SetPropertyStr(ctx, aval, "hint", JS_NewString(ctx, "expert") );
 			}
 		}
-		JS_SetPropertyUint32(ctx, res, idx, aval);
+		JS_SetPropertyUint32(ctx, array, idx, aval);
 		idx++;
 		a_idx++;
 	}
+}
+
+static JSValue jsff_all_args(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	Bool val_only = GF_TRUE;
+	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
+	if (!f)
+		return GF_JS_EXCEPTION(ctx);
+
+	if (argc && JS_IsBool(argv0) && JS_ToBool(ctx, argv0))
+		val_only = GF_FALSE;
+
+	JSValue res = JS_NewArray(ctx);
+	get_filter_args(ctx, f->session, f->freg, f, val_only, res);
 	return res;
 }
 
+static const GF_FilterRegister *find_reg(GF_FilterSession *fs, char *name)
+{
+	u32 i, count = gf_list_count(fs->registry);
+	for (i=0; i<count; i++) {
+		const GF_FilterRegister *freg = gf_list_get(fs->registry, i);
+		if (!strcmp(freg->name, name)) return freg;
+	}
+	return NULL;
+}
+
+#include <gpac/module.h>
+
+static Bool jsfs_get_filter_args(JSContext *ctx, GF_FilterSession *fs, GF_FilterSession **meta_fs, char *regname, GF_Filter *finst, JSValue args)
+{
+	GF_Filter *new_f = NULL;
+	const GF_FilterRegister *freg = NULL;
+	char *sep = strchr(regname, fs->sep_args);
+
+	if (sep) sep0 = 0;
+	freg = finst ? finst->freg : find_reg(fs, regname);
+	if (sep) sep0 = fs->sep_args;
+
+	if (!freg && !finst) {
+		GF_Err e;
+		Bool probe;
+		if (!strncmp(regname, "src=", 4)) {
+			gf_fs_load_source_dest_internal(fs, regname+4, NULL, NULL, &e, NULL, NULL, GF_TRUE, GF_FALSE, &probe, &freg);
+		} else if (!strncmp(regname, "dst=", 4)) {
+			gf_fs_load_source_dest_internal(fs, regname+4, NULL, NULL, &e, NULL, NULL, GF_FALSE, GF_FALSE, &probe, &freg);
+		}
+	}
+
+	if (!freg) return GF_FALSE;
+
+	if (!(freg->flags & GF_FS_REG_META)) {
+		get_filter_args(ctx, fs, freg, NULL, GF_FALSE, args);
+		return GF_TRUE;
+	}
+
+	//don't load a full session, only allocate object and create registry list
+	if (! *meta_fs) {
+		GF_SAFEALLOC(*meta_fs, GF_FilterSession)
+		(*meta_fs)->registry = gf_list_new();
+		(*meta_fs)->blacklist = fs->blacklist;
+
+		//load internal filters
+		gf_fs_reg_all(*meta_fs, *meta_fs);
+
+		//load external modules
+		u32 i, count = gf_modules_count();
+		for (i=0; i<count; i++) {
+			GF_FilterRegister *a_freg = (GF_FilterRegister *) gf_modules_load_filter(i, *meta_fs);
+			if (a_freg) {
+				gf_fs_add_filter_register(*meta_fs, a_freg);
+			}
+		}
+		(*meta_fs)->blacklist = NULL;
+	}
+
+	gf_fs_lock_filters(fs, GF_TRUE);
+	if (!finst) {
+		GF_Err e;
+		char *fdesc, szFmt30;
+		fdesc = gf_strdup(regname);
+		sprintf(szFmt, "%cgpac", fs->sep_args);
+		if (strstr(fdesc, szFmt)) {
+			sprintf(szFmt, "%c_GFTMP", fs->sep_args);
+		} else {
+			sprintf(szFmt, "%c%cgpac%c%c_GFTMP", fs->sep_args, fs->sep_args, fs->sep_args, fs->sep_args);
+		}
+		gf_dynstrcat(&fdesc, szFmt, NULL);
+
+		if (!strncmp(fdesc, "src=", 4)) {
+			new_f = gf_fs_load_source(fs, fdesc+4, NULL, NULL, &e);
+		} else if (!strncmp(fdesc, "dst=", 4)) {
+			new_f = gf_fs_load_destination(fs, fdesc+4, NULL, NULL, &e);
+		} else {
+			new_f = gf_fs_load_filter(fs, fdesc, &e);
+		}
+		if (fdesc) gf_free(fdesc);
+
+		if (!new_f) {
+			gf_fs_lock_filters(fs, GF_FALSE);
+			return GF_FALSE;
+		}
+		finst = new_f;
+	}
+
+	//get all args
+	get_filter_args(ctx, fs, finst->freg, finst, GF_FALSE, args);
+	const char *inst_names = gf_filter_meta_get_instances(finst);
+	while (inst_names && inst_names0) {
+		char szFName100;
+		sep = strchr(inst_names, ' ');
+		if (sep) sep0 = 0;
+		sprintf(szFName, "%s:%s", finst->freg->name, inst_names);
+
+		freg = find_reg(*meta_fs, szFName);
+		if (freg) {
+			get_filter_args(ctx, fs, freg, NULL, GF_FALSE, args);
+		}
+
+		if (!sep) break;
+		sep0 = ' ';
+		inst_names = sep+1;
+	}
+
+	//delete filter
+	if (new_f) {
+		gf_list_del_item(fs->filters, new_f);
+		if (!new_f->finalized && new_f->freg->finalize) {
+			new_f->freg->finalize(new_f);
+		}
+		gf_filter_del(new_f);
+	}
+
+	gf_fs_lock_filters(fs, GF_FALSE);
+	return GF_TRUE;
+}
+
+static void del_meta_fs(GF_FilterSession *metafs)
+{
+	while (gf_list_count(metafs->registry)) {
+		GF_FilterRegister *freg = gf_list_pop_back(metafs->registry);
+		if (freg->register_free)
+			freg->register_free(metafs, freg);
+	}
+	gf_list_del(metafs->registry);
+	gf_free(metafs);
+}
+
+static JSValue jsfs_filter_args(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	char *name = NULL;
+	GF_FilterSession *fs = JS_GetOpaque(this_val, fs_class_id);
+	if (!fs || !argc) return GF_JS_EXCEPTION(ctx);
+
+	name = (char *)JS_ToCString(ctx, argv0);
+	if (!name) return GF_JS_EXCEPTION(ctx);
+
+	GF_FilterSession *meta_fs = NULL;
+	JSValue args = JS_NewArray(ctx);
+	Bool res = jsfs_get_filter_args(ctx, fs, &meta_fs, name, NULL, args);
+	JS_FreeCString(ctx, name);
+	if (meta_fs)
+		del_meta_fs(meta_fs);
+
+	if (!res) {
+		JS_FreeValue(ctx, args);
+		return GF_JS_EXCEPTION(ctx);
+	}
+	return args;
+}
+
+
 static JSValue jsff_get_arg(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
 	u32 idx;
@@ -889,19 +1209,23 @@
 static JSValue jsff_update(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
 	const char *aname;
+	u32 prop_mask=0;
 	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
-	if (!f || (argc!=2) )
+	if (!f || (argc<2) )
 		return GF_JS_EXCEPTION(ctx);
 
 	aname = JS_ToCString(ctx, argv0);
 	if (!aname) return GF_JS_EXCEPTION(ctx);
+	if (argc>2) {
+		JS_ToInt32(ctx, &prop_mask, argv2);
+	}
 	if (JS_IsString(argv1)) {
 		const char *aval = JS_ToCString(ctx, argv1);
 		if (!aval) {
 			JS_FreeCString(ctx, aname);
 			return GF_JS_EXCEPTION(ctx);
 		}
-		gf_fs_send_update(f->session, NULL, f, aname, aval, 0);
+		gf_fs_send_update(f->session, NULL, f, aname, aval, prop_mask);
 		JS_FreeCString(ctx, aval);
 		JS_FreeCString(ctx, aname);
 		return JS_UNDEFINED;
@@ -921,7 +1245,7 @@
 			return err;
 		}
 		gf_props_dump_val(&p, szDump, GF_PROP_DUMP_DATA_PTR, NULL);
-		gf_fs_send_update(f->session, NULL, f, aname, szDump, 0);
+		gf_fs_send_update(f->session, NULL, f, aname, szDump, prop_mask);
 		gf_props_reset_single(&p);
 	}
 
@@ -959,6 +1283,7 @@
 	GF_Filter *new_f;
 	GF_Err e;
 	Bool is_source = GF_FALSE;
+	GF_FilterPid *opid=NULL;
 	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
 	if (!f || !argc)
 		return GF_JS_EXCEPTION(ctx);
@@ -967,10 +1292,21 @@
 	if (!fname) return GF_JS_EXCEPTION(ctx);
 	link_args = NULL;
 	if (argc>1) {
-		link_args = JS_ToCString(ctx, argv1);
-		if (!link_args) {
-			JS_FreeCString(ctx, fname);
-			return GF_JS_EXCEPTION(ctx);
+		u32 offset=1;
+		if (!JS_IsString(argv1)) {
+			s32 opid_idx=-1;
+			if (JS_ToInt32(ctx, &opid_idx, argv1)) return GF_JS_EXCEPTION(ctx);
+			if (opid_idx<0) return GF_JS_EXCEPTION(ctx);
+			opid = gf_filter_get_opid(f, opid_idx);
+			if (!opid) return GF_JS_EXCEPTION(ctx);
+			offset=2;
+		}
+		if ((u32) argc>offset) {
+			link_args = JS_ToCString(ctx, argvoffset);
+			if (!link_args) {
+				JS_FreeCString(ctx, fname);
+				return GF_JS_EXCEPTION(ctx);
+			}
 		}
 	}
 	gf_fs_lock_filters(f->session, GF_TRUE);
@@ -996,9 +1332,11 @@
 		gf_filter_set_source(new_f, (GF_Filter *) f, link_args);
 
 	gf_fs_lock_filters(f->session, GF_FALSE);
+
+	f->dst_filter = new_f;
 	
 	//reconnect outputs of source
-	gf_filter_reconnect_output((GF_Filter *) f);
+	gf_filter_reconnect_output((GF_Filter *) f, opid);
 
 	JS_FreeCString(ctx, fname);
 	if (link_args) JS_FreeCString(ctx, link_args);
@@ -1006,6 +1344,105 @@
 	return jsfs_new_filter_obj(ctx, new_f);
 }
 
+static Bool jsfs_get_filter_args(JSContext *ctx, GF_FilterSession *fs, GF_FilterSession **meta_fs, char *regname, GF_Filter *finst, JSValue args);
+static void del_meta_fs(GF_FilterSession *metafs);
+
+static JSValue jsff_compute_link(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	const char *fname;
+	char *fdesc=NULL;
+	char szFmt20;
+	GF_Filter *new_f;
+	GF_Err e;
+	Bool load_args=GF_FALSE;
+	s32 opid_idx=-1;
+	GF_FilterPid *opid=NULL;
+	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
+	if (!f || (argc<2))
+		return GF_JS_EXCEPTION(ctx);
+
+	if (JS_ToInt32(ctx, &opid_idx, argv0)) return GF_JS_EXCEPTION(ctx);
+	if (opid_idx<0) return GF_JS_EXCEPTION(ctx);
+	opid = gf_filter_get_opid(f, opid_idx);
+	if (!opid) return GF_JS_EXCEPTION(ctx);
+	fname = JS_ToCString(ctx, argv1);
+	if (!fname) return GF_JS_EXCEPTION(ctx);
+	if (!strncmp(fname, "src=", 4) || !strlen(fname)) {
+		JS_FreeCString(ctx, fname);
+		return GF_JS_EXCEPTION(ctx);
+	}
+	if ((argc==3) && JS_ToBool(ctx, argv2))
+		load_args = GF_TRUE;
+
+	fdesc = gf_strdup(fname);
+	JS_FreeCString(ctx, fname);
+	sprintf(szFmt, "%cgpac", f->session->sep_args);
+	if (strstr(fdesc, szFmt)) {
+		sprintf(szFmt, "%c_GFTMP", f->session->sep_args);
+	} else {
+		sprintf(szFmt, "%c%cgpac%c%c_GFTMP", f->session->sep_args, f->session->sep_args, f->session->sep_args, f->session->sep_args);
+	}
+	gf_dynstrcat(&fdesc, szFmt, NULL);
+
+	gf_fs_lock_filters(f->session, GF_TRUE);
+	if (!strncmp(fname, "dst=", 4)) {
+		new_f = gf_fs_load_destination(f->session, fdesc+4, NULL, NULL, &e);
+	} else {
+		new_f = gf_fs_load_filter(f->session, fdesc, &e);
+	}
+	gf_free(fdesc);
+
+	if (!new_f) {
+		JSValue ret = js_throw_err_msg(ctx, e, "Cannot load filter %s: %s\n", fname, gf_error_to_string(e));
+		gf_fs_lock_filters(f->session, GF_FALSE);
+		return ret;
+	}
+
+	JSValue res;
+	GF_List *fchain = gf_filter_pid_compute_link(opid, new_f);
+	if (fchain) {
+		res = JS_NewArray(ctx);
+		u32 i, count = gf_list_count(fchain);
+		GF_FilterSession *meta_fs=NULL;
+		for (i=0; i<count; i+=2) {
+			const GF_FilterRegister *freg = gf_list_get(fchain, i);
+
+			if (load_args) {
+				GF_Filter *finst = NULL;
+				JSValue obj = JS_NewObject(ctx);
+				JS_SetPropertyUint32(ctx, res, i/2, obj);
+				JS_SetPropertyStr(ctx, obj, "fname", JS_NewString(ctx, freg->name));
+				JSValue args = JS_NewArray(ctx);
+				JS_SetPropertyStr(ctx, obj, "args", args);
+				if (i+2>=count) finst = new_f;
+
+				jsfs_get_filter_args(ctx, f->session, &meta_fs, (char *) freg->name, finst, args);
+			} else {
+				JS_SetPropertyUint32(ctx, res, i/2, JS_NewString(ctx, freg->name));
+			}
+		}
+		gf_list_del(fchain);
+		if (meta_fs)
+			del_meta_fs(meta_fs);
+	} else {
+		res = JS_NULL;
+	}
+	gf_list_del_item(f->session->filters, new_f);
+	if (!new_f->finalized && new_f->freg->finalize) {
+		new_f->freg->finalize(new_f);
+	}
+	gf_filter_del(new_f);
+	gf_fs_lock_filters(f->session, GF_FALSE);
+	return res;
+}
+
+static JSValue jsff_require_source_id(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
+	if (!f) return GF_JS_EXCEPTION(ctx);
+	gf_filter_require_source_id(f);
+	return JS_UNDEFINED;
+}
 static JSValue jsff_bind(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
 	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
@@ -1024,6 +1461,74 @@
 	return js_throw_err_msg(ctx, GF_BAD_PARAM, "filter class %s has no JS bind capabilities", f->freg->name);
 }
 
+static JSValue jsff_get_stats(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, Bool is_input)
+{
+	JSValue res;
+	u32 mode=GF_STATS_LOCAL;
+	GF_Filter *f = JS_GetOpaque(this_val, fs_f_class_id);
+	u32 idx;
+	if (!f || (argc<1) )
+		return GF_JS_EXCEPTION(ctx);
+
+	if (JS_ToInt32(ctx, &idx, argv0))
+		return GF_JS_EXCEPTION(ctx);
+
+	GF_FilterPid *pid;
+	if (is_input) pid = gf_filter_get_ipid(f, idx);
+	else pid = gf_filter_get_opid(f, idx);
+	if (!pid)
+		return GF_JS_EXCEPTION(ctx);
+
+	if (argc>1)
+		JS_ToInt32(ctx, &mode, argv1);
+
+	GF_FilterPidStatistics stats;
+	gf_filter_pid_get_statistics(pid, &stats, (GF_FilterPidStatsLocation) mode);
+	res = JS_NewObject(ctx);
+	if (JS_IsException(res)) return res;
+
+	JS_SetPropertyStr(ctx, res, "disconnected", stats.disconnected ? JS_TRUE : JS_FALSE);
+#define SET_U32(_name) \
+	JS_SetPropertyStr(ctx, res, #_name, JS_NewInt32(ctx, stats._name));
+
+#define SET_U64(_name) \
+	JS_SetPropertyStr(ctx, res, #_name, JS_NewInt64(ctx, stats._name));
+
+	SET_U32(average_process_rate)
+	SET_U32(max_process_rate)
+	SET_U32(average_bitrate)
+	SET_U32(max_bitrate)
+	SET_U32(nb_processed)
+	SET_U32(max_process_time)
+	SET_U64(total_process_time)
+	SET_U64(first_process_time)
+	SET_U64(last_process_time)
+	SET_U32(min_frame_dur)
+	SET_U32(nb_saps)
+	SET_U32(max_sap_process_time)
+	SET_U64(total_sap_process_time)
+	SET_U64(max_buffer_time)
+	SET_U64(max_playout_time)
+	SET_U64(min_playout_time)
+	SET_U64(buffer_time)
+	SET_U32(nb_buffer_units)
+	SET_U64(last_rt_report)
+	SET_U32(rtt)
+	SET_U32(jitter)
+	SET_U32(loss_rate)
+	return res;
+}
+
+static JSValue jsff_ipid_stats(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	return jsff_get_stats(ctx, this_val, argc, argv, GF_TRUE);
+}
+
+static JSValue jsff_opid_stats(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	return jsff_get_stats(ctx, this_val, argc, argv, GF_FALSE);
+}
+
 #define JS_CGETSET_MAGIC_DEF_ENUM(name, fgetter, fsetter, magic) { name, JS_PROP_CONFIGURABLE|JS_PROP_ENUMERABLE, JS_DEF_CGETSET_MAGIC, magic, .u = { .getset = { .get = { .getter_magic = fgetter }, .set = { .setter_magic = fsetter } } } }
 
 static const JSCFunctionListEntry fs_f_funcs = {
@@ -1066,6 +1571,10 @@
 	JS_CFUNC_DEF("insert", 0, jsff_insert_filter),
 	JS_CFUNC_DEF("bind", 0, jsff_bind),
 	JS_CFUNC_DEF("lock", 0, jsff_lock),
+	JS_CFUNC_DEF("ipid_stats", 0, jsff_ipid_stats),
+	JS_CFUNC_DEF("opid_stats", 0, jsff_opid_stats),
+	JS_CFUNC_DEF("compute_link", 0, jsff_compute_link),
+	JS_CFUNC_DEF("require_source_id", 0, jsff_require_source_id),
 };
 
 static JSValue jsfs_new_filter_obj(JSContext *ctx, GF_Filter *f)
@@ -1245,6 +1754,7 @@
 JS_CFUNC_DEF("abort", 0, jsfs_abort),
 JS_CFUNC_DEF("get_filter", 0, jsfs_get_filter),
 JS_CFUNC_DEF("lock_filters", 0, jsfs_lock_filters),
+ JS_CFUNC_DEF("enable_rmt", 0, jsfs_enable_rmt),
 JS_CFUNC_DEF("rmt_send", 0, jsfs_rmt_send),
 JS_CFUNC_DEF("set_rmt_fun", 0, jsfs_set_rmt_fun),
 JS_CFUNC_DEF("set_new_filter_fun", 0, jsfs_set_new_filter_fun),
@@ -1254,6 +1764,8 @@
 JS_CFUNC_DEF("fire_event", 0, jsfs_fire_event),
 JS_CFUNC_DEF("reporting", 0, jsfs_reporting),
 JS_CFUNC_DEF("new_filter", 0, jsfs_new_filter),
+ JS_CFUNC_DEF("set_auth_fun", 0, jsfs_set_auth_fun),
+	JS_CFUNC_DEF("filter_args", 0, jsfs_filter_args),
 
 };
 
@@ -1311,6 +1823,12 @@
 	JS_NewClassID(&fs_f_class_id);
 	JS_NewClass(rt, fs_f_class_id, &fs_f_class);
 
+	JS_NewClassID(&jsf_auth_class_id);
+	JS_NewClass(rt, jsf_auth_class_id, &jsf_auth_class);
+	JSValue proto = JS_NewObjectClass(c, jsf_auth_class_id);
+	JS_SetPropertyFunctionList(c, proto, jsf_auth_funcs, countof(jsf_auth_funcs));
+	JS_SetClassProto(c, jsf_auth_class_id, proto);
+
 
 	fs_obj = JS_NewObjectClass(c, fs_class_id);
 JS_SetPropertyFunctionList(c, fs_obj, fs_funcs, countof(fs_funcs));
@@ -1321,8 +1839,7 @@
 return GF_OK;
 }
 
-GF_EXPORT
-GF_Err gf_fs_load_script(GF_FilterSession *fs, const char *jsfile)
+static GF_Err gf_fs_load_script_ex(GF_FilterSession *fs, const char *jsfile, JSContext *in_ctx, GF_Filter *for_filter)
 {
 	GF_Err e;
 JSValue global_obj;
@@ -1334,24 +1851,27 @@
 
 
 	if (!fs) return GF_BAD_PARAM;
-	if (fs->js_ctx) return GF_NOT_SUPPORTED;
+	if (!in_ctx) {
+		if (fs->js_ctx) return GF_NOT_SUPPORTED;
 
 #ifdef GPAC_HAS_QJS
-	ctx = gf_js_create_context();
-	if (!ctx) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("JSF Failed to load QuickJS context\n"));
-		return GF_IO_ERR;
-	}
-	JS_SetContextOpaque(ctx, fs);
-
- global_obj = JS_GetGlobalObject(ctx);
-	gf_fs_load_js_api(ctx, fs);
-	fs->js_ctx = ctx;
+		ctx = gf_js_create_context();
+		if (!ctx) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("JSF Failed to load QuickJS context\n"));
+			return GF_IO_ERR;
+		}
+		JS_SetContextOpaque(ctx, fs);
 
-	JS_SetPropertyStr(fs->js_ctx, global_obj, "_gpac_log_name", JS_NewString(fs->js_ctx, gf_file_basename(jsfile) ) );
-	JS_SetPropertyStr(fs->js_ctx, global_obj, "_gpac_script_src", JS_NewString(fs->js_ctx, jsfile ) );
- JS_FreeValue(fs->js_ctx, global_obj);
+		global_obj = JS_GetGlobalObject(ctx);
+		gf_fs_load_js_api(ctx, fs);
+		fs->js_ctx = ctx;
 
+		JS_SetPropertyStr(fs->js_ctx, global_obj, "_gpac_log_name", JS_NewString(fs->js_ctx, gf_file_basename(jsfile) ) );
+		JS_SetPropertyStr(fs->js_ctx, global_obj, "_gpac_script_src", JS_NewString(fs->js_ctx, jsfile ) );
+		JS_FreeValue(fs->js_ctx, global_obj);
+	} else {
+		ctx = in_ctx;
+	}
 
 	//load script
 	if (!strncmp(jsfile, "$GSHARE/", 8)) {
@@ -1370,22 +1890,26 @@
 		return e;
 	}
 
- 	if (!gf_opts_get_bool("core", "no-js-mods") && JS_DetectModule((char *)buf, buf_len)) {
-		qjs_init_all_modules(fs->js_ctx, GF_FALSE, GF_FALSE);
+	if (in_ctx || (!gf_opts_get_bool("core", "no-js-mods") && JS_DetectModule((char *)buf, buf_len))) {
+		qjs_init_all_modules(ctx, GF_FALSE, GF_FALSE);
 		flags = JS_EVAL_TYPE_MODULE;
 	}
 
-	ret = JS_Eval(fs->js_ctx, (char *)buf, buf_len, jsfile, flags);
+	JSValue global = JS_GetGlobalObject(ctx);
+	JS_SetPropertyStr(ctx, global, "parent_filter", for_filter ? jsfs_new_filter_obj(ctx, for_filter) : JS_NULL);
+	JS_FreeValue(ctx, global);
+
+	ret = JS_Eval(ctx, (char *)buf, buf_len, jsfile, flags);
 	gf_free(buf);
 
 	if (JS_IsException(ret)) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("JSF Error loading script %s\n", jsfile));
- js_dump_error(fs->js_ctx);
-		JS_FreeValue(fs->js_ctx, ret);
+ js_dump_error(ctx);
+		JS_FreeValue(ctx, ret);
 		return GF_BAD_PARAM;
 	}
-	JS_FreeValue(fs->js_ctx, ret);
-	js_std_loop(fs->js_ctx);
+	JS_FreeValue(ctx, ret);
+	js_std_loop(ctx);
 	return GF_OK;
 #else
 	return GF_NOT_SUPPORTED;
@@ -1393,10 +1917,23 @@
 
 }
 
+GF_EXPORT
+GF_Err gf_fs_load_script(GF_FilterSession *fs, const char *jsfile)
+{
+	return gf_fs_load_script_ex(fs, jsfile, NULL, NULL);
+}
+
 void gf_fs_unload_script(GF_FilterSession *fs, void *js_ctx)
 {
 	u32 i, count=gf_list_count(fs->jstasks);
 
+	gf_js_lock(js_ctx, GF_TRUE);
+	fs->new_f_task = NULL;
+	fs->del_f_task = NULL;
+	fs->on_evt_task = NULL;
+	fs->on_auth_task = NULL;
+	gf_js_lock(js_ctx, GF_FALSE);
+
 	for (i=0; i<count; i++) {
 		JSFS_Task *task = gf_list_get(fs->jstasks, i);
 		if (js_ctx && (task->ctx != js_ctx))
@@ -1405,6 +1942,10 @@
 		gf_js_lock(js_ctx, GF_TRUE);
 		JS_FreeValue(task->ctx, task->fun);
 		JS_FreeValue(task->ctx, task->_obj);
+		if (!JS_IsUndefined(task->_obj2)) {
+			JS_FreeValue(task->ctx, task->fun2);
+			JS_FreeValue(task->ctx, task->_obj2);
+		}
 		gf_js_lock(js_ctx, GF_FALSE);
 
 		gf_free(task);
@@ -1412,7 +1953,6 @@
 		i--;
 		count--;
 	}
-
 	if (fs->js_ctx) {
 		gf_js_delete_context(fs->js_ctx);
 		fs->js_ctx = NULL;
@@ -1422,6 +1962,31 @@
 		fs->jstasks = NULL;
 	}
 }
+void gf_filter_load_script(GF_Filter *filter, const char *js_file, const char *filters_blacklist)
+{
+	if (filter->finalized || filter->removed)
+		return;
+
+	gf_mx_p(filter->session->filters_mx);
+	if (filters_blacklist) {
+		u32 i, count = gf_list_count(filter->session->filters);
+		for (i=0; i<count; i++) {
+			GF_Filter *af = gf_list_get(filter->session->filters, i);
+			if (!strstr(filters_blacklist, af->freg->name)) continue;
+
+			if (!strcmp(af->freg->name, "compositor")) {
+				GF_PropertyValue p;
+				gf_filter_get_arg(af, "player", &p);
+				if (p.value.uint==0) continue;
+			}
+
+			gf_mx_v(filter->session->filters_mx);
+			return;
+		}
+	}
+	gf_fs_load_script_ex(filter->session, js_file, filter->session->js_ctx, filter);
+	gf_mx_v(filter->session->filters_mx);
+}
 
 #else
 GF_EXPORT
@@ -1433,6 +1998,10 @@
 {
 
 }
+void gf_filter_load_script(GF_Filter *filter, const char *js_file, const char *filters_blacklist)
+{
+
+}
 
 #endif

gpac-2.0.0.tar.gz/src/filters/bs_agg.c -> gpac-2.2.0.tar.gz/src/filters/bs_agg.c Changed

@@ -263,12 +263,17 @@
 
 	if (is_vvc) {
 		vvcc_out = gf_odf_vvc_cfg_new();
+		if (!vvcc_out) return GF_OUT_OF_MEM;
 	} else {
 #ifndef GPAC_DISABLE_HEVC
 		hvcc_out = gf_odf_hevc_cfg_new();
+		if (!hvcc_out) return GF_OUT_OF_MEM;
 #endif
 	}
 
+#define GOTO_ERR(_e) { e = _e; goto err_exit; }
+
+
 	count = gf_list_count(pctx->ipids);
 	for (i=0; i<count; i++) {
 		const GF_PropertyValue *dsi, *dsi_enh, *prop;
@@ -287,32 +292,35 @@
 
 			if (dsi) {
 				vvcc = gf_odf_vvc_cfg_read(dsi->value.data.ptr, dsi->value.data.size);
-				if (!vvcc) return GF_NON_COMPLIANT_BITSTREAM;
+				if (!vvcc) GOTO_ERR(GF_NON_COMPLIANT_BITSTREAM)
 			}
 			else if (dsi_enh) {
 				vvcc = gf_odf_vvc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size);
-				if (!vvcc) return GF_NON_COMPLIANT_BITSTREAM;
+				if (!vvcc) GOTO_ERR(GF_NON_COMPLIANT_BITSTREAM)
 			}
 			if (dsi) {
 				GF_List *bck = vvcc_out->param_array;
+				u8 *gci_bck = vvcc_out->general_constraint_info;
 				memcpy(vvcc_out, vvcc, sizeof(GF_VVCConfig));
+				vvcc_out->general_constraint_info = gf_realloc(gci_bck, sizeof(u8)*vvcc_out->num_constraint_info);
 				vvcc_out->param_array = bck;
+				if (!vvcc_out->general_constraint_info) GOTO_ERR(GF_OUT_OF_MEM)
+				memcpy(vvcc_out->general_constraint_info, vvcc->general_constraint_info, sizeof(u8)*vvcc_out->num_constraint_info);
 			}
 
 			gf_filter_pid_set_udta_flags(ipid, vvcc->nal_unit_size);
 			e = bsagg_transfer_param_array(vvcc_out->param_array, vvcc->param_array);
-			if (e) return e;
+			if (e) goto err_exit;
 
-			if (vvcc)
-				gf_odf_vvc_cfg_del(vvcc);
+			gf_odf_vvc_cfg_del(vvcc);
 
 			if (dsi && dsi_enh) {
 				vvcc = gf_odf_vvc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size);
-				if (!vvcc) return GF_NON_COMPLIANT_BITSTREAM;
+				if (!vvcc) GOTO_ERR(GF_NON_COMPLIANT_BITSTREAM)
 
 				e = bsagg_transfer_param_array(vvcc_out->param_array, vvcc->param_array);
 				gf_odf_vvc_cfg_del(vvcc);
-				if (e) return e;
+				if (e) goto err_exit;
 			}
 		} else {
 #ifndef GPAC_DISABLE_HEVC
@@ -322,11 +330,11 @@
 
 			if (dsi) {
 				hvcc = gf_odf_hevc_cfg_read(dsi->value.data.ptr, dsi->value.data.size, dsi_lhvc);
-				if (!hvcc) return GF_NON_COMPLIANT_BITSTREAM;
+				if (!hvcc) GOTO_ERR(GF_NON_COMPLIANT_BITSTREAM)
 			}
 			else if (dsi_enh) {
 				hvcc = gf_odf_hevc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size, GF_TRUE);
-				if (!hvcc) return GF_NON_COMPLIANT_BITSTREAM;
+				if (!hvcc) GOTO_ERR(GF_NON_COMPLIANT_BITSTREAM)
 			}
 			if (dsi) {
 				GF_List *bck = hvcc_out->param_array;
@@ -337,14 +345,14 @@
 			gf_filter_pid_set_udta_flags(ipid, hvcc->nal_unit_size);
 			if (dsi) {
 				e = bsagg_transfer_param_array(hvcc_out->param_array, hvcc->param_array);
-				if (e) return e;
+				if (e) goto err_exit;
 			} else {
 				if (!hvcc_enh_out) {
 					hvcc_enh_out = hvcc;
 					hvcc = NULL;
 				} else {
 					e = bsagg_transfer_param_array(hvcc_enh_out->param_array, hvcc->param_array);
-					if (e) return e;
+					if (e) goto err_exit;
 				}
 			}
 			if (hvcc)
@@ -352,11 +360,11 @@
 
 			if (dsi && dsi_enh) {
 				hvcc = gf_odf_hevc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size, GF_TRUE);
-				if (!hvcc) return GF_NON_COMPLIANT_BITSTREAM;
+				if (!hvcc) GOTO_ERR(GF_NON_COMPLIANT_BITSTREAM)
 
 				e = bsagg_transfer_param_array(hvcc_out->param_array, hvcc->param_array);
 				gf_odf_hevc_cfg_del(hvcc);
-				if (e) return e;
+				if (e) goto err_exit;
 			}
 #endif
 		}
@@ -400,12 +408,15 @@
 #endif
 	}
 
+
+err_exit:
+
 #ifndef GPAC_DISABLE_HEVC
 	if (hvcc_out) gf_odf_hevc_cfg_del(hvcc_out);
 	if (hvcc_enh_out) gf_odf_hevc_cfg_del(hvcc_enh_out);
 #endif
 	if (vvcc_out) gf_odf_vvc_cfg_del(vvcc_out);
-	return GF_OK;
+	return e;
 }
 
 
@@ -540,9 +551,7 @@
 					//u32 prio_id = (datasize+1) & 0x3F;
 					u32 dep_id = (datasize+2 >> 4) & 0x7;
 					u32 qual_id = (datasize+2) & 0xF;
-					u32 temporal_id = (datasize+3>>5) & 0x7;
-
-					svc_temporal_id = temporal_id;
+					svc_temporal_id = (datasize+3>>5) & 0x7;
 					svc_layer_id = ctx->svcqid ? qual_id : dep_id;
 				}
 				if (has_svc_prefix) {

gpac-2.0.0.tar.gz/src/filters/bs_split.c -> gpac-2.2.0.tar.gz/src/filters/bs_split.c Changed

gpac-2.0.0.tar.gz/src/filters/bsrw.c -> gpac-2.2.0.tar.gz/src/filters/bsrw.c Changed

@@ -54,7 +54,7 @@
 	GF_Fraction sar;
 	s32 m4vpl, prof, lev, pcomp, pidc, pspace, gpcflags;
 	s32 cprim, ctfc, cmx, vidfmt;
-	Bool rmsei, fullrange, novsi;
+	Bool rmsei, fullrange, novsi, novuitiming;
 
 	GF_List *pids;
 	Bool reconfigure;
@@ -421,6 +421,7 @@
 	pctx->vui.color_prim = ctx->cprim;
 	pctx->vui.fullrange = ctx->fullrange;
 	pctx->vui.remove_video_info = ctx->novsi;
+	pctx->vui.remove_vui_timing_info = ctx->novuitiming;
 	pctx->vui.color_tfc = ctx->ctfc;
 	pctx->vui.video_format = ctx->vidfmt;
 #endif /*GPAC_DISABLE_AV_PARSERS*/
@@ -432,6 +433,7 @@
 	if (ctx->cprim>-1) return;
 	if (ctx->fullrange) return;
 	if (ctx->novsi) return;
+	if (ctx->novuitiming) return;
 	if (ctx->ctfc>-1) return;
 	if (ctx->vidfmt>-1) return;
 	//all default
@@ -659,6 +661,7 @@
 	{ OFFS(m4vpl), "set ProfileLevel for MPEG-4 video part two", GF_PROP_SINT, "-1", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(fullrange), "video full range flag", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(novsi), "remove video_signal_type from VUI in AVC|H264 and HEVC", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_UPDATE},
+	{ OFFS(novuitiming), "remove timing_info from VUI in AVC|H264 and HEVC", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(prof), "profile indication for AVC|H264", GF_PROP_SINT, "-1", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(lev), "level indication for AVC|H264, level_idc for VVC", GF_PROP_SINT, "-1", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(pcomp), "profile compatibility for AVC|H264", GF_PROP_SINT, "-1", NULL, GF_FS_ARG_UPDATE},

gpac-2.0.0.tar.gz/src/filters/compose.c -> gpac-2.2.0.tar.gz/src/filters/compose.c Changed

@@ -37,16 +37,6 @@
 GF_Err compose_odf_dec_config_input(GF_Scene *scene, GF_FilterPid *pid, u32 oti, Bool is_remove);
 GF_Err compose_odf_dec_process(GF_Scene *scene, GF_FilterPid *pid);
 
-#define COMPOSITOR_MAGIC	GF_4CC('c','o','m','p')
-//a bit ugly, used by terminal (old APIs)
-GF_Compositor *gf_sc_from_filter(GF_Filter *filter)
-{
-	GF_Compositor *ctx = (GF_Compositor *) gf_filter_get_udta(filter);
-	if (ctx->magic != COMPOSITOR_MAGIC) return NULL;
-	if (ctx->magic_ptr != ctx) return NULL;
-
-	return ctx;
-}
 
 static GF_Err compose_process(GF_Filter *filter)
 {
@@ -55,10 +45,28 @@
 	Bool ret;
 	GF_Compositor *ctx = (GF_Compositor *) gf_filter_get_udta(filter);
 	if (!ctx) return GF_BAD_PARAM;
+	if (!ctx->vout) return GF_OK;
 
 	if (ctx->check_eos_state == 2)
 		return GF_EOS;
 
+	/*need to reload*/
+	if (ctx->reload_state == 1) {
+		ctx->reload_state = 0;
+		gf_sc_disconnect(ctx);
+		ctx->reload_state = 2;
+	}
+	if (ctx->reload_state == 2) {
+		if (!ctx->root_scene) {
+			ctx->reload_state = 0;
+			if (ctx->reload_url) {
+				gf_sc_connect_from_time(ctx, ctx->reload_url, 0, 0, 0, NULL);
+				gf_free(ctx->reload_url);
+				ctx->reload_url = NULL;
+			}
+		}
+	}
+
 	ctx->last_error = GF_OK;
 	if (ctx->reload_config) {
 		ctx->reload_config = GF_FALSE;
@@ -102,6 +110,7 @@
 
 	if (!ctx->player) {
 		Bool forced_eos = GF_FALSE;
+		Bool was_over = GF_FALSE;
 		/*remember to check for eos*/
 		if (ctx->dur<0) {
 			if (ctx->frame_number >= (u32) -ctx->dur)
@@ -116,9 +125,13 @@
 				if (!ctx->validator_mode)
 					ctx->force_next_frame_redraw = GF_TRUE;
 			}
-		} else if (!ret && !ctx->frame_was_produced && !ctx->audio_frames_sent && !ctx->check_eos_state && !nb_sys_streams_active) {
+		} else if (!ret && !ctx->frame_was_produced && !ctx->audio_frames_sent && !ctx->check_eos_state && !nb_sys_streams_active && !ctx->event_pending) {
 			ctx->check_eos_state = 1;
+			was_over = GF_TRUE;
+		} else if (ctx->sys_frames_pending) {
+			ctx->check_eos_state = 0;
 		}
+
 		if (ctx->timeout && (ctx->check_eos_state == 1) && !gf_filter_connections_pending(filter)) {
 			u32 now = gf_sys_clock();
 			if (!ctx->last_check_pass)
@@ -162,7 +175,7 @@
 			}
 			return forced_eos ? GF_SERVICE_ERROR : GF_EOS;
 		}
-		ctx->check_eos_state = 0;
+		ctx->check_eos_state = was_over ? 1 : 0;
 		//always repost a process task since we maye have things to draw even though no new input
 		gf_filter_post_process_task(filter);
 		return ctx->last_error;
@@ -205,6 +218,30 @@
 	}
 }
 
+static void compositor_setup_vout(GF_Compositor *ctx)
+{
+	//declare video output pid
+	GF_FilterPid *pid;
+	pid = ctx->vout = gf_filter_pid_new(ctx->filter);
+	gf_filter_pid_set_name(pid, "vout");
+	//compositor initiated for RT playback, vout pid may not be connected
+	gf_filter_pid_set_loose_connect(pid);
+
+	gf_filter_pid_set_property(pid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW) );
+	gf_filter_pid_set_property(pid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_VISUAL) );
+	if (ctx->timescale)
+		gf_filter_pid_set_property(pid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->timescale) );
+	else
+		gf_filter_pid_set_property(pid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->fps.num) );
+
+	gf_filter_pid_set_property(pid, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->opfmt ? ctx->opfmt : GF_PIXEL_RGB) );
+	gf_filter_pid_set_property(pid, GF_PROP_PID_WIDTH, &PROP_UINT(ctx->output_width) );
+	gf_filter_pid_set_property(pid, GF_PROP_PID_HEIGHT, &PROP_UINT(ctx->output_height) );
+
+	gf_filter_pid_set_property(pid, GF_PROP_PID_FPS, &PROP_FRAC(ctx->fps) );
+	gf_filter_pid_set_property(pid, GF_PROP_PID_DELAY, NULL);
+}
+
 static GF_Err compose_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
 {
 	GF_ObjectManager *odm;
@@ -242,11 +279,18 @@
 			} else if (scene->dims_url.OD_ID == ID) {
 				scene->dims_url.OD_ID = 0;
 				gf_scene_regenerate(scene);
+			} else if (scene->subs_url.OD_ID == ID) {
+				scene->subs_url.OD_ID = 0;
+				gf_scene_regenerate(scene);
 			}
 		}
 		return GF_OK;
 	}
 
+	if (!ctx->vout) {
+		compositor_setup_vout(ctx);
+	}
+
 	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
 	if (!prop) return GF_NOT_SUPPORTED;
 	mtype = prop->value.uint;
@@ -256,8 +300,41 @@
 	codecid = prop->value.uint;
 
 	odm = gf_filter_pid_get_udta(pid);
+
+	//in filter mode, check we can handle creating a canvas from input video format. If not, negociate a supported format
+	if (!ctx->player) {
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_PIXFMT);
+		if (prop && (!odm || (odm->mo && (odm->mo->pixelformat != prop->value.uint)))) {
+			GF_EVGSurface *test_c = gf_evg_surface_new(GF_FALSE);
+			GF_Err e = gf_evg_surface_attach_to_buffer(test_c, (u8 *) prop, 48, 48, 0, 0, prop->value.uint);
+			gf_evg_surface_delete(test_c);
+			if (e) {
+				u32 new_fmt;
+				Bool transparent = gf_pixel_fmt_is_transparent(prop->value.uint);
+				if (gf_pixel_fmt_is_yuv(prop->value.uint)) {
+					if (!transparent && gf_pixel_is_wide_depth(prop->value.uint)>8) {
+						new_fmt = GF_PIXEL_YUV444_10;
+					} else {
+						new_fmt = transparent ? GF_PIXEL_YUVA444_PACK : GF_PIXEL_YUV444_PACK;
+					}
+				} else {
+					new_fmt = transparent ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
+				}
+				gf_filter_pid_negociate_property(pid, GF_PROP_PID_PIXFMT, &PROP_UINT(new_fmt) );
+				return GF_OK;
+			}
+		}
+	}
+
 	if (odm) {
 		Bool notify_quality = GF_FALSE;
+
+		if (gf_filter_pid_is_sparse(pid)) {
+			odm->flags |= GF_ODM_IS_SPARSE;
+		} else {
+			odm->flags &= ~GF_ODM_IS_SPARSE;
+		}
+
 		if (mtype==GF_STREAM_SCENE) { }
 		else if (mtype==GF_STREAM_OD) { }
 		//change of stream type for a given object, no use case yet
@@ -272,6 +349,7 @@
 				}
 			}
 			gf_odm_update_duration(odm, pid);
+			//we can safely call this here since we are in reconfigure
 			gf_odm_check_clock_mediatime(odm);
 			notify_quality = GF_TRUE;
 		}
@@ -495,7 +573,12 @@
 			gf_sg_reset(scene->graph);
 
 		gf_scene_regenerate(scene);
+
+		if (!ctx->player)
+			gf_filter_pid_set_property_str(ctx->vout, "InteractiveScene", scene_vr_type ? &PROP_UINT(2) : NULL);
 	}
+	else if (!ctx->player)
+		gf_filter_pid_set_property_str(ctx->vout, "InteractiveScene", &PROP_UINT(1));
 
 	merge_properties(ctx, pid, mtype, scene);
 	return GF_OK;
@@ -527,10 +610,17 @@
 				}
 			}
 #endif
-			ctx->opfmt = p->value.uint;
-			gf_filter_pid_set_property(ctx->vout, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->opfmt) );
-			gf_pixel_get_size_info(ctx->opfmt, ctx->display_width, ctx->display_height, NULL, &stride, NULL, NULL, NULL);
-			gf_filter_pid_set_property(ctx->vout, GF_PROP_PID_STRIDE, &PROP_UINT(stride) );
+			if (ctx->opfmt != p->value.uint) {
+				ctx->opfmt = p->value.uint;
+				gf_filter_pid_set_property(ctx->vout, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->opfmt) );
+				gf_pixel_get_size_info(ctx->opfmt, ctx->display_width, ctx->display_height, NULL, &stride, NULL, NULL, NULL);
+				gf_filter_pid_set_property(ctx->vout, GF_PROP_PID_STRIDE, &PROP_UINT(stride) );
+				if (!ctx->player) {
+					ctx->new_width = ctx->display_width;
+					ctx->new_height = ctx->display_height;
+					ctx->msg_type |= GF_SR_CFG_INITIAL_RESIZE;
+				}
+			}
 		}
 		
 		w = h = 0;
@@ -598,7 +688,6 @@
 	{
 		u32 bps=0;
 		u64 tot_size=0, down_size=0;
-		GF_ObjectManager *odm = gf_filter_pid_get_udta(evt->base.on_pid);
 		GF_PropertyEntry *pe=NULL;
 		GF_PropertyValue *p = (GF_PropertyValue *) gf_filter_pid_get_info(evt->base.on_pid, GF_PROP_PID_TIMESHIFT_STATE, &pe);
 		if (p && p->value.uint) {
@@ -624,21 +713,50 @@
 		if (p) down_size = p->value.longuint;
 
 		if (bps && down_size && tot_size) {
-			odm = gf_filter_pid_get_udta(evt->base.on_pid);
+			GF_ObjectManager *odm = gf_filter_pid_get_udta(evt->base.on_pid);
 			if ((down_size!=odm->last_filesize_signaled) || (down_size != tot_size)) {
 				odm->last_filesize_signaled = down_size;
 				gf_odm_service_media_event_with_download(odm, GF_EVENT_MEDIA_PROGRESS, down_size, tot_size, bps/8, 0, 0);
 			}
 		}
-
 		gf_filter_release_property(pe);
-		gf_odm_check_clock_mediatime(odm);
 	}
 		return GF_TRUE;
 
 	case GF_FEVT_USER:
 		return gf_sc_user_event(gf_filter_get_udta(filter), (GF_Event *) &evt->user_event.event);
 
+	//handle play for non-player mode, dynamic scenes only
+	case GF_FEVT_PLAY:
+	{
+		GF_Compositor *compositor = gf_filter_get_udta(filter);
+		s32 diff = (s32) (evt->play.start_range*1000);
+		diff -= (s32) gf_sc_get_time_in_ms(compositor);
+		if (!compositor->player && compositor->root_scene->is_dynamic_scene && !evt->play.initial_broadcast_play
+			&& (abs(diff)>=1000)
+		) {
+			gf_sc_play_from_time(compositor, (u64) (evt->play.start_range*1000), GF_FALSE);
+		}
+	}
+		break;
+	//handle stop for non-player mode, dynamic scenes only
+	case GF_FEVT_STOP:
+	{
+		GF_Compositor *compositor = gf_filter_get_udta(filter);
+		if (!compositor->player && !evt->play.initial_broadcast_play) {
+			if (compositor->root_scene->is_dynamic_scene) {
+				u32 i, count = gf_list_count(compositor->root_scene->resources);
+				for (i=0; i<count; i++) {
+					GF_ObjectManager *odm = gf_list_get(compositor->root_scene->resources, i);
+					gf_odm_stop(odm, GF_TRUE);
+				}
+			} else {
+				gf_odm_stop(compositor->root_scene->root_od, 1);
+			}
+		}
+	}
+		break;
+
 	default:
 		break;
 	}
@@ -667,7 +785,7 @@
 }
 void compositor_setup_aout(GF_Compositor *ctx)
 {
-	if (! (ctx->init_flags & GF_TERM_NO_AUDIO) && ctx->audio_renderer && !ctx->audio_renderer->aout) {
+	if (!ctx->noaudio && ctx->audio_renderer && !ctx->audio_renderer->aout) {
 		GF_FilterPid *pid = ctx->audio_renderer->aout = gf_filter_pid_new(ctx->filter);
 		gf_filter_pid_set_udta(pid, ctx);
 		gf_filter_pid_set_name(pid, "aout");
@@ -678,6 +796,7 @@
 		gf_filter_pid_set_property(pid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(44100) );
 		gf_filter_pid_set_property(pid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(2) );
 		gf_filter_pid_set_max_buffer(ctx->audio_renderer->aout, 1000*ctx->abuf);
+		gf_filter_pid_set_property(pid, GF_PROP_PID_DELAY, NULL);
 		gf_filter_pid_set_loose_connect(pid);
 	}
 }
@@ -686,16 +805,19 @@
 {
 	GF_Err e;
 	GF_FilterSessionCaps sess_caps;
-	GF_FilterPid *pid;
 	GF_Compositor *ctx = gf_filter_get_udta(filter);
 
-	ctx->magic = COMPOSITOR_MAGIC;
-	ctx->magic_ptr = (void *) ctx;
 	ctx->filter = filter;
 
 	if (gf_filter_is_dynamic(filter)) {
-		ctx->dyn_filter_mode = GF_TRUE;
+		ctx->forced_alpha = GF_TRUE;
 		ctx->vfr = GF_TRUE;
+	} else if (ctx->bc && !GF_COL_A(ctx->bc)) {
+		ctx->forced_alpha = GF_TRUE;
+	} else if ((ctx->opfmt == GF_PIXEL_RGBA) || (ctx->opfmt == GF_PIXEL_ARGB) || (ctx->opfmt == GF_PIXEL_YUVA)) {
+		ctx->forced_alpha = GF_TRUE;
+	} else if (ctx->noback) {
+		ctx->forced_alpha = GF_TRUE;
 	}
 
 	//playout buffer not greater than max buffer
@@ -737,38 +859,25 @@
 	if (ctx->player) {
 
 		//load audio filter chain, declaring audio output pid first
-		if (! (ctx->init_flags & (GF_TERM_NO_AUDIO|GF_TERM_NO_DEF_AUDIO_OUT)) ) {
+		if (!ctx->noaudio) {
 			GF_Filter *audio_out = gf_filter_load_filter(filter, "aout", &e);
 			ctx->audio_renderer->non_rt_output = 0;
 			if (!audio_out) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("Terminal Failed to load audio output filter (%s) - audio disabled\n", gf_error_to_string(e) ));
+				GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("Compositor Failed to load audio output filter (%s) - audio disabled\n", gf_error_to_string(e) ));
 			}
 //			else {
 //				gf_filter_reconnect_output(filter);
 //			}
 		}
 		compositor_setup_aout(ctx);
-	}
-	
-	//declare video output pid
-	pid = ctx->vout = gf_filter_pid_new(filter);
-	gf_filter_pid_set_name(pid, "vout");
-	//compositor initiated for RT playback, vout pid may not be connected
-	if (! (ctx->init_flags & GF_TERM_NO_DEF_AUDIO_OUT))
-		gf_filter_pid_set_loose_connect(pid);
 
-	gf_filter_pid_set_property(pid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW) );
-	gf_filter_pid_set_property(pid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_VISUAL) );
-	if (ctx->timescale)
-		gf_filter_pid_set_property(pid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->timescale) );
-	else
-		gf_filter_pid_set_property(pid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->fps.num) );
-
-	gf_filter_pid_set_property(pid, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->opfmt ? ctx->opfmt : GF_PIXEL_RGB) );
-	gf_filter_pid_set_property(pid, GF_PROP_PID_WIDTH, &PROP_UINT(ctx->output_width) );
-	gf_filter_pid_set_property(pid, GF_PROP_PID_HEIGHT, &PROP_UINT(ctx->output_height) );
+		//create vout right away
+		compositor_setup_vout(ctx);
 
-	gf_filter_pid_set_property(pid, GF_PROP_PID_FPS, &PROP_FRAC(ctx->fps) );
+		//always request a process task since we don't depend on input packets arrival (animations, pure scene presentations)
+		gf_filter_post_process_task(filter);
+	}
+	//if not player mode, wait for pid connection to create vout, otherwise pid linking could fail
 
 	//for coverage
 #ifdef GPAC_ENABLE_COVERAGE
@@ -777,20 +886,18 @@
 	}
 #endif
 
-	//always request a process task since we don't depend on input packets arrival (animations, pure scene presentations)
-	gf_filter_post_process_task(filter);
-
 	gf_filter_set_event_target(filter, GF_TRUE);
 	if (ctx->player==2) {
-		const char *gui_path = gf_opts_get_key("General", "StartupFile");
+		const char *gui_path = gf_opts_get_key("core", "startup-file");
 		if (gui_path) {
-			gf_sc_connect_from_time_ex(ctx, gui_path, 0, 0, 0, NULL);
-			gf_opts_set_key("temp", "gui_load_url", ctx->src);
+			gf_sc_connect_from_time(ctx, gui_path, 0, 0, 0, NULL);
+			if (ctx->src)
+				gf_opts_set_key("temp", "gui_load_urls", ctx->src);
 		}
 	}
 	//src set, connect it (whether player mode or not)
 	else if (ctx->src) {
-		gf_sc_connect_from_time_ex(ctx, ctx->src, 0, 0, 0, NULL);
+		gf_sc_connect_from_time(ctx, ctx->src, 0, 0, 0, NULL);
 	}
 	return GF_OK;
 }
@@ -1000,6 +1107,13 @@
 	{ OFFS(gaze_x), "horizontal gaze coordinate (0=left, width=right)", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
 	{ OFFS(gaze_y), "vertical gaze coordinate (0=top, height=bottom)", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
 	{ OFFS(gazer_enabled), "enable gaze event dispatch", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+
+	{ OFFS(subtx), "horizontal translation in pixels towards right for subtitles renderers", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+	{ OFFS(subty), "vertical translation in pixels towards top for subtitles renderers", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+	{ OFFS(subfs), "font size for subtitles renderers (0 means automatic)", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+	{ OFFS(subd), "subtitle delay in milliseconds for subtitles renderers", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+	{ OFFS(audd), "audio delay in milliseconds", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+	{ OFFS(clipframe), "visual output is clipped to bounding rectangle", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -1046,6 +1160,7 @@
 	"- `rgb` when the filter is explicitly loaded by the application\n"
 	"- `rgba` when the filter is loaded during a link resolution\n"
 	"This can be changed by assigning the -opfmt() option.\n"
+	"If either -opfmt() specifies alpha channel or -bc() is not 0 but has alpha=0, background creation in default scene will be skipped.\n"
 	"\n"
 	"In filter-only mode, the special URL `gpid://` is used to locate PIDs in the scene description, in order to design scenes independently from source media.\n"
 	"When such a PID is associated to a `Background2D` node in BIFS (no SVG mapping yet), the compositor operates in pass-through mode.\n"

gpac-2.0.0.tar.gz/src/filters/dasher.c -> gpac-2.2.0.tar.gz/src/filters/dasher.c Changed

@@ -32,7 +32,7 @@
 #include <gpac/network.h>
 #include <gpac/crypt_tools.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
+#if !defined(GPAC_DISABLE_MPD)
 
 #define DEFAULT_PERIOD_ID	 "_gf_dash_def_period"
 
@@ -51,6 +51,7 @@
 	DASHER_BS_SWITCH_ON,
 	DASHER_BS_SWITCH_INBAND,
 	DASHER_BS_SWITCH_INBAND_PPS,
+	DASHER_BS_SWITCH_BOTH,
 	DASHER_BS_SWITCH_FORCE,
 	DASHER_BS_SWITCH_MULTI,
 };
@@ -77,6 +78,7 @@
 	DASHER_SAP_OFF=0,
 	DASHER_SAP_SIG,
 	DASHER_SAP_ON,
+	DASHER_SAP_INTRA_ONLY,
 };
 
 enum
@@ -128,6 +130,13 @@
 	DASHER_CMAF_CMF2
 };
 
+enum
+{
+	DASHER_DEFKID_OFF=0,
+	DASHER_DEFKID_ON,
+	DASHER_DEFKID_AUTO
+};
+
 typedef struct
 {
 	u32 bs_switch, profile, spd, cp, ntp;
@@ -138,6 +147,7 @@
 	u32 strict_sap;
 	u32 pssh;
 	u32 cmaf;
+	u32 dkid;
 	GF_Fraction segdur;
 	u32 dmode;
 	char *template;
@@ -153,7 +163,7 @@
 	char *title, *source, *info, *cprt, *lang;
 	char *chain, *chain_fbk;
 	GF_PropStringList location, base;
-	Bool check_dur, skip_seg, loop, reschedule, scope_deps;
+	Bool check_dur, skip_seg, loop, reschedule, scope_deps, keep_src;
 	Double refresh, tsb, subdur;
 	u64 *_p_gentime, *_p_mpdtime;
 	Bool cmpd, dual, sreg, pswitch;
@@ -163,12 +173,15 @@
 	char *utcs;
 	char *mname;
 	char *hlsdrm;
+	char *ckurl;
 	GF_PropStringList hlsx;
 	u32 llhls;
 	//inherited from mp4mx
 	GF_Fraction cdur;
-	Bool ll_preload_hint, ll_rend_rep;
-	Bool gencues;
+	Bool ll_preload_hint, ll_rend_rep, seg_sync;
+	Bool gencues, force_init, gxns;
+	Double ll_part_hb;
+	u32 hls_absu;
 
 	//internal
 	Bool in_error;
@@ -188,7 +201,7 @@
 	s32 period_idx;
 
 	GF_List *tpl_records;
-	Bool use_xlink, use_cenc, check_main_role;
+	Bool use_xlink, use_cenc, check_main_role, use_clearkey;
 
 	//options for muxers, constrained by profile
 	Bool no_fragments_defaults;
@@ -247,6 +260,8 @@
 	u64 min_segment_start_time, last_min_segment_start_time;
 
 	u32 def_max_seg_dur;
+
+	GF_Fraction64 min_cts_period;
 } GF_DasherCtx;
 
 typedef enum
@@ -276,7 +291,7 @@
 	char *template;
 	char *xlink;
 	char *hls_vp_name;
-	u32 nb_surround, nb_lfe;
+	u32 nb_surround, nb_lfe, atmos_complexity_type;
 	u64 ch_layout;
 	GF_PropVec4i srd;
 	DasherHDRType hdr_type;
@@ -320,7 +335,7 @@
 	//the parent adaptation set
 	GF_MPD_AdaptationSet *set;
 	Bool owns_set;
-	//set to 1 if full inband params, 2 if pps/aps only, 0 otherwise
+	//set to 1 if full inband params, 2 if pps/aps only, 3 if both inband and outband, 0 otherwise
 	u32 inband_params;
 	GF_List *multi_pids;
 	GF_List *multi_tracks;
@@ -525,6 +540,7 @@
 
 static GF_Err dasher_hls_setup_crypto(GF_DasherCtx *ctx, GF_DashStream *ds)
 {
+#ifndef GPAC_DISABLE_CRYPTO
 	GF_Err e;
 	u32 pid_id=1;
 	u32 i, count;
@@ -581,8 +597,10 @@
 			ds->iv_low <<= 8;
 		}
 	}
-
 	return GF_OK;
+#else
+	return GF_NOT_SUPPORTED;
+#endif
 }
 
 static u32 dasher_get_dep_bitrate(GF_DasherCtx *ctx, GF_DashStream *ds)
@@ -753,20 +771,42 @@
 			if (p && p->value.uint) {
 				ds->stl = GF_TRUE;
 				ds->mpd_timescale = p->value.uint;
+			} else if (ctx->stl) {
+				ds->mpd_timescale = ds->timescale;
 			}
-			else
-				ds->stl = GF_FALSE;
 		}
 	}
 	return e;
 }
 
+static void dasher_get_dash_dur(GF_DasherCtx *ctx, GF_DashStream *ds)
+{
+	ds->dash_dur = ctx->segdur;
+	const GF_PropertyValue *p = gf_filter_pid_get_property(ds->ipid, GF_PROP_PID_DASH_DUR);
+	if (p) {
+		ds->dash_dur = p->value.frac;
+		ds->no_seg_dur = GF_FALSE;
+		if (!ds->dash_dur.num || !ds->dash_dur.den) {
+			ds->dash_dur.num = 1;
+			ds->dash_dur.den = 1;
+		}
+	}
+	//this avoids very weird cases where (u64) (dash_dur*timescale) is 0. we limit the max segment duration to 1M sec, a bit more than 11.5 days
+	if ((u64) ds->dash_dur.num > (u64)ds->dash_dur.den * 1000000) {
+		ds->dash_dur.num = 1000000;
+		ds->dash_dur.den = 1;
+	}
+}
+
 static void dasher_send_encode_hints(GF_DasherCtx *ctx, GF_DashStream *ds)
 {
 	if (!ctx->sfile && !ds->stl && !ctx->use_cues) {
 		GF_FilterEvent evt;
 		GF_FEVT_INIT(evt, GF_FEVT_ENCODE_HINTS, ds->ipid)
+		if (!ds->dash_dur.num)
+			dasher_get_dash_dur(ctx, ds);
 		evt.encode_hints.intra_period = ds->dash_dur;
+
 		gf_filter_pid_send_event(ds->ipid, &evt);
 	}
 }
@@ -1209,22 +1249,9 @@
 			ds->src_url = gf_strdup("file");
 		ds->startNumber = 1;
 		CHECK_PROP(GF_PROP_PID_START_NUMBER, ds->startNumber, GF_EOS)
-		ds->dash_dur = ctx->segdur;
+
 		ds->no_seg_dur = ctx->no_seg_dur;
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_DASH_DUR);
-		if (p) {
-			ds->dash_dur = p->value.frac;
-			ds->no_seg_dur = GF_FALSE;
-			if (!ds->dash_dur.num || !ds->dash_dur.den) {
-				ds->dash_dur.num = 1;
-				ds->dash_dur.den = 1;
-			}
-		}
-		//this avoids very weird cases where (u64) (dash_dur*timescale) is 0. we limit the max segment duration to 1M sec, a bit more than 11.5 days
-		if ((u64) ds->dash_dur.num > (u64)ds->dash_dur.den * 1000000) {
-			ds->dash_dur.num = 1000000;
-			ds->dash_dur.den = 1;
-		}
+		dasher_get_dash_dur(ctx, ds);
 
 		ds->splitable = GF_FALSE;
 		switch (ds->stream_type) {
@@ -1323,11 +1350,14 @@
 					gf_odf_ac3_config_parse(dsi->value.data.ptr, dsi->value.data.size, (ds->codec_id==GF_CODECID_EAC3) ? GF_TRUE : GF_FALSE, &ac3);
 
 					ds->nb_lfe = ac3.streams0.lfon ? 1 : 0;
-					_nb_ch = gf_ac3_get_channels(ac3.streams0.acmod);
+					ds->nb_surround = gf_ac3_get_surround_channels(ac3.streams0.acmod);
+					ds->atmos_complexity_type = ac3.is_ec3 ? ac3.complexity_index_type : 0;
+					_nb_ch = gf_ac3_get_total_channels(ac3.streams0.acmod);
 					for (i=0; i<ac3.streams0.nb_dep_sub; ++i) {
 						assert(ac3.streams0.nb_dep_sub == 1);
-						_nb_ch += gf_ac3_get_channels(ac3.streams0.chan_loc);
+						_nb_ch += gf_eac3_get_chan_loc_count(ac3.streams0.chan_loc);
 					}
+ if (ds->nb_lfe) _nb_ch++;
 				}
 				break;
 			}
@@ -1550,13 +1580,14 @@
 	char profiles_stringGF_MAX_PATH;
 	GF_XMLAttribute *cenc_att = NULL;
 	GF_XMLAttribute *xlink_att = NULL;
+	GF_XMLAttribute *ck_att = NULL;
 
 	u32 i, count=gf_list_count(ctx->mpd->x_attributes);
 	for (i=0; i<count; i++) {
 		GF_XMLAttribute * att = gf_list_get(ctx->mpd->x_attributes, i);
 		if (!strcmp(att->name, "xmlns:cenc")) cenc_att = att;
 		if (!strcmp(att->name, "xmlns:xlink")) xlink_att = att;
-
+		if (!strcmp(att->name, "xmlns:ck")) ck_att = att;
 	}
 	if (ctx->dmode==GF_MPD_TYPE_DYNAMIC) {
 		ctx->mpd->type = GF_MPD_TYPE_DYNAMIC;
@@ -1615,6 +1646,10 @@
 		xlink_att = gf_xml_dom_create_attribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
 		gf_list_add(ctx->mpd->x_attributes, xlink_att);
 	}
+	if (ctx->use_clearkey && !ck_att) {
+		ck_att = gf_xml_dom_create_attribute("xmlns:ck", "http://dashif.org/guidelines/clearKey");
+		gf_list_add(ctx->mpd->x_attributes, ck_att);
+	}
 
 	ctx->mpd->time_shift_buffer_depth = 0;
 	ctx->mpd->minimum_update_period = 0;
@@ -1649,6 +1684,7 @@
 	ctx->mpd->locations = gf_list_new();
 	ctx->mpd->program_infos = gf_list_new();
 	ctx->mpd->periods = gf_list_new();
+	ctx->mpd->use_gpac_ext = ctx->gxns;
 	//created by default because we store xmlns in it
 	ctx->mpd->x_attributes = gf_list_new();
 	if (ctx->buf<0) {
@@ -1984,7 +2020,16 @@
 				if (p) subtype = gf_audio_fmt_to_isobmf(p->value.uint);
 			}
 		}
+
 		if (!subtype) {
+			const char *mime = gf_codecid_mime(ds->codec_id);
+			if (mime) mime = strchr(mime, '/');
+			if (mime) mime++;
+			if (mime && mime0) {
+				GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("Dasher codec parameters not known, using mime type %s\n", mime));
+				strcpy(szCodec, mime);
+				return GF_OK;
+			}
 			GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("Dasher codec parameters not known, cannot set codec string\n" ));
 			strcpy(szCodec, "unkn");
 			return GF_OK;
@@ -2056,7 +2101,6 @@
 
 static GF_List *dasher_get_content_protection_desc(GF_DasherCtx *ctx, GF_DashStream *ds, GF_MPD_AdaptationSet *for_set)
 {
-	char sCan40;
 	u32 prot_scheme=0;
 	u32 i, count;
 	const GF_PropertyValue *p;
@@ -2082,10 +2126,14 @@
 		p = gf_filter_pid_get_property(a_ds->ipid, GF_PROP_PID_PROTECTION_SCHEME_TYPE);
 		if (p) prot_scheme = p->value.uint;
 
+
+#ifndef GPAC_DISABLE_ISOM
 		if ((prot_scheme==GF_ISOM_CENC_SCHEME) || (prot_scheme==GF_ISOM_CBC_SCHEME) || (prot_scheme==GF_ISOM_CENS_SCHEME) || (prot_scheme==GF_ISOM_CBCS_SCHEME)
 		) {
+			char sCan40;
 			const GF_PropertyValue *ki;
 			u32 j, nb_pssh;
+			Bool add_kid=GF_FALSE;
 			GF_XMLAttribute *att;
 			char szValGF_MAX_PATH;
 
@@ -2100,12 +2148,41 @@
 			desc = gf_mpd_descriptor_new(NULL, "urn:mpeg:dash:mp4protection:2011", gf_4cc_to_str(prot_scheme));
 			gf_list_add(res, desc);
 
-			get_canon_urn(ki->value.data.ptr + 4, sCan);
-			att = gf_xml_dom_create_attribute("cenc:default_KID", sCan);
-			if (!desc->x_attributes) desc->x_attributes = gf_list_new();
-			gf_list_add(desc->x_attributes, att);
+			if (ctx->dkid==DASHER_DEFKID_ON) {
+				add_kid = GF_TRUE;
+			} else if (ctx->dkid==DASHER_DEFKID_AUTO) {
+				p = gf_filter_pid_get_property(a_ds->ipid, GF_PROP_PID_CENC_HAS_ROLL);
+				if (!p || !p->value.boolean) add_kid = GF_TRUE;
+			}
+
+			if (add_kid) {
+				get_canon_urn(ki->value.data.ptr + 4, sCan);
+				att = gf_xml_dom_create_attribute("cenc:default_KID", sCan);
+				if (!desc->x_attributes) desc->x_attributes = gf_list_new();
+				gf_list_add(desc->x_attributes, att);
+			}
+
+			char *ck_url = ctx->ckurl;
+			p = gf_filter_pid_get_property(a_ds->ipid, GF_PROP_PID_CLEARKEY_URI);
+			if (p && p->value.string) ck_url = p->value.string;
+			if (ck_url) {
+				desc = gf_mpd_descriptor_new(NULL, "urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e", "ClearKey1.0");
+				gf_list_add(res, desc);
+				GF_XMLNode *ck = gf_xml_dom_node_new("ck", "Laurl");
+
+				if (!desc->x_children) desc->x_children = gf_list_new();
+				gf_list_add(desc->x_children, ck);
+
+				GF_XMLNode *val = gf_xml_dom_node_new(NULL, NULL);
+				val->type = GF_XML_TEXT_TYPE;
+				val->name = gf_strdup(ck_url);
+				if (!ck->content) ck->content = gf_list_new();
+				gf_list_add(ck->content, val);
+				ctx->use_clearkey = GF_TRUE;
+			}
+
 
-			if (ctx->pssh <= GF_DASH_PSSH_MOOF) {
+			if ((ctx->pssh <= GF_DASH_PSSH_MOOF) || (ctx->pssh == GF_DASH_PSSH_NONE)) {
 				continue;
 			}
 			//(data) binary blob containing (u32)N (bin128)SystemID(u32)version(u32)KID_count(bin128)keyID(u32)priv_size(char*priv_size)priv_data
@@ -2177,8 +2254,8 @@
 						pnode->type = GF_XML_TEXT_TYPE;
 						gf_list_add(node->content, pnode);
 
-						size_64 = 2*pssh_len;
-						pnode->name = gf_malloc(size_64);
+						size_64 = 2*pssh_len + 3;
+						pnode->name = gf_malloc(sizeof(char) * size_64);
 						if (pnode->name) {
 							size_64 = gf_base64_encode((const char *)pssh_data, pssh_len, (char *)pnode->name, size_64);
 							pnode->namesize_64 = 0;
@@ -2187,7 +2264,9 @@
 				}
 				gf_free(pssh_data);
 			}
-		} else {
+		} else
+#endif // GPAC_DISABLE_ISOM
+		{
 			if (ctx->do_mpd) {
 				GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("Dasher Protection scheme %s has no official DASH mapping, using URI \"urn:gpac:dash:mp4protection:2018\"\n", gf_4cc_to_str(prot_scheme)));
 			}
@@ -2336,6 +2415,14 @@
 		gf_mpd_del_list(ds->rep->audio_channels, gf_mpd_descriptor_free, GF_TRUE);
 
 		gf_list_add(ds->rep->audio_channels, desc);
+		if (ds->atmos_complexity_type) {
+			desc = gf_mpd_descriptor_new(NULL, "tag:dolby.com,2018:dash:EC3_ExtensionType:2018", "JOC");
+			gf_list_add(ds->rep->supplemental_properties, desc);
+
+			sprintf(value, "%d", ds->atmos_complexity_type);
+			desc = gf_mpd_descriptor_new(NULL, "tag:dolby.com,2018:dash:EC3_ExtensionComplexityIndex:2018", value);
+			gf_list_add(ds->rep->supplemental_properties, desc);
+		}
 	} else {
 	}
 
@@ -2727,7 +2814,7 @@
 static void dasher_check_bitstream_swicthing(GF_DasherCtx *ctx, GF_MPD_AdaptationSet *set)
 {
 	u32 i, j, count;
-	Bool use_inband = ((ctx->bs_switch==DASHER_BS_SWITCH_INBAND) || (ctx->bs_switch==DASHER_BS_SWITCH_INBAND_PPS)) ? GF_TRUE : GF_FALSE;
+	Bool use_inband = ((ctx->bs_switch==DASHER_BS_SWITCH_INBAND) || (ctx->bs_switch==DASHER_BS_SWITCH_INBAND_PPS) || (ctx->bs_switch==DASHER_BS_SWITCH_BOTH)) ? GF_TRUE : GF_FALSE;
 	Bool use_multi = (ctx->bs_switch==DASHER_BS_SWITCH_MULTI) ? GF_TRUE : GF_FALSE;
 	GF_MPD_Representation *base_rep = gf_list_get(set->representations, 0);
 	GF_DashStream *base_ds;
@@ -2751,11 +2838,9 @@
 	if (count==1) {
 		if (ctx->bs_switch==DASHER_BS_SWITCH_FORCE) set->bitstream_switching=GF_TRUE;
 		else if (use_inband) {
-			if (base_ds->codec_id==GF_CODECID_VVC) {
-				base_ds->inband_params = (ctx->bs_switch==DASHER_BS_SWITCH_INBAND_PPS) ? 2 : 1;
-			} else {
-				base_ds->inband_params = 1;
-			}
+			base_ds->inband_params = ctx->bs_switch==DASHER_BS_SWITCH_BOTH ? 3 : 1;
+			if (base_ds->codec_id==GF_CODECID_VVC && ctx->bs_switch==DASHER_BS_SWITCH_INBAND_PPS)
+				base_ds->inband_params = 2;
 		}
 		return;
 	}
@@ -2827,6 +2912,8 @@
 	Bool has_strun=GF_FALSE;
 	Bool has_vodcache=GF_FALSE;
 	Bool has_cmaf=GF_FALSE;
+	Bool has_psshs=GF_FALSE;
+	const GF_PropertyValue *p;
 	char sep_args = gf_filter_get_sep(filter, GF_FS_SEP_ARGS);
 	char sep_name = gf_filter_get_sep(filter, GF_FS_SEP_NAME);
 	const char *dst_args, *trailer_args=NULL;
@@ -2901,6 +2988,9 @@
 
 		sprintf(szKey, "%ccmaf", sep_args);
 		if (strstr(dst_args, szKey)) has_cmaf = GF_TRUE;
+
+		sprintf(szKey, "%cpsshs", sep_args);
+		if (strstr(dst_args, szKey)) has_psshs = GF_TRUE;
 	}
 
 	if (trash_init) {
@@ -2929,28 +3019,53 @@
 		}
 	}
 
-	//override xps inband declaration in args
-	sprintf(szSRC, "%cxps_inband%c%s", sep_args, sep_name,
-		(ds->inband_params==2) ? "pps" : (ds->inband_params ? "all" : "no") );
+	{
+		//override xps inband declaration in args
+		char *xps_inband;
+		switch (ds->inband_params) {
+		case 1: xps_inband = "all"; break;
+		case 2: xps_inband = "pps"; break;
+		case 3: xps_inband = "both"; break;
+		default: xps_inband = "no"; break;
+		}
+		sprintf(szSRC, "%cxps_inband%c%s", sep_args, sep_name, xps_inband);
+	}
 	gf_dynstrcat(&szDST, szSRC, NULL);
 
 	if (ctx->no_fragments_defaults) {
 		sprintf(szSRC, "%cnofragdef", sep_args );
 		gf_dynstrcat(&szDST, szSRC, NULL);
 	}
-	switch (ctx->pssh) {
-	case GF_DASH_PSSH_MPD:
-		sprintf(szSRC, "%cpsshs%cnone", sep_args, sep_name);
-		break;
-	case GF_DASH_PSSH_MOOF:
-	case GF_DASH_PSSH_MOOF_MPD:
-		sprintf(szSRC, "%cpsshs%cmoof", sep_args, sep_name);
-		break;
-	default:
-		sprintf(szSRC, "%cpsshs%cmoov", sep_args, sep_name);
-		break;
+	if (!has_psshs) {
+		switch (ctx->pssh) {
+		case GF_DASH_PSSH_MPD:
+		case GF_DASH_PSSH_NONE:
+			sprintf(szSRC, "%cpsshs%cnone", sep_args, sep_name);
+			break;
+		case GF_DASH_PSSH_MOOF:
+		case GF_DASH_PSSH_MOOF_MPD:
+			p = gf_filter_pid_get_property(ds->ipid, GF_PROP_PID_CENC_HAS_ROLL);
+			//dual moov+moof only for dash
+			if (!ctx->do_mpd) p = NULL;
+			if (p && p->value.boolean) {
+				sprintf(szSRC, "%cpsshs%cboth", sep_args, sep_name);
+			} else {
+				sprintf(szSRC, "%cpsshs%cmoof", sep_args, sep_name);
+			}
+			break;
+		default:
+			p = gf_filter_pid_get_property(ds->ipid, GF_PROP_PID_CENC_HAS_ROLL);
+			//dual moov+moof only for dash
+			if (!ctx->do_mpd) p = NULL;
+			if (p && p->value.boolean) {
+				sprintf(szSRC, "%cpsshs%cboth", sep_args, sep_name);
+			} else {
+				sprintf(szSRC, "%cpsshs%cmoov", sep_args, sep_name);
+			}
+			break;
+		}
+		gf_dynstrcat(&szDST, szSRC, NULL);
 	}
-	gf_dynstrcat(&szDST, szSRC, NULL);
 
 	//patch for old arch: make sure we don't have any extra free box before the sidx
 	//we could also use vodcache=insert but this might break http outputs
@@ -3125,6 +3240,8 @@
 	gf_filter_pid_set_property(ds->opid, GF_PROP_PID_MUX_SRC, &PROP_STRING(szSRC) );
 	gf_filter_pid_set_property(ds->opid, GF_PROP_PID_DASH_MODE, &PROP_UINT(ctx->sseg ? 2 : 1) );
 	gf_filter_pid_set_property(ds->opid, GF_PROP_PID_DASH_DUR, &PROP_FRAC(ds->dash_dur) );
+	if (ctx->seg_sync)
+		gf_filter_pid_set_property(ds->opid, GF_PROP_PID_FORCE_SEG_SYNC, &PROP_BOOL(GF_TRUE) );
 
 	if (ds->id != ds->pid_id) {
 		dasher_update_dep_list(ctx, ds, "isom:scal");
@@ -3184,15 +3301,18 @@
 		gf_filter_pid_set_property(ds->opid, GF_PROP_PID_LLHLS, &PROP_UINT(ctx->llhls) );
 	}
 
-	if (ctx->tsb>=0) {
+	if ((ctx->dmode > GF_DASH_STATIC) && (ctx->tsb>=0)) {
 		u32 tsb_seg = ds->dash_dur.num ? ((u32) (ctx->tsb * ds->dash_dur.den / ds->dash_dur.num)) : 0;
 		tsb_seg++;
 		gf_filter_pid_set_property(ds->opid, GF_PROP_PID_TIMESHIFT_SEGS, &PROP_UINT(tsb_seg) );
+	} else {
+		gf_filter_pid_set_property(ds->opid, GF_PROP_PID_TIMESHIFT_SEGS, NULL);
 	}
 }
 
 static Bool dasher_template_use_source_url(const char *template)
 {
+	if (!template) return GF_FALSE;
 	if (strstr(template, "$File$") != NULL) return GF_TRUE;
 	else if (strstr(template, "$FSRC$") != NULL) return GF_TRUE;
 	else if (strstr(template, "$SourcePath$") != NULL) return GF_TRUE;
@@ -3273,7 +3393,7 @@
 	GF_List *multi_pids = NULL;
 	u32 set_timescale = 0;
 	Bool init_template_done=GF_FALSE;
-	Bool use_inband = ((ctx->bs_switch==DASHER_BS_SWITCH_INBAND) || (ctx->bs_switch==DASHER_BS_SWITCH_INBAND_PPS)) ? GF_TRUE : GF_FALSE;
+	Bool use_inband = ((ctx->bs_switch==DASHER_BS_SWITCH_INBAND) || (ctx->bs_switch==DASHER_BS_SWITCH_INBAND_PPS) || (ctx->bs_switch==DASHER_BS_SWITCH_BOTH)) ? GF_TRUE : GF_FALSE;
 	Bool template_use_source = GF_FALSE;
 	Bool split_rep_names = GF_FALSE;
 	Bool split_set_names = GF_FALSE;
@@ -3575,7 +3695,7 @@
 		}
 
 		if (use_inband) {
-			ds->inband_params = 1;
+			ds->inband_params = ctx->bs_switch==DASHER_BS_SWITCH_BOTH ? 3 : 1;
 			if ((ds->codec_id==GF_CODECID_VVC) && (ctx->bs_switch==DASHER_BS_SWITCH_INBAND_PPS))
 				ds->inband_params = 2;
 		}
@@ -3673,6 +3793,8 @@
 			if (ext_sub) {
 				if (!strcmp(ext_sub, "subx"))
 					ext_sub = "ttml";
+				if (!strcmp(ext_sub, "tx3g"))
+					ext_sub = "srt";
 
 				strncpy(szRawExt, ext_sub, 19);
 				szRawExt19 = 0;
@@ -3681,6 +3803,16 @@
 				def_ext = szRawExt;
 				skip_init = GF_TRUE;
 				ds->rawmux = GF_TRUE;
+
+				if (ds->rep->mime_type) gf_free(ds->rep->mime_type);
+				const char *mime = gf_codecid_mime(ds->codec_id);
+				if (!mime) mime = "text/plain";
+				ds->rep->mime_type = gf_strdup(mime);
+
+				if (ds->rep->codecs) {
+					gf_free(ds->rep->codecs);
+					ds->rep->codecs = NULL;
+				}
 			}
 		}
 
@@ -3763,28 +3895,71 @@
 					strcpy(szInitSegmentFilename, gf_file_basename(ds->src_url));
 
 					if (ctx->out_path && mpd_url) {
-						char *url, *mpd_out;
+						Bool keep_src = GF_FALSE;
+						char *url, *mpd_out, *mpd_src_alloc=NULL;
 						mpd_out = gf_file_basename(ctx->out_path);
 						u32 len = (u32) (mpd_out - ctx->out_path);
 						char *mpd_src = mpd_url->value.string;
-						if (!strncmp(ctx->out_path, mpd_url->value.string, len))
+						if (ctx->keep_src) {
+							keep_src = GF_TRUE;
+						}
+						else if (!strncmp(ctx->out_path, mpd_url->value.string, len))
 							mpd_src += len;
-
-						const GF_PropertyValue *init_url = gf_filter_pid_get_property_str(ds->ipid, "init_url");
-						if (init_url) {
-							url = gf_url_concatenate(mpd_src, init_url->value.string);
-							strcpy(szInitSegmentFilename, url);
-							strcpy(szInitSegmentTemplate, url);
-							gf_free(url);
+						else if (gf_url_is_relative(ctx->out_path) && gf_url_is_relative(mpd_src)) {
+							char *opath=NULL, *ipath=NULL;
+							if (ctx->out_path0!='.') gf_dynstrcat(&opath, "./", NULL);
+							gf_dynstrcat(&opath, ctx->out_path, NULL);
+							if (mpd_src0!='.') gf_dynstrcat(&ipath, "./", NULL);
+							gf_dynstrcat(&ipath, mpd_src, NULL);
+
+							mpd_src_alloc = gf_url_concatenate_parent(opath, ipath);
+							mpd_src = mpd_src_alloc;
+							if (opath) gf_free(opath);
+							if (ipath) gf_free(ipath);
 						} else {
-							//no init segment URL
-							strcpy(szInitSegmentFilename, "");
-							strcpy(szInitSegmentTemplate, "");
+							GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("Dasher Non-relative URLs used in manifest generation mode, cannot determine output locations. Source URLs will be kept\n"));
+							keep_src = GF_TRUE;
 						}
+						if (mpd_src && !strncmp(mpd_src, "./", 2)) mpd_src+=2;
 
-						url = gf_url_concatenate(mpd_src, ds->template);
-						strcpy(szSegmentName, url);
-						gf_free(url);
+						char *init_url=NULL;
+						const GF_PropertyValue *p = gf_filter_pid_get_property_str(ds->ipid, "init_url");
+						const GF_PropertyValue *hls_variant = gf_filter_pid_get_property_str(ds->ipid, "hls_variant_name");
+						if (p) {
+							if (hls_variant) {
+								init_url = gf_url_concatenate(hls_variant->value.string, p->value.string);
+							} else {
+								init_url = gf_strdup(p->value.string);
+							}
+						}
+						if (keep_src) {
+							strcpy(szInitSegmentFilename, init_url);
+							strcpy(szInitSegmentTemplate, init_url);
+							strcpy(szSegmentName, ds->template);
+						} else {
+							if (init_url) {
+								url = gf_url_concatenate(mpd_src, init_url);
+								strcpy(szInitSegmentFilename, url);
+								strcpy(szInitSegmentTemplate, url);
+								gf_free(url);
+							} else {
+								//no init segment URL
+								strcpy(szInitSegmentFilename, "");
+								strcpy(szInitSegmentTemplate, "");
+							}
+
+							if (hls_variant) {
+								char *tpl_int = gf_url_concatenate(hls_variant->value.string, ds->template);
+								url = gf_url_concatenate(mpd_src, tpl_int);
+								gf_free(tpl_int);
+							} else {
+								url = gf_url_concatenate(mpd_src, ds->template);
+							}
+							strcpy(szSegmentName, url);
+							gf_free(url);
+						}
+						if (init_url) gf_free(init_url);
+						if (mpd_src_alloc) gf_free(mpd_src_alloc);
 					}
 				 }
 			} else {
@@ -3875,7 +4050,7 @@
 
 		//we use segment template
 		if (ctx->tpl) {
-			Bool use_single_init;
+			Bool use_single_init, force_init_template=GF_FALSE;
 			GF_MPD_SegmentTemplate *seg_template;
 			u32 start_number = ds->startNumber ? ds->startNumber : 1;
 			u64 seg_duration = (u64)(ds->dash_dur.num) * ds->mpd_timescale / ds->dash_dur.den;
@@ -3885,6 +4060,10 @@
 				single_template = GF_FALSE;
 			} else {
 				use_single_init = (set->bitstream_switching || single_template) ? GF_TRUE : GF_FALSE;
+				if (is_bs_switch && ctx->force_init) {
+					use_single_init = GF_FALSE;
+					single_template = GF_FALSE;
+				}
 			}
 
 			//first rep in set and bs switching or single template, create segment template at set level
@@ -3898,7 +4077,11 @@
 							seg_template->initialization = force_init_seg_tpl ? gf_strdup(force_init_seg_tpl) : NULL;
 							seg_template->hls_init_name = force_init_seg_tpl ? tile_base_ds->init_seg : NULL;
 						} else {
-							seg_template->initialization = gf_strdup(szInitSegmentTemplate);
+							//bs switching, if we have still template fields init segment template use resolved init file name - cf #2141
+							if (!force_init_template && is_bs_switch && strchr(szInitSegmentTemplate, '$'))
+								seg_template->initialization = gf_strdup(szInitSegmentFilename);
+							else
+								seg_template->initialization = gf_strdup(szInitSegmentTemplate);
 							seg_template->hls_init_name = ds->init_seg;
 						}
 					}
@@ -4413,6 +4596,7 @@
 	u32 i, count, nb_periods, nb_streams;
 	GF_XMLAttribute *cenc_att = NULL;
 	GF_XMLAttribute *xlink_att = NULL;
+	GF_XMLAttribute *ck_att = NULL;
 	FILE *tmp = NULL;
 	GF_MPD *mpd = gf_mpd_new();
 	GF_List *recompute_sets = NULL;
@@ -4478,6 +4662,7 @@
 		GF_XMLAttribute * att = gf_list_get(mpd->x_attributes, i);
 		if (!strcmp(att->name, "xmlns:cenc")) cenc_att = att;
 		if (!strcmp(att->name, "xmlns:xlink")) xlink_att = att;
+		if (!strcmp(att->name, "xmlns:ck")) ck_att = att;
 
 	}
 	if (ctx->use_cenc && !cenc_att) {
@@ -4488,6 +4673,11 @@
 		xlink_att = gf_xml_dom_create_attribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
 		gf_list_add(mpd->x_attributes, xlink_att);
 	}
+	if (ctx->use_clearkey && !ck_att) {
+		ck_att = gf_xml_dom_create_attribute("xmlns:ck", "http://dashif.org/guidelines/clearKey");
+		gf_list_add(mpd->x_attributes, ck_att);
+	}
+
 
 	dasher_check_chaining(ctx, "urn:mpeg:dash:mpd-chaining:2016", ctx->chain);
 	dasher_check_chaining(ctx, "urn:mpeg:dash:fallback:2016", ctx->chain_fbk);
@@ -4526,6 +4716,9 @@
 		ctx->mpd->hls_ext_master = (const char **) ctx->hlsx.vals;
 		ctx->mpd->llhls_preload = ctx->ll_preload_hint;
 		ctx->mpd->llhls_rendition_reports = ctx->ll_rend_rep;
+		ctx->mpd->llhls_part_holdback = ctx->ll_part_hb;
+		ctx->mpd->hls_abs_url = ctx->hls_absu;
+
 		if (ctx->llhls==3)
 			ctx->mpd->force_llhls_mode = m3u8_second_pass ? 2 : 1;
 		else
@@ -5815,6 +6008,8 @@
 	min_dur.num = min_adur.num = max_adur.num = 0;
 	min_dur.den = min_adur.den = max_adur.den = 1;
 	srd_rep_idx = 2; //2 for compat with old arch
+	ctx->min_cts_period.num = 0;
+	ctx->min_cts_period.den = 0;
 
 	count = gf_list_count(ctx->current_period->streams);
 	//setup representations
@@ -5848,7 +6043,8 @@
 
 		if (ctx->loop) {
 			prop = gf_filter_pid_get_property(ds->ipid, GF_PROP_PID_DURATION);
-			if (prop && prop->value.lfrac.den) {
+			//only check true media dur
+			if (prop && prop->value.lfrac.den && (prop->value.lfrac.num>0)) {
 				GF_Fraction64 d;
 				d.num = prop->value.lfrac.num;
 				d.den = prop->value.lfrac.den;
@@ -5936,13 +6132,23 @@
 				}
 			}
 			//check if this rep should be muxed: same rep ID, not raw format, not CMAF
-			if (a_ds->muxed_base) continue;
+			if (a_ds->muxed_base) {
+				//happens when we switch base_ds to use video one
+				if (a_ds->muxed_base == ds) ds->nb_comp++;
+				continue;
+			}
 			if (ctx->muxtype==DASHER_MUX_RAW) continue;
 			if (ctx->cmaf) continue;
 			if (strcmp(a_ds->rep_id, ds->rep_id)) continue;
+			else if (ctx->sigfrag) {
+				if (a_ds->src_url && ds->src_url && strcmp(a_ds->src_url, ds->src_url)) continue;
+			}
 			if (a_ds->template && ds->template && strcmp(a_ds->template, ds->template)) continue;
 
 
+			if (!ds_video && (a_ds->stream_type==GF_STREAM_VISUAL))
+				ds_video = a_ds;
+
 			a_ds->muxed_base = ds;
 			a_ds->dash_dur = ds->dash_dur;
 			has_muxed_bases = GF_TRUE;
@@ -5971,14 +6177,21 @@
 			}
 		}
 		//use video as main stream for segmentation of muxed sources
-		if (ds_video != ds) {
+		if (ds_video && (ds_video != ds)) {
+			u32 nb_comp = ds->nb_comp;
 			for (j=0; j<count; j++) {
 				GF_DashStream *a_ds = gf_list_get(ctx->current_period->streams, j);
 				if ((a_ds->muxed_base==ds) || (a_ds==ds)) {
-					if (a_ds == ds_video)
+					if (a_ds == ds_video) {
 						a_ds->muxed_base = NULL;
-					else
+						a_ds->nb_comp = nb_comp;
+						if (a_ds->rep->codecs) gf_free(a_ds->rep->codecs);
+						a_ds->rep->codecs = ds->rep->codecs;
+						ds->rep->codecs = NULL;
+					} else {
 						a_ds->muxed_base = ds_video;
+						a_ds->nb_comp = 1;
+					}
 				}
 			}
 		}
@@ -5987,6 +6200,41 @@
 			ctx->def_max_seg_dur = (u32) ((ds->dash_dur.num * 1000) / ds->dash_dur.den);
 	}
 
+	if (ctx->sigfrag) {
+		Bool has_rep_conflict = GF_FALSE;
+		//make sure all representation have unique ids
+		for (i=0; i<count; i++) {
+			u32 nb_changed=0;
+			GF_DashStream *ds = gf_list_get(ctx->current_period->streams, i);
+			if (ds->muxed_base) continue;
+			for (j=0; j<count; j++) {
+				char szRep20;
+				GF_DashStream *a_ds;
+				if (j == i) continue;
+				a_ds = gf_list_get(ctx->current_period->streams, j);
+				if (a_ds->muxed_base) continue;
+
+				if (strcmp(ds->rep_id, a_ds->rep_id)) continue;
+				if (ds->template && strstr(ds->template, "$RepresentationID$")) {
+					has_rep_conflict = GF_TRUE;
+					continue;
+				}
+
+				nb_changed++;
+				sprintf(szRep, "%d", nb_changed);
+				gf_free(a_ds->rep_id);
+				a_ds->rep_id = NULL;
+				gf_dynstrcat(&a_ds->rep_id, ds->rep_id, NULL);
+				gf_dynstrcat(&a_ds->rep_id, "_", NULL);
+				gf_dynstrcat(&a_ds->rep_id, szRep, NULL);
+				gf_free(a_ds->rep->id);
+				a_ds->rep->id = gf_strdup(a_ds->rep_id);
+			}
+		}
+		if (has_rep_conflict && ctx->do_mpd) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Dasher Several representations with same ID and using $RepresentationID$ template, cannot change IDs. Resulting MPD is not strictly DASH compliant\n"));
+		}
+	}
 
 	if (ctx->loop && max_adur.num) {
 		if (max_adur.num * min_adur.den != min_adur.num * max_adur.den) {
@@ -6265,6 +6513,9 @@
 		ds->presentation_time_offset = 0;
 		ds->seg_done = GF_FALSE;
 		ds->next_seg_start = (u32) ( ((u64) ds->dash_dur.num * ds->timescale) / ds->dash_dur.den);
+		//adjust next_seg_start of first seg to presentation time if skip edit
+		if (!ds->cues && (ds->pts_minus_cts<0) && (ds->next_seg_start> (u32) -ds->pts_minus_cts))
+			ds->next_seg_start -= (u32) -ds->pts_minus_cts;
 		ds->adjusted_next_seg_start = ds->next_seg_start;
 		ds->segment_started = GF_FALSE;
 		ds->seg_number = ds->startNumber;
@@ -6551,6 +6802,14 @@
 		}
 		dasher_insert_timeline_entry(ctx, base_ds);
 
+		if (ctx->do_m3u8) {
+			u64 segdur = base_ds->first_cts_in_next_seg - ds->first_cts_in_seg;
+			if (gf_timestamp_less(base_ds->rep->hls_max_seg_dur.num, base_ds->rep->hls_max_seg_dur.den, segdur, base_ds->timescale)) {
+				base_ds->rep->hls_max_seg_dur.num = (s32) segdur;
+				base_ds->rep->hls_max_seg_dur.den = base_ds->timescale;
+			}
+		}
+
 		if (ctx->align) {
 			if (!set_ds->nb_rep_done || !set_ds->set_seg_duration) {
 				set_ds->set_seg_duration = seg_duration;
@@ -6726,23 +6985,39 @@
 	}
 }
 
-static char *dasher_strip_base(GF_DasherCtx *ctx, char *url)
+//seg_name is relative to the source manifest (MPD or master HLS) for segments
+static char *dasher_strip_base(GF_DasherCtx *ctx, GF_DashStream *ds, char *seg_url, char *seg_name)
 {
-	char *manifest_path = ctx->out_path;
-	char *file_path = url;
-	char *res = url;
+	if (ctx->keep_src) return gf_strdup(seg_name);
 
-	if (!manifest_path || !url) return NULL;
-	
-	if (!strncmp(manifest_path, "./", 2)) manifest_path+=2;
-	if (!strncmp(file_path, "./", 2)) file_path+=2;
+	const GF_PropertyValue *mpd_url = gf_filter_pid_get_property_str(ds->ipid, "manifest_url");
+	if (!mpd_url || !ctx->out_path) return gf_strdup(seg_url);
 
-	const char *base_manifest = gf_file_basename(manifest_path);
-	u32 diff = (u32) (base_manifest - manifest_path);
-	if (!strncmp(file_path, manifest_path, diff)) {
-		res = file_path + diff;
+	Bool gf_url_is_relative(const char *pathName);
+	char *url, *mpd_out, *mpd_src_alloc=NULL;
+	mpd_out = gf_file_basename(ctx->out_path);
+	u32 len = (u32) (mpd_out - ctx->out_path);
+	char *mpd_src = mpd_url->value.string;
+
+	if (!strncmp(ctx->out_path, mpd_url->value.string, len)) {
+		mpd_src += len;
+	} else if (gf_url_is_relative(ctx->out_path) && gf_url_is_relative(mpd_src)) {
+		char *opath=NULL, *ipath=NULL;
+		if (ctx->out_path0!='.') gf_dynstrcat(&opath, "./", NULL);
+		gf_dynstrcat(&opath, ctx->out_path, NULL);
+		if (mpd_src0!='.') gf_dynstrcat(&ipath, "./", NULL);
+		gf_dynstrcat(&ipath, mpd_src, NULL);
+
+		mpd_src_alloc = gf_url_concatenate_parent(opath, ipath);
+		mpd_src = mpd_src_alloc;
+		if (opath) gf_free(opath);
+		if (ipath) gf_free(ipath);
+	} else {
+		return gf_strdup(seg_name);
 	}
-	return res;
+
+	url = gf_url_concatenate(mpd_src, seg_name);
+	return url;
 }
 
 static GFINLINE
@@ -6885,12 +7160,7 @@
 				ds->rep->groupID = p->value.string;
 
 			ds->rep->dash_dur = ds->dash_dur;
-			if (ctx->sigfrag) {
-				const GF_PropertyValue *pid_url = gf_filter_pid_get_property(ds->ipid, GF_PROP_PID_URL);
-				if (pid_url && pid_url->value.string) {
-					ds->rep->hls_single_file_name = dasher_strip_base(ctx, pid_url->value.string);
-				}
-			}
+			ds->rep->hls_max_seg_dur = ds->dash_dur;
 
 			if (!ds->rep->hls_single_file_name) {
 				switch (ctx->muxtype) {
@@ -6988,11 +7258,11 @@
 		if (ctx->sigfrag) {
 			const GF_PropertyValue *frag_range = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_FRAG_RANGE);
 			const GF_PropertyValue *frag_url = gf_filter_pck_get_property(in_pck, GF_PROP_PID_URL);
-			if (frag_url && frag_url->value.string) {
-				char *f_url = dasher_strip_base(ctx, frag_url->value.string);
-				seg_state->filename = gf_strdup(f_url);
-			}
-			else if (frag_range) {
+			const GF_PropertyValue *frag_name = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_FILENAME);
+
+			if (frag_url && frag_name) {
+				seg_state->filename = dasher_strip_base(ctx, ds, frag_url->value.string, frag_name->value.string);
+			} else if (frag_range) {
 				seg_state->file_offset = frag_range->value.lfrac.num;
 				seg_state->file_size = (u32) (frag_range->value.lfrac.den - seg_state->file_offset);
 
@@ -7018,7 +7288,6 @@
 						seg_state->file_size -= (u32) sidx_size;
 					}
 				}
-
 			} else {
 				gf_list_del_item(ds->rep->state_seg_list, seg_state);
 				gf_free(seg_state);
@@ -7052,7 +7321,14 @@
 		if (ctx->gencues) return;
 
 		if (ctx->sigfrag) {
-			const GF_PropertyValue *p = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_SIDX_RANGE);
+			Bool has_root_sidx = GF_TRUE;
+			const GF_PropertyValue *p = gf_filter_pid_get_property(ds->ipid, GF_PROP_PCK_SIDX_RANGE);
+			if (!p) {
+				p = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_SIDX_RANGE);
+				has_root_sidx = GF_FALSE;
+			}
+
+
 			if (p) {
 				if (ds->rep->segment_base && !ds->rep->segment_base->index_range) {
 					GF_SAFEALLOC(ds->rep->segment_base->index_range, GF_MPD_ByteRange);
@@ -7072,7 +7348,7 @@
 							ds->rep->segment_base->initialization_segment->byte_range->end_range = p->value.lfrac.num-1;
 						}
 					}
-				} else {
+				} else if (!has_root_sidx) {
 					ctx->in_error = GF_TRUE;
 					GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Dasher Several SIDX found but trying to regenerate an on-demand MPD, source file is not compatible. Try re-dashing the content or use main or full profiles\n"));
 				}
@@ -7097,14 +7373,16 @@
 		if (ctx->sigfrag) {
 			const GF_PropertyValue *frag_range = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_FRAG_RANGE);
 			const GF_PropertyValue *frag_url = gf_filter_pck_get_property(in_pck, GF_PROP_PID_URL);
-			if (frag_url && frag_url->value.string) {
-				seg_url->media = gf_strdup(dasher_strip_base(ctx, frag_url->value.string));
+			const GF_PropertyValue *frag_name = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_FILENAME);
+			if (frag_url && frag_name) {
+				seg_url->media = dasher_strip_base(ctx, ds, frag_url->value.string, frag_name->value.string);
 				if (ds->rep->segment_list && ds->rep->segment_list->initialization_segment && !ds->rep->segment_list->initialization_segment->sourceURL) {
 
 					frag_url = gf_filter_pid_get_property(ds->ipid, GF_PROP_PID_URL);
-					if (frag_url && frag_url->value.string) {
+					frag_name = gf_filter_pid_get_property_str(ds->ipid, "init_url");
+					if (frag_url && frag_name) {
 						u32 j, nb_base;
-						ds->rep->segment_list->initialization_segment->sourceURL = gf_strdup(dasher_strip_base(ctx, frag_url->value.string) );
+						ds->rep->segment_list->initialization_segment->sourceURL = dasher_strip_base(ctx, ds, frag_url->value.string, frag_name->value.string);
 
 						nb_base = gf_list_count(ds->rep->base_URLs);
 						for (j=0; j<nb_base; j++) {
@@ -7186,7 +7464,7 @@
 		}
 	}
 
-	if (seg_state) {
+	if (seg_state && !ctx->sigfrag) {
 		seg_state->filepath = gf_strdup(szSegmentFullPath);
 		seg_state->filename = gf_strdup(szSegmentName);
 	}
@@ -7414,9 +7692,13 @@
 			if (max_ts<mpdtime)
 				max_ts = mpdtime;
 		}
-		if (pc > (s32) total_pc) total_pc = (u32) pc;
+		//don't use max, do an average
+		total_pc += pc;
 		gf_dynstrcat(&szStatus, szDS, " ");
 	}
+	if (count)
+		total_pc /= count;
+
 	if (total_pc!=10000) {
 		sprintf(szDS, " / MPD %.2fs %d %%", max_ts, total_pc/100);
 		gf_dynstrcat(&szStatus, szDS, NULL);
@@ -7571,9 +7853,29 @@
 		return GF_EOS;
 	if (ctx->setup_failure) return ctx->setup_failure;
 
+	count = gf_list_count(ctx->current_period->streams);
+	if (!ctx->min_cts_period.den) {
+		u64 min_ts=0, min_timescale = 0;
+		for (i=0; i<count; i++) {
+			GF_DashStream *ds = gf_list_get(ctx->current_period->streams, i);
+			GF_FilterPacket *pck = gf_filter_pid_get_packet(ds->ipid);
+			if (!pck) return GF_OK;
+			u64 ts = gf_filter_pck_get_cts(pck);
+			//only adjust if delay is negative (skip), otherwise (delay) keep mints as is.
+			//Not doing so will set the rep PTO to the delay, canceling the delay ...
+			if (ds->pts_minus_cts<0)
+				ts = ts + ds->pts_minus_cts;
+			if (!min_ts || gf_timestamp_less(ts, ds->timescale, min_ts, min_timescale)) {
+				min_ts = ts;
+				min_timescale = ds->timescale;
+			}
+		}
+		ctx->min_cts_period.num = min_ts;
+		ctx->min_cts_period.den = min_timescale;
+	}
+
 	nb_init = has_init = nb_reg_done = 0;
 
-	count = gf_list_count(ctx->current_period->streams);
 	for (i=0; i<count; i++) {
 		GF_DashStream *base_ds;
 		GF_DashStream *ds = gf_list_get(ctx->current_period->streams, i);
@@ -7617,13 +7919,18 @@
 					is_queue_flush = GF_TRUE;
 				}
 
-				//text streams, insert an empty segment if we are one segment behind last produced segment on other pids
-				//we don't generate if behing this last time in case a packet comes in
-				//
-				//TODO: extend this to send empty segments for other streams (audio, video) in case of signal loss ??
+				/*text streams, insert an empty segment if we are one segment behind last produced segment on other pids
+				- we don't generate if behind this last time in case a next packet comes in
+				- we only insert an empty segment if PID is done (eos) or if we generate for real-time
+
+				We cannot apply this in non real-time before end of stream, as we would end up starting a segment while next packet could be in the past (previous seg)
+
+				TODO: extend this to send empty segments for other streams (audio, video) in case of signal loss ??
+				*/
 				if (!pck
 					&& (ds->stream_type==GF_STREAM_TEXT)
 					&& !ds->muxed_base
+					&& (gf_filter_pid_is_eos(ds->ipid) || (ctx->dmode==GF_MPD_TYPE_DYNAMIC))
 				) {
 					u64 ddur_ms = (1000*ds->dash_dur.num)/ds->dash_dur.den;
 					while (ds->last_min_segment_start_time + ddur_ms < ctx->last_min_segment_start_time) {
@@ -7791,6 +8098,9 @@
 			dts = gf_filter_pck_get_dts(pck);
 			if (dts==GF_FILTER_NO_TS) dts = cts;
 
+			if ((ctx->strict_sap==DASHER_SAP_INTRA_ONLY) && (sap_type>=4))
+				sap_type = 0;
+
 			pcont_cts = cts;
 
 			if (!ds->rep_init) {
@@ -7853,6 +8163,11 @@
 						if (ds->timescale != ds->mpd_timescale) {
 							pto_adj = gf_timestamp_rescale(pto_adj, ds->timescale, ds->mpd_timescale);
 						}
+						if (ctx->min_cts_period.den) {
+							u64 diff = gf_timestamp_rescale(ctx->min_cts_period.num, ctx->min_cts_period.den, ds->mpd_timescale);
+							pto_adj = diff;
+						}
+
 						if (ds->rep->segment_list)
 							ds->rep->segment_list->presentation_time_offset = pto_adj;
 						else if (ds->rep->segment_template)
@@ -7861,8 +8176,10 @@
 							ds->set->segment_template->presentation_time_offset = pto_adj;
 						else if (ds->set->segment_list)
 							ds->set->segment_list->presentation_time_offset = pto_adj;
-						else if (ds->rep->segment_base)
+						else if (ds->rep->segment_base) {
 							ds->rep->segment_base->presentation_time_offset = pto_adj;
+							ds->rep->segment_base->timescale = ds->mpd_timescale;
+						}
 
 						ds->presentation_time_offset = pto;
 					}
@@ -8248,11 +8565,13 @@
 			//- we have an asto set (low latency)
 			//- this is not an audio stream or all samples are SAPs
 			//- we use cues
+			//- we use strict_sap=intra mode
 			else if (seg_over && ds->nb_samples_in_source && !ctx->loop
 				&& (ds->nb_pck+1 == ds->nb_samples_in_source)
 				&& !ds->inband_cues && !ds->cues
 				&& !ctx->asto
 				&& ! ((ds->sync_points_type==DASHER_SYNC_NONE) && (ds->stream_type!=GF_STREAM_AUDIO))
+				&& (ctx->strict_sap!=DASHER_SAP_INTRA_ONLY)
 			) {
 				seg_over = GF_FALSE;
 			}
@@ -8427,6 +8746,10 @@
 				ds->current_seg_state->encrypted = GF_TRUE;
 			//TODO check drift between MPD start time and min CTS in segment (not just first CTS in segment)
 
+			if (ctx->gxns && !ds->rep->first_tfdt_plus_one && !ds->muxed_base) {
+				ds->rep->first_tfdt_plus_one = 1 + gf_filter_pck_get_dts(dst);
+				ds->rep->first_tfdt_timescale = ds->timescale;
+			}
 			//send packet
 			gf_filter_pck_send(dst);
 
@@ -9089,6 +9412,10 @@
 	if ((ctx->tsb>=0) && (ctx->dmode!=GF_DASH_STATIC))
 		ctx->purge_segments = GF_TRUE;
 
+	if (ctx->llhls && !ctx->cmaf && !gf_sys_is_test_mode()) {
+		//cmaf is required for ll hls (at least tfdt per traf is)
+		ctx->cmaf = DASHER_CMAF_CMFC;
+	}
 	if (ctx->state && ctx->sreg) {
 		u32 diff;
 		u64 next_gen_ntp;
@@ -9113,7 +9440,9 @@
 		GF_DashStream *ds = gf_list_pop_back(ctx->pids);
 		dasher_reset_stream(filter, ds, GF_TRUE);
 		if (ds->packet_queue) gf_list_del(ds->packet_queue);
+#ifndef GPAC_DISABLE_CRYPTO
 		if (ds->cinfo) gf_crypt_info_del(ds->cinfo);
+#endif
 		gf_free(ds);
 	}
 	gf_list_del(ctx->pids);
@@ -9133,7 +9462,9 @@
 	gf_free(ctx->next_period);
 	if (ctx->out_path) gf_free(ctx->out_path);
 	gf_list_del(ctx->postponed_pids);
+#ifndef GPAC_DISABLE_CRYPTO
 	if (ctx->cinfo) gf_crypt_info_del(ctx->cinfo);
+#endif
 }
 
 #define MPD_EXTS "mpd|m3u8|3gm|ism"
@@ -9185,7 +9516,7 @@
 #define OFFS(_n)	#_n, offsetof(GF_DasherCtx, _n)
 static const GF_FilterArgs DasherArgs =
 {
-	{ OFFS(segdur), "target segment duration in seconds. A value less than or equal to 0 means to 1.0 second", GF_PROP_FRACTION, "0/0", NULL, 0},
+	{ OFFS(segdur), "target segment duration in seconds. A value less than or equal to 0 defaults to 1.0 second", GF_PROP_FRACTION, "0/0", NULL, 0},
 	{ OFFS(tpl), "use template mode (multiple segment, template URLs)", GF_PROP_BOOL, "true", NULL, 0},
 	{ OFFS(stl), "use segment timeline (ignored in on_demand mode)", GF_PROP_BOOL, "false", NULL, 0},
 	{ OFFS(dmode), "dash content mode\n"
@@ -9208,9 +9539,10 @@
 	"- off: disables BS switching\n"
 	"- on: enables it if same decoder configuration is possible\n"
 	"- inband: moves decoder config inband if possible\n"
+	"- both: inband and outband parameter sets\n"
 	"- pps: moves PPS and APS inband, keep VPS,SPS and DCI out of band (used for VVC RPR)\n"
 	"- force: enables it even if only one representation\n"
-	"- multi: uses multiple stsd entries in ISOBMFF", GF_PROP_UINT, "def", "def|off|on|inband|pps|force|multi", GF_FS_ARG_HINT_ADVANCED},
+	"- multi: uses multiple stsd entries in ISOBMFF", GF_PROP_UINT, "def", "def|off|on|inband|pps|both|force|multi", GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(template), "template string to use to generate segment name", GF_PROP_STRING, NULL, NULL, 0},
 	{ OFFS(segext), "file extension to use for segments", GF_PROP_STRING, NULL, NULL, 0},
 	{ OFFS(initext), "file extension to use for the init segment", GF_PROP_STRING, NULL, NULL, 0},
@@ -9243,7 +9575,7 @@
 	"", GF_PROP_UINT, "set", "set|rep|both", GF_FS_ARG_HINT_ADVANCED },
 	{ OFFS(pssh), "storage mode for PSSH box\n"
 	"- f: stores in movie fragment only\n"
-	"- v: stores in movie only\n"
+	"- v: stores in movie only, or movie and fragments if key roll is detected\n"
 	"- m: stores in mpd only\n"
 	"- mf: stores in mpd and movie fragment\n"
 	"- mv: stores in mpd and movie\n"
@@ -9273,7 +9605,9 @@
 	{ OFFS(strict_sap), "strict mode for sap\n"
 	"- off: ignore SAP types for PID other than video, enforcing _startsWithSAP=1_\n"
 	"- sig: same as -off() but keep _startsWithSAP_ to the true SAP value\n"
-	"- on: warn if any PID uses SAP 3 or 4 and switch to FULL profile", GF_PROP_UINT, "off", "off|sig|on", GF_FS_ARG_HINT_EXPERT},
+	"- on: warn if any PID uses SAP 3 or 4 and switch to FULL profile\n"
+	"- intra: ignore SAP types greater than 3 on all media types"
+	, GF_PROP_UINT, "off", "off|sig|on|intra", GF_FS_ARG_HINT_EXPERT},
 
 	{ OFFS(subs_sidx), "number of subsegments per sidx. negative value disables sidx. Only used to inherit sidx option of destination", GF_PROP_SINT, "-1", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(cmpd), "skip line feed and spaces in MPD XML for compactness", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
@@ -9310,6 +9644,17 @@
 	{ OFFS(hlsx), "list of string to append to master HLS header before variants with `'#foo','#bar=val'` added as `#foo \\n #bar=val`", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(ll_preload_hint), "inject preload hint for LL-HLS", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(ll_rend_rep), "inject rendition reports for LL-HLS", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(ll_part_hb), "user-defined part hold-back for LLHLS, negative value means 3 times max part duration in session", GF_PROP_DOUBLE, "-1", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(ckurl), "set the ClearKey URL common to all encrypted streams (overriden by `CKUrl` pid property)", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
+
+	{ OFFS(hls_absu), "use absolute url in HLS generation using first URL in base()\n"
+	"- no: do not use absolute URL\n"
+	"- var: use absolute URL only in variant playlists\n"
+	"- mas: use absolute URL only in master playlist\n"
+	"- both: use absolute URL everywhere"
+		, GF_PROP_UINT, "no", "no|var|mas|both", GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(seg_sync), "force waiting for last packet of fragment/segment to be written before announcing segment in DASH/HLS playlist", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+
 	{ OFFS(cmaf), "use cmaf guidelines\n"
 		"- no: CMAF not enforced\n"
 		"- cmfc: use CMAF `cmfc` guidelines\n"
@@ -9319,6 +9664,15 @@
 	{ OFFS(chain), "URL of next MPD for regular chaining", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(chain_fbk), "URL of fallback MPD", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(gencues), "only insert segment boundaries and do not generate manifests", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(force_init), "force init segment creation in bitstream switching mode", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(keep_src), "keep source URLs in manifest generation mode", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(gxns), "insert some gpac extensions in manifest (for now, only tfdt of first segment)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(dkid), "control injection of default KID in MPD\n"
+		"- off: default KID not injected\n"
+		"- on: default KID always injected\n"
+		"- auto: default KID only injected if no key roll is detected (as per DASH-IF guidelines)"
+		, GF_PROP_UINT, "auto", "off|on|auto", GF_FS_ARG_HINT_EXPERT},
+
 	{0}
 };
 
@@ -9425,6 +9779,10 @@
 "- completely ignore SAP when segmenting using -sap().\n"
 "- ignore SAP on non-video streams when segmenting using -strict_sap().\n"
 "\n"
+"The segmenter will by default announce a new segment in the manifest(s) as soon as its size/offset is known or its name is known, but the segment (or part in LL-HLS) may still not be completely written/sent.\n"
+"This may result in temporary mismatches between segment/part size currently received versus size as advertized in manifest.\n"
+"If the target destination cannot support this, use -seg_sync() to update manifest(s) only once segments/parts are completely flushed; this will however slightly increase the latency of manifest updates.\n"
+"\n"
 "## Dynamic (real-time live) Mode\n"
 "The dasher does not perform real-time regulation by default.\n"
 "For regular segmentation, you should enable segment regulation -sreg() if your sources are not real-time.\n"
@@ -9434,6 +9792,9 @@
 "- cdur: set the fMP4 fragment duration\n"
 "- asto: set the availability time offset for DASH. This value should be equal or slightly greater than segment duration minus cdur\n"
 "- llhls: enable low latency for HLS\n"
+"\n"
+"Note: -llhls() will force CMAF to `cmfc` if -cmaf() is not set.\n"
+"\n"
 "If your sources are not real-time, insert a reframer filter with real-time regulation\n"
 "EX gpac -i source.mp4 reframer:rt=on -o live.mpd:segdur=2:cdur=0.2:asto=1.8:profile=live:dmode=dynamic\n"
 "This will create DASH segments of 2 seconds made of fragments of 200 ms and indicate to the client that requests can be made 1.8 seconds earlier than segment complete availability on server.\n"
@@ -9533,13 +9894,14 @@
 " - noinit: disables output of init segment for the multiplexer (used to handle bitstream switching with single init in DASH)\n"
 " - frag: indicates multiplexer shall use fragmented format (used for ISOBMFF mostly)\n"
 " - subs_sidx=0: indicates an SIDX shall be generated - only added if not already specified by user\n"
-" - xps_inband=all|no: indicates AVC/HEVC/... parameter sets shall be sent inband or out of band\n"
+" - xps_inband=all|no|both: indicates AVC/HEVC/... parameter sets shall be sent inband, out of band, or both\n"
 " - nofragdef: indicates fragment defaults should be set in each segment rather than in init segment\n"
 "\n"
 "The segmenter adds the following properties to the output PIDs:\n"
 "- DashMode: identifies VoD (single file with global index) or regular DASH mode used by segmenter\n"
 "- DashDur: identifies target DASH segment duration - this can be used to estimate the SIDX size for example\n"
 "- LLHLS: identifies LLHLS is used; the multiplexer must send fragment size events back to the dasher, and set `LLHLSFragNum` on the first packet of each fragment\n"
+"- SegSync: indicates that fragments/segments must be completely flushed before sending back size events\n"
 			)
 	.private_size = sizeof(GF_DasherCtx),
 	.args = DasherArgs,
@@ -9557,5 +9919,9 @@
 {
 	return &DasherRegister;
 }
-
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
+#else
+const GF_FilterRegister *dasher_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+#endif /*#if !defined(GPAC_DISABLE_MPD)*/

gpac-2.0.0.tar.gz/src/filters/dec_bifs.c -> gpac-2.2.0.tar.gz/src/filters/dec_bifs.c Changed

@@ -140,7 +140,6 @@
 	GF_Err e;
 	Double ts_offset;
 	u64 now, cts;
-	u32 obj_time;
 	u32 i, count;
 	const char *data;
 	u32 size, ESID=0;
@@ -189,24 +188,18 @@
 		if (prop) ESID = prop->value.uint;
 
 		cts = gf_filter_pck_get_cts( pck );
-		ts_offset = (Double) cts;
-		ts_offset /= gf_filter_pck_get_timescale(pck);
-
-		gf_odm_check_buffering(odm, pid);
-
+		cts = gf_timestamp_to_clocktime(cts, gf_filter_pck_get_timescale(pck) );
 
-		//we still process any frame before our clock time even when buffering
-		obj_time = gf_clock_time(odm->ck);
-		if (ts_offset * 1000 > obj_time) {
-			gf_sc_sys_frame_pending(scene->compositor, ts_offset, obj_time, filter);
+		if (!gf_sc_check_sys_frame(scene, odm, pid, filter, cts, 0))
 			continue;
-		}
 
+		ts_offset = (Double) cts;
+		ts_offset /= 1000.0;
 		now = gf_sys_clock_high_res();
 		e = gf_bifs_decode_au(ctx->bifs_dec, ESID, data, size, ts_offset);
 		now = gf_sys_clock_high_res() - now;
 
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("BIFS ODM%d #CH%d at %d decoded AU TS %u in "LLU" us\n", odm->ID, ESID, obj_time, cts, now));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("BIFS ODM%d #CH%d decoded AU TS %u in "LLU" us\n", odm->ID, ESID, cts, now));
 
 		gf_filter_pid_drop_packet(pid);

gpac-2.0.0.tar.gz/src/filters/dec_j2k.c -> gpac-2.2.0.tar.gz/src/filters/dec_j2k.c Changed

gpac-2.0.0.tar.gz/src/filters/dec_laser.c -> gpac-2.2.0.tar.gz/src/filters/dec_laser.c Changed

@@ -35,7 +35,6 @@
 {
 	GF_Scene *scene;
 	GF_ObjectManager *odm;
-//	GF_Terminal *app;
 	GF_LASeRCodec *codec;
 	u32 PL, nb_streams;
 	Bool is_playing;
@@ -154,9 +153,7 @@
 	GF_FilterPacket *pck;
 	const char *data;
 	u32 size, ESID=0;
-	Double ts_offset;
 	u64 now, cts;
-	u32 obj_time;
 	u32 i, count;
 	const GF_PropertyValue *prop;
 	GF_LSRDecCtx *ctx = gf_filter_get_udta(filter);
@@ -202,24 +199,16 @@
 		if (prop) ESID = prop->value.uint;
 
 		cts = gf_filter_pck_get_cts( pck );
-		ts_offset = (Double) cts;
-		ts_offset /= gf_filter_pck_get_timescale(pck);
+		cts = gf_timestamp_to_clocktime(cts, gf_filter_pck_get_timescale(pck));
 
-		gf_odm_check_buffering(odm, pid);
-
-
-		//we still process any frame before our clock time even when buffering
-		obj_time = gf_clock_time(odm->ck);
-		if (ts_offset * 1000 > obj_time) {
-			gf_sc_sys_frame_pending(ctx->scene->compositor, ts_offset, obj_time, filter);
+		if (!gf_sc_check_sys_frame(scene, odm, pid, filter, cts, 0))
 			continue;
-		}
 
 		now = gf_sys_clock_high_res();
 		e = gf_laser_decode_au(ctx->codec, ESID, data, size);
 		now = gf_sys_clock_high_res() - now;
 
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("BIFS ODM%d #CH%d at %d decoded AU TS %u in "LLU" us\n", odm->ID, ESID, obj_time, cts, now));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("BIFS ODM%d #CH%d at %d decoded AU TS %u in "LLU" us\n", odm->ID, ESID, cts, now));
 
 		gf_filter_pid_drop_packet(pid);

gpac-2.0.0.tar.gz/src/filters/dec_mad.c -> gpac-2.2.0.tar.gz/src/filters/dec_mad.c Changed

gpac-2.0.0.tar.gz/src/filters/dec_mediacodec.c -> gpac-2.2.0.tar.gz/src/filters/dec_mediacodec.c Changed

gpac-2.0.0.tar.gz/src/filters/dec_mediacodec.h -> gpac-2.2.0.tar.gz/src/filters/dec_mediacodec.h Changed

gpac-2.0.0.tar.gz/src/filters/dec_mediacodec_jni.c -> gpac-2.2.0.tar.gz/src/filters/dec_mediacodec_jni.c Changed

@@ -34,7 +34,7 @@
 #include <jni.h>
 
 #include "dec_mediacodec.h"
-#define RANDOM_JAVA_APP_CLASS "com/gpac/Osmo4/GPACInstance"
+
 #define ALL_CODECS 1
 
 static jclass cSurfaceTexture = NULL;
@@ -92,6 +92,8 @@
 	return ret;
 }
 
+#ifndef GPAC_STATIC_MODULES
+
 jint JNI_OnLoad(JavaVM* vm, void* reserved)
 {
 	JNIEnv* env = NULL;
@@ -116,6 +118,15 @@
 	return javaVM;
 }
 
+#else
+
+//if static modules, these are defined in main wrapper
+JavaVM* GetJavaVM();
+JNIEnv* GetEnv();
+
+#endif
+
+
 u32 mcdec_exit_callback(void * param) {
 
 	GF_LOG(GF_LOG_INFO, GF_LOG_CODEC, ("MCDec Detach decoder thread\n"));
@@ -123,7 +134,7 @@
 	return GF_OK;
 }
 
-GF_Err mcdec_create_surface (GLuint tex_id, ANativeWindow ** window, Bool * surface_rendering, GF_MCDecSurfaceTexture * surfaceTex)
+GF_Err mcdec_create_surface(GLuint tex_id, ANativeWindow ** window, Bool * surface_rendering, GF_MCDecSurfaceTexture * surfaceTex)
 {
 	JNIEnv* env = NULL;
 	jobject otmp= NULL;
@@ -320,6 +331,7 @@
 {
 	JNIEnv* env = NULL;
 	jint res = 0;
+	//we must check this, as the calling thread is not always the decoder thread
 	res = (*GetJavaVM())->GetEnv(GetJavaVM(), (void**)&env, JNI_VERSION_1_2);
 	if ( res == JNI_EDETACHED ) {
 		(*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
@@ -344,6 +356,7 @@
 	jfloat *body;
 	GF_Err ret = GF_BAD_PARAM;
 	
+	//we must check this, as the calling thread is not always the decoder thread
 	res = (*GetJavaVM())->GetEnv(GetJavaVM(), (void**)&env, JNI_VERSION_1_2);
 	if ( res == JNI_EDETACHED ) {
 		(*GetJavaVM())->AttachCurrentThread(GetJavaVM(), &env, NULL);
@@ -402,7 +415,11 @@
 	cMediaFormat = NULL;
 	(*env)->DeleteGlobalRef(env, surfaceTex.oSurfaceTex);
 	surfaceTex.oSurfaceTex = NULL;
-	
+
+	if ( res == JNI_EDETACHED ) {
+		(*GetJavaVM())->DetachCurrentThread(GetJavaVM() );
+	}
+
 	return GF_OK;
 }

gpac-2.0.0.tar.gz/src/filters/dec_nvdec.c -> gpac-2.2.0.tar.gz/src/filters/dec_nvdec.c Changed

@@ -28,6 +28,10 @@
 #include <gpac/constants.h>
 #include <gpac/filters.h>
 
+#if defined(GPAC_CONFIG_DARWIN) && defined(__arm64__)
+#define GPAC_DISABLE_NVDEC
+#endif
+
 #if (!defined(GPAC_STATIC_BUILD) && (defined(WIN32) || defined(GPAC_CONFIG_LINUX) || defined(GPAC_CONFIG_DARWIN)) && !defined(GPAC_DISABLE_NVDEC))
 
 #include "dec_nvdec_sdk.h"
@@ -1404,8 +1408,7 @@
 	nvdec_merge_pck_props(ctx, f, dst_pck);
 	if (gf_filter_pck_get_seek_flag(dst_pck)) {
 		gf_filter_pck_discard(dst_pck);
-		memset(f, 0, sizeof(NVDecFrame));
-		gf_list_add(ctx->frames_res, f);
+		//no need to add frame to frame res, done in pck_release
 	} else {
 		gf_filter_pck_send(dst_pck);
 	}
@@ -1428,7 +1431,6 @@
 		CUresult res;
 		int device_count;
 	 res = cuInit(0, __CUDA_API_VERSION);
-		nb_cuvid_inst++;
 		cuvid_load_state = 1;
 		if (res == CUDA_ERROR_SHARED_OBJECT_INIT_FAILED) {
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("NVDec cuda lib not found on system\n") );
@@ -1443,16 +1445,17 @@
 					GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("NVDec no device found\n" ) );
 				} else {
 					cuvid_load_state = 2;
+					nb_cuvid_inst++;
 				}
 			}
 		}
 #endif
-
 	} else {
 		nb_cuvid_inst++;
 	}
 }
 
+
 static GF_Err nvdec_initialize(GF_Filter *filter)
 {
 	NVDecCtx *ctx = gf_filter_get_udta(filter);
@@ -1488,15 +1491,6 @@
 		gf_free(ctx->dec_inst);
 	}
 
-
-	assert(nb_cuvid_inst);
-	nb_cuvid_inst--;
-	if (!nb_cuvid_inst) {
-		if (cuda_ctx) cuCtxDestroy(cuda_ctx);
-		cuda_ctx = NULL;
-		cuUninit();
-		cuvid_load_state = 0;
-	}
 	while (gf_list_count(ctx->frames)) {
 		NVDecFrame *f = (NVDecFrame *) gf_list_pop_back(ctx->frames);
 		gf_free(f);
@@ -1550,14 +1544,15 @@
 		"- single: frame data is only retrieved when used, single memory space for all frames (not safe if multiple consumers)\n"
 		"- gl: frame data is mapped to an OpenGL texture"
 	, GF_PROP_UINT, "gl", "copy|single|gl", 0 },
-
 	{ 0 }
 };
 
 GF_FilterRegister NVDecRegister = {
 	.name = "nvdec",
 	GF_FS_SET_DESCRIPTION("NVidia decoder")
-	GF_FS_SET_HELP("This filter decodes MPEG-2, MPEG-4 Part 2, AVC|H264 and HEVC streams through NVidia decoder. It allows GPU frame dispatch or direct frame copy.")
+	GF_FS_SET_HELP("This filter decodes MPEG-2, MPEG-4 Part 2, AVC|H264 and HEVC streams through NVidia decoder. It allows GPU frame dispatch or direct frame copy."
+	"\n"
+	"If the SDK is not available, the configuration key `nvdec@disabled` will be written in configuration file to avoid future load attempts.")
 	.private_size = sizeof(NVDecCtx),
 	SETCAPS(NVDecCaps),
 	.flags = GF_FS_REG_CONFIGURE_MAIN_THREAD,
@@ -1569,9 +1564,23 @@
 	.process_event = nvdec_process_event
 };
 
+static void nvdec_register_free(GF_FilterSession *session, GF_FilterRegister *freg)
+{
+	if (nb_cuvid_inst==1) {
+		if (cuda_ctx) cuCtxDestroy(cuda_ctx);
+		cuda_ctx = NULL;
+		cuUninit();
+		cuvid_load_state = 0;
+	}
+	nb_cuvid_inst--;
+}
 
 const GF_FilterRegister *nvdec_register(GF_FilterSession *session)
 {
+	//failed to load SDK in previous attempt, do not retry
+	if (!gf_opts_get_bool("temp", "gendoc") && gf_opts_get_key("filter@nvdec", "disabled"))
+		return NULL;
+
 	//check if nvdec is not globally blacklisted - if so, do not try to load CUDA SDK which may be time consuming on some devices
 	const char *blacklist = gf_opts_get_key("core", "blacklist");
 	if (blacklist && (blacklist0!='-') && strstr(blacklist, "nvdec"))
@@ -1581,11 +1590,13 @@
 	//do not register if no SDK
 	if (cuvid_load_state != 2) {
 		// this is man / md generation, load filter
-		if (!gf_opts_get_bool("temp", "gendoc"))
+		if (!gf_opts_get_bool("temp", "gendoc")) {
+			gf_opts_set_key("filter@nvdec", "disabled", "yes");
 			return NULL;
+		}
 		NVDecRegister.version = "! Warning: CUVID SDK NOT AVAILABLE ON THIS SYSTEM !";
 	}
-
+	NVDecRegister.register_free = nvdec_register_free;
 	return &NVDecRegister;
 }

gpac-2.0.0.tar.gz/src/filters/dec_odf.c -> gpac-2.2.0.tar.gz/src/filters/dec_odf.c Changed

@@ -218,7 +218,7 @@
 				odm->mo->type = GF_MEDIA_OBJECT_UNDEF;
 				gf_list_add(scene->scene_objects, odm->mo);
 
-				gf_clock_set_time(odm->ck, 0);
+				gf_clock_set_time(odm->ck, 0, 1000);
 			}
 #endif
 			return;
@@ -336,9 +336,7 @@
 	GF_Err e;
 	GF_ODCom *com;
 	GF_ODCodec *oddec;
-	Double ts_offset;
 	u64 cts, now;
-	u32 obj_time;
 	u32 count, i;
 	const char *data;
 	u32 size, ESID=0;
@@ -379,18 +377,10 @@
 		if (prop) ESID = prop->value.uint;
 
 		cts = gf_filter_pck_get_cts( pck );
-		ts_offset = (Double) cts;
-		ts_offset /= gf_filter_pck_get_timescale(pck);
+		cts = gf_timestamp_to_clocktime(cts, gf_filter_pck_get_timescale(pck));
 
-		gf_odm_check_buffering(odm, pid);
-
-
-		//we still process any frame before our clock time even when buffering
-		obj_time = gf_clock_time(odm->ck);
-		if (ts_offset * 1000 > obj_time) {
-			gf_sc_sys_frame_pending(scene->compositor, ts_offset, obj_time, filter);
+		if (!gf_sc_check_sys_frame(scene, odm, pid, filter, cts, 0))
 			continue;
-		}
 
 		now = gf_sys_clock_high_res();
 		oddec = gf_odf_codec_new();
@@ -456,7 +446,7 @@
 		gf_odf_codec_del(oddec);
 
 		now = gf_sys_clock_high_res() - now;
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("ODF ODM%d #CH%d at %d decoded AU TS %u in "LLU" us\n", odm->ID, ESID, obj_time, cts, now));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("ODF ODM%d #CH%d decoded AU TS %u in "LLU" us\n", odm->ID, ESID, cts, now));
 	}
 
 	return GF_OK;

gpac-2.0.0.tar.gz/src/filters/dec_openhevc.c -> gpac-2.2.0.tar.gz/src/filters/dec_openhevc.c Changed

gpac-2.0.0.tar.gz/src/filters/dec_ttml.c -> gpac-2.2.0.tar.gz/src/filters/dec_ttml.c Changed

@@ -41,7 +41,7 @@
 	//opts
 	char *script;
 	char *color, *font;
-	Float fontSize, lineSpacing, txtx, txty;
+	Float fontSize, lineSpacing;
 	u32 txtw, txth, valign;
 
 	GF_FilterPid *ipid, *opid;
@@ -63,7 +63,11 @@
 
 	GF_BitStream *subs_bs;
 	s32 notify_clock;
+	s32 txtx, txty;
+	u32 fsize, vp_w, vp_h;
 
+	s64 delay;
+	u32 timescale;
 } GF_TTMLDec;
 
 void ttmldec_update_size_info(GF_TTMLDec *ctx)
@@ -84,6 +88,10 @@
 		p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_HEIGHT);
 		if (p) h = p->value.uint;
 
+		if (ctx->scene->compositor->osize.x && ctx->scene->compositor->osize.y) {
+			w = ctx->scene->compositor->osize.x;
+			h = ctx->scene->compositor->osize.y;
+		}
 		if (!w) w = ctx->txtw;
 		if (!h) h = ctx->txth;
 
@@ -92,6 +100,8 @@
 	}
 
 	gf_sg_set_scene_size_info(ctx->scenegraph, w, h, GF_TRUE);
+	ctx->vp_w = w;
+	ctx->vp_h = h;
 
 	sprintf(szVB, "0 0 %d %d", w, h);
 	gf_node_get_attribute_by_tag(root, TAG_SVG_ATT_viewBox, GF_TRUE, GF_FALSE, &info);
@@ -148,6 +158,7 @@
 
 static GF_Err ttmldec_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
 {
+	const GF_PropertyValue *p;
 	GF_TTMLDec *ctx = (GF_TTMLDec *)gf_filter_get_udta(filter);
 
 	if (is_remove) {
@@ -172,6 +183,11 @@
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
 
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
+	ctx->delay = p ? p->value.longsint : 0;
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+	ctx->timescale = p ? p->value.uint : 1000;
+
 	return GF_OK;
 }
 
@@ -246,10 +262,33 @@
 	JSContext *svg_script_get_context(GF_SceneGraph *sg);
 	JSContext *c = svg_script_get_context(sg);
 
+	if ((ctx->txtx != ctx->scene->compositor->subtx)
+		|| (ctx->txty != ctx->scene->compositor->subty)
+		|| (ctx->fsize != ctx->scene->compositor->subfs)
+	) {
+		ctx->txtx = ctx->scene->compositor->subtx;
+		ctx->txty = ctx->scene->compositor->subty;
+		ctx->fsize = ctx->scene->compositor->subfs;
+		ctx->update_args = GF_TRUE;
+	}
+
+
 	if (ctx->update_args) {
 		JSValue global = JS_GetGlobalObject(c);
 
-		JS_SetPropertyStr(c, global, "fontSize", JS_NewFloat64(c, ctx->fontSize));
+		u32 fs = (u32) MAX(ctx->fsize, ctx->fontSize);
+		u32 def_font_size = ctx->scene->compositor->subfs;
+		if (!def_font_size) {
+			if (ctx->vp_h > 2000) def_font_size = 80;
+			else if (ctx->vp_h > 700) def_font_size = 40;
+			else def_font_size = 20;
+		}
+
+		if (!fs || (def_font_size>fs)) {
+			fs = def_font_size;
+		}
+
+		JS_SetPropertyStr(c, global, "fontSize", JS_NewFloat64(c, fs));
 		JS_SetPropertyStr(c, global, "fontFamily", JS_NewString(c, ctx->font));
 		JS_SetPropertyStr(c, global, "textColor", JS_NewString(c, ctx->color));
 		JS_SetPropertyStr(c, global, "lineSpaceFactor", JS_NewFloat64(c, ctx->lineSpacing));
@@ -273,7 +312,7 @@
 	const u8 *pck_data;
 	char *pck_alloc=NULL, *ttml_doc;
 	u64 cts;
-	u32 timescale, obj_time;
+	u32 obj_time, dur;
 	u32 pck_size;
 	JSValue fun_val;
 	JSValue global;
@@ -308,9 +347,18 @@
 		return GF_OK;
 
 	cts = gf_filter_pck_get_cts( pck );
-	timescale = gf_filter_pck_get_timescale(pck);
+	s64 delay = ctx->scene->compositor->subd;
+	if (delay)
+		delay = gf_timestamp_rescale_signed(delay, 1000, ctx->timescale);
+	delay += ctx->delay;
+
+	if (delay>=0) cts += delay;
+	else if (cts > (u64) -delay) cts -= -delay;
+	else cts = 0;
 
 	gf_odm_check_buffering(ctx->odm, ctx->ipid);
+	cts = gf_timestamp_to_clocktime(cts, ctx->timescale);
+	dur = (u32) gf_timestamp_rescale(gf_filter_pck_get_duration(pck), ctx->timescale, 1000);
 
 	//we still process any frame before our clock time even when buffering
 	obj_time = gf_clock_time(ctx->odm->ck);
@@ -321,7 +369,7 @@
 		fun_val = JS_GetPropertyStr(c, global, "on_ttml_clock");
 		if (JS_IsFunction(c, fun_val) ) {
 			JSValue ret, argv1;
-			argv0 = JS_NewInt64(c, obj_time);
+			argv0 = JS_NewInt64(c, gf_clock_time_absolute(ctx->odm->ck) );
 
 			ret = JS_Call(c, fun_val, global, 1, argv);
 			if (JS_IsException(ret)) {
@@ -344,10 +392,9 @@
 		if (e) return e;
 	}
 
-	if (gf_timestamp_greater(cts, timescale, obj_time, 1000)) {
-		gf_sc_sys_frame_pending(ctx->scene->compositor, ((Double) cts / timescale), obj_time, filter);
+	if (!gf_sc_check_sys_frame(ctx->scene, ctx->odm, ctx->ipid, filter, cts, dur))
 		return GF_OK;
-	}
+
 	pck_data = gf_filter_pck_get_data(pck, &pck_size);
 	subs = gf_filter_pck_get_property(pck, GF_PROP_PCK_SUBS);
 
@@ -406,7 +453,7 @@
 
 		argv1 = JS_NewInt64(c, obj_time);
 		scene_ck = gf_filter_pck_get_duration(pck);
-		scene_ck /= timescale;
+		scene_ck /= ctx->timescale;
 		argv2 = JS_NewFloat64(c, scene_ck);
 
 		ret = JS_Call(c, fun_val, global, 3, argv);
@@ -497,10 +544,8 @@
 	"- center: align text at center of text area\n"
 	"- top: align text at top of text area", GF_PROP_UINT, "bottom", "bottom|center|top", GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
 	{ OFFS(lineSpacing), "line spacing as scaling factor to font size", GF_PROP_FLOAT, "1.0", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
-	{ OFFS(txtx), "horizontal offset", GF_PROP_FLOAT, "5", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
-	{ OFFS(txty), "vertical offset", GF_PROP_FLOAT, "5", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
-	{ OFFS(txtw), "default width in standalone rendering", GF_PROP_UINT, "400", NULL, 0},
-	{ OFFS(txth), "default height in standalone rendering", GF_PROP_UINT, "200", NULL, 0},
+	{ OFFS(txtw), "default width in standalone rendering", GF_PROP_UINT, "400", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(txth), "default height in standalone rendering", GF_PROP_UINT, "200", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -518,7 +563,13 @@
 	GF_FS_SET_DESCRIPTION("TTML decoder")
 	GF_FS_SET_HELP("This filter decodes TTML streams into a SVG scene graph of the compositor filter.\n"
 		"The scene graph creation is done through JavaScript.\n"
-		"The filter options are used to override the JS global variables of the TTML renderer.")
+		"The filter options are used to override the JS global variables of the TTML renderer.\n"
+		"\n"
+		"In stand-alone rendering (no associated video), the filter will use:\n"
+		"- `Width` and `Height` properties of input pid if any\n"
+		"- otherwise, `osize` option of compositor if set\n"
+		"- otherwise, -txtw() and -txth()\n"
+		)
 	.private_size = sizeof(GF_TTMLDec),
 	.flags = GF_FS_REG_MAIN_THREAD,
 	.args = TTMLDecArgs,

gpac-2.0.0.tar.gz/src/filters/dec_ttxt.c -> gpac-2.2.0.tar.gz/src/filters/dec_ttxt.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / 3GPP/MPEG4 text renderer filter
@@ -83,7 +83,8 @@
 	u32 dsi_crc;
 	Bool is_tx3g;
 	Bool is_playing, graph_registered, is_eos;
-
+	u32 timescale;
+	s64 delay;
 
 	GF_TextConfig *cfg;
 	GF_BitStream *bs_r;
@@ -103,12 +104,19 @@
 	u32 scroll_type, scroll_mode;
 	Fixed scroll_time, scroll_delay;
 	Bool timer_active;
+
+	Bool simple_text;
+	u8 *static_text;
+	u32 txt_static_alloc;
+	u64 sample_end;
 } GF_TTXTDec;
 
 
 static void ttd_set_blink_fraction(GF_Node *node, GF_Route *route);
 static void ttd_set_scroll_fraction(GF_Node *node, GF_Route *route);
 static void ttd_reset_display(GF_TTXTDec *ctx);
+static void ttd_setup_scene(GF_TTXTDec *ctx);
+static void ttd_toggle_display(GF_TTXTDec *ctx);
 
 /*the WORST thing about 3GP in MPEG4 is positioning of the text track...*/
 static void ttd_update_size_info(GF_TTXTDec *ctx)
@@ -125,7 +133,30 @@
 		} else if (ctx->cfg->text_width && ctx->cfg->text_height) {
 			gf_sg_set_scene_size_info(ctx->scenegraph, ctx->cfg->text_width, ctx->cfg->text_height, GF_TRUE);
 		} else {
-			gf_sg_set_scene_size_info(ctx->scenegraph, ctx->txtw, ctx->txth, GF_TRUE);
+			w=0;
+			h=0;
+			const GF_PropertyValue *p;
+			p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_WIDTH);
+			if (p) w = p->value.uint;
+			p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_HEIGHT);
+			if (p) h = p->value.uint;
+
+			if (ctx->scene->compositor->osize.x
+				&& ctx->scene->compositor->osize.y
+				&& gf_filter_is_dynamic(ctx->scene->compositor->filter)
+			) {
+				w = ctx->scene->compositor->osize.x;
+				h = ctx->scene->compositor->osize.y;
+			}
+
+			if (ctx->scene->compositor->osize.x && ctx->scene->compositor->osize.y) {
+				w = ctx->scene->compositor->osize.x;
+				h = ctx->scene->compositor->osize.y;
+			}
+			if (!w) w = ctx->txtw;
+			if (!h) h = ctx->txth;
+
+			gf_sg_set_scene_size_info(ctx->scenegraph, w, h, GF_TRUE);
 		}
 		gf_sg_get_scene_size_info(ctx->scenegraph, &w, &h);
 		if (!w || !h) return;
@@ -159,6 +190,15 @@
 		/*otherwise override (mainly used for SRT & TTXT file direct loading*/
 		ctx->cfg->text_width = w;
 		ctx->cfg->text_height = h;
+
+		u32 i=0;
+		GF_TextSampleDescriptor *td;
+		while ((td = gf_list_enum(ctx->cfg->sample_descriptions, &i))) {
+			td->default_pos.left = 0;
+			td->default_pos.top = 0;
+			td->default_pos.right = w;
+			td->default_pos.bottom = h;
+		}
 	}
 
 	/*ok override video size with main scene size*/
@@ -229,40 +269,17 @@
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
 	if (p) codecid = p->value.uint;
 
-	dsi = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
-	if (!dsi) return GF_NOT_SUPPORTED;
-
 	if (st != GF_STREAM_TEXT) return GF_NOT_SUPPORTED;
 
-	dsi_crc = gf_crc_32(dsi->value.data.ptr, dsi->value.data.size);
-	if (dsi_crc == ctx->dsi_crc) return GF_OK;
-	ctx->dsi_crc = dsi_crc;
+	ctx->timescale = gf_filter_pid_get_timescale(pid);
 
-	if (ctx->cfg) gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
-	ctx->cfg = (GF_TextConfig *) gf_odf_desc_new(GF_ODF_TEXT_CFG_TAG);
-	if (codecid == GF_CODECID_TEXT_MPEG4) {
-		e = gf_odf_get_text_config(dsi->value.data.ptr, dsi->value.data.size, codecid, ctx->cfg);
-		if (e) {
-			gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
-			ctx->cfg = NULL;
-			return e;
-		}
-		ctx->is_tx3g = GF_FALSE;
-	} else if (codecid == GF_CODECID_TX3G) {
-		GF_TextSampleDescriptor * sd = gf_odf_tx3g_read(dsi->value.data.ptr, dsi->value.data.size);
-		if (!sd) {
-			gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
-			ctx->cfg = NULL;
-			return GF_NON_COMPLIANT_BITSTREAM;
-		}
-		if (!sd->default_style.text_color)
-			sd->default_style.text_color = 0xFFFFFFFF;
-
-		gf_list_add(ctx->cfg->sample_descriptions, sd);
-		ctx->is_tx3g = GF_TRUE;
+	ctx->simple_text = GF_FALSE;
+	switch (codecid) {
+	case GF_CODECID_SUBS_TEXT:
+	case GF_CODECID_SIMPLE_TEXT:
+		ctx->simple_text = GF_TRUE;
+		break;
 	}
-	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
-	if (p && !ctx->cfg->timescale) ctx->cfg->timescale = p->value.uint;
 
 	ctx->ipid = pid;
 	if (!ctx->opid) {
@@ -274,6 +291,68 @@
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
 
+	if (ctx->simple_text) {
+		if (!ctx->cfg) ctx->cfg = (GF_TextConfig *) gf_odf_desc_new(GF_ODF_TEXT_CFG_TAG);
+		if (!gf_list_count(ctx->cfg->sample_descriptions)) {
+			GF_TextSampleDescriptor *txtc;
+			GF_SAFEALLOC(txtc, GF_TextSampleDescriptor);
+			gf_list_add(ctx->cfg->sample_descriptions, txtc);
+			txtc->sample_index = 1;
+			//font will default to compositor settings
+			txtc->back_color = 0x00000000;	/*transparent*/
+			txtc->default_style.text_color = 0xFFFFFFFF;	/*white*/
+			txtc->default_style.style_flags = 0;
+			txtc->horiz_justif = 1; /*center of scene*/
+			txtc->vert_justif = (s8) -1;	/*bottom of scene*/
+		}
+	} else {
+		Bool needs_init = GF_TRUE;
+		//check dsi is ready
+		dsi = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+		if (!dsi) return GF_OK;
+
+		dsi_crc = gf_crc_32(dsi->value.data.ptr, dsi->value.data.size);
+		if (dsi_crc == ctx->dsi_crc) return GF_OK;
+		ctx->dsi_crc = dsi_crc;
+
+		if (ctx->cfg) {
+			needs_init = GF_FALSE;
+			gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
+		}
+		ctx->cfg = (GF_TextConfig *) gf_odf_desc_new(GF_ODF_TEXT_CFG_TAG);
+		if (codecid == GF_CODECID_TEXT_MPEG4) {
+			e = gf_odf_get_text_config(dsi->value.data.ptr, dsi->value.data.size, codecid, ctx->cfg);
+			if (e) {
+				gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
+				ctx->cfg = NULL;
+				return e;
+			}
+			ctx->is_tx3g = GF_FALSE;
+		} else if (codecid == GF_CODECID_TX3G) {
+			GF_TextSampleDescriptor * sd = gf_odf_tx3g_read(dsi->value.data.ptr, dsi->value.data.size);
+			if (!sd) {
+				gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
+				ctx->cfg = NULL;
+				return GF_NON_COMPLIANT_BITSTREAM;
+			}
+			if (!sd->default_style.text_color)
+				sd->default_style.text_color = 0xFFFFFFFF;
+
+			gf_list_add(ctx->cfg->sample_descriptions, sd);
+			ctx->is_tx3g = GF_TRUE;
+		}
+
+		if (needs_init && ctx->odm && ctx->scene) {
+			ttd_setup_scene(ctx);
+			ttd_toggle_display(ctx);
+		}
+	}
+
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+	if (p && !ctx->cfg->timescale) ctx->cfg->timescale = p->value.uint;
+
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
+	ctx->delay = p ? p->value.longsint : 0;
 	return GF_OK;
 }
 
@@ -519,13 +598,16 @@
 		color = tsd->default_style.text_color;
 		if (!color && !tsd->back_color)
 			color = 0xFFFFFFFF;
-		if (!fontSize) {
-			if (ctx->cfg->text_height > 2000)
-				fontSize = 80;
-			else if (ctx->cfg->text_height > 700)
-				fontSize = 40;
-			else
-				fontSize = 20;
+
+		u32 def_font_size = ctx->scene->compositor->subfs;
+		if (!def_font_size) {
+			if (ctx->cfg->text_height > 2000) def_font_size = 80;
+			else if (ctx->cfg->text_height > 700) def_font_size = 40;
+			else def_font_size = 20;
+		}
+
+		if (!fontSize || (def_font_size>fontSize)) {
+			fontSize = def_font_size;
 		}
 	} else {
 		fontName = ttd_find_font(tsd, tc->srec->fontID);
@@ -619,7 +701,8 @@
 	start_char = tc->start_char;
 	for (i=tc->start_char; i<tc->end_char; i++) {
 		Bool new_line = GF_FALSE;
-		if ((utf16_txti == '\n') || (utf16_txti == '\r') || (utf16_txti == 0x85) || (utf16_txti == 0x2028) || (utf16_txti == 0x2029))
+		if (utf16_txti == '\r') continue;
+		if ((utf16_txti == '\n') || (utf16_txti == 0x85) || (utf16_txti == 0x2028) || (utf16_txti == 0x2029))
 			new_line = GF_TRUE;
 
 		if (new_line || (i+1==tc->end_char) ) {
@@ -659,6 +742,8 @@
 				len = gf_utf8_wcstombs(szLine, 5000, (const unsigned short **) &sp);
 				if (len == GF_UTF8_FAIL) len = 0;
 				szLinelen = 0;
+				if (len && (szLinelen-1=='\r'))
+					szLinelen-1 = 0;
 
 				gf_sg_vrml_mf_append(&text->string, GF_SG_VRML_MFSTRING, (void **) &st);
 				st->buffer = gf_strdup(szLine);
@@ -812,6 +897,7 @@
 		br.right = ctx->cfg->text_width;
 		br.bottom = ctx->cfg->text_height;
 	}
+
 	thw = br.right - br.left;
 	thh = br.bottom - br.top;
 	if (!thw || !thh) {
@@ -859,11 +945,13 @@
 	offset = br.left - tw/2 + thw;
 	if (offset + thw < - tw/2) offset = - tw/2 + thw;
 	else if (offset - thw > tw/2) offset = tw/2 - thw;
+	offset += ctx->scene->compositor->subtx;
 	ctx->tr_box->translation.x = INT2FIX(offset);
 
 	offset = th/2 - br.top - thh;
 	if (offset + thh > th/2) offset = th/2 - thh;
 	else if (offset - thh < -th/2) offset = -th/2 + thh;
+	offset += ctx->scene->compositor->subty;
 	ctx->tr_box->translation.y = INT2FIX(offset);
 
 	gf_node_dirty_set((GF_Node *)ctx->tr_box, 0, GF_TRUE);
@@ -987,7 +1075,7 @@
 	}
 	gf_list_del(chunks);
 
-	if (form->groupsIndex.valsform->groupsIndex.count-1 != -1)
+	if (form->groupsIndex.count && (form->groupsIndex.valsform->groupsIndex.count-1 != -1))
 		ttd_add_line(form);
 
 	/*rewrite form groupIndex - group is fine (eg one child per group)*/
@@ -1201,16 +1289,34 @@
 		ctx->odm = NULL;
 		ctx->scene = NULL;
 	 } else {
-		 ttd_setup_scene(ctx);
-		 ttd_toggle_display(ctx);
+		if (ctx->cfg) {
+			ttd_setup_scene(ctx);
+			ttd_toggle_display(ctx);
+		}
 	 }
 	 return GF_TRUE;
 }
 
+static GF_Err ttd_render_simple_text(GF_TTXTDec *ctx, const char *pck_data, u32 pck_size, u32 sample_duration)
+{
+	GF_TextSample static_txts;
+	memset(&static_txts, 0, sizeof (GF_TextSample));
+	if (ctx->txt_static_alloc < pck_size+1) {
+		ctx->static_text = gf_realloc(ctx->static_text, pck_size+1);
+		if (ctx->static_text) ctx->txt_static_alloc = pck_size+1;
+		else return GF_OUT_OF_MEM;
+	}
+	memcpy(ctx->static_text, pck_data, pck_size);
+	ctx->static_textpck_size = 0;
+	static_txts.text = ctx->static_text;
+	static_txts.len = pck_size;
+	ttd_apply_sample(ctx, &static_txts, 1, GF_FALSE, sample_duration);
+	return GF_OK;
+}
 static GF_Err ttd_process(GF_Filter *filter)
 {
 	const char *pck_data;
-	u32 pck_size, obj_time, timescale;
+	u32 pck_size;
 	u64 cts;
 	GF_FilterPacket *pck;
 	GF_TTXTDec *ctx = gf_filter_get_udta(filter);
@@ -1236,28 +1342,57 @@
 			}
 			return GF_EOS;
 		}
-		return GF_OK;
+		if (!ctx->sample_end)
+			return GF_OK;
 	}
 	ctx->is_eos = GF_FALSE;
 
 	//object clock shall be valid
 	assert(ctx->odm->ck);
-	cts = gf_filter_pck_get_cts( pck );
-	timescale = gf_filter_pck_get_timescale(pck);
-
-	gf_odm_check_buffering(ctx->odm, ctx->ipid);
-
-	//we still process any frame before our clock time even when buffering
-	obj_time = gf_clock_time(ctx->odm->ck);
-	if (gf_timestamp_greater(cts, timescale, obj_time, 1000)) {
-		Double ts_offset = (Double) cts;
-		ts_offset /= timescale;
-
-		gf_sc_sys_frame_pending(ctx->scene->compositor, ts_offset, obj_time, filter);
+	if (pck) {
+		s64 delay;
+		cts = gf_filter_pck_get_cts( pck );
+
+		delay = ctx->scene->compositor->subd;
+		if (delay)
+			delay = gf_timestamp_rescale_signed(delay, 1000, ctx->timescale);
+		delay += ctx->delay;
+
+		if (delay>=0) cts += delay;
+		else if (cts > (u64) -delay) cts -= -delay;
+		else cts = 0;
+	} else {
+		cts = ctx->sample_end;
+	}
+	if (ctx->sample_end && (ctx->sample_end<cts)) {
+		cts = ctx->sample_end;
+		pck = NULL;
+	}
+	if (!ctx->is_playing)
+		return GF_EOS;
+	cts = gf_timestamp_to_clocktime(cts, ctx->timescale);
+	u32 dur = 0;
+	if (pck)
+		dur = (u32) gf_timestamp_rescale( gf_filter_pck_get_duration(pck), ctx->timescale, 1000);
+
+	if (!gf_sc_check_sys_frame(ctx->scene, ctx->odm, ctx->ipid, filter, cts, dur))
 		return GF_OK;
+
+	if (!pck) {
+		GF_Err e = ttd_render_simple_text(ctx, NULL, 0, 0);
+		ctx->sample_end = 0;
+		return e;
 	}
 
 	pck_data = gf_filter_pck_get_data(pck, &pck_size);
+
+	if (ctx->simple_text) {
+		u32 sample_duration = gf_filter_pck_get_duration(pck);
+		GF_Err e = ttd_render_simple_text(ctx, pck_data, pck_size, sample_duration);
+		gf_filter_pid_drop_packet(ctx->ipid);
+		ctx->sample_end = sample_duration + cts;
+		return e;
+	}
 	gf_bs_reassign_buffer(ctx->bs_r, pck_data, pck_size);
 
 	while (gf_bs_available(ctx->bs_r)) {
@@ -1318,6 +1453,8 @@
 
 	if (ctx->cfg) gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
 	gf_bs_del(ctx->bs_r);
+
+	if (ctx->static_text) gf_free(ctx->static_text);
 }
 
 
@@ -1326,8 +1463,8 @@
 {
 	{ OFFS(texture), "use texturing for output text", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(outline), "draw text outline", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(txtw), "default width in standalone rendering", GF_PROP_UINT, "400", NULL, 0},
-	{ OFFS(txth), "default height in standalone rendering", GF_PROP_UINT, "200", NULL, 0},
+	{ OFFS(txtw), "default width in standalone rendering", GF_PROP_UINT, "400", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(txth), "default height in standalone rendering", GF_PROP_UINT, "200", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -1337,6 +1474,8 @@
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TEXT_MPEG4),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
 };
@@ -1345,7 +1484,13 @@
 	.name = "ttxtdec",
 	GF_FS_SET_DESCRIPTION("TTXT/TX3G decoder")
 	GF_FS_SET_HELP("This filter decodes TTXT/TX3G streams into a BIFS scene graph of the compositor filter.\n"
-	"The TTXT documentation is available at https://wiki.gpac.io/TTXT-Format-Documentation\n")
+		"The TTXT documentation is available at https://wiki.gpac.io/TTXT-Format-Documentation\n"
+		"\n"
+		"In stand-alone rendering (no associated video), the filter will use:\n"
+		"- `Width` and `Height` properties of input pid if any\n"
+		"- otherwise, `osize` option of compositor if set\n"
+		"- otherwise, -txtw() and -txth()\n"
+	)
 	.private_size = sizeof(GF_TTXTDec),
 	.flags = GF_FS_REG_MAIN_THREAD,
 	.args = TTXTDecArgs,

gpac-2.0.0.tar.gz/src/filters/dec_vorbis.c -> gpac-2.2.0.tar.gz/src/filters/dec_vorbis.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / XIPH Vorbis decoder filter
@@ -53,6 +53,42 @@
 	Bool has_reconfigured;
 } GF_VorbisDecCtx;
 
+
+void vorbisdec_set_props(GF_VorbisDecCtx *ctx)
+{
+	u32 chan_mask;
+
+	ctx->nb_chan = ctx->vi.channels;
+	ctx->sample_rate = ctx->vi.rate;
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(ctx->sample_rate) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(ctx->nb_chan) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_AUDIO_FORMAT, &PROP_UINT(GF_AUDIO_FMT_S16) );
+
+	switch (ctx->vi.channels) {
+	case 1:
+		chan_mask = GF_AUDIO_CH_FRONT_CENTER;
+		break;
+	case 2:
+		chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT;
+		break;
+	case 3:
+		chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER;
+		break;
+	case 4:
+		chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_SURROUND_LEFT | GF_AUDIO_CH_SURROUND_RIGHT;
+		break;
+	case 5:
+		chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_SURROUND_LEFT | GF_AUDIO_CH_SURROUND_RIGHT;
+		break;
+	case 6:
+		chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_SURROUND_LEFT | GF_AUDIO_CH_SURROUND_RIGHT | GF_AUDIO_CH_LFE;
+		break;
+	default:
+		chan_mask = GF_AUDIO_CH_FRONT_CENTER;
+		break;
+	}
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT(chan_mask) );
+}
 static GF_Err vorbisdec_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
 {
 	const GF_PropertyValue *p;
@@ -127,6 +163,7 @@
 	vorbis_block_init(&ctx->vd, &ctx->vb);
 	gf_bs_del(bs);
 
+	vorbisdec_set_props(ctx);
 	return GF_OK;
 }
 
@@ -198,35 +235,7 @@
 		vorbis_synthesis_blockin(&ctx->vd, &ctx->vb) ;
 
 	if ( (ctx->vi.channels != ctx->nb_chan) || (ctx->vi.rate != ctx->sample_rate) ) {
-		u64 chan_mask = 0;
-		ctx->nb_chan = ctx->vi.channels;
-		ctx->sample_rate = ctx->vi.rate;
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(ctx->sample_rate) );
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(ctx->nb_chan) );
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_AUDIO_FORMAT, &PROP_UINT(GF_AUDIO_FMT_S16) );
-
-		switch (ctx->vi.channels) {
-		case 1:
-			chan_mask = GF_AUDIO_CH_FRONT_CENTER;
-			break;
-		case 2:
-			chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT;
-			break;
-		case 3:
-			chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER;
-			break;
-		case 4:
-			chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_SURROUND_LEFT | GF_AUDIO_CH_SURROUND_RIGHT;
-			break;
-		case 5:
-			chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_SURROUND_LEFT | GF_AUDIO_CH_SURROUND_RIGHT;
-			break;
-		case 6:
-			chan_mask = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_SURROUND_LEFT | GF_AUDIO_CH_SURROUND_RIGHT | GF_AUDIO_CH_LFE;
-			break;
-		}
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT(chan_mask) );
-
+		vorbisdec_set_props(ctx);
 	}
 	size = (ctx->vd.pcm_current - ctx->vd.pcm_returned) * 2 * ctx->vi.channels;
 	if (size) {

gpac-2.0.0.tar.gz/src/filters/dec_vtb.c -> gpac-2.2.0.tar.gz/src/filters/dec_vtb.c Changed

@@ -83,6 +83,7 @@
 	u32 reorder, ofmt;
 	Bool no_copy;
 	Bool disable_hw;
+	Bool wait_sync;
 
 	//internal
 //	GF_FilterPid *ipid;
@@ -95,6 +96,9 @@
 	u32 cfg_crc;
 	u32 codecid;
 	Bool is_hardware;
+	Bool wait_rap;
+	s32 cmx;
+	Bool full_range;
 
 	GF_Err last_error;
 	
@@ -104,7 +108,7 @@
 
 GF_List *frames, *frames_res;
 GF_FilterPacket *cur_pck;
-
+	GF_Mutex *mx;
 	u8 chroma_format, luma_bit_depth, chroma_bit_depth;
 	Bool frame_size_changed;
 	Bool reorder_detected;
@@ -214,7 +218,9 @@
 
 	ctx->profile_supported = GF_TRUE;
 	ctx->nb_consecutive_errors=0;
+	gf_mx_p(ctx->mx);
 	frame = gf_list_pop_back(ctx->frames_res);
+	gf_mx_v(ctx->mx);
 	if (!frame) {
 		GF_SAFEALLOC(frame, GF_VTBHWFrame);
 		if (!frame) return;
@@ -239,6 +245,7 @@
 	if (!ctx->last_timescale_out)
 		ctx->last_timescale_out = gf_filter_pck_get_timescale(frame->pck_src);
 
+	gf_mx_p(ctx->mx);
 	count = gf_list_count(ctx->frames);
 	for (i=0; i<count; i++) {
 		GF_VTBHWFrame *aframe = gf_list_get(ctx->frames, i);
@@ -269,10 +276,13 @@
 		if (insert) {
 			gf_list_insert(ctx->frames, frame, i);
 			ctx->reorder_detected = GF_TRUE;
+			gf_mx_v(ctx->mx);
 			return;
 		}
 	}
+
 	gf_list_add(ctx->frames, frame);
+	gf_mx_v(ctx->mx);
 }
 
 static CFDictionaryRef vtbdec_create_buffer_attributes(GF_VTBDecCtx *ctx, OSType pix_fmt)
@@ -327,17 +337,22 @@
 	
 dec_dsi = CFDictionaryCreateMutable(kCFAllocatorDefault, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 
-	if (ctx->ofmt==1) {
+	switch (ctx->ofmt) {
+	case GF_PIXEL_YUV:
 		kColorSpace = kCVPixelFormatType_420YpCbCr8Planar;
 		ctx->pix_fmt = GF_PIXEL_YUV;
-	} else if (ctx->ofmt==2) {
+		break;
+	case GF_PIXEL_RGB:
 		kColorSpace = kCVPixelFormatType_24RGB;
 		ctx->pix_fmt = GF_PIXEL_RGB;
-	} else {
+		break;
+	default:
 		kColorSpace = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
 		ctx->pix_fmt = GF_PIXEL_NV12;
+		break;
 	}
 
+	ctx->wait_rap = ctx->wait_sync;
 	ctx->reorder_probe = ctx->reorder;
 	ctx->reorder_detected = GF_FALSE;
 	pid = gf_list_get(ctx->streams, 0);
@@ -782,6 +797,7 @@
 case kVTVideoDecoderMalfunctionErr:
 return GF_IO_ERR;
 case kVTVideoDecoderBadDataErr :
+ case -8969:
 return GF_NOT_SUPPORTED;
 
 	case kVTPixelTransferNotSupportedErr:
@@ -790,7 +806,7 @@
 case 0:
 break;
 default:
- return GF_SERVICE_ERROR;
+		return GF_NOT_SUPPORTED;
 }
 	
 	//good to go !
@@ -867,6 +883,8 @@
 			if (ps_id<0) return;
 		}
 	}
+
+	if (!dest) return;
 	
 	count = gf_list_count(dest);
 	for (i=0; i<count; i++) {
@@ -1016,6 +1034,11 @@
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE, &PROP_UINT(ctx->stride) );
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_PAR, &PROP_FRAC(ctx->pixel_ar) );
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->pix_fmt) );
+
+		if (ctx->full_range)
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(ctx->full_range));
+		if (ctx->cmx>=0)
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_MX, &PROP_UINT((u32) ctx->cmx));
 		return GF_OK;
 	}
 	//need a reset !
@@ -1106,13 +1129,15 @@
 			gf_odf_avc_cfg_del(cfg);
 
 			if ((ctx->active_sps>=0) && ctx->avc.spsctx->active_sps.vui_parameters_present_flag) {
-				Bool full_range = ctx->avc.spsctx->active_sps.vui.video_full_range_flag;
-				u32 cmx = ctx->avc.spsctx->active_sps.vui.matrix_coefficients;
-				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(full_range));
-				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_MX, &PROP_UINT(cmx));
+				ctx->full_range = ctx->avc.spsctx->active_sps.vui.video_full_range_flag;
+				ctx->cmx = ctx->avc.spsctx->active_sps.vui.matrix_coefficients;
+				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(ctx->full_range));
+				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_MX, &PROP_UINT((u32) ctx->cmx));
 			} else {
 				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_RANGE, NULL);
 				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_MX, NULL);
+				ctx->full_range = GF_FALSE;
+				ctx->cmx = -1;
 			}
 			return e;
 		}
@@ -1172,13 +1197,15 @@
 			gf_odf_hevc_cfg_del(cfg);
 
 			if ((ctx->active_sps>=0) && ctx->hevc.spsctx->active_sps.vui_parameters_present_flag) {
-				Bool full_range = ctx->hevc.spsctx->active_sps.video_full_range_flag;
-				u32 cmx = ctx->hevc.spsctx->active_sps.matrix_coeffs;
-				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(full_range));
-				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_MX, &PROP_UINT(cmx));
+				ctx->full_range = ctx->hevc.spsctx->active_sps.video_full_range_flag;
+				ctx->cmx = ctx->hevc.spsctx->active_sps.matrix_coeffs;
+				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(ctx->full_range));
+				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_MX, &PROP_UINT((u32) ctx->cmx));
 			} else {
 				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_RANGE, NULL);
 				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_COLR_MX, NULL);
+				ctx->cmx = -1;
+				ctx->full_range = GF_FALSE;
 			}
 			return e;
 		}
@@ -1425,14 +1452,18 @@
 
 	if (ctx->no_copy) return vtbdec_send_output_frame(filter, ctx);
 
+	gf_mx_p(ctx->mx);
 	vtbframe = gf_list_pop_front(ctx->frames);
 	GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("VTB Outputting frame DTS "LLU" CTS "LLU" timescale %d\n", gf_filter_pck_get_dts(vtbframe->pck_src), gf_filter_pck_get_cts(vtbframe->pck_src), gf_filter_pck_get_timescale(vtbframe->pck_src)));
+	gf_mx_v(ctx->mx);
 
 
 	status = CVPixelBufferLockBaseAddress(vtbframe->frame, kCVPixelBufferLock_ReadOnly);
 if (status != kCVReturnSuccess) {
 GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("VTB Error locking frame data\n"));
+		gf_mx_p(ctx->mx);
 		gf_list_add(ctx->frames_res, vtbframe);
+		gf_mx_v(ctx->mx);
 return GF_IO_ERR;
 }
 
@@ -1496,9 +1527,12 @@
 		gf_filter_pck_send(dst_pck);
 	}
 CVPixelBufferUnlockBaseAddress(vtbframe->frame, kCVPixelBufferLock_ReadOnly);
+	gf_mx_p(ctx->mx);
 	gf_list_add(ctx->frames_res, vtbframe);
+	gf_mx_v(ctx->mx);
 	return GF_OK;
 }
+
 static GF_Err vtbdec_process(GF_Filter *filter)
 {
 OSStatus status;
@@ -1553,7 +1587,11 @@
 		gf_filter_pid_drop_packet(ref_pid);
 		return GF_OK;
 	}
-
+	if (ctx->wait_rap && !gf_filter_pck_get_sap(pck)) {
+		gf_filter_pid_drop_packet(ref_pid);
+		return GF_OK;
+	}
+	ctx->wait_rap = GF_FALSE;
 	in_buffer = (char *) gf_filter_pck_get_data(pck, &in_buffer_size);
 
 	//discard empty packets
@@ -1744,7 +1782,9 @@
 }
 
 safe_int_dec(&f->ctx->decoded_frames_pending);
+	gf_mx_p(f->ctx->mx);
 	gf_list_add(f->ctx->frames_res, f);
+	gf_mx_v(f->ctx->mx);
 }
 
 GF_Err vtbframe_get_plane(GF_FilterFrameInterface *frame, u32 plane_idx, const u8 **outPlane, u32 *outStride)
@@ -1799,7 +1839,7 @@
 
 GF_Err vtbframe_get_gl_texture(GF_FilterFrameInterface *frame, u32 plane_idx, u32 *gl_tex_format, u32 *gl_tex_id, GF_CodecMatrix * texcoordmatrix)
 {
- OSStatus status;
+ OSStatus status=kCVReturnSuccess;
 	GLenum target_fmt;
 	u32 w, h;
 	GF_CVGLTextureREF *outTexture=NULL;
@@ -1888,7 +1928,9 @@
 	GF_VTBHWFrame *vtb_frame;
 	GF_FilterPacket *dst_pck;
 
+	gf_mx_p(ctx->mx);
 	vtb_frame = gf_list_pop_front(ctx->frames);
+	gf_mx_v(ctx->mx);
 	if (!vtb_frame) return GF_BAD_PARAM;
 
 	GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("VTB Outputting frame DTS "LLU" CTS "LLU" timescale %d\n", gf_filter_pck_get_dts(vtb_frame->pck_src), gf_filter_pck_get_cts(vtb_frame->pck_src), gf_filter_pck_get_timescale(vtb_frame->pck_src)));
@@ -1928,12 +1970,14 @@
 {
 	GF_VTBDecCtx *ctx = (GF_VTBDecCtx *) gf_filter_get_udta(filter);
 	if (evt->base.type==GF_FEVT_PLAY) {
+		gf_mx_p(ctx->mx);
 		while (gf_list_count(ctx->frames) ) {
 			GF_VTBHWFrame *f = gf_list_pop_back(ctx->frames);
 			if (f->pck_src) gf_filter_pck_unref(f->pck_src);
 			f->pck_src = NULL;
 			gf_list_add(ctx->frames_res, f);
 		}
+		gf_mx_v(ctx->mx);
 		ctx->drop_non_refs = evt->play.drop_non_ref;
 	}
 	else if ((evt->base.type==GF_FEVT_SET_SPEED) || (evt->base.type==GF_FEVT_RESUME)) {
@@ -1953,6 +1997,10 @@
 	ctx->frames_res = gf_list_new();
 	ctx->frames = gf_list_new();
 	ctx->streams = gf_list_new();
+	ctx->mx = gf_mx_new("VTBDec");
+
+	gf_filter_force_main_thread(filter, GF_TRUE);
+
 	return GF_OK;
 }
 
@@ -1990,6 +2038,7 @@
 	if (ctx->ps_bs) gf_bs_del(ctx->ps_bs);
 	if (ctx->nalu_rewrite_bs) gf_bs_del(ctx->nalu_rewrite_bs);
 	if (ctx->nalu_buffer) gf_free(ctx->nalu_buffer);
+	gf_mx_del(ctx->mx);
 }
 
 
@@ -2030,6 +2079,7 @@
 	{ OFFS(no_copy), "dispatch decoded frames as OpenGL textures (true) or as copied packets (false) ", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(ofmt), "set default pixel format for decoded video. If not found, fall back to `nv12`", GF_PROP_PIXFMT, "nv12", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(disable_hw), "disable hardware decoding", GF_PROP_BOOL, "false", NULL, 0},
+	{ OFFS(wait_sync), "wait for sync frame before decoding", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_UPDATE},
 	{}
 };

gpac-2.0.0.tar.gz/src/filters/dec_webvtt.c -> gpac-2.2.0.tar.gz/src/filters/dec_webvtt.c Changed

@@ -43,7 +43,7 @@
 	//opts
 	char *script;
 	char *color, *font;
-	Float fontSize, lineSpacing, txtx, txty;
+	Float fontSize, lineSpacing;
 	u32 txtw, txth;
 
 	GF_FilterPid *ipid, *opid;
@@ -68,7 +68,15 @@
 	/* Scene graph for the subtitle content */
 	GF_SceneGraph *scenegraph;
 
+	u32 timescale;
+	s64 delay;
+	u64 cue_end;
+
 	Bool update_args;
+	s32 txtx, txty;
+	u32 fsize;
+	u32 vp_w, vp_h;
+	u32 nb_frames;
 } GF_VTTDec;
 
 void vttd_update_size_info(GF_VTTDec *ctx)
@@ -89,8 +97,13 @@
 		p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_HEIGHT);
 		if (p) h = p->value.uint;
 
+		if (ctx->scene->compositor->osize.x && ctx->scene->compositor->osize.y) {
+			w = ctx->scene->compositor->osize.x;
+			h = ctx->scene->compositor->osize.y;
+		}
 		if (!w) w = ctx->txtw;
 		if (!h) h = ctx->txth;
+		else if (h<=3*ctx->fontSize) h *= 2;
 
 		gf_sg_set_scene_size_info(ctx->scenegraph, w, h, GF_TRUE);
 		gf_scene_force_size(ctx->scene, w, h);
@@ -108,7 +121,8 @@
 	sprintf(szVB, "0 0 %d %d", w, h);
 	gf_node_get_attribute_by_tag(root, TAG_SVG_ATT_viewBox, GF_TRUE, GF_FALSE, &info);
 	gf_svg_parse_attribute(root, &info, szVB, 0);
-
+	ctx->vp_w = w;
+	ctx->vp_h = h;
 }
 
 void vttd_setup_scene(GF_VTTDec *ctx)
@@ -156,7 +170,7 @@
 	u32 entry_type;
 	GF_BitStream *bs;
 	u32 dsi_crc;
-	const GF_PropertyValue *dsi;
+	const GF_PropertyValue *p;
 	GF_VTTDec *ctx = (GF_VTTDec *)gf_filter_get_udta(filter);
 
 	if (is_remove) {
@@ -171,15 +185,31 @@
 	if (ctx->ipid && !gf_filter_pid_check_caps(pid)) return GF_NOT_SUPPORTED;
 	assert(!ctx->ipid || (ctx->ipid == pid));
 
-	dsi = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
-	if (!dsi) return GF_NOT_SUPPORTED;
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
+	ctx->delay = p ? p->value.longsint : 0;
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+	ctx->timescale = p ? p->value.uint: 1000;
+
+	ctx->ipid = pid;
+	if (!ctx->opid) {
+		ctx->opid = gf_filter_pid_new(filter);
+	}
 
-	dsi_crc = gf_crc_32(dsi->value.data.ptr, dsi->value.data.size);
+	//copy properties at init or reconfig
+	gf_filter_pid_copy_properties(ctx->opid, ctx->ipid);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT));
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
+
+	//decoder config not yet ready
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+	if (!p) return GF_OK;
+
+	dsi_crc = gf_crc_32(p->value.data.ptr, p->value.data.size);
 	if (dsi_crc == ctx->dsi_crc) return GF_OK;
 	ctx->dsi_crc = dsi_crc;
 
 	//parse DSI
-	bs = gf_bs_new(dsi->value.data.ptr, dsi->value.data.size, GF_BITSTREAM_READ);
+	bs = gf_bs_new(p->value.data.ptr, p->value.data.size, GF_BITSTREAM_READ);
 	entry_type = gf_bs_read_u32(bs);
 	if (entry_type == GF_ISOM_BOX_TYPE_WVTT) {
 		GF_Box *b;
@@ -188,22 +218,12 @@
 		((GF_StringBox *)b)->string = NULL;
 		gf_isom_box_del(b);
 	} else {
-		ctx->dsi = gf_malloc( dsi->value.data.size + 1);
-		memcpy(ctx->dsi, dsi->value.data.ptr, dsi->value.data.size);
-		ctx->dsidsi->value.data.size = 0;
+		ctx->dsi = gf_malloc( p->value.data.size + 1);
+		memcpy(ctx->dsi, p->value.data.ptr, p->value.data.size);
+		ctx->dsip->value.data.size = 0;
 	}
 	gf_bs_del(bs);
 
-	ctx->ipid = pid;
-	if (!ctx->opid) {
-		ctx->opid = gf_filter_pid_new(filter);
-	}
-
-	//copy properties at init or reconfig
-	gf_filter_pid_copy_properties(ctx->opid, ctx->ipid);
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT));
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
-
 	return GF_OK;
 }
 
@@ -277,10 +297,33 @@
 	JSContext *svg_script_get_context(GF_SceneGraph *sg);
 	JSContext *c = svg_script_get_context(sg);
 
+	if ((ctx->txtx != ctx->scene->compositor->subtx)
+		|| (ctx->txty != ctx->scene->compositor->subty)
+		|| (ctx->fsize != ctx->scene->compositor->subfs)
+	) {
+		ctx->txtx = ctx->scene->compositor->subtx;
+		ctx->txty = ctx->scene->compositor->subty;
+		ctx->fsize = ctx->scene->compositor->subfs;
+		ctx->update_args = GF_TRUE;
+	}
+
+
 	if (ctx->update_args) {
 		JSValue global = JS_GetGlobalObject(c);
 
-		JS_SetPropertyStr(c, global, "fontSize", JS_NewFloat64(c, ctx->fontSize));
+		u32 fs = (u32) MAX(ctx->fsize, ctx->fontSize);
+		u32 def_font_size = ctx->scene->compositor->subfs;
+		if (!def_font_size) {
+			if (ctx->vp_h > 2000) def_font_size = 80;
+			else if (ctx->vp_h > 700) def_font_size = 40;
+			else def_font_size = 20;
+		}
+
+		if (!fs || (def_font_size>fs)) {
+			fs = def_font_size;
+		}
+
+		JS_SetPropertyStr(c, global, "fontSize", JS_NewFloat64(c, fs));
 		JS_SetPropertyStr(c, global, "fontFamily", JS_NewString(c, ctx->font));
 		JS_SetPropertyStr(c, global, "textColor", JS_NewString(c, ctx->color));
 		JS_SetPropertyStr(c, global, "lineSpaceFactor", JS_NewFloat64(c, ctx->lineSpacing));
@@ -294,7 +337,7 @@
 }
 
 
-static GF_Err vttd_js_add_cue(GF_VTTDec *ctx, GF_Node *node, const char *id, const char *start, const char *end, const char *settings, const char *payload)
+static GF_Err vttd_js_add_cue(GF_VTTDec *ctx, GF_Node *node, const char *id, const char *start, const char *end, const char *settings, const char *payload, char *comment)
 {
 	GF_Err e=GF_OK;
 	JSValue fun_val;
@@ -308,13 +351,14 @@
 	if (!JS_IsFunction(c, fun_val) ) {
 		e = GF_BAD_PARAM;
 	} else {
-		JSValue ret, argv5;
+		JSValue ret, argv6;
 
 		argv0 = JS_NewString(c, id ? id : "");
 		argv1 = JS_NewString(c, start ? start : "");
 		argv2 = JS_NewString(c, end ? end : "");
 		argv3 = JS_NewString(c, settings ? settings : "");
 		argv4 = JS_NewString(c, payload ? payload : "");
+		argv5 = JS_NewString(c, comment ? comment : "");
 
 		ret = JS_Call(c, fun_val, global, 5, argv);
 		if (JS_IsException(ret)) {
@@ -327,6 +371,7 @@
 		JS_FreeValue(c, argv2);
 		JS_FreeValue(c, argv3);
 		JS_FreeValue(c, argv4);
+		JS_FreeValue(c, argv5);
 	}
 	JS_FreeValue(c, global);
 	JS_FreeValue(c, fun_val);
@@ -369,7 +414,6 @@
 	GF_List *cues;
 	const char *pck_data;
 	u64 cts;
-	u32 timescale, obj_time;
 	u32 pck_size;
 	GF_VTTDec *ctx = (GF_VTTDec *) gf_filter_get_udta(filter);
 
@@ -382,7 +426,7 @@
 	}
 
 	pck = gf_filter_pid_get_packet(ctx->ipid);
-	if (!pck) {
+	if (!pck && !ctx->cue_end) {
 		if (gf_filter_pid_is_eos(ctx->ipid)) {
 			gf_filter_pid_set_eos(ctx->opid);
 			return GF_EOS;
@@ -394,19 +438,51 @@
 	if (!ctx->odm->ck)
 		return GF_OK;
 
-	cts = gf_filter_pck_get_cts( pck );
-	timescale = gf_filter_pck_get_timescale(pck);
-
-	gf_odm_check_buffering(ctx->odm, ctx->ipid);
+	if (ctx->cue_end) {
+		u64 old_cue_end = ctx->cue_end;
+		u32 obj_time = gf_clock_time(ctx->odm->ck);
+		if (gf_clock_diff(ctx->odm->ck, obj_time, (u32) ctx->cue_end)<=0) {
+			vttd_js_remove_cues(ctx, ctx->scenegraph->RootNode);
+			ctx->cue_end = 0;
+		}
+		if (!pck) {
+			if (gf_filter_pid_is_eos(ctx->ipid)) {
+				//single frame, don't reset compositor (avoid last blank frame generation)
+				if (ctx->nb_frames==1) {
+					gf_filter_pid_set_eos(ctx->opid);
+					return GF_EOS;
+				}
+				if (ctx->cue_end) {
+					gf_sc_sys_frame_pending(ctx->scene->compositor, (u32) ctx->cue_end, obj_time, filter);
+				} else {
+					gf_sc_check_sys_frame(ctx->scene, ctx->odm, ctx->ipid, filter, old_cue_end, 0);
+					gf_filter_pid_set_eos(ctx->opid);
+					return GF_EOS;
+				}
+			}
+			return GF_OK;
+		}
+	}
 
-	//we still process any frame before our clock time even when buffering
-	obj_time = gf_clock_time(ctx->odm->ck);
-	if (gf_timestamp_greater(cts, timescale, obj_time, 1000)) {
-		gf_sc_sys_frame_pending(ctx->scene->compositor, ((Double) cts / timescale), obj_time, filter);
+	cts = gf_filter_pck_get_cts( pck );
+	s64 delay = ctx->scene->compositor->subd;
+	if (delay)
+		delay = gf_timestamp_rescale_signed(delay, 1000, ctx->timescale);
+	delay += ctx->delay;
+
+	if (delay>=0) cts += delay;
+	else if (cts > (u64) -delay) cts -= -delay;
+	else cts = 0;
+	cts = gf_timestamp_to_clocktime(cts, ctx->timescale);
+
+	u32 dur = (u32) gf_timestamp_rescale( gf_filter_pck_get_duration(pck), ctx->timescale, 1000);
+	if (!gf_sc_check_sys_frame(ctx->scene, ctx->odm, ctx->ipid, filter, cts, dur))
 		return GF_OK;
-	}
+
 	pck_data = gf_filter_pck_get_data(pck, &pck_size);
 
+	ctx->cue_end = cts + gf_timestamp_rescale(gf_filter_pck_get_duration(pck), ctx->timescale, 1000);
+	ctx->nb_frames++;
 	cues = gf_webvtt_parse_cues_from_data(pck_data, pck_size, 0, 0);
 	vttd_js_remove_cues(ctx, ctx->scenegraph->RootNode);
 	if (gf_list_count(cues)) {
@@ -416,7 +492,7 @@
 			gf_list_rem(cues, 0);
 			sprintf(start, "%02d:%02d:%02d.%03d", cue->start.hour, cue->start.min, cue->start.sec, cue->start.ms);
 			sprintf(end, "%02d:%02d:%02d.%03d", cue->end.hour, cue->end.min, cue->end.sec, cue->end.ms);
-			vttd_js_add_cue(ctx, ctx->scenegraph->RootNode, cue->id, start, end, cue->settings, cue->text);
+			vttd_js_add_cue(ctx, ctx->scenegraph->RootNode, cue->id, start, end, cue->settings, cue->text, cue->pre_text);
 
 			gf_webvtt_cue_del(cue);
 		}
@@ -455,6 +531,14 @@
 void vttd_finalize(GF_Filter *filter)
 {
 	GF_VTTDec *ctx = (GF_VTTDec *) gf_filter_get_udta(filter);
+
+	if (ctx->scenegraph) {
+		if (ctx->graph_registered) {
+			gf_scene_register_extra_graph(ctx->scene, ctx->scenegraph, GF_TRUE);
+		}
+		gf_sg_del(ctx->scenegraph);
+	}
+
 	if (ctx->cues) gf_list_del(ctx->cues);
 	if (ctx->dsi) gf_free(ctx->dsi);
 }
@@ -467,10 +551,8 @@
 	{ OFFS(fontSize), "font size", GF_PROP_FLOAT, "20", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
 	{ OFFS(color), "text color", GF_PROP_STRING, "white", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
 	{ OFFS(lineSpacing), "line spacing as scaling factor to font size", GF_PROP_FLOAT, "1.0", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
-	{ OFFS(txtx), "horizontal offset", GF_PROP_FLOAT, "5", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
-	{ OFFS(txty), "vertical offset", GF_PROP_FLOAT, "5", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
-	{ OFFS(txtw), "default width in standalone rendering", GF_PROP_UINT, "400", NULL, 0},
-	{ OFFS(txth), "default height in standalone rendering", GF_PROP_UINT, "200", NULL, 0},
+	{ OFFS(txtw), "default width in standalone rendering", GF_PROP_UINT, "400", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(txth), "default height in standalone rendering", GF_PROP_UINT, "200", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -488,7 +570,13 @@
 	GF_FS_SET_DESCRIPTION("WebVTT decoder")
 	GF_FS_SET_HELP("This filter decodes WebVTT streams into a SVG scene graph of the compositor filter.\n"
 		"The scene graph creation is done through JavaScript.\n"
-		"The filter options are used to override the JS global variables of the WebVTT renderer.")
+		"The filter options are used to override the JS global variables of the WebVTT renderer."
+		"\n"
+		"In stand-alone rendering (no associated video), the filter will use:\n"
+		"- `Width` and `Height` properties of input pid if any\n"
+		"- otherwise, `osize` option of compositor if set\n"
+		"- otherwise, -txtw() and -txth()\n"
+	)
 	.private_size = sizeof(GF_VTTDec),
 	.flags = GF_FS_REG_MAIN_THREAD,
 	.args = VTTDecArgs,

gpac-2.0.0.tar.gz/src/filters/dec_xvid.c -> gpac-2.2.0.tar.gz/src/filters/dec_xvid.c Changed

gpac-2.0.0.tar.gz/src/filters/decrypt_cenc_isma.c -> gpac-2.2.0.tar.gz/src/filters/decrypt_cenc_isma.c Changed

@@ -84,6 +84,7 @@
 	Bool is_cenc;
 	Bool is_cbc;
 	u32 KID_count;
+	Bool inband_keys;
 	bin128 *KIDs;
 	bin128 *keys;
 
@@ -104,6 +105,8 @@
 
 	Bool gpac_master_leaf;
 	bin128 master_key;
+
+	u32 clearkey_crc;
 } GF_CENCDecStream;
 
 typedef struct
@@ -636,6 +639,155 @@
 	return GF_OK;
 }
 
+typedef struct
+{
+	u8 *data;
+	u32 data_len;
+	Bool hdr_done;
+} ClearKeyParam;
+
+static void ck_http_io(void *usr_cbk, GF_NETIO_Parameter *par)
+{
+	switch (par->msg_type) {
+	case GF_NETIO_GET_METHOD:
+		par->name = "POST";
+		break;
+	case GF_NETIO_GET_HEADER:
+		if (! ((ClearKeyParam*)usr_cbk)->hdr_done) {
+			((ClearKeyParam*)usr_cbk)->hdr_done = GF_TRUE;
+			par->name = "Content-Type";
+			par->value = "application/json";
+		}
+		break;
+	case GF_NETIO_GET_CONTENT:
+		par->data = ((ClearKeyParam*)usr_cbk)->data;
+		par->size = ((ClearKeyParam*)usr_cbk)->data_len;
+		break;
+	default:
+		break;
+	}
+}
+
+static GF_Err rfmt_dec_b64(u8 *data, u8 *output, u32 osize)
+{
+	u32 len, i=0;
+	while (datai) {
+		if (datai == '-') datai = '+';
+		else if (datai == '_') datai = '/';
+		i++;
+	}
+	len = (u32) strlen(data);
+	switch (len%4) {
+	case 0: break;
+	case 2: strcat(data, "=="); break;
+	case 3: strcat(data, "="); break;
+	default: return GF_NON_COMPLIANT_BITSTREAM;
+	}
+	len = gf_base64_decode(data, (u32) strlen(data), output, osize);
+	if (len != 16) return GF_NON_COMPLIANT_BITSTREAM;
+	return GF_OK;
+}
+
+#define CK_MAX_BUF	1000
+static GF_Err cenc_dec_set_clearkey(GF_CENCDecCtx *ctx, GF_CENCDecStream *cstr, char *ck_url, u8 *ck_kid)
+{
+	GF_Err e;
+	char data6432, bodyCK_MAX_BUF;
+	ClearKeyParam ckp;
+	memset(&ckp, 0, sizeof(ClearKeyParam));
+	u32 i, res = gf_base64_encode(ck_kid, 16, data64, 32);
+	data64res=0;
+	for (i=0; i<res; i++) {
+		if (data64i=='+') data64i = '-';
+		else if (data64i=='/') data64i = '_';
+	}
+	while (data64res-1=='=') {
+		data64res-1=0;
+		res--;
+		if (!res) break;
+	}
+	strcpy(body, "{\"kids\": \"");
+	strcat(body, data64);
+	strcat(body, "\", \"type\":\"temporary\"}");
+	ckp.data = body;
+	ckp.data_len = (u32) strlen(body);
+
+	u32 crc = gf_crc_32(ckp.data, ckp.data_len);
+	if (cstr->clearkey_crc == crc) return GF_OK;
+	cstr->clearkey_crc = crc;
+
+	GF_DownloadManager *dm = gf_filter_get_download_manager(ctx->filter);
+	GF_DownloadSession *sess = gf_dm_sess_new(dm, ck_url, GF_NETIO_SESSION_NOT_THREADED | GF_NETIO_SESSION_NOT_CACHED, ck_http_io, &ckp, &e);
+	if (e) return e;
+
+	u32 nb_read=0;
+	while (1) {
+		u32 nread=0;
+		e = gf_dm_sess_fetch_data(sess, body + nb_read, CK_MAX_BUF-nb_read, &nread);
+		nb_read += nread;
+		if (nb_read >= CK_MAX_BUF) e = GF_BUFFER_TOO_SMALL;
+
+		if ((e<0) && (e != GF_IP_NETWORK_EMPTY)) break;
+		if (e == GF_EOS) {
+			break;
+		}
+	}
+	gf_dm_sess_del(sess);
+	if (e<GF_OK) return e;
+
+	//extract kids and keys from json
+	u32 key_idx=0;
+	char *ptr = body;
+	while (1) {
+		char *k = strstr(ptr, "\"k\"");
+		char *kid = strstr(ptr, "\"kid\"");
+		if (!k || !kid) break;
+		k+=3;
+		kid+=5;
+		while (k0 && (k0 != '"')) k++;
+		while (kid0 && (kid0 != '"')) kid++;
+		if ((k0 != '"') || (kid0 != '"')) {
+			e = GF_NON_COMPLIANT_BITSTREAM;
+			break;
+		}
+
+		k++;
+		kid++;
+		char *s1 = strchr(k, '"');
+		char *s2 = strchr(kid, '"');
+		if (!s1 || !s2) {
+			e = GF_NON_COMPLIANT_BITSTREAM;
+			break;
+		}
+		s10 = 0;
+		s20 = 0;
+
+		u8 key_val20, kid_val20;
+		e = rfmt_dec_b64(k, key_val, 20);
+		if (e) break;
+		e = rfmt_dec_b64(kid, kid_val, 20);
+		if (e) break;
+
+		cstr->keys = gf_realloc(cstr->keys, sizeof(bin128)*(key_idx+1));
+		cstr->KIDs = gf_realloc(cstr->KIDs, sizeof(bin128)*(key_idx+1));
+		memcpy(cstr->keyskey_idx, key_val, sizeof(bin128));
+		memcpy(cstr->KIDskey_idx, kid_val, sizeof(bin128));
+		key_idx++;
+		if (s1 < s2) ptr = s2+1;
+		else ptr = s1+1;
+	}
+	if (e) return e;
+	cstr->KID_count = key_idx;
+
+	if (!cstr->crypts) {
+		cstr->crypts = gf_malloc(sizeof(CENCDecKey));
+		memset(cstr->crypts, 0, sizeof(CENCDecKey));
+	}
+	memcpy(cstr->crypts0.key, cstr->keys0, sizeof(bin128));
+	cstr->crypts0.key_valid = 1;
+	return GF_OK;
+}
+
 static GF_Err cenc_dec_set_hls_key(GF_CENCDecCtx *ctx, GF_CENCDecStream *cstr, char *key_url, u8 *key_IV)
 {
 	GF_Err e;
@@ -784,13 +936,14 @@
 
 		/*SystemID for GPAC Player: 67706163-6365-6E63-6472-6D746F6F6C31*/
 		if (!strcmp(szSystemID, "6770616363656E6364726D746F6F6C31")) {
-			if (version==2)
-				cstr->gpac_master_leaf = GF_TRUE;
-			else if (version==3)
-				is_leaf_key = GF_TRUE;
-			else if (version==1)
+			//no KID signaled (version 0), use inband setup
+			if (version==0) {
 				cstr->gpac_master_leaf = GF_FALSE;
-			else {
+				cstr->inband_keys = GF_TRUE;
+				cstr->KID_count = 0;
+				return GF_OK;
+			}
+			else if (version>1) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("CENC/ISMA Unsupported GPAC DRM config (version %d)\n", version));
 				continue;
 			}
@@ -810,6 +963,7 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("CENC/ISMA Invalid KID count %d in GPAC init blob\n", kid_count));
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
+		gf_bin128_parse("0x6770616363656E6364726D746F6F6C31", cypherKey);
 
 		/*store key IDs*/
 		cstr->KID_count = kid_count;
@@ -819,6 +973,15 @@
 
 		memmove(cstr->KIDs, pssh_data + pos, cstr->KID_count*sizeof(bin128));
 		gf_bs_skip_bytes(ctx->bs_r, cstr->KID_count*sizeof(bin128));
+
+		//no key announced yet (roll)
+		if ((cstr->KID_count==1) && !memcmp(cstr->KIDs0, cypherKey, sizeof(bin128))) {
+			cstr->inband_keys = GF_TRUE;
+			cstr->gpac_master_leaf = GF_FALSE;
+			cstr->KID_count = 0;
+			return GF_OK;
+		}
+
 		priv_len = gf_bs_read_u32(ctx->bs_r);
 		pos = (u32) gf_bs_get_position(ctx->bs_r);
 
@@ -827,27 +990,48 @@
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
 
+		if (gf_bs_available(ctx->bs_r) % 16 == 0) {
+			cypherOffset = 0;
+			if (cstr->gpac_master_leaf)
+				is_leaf_key = GF_TRUE;
+		} else {
+			cypherOffset = pssh_datapos + 1;
+			if (priv_len < cypherOffset) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("CENC/ISMA Invalid cypher offset %d in GPAC init blob\n", cypherOffset));
+				return GF_NON_COMPLIANT_BITSTREAM;
+			}
+			if (!strncmp(pssh_data + pos + 1, "master", 6)) {
+				cstr->gpac_master_leaf = GF_TRUE;
+			}
+			else if (!strncmp(pssh_data + pos + 1, "leaf", 4)) {
+				is_leaf_key = GF_TRUE;
+			} else if (cypherOffset>1) {
+				cstr->gpac_master_leaf = GF_FALSE;
+				if (!is_pck_pssh) {
+					cstr->gpac_master_leaf = GF_FALSE;
+					cstr->inband_keys = (version==0) ? GF_TRUE : GF_FALSE;
+				}
+			} else if (cstr->gpac_master_leaf) {
+				is_leaf_key = GF_TRUE;
+			}
+		}
+
+
 		if (is_leaf_key) {
-			if (gf_bs_available(ctx->bs_r) < 16) {
+			if (gf_bs_available(ctx->bs_r) < 16 + cypherOffset	) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("CENC/ISMA Invalid GPAC init blob for leaf key\n", kid_count));
 				return GF_NON_COMPLIANT_BITSTREAM;
 			}
-			memmove(cstr->keys, pssh_data + pos, cstr->KID_count*sizeof(bin128));
-		} else {
+			memmove(cstr->keys, pssh_data + pos + cypherOffset, cstr->KID_count*sizeof(bin128));
+		} else if (priv_len) {
+			Bool use_cbc = (!cstr->gpac_master_leaf && cstr->inband_keys) ? GF_TRUE : GF_FALSE;
 			/*GPAC DRM TEST system info, used to validate cypher offset in CENC packager
 				keyIDs as usual (before private data)
 				URL len on 8 bits
 				URL
 				keys, cyphered with our magic key :)
 			*/
-			cypherOffset = pssh_datapos + 1;
 
-			if (priv_len < cypherOffset) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("CENC/ISMA Invalid cypher offset %d in GPAC init blob\n", cypherOffset));
-				return GF_NON_COMPLIANT_BITSTREAM;
-			}
-
-			gf_bin128_parse("0x6770616363656E6364726D746F6F6C31", cypherKey);
 			gf_bin128_parse("0x00000000000000000000000000000001", cypherIV);
 
 			enc_payload_len = priv_len - cypherOffset;
@@ -856,7 +1040,11 @@
 				return GF_NON_COMPLIANT_BITSTREAM;
 			}
 
-			mc = gf_crypt_open(GF_AES_128, GF_CTR);
+			if (use_cbc) {
+				mc = gf_crypt_open(GF_AES_128, GF_CBC);
+			} else {
+				mc = gf_crypt_open(GF_AES_128, GF_CTR);
+			}
 			if (!mc) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("CENC/ISMA Cannot open AES-128 CTR\n"));
 				return GF_IO_ERR;
@@ -864,7 +1052,7 @@
 			enc_data = gf_malloc(priv_len - cypherOffset);
 			memcpy(enc_data, pssh_data + pos + cypherOffset, priv_len - cypherOffset);
 
-			gf_crypt_init(mc, cypherKey, cypherIV);
+			gf_crypt_init(mc, cypherKey, use_cbc ? NULL : cypherIV);
 			gf_crypt_decrypt(mc, enc_data, priv_len - cypherOffset);
 			gf_crypt_close(mc);
 
@@ -884,7 +1072,6 @@
 			return GF_OK;
 		}
 		if (is_leaf_key) {
-			u32 j;
 			for (j=0; j<cstr->KID_count; j++) {
 				GF_Crypt *crypto = gf_crypt_open(GF_AES_128, GF_CBC);
 				if (!crypto) return GF_OUT_OF_MEM;
@@ -948,7 +1135,7 @@
 		u32 new_crc = gf_crc_32(cstr->cenc_ki->value.data.ptr, cstr->cenc_ki->value.data.size);
 
 		//change of key config and same pssh, setup single key
-		if ((new_crc != ki_crc) && (pssh_crc==cstr->pssh_crc)) {
+		if ((new_crc != ki_crc) && (pssh_crc==cstr->pssh_crc) && !cstr->inband_keys) {
 			e = cenc_dec_load_keys(ctx, cstr);
 			if (e) return e;
 		}
@@ -1039,6 +1226,16 @@
 		if (!e) return GF_OK;
 	}
 
+	cinfo_prop = gf_filter_pid_get_property(cstr->ipid, GF_PROP_PID_CLEARKEY_URI);
+	prop = gf_filter_pid_get_property(cstr->ipid, GF_PROP_PID_CLEARKEY_KID);
+
+	if (cinfo_prop && prop) {
+		e = cenc_dec_set_clearkey(ctx, cstr, cinfo_prop->value.string, prop->value.data.ptr);
+		if (!e) return GF_OK;
+		GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("CENC Failed to setup clearkey from download key %s: %s\n", cinfo_prop->value.string, gf_error_to_string(e)))
+	}
+
+
 	if (ctx->decrypt!=DECRYPT_FULL) {
 		GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("CENC/ISMA No keys found but playback forced\n"));
 		return GF_OK;
@@ -1548,7 +1745,6 @@
 	}
 
 send_packet:
-	gf_filter_pck_merge_properties(in_pck, out_pck);
 	gf_filter_pck_set_property(out_pck, GF_PROP_PCK_CENC_SAI, NULL);
 	gf_filter_pck_set_crypt_flags(out_pck, 0);
 
@@ -1721,7 +1917,6 @@
 
 
 send_packet:
-	gf_filter_pck_merge_properties(in_pck, out_pck);
 	gf_filter_pck_set_property(out_pck, GF_PROP_PCK_CENC_SAI, NULL);
 	gf_filter_pck_set_crypt_flags(out_pck, 0);
 
@@ -1963,7 +2158,7 @@
 	gf_filter_pid_set_property(cstr->opid, GF_PROP_PID_CENC_PATTERN, NULL);
 	gf_filter_pid_set_property(cstr->opid, GF_PROP_PID_HLS_KMS, NULL);
 
-	gf_filter_pid_set_property(cstr->opid, GF_PROP_PID_ORIG_CRYPT_SCHEME, &PROP_UINT(scheme_type) );
+	gf_filter_pid_set_property(cstr->opid, GF_PROP_PID_ORIG_CRYPT_SCHEME, &PROP_4CC(scheme_type) );
 
 
 	cstr->is_nalu = GF_FALSE;;
@@ -2012,6 +2207,8 @@
 		} else {
 			cenc_dec_access_isma(ctx, cstr, is_play);
 		}
+		if (!is_play)
+			cstr->crypt_init = GF_FALSE;
 		break;
 	default:
 		break;

gpac-2.0.0.tar.gz/src/filters/dmx_avi.c -> gpac-2.2.0.tar.gz/src/filters/dmx_avi.c Changed

@@ -48,16 +48,17 @@
 {
 	//opts
 	GF_Fraction fps;
-	Bool importer;
+	Bool importer, noreframe;
 
 	GF_FilterPid *ipid;
 
 	GF_FilterPid *v_opid;
-	Bool v_in_use;
+	Bool v_in_use, video_done;
 	u32 nb_frames, cur_frame, nb_frame_sent;
 	u32 dummy, nvops;
 	const char *src_url;
 	avi_t *avi;
+	u64 file_size;
 
 	Bool use_file_fps;
 	GF_Fraction64 duration;
@@ -114,7 +115,9 @@
 		codecid = GF_CODECID_AVC;
 		unframed = GF_FALSE;
 	} else if (!stricmp(comp, "DIV3") || !stricmp(comp, "DIV4")) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("AVIDmx Video format %s not compliant with MPEG-4 Visual - please recompress the file first\n", comp));
+//		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("AVIDmx Video format %s not compliant with MPEG-4 Visual - please recompress the file first\n", comp));
+		codecid = GF_CODECID_MSPEG4_V3;
+		unframed = GF_FALSE;
 	} else if (!comp0) {
 		codecid = GF_CODECID_RAW;
 		pfmt = GF_PIXEL_BGR;
@@ -160,8 +163,9 @@
 			gf_filter_pid_set_property_str(ctx->v_opid, "nocts", &PROP_BOOL( GF_TRUE ) );
 		} else if (ctx->avi->extradata_size && ctx->avi->extradata) {
 			gf_filter_pid_set_property(ctx->v_opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA(ctx->avi->extradata, ctx->avi->extradata_size) );
-
 		}
+		if (ctx->noreframe)
+			gf_filter_pid_set_property(ctx->v_opid, GF_PROP_PID_UNFRAMED, NULL);
 	}
 
 	unframed = GF_FALSE;
@@ -329,6 +333,8 @@
 				}
 			}
 
+			if (ctx->noreframe)
+				gf_filter_pid_set_property(st->opid, GF_PROP_PID_UNFRAMED, NULL);
 		}
 	}
 }
@@ -360,7 +366,7 @@
 		ctx->ipid = pid;
 
 		//we work with full file only, send a play event on source to indicate that
-		GF_FEVT_INIT(fevt, GF_FEVT_PLAY, pid);
+		GF_FEVT_INIT(fevt, GF_FEVT_PLAY_HINT, pid);
 		fevt.play.start_range = 0;
 		fevt.base.on_pid = ctx->ipid;
 		fevt.play.full_file_only = GF_TRUE;
@@ -398,6 +404,7 @@
 		if (evt->base.on_pid==ctx->v_opid) {
 			u32 frame_idx = 0;
 			ctx->v_playing = GF_TRUE;
+			ctx->video_done = GF_FALSE;
 			if ((evt->play.start_range==0) && !ctx->v_init_play_done) {
 				ctx->v_init_play_done = GF_TRUE;
 				return GF_TRUE;
@@ -405,6 +412,11 @@
 			ctx->v_init_play_done = GF_TRUE;
 			frame_idx = (u32) (ctx->avi->fps * evt->play.start_range);
 			if (frame_idx) {
+#ifdef GPAC_ENABLE_COVERAGE
+				if (gf_sys_is_cov_mode()) {
+					AVI_seek_start(ctx->avi);
+				}
+#endif
 				AVI_set_video_position(ctx->avi, frame_idx);
 			} else {
 				AVI_seek_start(ctx->avi);
@@ -417,6 +429,7 @@
 				AVIAstream *st = gf_list_get(ctx->audios, i);
 				if (st->opid != evt->base.on_pid) continue;
 				st->playing = GF_TRUE;
+				st->audio_done = GF_FALSE;
 				if ((evt->play.start_range==0) && !st->init_play_done) {
 					st->init_play_done = GF_TRUE;
 					return GF_TRUE;
@@ -438,7 +451,7 @@
 			for (i=0; i<gf_list_count(ctx->audios); i++) {
 				AVIAstream *st = gf_list_get(ctx->audios, i);
 				if (st->opid != evt->base.on_pid) continue;
-				st->playing = GF_TRUE;
+				st->playing = GF_FALSE;
 			}
 		}
 		//don't cancel event
@@ -458,7 +471,8 @@
 {
 	GF_AVIDmxCtx *ctx = gf_filter_get_udta(filter);
 	u32 i, count, nb_done, nb_active=0;
-	Bool start, end, video_done;
+	Bool start, end;
+	u32 a_pc=0;
 
 	if (!ctx->avi) {
 		GF_FilterPacket *pck = gf_filter_pid_get_packet(ctx->ipid);
@@ -471,7 +485,6 @@
 		if (!end) {
 			return GF_OK;
 		}
-
 		ctx->avi = AVI_open_input_file((char *)ctx->src_url, 1);
 		if (!ctx->avi) {
 			GF_Err e = GF_NON_COMPLIANT_BITSTREAM;
@@ -479,10 +492,16 @@
 			gf_filter_setup_failure(filter, e);
 			return GF_NOT_SUPPORTED;
 		}
+		FILE *fp = gf_fopen(ctx->src_url, "r");
+		if (fp) {
+			ctx->file_size = gf_fsize(fp);
+			gf_fclose(fp);
+		}
+
 		avidmx_setup(filter, ctx);
 		return GF_OK;
 	}
-	video_done = GF_FALSE;
+
 	if (ctx->v_in_use && ctx->v_playing && (ctx->cur_frame < ctx->nb_frames) && !gf_filter_pid_would_block(ctx->v_opid) ) {
 		u32 key;
 		u64 file_offset, cts;
@@ -518,35 +537,52 @@
 		ctx->cur_frame++;
 		if (ctx->cur_frame < ctx->nb_frames)
 			gf_filter_post_process_task(filter);
-		else
-			video_done = GF_TRUE;
-	} else if (!ctx->v_in_use) {
-		video_done = GF_TRUE;
-	} else if (ctx->cur_frame >= ctx->nb_frames) {
-		video_done = GF_TRUE;
+		else if (!ctx->video_done) {
+			ctx->video_done = GF_TRUE;
+			gf_filter_pid_set_eos(ctx->v_opid);
+		}
+	} else if (!ctx->v_in_use || (ctx->cur_frame >= ctx->nb_frames)) {
+		if (!ctx->video_done) {
+			if (ctx->v_in_use) {
+				gf_filter_pid_set_eos(ctx->v_opid);
+			}
+			ctx->video_done = GF_TRUE;
+		}
 	}
 	
 	nb_done = 0;
 	count = gf_list_count(ctx->audios);
 	for (i=0; i<count; i++) {
 		s32 size;
+		u32 pc=0;
 		AVIAstream *st = gf_list_get(ctx->audios, i);
 		if (st->audio_done || !st->in_use) {
 			nb_done++;
 			continue;
 		}
-		if (!ctx->v_playing) video_done = GF_TRUE;
+		if (!ctx->v_playing)
+			ctx->video_done = GF_TRUE;
+
 		if (!st->playing || gf_filter_pid_would_block(st->opid) )
 			continue;
 		AVI_set_audio_track(ctx->avi, st->stream_num);
 		nb_active++;
 
+restart:
 		size = AVI_audio_size(ctx->avi, st->aud_frame);
 
 		if (st->seek_to_ts && size) {
 			if (st->seek_to_ts > st->audio_ts) {
 				st->aud_frame ++;
-				continue;
+				if (st->audio_bps) {
+					u32 nb_samples = (8*size) / (st->audio_bps * st->nb_channels);
+					st->audio_ts += nb_samples;
+				} else if (st->is_aac) {
+					st->audio_ts += 1024;
+				} else {
+					st->audio_ts ++;
+				}
+				goto restart;
 			}
 			else
 				st->seek_to_ts = 0;
@@ -562,6 +598,10 @@
 			file_offset = gf_ftell(ctx->avi->fdes);
 			AVI_read_audio(ctx->avi, pck_data, size, (int*)&continuous);
 
+			if (ctx->file_size) {
+				pc = (u32) ( file_offset * 100 / ctx->file_size);
+			}
+
 			if (st->audio_bps) {
 				u32 nb_samples = (8*size) / (st->audio_bps * st->nb_channels);
 				gf_filter_pck_set_cts(dst_pck, st->audio_ts);
@@ -581,20 +621,40 @@
 			st->aud_frame ++;
 		} else {
 			st->audio_done = GF_TRUE;
+			gf_filter_pid_set_eos(st->opid);
 			nb_done++;
+			pc = 100;
 		}
+		if (!a_pc || (pc<a_pc)) a_pc = pc;
 	}
-	if (!nb_active)
-		return GF_OK;
-	if (video_done && (nb_done==count) ) {
-		if (ctx->v_opid && ctx->v_in_use) gf_filter_pid_set_eos(ctx->v_opid);
+	if (gf_filter_reporting_enabled(filter)) {
+		char szStatus1024;
+		u32 v_pc=0;
+		if (ctx->v_in_use) {
+			v_pc = ctx->cur_frame * 100;
+			v_pc /= ctx->nb_frames;
+		}
 
-		for (i=0; i<count;i++) {
-			AVIAstream *st = gf_list_get(ctx->audios, i);
-			gf_filter_pid_set_eos(st->opid);
+		if (ctx->video_done && (nb_done==count) ) {
+			sprintf(szStatus, "100 %%");
+			v_pc=100;
+		}
+		else if (count && ctx->v_in_use) {
+			sprintf(szStatus, "V %d %% A %d %%", v_pc, a_pc);
+			if (v_pc>a_pc) v_pc=a_pc;
+		} else if (count) {
+			sprintf(szStatus, "A %d %%", a_pc);
+			v_pc = a_pc;
+		} else {
+			sprintf(szStatus, "V %d %%", v_pc);
 		}
+		gf_filter_update_status(filter, v_pc, szStatus);
+	}
+	if (ctx->video_done && (nb_done==count) ) {
 		return GF_EOS;
 	}
+	if (!nb_active)
+		return GF_OK;
 	gf_filter_post_process_task(filter);
 	return GF_OK;
 }
@@ -626,6 +686,7 @@
 static const char * avidmx_probe_data(const u8 *data, u32 size, GF_FilterProbeScore *score)
 {
 	if (size<12) return NULL;
+	*score = GF_FPROBE_NOT_SUPPORTED;
 	if (strncmp(data, "RIFF", 4)) return NULL;
 	if (strncmp(data+8, "AVI ", 4)) return NULL;
 	*score = GF_FPROBE_SUPPORTED;
@@ -647,6 +708,7 @@
 {
 	{ OFFS(fps), "import frame rate, default is AVI one", GF_PROP_FRACTION, "1/0", NULL, 0},
 	{ OFFS(importer), "compatibility with old importer, displays import results", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(noreframe), "skip media reframer", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{0}
 };

gpac-2.0.0.tar.gz/src/filters/dmx_dash.c -> gpac-2.2.0.tar.gz/src/filters/dmx_dash.c Changed

@@ -56,10 +56,16 @@
 	BMIN_MPD,
 };
 
+enum {
+	FLAG_PERIOD_SWITCH = 1,
+	FLAG_TIME_OVERFLOW = 1<<1,
+	FLAG_FIRST_IN_SEG = 1<<2,
+};
+
 typedef struct
 {
 	//opts
-	s32 shift_utc, route_shift;
+	s32 shift_utc, spd, route_shift;
 	u32 max_buffer, tiles_rate, segstore, delay40X, exp_threshold, switch_count, bwcheck;
 	s32 auto_switch;
 	s32 init_timeshift;
@@ -139,7 +145,8 @@
 	Bool wait_for_pck;
 	Bool eos_detected;
 	u32 next_dependent_rep_idx, current_dependent_rep_idx;
-
+	u64 utc_map;
+	
 	GF_DownloadSession *sess;
 	Bool is_timestamp_based, pto_setup;
 	Bool prev_is_init_segment;
@@ -167,6 +174,9 @@
 
 	const char *hls_key_uri;
 	bin128 hls_key_IV;
+
+	char *current_url;
+	Bool url_changed;
 } GF_DASHGroup;
 
 static void dashdmx_notify_group_quality(GF_DASHDmxCtx *ctx, GF_DASHGroup *group);
@@ -251,6 +261,11 @@
 				if (seg_name) {
 					gf_filter_pck_set_property(ref, GF_PROP_PCK_FILENAME, &PROP_STRING(seg_name) );
 					gf_filter_pck_set_property(ref, GF_PROP_PCK_FILENUM, &PROP_UINT(seg_number) );
+					if (group->url_changed && group->current_url) {
+						gf_filter_pck_set_property(ref, GF_PROP_PCK_FRAG_RANGE, NULL);
+						gf_filter_pck_set_property(ref, GF_PROP_PID_URL, &PROP_STRING(group->current_url));
+						group->url_changed = GF_FALSE;
+					}
 
 					if (is_filemode) {
 						u64 ts;
@@ -275,8 +290,9 @@
 			dashdmx_set_string_list_prop(ref, GF_PROP_PCK_HLS_VARIANT_NAME, &ctx->hls_variants_names);
 		}
 
-		if (gf_filter_pid_get_udta_flags(out_pid)) {
-			gf_filter_pid_set_udta_flags(out_pid, 0);
+		u32 flags = gf_filter_pid_get_udta_flags(out_pid);
+		if (flags & FLAG_PERIOD_SWITCH) {
+			gf_filter_pid_set_udta_flags(out_pid, flags & ~FLAG_PERIOD_SWITCH);
 			gf_filter_pck_set_property(ref, GF_PROP_PID_DASH_PERIOD_START, &PROP_LONGUINT(0) );
 		}
 		gf_filter_pck_send(ref);
@@ -284,14 +300,25 @@
 	}
 
 	if (!ctx->is_dash) {
-		gf_filter_pck_forward(in_pck, out_pid);
+		dst_pck = gf_filter_pck_new_ref(out_pid, 0, 0, in_pck);
+		if (!dst_pck) return;
+		gf_filter_pck_merge_properties(in_pck, dst_pck);
+
+		u32 flags = gf_filter_pid_get_udta_flags(out_pid);
+		if (! (flags & FLAG_FIRST_IN_SEG) ) {
+			if (!group->pto_setup) {
+				gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_MEDIA_TIME, &PROP_DOUBLE(ctx->media_start_range) );
+				group->pto_setup = GF_TRUE;
+			}
+
+			if (group->utc_map) {
+				gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_UTC_TIME, & PROP_LONGUINT(group->utc_map) );
+			}
+			flags |= FLAG_FIRST_IN_SEG;
+			gf_filter_pid_set_udta_flags(out_pid, flags);
 
-		if (!group->pto_setup) {
-			cts = gf_filter_pck_get_cts(in_pck);
-			gf_filter_pid_set_property_str(out_pid, "time:timestamp", &PROP_LONGUINT(cts) );
-			gf_filter_pid_set_property_str(out_pid, "time:media", &PROP_DOUBLE(ctx->media_start_range) );
-			group->pto_setup = GF_TRUE;
 		}
+		gf_filter_pck_send(dst_pck);
 
 		gf_filter_pid_drop_packet(in_pid);
 		return;
@@ -315,6 +342,7 @@
 			u32 mpd_timescale;
 			gf_dash_group_get_presentation_time_offset(ctx->dash, group->idx, &pto, &mpd_timescale);
 			group->pto_setup = 1;
+			do_map_time = GF_TRUE;
 
 			//we are forwarding segment boundaries and potentially rebuilding manifest based on the source time
 			//do not adjust timestamps
@@ -398,9 +426,9 @@
 				//if DTS larger than max TS, drop packet
 				if ( (s64) _dts > (s64) scale_max_cts) {
 					flags = gf_filter_pid_get_udta_flags(out_pid);
-					if (!flags) {
+					if (!(flags & FLAG_TIME_OVERFLOW)) {
 						GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("DASHDmx Packet decode timestamp "LLU" larger than max CTS in period "LLU" - dropping all further packets\n", adj_cts, scale_max_cts));
-						gf_filter_pid_set_udta_flags(out_pid, 1);
+						gf_filter_pid_set_udta_flags(out_pid, flags | FLAG_TIME_OVERFLOW);
 					}
 					gf_filter_pid_drop_packet(in_pid);
 					return;
@@ -434,8 +462,8 @@
 		dts += scale_timesdisc_offset;
 		cts += scale_timesdisc_offset;
 	} else if (!group->pto_setup) {
-		do_map_time = 1;
-		group->pto_setup = 1;
+		do_map_time = GF_TRUE;
+		group->pto_setup = GF_TRUE;
 	}
 
 	dst_pck = gf_filter_pck_new_ref(out_pid, 0, 0, in_pck);
@@ -446,13 +474,21 @@
 	gf_filter_pck_set_dts(dst_pck, dts);
 	gf_filter_pck_set_cts(dst_pck, cts);
 	gf_filter_pck_set_seek_flag(dst_pck, seek_flag);
-	gf_filter_pck_send(dst_pck);
-	gf_filter_pid_drop_packet(in_pid);
 
-	if (do_map_time) {
-		gf_filter_pid_set_property_str(out_pid, "time:timestamp", &PROP_LONGUINT(cts) );
-		gf_filter_pid_set_property_str(out_pid, "time:media", &PROP_DOUBLE(ctx->media_start_range) );
+
+	u32 flags = gf_filter_pid_get_udta_flags(out_pid);
+	if (! (flags & FLAG_FIRST_IN_SEG) ) {
+		flags |= FLAG_FIRST_IN_SEG;
+		gf_filter_pid_set_udta_flags(out_pid, flags);
+		if (do_map_time)
+			gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_MEDIA_TIME, &PROP_DOUBLE(ctx->media_start_range) );
+
+		if (group->utc_map)
+			gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_UTC_TIME, & PROP_LONGUINT(group->utc_map) );
 	}
+
+	gf_filter_pck_send(dst_pck);
+	gf_filter_pid_drop_packet(in_pid);
 }
 
 
@@ -488,7 +524,9 @@
 	return GF_FALSE;
 }
 
+#ifndef GPAC_DISABLE_CRYPTO
 void gf_cryptfin_set_kms(GF_Filter *f, const char *key_url, bin128 key_IV);
+#endif
 
 /*locates input service (demuxer) based on mime type or segment name*/
 static GF_Err dashdmx_load_source(GF_DASHDmxCtx *ctx, u32 group_index, const char *mime, const char *init_segment_name, u64 start_range, u64 end_range)
@@ -540,17 +578,17 @@
 
 	//not from file system, set cache option
 	if (url_type) {
+		char szOpt100;
+		char sep_name = gf_filter_get_sep(ctx->filter, GF_FS_SEP_NAME);
 		if (!ctx->segstore) {
 			if (!has_sep) { gf_dynstrcat(&sURL, "gpac", szSep); has_sep = GF_TRUE; }
 			//if operating in mem mode and we load a file decryptor, only store in mem cache the first seg, and no cache for segments
-			if (crypto_type==1)
-				gf_dynstrcat(&sURL, "cache=none_keep", szSep);
-			else
-				gf_dynstrcat(&sURL, "cache=mem_keep", szSep);
-		}
-		else if (ctx->segstore==2) {
+			sprintf(szOpt, "cache%c%s", sep_name, (crypto_type==1) ? "none_keep" : "mem_keep");
+			gf_dynstrcat(&sURL, szOpt, szSep);
+		} else {
+			sprintf(szOpt, "cache%c%s", sep_name, (ctx->segstore==2) ? "keep" : "disk");
 			if (!has_sep) { gf_dynstrcat(&sURL, "gpac", szSep); has_sep = GF_TRUE; }
-			gf_dynstrcat(&sURL, "cache=keep", szSep);
+			gf_dynstrcat(&sURL, szOpt, szSep);
 		}
 	}
 
@@ -592,7 +630,13 @@
 	//if HLS AES-CBC, set key BEFORE discarding segment URL (if TS, discarding the segment will discard the key uri)
 	if (key_uri) {
 		if (crypto_type==1) {
+#ifndef GPAC_DISABLE_CRYPTO
 			gf_cryptfin_set_kms(group->seg_filter_src, key_uri, key_IV);
+#else
+			gf_free(sURL);
+			return GF_NOT_SUPPORTED;
+#endif
+
 		} else {
 			group->hls_key_uri = key_uri;
 			memcpy(group->hls_key_IV, key_IV, sizeof(bin128));
@@ -615,6 +659,8 @@
 	gf_dm_delete_cached_file_entry_session((GF_DownloadSession *)session, cache_url);
 }
 
+void gf_dm_sess_force_blocking(GF_DownloadSession *sess);
+
 GF_DASHFileIOSession dashdmx_io_create(GF_DASHFileIO *dashio, Bool persistent, const char *url, s32 group_idx)
 {
 	GF_DownloadSession *sess;
@@ -632,6 +678,7 @@
 		const GF_PropertyValue *p = gf_filter_pid_get_property(ctx->mpd_pid, GF_PROP_PID_DOWNLOAD_SESSION);
 		if (p) {
 			sess = (GF_DownloadSession *) p->value.ptr;
+			gf_dm_sess_force_blocking(sess);
 			if (!ctx->segstore) {
 				gf_dm_sess_force_memory_mode(sess, 1);
 			}
@@ -909,12 +956,14 @@
 #ifdef GPAC_ENABLE_COVERAGE
 		if (gf_sys_is_cov_mode()) {
 			gf_dash_groups_set_language(ctx->dash, gf_opts_get_key("core", "lang"));
-			//not used in the test suite (require JS)
-			gf_dash_switch_quality(ctx->dash, GF_TRUE);
+			//not used in the test suite (require JS), but don't run if algo is none
+			if (!ctx->algo || strcmp(ctx->algo, "none"))
+				gf_dash_switch_quality(ctx->dash, GF_TRUE);
 			//not used relyably in the test suite (require fatal error in session)
 			dashin_abort(NULL);
 		}
 #endif
+
 		if (ctx->groupsel)
 			gf_dash_groups_set_language(ctx->dash, gf_opts_get_key("core", "lang"));
 
@@ -1047,6 +1096,7 @@
 				group->seg_filter_src = NULL;
 			}
 			if (group->template) gf_free(group->template);
+			if (group->current_url) gf_free(group->current_url);
 			gf_free(group);
 			gf_dash_set_group_udta(ctx->dash, i, NULL);
 		}
@@ -1150,7 +1200,7 @@
 
 			//in forward mode, signal period switch at packet level but don't touch timestamps for now
 			if (ctx->forward) {
-				gf_filter_pid_set_udta_flags(opid, 1);
+				gf_filter_pid_set_udta_flags(opid, FLAG_PERIOD_SWITCH);
 				continue;
 			}
 			u32 timescale = gf_filter_pid_get_timescale(opid);
@@ -1372,6 +1422,8 @@
 	}
 }
 
+const char *gf_dash_group_get_clearkey_uri(GF_DashClient *dash, u32 group_idx, bin128 *def_kid);
+
 static void dashdmx_declare_properties(GF_DASHDmxCtx *ctx, GF_DASHGroup *group, u32 group_idx, GF_FilterPid *opid, GF_FilterPid *ipid, Bool is_period_switch)
 {
 	GF_DASHQualityInfo qinfo;
@@ -1540,18 +1592,22 @@
 	}
 
 	if (ctx->forward == DFWD_FILE) {
-		u32 segdur, timescale;
-		u64 tsb = (u64) gf_dash_group_get_time_shift_buffer_depth(ctx->dash, group_idx);
-		gf_dash_group_get_segment_duration(ctx->dash, group_idx, &segdur, &timescale);
-		if (segdur) {
-			tsb *= timescale;
-			tsb /= segdur;
-			tsb /= 1000; //tsb given in ms
+		if (gf_dash_is_dynamic_mpd(ctx->dash)) {
+			u32 segdur, timescale;
+			u64 tsb = (u64) gf_dash_group_get_time_shift_buffer_depth(ctx->dash, group_idx);
+			gf_dash_group_get_segment_duration(ctx->dash, group_idx, &segdur, &timescale);
+			if (segdur) {
+				tsb *= timescale;
+				tsb /= segdur;
+				tsb /= 1000; //tsb given in ms
+			} else {
+				tsb = 0;
+			}
+			tsb++;
+			gf_filter_pid_set_property(opid, GF_PROP_PID_TIMESHIFT_SEGS, &PROP_UINT((u32) tsb) );
 		} else {
-			tsb = 0;
+			gf_filter_pid_set_property(opid, GF_PROP_PID_TIMESHIFT_SEGS, NULL );
 		}
-		tsb++;
-		gf_filter_pid_set_property(opid, GF_PROP_PID_TIMESHIFT_SEGS, &PROP_UINT((u32) tsb) );
 	}
 
 	const char *title, *source;
@@ -1631,8 +1687,14 @@
 	if (group->hls_key_uri) {
 		gf_filter_pid_set_property(opid, GF_PROP_PID_HLS_KMS, &PROP_STRING(group->hls_key_uri));
 		gf_filter_pid_set_property(opid, GF_PROP_PID_HLS_IV, &PROP_DATA(group->hls_key_IV, sizeof(bin128) ));
+	} else {
+		bin128 ck_kid;
+		const char *ckuri = gf_dash_group_get_clearkey_uri(ctx->dash, group_idx, &ck_kid);
+		if (ckuri) {
+			gf_filter_pid_set_property(opid, GF_PROP_PID_CLEARKEY_URI, &PROP_STRING(ckuri));
+			gf_filter_pid_set_property(opid, GF_PROP_PID_CLEARKEY_KID, &PROP_DATA(ck_kid, sizeof(bin128) ));
+		}
 	}
-
 	if (ctx->forward > DFWD_FILE) {
 		u64 pstart;
 		u32 timescale;
@@ -1779,6 +1841,7 @@
 		opid = dashdmx_create_output_pid(ctx, pid, &run_status, group);
 		gf_filter_pid_set_udta(opid, group);
 		gf_filter_pid_set_udta(pid, opid);
+		//reste all flags
 		gf_filter_pid_set_udta_flags(opid, 0);
 		group->nb_pids ++;
 
@@ -2024,13 +2087,6 @@
 	ctx->dm = gf_filter_get_download_manager(filter);
 	if (!ctx->dm) return GF_SERVICE_ERROR;
 
-	//old syntax
-	if (ctx->filemode) {
-		GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("DASHDmx `filemode` option will soon be deprecated, update your script to use `:forward=file` option.\n"));
-		ctx->forward = DFWD_FILE;
-		ctx->filemode = GF_FALSE;
-	}
-
 	ctx->dash_io.udta = ctx;
 	ctx->dash_io.delete_cache_file = dashdmx_io_delete_cache_file;
 	ctx->dash_io.create = dashdmx_io_create;
@@ -2142,6 +2198,7 @@
 
 	gf_dash_set_algo(ctx->dash, algo);
 	gf_dash_set_utc_shift(ctx->dash, ctx->shift_utc);
+	gf_dash_set_suggested_presentation_delay(ctx->dash, ctx->spd);
 	gf_dash_set_route_ast_shift(ctx->dash, ctx->route_shift);
 	gf_dash_enable_utc_drift_compensation(ctx->dash, ctx->server_utc);
 	gf_dash_set_tile_adaptation_mode(ctx->dash, ctx->tile_mode, ctx->tiles_rate);
@@ -2193,6 +2250,10 @@
 		dashdmx_on_filter_setup_error(NULL, NULL, GF_OK);
 	}
 #endif
+
+	//we are blocking in live mode for manifest update 
+	gf_filter_set_blocking(filter, GF_TRUE);
+
 	return GF_OK;
 }
 
@@ -2366,7 +2427,8 @@
 			gf_dash_set_speed(ctx->dash, fevt->play.speed);
 
 		initial_play = ctx->initial_play;
-		if (fevt->play.initial_broadcast_play) initial_play = GF_TRUE;
+		if (fevt->play.initial_broadcast_play==1)
+			initial_play = GF_TRUE;
 
 		/*don't seek if this command is the first PLAY request of objects declared by the subservice, unless start range is not default one (0) */
 		if (!ctx->nb_playing) {
@@ -2383,14 +2445,19 @@
 
 				//to remove once we manage to keep the service alive
 				/*don't forward commands if a switch of period is to be scheduled, we are killing the service anyway ...*/
-				if (gf_dash_get_period_switch_status(ctx->dash)) return GF_TRUE;
+				if (gf_dash_get_period_switch_status(ctx->dash)) {
+					ctx->nb_playing++;
+					return GF_TRUE;
+				}
 			}
 		}
 		//otherwise in static mode, perform a group seek
 		else if (!initial_play && !gf_dash_is_dynamic_mpd(ctx->dash) ) {
 			/*don't forward commands if a switch of period is to be scheduled, we are killing the service anyway ...*/
-			if (gf_dash_get_period_switch_status(ctx->dash)) return GF_TRUE;
-
+			if (gf_dash_get_period_switch_status(ctx->dash)) {
+				ctx->nb_playing++;
+				return GF_TRUE;
+			}
 			//seek on a single group
 
 			gf_dash_group_seek(ctx->dash, group->idx, fevt->play.start_range);
@@ -2525,6 +2592,7 @@
 		if (ctx->forward) {
 			GF_DASHQualityInfo q;
 			const char *init_seg = NULL;
+			const char *hls_variant = NULL;
 			const char *dash_url = gf_dash_get_url(ctx->dash);
 			u32 segment_timeline_timescale = 0;
 
@@ -2540,7 +2608,7 @@
 					gf_filter_pid_set_property(opid, GF_PROP_PID_CODEC, &PROP_STRING(q.codec));
 			}
 			if (group->template) gf_free(group->template);
-			group->template = gf_dash_group_get_template(ctx->dash, group->idx, &segment_timeline_timescale, &init_seg);
+			group->template = gf_dash_group_get_template(ctx->dash, group->idx, &segment_timeline_timescale, &init_seg, &hls_variant);
 			if (!group->template) {
 				GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("DASHDmx Cannot extract template string for %s\n", dash_url ));
 				gf_filter_pid_set_property(opid, GF_PROP_PID_TEMPLATE, NULL);
@@ -2552,6 +2620,7 @@
 				gf_filter_pid_set_property_str(opid, "stl_timescale", segment_timeline_timescale ? &PROP_UINT(segment_timeline_timescale) : NULL);
 				gf_filter_pid_set_property_str(opid, "init_url", init_seg ? &PROP_STRING(init_seg) : NULL);
 				gf_filter_pid_set_property_str(opid, "manifest_url", dash_url ? &PROP_STRING(dash_url) : NULL);
+				gf_filter_pid_set_property_str(opid, "hls_variant_name", hls_variant ? &PROP_STRING(hls_variant) : NULL);
 			}
 			gf_filter_pid_set_property(opid, GF_PROP_PID_REP_ID, &PROP_STRING(q.ID) );
 
@@ -2728,7 +2797,7 @@
 
 	e = gf_dash_group_get_next_segment_location(ctx->dash, group_idx, dependent_representation_index, &next_url, &start_range, &end_range,
 		 NULL, &next_url_init_or_switch_segment, &switch_start_range , &switch_end_range,
-		 &src_url, &has_scalable_next, &key_url, &key_IV);
+		 &src_url, &has_scalable_next, &key_url, &key_IV, &group->utc_map);
 
 	if (e == GF_EOS) {
 		group->eos_detected = GF_TRUE;
@@ -2771,7 +2840,9 @@
 
 	if (next_url_init_or_switch_segment && !group->init_switch_seg_sent) {
 		if (group->in_is_cryptfile) {
+#ifndef GPAC_DISABLE_CRYPTO
 			gf_cryptfin_set_kms(group->seg_filter_src, key_url, key_IV);
+#endif
 		}
 		GF_FEVT_INIT(evt, GF_FEVT_SOURCE_SWITCH, NULL);
 		evt.seek.start_offset = switch_start_range;
@@ -2779,6 +2850,10 @@
 		evt.seek.source_switch = next_url_init_or_switch_segment;
 		evt.seek.is_init_segment = GF_TRUE;
 		evt.seek.skip_cache_expiration = GF_TRUE;
+		if (ctx->forward) {
+			if (group->current_url) gf_free(group->current_url);
+			group->current_url = gf_strdup(next_url_init_or_switch_segment);
+		}
 
 		group->prev_is_init_segment = GF_TRUE;
 
@@ -2811,7 +2886,20 @@
 	}
 
 	if (group->in_is_cryptfile) {
+#ifndef GPAC_DISABLE_CRYPTO
 		gf_cryptfin_set_kms(group->seg_filter_src, key_url, key_IV);
+#endif
+	}
+
+	if (ctx->forward) {
+		if (group->current_url && strcmp(group->current_url, next_url)) {
+			gf_free(group->current_url);
+			group->current_url = NULL;
+		}
+		if (!group->current_url) {
+			group->current_url = gf_strdup(next_url);
+			group->url_changed = GF_TRUE;
+		}
 	}
 
 	GF_FEVT_INIT(evt, GF_FEVT_SOURCE_SWITCH, NULL);
@@ -2992,6 +3080,9 @@
 								gf_dash_group_push_tfrf(ctx->dash, group->idx, p->value.ptr, gf_filter_pid_get_timescale(an_ipid));
 							}
 							gf_filter_release_property(pe);
+
+							u32 flags = gf_filter_pid_get_udta_flags(an_opid);
+							gf_filter_pid_set_udta_flags(an_opid, flags & ~FLAG_FIRST_IN_SEG);
 						}
 						dashdmx_update_group_stats(ctx, group);
 						group->stats_uploaded = GF_TRUE;
@@ -3022,6 +3113,9 @@
 
 						gf_filter_pid_clear_eos(an_ipid, GF_TRUE);
 						GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("DASHDmx Clearing EOS on pids from group %d\n", group->idx));
+
+						u32 flags = gf_filter_pid_get_udta_flags(an_opid);
+						gf_filter_pid_set_udta_flags(an_opid, flags & ~FLAG_FIRST_IN_SEG);
 					}
 					dashdmx_switch_segment(ctx, group);
 					gf_filter_prevent_blocking(filter, GF_FALSE);
@@ -3214,6 +3308,7 @@
 		"- mpd: use the indicated min buffer time of the MPD", GF_PROP_UINT, "auto", "no|auto|mpd", 0},
 
 	{ OFFS(shift_utc), "shift DASH UTC clock in ms", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(spd), "suggested presentation delay in ms", GF_PROP_SINT, "-I", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(route_shift), "shift ROUTE requests time by given ms", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(server_utc), "use `ServerUTC` or `Date` HTTP headers instead of local UTC", GF_PROP_BOOL, "yes", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(screen_res), "use screen resolution in selection phase", GF_PROP_BOOL, "yes", NULL, GF_FS_ARG_HINT_ADVANCED},
@@ -3255,7 +3350,6 @@
 
 	{ OFFS(skip_lqt), "disable decoding of tiles with highest degradation hints (not visible, not gazed at) for debug purposes", GF_PROP_BOOL, "no", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(llhls_merge), "merge LL-HLS byte range parts into a single open byte range request", GF_PROP_BOOL, "yes", NULL, GF_FS_ARG_HINT_EXPERT},
-	{ OFFS(filemode), "alias for forward=file", GF_PROP_BOOL, "no", NULL, GF_FS_ARG_HINT_HIDE},
 	{ OFFS(groupsel), "select groups based on language (by default all playable groups are exposed)", GF_PROP_BOOL, "no", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(chain_mode), "MPD chaining mode\n"
 	"- off: do not use MPD chaining\n"
@@ -3305,8 +3399,6 @@
 	"To expose a live DASH session to route:\n"
 	"EX gpac -i MANIFEST_URL dashin:forward=file -o route://225.0.0.1:8000/\n"
 	"\n"
-	"Note: This mode used to be trigger by -filemode() option, still recognized.\n"
-	"\n"
 	"If the source has dependent media streams (scalability) and all qualities and initialization segments need to be forwarded, add -split_as().\n"
 	"\n"
 	"# Segment bound modes\n"
@@ -3325,7 +3417,7 @@
 	"Each first packet of a segment will have the following properties attached:\n"
 	"- `CueStart`: indicate this is a segment start\n"
 	"- `FileNumber`: current segment number\n"
-	"- `FileName`: current segment file name without manifest base url\n"
+	"- `FileName`: current segment file name without manifest (MPD or master HLS) base url\n"
 	"- `DFPStart`: set with value `0` if this is the first packet in the period, absent otherwise\n"
 	"\n"
 	"If -forward() is set to `mani`, the first packet of a segment dispatched after a manifest update will also carry the manifest payload as a property:\n"
@@ -3342,8 +3434,9 @@
 	"- `DashDur`: set to the average segment duration as indicated in the manifest\n"
 	"- `source_template`: set to true to indicate the source template is known\n"
 	"- `stl_timescale`: timescale used by SegmentTimeline, or 0 if no SegmentTimeline\n"
-	"- `init_url`: unresolved intialization URL (as it appears in the manifest)\n"
+	"- `init_url`: unresolved intialization URL (as it appears in the MPD or in the variant playlist)\n"
 	"- `manifest_url`: manifest URL\n"
+	"- `hls_variant_name`: HLS variant playlist name (as it appears in the HLS master playlist)\n"
 	"\n"
 	"When the dasher(dasher) is used together with this mode, this will force all generated segments to have the same name, duration and fragmentation properties as the input ones. It is therefore not recommended for sessions stored/generated on local storage to generate the output in the same directory.\n"
 	)

gpac-2.0.0.tar.gz/src/filters/dmx_gsf.c -> gpac-2.2.0.tar.gz/src/filters/dmx_gsf.c Changed

gpac-2.0.0.tar.gz/src/filters/dmx_m2ts.c -> gpac-2.2.0.tar.gz/src/filters/dmx_m2ts.c Changed

@@ -31,6 +31,7 @@
 
 #include <gpac/mpegts.h>
 #include <gpac/thread.h>
+#include <gpac/internal/media_dev.h>
 
 typedef struct {
 	char *fragment;
@@ -59,7 +60,7 @@
 {
 	//opts
 	const char *temi_url;
-	Bool dsmcc, seeksrc, sigfrag;
+	Bool dsmcc, seeksrc, sigfrag, dvbtxt;
 
 	GF_Filter *filter;
 	GF_FilterPid *ipid;
@@ -72,7 +73,7 @@
 	u64 file_size;
 	Bool in_seek;
 	Bool initial_play_done;
-	u32 nb_playing;
+	u32 nb_playing, nb_stop_pending;
 
 	//duration estimation
 	GF_Fraction64 duration;
@@ -203,13 +204,13 @@
 	if (stream->flags & GF_M2TS_GPAC_CODEC_ID) {
 		codecid = stream->stream_type;
 		stype = gf_codecid_type(codecid);
-		unframed = GF_TRUE;
+		if (stream->gpac_meta_dsi)
+			stype = stream->gpac_meta_dsi4;
 		if (!stype) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("M2TSDmx Unrecognized gpac codec %s - ignoring pid\n", gf_4cc_to_str(codecid) ));
 			return;
 		}
 	} else {
-
 		switch (stream->stream_type) {
 		case GF_M2TS_VIDEO_MPEG1:
 			stype = GF_STREAM_VISUAL;
@@ -272,6 +273,12 @@
 		case GF_M2TS_VIDEO_VC1:
 			stype = GF_STREAM_VISUAL;
 			codecid = GF_CODECID_SMPTE_VC1;
+			stream->flags |= GF_M2TS_CHECK_VC1;
+			break;
+		case GF_M2TS_VIDEO_AV1:
+			stype = GF_STREAM_VISUAL;
+			codecid = GF_CODECID_AV1;
+			unframed = GF_TRUE;
 			break;
 		case GF_M2TS_AUDIO_MPEG1:
 			stype = GF_STREAM_AUDIO;
@@ -312,6 +319,12 @@
 		case GF_M2TS_AUDIO_EC3:
 			stype = GF_STREAM_AUDIO;
 			codecid = GF_CODECID_EAC3;
+			unframed = GF_TRUE;
+			break;
+		case GF_M2TS_AUDIO_TRUEHD:
+			stype = GF_STREAM_AUDIO;
+			codecid = GF_CODECID_TRUEHD;
+			unframed = GF_TRUE;
 			break;
 		case GF_M2TS_AUDIO_DTS:
 			stype = GF_STREAM_AUDIO;
@@ -327,7 +340,7 @@
 		case GF_M2TS_SYSTEMS_MPEG4_PES:
 			if (!esd) {
 				m4sys_iod_stream = GF_TRUE;
-				count = gf_list_count(stream->program->pmt_iod->ESDescriptors);
+				count = stream->program->pmt_iod ? gf_list_count(stream->program->pmt_iod->ESDescriptors) : 0;
 				for (i=0; i<count; i++) {
 					esd = gf_list_get(stream->program->pmt_iod->ESDescriptors, i);
 					if (esd->ESID == stream->mpeg4_es_id) break;
@@ -365,6 +378,20 @@
 			orig_stype = GF_STREAM_AUDIO;
 			codecid = GF_CODECID_EAC3;
 			break;
+		case GF_M2TS_DVB_SUBTITLE:
+			stype = GF_STREAM_TEXT;
+			codecid = GF_CODECID_DVB_SUBS;
+			stream->flags |= GF_M2TS_ES_FULL_AU;
+			break;
+		case GF_M2TS_DVB_TELETEXT:
+			if (!ctx->dvbtxt) {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("M2TSDmx DVB teletext pid skipped, use --dvbtxt to enable\n", stream->stream_type));
+				return;
+			}
+			stype = GF_STREAM_TEXT;
+			codecid = GF_CODECID_DVB_TELETEXT;
+			stream->flags |= GF_M2TS_ES_FULL_AU;
+			break;
 		default:
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("M2TSDmx Stream type 0x%02X not supported - ignoring pid\n", stream->stream_type));
 			return;
@@ -386,6 +413,17 @@
 	stream->user = opid;
 	stream->flags |= GF_M2TS_ES_ALREADY_DECLARED;
 
+	u32 d_type = orig_stype ? orig_stype : stype;
+	switch (d_type) {
+	case GF_STREAM_AUDIO:
+	case GF_STREAM_VISUAL:
+		stream->flags |= GF_M2TS_CHECK_DISC;
+		break;
+	default:
+		stream->flags &= ~GF_M2TS_CHECK_DISC;
+		break;
+	}
+
 	stname = gf_stream_type_name(stype);
 	sprintf(szName, "P%d%c%d", stream->program->number, stname0, 1+gf_list_find(stream->program->streams, stream));
 	gf_filter_pid_set_name(opid, szName);
@@ -428,12 +466,47 @@
 
 		gf_filter_pid_set_property(opid, GF_PROP_PID_TIMESCALE, &PROP_UINT(90000) );
 		gf_filter_pid_set_property(opid, GF_PROP_PID_CLOCK_ID, &PROP_UINT(stream->program->pcr_pid) );
+
+		if ((stream->flags&GF_M2TS_ES_IS_PES) && stream->gpac_meta_dsi) {
+			char *cname;
+			GF_BitStream *bs = gf_bs_new(stream->gpac_meta_dsi, stream->gpac_meta_dsi_size, GF_BITSTREAM_READ);
+			u32 val = gf_bs_read_u32(bs); //codec ID (meta codec identifier)
+			gf_filter_pid_set_property(opid, GF_PROP_PID_CODECID, &PROP_UINT(val) );
+			gf_bs_read_u8(bs); //stream type
+			gf_bs_read_u8(bs); //version
+			val = gf_bs_read_u32(bs); //codecID for meta codec, e.g. an AVCodecID or other
+			gf_filter_pid_set_property(opid, GF_PROP_PID_META_DEMUX_CODEC_ID, &PROP_UINT(val) );
+			cname = gf_bs_read_utf8(bs); //meta codec name
+			gf_filter_pid_set_property(opid, GF_PROP_PID_META_DEMUX_CODEC_NAME, cname ? &PROP_STRING_NO_COPY(cname) : NULL );
+			val = gf_bs_read_u32(bs); //meta opaque
+			gf_filter_pid_set_property(opid, GF_PROP_PID_META_DEMUX_OPAQUE, &PROP_UINT(val) );
+			u32 dsi_len = gf_bs_read_u32(bs);
+			if (dsi_len) {
+				u32 pos = (u32) gf_bs_get_position(bs);
+				gf_filter_pid_set_property(opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA(stream->gpac_meta_dsi+pos, dsi_len) );
+				gf_bs_skip_bytes(bs, dsi_len);
+			} else {
+				gf_filter_pid_set_property(opid, GF_PROP_PID_DECODER_CONFIG, NULL);
+			}
+			if (stype==GF_STREAM_VISUAL) {
+				val = gf_bs_read_u32(bs);
+				gf_filter_pid_set_property(opid, GF_PROP_PID_WIDTH, &PROP_UINT(val) );
+				val = gf_bs_read_u32(bs);
+				gf_filter_pid_set_property(opid, GF_PROP_PID_HEIGHT, &PROP_UINT(val) );
+			} else if (stype==GF_STREAM_AUDIO) {
+				val = gf_bs_read_u32(bs);
+				gf_filter_pid_set_property(opid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(val) );
+				val = gf_bs_read_u32(bs);
+				gf_filter_pid_set_property(opid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(val) );
+			}
+			gf_bs_del(bs);
+		}
 	}
 	gf_filter_pid_set_property(opid, GF_PROP_PID_SCALABLE, has_scal_layer ? &PROP_BOOL(GF_TRUE) : NULL);
 
 	gf_filter_pid_set_property(opid, GF_PROP_PID_SERVICE_ID, &PROP_UINT(stream->program->number) );
 
-	if (stream->lang) {
+	if ((stream->flags&GF_M2TS_ES_IS_PES) && stream->lang) {
 		char szLang4;
 		szLang0 = (stream->lang>>16) & 0xFF;
 		szLang1 = (stream->lang>>8) & 0xFF;
@@ -442,7 +515,20 @@
 		if (szLang2==' ') szLang2 = 0;
 		gf_filter_pid_set_property(opid, GF_PROP_PID_LANGUAGE, &PROP_STRING(szLang) );
 	}
+	if (codecid == GF_CODECID_DVB_SUBS) {
+		char szLang4;
+		memcpy(szLang, stream->sub.language, 3);
+		szLang3=0;
+		gf_filter_pid_set_property(opid, GF_PROP_PID_LANGUAGE, &PROP_STRING(szLang) );
 
+		u8 dsi5;
+		dsi0 = stream->sub.composition_page_id>>8;
+		dsi1 = stream->sub.composition_page_id & 0xFF;
+		dsi2 = stream->sub.ancillary_page_id>>8;
+		dsi3 = stream->sub.ancillary_page_id & 0xFF;
+		dsi4 = stream->sub.type;
+		gf_filter_pid_set_property(opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA(dsi, 5));
+	}
 
 	if (ctx->duration.num>1) {
 		gf_filter_pid_set_property(opid, GF_PROP_PID_DURATION, &PROP_FRAC64(ctx->duration) );
@@ -450,7 +536,7 @@
 	}
 	/*indicate our coding dependencies if any*/
 	if (!m4sys_stream) {
-		if (stream->depends_on_pid) {
+		if ((stream->flags&GF_M2TS_ES_IS_PES) && stream->depends_on_pid) {
 			gf_filter_pid_set_property(opid, GF_PROP_PID_DEPENDENCY_ID, &PROP_UINT(stream->depends_on_pid) );
 			if ((stream->stream_type == GF_M2TS_VIDEO_HEVC_TEMPORAL) || (stream->stream_type == GF_M2TS_VIDEO_HEVC_MCTS)) {
 				gf_filter_pid_set_property(opid, GF_PROP_PID_SUBLAYER, &PROP_BOOL(GF_TRUE) );
@@ -461,7 +547,7 @@
 		}
 	}
 
-	if (stream->dv_info0) {
+	if ((stream->flags & GF_M2TS_ES_IS_PES) && (stream->dv_info0)) {
 		gf_filter_pid_set_property(opid, GF_PROP_PID_DOLBY_VISION, &PROP_DATA(stream->dv_info, 24) );
 		u32 dvtype=0;
 		if (stream->dv_info24) {
@@ -540,25 +626,93 @@
 	GF_FilterPid *opid;
 	GF_FilterPacket *dst_pck;
 	u8 * data;
+	//we don't have end of frame signaling by default
+	Bool au_end = GF_FALSE;
+	GF_FilterSAPType sap_type = GF_FILTER_SAP_NONE;
 
 	/*pcr not initialized, don't send any data*/
 //	if (! pck->stream->program->first_dts) return;
 	if (!pck->stream->user) return;
 	opid = pck->stream->user;
 
-	dst_pck = gf_filter_pck_new_alloc(opid, pck->data_len, &data);
+	u8 *ptr = pck->data;
+	u32 len = pck->data_len;
+
+	//skip dataID and stream ID
+	if (pck->stream->stream_type==GF_M2TS_DVB_SUBTITLE) {
+		ptr+=2;
+		len-=2;
+	}
+	//for now GF_M2TS_ES_FULL_AU is only used for text, all rap
+	if (pck->stream->flags & GF_M2TS_ES_FULL_AU) {
+		au_end = GF_TRUE;
+		sap_type = GF_FILTER_SAP_1;
+	}
+
+	if (pck->stream->flags & GF_M2TS_CHECK_VC1) {
+		//extract seq header
+		u32 start, next, sc_size, sc_size2, sc_size3, hdr_len=0;
+
+		start = next = gf_media_nalu_next_start_code(ptr, len, &sc_size);
+		if ((next<len) && (ptrnext+sc_size==0x0F)) {
+			u32 ephdr = gf_media_nalu_next_start_code (ptr+next+sc_size, len-next-sc_size, &sc_size2);
+			if ((ephdr + next + sc_size < len) && (ptrnext+sc_size+ephdr+sc_size2==0x0E)) {
+				u32 end = gf_media_nalu_next_start_code (ptr+next+sc_size+ephdr+sc_size2, len-next-sc_size-ephdr-sc_size2, &sc_size3);
+				if (end + ephdr + next + sc_size + sc_size2 < len)
+					hdr_len = end + ephdr + sc_size2 + next + sc_size;
+			} else if ((ephdr + next + sc_size < len) && (ptrnext+sc_size+ephdr+sc_size2==0x0D)) {
+				hdr_len = ephdr + next + sc_size;
+			}
+		}
+		if (hdr_len) {
+			u8 *dsi=NULL;
+			u32 dsi_len;
+			ptr += start;
+			len -= start;
+			gf_media_vc1_seq_header_to_dsi(ptr, len, &dsi, &dsi_len);
+			if (dsi)
+				gf_filter_pid_set_property(opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, dsi_len));
+
+			ptr += hdr_len;
+			len -= hdr_len;
+			pck->stream->flags &= ~GF_M2TS_CHECK_VC1;
+		}
+	}
+
+
+	dst_pck = gf_filter_pck_new_alloc(opid, len, &data);
 	if (!dst_pck) return;
+	memcpy(data, ptr, len);
 
-	memcpy(data, pck->data, pck->data_len);
-	//we don't have end of frame signaling
-	gf_filter_pck_set_framing(dst_pck, (pck->flags & GF_M2TS_PES_PCK_AU_START) ? GF_TRUE : GF_FALSE, GF_FALSE);
+	gf_filter_pck_set_framing(dst_pck, (pck->flags & GF_M2TS_PES_PCK_AU_START) ? GF_TRUE : GF_FALSE, au_end);
 
 	if (pck->flags & GF_M2TS_PES_PCK_AU_START) {
+		if (pck->flags & GF_M2TS_PES_PCK_RAP)
+			sap_type = GF_FILTER_SAP_1;
+
 		gf_filter_pck_set_cts(dst_pck, pck->PTS);
 		if (pck->DTS != pck->PTS) {
 			gf_filter_pck_set_dts(dst_pck, pck->DTS);
 		}
-		gf_filter_pck_set_sap(dst_pck, (pck->flags & GF_M2TS_PES_PCK_RAP) ? GF_FILTER_SAP_1 : GF_FILTER_SAP_NONE);
+		gf_filter_pck_set_sap(dst_pck, sap_type);
+
+		if (pck->stream->flags & GF_M2TS_ES_IS_PES) {
+			GF_M2TS_PES *pes = (GF_M2TS_PES *)pck->stream;
+			if (pes->map_utc) {
+				s64 diff = pck->PTS;
+				diff -= pes->map_utc_pcr;
+				diff = gf_timestamp_rescale_signed(diff, 90000, 1000);
+				gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_UTC_TIME, &PROP_LONGUINT(pes->map_utc+diff) );
+				pes->map_utc=0;
+			}
+			if (pes->map_pcr) {
+				Double diff = (Double) pck->PTS;
+				diff -= pes->map_pcr;
+				diff /= 90000;
+				gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_MEDIA_TIME, &PROP_DOUBLE(ctx->media_start_range+diff) );
+				pes->map_pcr=0;
+			}
+		}
 	}
 	m2tdmx_merge_temi(opid, (GF_M2TS_ES *)pck->stream, dst_pck);
 
@@ -566,7 +720,9 @@
 		pck->stream->is_seg_start = GF_FALSE;
 		gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_CUE_START, &PROP_BOOL(GF_TRUE));
 	}
+
 	gf_filter_pck_send(dst_pck);
+	ctx->nb_stop_pending = 0;
 }
 
 static GF_M2TS_ES *m2tsdmx_get_m4sys_stream(GF_M2TSDmxCtx *ctx, u32 m4sys_es_id)
@@ -791,9 +947,8 @@
 			}
 			gf_filter_pck_send(dst_pck);
 
-			if (map_time) {
-				gf_filter_pid_set_info_str(stream->user, "time:timestamp", &PROP_LONGUINT(pcr) );
-				gf_filter_pid_set_info_str(stream->user, "time:media", &PROP_DOUBLE(ctx->media_start_range) );
+			if (map_time && (stream->flags & GF_M2TS_ES_IS_PES) ) {
+				((GF_M2TS_PES*)stream)->map_pcr = pcr;
 			}
 		}
 
@@ -814,13 +969,14 @@
 			u32 j, count2 = gf_list_count(prog->streams);
 			for (j=0; j<count2; j++) {
 				GF_M2TS_ES * stream = gf_list_get(prog->streams, j);
-				if (stream->user) {
-					gf_filter_pid_set_info(stream->user, GF_PROP_PID_UTC_TIME, & PROP_LONGUINT(utc_ts) );
-					gf_filter_pid_set_info(stream->user, GF_PROP_PID_UTC_TIMESTAMP, & PROP_LONGUINT(prog->last_pcr_value / 300) );
+				if (stream->user && (stream->flags & GF_M2TS_ES_IS_PES)) {
+					GF_M2TS_PES*pes = (GF_M2TS_PES*)stream;
+					pes->map_utc = utc_ts;
+					pes->map_utc_pcr = prog->last_pcr_value/300;
 				}
 			}
-			GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("M2TS In Mapping TDT Time %04d/%02d/%02d %02d:%02d:%02d and PCR time "LLD" on program %d\n",
-				 tdt->year, tdt->month, tdt->day, tdt->hour, tdt->minute, tdt->second, prog->last_pcr_value/300, prog->number));
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("M2TS In Mapping TDT Time %04d-%02d-%02dT%02d:%02d:%02d and PCR time "LLD" on program %d\n",
+				 tdt->year, tdt->month+1, tdt->day, tdt->hour, tdt->minute, tdt->second, prog->last_pcr_value/300, prog->number));
 		}
 	}
 		break;
@@ -952,17 +1108,10 @@
 
 	if (is_remove) {
 		ctx->ipid = NULL;
-		u32 i, count = gf_list_count(ctx->ts->programs);
+		u32 i, count = gf_filter_get_opid_count(filter);
 		for (i=0; i<count; i++) {
-			GF_M2TS_Program *prog = gf_list_get(ctx->ts->programs, i);
-			u32 j, count2 = gf_list_count(prog->streams);
-			for (j=0; j<count2; j++) {
-				GF_M2TS_ES *es = gf_list_get(prog->streams, j);
-				if (es->user) {
-					GF_FilterPid *opid = es->user;
-					gf_filter_pid_remove(opid);
-				}
-			}
+			GF_FilterPid *opid = gf_filter_get_opid(filter, i);
+			gf_filter_pid_remove( opid);
 		}
 		return GF_OK;
 	}
@@ -1089,6 +1238,8 @@
 	if (!com->base.on_pid) return GF_FALSE;
 	switch (com->base.type) {
 	case GF_FEVT_PLAY:
+		if (com->play.initial_broadcast_play==2)
+			return GF_TRUE;
 		pes = m2tsdmx_get_stream(ctx, com->base.on_pid);
 		if (!pes) {
 			if (com->base.on_pid == ctx->eit_pid) {
@@ -1105,8 +1256,20 @@
 
 		/*this is a multiplex, only trigger the play command for the first activated stream*/
 		ctx->nb_playing++;
-		if (ctx->nb_playing>1) return GF_TRUE;
 
+		if (ctx->nb_playing>1) {
+			Bool skip_com = GF_TRUE;
+			//PLAY/STOP may arrive at different times depending on the length of filter chains on each PID
+			//we stack number of STOP received and trigger seek when we have the same amount of play
+			if (ctx->nb_stop_pending==ctx->nb_playing) {
+				skip_com = GF_FALSE;
+			}
+			if (skip_com) {
+				return GF_TRUE;
+			}
+		}
+
+		ctx->nb_stop_pending = 0;
 		//not file, don't cancel the event
 		if (!ctx->is_file) {
 			ctx->initial_play_done = GF_TRUE;
@@ -1127,15 +1290,13 @@
 		if (!ctx->initial_play_done) {
 			ctx->initial_play_done = GF_TRUE;
 			//seek will not change the current source state, don't send a seek
-			if (!file_pos)
-				return GF_TRUE;
+			if (!file_pos) return GF_TRUE;
 		}
 
 		//file and seek, cancel the event and post a seek event to source
 		ctx->in_seek = GF_TRUE;
 		//we seek so consider the mux tuned in
 		ctx->mux_tune_state = DMX_TUNE_DONE;
-
 		//post a seek
 		GF_FEVT_INIT(fevt, GF_FEVT_SOURCE_SEEK, ctx->ipid);
 		fevt.seek.start_offset = file_pos;
@@ -1150,11 +1311,14 @@
 			}
 			return GF_FALSE;
 		}
-		/* In case of EOS, we may receive a stop command after no one is playing */
-		if (ctx->nb_playing)
-			ctx->nb_playing--;
-
 		gf_m2ts_set_pes_framing(pes, GF_M2TS_PES_FRAMING_SKIP);
+
+		if (com->play.initial_broadcast_play==2)
+			return GF_TRUE;
+
+		ctx->nb_stop_pending++;
+		if (ctx->nb_playing) ctx->nb_playing--;
+
 		//don't cancel event if still playing
 		return ctx->nb_playing ? GF_TRUE : GF_FALSE;
 
@@ -1229,17 +1393,24 @@
 	if (ctx->in_seek) {
 		gf_m2ts_reset_parsers(ctx->ts);
 		ctx->in_seek = GF_FALSE;
-	} else if (check_block) {
+	} else if (check_block && !ctx->wait_for_progs) {
 		u32 i, nb_streams, would_block = 0;
 		nb_streams = gf_filter_get_opid_count(filter);
 		for (i=0; i<nb_streams; i++) {
 			GF_FilterPid *opid = gf_filter_get_opid(filter, i);
-			if ( gf_filter_pid_would_block(opid) ) {
+			if (!gf_filter_pid_is_playing(opid)) {
+				would_block++;
+			} else if ( gf_filter_pid_would_block(opid) ) {
 				would_block++;
 			}
 		}
-		if (would_block && (would_block==nb_streams))
+		if (would_block && (would_block==nb_streams)) {
+			//keep filter alive
+			if (ctx->nb_playing) {
+				gf_filter_ask_rt_reschedule(filter, 0);
+			}
 			return GF_OK;
+		}
 
 		check_block = GF_FALSE;
 	}
@@ -1279,6 +1450,8 @@
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_SCENE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_METADATA),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_OD),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_PRIVATE_SCENE),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_ENCRYPTED),
@@ -1292,6 +1465,7 @@
 	{ OFFS(dsmcc), "enable DSMCC receiver", GF_PROP_BOOL, "no", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(seeksrc), "seek local source file back to origin once all programs are setup", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(sigfrag), "signal segment boundaries on output packets for DASH or HLS sources", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(dvbtxt), "export DVB teletext streams", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };

gpac-2.0.0.tar.gz/src/filters/dmx_nhml.c -> gpac-2.2.0.tar.gz/src/filters/dmx_nhml.c Changed

@@ -33,8 +33,6 @@
 #include <gpac/isomedia.h>
 #include <gpac/base_coding.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 #ifndef GPAC_DISABLE_AV_PARSERS
 #include <gpac/avparse.h>
 #endif
@@ -306,7 +304,7 @@
 		if (has_bs) {
 			GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 			prop_val.type = GF_PROP_DATA_NO_COPY;
-			gf_xml_parse_bit_sequence_bs(childnode, ctx->src_url, bs);
+			gf_xml_parse_bit_sequence_bs(childnode, ctx->src_url, NULL, bs);
 			gf_bs_get_content(bs, &prop_val.value.data.ptr, &prop_val.value.data.size);
 			gf_bs_del(bs);
 			reset = GF_FALSE;
@@ -409,7 +407,7 @@
 
 	xml = gf_fopen(xml_file, "rb");
 	if (!xml) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure: file %s not found", xml_file ));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure: file %s not found\n", xml_file ));
 		goto exit;
 	}
 	//we cannot use files with BOM since the XML position we get from the parser are offsets in the UTF-8 version of the XML.
@@ -418,7 +416,7 @@
 	if (read==3) {
 		gf_fseek(xml, 0, SEEK_SET);
 		if ((szBOM0==0xFF) || (szBOM0==0xFE) || (szBOM0==0xEF)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure: XML file %s uses unsupported BOM, please convert to plain UTF-8 or ANSI first", xml_file));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure: XML file %s uses unsupported BOM, please convert to plain UTF-8 or ANSI first\n", xml_file));
 			goto exit;
 		}
 	}
@@ -454,7 +452,7 @@
 		breaker.to_pos = gf_fsize(xml);
 	}
 	if (breaker.to_pos < breaker.from_pos) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure: xmlFrom %s is located after xmlTo %s", xmlFrom, xmlTo));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure: xmlFrom %s is located after xmlTo %s\n", xmlFrom, xmlTo));
 		goto exit;
 	}
 
@@ -688,7 +686,7 @@
 
 				if (url) gf_free(url);
 				if (e) {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Cannot open dictionary file %s: %s", att->value, gf_error_to_string(e) ));
+					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Cannot open dictionary file %s: %s\n", att->value, gf_error_to_string(e) ));
 					continue;
 				}
 			}
@@ -782,7 +780,7 @@
 
 	specInfoSize = 0;
 	if (!streamType && !mtype && !codec_tag) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx parsing %s file - StreamType or MediaType not specified", szImpName));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx parsing %s file - StreamType or MediaType not specified\n", szImpName));
 		return GF_NON_COMPLIANT_BITSTREAM;
 	}
 
@@ -810,7 +808,7 @@
 		ctx->samp_buffer_size = 0;
 		e = nhml_sample_from_xml(ctx, ctx->media_file, szXmlFrom, szXmlHeaderEnd);
 		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx failed to load XML header: %s", gf_error_to_string(e) ));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx failed to load XML header: %s\n", gf_error_to_string(e) ));
 			if (init_name) gf_free(init_name);
 			return e;
 		}
@@ -1005,7 +1003,7 @@
 	ctx->src_url = p->value.string;
 	nhml = gf_fopen(ctx->src_url, "rt");
 	if (!nhml) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Cannot find %s file %s", szImpName, ctx->src_url));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Cannot find %s file %s\n", szImpName, ctx->src_url));
 		return GF_URL_ERROR;
 	}
 
@@ -1027,14 +1025,14 @@
 	e = gf_xml_dom_parse(ctx->parser, p->value.string, NULL, NULL);
 	if (e) {
 		gf_fclose(nhml);
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Error parsing %s file: Line %d - %s", szImpName, gf_xml_dom_get_line(ctx->parser), gf_xml_dom_get_error(ctx->parser) ));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Error parsing %s file: Line %d - %s\n", szImpName, gf_xml_dom_get_line(ctx->parser), gf_xml_dom_get_error(ctx->parser) ));
 		return GF_NON_COMPLIANT_BITSTREAM;
 	}
 	gf_fclose(nhml);
 
 	ctx->root = gf_xml_dom_get_root(ctx->parser);
 	if (!ctx->root) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Error parsing %s file - no root node found", szImpName ));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Error parsing %s file - no root node found\n", szImpName ));
 		return GF_NON_COMPLIANT_BITSTREAM;
 	}
 
@@ -1254,7 +1252,7 @@
 						childnode = ref_sai;
 						goto retry_sai;
 					} else {
-						GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Cannot locate SAI with id %s, ignoring SAI", att->value));
+						GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Cannot locate SAI with id %s, ignoring SAI\n", att->value));
 						valid=GF_FALSE;
 					}
 				}
@@ -1267,7 +1265,7 @@
 		if (!valid) continue;
 
 		bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-		gf_xml_parse_bit_sequence_bs(childnode, ctx->src_url, bs);
+		gf_xml_parse_bit_sequence_bs(childnode, ctx->src_url, NULL, bs);
 
 		u8 *sai_data;
 		u32 sai_size;
@@ -1304,6 +1302,7 @@
 		u64 offset=0, byte_offset = GF_FILTER_NO_BO;
 		Bool redundant_rap, append, has_subbs;
 		u32 compress_type;
+		char *base_media_file = NULL;
 		char *base_data = NULL;
 		if (node->type) continue;
 		if (stricmp(node->name, ctx->is_dims ? "DIMSUnit" : "NHNTSample") ) {
@@ -1368,6 +1367,7 @@
 				} else if (!strnicmp(att->value, "gmem://", 7)) {
 					GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("NHMLDmx Invalid url %s for NHML import\n", att->value));
 				} else {
+					base_media_file = att->value;
 					char *url = gf_url_concatenate(ctx->src_url, att->value);
 					if (!url) {
 						GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("NHMLDmx Failed to get full url for %s\n", att->value));
@@ -1479,7 +1479,7 @@
 			if (strlen(szMediaTemp)) {
 				f = gf_fopen(szMediaTemp, "rb");
 				if (!f) {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure in sample %d: file %s not found", ctx->sample_num, close ? szMediaTemp : ctx->media_file));
+					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx import failure in sample %d: file %s not found\n", ctx->sample_num, close ? szMediaTemp : ctx->media_file));
 					return GF_NON_COMPLIANT_BITSTREAM;
 				}
 				close = GF_TRUE;
@@ -1490,12 +1490,14 @@
 				byte_offset = offset;
 			}
 
-			if (f) {
-				if (!ctx->samp_buffer_size) {
-					u64 ssize = gf_fsize(f);
-					assert(ssize < 0x80000000);
-					ctx->samp_buffer_size = (u32) ssize;
-				}
+			//use full file only if no subbs
+			if (!ctx->samp_buffer_size && !has_subbs && f) {
+				u64 ssize = gf_fsize(f);
+				assert(ssize < 0x80000000);
+				ctx->samp_buffer_size = (u32) ssize;
+			}
+
+			if (f && ctx->samp_buffer_size) {
 				gf_fseek(f, offset, SEEK_SET);
 
 				if (ctx->is_dims) {
@@ -1527,24 +1529,33 @@
 						GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Failed to fully read sample %d: dataLength %d read %d\n", ctx->sample_num, ctx->samp_buffer_size, read));
 					}
 				}
-				if (close) gf_fclose(f);
 			} else {
 				e = GF_OK;
 			}
+			if (f && close) gf_fclose(f);
 		}
 
 		if (e) return e;
 
 		//child BS present, parse them
 		if (has_subbs) {
-			nhml_get_bs(&ctx->bs_w, ctx->samp_buffer, ctx->samp_buffer_size, GF_BITSTREAM_WRITE);
+			u8 *output;
+			//we must create a tmp bitstream, we don't know how much we will write in the XML bit sequence
+			GF_BitStream *bs_tmp = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 			if (ctx->samp_buffer_size) {
-				gf_bs_seek(ctx->bs_w, ctx->samp_buffer_size);
+				gf_bs_write_data(bs_tmp, ctx->samp_buffer, ctx->samp_buffer_size);
 			}
-			gf_xml_parse_bit_sequence_bs(sample_child ? sample_child : node, ctx->src_url, ctx->bs_w);
-			gf_bs_get_content(ctx->bs_w, &ctx->samp_buffer, &ctx->samp_buffer_size);
-			if (ctx->samp_buffer_size > ctx->samp_buffer_alloc)
+			if (!base_media_file) base_media_file = ctx->media_file;
+			gf_xml_parse_bit_sequence_bs(sample_child ? sample_child : node, ctx->src_url, base_media_file, bs_tmp);
+			gf_bs_get_content(bs_tmp, &output, &ctx->samp_buffer_size);
+			gf_bs_del(bs_tmp);
+
+			if (ctx->samp_buffer_size > ctx->samp_buffer_alloc) {
 				ctx->samp_buffer_alloc = ctx->samp_buffer_size;
+				ctx->samp_buffer = gf_realloc(ctx->samp_buffer, ctx->samp_buffer_size);;
+			}
+			memcpy(ctx->samp_buffer, output, ctx->samp_buffer_size);
+			gf_free(output);
 		}
 		if (!ctx->samp_buffer_size) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("NHMLDmx No media file associated with sample %d!\n", ctx->sample_num));
@@ -1567,13 +1578,13 @@
 				gf_bs_write_u16(ctx->bs_w, ctx->samp_buffer_size-2);
 			}
 #else
-			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Error: your version of GPAC was compiled with no libz support. Abort."));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx Error: your version of GPAC was compiled with no libz support, aborting\n"));
 			return GF_NOT_SUPPORTED;
 #endif
 		}
 
 		if (ctx->is_dims && (ctx->samp_buffer_size > 0xFFFF)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx DIMS import failure: sample %d data is too long - maximum size allowed: 65532 bytes", ctx->sample_num));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("NHMLDmx DIMS import failure: sample %d data is too long - maximum size allowed: 65532 bytes\n", ctx->sample_num));
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
 		if (ctx->samp_buffer_size) {
@@ -1733,5 +1744,3 @@
 	return &NHMLDmxRegister;
 }
 
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
-

gpac-2.0.0.tar.gz/src/filters/dmx_ogg.c -> gpac-2.2.0.tar.gz/src/filters/dmx_ogg.c Changed

@@ -30,7 +30,6 @@
 
 #if !defined(GPAC_DISABLE_AV_PARSERS) && !defined(GPAC_DISABLE_OGG)
 #include <gpac/internal/ogg.h>
-#include <gpac/internal/isomedia_dev.h>
 //#include <ogg/ogg.h>
 #include <gpac/avparse.h>
 #include <gpac/base_coding.h>
@@ -72,7 +71,7 @@
 
 	GF_VorbisParser *vorbis_parser;
 
-	GF_OpusParser *opus_parser;
+	GF_OpusConfig *opus_cfg;
 } GF_OGGStream;
 
 typedef struct
@@ -98,6 +97,8 @@
 	ogg_sync_state oy;
 
 	GF_FilterPid *art_opid;
+
+	Bool is_dash;
 } GF_OGGDmxCtx;
 
 void oggdmx_signal_eos(GF_OGGDmxCtx *ctx)
@@ -209,36 +210,30 @@
 
 static void oggdmx_declare_pid(GF_Filter *filter, GF_OGGDmxCtx *ctx, GF_OGGStream *st)
 {
+	char szName20;
+	const char *st_name;
+	u32 id;
 	if (!st->opid) {
 		st->opid = gf_filter_pid_new(filter);
 	}
-//	gf_filter_pid_set_property(st->opid, GF_PROP_PID_ID, &PROP_UINT(st->serial_no) );
-	gf_filter_pid_set_property(st->opid, GF_PROP_PID_ID, &PROP_UINT(1 + gf_list_find(ctx->streams, st) ) );
+
+	id = 1 + gf_list_find(ctx->streams, st);
+	gf_filter_pid_set_property(st->opid, GF_PROP_PID_ID, &PROP_UINT(id ) );
 	gf_filter_pid_set_property(st->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(st->info.streamType) );
 	gf_filter_pid_set_property(st->opid, GF_PROP_PID_CODECID, &PROP_UINT(st->info.type) );
 	gf_filter_pid_set_property(st->opid, GF_PROP_PID_BITRATE, &PROP_UINT(st->info.bitrate) );
 	gf_filter_pid_set_property(st->opid, GF_PROP_PID_TIMESCALE, &PROP_UINT(st->info.sample_rate ? st->info.sample_rate : st->info.frame_rate.den) );
 	gf_filter_pid_set_property(st->opid, GF_PROP_PID_PROFILE_LEVEL, &PROP_UINT(0xFE) );
 
+	st_name = gf_stream_type_name(st->info.streamType);
+	sprintf(szName, "%c%d", st_name0, id);
+	gf_filter_pid_set_name(st->opid, szName);
+
 	//opus DSI is formatted as box (ffmpeg compat) we might want to change that to avoid the box header
 	if (st->info.type==GF_CODECID_OPUS) {
-		GF_OpusSpecificBox *opus = (GF_OpusSpecificBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_DOPS);
 		st->dsi_bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-		opus->version = 0;
-
-		opus->OutputChannelCount = st->opus_parser->OutputChannelCount;
-		opus->PreSkip = st->opus_parser->PreSkip;
-		opus->InputSampleRate = st->opus_parser->InputSampleRate;
-		opus->OutputGain = st->opus_parser->OutputGain;
-		opus->ChannelMappingFamily = st->opus_parser->ChannelMappingFamily;
-		opus->StreamCount = st->opus_parser->StreamCount;
-		opus->CoupledCount = st->opus_parser->CoupledCount;
-		memcpy(opus->ChannelMapping, st->opus_parser->ChannelMapping, sizeof(char)*255);
-		gf_isom_box_size((GF_Box *) opus);
-		gf_isom_box_write((GF_Box *) opus, st->dsi_bs);
-		gf_isom_box_del((GF_Box *) opus);
-
-		st->info.nb_chan = st->opus_parser->OutputChannelCount;
+		gf_odf_opus_cfg_write_bs(st->opus_cfg, st->dsi_bs);
+		st->info.nb_chan = st->opus_cfg->OutputChannelCount;
 	}
 
 	if (st->dsi_bs) {
@@ -322,7 +317,7 @@
 		GF_SAFEALLOC(st->vorbis_parser, GF_VorbisParser);
 		break;
 	case GF_CODECID_OPUS:
-		GF_SAFEALLOC(st->opus_parser, GF_OpusParser);
+		GF_SAFEALLOC(st->opus_cfg, GF_OpusConfig);
 		break;
 	default:
 		break;
@@ -384,11 +379,11 @@
 	u64 max_gran;
 	Bool has_stream = GF_FALSE;
 	GF_VorbisParser vp;
-	GF_OpusParser op;
+	GF_OpusConfig op;
 	u64 recompute_ts;
 	GF_Fraction64 dur;
 
-	if (!ctx->index || ctx->duration.num) return;
+	if (!ctx->index || ctx->duration.num || ctx->is_dash) return;
 
 	p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_FILE_CACHED);
 	if (p && p->value.boolean) ctx->file_loaded = GF_TRUE;
@@ -495,7 +490,8 @@
 			GF_OGGStream *st;
 			ctx->duration = dur;
 			while ( (st = gf_list_enum(ctx->streams, &i)) ) {
-				gf_filter_pid_set_property(st->opid, GF_PROP_PID_DURATION, & PROP_FRAC64(ctx->duration));
+				if (st->opid)
+					gf_filter_pid_set_property(st->opid, GF_PROP_PID_DURATION, & PROP_FRAC64(ctx->duration));
 			}
 		}
 	}
@@ -519,6 +515,7 @@
 		if (! ctx->is_file) {
 			return GF_FALSE;
 		}
+		if (evt->play.no_byterange_forward) ctx->is_dash = GF_TRUE;
 		oggdmx_check_dur(filter, ctx);
 
 
@@ -796,7 +793,7 @@
 					}
 					break;
 				case GF_CODECID_OPUS:
-					res = gf_opus_parse_header(st->opus_parser, (char *) oggpacket.packet, oggpacket.bytes);
+					res = gf_opus_parse_header(st->opus_cfg, (char *) oggpacket.packet, oggpacket.bytes);
 					if (!res) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("OGG Failed to parse Opus header\n"));
 					}
@@ -850,7 +847,7 @@
 						if (!block_size) continue;
 					}
 					else if (st->info.type==GF_CODECID_OPUS) {
-						block_size = gf_opus_check_frame(st->opus_parser, (char *) oggpacket.packet, oggpacket.bytes);
+						block_size = gf_opus_check_frame(st->opus_cfg, (char *) oggpacket.packet, oggpacket.bytes);
 						if (!block_size) {
 							if ((oggpacket.bytes>8) && !strnicmp(oggpacket.packet, "OpusTags", 8)) {
 								oggdmx_parse_tags(filter, st, oggpacket.packet + 8, oggpacket.bytes - 8);
@@ -861,7 +858,7 @@
 						if (!st->recomputed_ts) {
 							//compat with old arch (keep same hashes), to remove once dropping it
 							if (!gf_sys_old_arch_compat()) {
-								gf_filter_pid_set_property(st->opid, GF_PROP_PID_DELAY, &PROP_LONGSINT( -st->opus_parser->PreSkip));
+								gf_filter_pid_set_property(st->opid, GF_PROP_PID_DELAY, &PROP_LONGSINT( -st->opus_cfg->PreSkip));
 							}
 						}
 					}
@@ -927,7 +924,7 @@
 		ogg_stream_clear(&st->os);
 		if (st->dsi_bs) gf_bs_del(st->dsi_bs);
 		if (st->vorbis_parser) gf_free(st->vorbis_parser);
-		if (st->opus_parser) gf_free(st->opus_parser);
+		if (st->opus_cfg) gf_free(st->opus_cfg);
 		gf_free(st);
 	}
 	gf_list_del(ctx->streams);

gpac-2.0.0.tar.gz/src/filters/enc_png.c -> gpac-2.2.0.tar.gz/src/filters/enc_png.c Changed

gpac-2.0.0.tar.gz/src/filters/encrypt_cenc_isma.c -> gpac-2.2.0.tar.gz/src/filters/encrypt_cenc_isma.c Changed

@@ -46,7 +46,7 @@
 
 
 typedef enum {
-	CENC_FULL_SAMPLE,
+	CENC_FULL_SAMPLE=1,
 
 	/*below types may have several ranges (clear/encrypted) per sample*/
 	CENC_AVC, /*AVC, nalu-based*/
@@ -495,6 +495,16 @@
 		}
 
 		bs = gf_bs_new(specInfo, specInfoSize, GF_BITSTREAM_READ);
+		u32 bsize = gf_bs_read_u32(bs);
+		u32 btype = gf_bs_read_u32(bs);
+		if ((bsize==specInfoSize) && (btype == GF_ISOM_BOX_TYPE_PSSH)) {
+			version = gf_bs_read_u8(bs);
+			/*flags*/ gf_bs_read_int(bs, 24);
+		} else {
+			gf_bs_seek(bs, 0);
+			btype = 0;
+		}
+
 		gf_bs_read_data(bs, (char *)systemID, 16);
 		if (version) {
 			KID_count = gf_bs_read_u32(bs);
@@ -520,6 +530,7 @@
 			KID_count = 0;
 			KIDs = NULL;
 		}
+
 		if (specInfoSize < 16 + (version ? 4 + 16*KID_count : 0)) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("CENC/ISMA Invalid PSSH blob in version %d: size %d key count %d - ignoring PSSH\n", version, specInfoSize, KID_count));
 
@@ -528,7 +539,11 @@
 			if (KIDs) gf_free(KIDs);
 			continue;
 		}
-		len = specInfoSize - 16 - (version ? 4 + 16*KID_count : 0);
+		if (btype)
+			len = gf_bs_read_u32(bs);
+		else
+			len = specInfoSize - 16 - (version ? 4 + 16*KID_count : 0);
+
 		data = (char *)gf_malloc(len*sizeof(char));
 		if (!data) {
 			e = GF_OUT_OF_MEM;
@@ -710,6 +725,8 @@
 				if (!cstr->av1_state) return GF_OUT_OF_MEM;
 				break;
 			}
+		} else {
+			is_reinit = GF_FALSE;
 		}
 
 
@@ -967,6 +984,11 @@
 				}
 				memcpy(cstr->keys0.key, cstr->tci->keyscstr->kidx.key, 16);
 			}
+			GF_Err e = gf_crypt_init(cstr->keysi.crypt, cstr->keysi.key, cstr->tci->keysi.IV);
+			if (e) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("CENC Cannot initialize AES-128 %s\n", cstr->ctr_mode ? "CTR" : "CBC"));
+				return e;
+			}
 		}
 
 		cstr->prev_pck_encrypted = cstr->tci->IsEncrypted;
@@ -1023,6 +1045,9 @@
 	if (!cstr->tci->keys0.constant_IV_size || cstr->use_subsamples) {
 		gf_filter_pid_set_property(cstr->opid, GF_PROP_PID_CENC_STORE, &PROP_4CC(cstr->tci->sai_saved_box_type) );
 	}
+	if (cstr->tci->roll_type && (cstr->tci->roll_type!=GF_KEYROLL_PERIODS)) {
+		gf_filter_pid_set_property(cstr->opid, GF_PROP_PID_CENC_HAS_ROLL, &PROP_BOOL(GF_TRUE) );
+	}
 
 	//parse pssh even if reinit since we need to reassign pssh property
 	return cenc_parse_pssh(ctx, cstr, cfile_name);
@@ -1591,9 +1616,10 @@
 #if !defined(GPAC_DISABLE_HEVC)
 			u8 ntype, ntid, nlid;
 			cstr->hevc_state->full_slice_header_parse = GF_TRUE;
-			gf_hevc_parse_nalu(samp_data + nal_start, nal_size, cstr->hevc_state, &ntype, &ntid, &nlid);
+//			gf_hevc_parse_nalu(samp_data + nal_start, nal_size, cstr->hevc_state, &ntype, &ntid, &nlid);
+			gf_hevc_parse_nalu_bs(plaintext_bs, cstr->hevc_state, &ntype, &ntid, &nlid);
 			if (ntype<=GF_HEVC_NALU_SLICE_CRA) {
-				clear_bytes = cstr->hevc_state->s_info.payload_start_offset;
+				clear_bytes = cstr->hevc_state->s_info.payload_start_offset - nal_start;
 			} else {
 				clear_bytes = nal_size;
 			}
@@ -1601,13 +1627,16 @@
 		} else if (cstr->cenc_codec==CENC_VVC) {
 			u8 ntype, ntid, nlid;
 			cstr->vvc_state->parse_mode = 1;
-			gf_vvc_parse_nalu(samp_data + nal_start, nal_size, cstr->vvc_state, &ntype, &ntid, &nlid);
+//			gf_vvc_parse_nalu(samp_data + nal_start, nal_size, cstr->vvc_state, &ntype, &ntid, &nlid);
+			gf_vvc_parse_nalu_bs(plaintext_bs, cstr->vvc_state, &ntype, &ntid, &nlid);
 			if (ntype <= GF_VVC_NALU_SLICE_GDR) {
-				clear_bytes = cstr->vvc_state->s_info.payload_start_offset;
+				clear_bytes = cstr->vvc_state->s_info.payload_start_offset - nal_start;
 			} else {
 				clear_bytes = nal_size;
 			}
 		}
+		//reset EPB removal and seek to start of nal
+		gf_bs_enable_emulation_byte_removal(plaintext_bs, GF_FALSE);
 		gf_bs_seek(plaintext_bs, nal_start);
 	} else {
 		clear_bytes = bytes_in_nalhr;
@@ -2173,7 +2202,7 @@
 	}
 
 	if (cstr->pssh_template_plus_one) {
-		u32 key_idx = cstr->pssh_template_plus_one-1;
+		key_idx = cstr->pssh_template_plus_one-1;
 		cstr->pssh_template_plus_one = 0;
 
 		if (cstr->pssh_templates) {
@@ -2233,10 +2262,6 @@
 					GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("ISMACrypt Missing systemID, ignoring DRMInfoTemplate\n"));
 					continue;
 				}
-				if (!key_val) {
-					GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("ISMACrypt Missing keyval, ignoring DRMInfoTemplate\n"));
-					continue;
-				}
 
 				j=0;
 				while ((bs_node = gf_list_enum(pssh_tpl->content, &j))) {
@@ -2250,28 +2275,37 @@
 							kid_att = att;
 					}
 				}
+				if (key_att && !key_val) {
+					if (!pssh_tpl->orig_pos) {
+						GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("ISMACrypt Missing keyval, injecting key in clear\n"));
+						pssh_tpl->orig_pos = 1;
+					}
+				}
 
 				if (kid_att) {
 					kid_att_backup = kid_att->value;
 					kid_att->value = szKID;
 				}
 
-				if (key_val && key_att) {
-					bin128 master_key, leaf_key;
+				if (key_att) {
+					bin128 leaf_key;
 					key_att_backup = key_att->value;
-					gf_bin128_parse(key_val->value, master_key);
-					GF_Crypt *crypto = gf_crypt_open(GF_AES_128, crypt_mode);
-					if (iv_val) {
-						bin128 IV;
-						gf_bin128_parse(iv_val->value, IV);
-						gf_crypt_init(crypto, master_key, IV);
-					} else {
-						gf_crypt_init(crypto, master_key, NULL);
-					}
 					memcpy(leaf_key, cstr->tci->keyskey_idx.key, 16);
-					gf_crypt_encrypt(crypto, leaf_key, 16);
-					gf_crypt_close(crypto);
-
+					if (key_val) {
+						bin128 master_key;
+
+						gf_bin128_parse(key_val->value, master_key);
+						GF_Crypt *crypto = gf_crypt_open(GF_AES_128, crypt_mode);
+						if (iv_val) {
+							bin128 IV;
+							gf_bin128_parse(iv_val->value, IV);
+							gf_crypt_init(crypto, master_key, IV);
+						} else {
+							gf_crypt_init(crypto, master_key, NULL);
+						}
+						gf_crypt_encrypt(crypto, leaf_key, 16);
+						gf_crypt_close(crypto);
+					}
 					szCryptKey0=0;
 					for (j=0; j<16; j++) {
 						char szTmp3;
@@ -2643,6 +2677,14 @@
 const GF_FilterRegister *cenc_encrypt_register(GF_FilterSession *session)
 {
 #ifndef GPAC_DISABLE_CRYPTO
+
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) {
+		bin128 test;
+		cenc_gen_bin128(test);
+	}
+#endif
+
 	return &CENCEncRegister;
 #else
 	return NULL;

gpac-2.0.0.tar.gz/src/filters/ff_avf.c -> gpac-2.2.0.tar.gz/src/filters/ff_avf.c Changed

@@ -45,9 +45,10 @@
 {
 	AVFilterContext *io_filter_ctx;
 	GF_FilterPid *io_pid;
-	u32 timescale, pfmt, width, height, sr, nb_ch, bps;
+	u32 timescale, width, height, sr, nb_ch, bps;
 	Bool planar;
-	u64 ch_layout;
+	u32 pfmt; //ffmpeg pixel or audio format
+	u64 ch_layout; //ffmpeg channel layout
 	GF_Fraction sar;
 	u32 stride, stride_uv, nb_planes;
 	//output only
@@ -81,6 +82,9 @@
 	//0: no flush, 1: graph flush (push EOS in input), 2: wait for EOS in output
 	u32 flush_state;
 	GF_Err in_error;
+
+	u32 nb_playing;
+	Bool done;
 } GF_FFAVFilterCtx;
 
 
@@ -203,7 +207,7 @@
 		}
 		if (opid->is_video) {
 			if (ctx->pfmt) {
-				enum AVPixelFormat pfmt = ffmpeg_pixfmt_from_gpac(ctx->pfmt);
+				enum AVPixelFormat pfmt = ffmpeg_pixfmt_from_gpac(ctx->pfmt, GF_FALSE);
 				ret = av_opt_set_bin(opid->io_filter_ctx, "pix_fmts", (uint8_t*)&pfmt, sizeof(pfmt), AV_OPT_SEARCH_CHILDREN);
 				if (ret < 0) {
 					GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("FFAVF Fail to set %s pixel format: %s\n", avf->name, av_err2str(ret) ));
@@ -293,6 +297,21 @@
 		return GF_BAD_PARAM;
 	}
 
+	char *desc = NULL;
+	for (i=0; i<ctx->filter_graph->nb_filters; i++) {
+		AVFilterContext *avf = ctx->filter_graph->filtersi;
+		if (desc) {
+			char *sep = strstr(desc, avf->filter->name);
+			if (sep) {
+				u32 slen = (u32) strlen(avf->filter->name);
+				if ((sepslen==',') || !sepslen) continue;;
+			}
+		}
+		gf_dynstrcat(&desc, avf->filter->name, " ");
+	}
+	gf_filter_meta_set_instances(filter, desc);
+	gf_free(desc);
+
 	ctx->nb_inputs=0;
 	io = inputs;
 	while (io) {
@@ -335,7 +354,7 @@
 
 	/*update filter caps*/
 	memset(ctx->filter_caps, 0, sizeof(GF_FilterCapability) * 7);
-	ctx->filter_caps0.flags = GF_CAPS_INPUT_OUTPUT;
+	ctx->filter_caps0.flags = ctx->nb_inputs ? GF_CAPS_INPUT_OUTPUT : GF_CAPS_OUTPUT;
 	ctx->filter_caps0.code = GF_PROP_PID_CODECID;
 	ctx->filter_caps0.val = PROP_UINT(GF_CODECID_RAW);
 	i=1;
@@ -365,6 +384,11 @@
 	}
 	gf_filter_override_caps(filter, ctx->filter_caps, i);
 
+	if (!ctx->nb_inputs) {
+		ctx->configure_state = 1;
+		gf_filter_post_process_task(filter);
+		return ffavf_setup_outputs(filter, ctx);
+	}
 	return GF_OK;
 }
 
@@ -458,6 +482,8 @@
 
 	if (ctx->in_error)
 		return ctx->in_error;
+	if (ctx->done)
+		return GF_EOS;
 
 	//graph needs to be loaded
 	if (ctx->configure_state==1) {
@@ -467,6 +493,8 @@
 			return GF_OK;
 		return ffavf_setup_filter(filter, ctx);
 	}
+	if (!ctx->nb_playing)
+		return GF_OK;
 
 	//push input
 	nb_eos = 0;
@@ -594,6 +622,9 @@
 					nb_eos++;
 				} else if (nb_eos) {
 					gf_filter_pid_set_eos(opid->io_pid);
+				} else if (!ctx->nb_inputs) {
+					gf_filter_pid_set_eos(opid->io_pid);
+					nb_eos++;
 				}
 			} else if (ret != AVERROR(EAGAIN)) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFAVF Fail to pull frame from filtergaph: %s\n", av_err2str(ret) ));
@@ -693,8 +724,9 @@
 				update_props = GF_FALSE;
 			}
 			if (update_props) {
+				u64 gpac_ch_layout = ffmpeg_channel_layout_to_gpac(frame->channel_layout);
 				gf_filter_pid_set_property(opid->io_pid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(frame->sample_rate));
-				gf_filter_pid_set_property(opid->io_pid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT(frame->channel_layout));
+				gf_filter_pid_set_property(opid->io_pid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT(gpac_ch_layout));
 				gf_filter_pid_set_property(opid->io_pid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(frame->channels));
 				opid->gf_pfmt = ffmpeg_audio_fmt_to_gpac(frame->format);
 				gf_filter_pid_set_property(opid->io_pid, GF_PROP_PID_AUDIO_FORMAT, &PROP_UINT(opid->gf_pfmt));
@@ -735,7 +767,14 @@
 		if (nb_eos<count) return GF_OK;
 		return ffavf_reconfigure_graph(filter, ctx);
 	}
-	if (nb_eos) return GF_EOS;
+	if (nb_eos) {
+		if (ctx->nb_inputs) {
+			return GF_EOS;
+		} else if (nb_eos == count) {
+			ctx->done = GF_TRUE;
+			return GF_EOS;
+		}
+	}
 	return GF_OK;
 }
 
@@ -754,6 +793,23 @@
 	streamtype = p->value.uint;
 
 	pid_ctx = gf_filter_pid_get_udta(pid);
+
+	if (is_remove) {
+		if (pid_ctx) {
+			gf_filter_pid_set_udta(pid, NULL);
+			ctx->nb_inputs--;
+			if (!ctx->nb_inputs) {
+				ffavf_reset_graph(ctx);
+				while (gf_list_count(ctx->opids)) {
+					GF_FFAVPid *opid = gf_list_pop_back(ctx->opids);
+					//io_filter_ctx is destroyed while resetting the graph
+					gf_filter_pid_remove(opid->io_pid);
+					gf_free(opid);
+				}
+			}
+		}
+		return GF_OK;
+	}
 	if (!pid_ctx) {
 		GF_SAFEALLOC(pid_ctx, GF_FFAVPid);
 		if (!pid_ctx) return GF_OUT_OF_MEM;
@@ -786,7 +842,7 @@
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_PIXFMT);
 		if (!p) return GF_OK; //not ready yet
 		gf_pfmt = p->value.uint;
-		pix_fmt = ffmpeg_pixfmt_from_gpac(gf_pfmt);
+		pix_fmt = ffmpeg_pixfmt_from_gpac(gf_pfmt, GF_FALSE);
 
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAR);
 		if (p && p->value.frac.num && p->value.frac.den) sar = p->value.frac;
@@ -818,7 +874,7 @@
 		u64 ch_layout=0;
 		u32 sr, afmt, nb_ch;
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_CHANNEL_LAYOUT);
-		if (p) ch_layout = p->value.longuint;
+		if (p) ch_layout = ffmpeg_channel_layout_from_gpac(p->value.longuint);
 
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_NUM_CHANNELS);
 		if (!p) return GF_OK; //not ready yet
@@ -959,6 +1015,24 @@
 	return GF_NOT_FOUND;
 }
 
+static Bool ffavf_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
+{
+	GF_FFAVFilterCtx *ctx = gf_filter_get_udta(filter);
+
+	if (evt->base.type == GF_FEVT_PLAY) {
+		if (!ctx->nb_playing && !ctx->nb_inputs) ctx->done = GF_FALSE;
+		ctx->nb_playing++;
+	}
+	else if (evt->base.type == GF_FEVT_STOP) {
+		if (ctx->nb_playing) {
+			ctx->nb_playing--;
+			if (!ctx->nb_playing && !ctx->nb_inputs) ctx->done = GF_TRUE;
+		}
+	}
+
+	if (ctx->nb_inputs) return GF_FALSE;
+	return GF_TRUE;
+}
 
 static const GF_FilterCapability FFAVFilterCaps =
 {
@@ -983,6 +1057,12 @@
 		"\n"
 		"Unlike other FFMPEG bindings in GPAC, this filter does not parse other libavfilter options, you must specify them directly in the filter chain, and the -f() option will have to be escaped.\n"
 		"EX ffavf::f=showspectrum=size=320x320 or ffavf::f=showspectrum=size=320x320::pfmt=rgb\n"
+		"EX ffavf::f=anullsrc=channel_layout=5.1:sample_rate=48000\n"
+		"\n"
+		"For complex filter graphs, it is possible to store options in a file (e.g. `opts.txt`):\n"
+		"EX :f=anullsrc=channel_layout=5.1:sample_rate=48000\n"
+		"And load arguments from file:\n"
+		"EX ffavf:opts.txt aout\n"
 		"\n"
 		"The filter will automatically create `buffer` and `buffersink` AV filters for data exchange between GPAC and libavfilter.\n"
 		"The builtin options ( -pfmt(), -afmt() ...) can be used to configure the `buffersink` filter to set the output format of the filter.\n"
@@ -1012,13 +1092,14 @@
 		"- name#com_name=value: sends command `com_name` with value `value` to filter named `name`\n"
 		"\n"
 	)
-	.flags = GF_FS_REG_META | GF_FS_REG_EXPLICIT_ONLY | GF_FS_REG_ALLOW_CYCLIC,
+	.flags = GF_FS_REG_META | GF_FS_REG_EXPLICIT_ONLY | GF_FS_REG_ALLOW_CYCLIC | GF_FS_REG_TEMP_INIT,
 	.private_size = sizeof(GF_FFAVFilterCtx),
 	SETCAPS(FFAVFilterCaps),
 	.initialize = ffavf_initialize,
 	.finalize = ffavf_finalize,
 	.configure_pid = ffavf_configure_pid,
 	.process = ffavf_process,
+	.process_event = ffavf_process_event,
 	.update_arg = ffavf_update_arg,
 };
 
@@ -1040,8 +1121,7 @@
 
 const GF_FilterRegister *ffavf_register(GF_FilterSession *session)
 {
-	ffmpeg_build_register(session, &FFAVFilterRegister, FFAVFilterArgs, FFAVF_STATIC_ARGS, FF_REG_TYPE_AVF);
-	return &FFAVFilterRegister;
+	return ffmpeg_build_register(session, &FFAVFilterRegister, FFAVFilterArgs, FFAVF_STATIC_ARGS, FF_REG_TYPE_AVF);
 }
 
 #else

gpac-2.2.0.tar.gz/src/filters/ff_bsf.c Added

@@ -0,0 +1,458 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom Paris 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / ffmpeg avbitstreamfilter filter
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <gpac/setup.h>
+
+#ifdef GPAC_HAS_FFMPEG
+
+#include "ff_common.h"
+#include <gpac/network.h>
+
+#endif
+
+#ifdef FFMPEG_HAS_BSF
+
+typedef struct
+{
+	GF_PropStringList f;
+
+	GF_FilterPid *ipid, *opid;
+	//decode options
+	AVDictionary *options;
+
+	AVBSFContext *bsfc;
+
+	Bool flush_done, inject_cfg;
+	Bool passthrough;
+	u32 codec_id;
+	Bool gen_dsi;
+} GF_FFBSFCtx;
+
+
+static GF_Err ffbsf_init_bsf(GF_Filter *filter, u32 ff_codecid)
+{
+	int res;
+	u32 i, nb_filters=0;
+	AVBSFList *bs_list;
+
+	const AVBitStreamFilter *bsf;
+	GF_FFBSFCtx *ctx = (GF_FFBSFCtx *) gf_filter_get_udta(filter);
+
+	if (!ctx->f.nb_items) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFBSF Missing bitstream filter name\n"));
+		return GF_BAD_PARAM;
+	}
+
+	bs_list = av_bsf_list_alloc();
+	if (!bs_list) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFBSF Failed to allocate bitstream filter list\n"));
+		return GF_OUT_OF_MEM;
+	}
+	char *desc = NULL;
+	for (i=0; i<ctx->f.nb_items; i++) {
+		u32 k;
+		char *f = ctx->f.valsi;
+		bsf = av_bsf_get_by_name(f);
+		if (!bsf) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFBSF Unknown bitstream filter %s\n", f));
+			av_bsf_list_free(&bs_list);
+			return GF_BAD_PARAM;
+		}
+		if (!ff_codecid) {
+			//declare bsf name as not found option to track which BSFs are used
+			gf_filter_report_meta_option(filter, f, GF_FALSE, "f");
+			gf_dynstrcat(&desc, bsf->name, " ");
+			continue;
+		}
+
+		k=0;
+		while (bsf->codec_idsk!=AV_CODEC_ID_NONE) {
+			if (bsf->codec_idsk==ff_codecid) break;
+			k++;
+		}
+		if (bsf->codec_idsk==AV_CODEC_ID_NONE)
+			continue;
+
+		AVDictionary *options=NULL;
+		av_dict_copy(&options, ctx->options, 0);
+		res = av_bsf_list_append2(bs_list, f, &options);
+		if (res) {
+			if (options) av_dict_free(&options);
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFBSF Failed to allocate bitstream filter context %s: %s\n", f, av_err2str(res) ));
+			av_bsf_list_free(&bs_list);
+			return GF_BAD_PARAM;
+		}
+		ffmpeg_report_options(filter, options, ctx->options);
+		nb_filters++;
+
+		//declare bsf name as found option
+		gf_filter_report_meta_option(filter, f, GF_TRUE, "f");
+
+	}
+	if (!ff_codecid) {
+		av_bsf_list_free(&bs_list);
+
+		gf_filter_meta_set_instances(filter, desc);
+		gf_free(desc);
+		return GF_OK;
+	}
+
+	if (!nb_filters) {
+		AVDictionary *options=NULL;
+		av_dict_copy(&options, ctx->options, 0);
+		ffmpeg_report_options(filter, options, ctx->options);
+		ctx->passthrough = GF_TRUE;
+		av_bsf_list_free(&bs_list);
+		return GF_OK;
+	}
+
+	//finalize list
+	ctx->passthrough = GF_FALSE;
+	res = av_bsf_list_finalize(&bs_list, &ctx->bsfc);
+	av_bsf_list_free(&bs_list);
+	if (res) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFBSF Failed to finalize bitstream filter context: %s\n", av_err2str(res) ));
+		return GF_BAD_PARAM;
+	}
+	return GF_OK;
+}
+
+static GF_Err ffbsf_initialize(GF_Filter *filter)
+{
+	//just probe the bsf names
+	return ffbsf_init_bsf(filter, 0);
+}
+
+
+static GF_Err ffbsf_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
+{
+	GF_FFBSFCtx *ctx = (GF_FFBSFCtx *) gf_filter_get_udta(filter);
+	u32 codec;
+	GF_Err e;
+	Bool check_reconf = GF_FALSE;
+	if (is_remove) {
+		if (ctx->opid) {
+			gf_filter_pid_remove(ctx->opid);
+			ctx->opid = NULL;
+		}
+		return GF_OK;
+	}
+	ctx->ipid = pid;
+	const GF_PropertyValue *p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+	if (!p) return GF_BAD_PARAM;
+
+	u32 ff_ctag;
+	codec = p->value.uint;
+	u32 cid = ffmpeg_codecid_from_gpac(codec, &ff_ctag);
+	if (cid == 0) return GF_FILTER_NOT_SUPPORTED;
+	//reevaluate if change of codec id
+	if (ctx->codec_id != codec) {
+		ctx->codec_id = codec;
+		if (ctx->bsfc) {
+			av_bsf_free(&ctx->bsfc);
+			ctx->bsfc = NULL;
+		}
+	}
+
+retry:
+	//we can instantiate now that we have a codec id
+	if (!ctx->bsfc) {
+		e = ffbsf_init_bsf(filter, cid);
+		if (e) return GF_FILTER_NOT_SUPPORTED;
+	}
+
+	if (!ctx->opid) {
+		ctx->opid = gf_filter_pid_new(filter);
+		if (!ctx->opid) return GF_OUT_OF_MEM;
+	}
+	gf_filter_pid_copy_properties(ctx->opid, ctx->ipid);
+
+	if (ctx->passthrough) return GF_OK;
+
+	ctx->bsfc->par_in->codec_id = cid;
+	ctx->bsfc->par_in->codec_tag = ff_ctag;
+	e = ffmpeg_codec_par_from_gpac(ctx->ipid, ctx->bsfc->par_in, 0);
+	if (e) return e;
+
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+	if (p) {
+		ffmpeg_extradata_from_gpac(codec, p->value.data.ptr, p->value.data.size, &ctx->bsfc->par_in->extradata, &ctx->bsfc->par_in->extradata_size);
+	}
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+	if (p) {
+		ctx->bsfc->time_base_in.num = 1;
+		ctx->bsfc->time_base_in.den = p->value.uint;
+	}
+
+	//init
+	int ret = av_bsf_init(ctx->bsfc);
+	if (ret<0) {
+		av_bsf_free(&ctx->bsfc);
+		ctx->bsfc = NULL;
+		if (!check_reconf) {
+			check_reconf = GF_TRUE;
+			goto retry;
+		}
+		return GF_FILTER_NOT_SUPPORTED;
+	}
+
+	codec = ffmpeg_codecid_to_gpac(ctx->bsfc->par_out->codec_id);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(codec));
+
+	ffmpeg_codec_par_to_gpac(ctx->bsfc->par_out, ctx->opid, 0);
+
+
+	ctx->gen_dsi = GF_FALSE;
+
+	//even if given size-prefixed format, bsfilters always return annexB, we force a reframer (as with ffenc output) ...
+	switch (codec) {
+	case GF_CODECID_AVC:
+	case GF_CODECID_SVC:
+	case GF_CODECID_MVC:
+	case GF_CODECID_HEVC:
+	case GF_CODECID_LHVC:
+	case GF_CODECID_VVC:
+	case GF_CODECID_AV1:
+		if (ctx->bsfc->par_out->extradata_size) {
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE));
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED_FULL_AU, &PROP_BOOL(GF_TRUE) );
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, NULL);
+			ctx->inject_cfg = GF_TRUE;
+		}
+		break;
+
+	//for these, we will need to generate dsi from first frame - this avoids using reframers only for DSI extraction
+	case GF_CODECID_MPEG1:
+	case GF_CODECID_MPEG2_422:
+	case GF_CODECID_MPEG2_SNR:
+	case GF_CODECID_MPEG2_HIGH:
+	case GF_CODECID_MPEG2_MAIN:
+	case GF_CODECID_MPEG2_SIMPLE:
+	case GF_CODECID_MPEG2_SPATIAL:
+	case GF_CODECID_MPEG4_PART2:
+	case GF_CODECID_VP8:
+	case GF_CODECID_VP9:
+	case GF_CODECID_VP10:
+	case GF_CODECID_AC3:
+	case GF_CODECID_EAC3:
+	case GF_CODECID_TRUEHD:
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, NULL);
+		ctx->gen_dsi = GF_TRUE;
+		break;
+
+	default:
+		if (ctx->bsfc->par_out->extradata) {
+			u8 *dsi;
+			u32 size;
+			ffmpeg_extradata_to_gpac(codec, ctx->bsfc->par_out->extradata, ctx->bsfc->par_out->extradata_size, &dsi, &size);
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, size));
+		}
+		break;
+	}
+	return GF_OK;
+}
+
+
+static GF_Err ffbsf_process(GF_Filter *filter)
+{
+	GF_FFBSFCtx *ctx = (GF_FFBSFCtx *) gf_filter_get_udta(filter);
+
+	if (!ctx->ipid) return GF_BAD_PARAM;
+	while (1) {
+		GF_FilterPacket *src = gf_filter_pid_get_packet(ctx->ipid);
+		if (!src) {
+			if (gf_filter_pid_is_eos(ctx->ipid)) {
+				if (ctx->flush_done || ctx->passthrough) {
+					gf_filter_pid_set_eos(ctx->opid);
+					return GF_EOS;
+				}
+			} else {
+				return GF_OK;
+			}
+		}
+		if (ctx->passthrough) {
+			gf_filter_pck_forward(src, ctx->opid);
+			gf_filter_pid_drop_packet(ctx->ipid);
+			continue;
+		}
+		if (!ctx->bsfc) return GF_BAD_PARAM;
+
+		AVPacket *avpck = av_packet_alloc();
+		if (src) {
+			u32 size;
+			const u8 *data = gf_filter_pck_get_data(src, &size);
+			avpck->size = size;
+			avpck->data = av_malloc(size+8);
+			memcpy(avpck->data, data, size);
+			avpck->dts = gf_filter_pck_get_dts(src);
+			avpck->pts = gf_filter_pck_get_cts(src);
+			avpck->duration = gf_filter_pck_get_duration(src);
+			u32 sap = gf_filter_pck_get_sap(src);
+			if (sap==GF_FILTER_SAP_1) avpck->flags = AV_PKT_FLAG_KEY;
+		}
+		av_bsf_send_packet(ctx->bsfc, avpck);
+
+		int res;
+		while (1) {
+			avpck = av_packet_alloc();
+			res = av_bsf_receive_packet(ctx->bsfc, avpck);
+			if (res<0) {
+				av_packet_unref(avpck);
+				break;
+			}
+			u8 *output;
+			u32 size = avpck->size;
+			if (ctx->inject_cfg)
+				size+=ctx->bsfc->par_out->extradata_size;
+			GF_FilterPacket *dst = gf_filter_pck_new_alloc(ctx->opid, size, &output);
+			if (ctx->inject_cfg) {
+				memcpy(output, ctx->bsfc->par_out->extradata, ctx->bsfc->par_out->extradata_size);
+				output += ctx->bsfc->par_out->extradata_size;
+				ctx->inject_cfg = GF_FALSE;
+			}
+			memcpy(output, avpck->data, avpck->size);
+
+			if (ctx->gen_dsi) {
+				ffmpeg_generate_gpac_dsi(ctx->opid, ctx->codec_id, ctx->bsfc->par_out->color_primaries, ctx->bsfc->par_out->color_trc, ctx->bsfc->par_out->color_space, output, size);
+				ctx->gen_dsi = GF_FALSE;
+			}
+
+			//set sap first, and copy over src props
+			gf_filter_pck_set_sap(dst, (avpck->flags & AV_PKT_FLAG_KEY) ? GF_FILTER_SAP_1 : GF_FILTER_SAP_NONE);
+			if (src)
+				gf_filter_pck_merge_properties(src, dst);
+
+			gf_filter_pck_set_cts(dst, avpck->pts);
+			gf_filter_pck_set_dts(dst, avpck->dts);
+			gf_filter_pck_set_duration(dst, (u32) avpck->duration);
+
+			gf_filter_pck_send(dst);
+
+			av_packet_unref(avpck);
+		}
+		if (src)
+			gf_filter_pid_drop_packet(ctx->ipid);
+
+		if (res == AVERROR(EAGAIN)) continue;
+		if (res == AVERROR_EOF) {
+			if (!src) {
+				ctx->flush_done = GF_TRUE;
+				return GF_EOS;
+			}
+			break;
+		}
+		if (res<0) return GF_SERVICE_ERROR;
+	}
+
+	return GF_OK;
+}
+
+
+
+static void ffbsf_finalize(GF_Filter *filter)
+{
+	GF_FFBSFCtx *ctx = (GF_FFBSFCtx *) gf_filter_get_udta(filter);
+	if (ctx->bsfc)
+		av_bsf_free(&ctx->bsfc);
+	return;
+}
+
+static GF_Err ffbsf_update_arg(GF_Filter *filter, const char *arg_name, const GF_PropertyValue *arg_val)
+{
+	GF_FFBSFCtx *ctx = gf_filter_get_udta(filter);
+	return ffmpeg_update_arg("FFBSF", ctx->bsfc, &ctx->options, arg_name, arg_val);
+}
+
+static Bool ffbsf_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
+{
+	GF_FFBSFCtx *ctx = gf_filter_get_udta(filter);
+	if (evt->base.type== GF_FEVT_STOP) {
+		if (ctx->bsfc) av_bsf_flush(ctx->bsfc);
+	}
+	return GF_FALSE;
+}
+
+//for now we only accept compressed inputs
+static const GF_FilterCapability FFBSFCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT|GF_CAPFLAG_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
+	{0},
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT|GF_CAPFLAG_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
+};
+
+GF_FilterRegister FFBSFRegister = {
+	.name = "ffbsf",
+	.version = LIBAVCODEC_IDENT,
+	GF_FS_SET_DESCRIPTION("FFMPEG BitStream filter")
+	GF_FS_SET_HELP("This filter provides bitstream filters (BSF) for compressed audio and video formats.\n"
+		"See FFMPEG documentation (https://ffmpeg.org/documentation.html) for more details\n"
+		"To list all supported bitstream filters for your GPAC build, use `gpac -h ffbsf:*`.\n"
+		"\n"
+		"Several BSF may be specified in -f() for different coding types. BSF not matching the coding type are silently ignored.\n"
+		"When no BSF matches the input coding type, or when -f() is empty, the filter acts as a passthrough filter.\n"
+		"\n"
+		"Options are specified after the desired filters:\n"
+		"- `ffbsf:f=h264_metadata:video_full_range_flag=0`\n"
+		"- `ffbsf:f=h264_metadata,av1_metadata:video_full_range_flag=0:color_range=tv`\n"
+		"\n"
+		"Note: Using BSFs on some media types (e.g. avc, hevc) may trigger creation of a reframer filter (e.g. rfnalu)\n"
+	)
+	.flags = GF_FS_REG_META | GF_FS_REG_EXPLICIT_ONLY,
+	.private_size = sizeof(GF_FFBSFCtx),
+	SETCAPS(FFBSFCaps),
+	.initialize = ffbsf_initialize,
+	.finalize = ffbsf_finalize,
+	.configure_pid = ffbsf_configure_pid,
+	.process = ffbsf_process,
+	.update_arg = ffbsf_update_arg,
+	.process_event = ffbsf_process_event
+};
+
+#define OFFS(_n)	#_n, offsetof(GF_FFBSFCtx, _n)
+
+static const GF_FilterArgs FFBSFArgs =
+{
+	{ OFFS(f), "bitstream filters name - see filter help", GF_PROP_STRING_LIST, NULL, NULL, 0},
+	{ "*", -1, "any possible options defined for AVBitstreamFilter and sub-classes. See `gpac -hx ffbsf` and `gpac -hx ffbsf:*`", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_META},
+	{0}
+};
+
+const int FFBSF_STATIC_ARGS = (sizeof (FFBSFArgs) / sizeof (GF_FilterArgs)) - 1;
+
+const GF_FilterRegister *ffbsf_register(GF_FilterSession *session)
+{
+	return ffmpeg_build_register(session, &FFBSFRegister, FFBSFArgs, FFBSF_STATIC_ARGS, FF_REG_TYPE_BSF);
+}
+
+#else //FFMPEG_HAS_BSF
+
+#include <gpac/filters.h>
+const GF_FilterRegister *ffbsf_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+#endif

gpac-2.0.0.tar.gz/src/filters/ff_common.c -> gpac-2.2.0.tar.gz/src/filters/ff_common.c Changed

@@ -30,6 +30,8 @@
 #include "ff_common.h"
 
 #include <libavfilter/avfilter.h>
+#include <gpac/isomedia.h>
+#include <gpac/internal/media_dev.h>
 
 #if !defined(__GNUC__)
 # if defined(_WIN32_WCE) || defined (WIN32)
@@ -49,10 +51,123 @@
 {
 	GF_List *all_filters;
 	u32 nb_arg_skip;
+	Bool free_help;
+	Bool is_building;
 } GF_FFRegistryExt;
 
 typedef struct
 {
+	const char *ff_name;
+	u32 gpac_p4cc;
+	u32 gpac_tag;
+} GF_FF_TAGREG;
+
+static const GF_FF_TAGREG FF2GPAC_Tags =
+{
+	{"album", 0, GF_ISOM_ITUNE_ALBUM},
+	{"album_artist", 0, GF_ISOM_ITUNE_ALBUM_ARTIST},
+	{"artist", 0, GF_ISOM_ITUNE_ARTIST},
+	{"comment", 0, GF_ISOM_ITUNE_ALBUM_ARTIST},
+	{"composer", 0, GF_ISOM_ITUNE_COMPOSER},
+	{"copyright", 0, GF_ISOM_ITUNE_COPYRIGHT},
+//	{"creation_time", 0, 0},
+	{"date", 0, GF_ISOM_ITUNE_CREATED},
+	{"disc", 0, GF_ISOM_ITUNE_DISK},
+	{"encoder", 0, GF_ISOM_ITUNE_TOOL},
+	{"encoded_by", 0, GF_ISOM_ITUNE_ENCODER},
+	{"genre", 0, GF_ISOM_ITUNE_GENRE},
+	{"language", GF_PROP_PID_LANGUAGE, 0},
+	{"performer", 0, GF_ISOM_ITUNE_PERFORMER},
+	{"service_name", GF_PROP_PID_SERVICE_NAME, 0},
+	{"service_provider", GF_PROP_PID_SERVICE_PROVIDER, 0},
+	{"title", 0, GF_ISOM_ITUNE_NAME},
+	{"track", 0, GF_ISOM_ITUNE_TRACK},
+	{NULL, 0, 0}
+};
+
+void ffmpeg_tags_from_gpac(GF_FilterPid *pid, AVDictionary **metadata)
+{
+	const GF_PropertyValue *p;
+	u32 i=0;
+	while (FF2GPAC_Tagsi.ff_name) {
+		p = NULL;
+		if (FF2GPAC_Tagsi.gpac_p4cc) {
+			p = gf_filter_pid_get_property(pid, FF2GPAC_Tagsi.gpac_p4cc);
+		} else {
+			const char *name = gf_itags_get_name(FF2GPAC_Tagsi.gpac_tag);
+			if (name)
+				p = gf_filter_pid_get_property_str(pid, name);
+		}
+		if (p) {
+			switch (p->type) {
+			case GF_PROP_NAME:
+			case GF_PROP_STRING:
+				if (p->value.string)
+					av_dict_set(metadata, FF2GPAC_Tagsi.ff_name, p->value.string, 0);
+				break;
+			default:
+				break;
+			}
+		}
+		i++;
+	}
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ISOM_HANDLER);
+	if (p && (p->type==GF_PROP_STRING) && p->value.string && !strstr(p->value.string, "@GPAC")) {
+		av_dict_set(metadata, "title", p->value.string, 0);
+	}
+}
+
+void ffmpeg_tags_to_gpac(AVDictionary *metadata, GF_FilterPid *pid)
+{
+	AVDictionaryEntry *ent=NULL;
+	while (metadata) {
+		ent = av_dict_get(metadata, "", ent, AV_DICT_IGNORE_SUFFIX);
+		if (!ent) break;
+		if (!strncmp(ent->key, "NUMBER_OF_FRAMES", 16)) {
+			gf_filter_pid_set_property(pid, GF_PROP_PID_NB_FRAMES, &PROP_UINT( atoi(ent->value) ) );
+			continue;
+		}
+		if (!strncmp(ent->key, "_STATISTICS_WRITING_APP", 23)) {
+			gf_filter_pid_set_property_str(pid, "tool", &PROP_STRING(ent->value));
+			continue;
+		}
+		if (!strncmp(ent->key, "_STATISTICS_WRITING_DATE_UTC", 28)) {
+			gf_filter_pid_set_property_str(pid, "created_utc", &PROP_STRING(ent->value));
+			continue;
+		}
+		Bool found=GF_FALSE;
+		u32 i=0;
+		while (FF2GPAC_Tagsi.ff_name) {
+			if (strcmp(FF2GPAC_Tagsi.ff_name, ent->key)) {
+				i++;
+				continue;
+			}
+			if (FF2GPAC_Tagsi.gpac_p4cc) {
+				gf_filter_pid_set_property(pid, FF2GPAC_Tagsi.gpac_p4cc, &PROP_STRING(ent->value) );
+			} else {
+				const char *name = gf_itags_get_name(FF2GPAC_Tagsi.gpac_tag);
+				if (name)
+					gf_filter_pid_set_property_str(pid, name, &PROP_STRING(ent->value));
+				if (FF2GPAC_Tagsi.gpac_tag == GF_ISOM_ITUNE_NAME)
+					gf_filter_pid_set_property(pid, GF_PROP_PID_ISOM_HANDLER, &PROP_STRING(ent->value) );
+			}
+			found = GF_TRUE;
+			break;
+		}
+		if (!found && stricmp(ent->key, "duration")) {
+			char *name=NULL;
+			gf_dynstrcat(&name, "meta:", NULL);
+			gf_dynstrcat(&name, ent->key, NULL);
+			if (name) {
+				gf_filter_pid_set_property_dyn(pid, name, &PROP_STRING(ent->value) );
+				gf_free(name);
+			}
+		}
+	}
+}
+
+typedef struct
+{
 	u32 ff_pf;
 	u32 gpac_pf;
 	u32 flags; //only 1 used, for full range
@@ -112,7 +227,7 @@
 	{0},
 };
 
-u32 ffmpeg_pixfmt_from_gpac(u32 pfmt)
+enum AVPixelFormat ffmpeg_pixfmt_from_gpac(u32 pfmt, Bool no_warn)
 {
 	u32 i=0;
 	while (FF2GPAC_PixelFormatsi.gpac_pf) {
@@ -120,11 +235,13 @@
 			return FF2GPAC_PixelFormatsi.ff_pf;
 		i++;
 	}
-	GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("FFMPEG Unmapped GPAC pixel format %s, patch welcome\n", gf_4cc_to_str(pfmt) ));
-	return 0;
+	if (!no_warn) {
+		GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("FFMPEG Unmapped GPAC pixel format %s, patch welcome\n", gf_4cc_to_str(pfmt) ));
+	}
+	return AV_PIX_FMT_NONE;
 }
 
-u32 ffmpeg_pixfmt_to_gpac(u32 pfmt, Bool no_warn)
+u32 ffmpeg_pixfmt_to_gpac(enum AVPixelFormat pfmt, Bool no_warn)
 {
 	const AVPixFmtDescriptor *ffdesc = av_pix_fmt_desc_get(pfmt);
 	if (!ffdesc) {
@@ -376,11 +493,20 @@
 #ifdef FFMPEG_ENABLE_VVC
 	{AV_CODEC_ID_VVC, GF_CODECID_VVC, 0},
 #endif
-
-	{AV_CODEC_ID_V210, GF_CODECID_V210, 0},
-
 	{AV_CODEC_ID_TRUEHD, GF_CODECID_TRUEHD, 0},
 	{AV_CODEC_ID_FFV1, GF_CODECID_FFV1, 0},
+
+	{AV_CODEC_ID_SUBRIP, GF_CODECID_SUBS_TEXT, 0},
+	{AV_CODEC_ID_SUBRIP, GF_CODECID_SIMPLE_TEXT, 0},
+	{AV_CODEC_ID_TEXT, GF_CODECID_SIMPLE_TEXT, 0},
+	{AV_CODEC_ID_WEBVTT, GF_CODECID_WEBVTT, 0},
+	{AV_CODEC_ID_SSA, GF_CODECID_SUBS_SSA, 0},
+	{AV_CODEC_ID_ASS, GF_CODECID_SUBS_SSA, 0},
+	{AV_CODEC_ID_DVB_SUBTITLE, GF_CODECID_DVB_SUBS, 0},
+	{AV_CODEC_ID_DVB_TELETEXT, GF_CODECID_DVB_TELETEXT, 0},
+	{AV_CODEC_ID_MSMPEG4V3, GF_CODECID_MSPEG4_V3, 0},
+	{AV_CODEC_ID_DTS, GF_CODECID_DTS_CA, 0},
+	{AV_CODEC_ID_ALAC, GF_CODECID_ALAC, 0},
 	{0}
 };
 
@@ -396,6 +522,14 @@
 		}
 		i++;
 	}
+	//try unmapped codecs
+	if (gf_codecid_type(codec_id)==GF_STREAM_UNKNOWN) {
+		const AVCodec *c = avcodec_find_decoder(codec_id);
+		if (c) return c->id;
+		c = avcodec_find_decoder_by_name(gf_4cc_to_str(codec_id));
+		if (c) return c->id;
+	}
+
 	GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("FFMPEG Unmapped GPAC codec %s\n", gf_codecid_name(codec_id) ));
 	return 0;
 }
@@ -486,7 +620,7 @@
 
 static GF_LOG_Tool gpac_to_ffmpeg_log_tool(AVClass* avc)
 {
-	if (!avc) return GF_LOG_CORE;
+	if (!avc) return GF_LOG_MEDIA;
 	switch (avc->category) {
 	case AV_CLASS_CATEGORY_INPUT:
 	case AV_CLASS_CATEGORY_OUTPUT:
@@ -511,7 +645,7 @@
 	case AV_CLASS_CATEGORY_DEVICE_INPUT:
 		return GF_LOG_MMIO;
 	default:
-		return GF_LOG_CORE;
+		return GF_LOG_MEDIA;
 	}
 }
 
@@ -567,12 +701,23 @@
 
 }
 
+void ffmpeg_register_set_dyn_help(GF_FilterRegister *reg)
+{
+	GF_FFRegistryExt *ffregext = reg->udta;
+	if (ffregext) ffregext->free_help = GF_TRUE;
+}
 static void ffmpeg_register_free(GF_FilterSession *session, GF_FilterRegister *reg)
 {
 	u32 i;
 	GF_FFRegistryExt *ffregext = reg->udta;
 	GF_List *all_filters = ffregext->all_filters;
 	u32 nb_skip_begin = ffregext->nb_arg_skip;
+	if (ffregext->is_building) return;
+
+#if !defined(GPAC_DISABLE_DOC)
+	if (ffregext->free_help)
+		gf_free((char *)reg->help);
+#endif
 	gf_free(ffregext);
 	reg->udta = NULL;
 
@@ -608,7 +753,7 @@
 		if (arg->flags & GF_FS_ARG_META_ALLOC) gf_free((void *) arg->arg_desc);
 	}
 	if (reg->args) gf_free((void *) reg->args);
-
+	gf_free(reg);
 }
 
 GF_FilterArgs ffmpeg_arg_translate(const struct AVOption *opt)
@@ -623,6 +768,9 @@
 	if (opt->name0 == 0)
 		arg.flags = GF_FS_ARG_META;
 
+	if (!(opt->flags & AV_OPT_FLAG_READONLY))
+		arg.flags |= GF_FS_ARG_UPDATE;
+
 	switch (opt->type) {
 	case AV_OPT_TYPE_INT64:
 	case AV_OPT_TYPE_INT:
@@ -724,6 +872,12 @@
 		arg.min_max_enum = enum_val;
 		}
 		break;
+#if AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, LIBAVUTIL_VERSION_MINOR, 0) > AV_VERSION_INT(57,23, 0)
+	case AV_OPT_TYPE_CHLAYOUT:
+		arg.arg_type = GF_PROP_STRING;
+		arg.arg_default_val = gf_strdup(opt->default_val.str ? opt->default_val.str : "mono");
+		break;
+#endif
 	default:
 		GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("FFMPEG Unknown ffmpeg option type %d\n", opt->type));
 		break;
@@ -758,9 +912,15 @@
 	const AVInputFormat *fmt = NULL;
 	const AVOutputFormat *ofmt = NULL;
 	const AVCodec *codec = NULL;
+#ifdef FFMPEG_HAS_BSF
+	const AVBitStreamFilter *bsf = NULL;
+#endif
 #if (LIBAVFILTER_VERSION_MAJOR > 5)
 	const AVFilter *avf = NULL;
 #endif
+#if (LIBAVCODEC_VERSION_MAJOR >= 58) && (LIBAVCODEC_VERSION_MINOR>=20)
+	Bool audio_pass = GF_FALSE;
+#endif
 
 #if !defined(NO_AVIO_PROTO) || (LIBAVFILTER_VERSION_MAJOR > 6) || (LIBAVFORMAT_VERSION_MAJOR >= 59)
 	void *av_it = NULL;
@@ -787,6 +947,11 @@
 	else if (type==FF_REG_TYPE_AVF) {
 		fname = "ffavf";
 	}
+#ifdef FFMPEG_HAS_BSF
+	else if (type==FF_REG_TYPE_BSF) {
+		fname = "ffbsf";
+	}
+#endif
 	else return;
 
 
@@ -852,14 +1017,24 @@
 #endif
 		} else if (type==FF_REG_TYPE_DEV_IN) {
 #if (LIBAVCODEC_VERSION_MAJOR >= 58) && (LIBAVCODEC_VERSION_MINOR>=20)
-			fmt = av_input_video_device_next(FF_IFMT_CAST fmt);
-			if (!fmt) break;
+			if (audio_pass) {
+				fmt = av_input_audio_device_next(FF_IFMT_CAST fmt);
+			} else {
+				fmt = av_input_video_device_next(FF_IFMT_CAST fmt);
+			}
+			if (!fmt) {
+				if (!audio_pass) break;
+				audio_pass = GF_TRUE;
+				continue;
+			}
 			av_class = fmt->priv_class;
 			subname = fmt->name;
 #ifndef GPAC_DISABLE_DOC
 			description = fmt->long_name;
 #endif
- 		if (!av_class || (av_class->category!=AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT) ) continue;
+ 		if (!av_class) continue;
+			if (audio_pass && (av_class->category!=AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT) ) continue;
+			if (!audio_pass && (av_class->category!=AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT) ) continue;
 #else
 
 #if (LIBAVFORMAT_VERSION_MAJOR<59)
@@ -951,7 +1126,16 @@
 			break;
 
 #endif
-		} else {
+		}
+#ifdef FFMPEG_HAS_BSF
+		else if (type==FF_REG_TYPE_BSF) {
+			bsf = av_bsf_iterate(&av_it);
+			if (!bsf) break;
+			av_class = bsf->priv_class;
+			subname = bsf->name;
+		}
+#endif
+		else {
 			break;
 		}
 		GF_SAFEALLOC(freg, GF_FilterRegister);
@@ -961,7 +1145,9 @@
 		freg->caps = NULL;
 		freg->nb_caps = 0;
 		//no help
+#ifndef GPAC_DISABLE_DOC
 		freg->help = NULL;
+#endif
 
 		gf_list_add(all_filters, freg);
 
@@ -970,29 +1156,54 @@
 #ifndef GPAC_DISABLE_DOC
 		freg->description = description;
 #endif
-		 if ((type==FF_REG_TYPE_ENCODE) || (type==FF_REG_TYPE_DECODE)) {
+
+#ifndef NO_AVIO_PROTO
+		if (protocol_pass && gf_opts_get_bool("temp", "get_proto_schemes")) {
+			if (type==FF_REG_TYPE_DEMUX)
+				gf_opts_set_key("temp_in_proto", freg->name, subname);
+			else if (type==FF_REG_TYPE_MUX)
+				gf_opts_set_key("temp_out_proto", freg->name, subname);
+		}
+#endif
+
+		if ((type==FF_REG_TYPE_ENCODE) || (type==FF_REG_TYPE_DECODE)) {
 		 	GF_FilterCapability *caps;
 		 	u32 cid = ffmpeg_codecid_to_gpac(codec->id);
 		 	freg->nb_caps = 3;
 
-		 	caps = gf_malloc(sizeof(GF_FilterCapability)*3);
-		 	memset(caps, 0, sizeof(GF_FilterCapability)*3);
-		 	caps0.code = GF_PROP_PID_STREAM_TYPE;
-		 	caps0.val.type = GF_PROP_UINT;
-		 	caps0.val.value.uint = ff_streamtype(codec->type);
-		 	caps0.flags = GF_CAPS_INPUT_OUTPUT;
-
-		 	caps1.code = GF_PROP_PID_CODECID;
-		 	caps1.val.type = GF_PROP_UINT;
-		 	caps1.val.value.uint = (type==FF_REG_TYPE_DECODE) ? cid : GF_CODECID_RAW;
-		 	caps1.flags = GF_CAPS_INPUT;
+			caps = gf_malloc(sizeof(GF_FilterCapability)*freg->nb_caps);
+			memset(caps, 0, sizeof(GF_FilterCapability)*freg->nb_caps);
+			caps0.code = GF_PROP_PID_STREAM_TYPE;
+			caps0.val.type = GF_PROP_UINT;
+			caps0.val.value.uint = ff_streamtype(codec->type);
+			caps0.flags = GF_CAPS_INPUT_OUTPUT;
 
-		 	caps2.code = GF_PROP_PID_CODECID;
-		 	caps2.val.type = GF_PROP_UINT;
-		 	caps2.val.value.uint = (type==FF_REG_TYPE_DECODE) ? GF_CODECID_RAW : cid;
-		 	caps2.flags = GF_CAPS_OUTPUT;
+			caps1.code = GF_PROP_PID_CODECID;
+			caps1.flags = GF_CAPS_INPUT;
+			caps1.val.type = GF_PROP_UINT;
+			caps1.val.value.uint = GF_CODECID_RAW;
+			if (type==FF_REG_TYPE_DECODE) {
+				if (cid) {
+					caps1.val.value.uint = cid;
+				} else {
+					caps1.val.type = GF_PROP_NAME;
+					caps1.val.value.string = (char *) codec->long_name;
+				}
+			}
 
-		 	freg->caps = caps;
+			caps2.code = GF_PROP_PID_CODECID;
+			caps2.val.type = GF_PROP_UINT;
+			caps2.val.value.uint = GF_CODECID_RAW;
+			caps2.flags = GF_CAPS_OUTPUT;
+			if (type==FF_REG_TYPE_ENCODE) {
+				if (cid) {
+					caps2.val.value.uint = cid;
+				} else {
+					caps2.val.type = GF_PROP_NAME;
+					caps2.val.value.string = (char *) codec->long_name;
+				}
+			}
+			freg->caps = caps;
 		}
 		else if ((type==FF_REG_TYPE_DEMUX)
 			&& fmt
@@ -1004,7 +1215,7 @@
 			){
 		 	GF_FilterCapability *caps;
 #if LIBAVCODEC_VERSION_MAJOR >= 58
-			freg->nb_caps = (fmt->mime_type && fmt->extensions) ? 4 : 2;
+			freg->nb_caps = (fmt->mime_type && fmt->extensions) ? 3 : 2;
 #else
 			freg->nb_caps = 2;
 #endif
@@ -1026,11 +1237,10 @@
 
 #if LIBAVCODEC_VERSION_MAJOR >= 58
 			if (fmt->mime_type && fmt->extensions) {
-				caps2.flags = 0;
-				caps3.code = GF_PROP_PID_MIME;
-				caps3.val.type = GF_PROP_NAME;
-				caps3.val.value.string = (char *) fmt->mime_type;
-				caps3.flags = GF_CAPS_INPUT;
+				caps2.code = GF_PROP_PID_MIME;
+				caps2.val.type = GF_PROP_NAME;
+				caps2.val.value.string = (char *) fmt->mime_type;
+				caps2.flags = GF_CAPS_INPUT;
 			}
 #endif
 			//TODO map codec IDs if known ?
@@ -1046,7 +1256,7 @@
 			){
 			GF_FilterCapability *caps;
 #if LIBAVCODEC_VERSION_MAJOR >= 58
-			freg->nb_caps = (ofmt->mime_type && ofmt->extensions) ? 4 : 2;
+			freg->nb_caps = (ofmt->mime_type && ofmt->extensions) ? 3 : 2;
 #else
 			freg->nb_caps = 2;
 #endif
@@ -1068,16 +1278,73 @@
 
 #if LIBAVCODEC_VERSION_MAJOR >= 58
 			if (ofmt->mime_type && ofmt->extensions) {
-				caps2.flags = 0;
-				caps3.code = GF_PROP_PID_MIME;
-				caps3.val.type = GF_PROP_NAME;
-				caps3.val.value.string = (char *) ofmt->mime_type;
-				caps3.flags = GF_CAPS_OUTPUT;
+				caps2.code = GF_PROP_PID_MIME;
+				caps2.val.type = GF_PROP_NAME;
+				caps2.val.value.string = (char *) ofmt->mime_type;
+				caps2.flags = GF_CAPS_OUTPUT;
 			}
 #endif
 			//TODO map codec IDs if known ?
 			freg->caps = caps;
 		}
+#ifdef FFMPEG_HAS_BSF
+		else if (type==FF_REG_TYPE_BSF) {
+			GF_FilterCapability *caps;
+			u32 cur_cap, nb_codecs = 0;
+			i=0;
+			while (bsf->codec_ids) {
+				if (bsf->codec_idsi==AV_CODEC_ID_NONE) break;
+				i++;
+				nb_codecs++;
+			}
+
+			if (!nb_codecs) {
+				freg->nb_caps = 5;
+				caps = gf_malloc(sizeof(GF_FilterCapability)*freg->nb_caps);
+				memset(caps, 0, sizeof(GF_FilterCapability)*freg->nb_caps);
+				caps0.code = GF_PROP_PID_STREAM_TYPE;
+				caps0.val.type = GF_PROP_UINT;
+				caps0.val.value.uint = GF_STREAM_VISUAL;
+				caps0.flags = GF_CAPS_INPUT_OUTPUT;
+
+				caps2.code = GF_PROP_PID_STREAM_TYPE;
+				caps2.val.type = GF_PROP_UINT;
+				caps2.val.value.uint = GF_STREAM_AUDIO;
+				caps2.flags = GF_CAPS_INPUT_OUTPUT;
+
+				caps4.code = GF_PROP_PID_STREAM_TYPE;
+				caps4.val.type = GF_PROP_UINT;
+				caps4.val.value.uint = GF_STREAM_TEXT;
+				caps4.flags = GF_CAPS_INPUT_OUTPUT;
+			} else {
+				freg->nb_caps = 3*nb_codecs - 1;
+				caps = gf_malloc(sizeof(GF_FilterCapability)*freg->nb_caps);
+				memset(caps, 0, sizeof(GF_FilterCapability)*freg->nb_caps);
+
+				i=0;
+				cur_cap = 0;
+				while (bsf->codec_ids) {
+					u32 codec_id;
+					if (bsf->codec_idsi==AV_CODEC_ID_NONE) break;
+					codec_id = bsf->codec_idsi;
+					i++;
+
+					capscur_cap.code = GF_PROP_PID_STREAM_TYPE;
+					capscur_cap.val.type = GF_PROP_UINT;
+					capscur_cap.val.value.uint = ff_streamtype( avcodec_get_type(codec_id) );
+					capscur_cap.flags = GF_CAPS_INPUT_OUTPUT;
+
+					capscur_cap+1.code = GF_PROP_PID_CODECID;
+					capscur_cap+1.val.type = GF_PROP_UINT;
+					capscur_cap+1.val.value.uint = ffmpeg_codecid_to_gpac(codec_id);
+					capscur_cap+1.flags = GF_CAPS_INPUT_OUTPUT;
+					//empty cap between each codecid
+					cur_cap += 3;
+				}
+			}
+			freg->caps = caps;
+		}
+#endif
 
 		idx=0;
 		i=0;
@@ -1184,7 +1451,7 @@
 #endif
 }
 
-void ffmpeg_build_register(GF_FilterSession *session, GF_FilterRegister *orig_reg, const GF_FilterArgs *default_args, u32 nb_def_args, u32 reg_type)
+GF_FilterRegister *ffmpeg_build_register(GF_FilterSession *session, GF_FilterRegister *orig_reg, const GF_FilterArgs *default_args, u32 nb_def_args, u32 reg_type)
 {
 	GF_FilterArgs *args;
 	u32 i=0, idx=0, nb_args;
@@ -1195,31 +1462,45 @@
 	AVCodecContext *codec_ctx = NULL;
 	const AVClass *av_class = NULL;
 	GF_FFRegistryExt *ffregext;
-
+	GF_FilterRegister *new_reg;
 	ffmpeg_initialize();
 
+#ifndef GPAC_DISABLE_DOC
 	orig_reg->author = avfilter_configuration();
-	
+#endif
+
 	//by default no need to load option descriptions, everything is handled by av_set_opt in update_args
 	if (!load_meta_filters) {
 		orig_reg->args = default_args;
 		orig_reg->register_free = NULL;
-		return;
+		return orig_reg;
 	}
 
+	GF_SAFEALLOC(new_reg, GF_FilterRegister);
+	memcpy(new_reg, orig_reg, sizeof(GF_FilterRegister));
+	orig_reg = new_reg;
+
 	if (reg_type==FF_REG_TYPE_ENCODE) opt_type = AV_OPT_FLAG_ENCODING_PARAM;
 	else if (reg_type==FF_REG_TYPE_MUX) opt_type = AV_OPT_FLAG_ENCODING_PARAM;
 	else if (reg_type==FF_REG_TYPE_AVF) opt_type = 0xFFFFFFFF;
 
 	if ((reg_type==FF_REG_TYPE_ENCODE) || (reg_type==FF_REG_TYPE_DECODE)) {
+#ifndef GPAC_DISABLE_DOC
 		orig_reg->author = avcodec_configuration();
+#endif
 		codec_ctx = avcodec_alloc_context3(NULL);
 		av_class = codec_ctx->av_class;
 	} else if (reg_type==FF_REG_TYPE_AVF) {
 #if (LIBAVFILTER_VERSION_MAJOR > 5)
 		av_class = avfilter_get_class();
 #endif
-	} else {
+	}
+#ifdef FFMPEG_HAS_BSF
+	else if (reg_type==FF_REG_TYPE_BSF) {
+		av_class = av_bsf_get_class();
+	}
+#endif
+	else {
 		format_ctx = avformat_alloc_context();
 		av_class = format_ctx->av_class;
 	}
@@ -1342,15 +1623,17 @@
 		avformat_free_context(format_ctx);
 	}
 
-	GF_SAFEALLOC(ffregext, GF_FFRegistryExt);
-	if (!ffregext) return;
-	
-	orig_reg->udta = ffregext;
-	ffregext->nb_arg_skip = nb_def_args-1;
 	orig_reg->register_free = ffmpeg_register_free;
 
-	ffmpeg_expand_register(session, orig_reg, reg_type);
-
+	GF_SAFEALLOC(ffregext, GF_FFRegistryExt);
+	if (ffregext) {
+		orig_reg->udta = ffregext;
+		ffregext->nb_arg_skip = nb_def_args-1;
+		ffregext->is_building = GF_TRUE;
+		ffmpeg_expand_register(session, orig_reg, reg_type);
+		ffregext->is_building = GF_FALSE;
+	}
+	return orig_reg;
 }
 
 void ffmpeg_set_enc_dec_flags(const AVDictionary *options, AVCodecContext *ctx)
@@ -1415,10 +1698,467 @@
 			AVDictionaryEntry *unkn = av_dict_get(options, prev_e->key, NULL, 0);
 			if (unkn) unknown_opt = GF_TRUE;
 		}
-		gf_filter_report_meta_option(filter, prev_e->key, unknown_opt ? GF_FALSE : GF_TRUE);
+		gf_filter_report_meta_option(filter, prev_e->key, unknown_opt ? 0 : 1, NULL);
 	}
 	if (options)
 		av_dict_free(&options);
 }
 
+#include <gpac/bitstream.h>
+GF_Err ffmpeg_extradata_from_gpac(u32 gpac_codec_id, const u8 *dsi_in, u32 dsi_in_size, u8 **dsi_out, u32 *dsi_out_size)
+{
+	GF_Err e = GF_OK;
+	*dsi_out = NULL;
+	*dsi_out_size = 0;
+	if (!dsi_in) return GF_BAD_PARAM;
+
+	//rewrite our ogg dsi (sequence of blocks with 16 bit length prefix) into ffmpeg (1 byte num_bk-1, num_bk-1 sizes (8bits) and all data)
+	if (gpac_codec_id==GF_CODECID_VORBIS) {
+		u32 nb_pre=0;
+		u32 dsize;
+		u8 *d;
+		GF_BitStream *bs1 = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		GF_BitStream *bs2 = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		GF_BitStream *bs = gf_bs_new(dsi_in, dsi_in_size, GF_BITSTREAM_READ);
+		gf_bs_write_u8(bs1, 0);
+		while (gf_bs_available(bs)) {
+			u32 size = gf_bs_read_u16(bs);
+			if (size > gf_bs_available(bs)) {
+				e = GF_NON_COMPLIANT_BITSTREAM;
+				break;
+			}
+			if (size<255) {
+				nb_pre ++;
+				gf_bs_write_u8(bs1, size);
+			}
+			while (size) {
+				gf_bs_write_u8(bs2, gf_bs_read_u8(bs));
+				size--;
+			}
+		}
+		if (e) {
+			gf_bs_del(bs);
+			gf_bs_del(bs1);
+			gf_bs_del(bs2);
+			return e;
+		}
+		gf_bs_transfer(bs1, bs2, GF_FALSE);
+		gf_bs_get_content(bs1, &d, &dsize);
+		d0 = nb_pre;
+		gf_bs_del(bs);
+		gf_bs_del(bs1);
+		gf_bs_del(bs2);
+		*dsi_out_size = dsize;
+		*dsi_out = av_malloc(dsize + AV_INPUT_BUFFER_PADDING_SIZE);
+		if (!*dsi_out) return GF_OUT_OF_MEM;
+		memcpy(*dsi_out, d, dsize);
+		memset(*dsi_out + dsize, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+		gf_free(d);
+	}
+
+	//we don't set full header fLaC+blocks as some muxer in libavformat expect only STREAMINFO for flac
+	//only inject STERAMINFO
+	else if (gpac_codec_id==GF_CODECID_FLAC) {
+		const u8 *flac_dsi=NULL;
+		u32 flac_dsi_size=0;
+		GF_BitStream *bs = gf_bs_new(dsi_in, dsi_in_size, GF_BITSTREAM_READ);
+		while (gf_bs_available(bs)) {
+			gf_bs_read_int(bs, 1);
+			u8 type = gf_bs_read_int(bs, 7);
+			u8 bsize = gf_bs_read_int(bs, 24);
+			if (!type) {
+				flac_dsi_size = bsize;
+				flac_dsi = dsi_in + (u32) gf_bs_get_position(bs);
+				break;
+			}
+			gf_bs_skip_bytes(bs, bsize);
+		}
+		gf_bs_del(bs);
+		if (!flac_dsi || !flac_dsi_size) return GF_NON_COMPLIANT_BITSTREAM;
+		*dsi_out_size = flac_dsi_size;
+		*dsi_out = av_malloc(sizeof(char) * (flac_dsi_size) );
+		if (! *dsi_out) return GF_OUT_OF_MEM;
+		memcpy(*dsi_out, flac_dsi, flac_dsi_size);
+	} else if (gpac_codec_id==GF_CODECID_OPUS) {
+		*dsi_out_size = dsi_in_size+8;
+		*dsi_out = av_malloc(sizeof(char) * (dsi_in_size+8) );
+		if (! *dsi_out) return GF_OUT_OF_MEM;
+		memcpy(*dsi_out, "OpusHead", 8);
+		memcpy(*dsi_out+8, dsi_in, dsi_in_size);
+	} else if ((gpac_codec_id==GF_CODECID_SMPTE_VC1) && (dsi_in_size>7)) {
+		*dsi_out_size = dsi_in_size-7;
+		*dsi_out = av_malloc(sizeof(char) * (dsi_in_size-7) );
+		if (! *dsi_out) return GF_OUT_OF_MEM;
+		memcpy(*dsi_out, dsi_in+7, dsi_in_size-7);
+	} else {
+		*dsi_out_size = dsi_in_size;
+		*dsi_out = av_malloc(sizeof(char) * dsi_in_size);
+		if (! *dsi_out) return GF_OUT_OF_MEM;
+		memcpy(*dsi_out, dsi_in, dsi_in_size);
+	}
+	return e;
+}
+
+GF_Err ffmpeg_extradata_to_gpac(u32 gpac_codec_id, const u8 *data, u32 size, u8 **dsi_out, u32 *dsi_out_size)
+{
+	*dsi_out = NULL;
+	*dsi_out_size = 0;
+	if (!data) return GF_BAD_PARAM;
+	if (gpac_codec_id==GF_CODECID_VORBIS) {
+		GF_BitStream *bs;
+		u32 nb_page = 1 + data0;
+		if (nb_page != 3) return GF_NON_COMPLIANT_BITSTREAM;
+		u32 s1 = data1;
+		u32 s2 = data2;
+		u32 s3;
+		if (size < s1 + s2 + 1) return GF_NON_COMPLIANT_BITSTREAM;
+		s3 = size - s1 - s2 - 1;
+		bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		gf_bs_write_u16(bs, s1);
+		gf_bs_write_data(bs, data + 3, s1);
+		gf_bs_write_u16(bs, s2);
+		gf_bs_write_data(bs, data + 3 + s1, s2);
+		gf_bs_write_u16(bs, s3);
+		gf_bs_write_data(bs, data + 3 + s1 + s2, s3);
+		gf_bs_get_content(bs, dsi_out, dsi_out_size);
+		gf_bs_del(bs);
+		return GF_OK;
+	}
+
+	if (gpac_codec_id==GF_CODECID_FLAC) {
+		//flac DSI is only STREAMINFO block in ffmpeg, without block header
+		if ((size>4) && (GF_4CC(data0,data1, data2, data3) != GF_4CC('f', 'L', 'a', 'c'))) {
+			*dsi_out_size = size+4;
+			u8 *dsi = gf_malloc(size+4);
+			if (! dsi) return GF_OUT_OF_MEM;
+
+			dsi0 = (size==34) ? 0x80 : 0;
+			dsi1 = size >> 16;
+			dsi2 = size >> 8;
+			dsi3 = size & 0xFF;
+			memcpy(dsi+4, data, size);
+			*dsi_out = dsi;
+			return GF_OK;
+		}
+		//fallthrough
+	}
+
+	if (gpac_codec_id==GF_CODECID_OPUS) {
+		if ((size>8) && !memcmp(data, "OpusHead", 8)) {
+			*dsi_out_size = size-8;
+			*dsi_out = gf_malloc(size-8);
+			if (! *dsi_out) return GF_OUT_OF_MEM;
+			memcpy(*dsi_out, data+8, size-8);
+			return GF_OK;
+		}
+		//fallthrough
+	}
+	if (gpac_codec_id==GF_CODECID_SMPTE_VC1) {
+		return gf_media_vc1_seq_header_to_dsi(data, size, dsi_out, dsi_out_size);
+	}
+
+	//default is direct mapping
+
+	*dsi_out_size = size;
+	*dsi_out = gf_malloc(size);
+	if (! *dsi_out) return GF_OUT_OF_MEM;
+	memcpy(*dsi_out, data, size);
+	return GF_OK;
+}
+
+#include <gpac/avparse.h>
+#include <gpac/internal/media_dev.h>
+
+void ffmpeg_generate_gpac_dsi(GF_FilterPid *out_pid, u32 gpac_codec_id, u32 color_primaries, u32 transfer_characteristics, u32 colorspace, const u8 *data, u32 size)
+{
+	GF_VPConfig *vpc=NULL;
+	GF_AC3Header ac3hdr;
+	u32 dsi_size=0;
+	u8 *dsi=NULL;
+	GF_BitStream *bs;
+	GF_Err e;
+	Bool flag=GF_FALSE;
+
+	switch (gpac_codec_id) {
+	case GF_CODECID_VP8:
+	case GF_CODECID_VP10:
+		vpc = gf_odf_vp_cfg_new();
+		vpc->profile = 1;
+		vpc->level = 10;
+		vpc->bit_depth = 8;
+		vpc->colour_primaries = color_primaries;
+		vpc->transfer_characteristics = transfer_characteristics;
+		vpc->matrix_coefficients = colorspace;
+		break;
+	case GF_CODECID_VP9:
+	{
+		Bool key_frame = GF_FALSE;
+		u32 width = 0, height = 0, renderWidth, renderHeight;
+		u32 num_frames_in_superframe = 0, superframe_index_size = 0, i;
+		u32 frame_sizesVP9_MAX_FRAMES_IN_SUPERFRAME;
+		bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
+		e = gf_vp9_parse_superframe(bs, size, &num_frames_in_superframe, frame_sizes, &superframe_index_size);
+		if (!e) {
+			vpc = gf_odf_vp_cfg_new();
+			for (i = 0; i < num_frames_in_superframe; ++i) {
+				u64 pos2 = gf_bs_get_position(bs);
+				if (gf_vp9_parse_sample(bs, vpc, &key_frame, &width, &height, &renderWidth, &renderHeight) != GF_OK) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("VP9Dmx Error parsing frame\n"));
+					gf_odf_vp_cfg_del(vpc);
+					vpc = NULL;
+					break;
+				}
+				gf_bs_seek(bs, pos2 + frame_sizesi);
+			}
+		}
+		gf_bs_del(bs);
+	}
+		break;
+	case GF_CODECID_EAC3:
+		flag = GF_TRUE;
+	case GF_CODECID_AC3:
+		bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
+		if (flag) {
+			if (gf_eac3_parser_bs(bs, &ac3hdr, GF_FALSE) == GF_TRUE) {
+				ac3hdr.is_ec3=GF_TRUE;
+				gf_odf_ac3_cfg_write(&ac3hdr, &dsi, &dsi_size);
+			}
+		} else {
+			if (gf_ac3_parser_bs(bs, &ac3hdr, GF_TRUE) == GF_TRUE) {
+				gf_odf_ac3_cfg_write(&ac3hdr, &dsi, &dsi_size);
+			}
+		}
+		gf_bs_del(bs);
+		break;
+	case GF_CODECID_TRUEHD:
+	{
+		u32 format, peak_rate, sync, valid=0;
+		bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
+
+		/*nibble, frame size and time = */gf_bs_read_u32(bs);
+		sync = gf_bs_read_u32(bs);
+		if (sync == 0xF8726FBA) {
+			format = gf_bs_read_u32(bs);
+			u16 sig = gf_bs_read_u16(bs);
+			if (sig == 0xB752) {
+				gf_bs_read_u16(bs);
+				gf_bs_read_u16(bs);
+				gf_bs_read_int(bs, 1);
+				peak_rate = gf_bs_read_int(bs, 15);
+				valid = 1;
+			}
+		}
+		gf_bs_del(bs);
+
+		if (valid) {
+			bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+			gf_bs_write_u32(bs, format);
+			gf_bs_write_int(bs, peak_rate, 15);
+			gf_bs_write_int(bs, 0, 1);
+			gf_bs_write_u32(bs, 0);
+			gf_bs_get_content(bs, &dsi, &dsi_size);
+			gf_bs_del(bs);
+		}
+	}
+		break;
+	case GF_CODECID_MPEG1:
+	case GF_CODECID_MPEG2_422:
+	case GF_CODECID_MPEG2_SNR:
+	case GF_CODECID_MPEG2_HIGH:
+	case GF_CODECID_MPEG2_MAIN:
+	case GF_CODECID_MPEG2_SIMPLE:
+	case GF_CODECID_MPEG2_SPATIAL:
+		flag = GF_TRUE;
+	case GF_CODECID_MPEG4_PART2:
+	{
+		GF_M4VDecSpecInfo vcfg;
+		GF_M4VParser *mvp;
+		mvp = gf_m4v_parser_new((u8*)data, size, flag);
+		if (gf_m4v_parse_config(mvp, &vcfg) == GF_OK) {
+			dsi_size = (u32) gf_m4v_get_object_start(mvp);
+			dsi = gf_malloc(sizeof(u8) * dsi_size);
+			memcpy(dsi, data, dsi_size);
+		}
+		gf_m4v_parser_del(mvp);
+	}
+		break;
+	}
+
+	if (vpc) {
+		gf_odf_vp_cfg_write(vpc, &dsi, &dsi_size, vpc->codec_initdata_size ? GF_TRUE : GF_FALSE);
+		gf_odf_vp_cfg_del(vpc);
+	}
+
+	if (dsi)
+		gf_filter_pid_set_property(out_pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, dsi_size));
+}
+
+#if (LIBAVCODEC_VERSION_MAJOR > 56)
+
+GF_Err ffmpeg_codec_par_from_gpac(GF_FilterPid *pid, AVCodecParameters *codecpar, u32 ffmpeg_timescale)
+{
+	u32 streamtype=0;
+	u32 codec_id=0;
+	if (!pid || !codecpar) return GF_BAD_PARAM;
+	const GF_PropertyValue *p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
+	if (!p) return GF_BAD_PARAM;
+	streamtype = p->value.uint;
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+	if (!p) return GF_BAD_PARAM;
+	codec_id = p->value.uint;
+
+	if (streamtype==GF_STREAM_VISUAL) {
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_WIDTH);
+		if (p) codecpar->width = p->value.uint;
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_HEIGHT);
+		if (p) codecpar->height = p->value.uint;
+
+		if (codec_id==GF_CODECID_RAW) {
+			p = gf_filter_pid_get_property(pid, GF_PROP_PID_PIXFMT);
+			if (p) {
+				codecpar->format = ffmpeg_pixfmt_from_gpac(p->value.uint, GF_FALSE);
+				codecpar->codec_tag = avcodec_pix_fmt_to_codec_tag(codecpar->format);
+			}
+		}
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAR);
+		if (p) {
+			codecpar->sample_aspect_ratio.num = p->value.frac.num;
+			codecpar->sample_aspect_ratio.den = p->value.frac.den;
+		}
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_PRIMARIES);
+		if (p) codecpar->color_primaries = p->value.uint;
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_RANGE);
+		if (p) codecpar->color_range = (p->value.uint==1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_TRANSFER);
+		if (p) codecpar->color_trc = p->value.uint;
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_MX);
+		if (p) codecpar->color_space = p->value.uint;
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_CHROMALOC);
+		if (p) codecpar->chroma_location = p->value.uint;
+	}
+	else if (streamtype==GF_STREAM_AUDIO) {
+		u64 ch_layout;
+		u32 samplerate=0;
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAMPLE_RATE);
+		if (p) codecpar->sample_rate = samplerate = p->value.uint;
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_NUM_CHANNELS);
+		if (p) codecpar->channels = p->value.uint;
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAMPLES_PER_FRAME);
+		if (p) codecpar->frame_size = p->value.uint;
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_AUDIO_BPS);
+		if (p) codecpar->bits_per_raw_sample = p->value.uint;
+		if (codec_id==GF_CODECID_RAW) {
+			p = gf_filter_pid_get_property(pid, GF_PROP_PID_AUDIO_FORMAT);
+			if (p) codecpar->format = ffmpeg_audio_fmt_from_gpac(p->value.uint);
+		}
+
+		ch_layout = GF_AUDIO_CH_FRONT_CENTER;
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_CHANNEL_LAYOUT);
+		if (p)
+			ch_layout = p->value.longuint;
+		else if (codecpar->channels==2)
+			ch_layout = GF_AUDIO_CH_FRONT_LEFT|GF_AUDIO_CH_FRONT_RIGHT;
+		codecpar->channel_layout = ffmpeg_channel_layout_from_gpac(ch_layout);
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
+		if (p && (p->value.sint<0) && samplerate) {
+			s64 pad = -p->value.longsint;
+			if (ffmpeg_timescale && (ffmpeg_timescale!=samplerate)) {
+				pad *= samplerate;
+				pad /= ffmpeg_timescale;
+			}
+			codecpar->initial_padding = (s32) pad;
+		}
+		/*
+		//not mapped in gpac
+		int trailing_padding;
+		*/
+	}
+	return GF_OK;
+}
+
+GF_Err ffmpeg_codec_par_to_gpac(AVCodecParameters *codecpar, GF_FilterPid *opid, u32 ffmpeg_timescale)
+{
+	if (!opid || !codecpar) return GF_BAD_PARAM;
+
+	if (codecpar->width)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_WIDTH, &PROP_UINT(codecpar->width));
+	if (codecpar->height)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_WIDTH, &PROP_UINT(codecpar->height));
+	if (codecpar->sample_aspect_ratio.num) {
+		gf_filter_pid_set_property(opid, GF_PROP_PID_SAR, &PROP_FRAC_INT(codecpar->sample_aspect_ratio.num, codecpar->sample_aspect_ratio.den));
+	}
+	if (codecpar->color_primaries)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_COLR_PRIMARIES, &PROP_UINT(codecpar->color_primaries));
+
+	if (codecpar->color_range==AVCOL_RANGE_JPEG)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(GF_TRUE));
+	else if (codecpar->color_range==AVCOL_RANGE_MPEG)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(GF_FALSE));
+
+	if (codecpar->color_trc)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_COLR_TRANSFER, &PROP_UINT(codecpar->color_trc));
+
+	if (codecpar->color_space)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_COLR_MX, &PROP_UINT(codecpar->color_space));
+
+	if (codecpar->chroma_location)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_COLR_CHROMALOC, &PROP_UINT(codecpar->chroma_location));
+
+	if (codecpar->format>=0) {
+		if (codecpar->width) {
+			gf_filter_pid_set_property(opid, GF_PROP_PID_PIXFMT, &PROP_UINT( ffmpeg_pixfmt_to_gpac(codecpar->format, GF_FALSE)));
+		} else {
+			gf_filter_pid_set_property(opid, GF_PROP_PID_AUDIO_FORMAT, &PROP_UINT( ffmpeg_audio_fmt_to_gpac(codecpar->format)));
+		}
+	}
+
+	if (codecpar->sample_rate)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(codecpar->sample_rate));
+
+	if (codecpar->channels) {
+		gf_filter_pid_set_property(opid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(codecpar->channels));
+		if (codecpar->channel_layout) {
+			gf_filter_pid_set_property(opid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT( ffmpeg_channel_layout_to_gpac(codecpar->channel_layout) ));
+		}
+
+		if (codecpar->frame_size)
+			gf_filter_pid_set_property(opid, GF_PROP_PID_SAMPLES_PER_FRAME, &PROP_UINT(codecpar->frame_size));
+
+		if (codecpar->bits_per_raw_sample)
+			gf_filter_pid_set_property(opid, GF_PROP_PID_AUDIO_BPS, &PROP_UINT(codecpar->bits_per_raw_sample));
+	}
+	return GF_OK;
+}
+#endif
+
+GF_Err ffmpeg_update_arg(const char *log_name, void *ctx, AVDictionary **options, const char *arg_name, const GF_PropertyValue *arg_val)
+{
+	char dumpbufGF_PROP_DUMP_ARG_SIZE;
+	int ret;
+	const char *val = gf_props_dump_val(arg_val, dumpbuf, GF_PROP_DUMP_DATA_NONE, NULL);
+
+	if (!val && (arg_val->type == GF_PROP_STRING))
+		val = "1";
+
+	if (ctx) {
+		ret = av_opt_set(ctx, arg_name, val, AV_OPT_SEARCH_CHILDREN);
+	} else if (options) {
+		ret = av_dict_set(options, arg_name, val, 0);
+	} else {
+		return GF_BAD_PARAM;
+	}
+	if (ret<0) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("%s Failed to set option %s to %s: %s\n", log_name, arg_name, arg_val, av_err2str(ret)));
+		return GF_BAD_PARAM;
+	}
+	return GF_OK;
+}
+
 #endif

gpac-2.0.0.tar.gz/src/filters/ff_common.h -> gpac-2.2.0.tar.gz/src/filters/ff_common.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2017-2021
+ *			Copyright (c) Telecom ParisTech 2017-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common ffmpeg filters
@@ -56,9 +56,11 @@
 #define FF_IFMT_CAST
 #endif
 
-
-//rendering/translating to internal supported formats for text streams is not yet implemented
-//#define FF_SUB_SUPPORT
+//consider stable bsf api after major version 59
+#if (LIBAVCODEC_VERSION_MAJOR > 58)
+#define FFMPEG_HAS_BSF
+#include <libavcodec/bsf.h>
+#endif
 
 
 GF_FilterArgs ffmpeg_arg_translate(const struct AVOption *opt);
@@ -71,12 +73,15 @@
 	FF_REG_TYPE_ENCODE,
 	FF_REG_TYPE_MUX,
 	FF_REG_TYPE_AVF,
+#ifdef FFMPEG_HAS_BSF
+	FF_REG_TYPE_BSF,
+#endif
 };
 
-void ffmpeg_build_register(GF_FilterSession *session, GF_FilterRegister *orig_reg, const GF_FilterArgs *default_args, u32 nb_def_args, u32 reg_type);
+GF_FilterRegister *ffmpeg_build_register(GF_FilterSession *session, GF_FilterRegister *orig_reg, const GF_FilterArgs *default_args, u32 nb_def_args, u32 reg_type);
 
-u32 ffmpeg_pixfmt_from_gpac(u32 pfmt);
-u32 ffmpeg_pixfmt_to_gpac(u32 pfmt, Bool no_warn);
+enum AVPixelFormat ffmpeg_pixfmt_from_gpac(u32 pfmt, Bool no_warn);
+u32 ffmpeg_pixfmt_to_gpac(enum AVPixelFormat pfmt, Bool no_warn);
 //return GPAC pix format from codec tag
 u32 ffmpeg_pixfmt_from_codec_tag(u32 codec_tag, Bool *is_full_range);
 //check if FF pixfmt is an old format fullrange
@@ -98,3 +103,29 @@
 
 //this will destroy unknown_options if set
 void ffmpeg_report_options(GF_Filter *filter, AVDictionary *unknown_options, AVDictionary *all_options);
+
+void ffmpeg_register_set_dyn_help(GF_FilterRegister *reg);
+
+//output allocated with av_malloc
+GF_Err ffmpeg_extradata_from_gpac(u32 gpac_codec_id, const u8 *dsi_in, u32 dsi_in_size, u8 **dsi_out, u32 *dsi_out_size);
+//output allocated with gf_malloc
+GF_Err ffmpeg_extradata_to_gpac(u32 gpac_codec_id, const u8 *data, u32 size, u8 **dsi_out, u32 *dsi_out_size);
+
+void ffmpeg_tags_from_gpac(GF_FilterPid *pid, AVDictionary **metadata);
+void ffmpeg_tags_to_gpac(AVDictionary *metadata, GF_FilterPid *pid);
+
+void ffmpeg_generate_gpac_dsi(GF_FilterPid *out_pid, u32 gpac_codec_id, u32 color_primaries, u32 transfer_characteristics, u32 colorspace, const u8 *data, u32 size);
+
+#if (LIBAVCODEC_VERSION_MAJOR > 56)
+/*fills codecpar from pid properties. This assumes the codecpar was properly initialized.
+codec_id, codec_type, and extradata are NOT set by this function
+*/
+GF_Err ffmpeg_codec_par_from_gpac(GF_FilterPid *pid, AVCodecParameters *codecpar, u32 ffmpeg_timescale);
+
+/*sets pid properties from codecpar:
+codec_id, codec_type, and extradata are NOT set by this function
+*/
+GF_Err ffmpeg_codec_par_to_gpac(AVCodecParameters *codecpar, GF_FilterPid *opid, u32 ffmpeg_timescale);
+#endif
+
+GF_Err ffmpeg_update_arg(const char *log_name, void *ctx, AVDictionary **options, const char *arg_name, const GF_PropertyValue *arg_val);

gpac-2.0.0.tar.gz/src/filters/ff_dec.c -> gpac-2.2.0.tar.gz/src/filters/ff_dec.c Changed

@@ -29,6 +29,10 @@
 
 #include "ff_common.h"
 
+#if (LIBAVCODEC_VERSION_MAJOR < 58)
+#define FFMPEG_NO_SUBS
+#endif
+
 #include <libswscale/swscale.h>
 
 #define FF_CHECK_PROP(_name, _ffname, _type)	if (ctx->_name != ctx->decoder->_ffname) { \
@@ -48,13 +52,12 @@
 
 static GF_Err ffdec_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove);
 
+#include <gpac/color.h>
 
 typedef struct _gf_ffdec_ctx
 {
 	GF_PropStringList ffcmap;
-
-	//internal data
-	Bool initialized;
+	char *c;
 
 	Bool owns_context;
 	AVCodecContext *decoder;
@@ -106,20 +109,36 @@
 #else
 	AVPacket *pkt;
 #endif
-
+	u64 last_cts;
+	Bool prev_sub_valid, warned_txt;
+	GF_IRect irc;
+	GF_FilterFrameInterface sub_ifce;
 } GF_FFDecodeCtx;
 
 static GF_Err ffdec_initialize(GF_Filter *filter)
 {
 	GF_FFDecodeCtx *ctx = (GF_FFDecodeCtx *) gf_filter_get_udta(filter);
-	ctx->initialized = GF_TRUE;
 	ctx->src_packets = gf_list_new();
+	ctx->sar.den = 1;
 
 #if (LIBAVCODEC_VERSION_MAJOR >= 59)
 	ctx->pkt = av_packet_alloc();
 #endif
 
 	ffmpeg_setup_logs(GF_LOG_CODEC);
+
+	if (ctx->c && gf_filter_is_temporary(filter)) {
+		const AVCodec *codec = avcodec_find_decoder_by_name(ctx->c);
+		if (!codec) {
+			u32 codec_id = gf_codecid_parse(ctx->c);
+			if (codec_id!=GF_CODECID_NONE) {
+				codec = avcodec_find_decoder(ffmpeg_codecid_from_gpac(codec_id, NULL) );
+			}
+		}
+		if (codec) {
+			gf_filter_meta_set_instances(filter, codec->name);
+		}
+	}
 	return GF_OK;
 }
 
@@ -401,8 +420,12 @@
 		seek_flag = gf_filter_pck_get_seek_flag(pck_src);
 		out_cts = gf_filter_pck_get_cts(pck_src);
 	} else {
-		out_cts = frame->pts;
+		if (frame->pts==AV_NOPTS_VALUE)
+			out_cts = ctx->last_cts+1;
+		else
+			out_cts = frame->pts;
 	}
+	ctx->last_cts = out_cts;
 	//this was a seek frame, do not dispatch
 	if (seek_flag) {
 		if (pck_src) {
@@ -524,7 +547,7 @@
 #endif
 	AVPacket *pkt;
 	s32 res, in_size, i;
-	u32 samples_to_trash;
+	u32 samples_to_trash, pck_timescale=0;
 	u32 output_size, prev_afmt;
 	Bool is_eos=GF_FALSE;
 	u8 *data;
@@ -695,10 +718,10 @@
 	if (pck) {
 		const GF_PropertyValue *er = gf_filter_pck_get_property(pck, GF_PROP_PCK_END_RANGE);
 		if (er && er->value.boolean) {
-			u32 timescale = gf_filter_pck_get_timescale(pck);
+			pck_timescale = gf_filter_pck_get_timescale(pck);
 			u64 odur = gf_filter_pck_get_duration(pck);
-			if (timescale != ctx->sample_rate) {
-				odur = gf_timestamp_rescale(odur, timescale, ctx->sample_rate);
+			if (pck_timescale != ctx->sample_rate) {
+				odur = gf_timestamp_rescale(odur, pck_timescale, ctx->sample_rate);
 			}
 			if (odur < frame->nb_samples) {
 				frame->nb_samples = (int) odur;
@@ -734,6 +757,7 @@
 	src_pck = gf_list_get(ctx->src_packets, 0);
 
 	if (src_pck) {
+		pck_timescale = gf_filter_pck_get_timescale(src_pck);
 		gf_filter_pck_merge_properties(src_pck, dst_pck);
 		gf_filter_pck_set_dependency_flags(dst_pck, 0);
 		gf_list_rem(ctx->src_packets, 0);
@@ -743,9 +767,8 @@
 	if (output_size) {
 		if (frame->pts != AV_NOPTS_VALUE) {
 			u64 pts = frame->pts;
-			u32 timescale = gf_filter_pck_get_timescale(pck);
 			if (ctx->nb_samples_already_in_frame) {
-				if (ctx->sample_rate == timescale) {
+				if (ctx->sample_rate == pck_timescale) {
 					pts += ctx->nb_samples_already_in_frame;
 				}
 			}
@@ -797,7 +820,14 @@
 //	return ffdec_process_audio(filter, ctx);
 }
 
-#ifdef FF_SUB_SUPPORT
+#ifndef FFMPEG_NO_SUBS
+void gf_irect_union(GF_IRect *rc1, GF_IRect *rc2);
+
+static void ffsub_packet_destructor(GF_Filter *filter, GF_FilterPid *PID, GF_FilterPacket *pck)
+{
+
+}
+
 static GF_Err ffdec_process_subtitle(GF_Filter *filter, struct _gf_ffdec_ctx *ctx)
 {
 	AVPacket *pkt;
@@ -817,15 +847,9 @@
 	if (pck) pkt->data = (uint8_t *) gf_filter_pck_get_data(pck, &in_size);
 
 	if (!is_eos) {
-		u64 dts;
 		pkt->pts = gf_filter_pck_get_cts(pck);
-
-		//copy over SAP and duration in dts
-		dts = gf_filter_pck_get_sap(pck);
-		dts <<= 32;
-		dts |= gf_filter_pck_get_duration(pck);
-		pkt->dts = dts;
-
+		pkt->dts = pkt->pts;
+		pkt->duration = gf_filter_pck_get_duration(pck);
 		pkt->size = in_size;
 	} else {
 		pkt->size = 0;
@@ -837,11 +861,23 @@
 	//this will handle eos as well
 	if ((len<0) || !gotpic) {
 		FF_RELEASE_PCK(pkt)
-		if (pck) gf_filter_pid_drop_packet(ctx->in_pid);
+		if (pck) {
+			if (ctx->prev_sub_valid) {
+				ctx->prev_sub_valid = GF_FALSE;
+				GF_FilterPacket *opck = gf_filter_pck_new_frame_interface(ctx->out_pid, &ctx->sub_ifce, ffsub_packet_destructor);
+				if (opck) {
+					gf_filter_pck_merge_properties(pck, opck);
+					gf_filter_pck_set_dts(opck, gf_filter_pck_get_cts(pck));
+					gf_filter_pck_send(opck);
+				}
+			}
+			gf_filter_pid_drop_packet(ctx->in_pid);
+		}
 		if (len<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFDec PID %s failed to decode frame PTS "LLU": %s\n", gf_filter_pid_get_name(ctx->in_pid), pkt->pts, av_err2str(len) ));
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
+
 		if (is_eos) {
 			gf_filter_pid_set_eos(ctx->out_pid);
 			return GF_EOS;
@@ -849,10 +885,78 @@
 		return GF_OK;
 	}
 	//TODO - do we want to remap to TX3G/other and handle the rendering some place else, or do we do the rendering here ?
+	if (subs.num_rects) {
+		u32 i, nb_img=0;
+		ctx->irc.width = ctx->irc.height = 0;
+		for (i=0; i<subs.num_rects; i++) {
+			AVSubtitleRect *rc = subs.rectsi;
+			//todo ? deal with text formats (most are handled through other filters)
+			if (rc->type != SUBTITLE_BITMAP) {
+				if (!ctx->warned_txt) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFDec Non bitmap subtitles not supported, patch welcome\n"));
+					ctx->warned_txt = GF_TRUE;
+				}
+				continue;
+			}
+			if (!rc->nb_colors) continue;
+			GF_IRect a_rc;
+			a_rc.x = rc->x;
+			a_rc.y = rc->y;
+			a_rc.width = rc->w;
+			a_rc.height = rc->h;
+			gf_irect_union(&ctx->irc, &a_rc);
+			nb_img++;
+		}
+		if (!nb_img) goto exit;
+		if (!ctx->irc.width || !ctx->irc.height) goto exit;
+
+		u8 *output;
+		GF_FilterPacket *opck = gf_filter_pck_new_alloc(ctx->out_pid, 4*ctx->irc.width*ctx->irc.height, &output);
+		if (!opck) goto exit;
+
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_WIDTH, &PROP_UINT(ctx->irc.width));
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_HEIGHT, &PROP_UINT(ctx->irc.height));
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_TRANS_X_INV, &PROP_SINT(ctx->irc.x));
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_TRANS_Y_INV, &PROP_SINT(ctx->irc.y));
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_PIXFMT, &PROP_UINT(GF_PIXEL_RGBA));
+
+		memset(output, 0, 4*ctx->irc.width*ctx->irc.height);
+		for (i=0; i<subs.num_rects; i++) {
+			int j, k;
+			AVSubtitleRect *rc = subs.rectsi;
+			if (rc->type != SUBTITLE_BITMAP) continue;
+			if (!rc->nb_colors) continue;
+			u32 *palette = (u32 *) rc->data1;
+			rc->x -= ctx->irc.x;
+			rc->y = ctx->irc.y - rc->y;
+			for (j=0; j<rc->h; j++) {
+				u8 *dst = output + 4*ctx->irc.width*(rc->y+j) + 4*rc->x;
+				u8 *src = rc->data0 + rc->linesize0*j;
+				for (k=0; k<rc->w; k++) {
+					int pval = *src;
+					if (pval>=rc->nb_colors) continue;
+					u32 col = palettepval;
+					dst0 = GF_COL_R(col);
+					dst1 = GF_COL_G(col);
+					dst2 = GF_COL_B(col);
+					dst3 = GF_COL_A(col);
+					dst+=4;
+					src++;
+				}
+			}
+		}
 
+		gf_filter_pck_merge_properties(pck, opck);
+		gf_filter_pck_set_dts(opck, gf_filter_pck_get_cts(pck));
+		gf_filter_pck_send(opck);
+		ctx->prev_sub_valid = GF_TRUE;
+	}
 
+exit:
 	avsubtitle_free(&subs);
-	if (pck) gf_filter_pid_drop_packet(ctx->in_pid);
+	if (pck)
+		gf_filter_pid_drop_packet(ctx->in_pid);
+
 	FF_RELEASE_PCK(pkt)
 	return GF_OK;
 }
@@ -861,9 +965,10 @@
 static GF_Err ffdec_process(GF_Filter *filter)
 {
 	GF_FFDecodeCtx *ctx = (GF_FFDecodeCtx *) gf_filter_get_udta(filter);
-	if (gf_filter_pid_would_block(ctx->out_pid))
+	if (!ctx->decoder) {
+		gf_filter_pid_get_packet(ctx->in_pid);
 		return GF_OK;
-
+	}
 	return ctx->process(filter, ctx);
 }
 
@@ -906,9 +1011,7 @@
 	switch (type) {
 	case GF_STREAM_AUDIO:
 	case GF_STREAM_VISUAL:
-#ifdef FF_SUB_SUPPORT
 	case GF_STREAM_TEXT:
-#endif
 		break;
 	default:
 		return GF_NOT_SUPPORTED;
@@ -962,7 +1065,7 @@
 	}
 
 	if (gpac_codecid == GF_CODECID_FFMPEG) {
-		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_FFMPEG_CODEC_ID);
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_META_DEMUX_CODEC_ID);
 		if (prop && (prop->type==GF_PROP_POINTER)) {
 			ctx->decoder = prop->value.ptr;
 			if (!ctx->decoder) {
@@ -982,6 +1085,17 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFDec PID %s codec context not exposed by demuxer !\n", gf_filter_pid_get_name(pid) ));
 			return GF_SERVICE_ERROR;
 		}
+		if (!codec) {
+			prop = gf_filter_pid_get_property(pid, GF_PROP_PID_META_DEMUX_CODEC_NAME);
+			if (prop) {
+				codec = avcodec_find_decoder_by_name(prop->value.string);
+				if (codec) {
+					ctx->decoder = avcodec_alloc_context3(NULL);
+					if (! ctx->decoder) return GF_OUT_OF_MEM;
+					ctx->owns_context = GF_TRUE;
+				}
+			}
+		}
 
 		if (!codec) {
 			gf_filter_set_name(filter, "ffdec");
@@ -1091,58 +1205,70 @@
 		&& prop->value.data.ptr
 		&& prop->value.data.size
 	) {
-		//looks like ffmpeg wants the fLaC keyword
-		if (gpac_codecid==GF_CODECID_FLAC) {
-			ctx->decoder->extradata_size = prop->value.data.size+4;
-			ctx->decoder->extradata = av_malloc(sizeof(char) * prop->value.data.size+4);
-			memcpy(ctx->decoder->extradata, "fLaC", 4);
-			memcpy(ctx->decoder->extradata+4, prop->value.data.ptr, prop->value.data.size);
-		} else {
-			u8 *dsi = prop->value.data.ptr;
-			u32 dsi_size = prop->value.data.size;
-			if (unwrap_extra_data && (dsi_size>8)) {
-				u32 size = dsi0; size<<=8;
-				size |= dsi1; size<<=8;
-				size |= dsi2; size<<=8;
-				size |= dsi3;
-				if (size == dsi_size) {
-					dsi += 8;
-					dsi_size -= 8;
-				}
+		u8 *dsi = prop->value.data.ptr;
+		u32 dsi_size = prop->value.data.size;
+		if (unwrap_extra_data && (dsi_size>8)) {
+			u32 size = dsi0; size<<=8;
+			size |= dsi1; size<<=8;
+			size |= dsi2; size<<=8;
+			size |= dsi3;
+			if (size == dsi_size) {
+				dsi += 8;
+				dsi_size -= 8;
 			}
-
-			ctx->decoder->extradata_size = dsi_size;
-			ctx->decoder->extradata = av_malloc(sizeof(char) * dsi_size);
-			memcpy(ctx->decoder->extradata, dsi, dsi_size);
 		}
-		ctx->extra_data_crc = gf_crc_32(ctx->decoder->extradata, ctx->decoder->extradata_size);
+		GF_Err e = ffmpeg_extradata_from_gpac(gpac_codecid, dsi, dsi_size, &ctx->decoder->extradata, &ctx->decoder->extradata_size);
+		if (e) return e;
+
+		//crc of GPAC DSI, not ffmpeg
+		ctx->extra_data_crc = gf_crc_32(dsi, dsi_size);
 	}
 
 	//by default let libavcodec decide - if single thread is required, let the user define -threads option
-	if (codec->capabilities & AV_CODEC_CAP_AUTO_THREADS)
+	//only do this for visual as it breaks flac decoder on old ffmpeg (maybe other ?)
+	if (type==GF_STREAM_VISUAL)
 		ctx->decoder->thread_count = 0;
 
+	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_META_DEMUX_OPAQUE);
+	ctx->decoder->block_align = prop ? prop->value.uint : 0;
+
+	//we're good to go, declare our output pid
+	ctx->in_pid = pid;
+	if (!ctx->out_pid) {
+		ctx->out_pid = gf_filter_pid_new(filter);
+		gf_filter_pid_set_framing_mode(ctx->in_pid, GF_TRUE);
+	}
+
 	//clone options (in case we need to destroy/recreate the codec) and open codec
 	av_dict_copy(&options, ctx->options, 0);
 	res = avcodec_open2(ctx->decoder, codec, &options);
 	if (res < 0) {
 		if (options) av_dict_free(&options);
+		//decoder config not ready, start fetching first packet
+		if (!ctx->decoder->width && !ctx->decoder->height && !ctx->decoder->sample_rate && !ctx->decoder->extradata) {
+			gf_filter_pid_copy_properties(ctx->out_pid, ctx->in_pid);
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW) );
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_DECODER_CONFIG, NULL );
+			avcodec_free_context(&ctx->decoder);
+			ctx->decoder = NULL;
+			return GF_OK;
+		}
+
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFDec PID %s failed to open codec context: %s\n", gf_filter_pid_get_name(pid), av_err2str(res) ));
 		return GF_NON_COMPLIANT_BITSTREAM;
 	}
 
 	ffmpeg_report_options(filter, options, ctx->options);
+	if (ctx->c) gf_free(ctx->c);
+	ctx->c = gf_strdup(codec->name);
 
-	//we're good to go, declare our output pid
-	ctx->in_pid = pid;
-	if (!ctx->out_pid) {
+	{
 		char szCodecName1000;
-		ctx->out_pid = gf_filter_pid_new(filter);
-
-		//to change once we implement on-the-fly codec change
-		sprintf(szCodecName, "ffdec:%s", ctx->decoder->codec->name ? ctx->decoder->codec->name : "unknown");
+		if (ctx->decoder->thread_count>1)
+			sprintf(szCodecName, "ffdec:%s (%d threads)", ctx->decoder->codec->name ? ctx->decoder->codec->name : "unknown", ctx->decoder->thread_count);
+		else
+			sprintf(szCodecName, "ffdec:%s", ctx->decoder->codec->name ? ctx->decoder->codec->name : "unknown");
 		gf_filter_set_name(filter, szCodecName);
-		gf_filter_pid_set_framing_mode(ctx->in_pid, GF_TRUE);
 	}
 
 reuse_codec_context:
@@ -1198,6 +1324,15 @@
 		if (ctx->pixel_fmt) {
 			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_PIXFMT, &PROP_UINT( ctx->pixel_fmt) );
 		}
+		//if SAR is given ignore sar detection
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_SAR);
+		if (prop) {
+			ctx->sar.num = 0;
+			ctx->sar.den = 0;
+		} else if (ctx->sar.num) {
+			ctx->sar.num = 0;
+			ctx->sar.den = 1;
+		}
 
 	} else if (type==GF_STREAM_AUDIO) {
 		ctx->process = ffdec_process_audio;
@@ -1229,6 +1364,8 @@
 		if (ctx->sample_fmt) {
 			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_AUDIO_FORMAT, &PROP_UINT( ctx->sample_fmt) );
 		}
+		//we'll like change our number of frames when transcoding audio
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_NB_FRAMES, NULL);
 
 		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_NO_PRIMING);
 		if (prop && prop->value.boolean) {
@@ -1243,9 +1380,18 @@
 			else
 				ctx->ts_offset = 0;
 		}
-
+#ifndef FFMPEG_NO_SUBS
 	} else {
-#ifdef FF_SUB_SUPPORT
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT( GF_STREAM_VISUAL) );
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_ORIG_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT));
+		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_SPARSE, &PROP_BOOL(GF_TRUE));
+		if (ctx->irc.width) {
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_WIDTH, &PROP_UINT(ctx->irc.width));
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_HEIGHT, &PROP_UINT(ctx->irc.height));
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_TRANS_X_INV, &PROP_SINT(ctx->irc.x));
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_TRANS_Y_INV, &PROP_SINT(ctx->irc.y));
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_PIXFMT, &PROP_UINT(GF_PIXEL_RGBA));
+		}
 		ctx->process = ffdec_process_subtitle;
 #endif
 	}
@@ -1255,26 +1401,13 @@
 
 static GF_Err ffdec_update_arg(GF_Filter *filter, const char *arg_name, const GF_PropertyValue *arg_val)
 {
-	s32 res;
 	GF_FFDecodeCtx *ctx = gf_filter_get_udta(filter);
-
-	//initial parsing of arguments
-	if (!ctx->initialized) {
-		switch (arg_val->type) {
-		case GF_PROP_STRING:
-			res = av_dict_set(&ctx->options, arg_name, arg_val->value.string, 0);
-			if (res<0) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFDec Failed to set option %s:%s\n", arg_name, arg_val ));
-			}
-			break;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFDec Failed to set option %s:%s, unrecognized type %d\n", arg_name, arg_val, arg_val->type ));
-			return GF_NOT_SUPPORTED;
-		}
+	//prevent any change on b option which can break some decoders
+	if (!strcmp(arg_name, "b")) {
+		gf_filter_report_meta_option(filter, "b", 1, NULL);
 		return GF_OK;
 	}
-	//updates of arguments, not supported for ffmpeg decoders
-	return GF_NOT_SUPPORTED;
+	return ffmpeg_update_arg("FFDec", ctx->decoder, &ctx->options, arg_name, arg_val);
 }
 
 static Bool ffdec_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
@@ -1292,6 +1425,9 @@
 			//for video, this will reset the decoder
 			ctx->flush_done = GF_TRUE;
 		}
+		//flush draining state
+		if (ctx->decoder && ctx->flush_done)
+			avcodec_flush_buffers(ctx->decoder);
 	}
 
 	return GF_FALSE;
@@ -1316,19 +1452,21 @@
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
-
-#ifdef FF_SUB_SUPPORT
+#ifndef FFMPEG_NO_SUBS
 	{0},
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_TEXT_MPEG4),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_SUBS_TEXT),
+	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_SUBS_SSA),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
 #endif
-
 };
 
 GF_FilterRegister FFDecodeRegister = {
@@ -1344,12 +1482,12 @@
 	"\n"
 	"# Codec Map\n"
 	"The -ffcmap() option allows specifying FFMPEG codecs for codecs not supported by GPAC.\n"
-	"Each entry in the list is formated as `GID@name` or `GID@+name`, with:\n"
+	"Each entry in the list is formatted as `GID@name` or `GID@+name`, with:\n"
 	"- GID: 4CC or 32 bit identifier of codec ID, as indicated by `gpac -i source inspect:full`\n"
 	"- name: FFMPEG codec name\n"
 	"- `+': is set and extra data is set and formatted as an ISOBMFF box, removes box header\n"
 	"\n"
-	"EX gpac -i source --ffcmap=BKV1@binkvideo vout\n"
+	"EX gpac -i source.mp4 --ffcmap=BKV1@binkvideo vout\n"
 	"This will map an ISOBMFF track declared with coding type `BKV1` to binkvideo.\n"
 	)
 	.private_size = sizeof(GF_FFDecodeCtx),
@@ -1372,14 +1510,14 @@
 static const GF_FilterArgs FFDecodeArgs =
 {
 	{ OFFS(ffcmap), "codec map", GF_PROP_STRING_LIST, NULL, NULL, 0},
+	{ OFFS(c), "codec name (GPAC or ffmpeg), only used to query possible arguments - updated to ffmpeg codec name after initialization", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{ "*", -1, "any possible options defined for AVCodecContext and sub-classes. See `gpac -hx ffdec` and `gpac -hx ffdec:*`", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_META},
 	{0}
 };
 
 const GF_FilterRegister *ffdec_register(GF_FilterSession *session)
 {
-	ffmpeg_build_register(session, &FFDecodeRegister, FFDecodeArgs, 1, FF_REG_TYPE_DECODE);
-	return &FFDecodeRegister;
+	return ffmpeg_build_register(session, &FFDecodeRegister, FFDecodeArgs, 1, FF_REG_TYPE_DECODE);
 }
 
 #else

gpac-2.0.0.tar.gz/src/filters/ff_dmx.c -> gpac-2.2.0.tar.gz/src/filters/ff_dmx.c Changed

@@ -32,6 +32,11 @@
 //for NTP clock
 #include <gpac/network.h>
 #include <gpac/bitstream.h>
+#if (LIBAVCODEC_VERSION_MAJOR>58)
+#include <libavutil/mastering_display_metadata.h>
+#else
+#define FFMPEG_NO_DOVI
+#endif
 
 enum
 {
@@ -45,6 +50,10 @@
 {
 	GF_FilterPid *pid;
 	u64 ts_offset;
+	Bool mkv_webvtt;
+	u32 vc1_mode;
+	u64 fake_dts;
+	Bool fake_dts_set;
 } PidCtx;
 
 typedef struct
@@ -60,7 +69,6 @@
 	const char *fname;
 	u32 log_class;
 
-	Bool initialized;
 	Bool raw_data;
 	//input file
 	AVFormatContext *demuxer;
@@ -71,7 +79,7 @@
 
 	Bool raw_pck_out;
 	u32 nb_streams;
-	u32 nb_playing;
+	u32 nb_playing, nb_stop_pending;
 	Bool stop_seen;
 	u64 first_sample_clock, last_frame_ts;
 	u32 probe_frames;
@@ -93,6 +101,7 @@
 	u8 *avio_ctx_buffer;
 	AVIOContext *avio_ctx;
 	FILE *gfio;
+	GF_Fraction fps_forced;
 } GF_FFDemuxCtx;
 
 static void ffdmx_finalize(GF_Filter *filter)
@@ -130,6 +139,151 @@
 	}
 }
 
+static GF_Err ffdmx_set_decoder_config(PidCtx *pctx, const u8 *exdata, u32 exdata_size, u32 gpac_codec_id)
+{
+	u8 *dsi;
+	u32 dsi_size;
+	GF_Err e = ffmpeg_extradata_to_gpac(gpac_codec_id, exdata, exdata_size, &dsi, &dsi_size);
+	if (e) return e;
+
+	if (gpac_codec_id==GF_CODECID_SMPTE_VC1) {
+		pctx->vc1_mode = 1;
+		//if no_interlace (bit 6 of 2nd byte) is not set, inject interlaced
+		if ((dsi_size>=7) && ((dsi2 & 0x20) != 0x20))
+			pctx->vc1_mode = 2;
+	}
+	return gf_filter_pid_set_property(pctx->pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY( dsi, dsi_size) );
+}
+
+#if (LIBAVCODEC_VERSION_MAJOR>58)
+static inline u32 rescale_mdcv(AVRational q, int b)
+{
+ return (u32) av_rescale(q.num, b, q.den);
+}
+#endif
+
+//dovi_meta.h not exported in old releases, just redefine
+typedef struct {
+ u8 dv_version_major;
+ u8 dv_version_minor;
+ u8 dv_profile;
+ u8 dv_level;
+ u8 rpu_present_flag;
+ u8 el_present_flag;
+ u8 bl_present_flag;
+ u8 dv_bl_signal_compatibility_id;
+} Ref_FFAVDoviRecord;
+
+static void ffdmx_parse_side_data(const AVPacketSideData *sd, GF_FilterPid *pid)
+{
+	switch (sd->type) {
+	case AV_PKT_DATA_PALETTE:
+		break;
+	case AV_PKT_DATA_NEW_EXTRADATA:
+		break;
+	case AV_PKT_DATA_PARAM_CHANGE:
+		break;
+	case AV_PKT_DATA_H263_MB_INFO:
+		break;
+	case AV_PKT_DATA_REPLAYGAIN:
+		break;
+	case AV_PKT_DATA_STEREO3D:
+		break;
+	case AV_PKT_DATA_AUDIO_SERVICE_TYPE:
+		break;
+	case AV_PKT_DATA_QUALITY_STATS:
+		break;
+	case AV_PKT_DATA_DISPLAYMATRIX:
+	{
+		GF_PropertyValue p;
+		memset(&p, 0, sizeof(GF_PropertyValue));
+		p.type = GF_PROP_SINT_LIST;
+		p.value.uint_list.nb_items = 9;
+		p.value.uint_list.vals = (u32 *)sd->data;
+		gf_filter_pid_set_property(pid, GF_PROP_PID_ISOM_TRACK_MATRIX, &p);
+
+	}
+		break;
+
+#if (LIBAVCODEC_VERSION_MAJOR >= 58)
+	case AV_PKT_DATA_CPB_PROPERTIES:
+		break;
+	case AV_PKT_DATA_SPHERICAL:
+		break;
+#endif
+
+
+#if (LIBAVCODEC_VERSION_MAJOR>58)
+	case AV_PKT_DATA_MASTERING_DISPLAY_METADATA:
+	{
+		u8 mdcv24;
+		const int chroma_den = 50000;
+		const int luma_den = 10000;
+		memset(mdcv, 0, sizeof(u8)*24);
+		const AVMasteringDisplayMetadata *metadata = (const AVMasteringDisplayMetadata *)sd->data;
+		GF_BitStream *bs = gf_bs_new(mdcv, 24, GF_BITSTREAM_WRITE);
+		gf_bs_write_u16(bs, rescale_mdcv(metadata->display_primaries10, chroma_den));
+		gf_bs_write_u16(bs, rescale_mdcv(metadata->display_primaries11, chroma_den));
+ 	gf_bs_write_u16(bs, rescale_mdcv(metadata->display_primaries20, chroma_den));
+ 	gf_bs_write_u16(bs, rescale_mdcv(metadata->display_primaries21, chroma_den));
+ 	gf_bs_write_u16(bs, rescale_mdcv(metadata->display_primaries00, chroma_den));
+ 	gf_bs_write_u16(bs, rescale_mdcv(metadata->display_primaries01, chroma_den));
+ 	gf_bs_write_u16(bs, rescale_mdcv(metadata->white_point0, chroma_den));
+ 	gf_bs_write_u16(bs, rescale_mdcv(metadata->white_point1, chroma_den));
+ 	gf_bs_write_u32(bs, rescale_mdcv(metadata->max_luminance, luma_den));
+ 	gf_bs_write_u32(bs, rescale_mdcv(metadata->min_luminance, luma_den));
+ 	gf_bs_del(bs);
+		gf_filter_pid_set_property(pid, GF_PROP_PID_MASTER_DISPLAY_COLOUR, &PROP_DATA(mdcv, 24));
+	}
+		break;
+
+	case AV_PKT_DATA_CONTENT_LIGHT_LEVEL:
+	{
+		u8 clli4;
+		memset(clli, 0, sizeof(u8)*4);
+		const AVContentLightMetadata *metadata = (const AVContentLightMetadata *)sd->data;
+		GF_BitStream *bs = gf_bs_new(clli, 4, GF_BITSTREAM_WRITE);
+		gf_bs_write_u16(bs, metadata->MaxCLL);
+		gf_bs_write_u16(bs, metadata->MaxFALL);
+ 	gf_bs_del(bs);
+		gf_filter_pid_set_property(pid, GF_PROP_PID_CONTENT_LIGHT_LEVEL, &PROP_DATA(clli, 4));
+	}
+		break;
+	case AV_PKT_DATA_ICC_PROFILE:
+		gf_filter_pid_set_property(pid, GF_PROP_PID_ICC_PROFILE, &PROP_DATA(sd->data, (u32) sd->size));
+		break;
+	case AV_PKT_DATA_DOVI_CONF:
+	{
+		u8 dv_cfg24;
+		const Ref_FFAVDoviRecord *dovi = (const Ref_FFAVDoviRecord *)sd->data;
+		memset(dv_cfg, 0, sizeof(u8)*24);
+		GF_BitStream *bs = gf_bs_new(dv_cfg, 24, GF_BITSTREAM_WRITE);
+		gf_bs_write_u8(bs, dovi->dv_version_major);
+		gf_bs_write_u8(bs, dovi->dv_version_minor);
+		gf_bs_write_int(bs, dovi->dv_profile, 7);
+		gf_bs_write_int(bs, dovi->dv_level, 6);
+		gf_bs_write_int(bs, dovi->rpu_present_flag, 1);
+		gf_bs_write_int(bs, dovi->el_present_flag, 1);
+		gf_bs_write_int(bs, dovi->bl_present_flag, 1);
+		gf_bs_write_int(bs, dovi->dv_bl_signal_compatibility_id, 4);
+		//the rest is zero-reserved
+		gf_bs_write_int(bs, 0, 28);
+		gf_bs_write_u32(bs, 0);
+		gf_bs_write_u32(bs, 0);
+		gf_bs_write_u32(bs, 0);
+		gf_bs_write_u32(bs, 0);
+		gf_bs_del(bs);
+		gf_filter_pid_set_property(pid, GF_PROP_PID_DOLBY_VISION, &PROP_DATA(dv_cfg, 24));
+	}
+		break;
+	case AV_PKT_DATA_S12M_TIMECODE:
+		break;
+#endif
+	default:
+		break;
+	}
+}
+
 static GF_Err ffdmx_process(GF_Filter *filter)
 {
 	GF_Err e;
@@ -137,6 +291,7 @@
 	u64 sample_time;
 	u8 *data_dst;
 	Bool copy = GF_TRUE;
+	Bool check_webvtt = GF_FALSE;
 	GF_FilterPacket *pck_dst;
 	AVPacket *pkt;
 	PidCtx *pctx;
@@ -148,9 +303,25 @@
 	if (ctx->raw_pck_out)
 		return GF_EOS;
 
+	u32 would_block=0, pids=0;
+	for (i=0; i<ctx->nb_streams; i++) {
+		if (!ctx->pids_ctxi.pid) continue;
+		pids++;
+		if (!gf_filter_pid_is_playing(ctx->pids_ctxi.pid))
+			would_block++;
+		else if (gf_filter_pid_would_block(ctx->pids_ctxi.pid))
+			would_block++;
+	}
+	if (would_block == pids) {
+		gf_filter_ask_rt_reschedule(filter, 0);
+		return GF_OK;
+	}
+	
 	sample_time = gf_sys_clock_high_res();
 
 	FF_INIT_PCK(ctx, pkt)
+	pkt->side_data = NULL;
+	pkt->side_data_elems = 0;
 
 	pkt->stream_index = -1;
 
@@ -229,7 +400,12 @@
 		for (i=0; i < (u32) pkt->side_data_elems; i++) {
 			AVPacketSideData *sd = &pkt->side_datai;
 			if (sd->type == AV_PKT_DATA_NEW_EXTRADATA) {
-				gf_filter_pid_set_property(pctx->pid, GF_PROP_PID_DECODER_CONFIG, & PROP_DATA(sd->data, sd->size) );
+				if (sd->data) {
+					u32 cid = 0;
+					const GF_PropertyValue *p = gf_filter_pid_get_property(pctx->pid, GF_PROP_PID_CODECID);
+					if (p) cid = p->value.uint;
+					ffdmx_set_decoder_config(pctx, sd->data, (u32) sd->size, cid);
+				}
 			}
 			else if (sd->type == AV_PKT_DATA_PARAM_CHANGE) {
 				GF_BitStream *bs = gf_bs_new(sd->data, sd->size, GF_BITSTREAM_READ);
@@ -256,7 +432,15 @@
 				}
 				gf_bs_del(bs);
 			}
+			else if ((sd->type == AV_PKT_DATA_WEBVTT_IDENTIFIER) || (sd->type == AV_PKT_DATA_WEBVTT_SETTINGS)
+				|| (sd->type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL)
+			) {
+				check_webvtt = pctx->mkv_webvtt;
+			}
 			//todo, map the rest ?
+			else {
+				ffdmx_parse_side_data(sd, pctx->pid);
+			}
 		}
 	}
 
@@ -265,20 +449,31 @@
 		else copy = ctx->copy_video;
 	}
 
-	if (ctx->raw_data && !copy) {
+	/*patch vc1 to always include start codes*/
+	if (pctx->vc1_mode && (pkt->data0!=0) && (pkt->data1!=0) && (pkt->data2!=1)) {
+		pck_dst = gf_filter_pck_new_alloc(pctx->pid, pkt->size+4, &data_dst);
+		if (!pck_dst) return GF_OUT_OF_MEM;
+		data_dst0=0;
+		data_dst1=0;
+		data_dst2=1;
+		if ((pctx->vc1_mode==2) && ((pkt->data0 & 0xC0) == 0xC0)) {
+			data_dst3 = 0x0C;
+		} else {
+			data_dst3 = 0x0D;
+		}
+		memcpy(data_dst+4, pkt->data, pkt->size);
+	} else if (ctx->raw_data && !copy) {
 		//we don't use shared memory on demuxers since they are usually the ones performing all the buffering
 		pck_dst = gf_filter_pck_new_shared(pctx->pid, pkt->data, pkt->size, ffdmx_shared_pck_release);
 		if (!pck_dst) return GF_OUT_OF_MEM;
 		ctx->raw_pck_out = GF_TRUE;
 	} else {
 		//we don't use shared memory on demuxers since they are usually the ones performing all the buffering
-		pck_dst = gf_filter_pck_new_alloc(pctx->pid , pkt->size, &data_dst);
+		pck_dst = gf_filter_pck_new_alloc(pctx->pid, pkt->size, &data_dst);
 		if (!pck_dst) return GF_OUT_OF_MEM;
-		assert(pck_dst);
 		memcpy(data_dst, pkt->data, pkt->size);
 	}
 
-
 	if (ctx->raw_data && ctx->sclock) {
 		u64 ts;
 		if (!ctx->first_sample_clock) {
@@ -294,7 +489,7 @@
 		//initial delay setup - we only dispatch dts or cts >=0
 		if (!pctx->ts_offset) {
 			//if first dts is <0, offset timeline and set offset
-			if ((pkt->dts != AV_NOPTS_VALUE) && (pkt->dts<0) && pctx->ts_offset) {
+			if ((pkt->dts != AV_NOPTS_VALUE) && (pkt->dts<0) && !pctx->ts_offset) {
 				pctx->ts_offset = -pkt->dts + 1;
 				gf_filter_pid_set_property(pctx->pid, GF_PROP_PID_DELAY, &PROP_LONGSINT( pkt->dts) );
 			}
@@ -309,8 +504,18 @@
 		gf_filter_pck_set_cts(pck_dst, ts );
 
 		if (pkt->dts != AV_NOPTS_VALUE) {
-			ts = (pkt->dts + pctx->ts_offset-1) * stream->time_base.num;
+			ts = (pctx->fake_dts + pkt->dts + pctx->ts_offset-1) * stream->time_base.num;
 			gf_filter_pck_set_dts(pck_dst, ts);
+			if (!pctx->fake_dts_set && pctx->fake_dts) {
+				s64 offset = pctx->fake_dts;
+				gf_filter_pid_set_property(pctx->pid, GF_PROP_PID_DELAY, &PROP_LONGSINT( -offset) );
+				pctx->fake_dts_set = GF_TRUE;
+			}
+		} else {
+			//trick for some demuxers in libavformat no setting dts when negative (mkv for ex)
+			ts = pctx->fake_dts;
+			gf_filter_pck_set_dts(pck_dst, ts);
+			pctx->fake_dts += pkt->duration;
 		}
 
 		if (pkt->duration)
@@ -324,14 +529,38 @@
 	if (pkt->flags & AV_PKT_FLAG_CORRUPT)
 		gf_filter_pck_set_corrupted(pck_dst, GF_TRUE);
 
-	gf_net_get_utc();
-
 	if (ctx->raw_data) {
 		u64 ntp = gf_net_get_ntp_ts();
 		gf_filter_pck_set_property(pck_dst, GF_PROP_PCK_SENDER_NTP, &PROP_LONGUINT(ntp) );
 	}
+	if (check_webvtt) {
+		for (i=0; i < (u32) pkt->side_data_elems; i++) {
+			AVPacketSideData *sd = &pkt->side_datai;
+			if (!sd->data) continue;
+			if ((sd->type == AV_PKT_DATA_WEBVTT_IDENTIFIER) || (sd->type == AV_PKT_DATA_WEBVTT_SETTINGS)) {
+				u8 *d = gf_malloc(sd->size+1);
+				if (d) {
+					memcpy(d, sd->data, sd->size);
+					dsd->size=0;
+					if (sd->type == AV_PKT_DATA_WEBVTT_SETTINGS)
+						gf_filter_pck_set_property_str(pck_dst, "vtt_settings", &PROP_STRING_NO_COPY(d) );
+					else
+						gf_filter_pck_set_property_str(pck_dst, "vtt_cueid", &PROP_STRING_NO_COPY(d) );
+				}
+			} else if ((sd->type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL) && (sd->size>8)) {
+				u8 *d = gf_malloc(sd->size-7);
+				if (d) {
+					memcpy(d, sd->data+8, sd->size-8);
+					dsd->size-8=0;
+					gf_filter_pck_set_property_str(pck_dst, "vtt_pre", &PROP_STRING_NO_COPY(d) );
+				}
+			}
+		}
+	}
+
 	e = gf_filter_pck_send(pck_dst);
 ctx->nb_pck_sent++;
+	ctx->nb_stop_pending=0;
 	if (!ctx->raw_pck_out) {
 		FF_FREE_PCK(pkt);
 	}
@@ -341,37 +570,120 @@
 
 static GF_Err ffdmx_update_arg(GF_Filter *filter, const char *arg_name, const GF_PropertyValue *arg_val)
 {
-	s32 res;
 	GF_FFDemuxCtx *ctx = gf_filter_get_udta(filter);
+	return ffmpeg_update_arg(ctx->fname, ctx->demuxer, &ctx->options, arg_name, arg_val);
+}
 
-	//initial parsing of arguments
-	if (!ctx->initialized) {
-		switch (arg_val->type) {
-		case GF_PROP_STRING:
-			res = av_dict_set(&ctx->options, arg_name, arg_val->value.string, 0);
-			if (res<0) {
-				GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Failed to set option %s:%s\n", ctx->fname, arg_name, arg_val ));
-			}
-			break;
-		default:
-			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Failed to set option %s:%s, unrecognized type %d\n", ctx->fname, arg_name, arg_val, arg_val->type ));
-			return GF_NOT_SUPPORTED;
+#include <gpac/mpeg4_odf.h>
+#include <gpac/avparse.h>
+/* probe DSI syntax - if valid according to our own representation, we're good to go otherwise we'll need a reframer
+
+This is needed because libavformat does not always expose the same dsi syntax depending on mux types (!)
+*/
+static u32 ffdmx_valid_should_reframe(u32 gpac_codec_id, u8 *dsi, u32 dsi_size)
+{
+	GF_AC3Config ac3;
+	GF_M4ADecSpecInfo aaccfg;
+	GF_AVCConfig *avcc;
+	GF_HEVCConfig *hvcc;
+	GF_VVCConfig *vvcc;
+	GF_AV1Config *av1c;
+	GF_VPConfig *vpxc;
+
+	if (!dsi_size) dsi = NULL;
+
+	switch (gpac_codec_id) {
+	//force reframer for the following formats if no DSI is found
+	case GF_CODECID_AC3:
+	case GF_CODECID_EAC3:
+		if (dsi && (gf_odf_ac3_config_parse(dsi, dsi_size, (gpac_codec_id==GF_CODECID_EAC3) ? GF_TRUE : GF_FALSE, &ac3) == GF_OK))
+			return 0;
+		return 1;
+
+	case GF_CODECID_AAC_MPEG4:
+	case GF_CODECID_AAC_MPEG2_MP:
+	case GF_CODECID_AAC_MPEG2_LCP:
+	case GF_CODECID_AAC_MPEG2_SSRP:
+		if (dsi && (gf_m4a_get_config(dsi, dsi_size, &aaccfg) == GF_OK))
+			return 0;
+		return 1;
+
+	case GF_CODECID_FLAC:
+		if (!dsi) return 1;
+		break;
+	case GF_CODECID_AVC:
+		avcc = dsi ? gf_odf_avc_cfg_read(dsi, dsi_size) : NULL;
+		if (avcc) {
+			gf_odf_avc_cfg_del(avcc);
+			return 0;
 		}
-		return GF_OK;
+		return 1;
+	case GF_CODECID_HEVC:
+		hvcc = dsi ? gf_odf_hevc_cfg_read(dsi, dsi_size, GF_FALSE) : NULL;
+		if (hvcc) {
+			gf_odf_hevc_cfg_del(hvcc);
+			return 0;
+		}
+		return 1;
+	case GF_CODECID_VVC:
+		vvcc = dsi ? gf_odf_vvc_cfg_read(dsi, dsi_size) : NULL;
+		if (vvcc) {
+			gf_odf_vvc_cfg_del(vvcc);
+			return 0;
+		}
+		return 1;
+	case GF_CODECID_AV1:
+		av1c = dsi ? gf_odf_av1_cfg_read(dsi, dsi_size) : NULL;
+		if (av1c) {
+			gf_odf_av1_cfg_del(av1c);
+			return 0;
+		}
+		return 1;
+	case GF_CODECID_VP8:
+	case GF_CODECID_VP9:
+		vpxc = dsi ? gf_odf_vp_cfg_read(dsi, dsi_size) : NULL;
+		if (vpxc) {
+			gf_odf_vp_cfg_del(vpxc);
+			return 0;
+		}
+		return 1;
+	//force reframer for the following formats regardless of DSI and drop it
+	case GF_CODECID_MPEG1:
+	case GF_CODECID_MPEG2_422:
+	case GF_CODECID_MPEG2_SNR:
+	case GF_CODECID_MPEG2_HIGH:
+	case GF_CODECID_MPEG2_MAIN:
+	case GF_CODECID_MPEG2_SIMPLE:
+	case GF_CODECID_MPEG2_SPATIAL:
+	case GF_CODECID_MPEG4_PART2:
+		return 1;
+
+	//SRT or other subs: sample data is the raw text but timing is at packet level, force a reframer to parse styles and other
+	//keep dsi if any (for webvtt in mkv)
+	case GF_CODECID_SUBS_TEXT:
+	case GF_CODECID_WEBVTT:
+	case GF_CODECID_SUBS_SSA:
+		return 2;
+
+	//all other codecs are reframed
+	default:
+		break;
 	}
-	//updates of arguments, not supported for ffmpeg demuxers
-	return GF_NOT_SUPPORTED;
+	return 0;
 }
 
-GF_Err ffdmx_init_common(GF_Filter *filter, GF_FFDemuxCtx *ctx, Bool is_grab)
+GF_Err ffdmx_init_common(GF_Filter *filter, GF_FFDemuxCtx *ctx, u32 grab_type)
 {
 	u32 i;
-	u32 nb_a, nb_v;
-#ifdef FF_SUB_SUPPORT
-	u32 nb_t = 0;
-#endif
+	u32 nb_a, nb_v, nb_t, clock_id;
 	char szName50;
 
+
+	if (gf_filter_is_temporary(filter)) {
+		gf_filter_meta_set_instances(filter, ctx->demuxer->av_class->class_name);
+		return GF_OK;
+	}
+
 #if (LIBAVCODEC_VERSION_MAJOR >= 59)
 	ctx->pkt = av_packet_alloc();
 #endif
@@ -380,10 +692,31 @@
 	memset(ctx->pids_ctx, 0, sizeof(PidCtx)*ctx->demuxer->nb_streams);
 	ctx->nb_streams = ctx->demuxer->nb_streams;
 
-	nb_a = nb_v = 0;
+	clock_id = 0;
+	for (i = 0; i < ctx->demuxer->nb_streams; i++) {
+		AVStream *stream = ctx->demuxer->streamsi;
+#if (LIBAVFORMAT_VERSION_MAJOR < 59)
+		AVCodecContext *codec = stream->codec;
+		u32 codec_type = codec->codec_type;
+#else
+		u32 codec_type = stream->codecpar->codec_type;
+#endif
+		switch(codec_type) {
+		case AVMEDIA_TYPE_AUDIO:
+			if (!clock_id) clock_id = stream->id ? stream->id : i+1;
+			break;
+		case AVMEDIA_TYPE_VIDEO:
+			clock_id = stream->id ? stream->id : i+1;
+			break;
+		}
+	}
+
+	nb_a = nb_v = nb_t = 0;
 	for (i = 0; i < ctx->demuxer->nb_streams; i++) {
 		GF_FilterPid *pid=NULL;
-		Bool force_reframer = GF_FALSE;
+		PidCtx *pctx;
+		u32 j;
+		u32 force_reframer = 0;
 		Bool expose_ffdec=GF_FALSE;
 		u32 gpac_codec_id;
 		AVStream *stream = ctx->demuxer->streamsi;
@@ -401,6 +734,7 @@
 		u32 codec_field_order = codec->field_order;
 		u32 codec_tag = codec->codec_tag;
 		u32 codec_pixfmt = codec->pix_fmt;
+		u32 codec_blockalign = 0;
 		AVRational codec_framerate = {0, 0};
 #if LIBAVCODEC_VERSION_MAJOR >= 58
 		codec_framerate = codec->framerate;
@@ -423,11 +757,17 @@
 		u32 codec_pixfmt = (codec_type==AVMEDIA_TYPE_VIDEO) ? stream->codecpar->format : 0;
 		s32 codec_sample_fmt = (codec_type==AVMEDIA_TYPE_AUDIO) ? stream->codecpar->format : 0;
 		u32 codec_bitrate = (u32) stream->codecpar->bit_rate;
+		u32 codec_blockalign = (u32) stream->codecpar->block_align;
 		AVRational codec_framerate = stream->r_frame_rate;
 		if (!stream->r_frame_rate.num || !stream->r_frame_rate.den)
 			codec_framerate = stream->avg_frame_rate;
 #endif
 
+		//if fps was detected by ffavin, use it (r_frame_rate is unreliable, just a guess)
+		if (ctx->fps_forced.num) {
+			codec_framerate.num = ctx->fps_forced.num;
+			codec_framerate.den = ctx->fps_forced.den;
+		}
 		switch(codec_type) {
 		case AVMEDIA_TYPE_AUDIO:
 			pid = gf_filter_pid_new(filter);
@@ -448,7 +788,6 @@
 			if (ctx->video_idx<0)
 				ctx->video_idx = i;
 			break;
-#ifdef FF_SUB_SUPPORT
 		case AVMEDIA_TYPE_SUBTITLE:
 			pid = gf_filter_pid_new(filter);
 			if (!pid) return GF_OUT_OF_MEM;
@@ -456,17 +795,17 @@
 			nb_t++;
 			sprintf(szName, "text%d", nb_t);
 			break;
-#endif
 		default:
 			sprintf(szName, "ffdmx%d", i+1);
 			break;
 		}
 		if (!pid) continue;
-		ctx->pids_ctxi.pid = pid;
-		ctx->pids_ctxi.ts_offset = 0;
+		pctx = &ctx->pids_ctxi;
+		pctx->pid = pid;
+		pctx->ts_offset = 0;
 		gf_filter_pid_set_udta(pid, stream);
 
-		gf_filter_pid_set_property(pid, GF_PROP_PID_ID, &PROP_UINT(stream->id ? stream->id : i+1) );
+		gf_filter_pid_set_property(pid, GF_PROP_PID_ID, &PROP_UINT( (stream->id ? stream->id : i+1)) );
 		gf_filter_pid_set_name(pid, szName);
 
 		if (ctx->raw_data && ctx->sclock) {
@@ -474,6 +813,8 @@
 		} else {
 			gf_filter_pid_set_property(pid, GF_PROP_PID_TIMESCALE, &PROP_UINT(stream->time_base.den) );
 		}
+		if (clock_id)
+			gf_filter_pid_set_property(pid, GF_PROP_PID_CLOCK_ID, &PROP_UINT(clock_id) );
 
 		if (!ctx->raw_data) {
 			if (stream->duration>=0)
@@ -485,16 +826,7 @@
 		if (stream->sample_aspect_ratio.num && stream->sample_aspect_ratio.den)
 			gf_filter_pid_set_property(pid, GF_PROP_PID_SAR, &PROP_FRAC_INT( stream->sample_aspect_ratio.num, stream->sample_aspect_ratio.den ) );
 
-		if (stream->metadata) {
-			AVDictionaryEntry *ent=NULL;
-			while (1) {
-				ent = av_dict_get(stream->metadata, "", ent, AV_DICT_IGNORE_SUFFIX);
-				if (!ent) break;
-
-				//we use the same syntax as ffmpeg here
-				gf_filter_pid_set_property_str(pid, ent->key, &PROP_STRING(ent->value) );
-			}
-		}
+		ffmpeg_tags_to_gpac(stream->metadata, pid);
 
 		gpac_codec_id = ffmpeg_codecid_to_gpac(codec_id);
 		if (!gpac_codec_id) {
@@ -504,34 +836,25 @@
 			gf_filter_pid_set_property(pid, GF_PROP_PID_CODECID, &PROP_UINT(gpac_codec_id) );
 		}
 
-		if (is_grab)
-			gf_filter_pid_set_property(pid, GF_PROP_PID_RAWGRAB, &PROP_BOOL(GF_TRUE) );
+		if (grab_type)
+			gf_filter_pid_set_property(pid, GF_PROP_PID_RAWGRAB, &PROP_UINT(grab_type) );
 		else if (ctx->demuxer->iformat) {
 			if ((ctx->demuxer->iformat->flags & AVFMT_SEEK_TO_PTS) || ctx->demuxer->iformat->read_seek)
 				gf_filter_pid_set_property(pid, GF_PROP_PID_PLAYBACK_MODE, &PROP_UINT(GF_PLAYBACK_MODE_FASTFORWARD ) );
 		}
 
-		//force reframer for the following formats if no DSI is found
-		if (!exdata_size) {
-			switch (gpac_codec_id) {
-			case GF_CODECID_AC3:
-			case GF_CODECID_AAC_MPEG4:
-			case GF_CODECID_AAC_MPEG2_MP:
-			case GF_CODECID_AAC_MPEG2_LCP:
-			case GF_CODECID_AAC_MPEG2_SSRP:
-			case GF_CODECID_AVC:
-			case GF_CODECID_HEVC:
-			case GF_CODECID_AV1:
-				force_reframer = GF_TRUE;
-				break;
-			}
-		}
+
+		u32 lt = gf_log_get_tool_level(GF_LOG_CODING);
+		gf_log_set_tool_level(GF_LOG_CODING, GF_LOG_QUIET);
+		force_reframer = ffdmx_valid_should_reframe(gpac_codec_id, (u8 *) exdata, exdata_size);
+		gf_log_set_tool_level(GF_LOG_CODING, lt);
+
 		if (expose_ffdec) {
 			const char *cname = avcodec_get_name(codec_id);
 #if (LIBAVFORMAT_VERSION_MAJOR < 59)
-			gf_filter_pid_set_property(pid, GF_PROP_PID_FFMPEG_CODEC_ID, &PROP_POINTER( (void*)codec ) );
+			gf_filter_pid_set_property(pid, GF_PROP_PID_META_DEMUX_CODEC_ID, &PROP_POINTER( (void*)codec ) );
 #else
-			gf_filter_pid_set_property(pid, GF_PROP_PID_FFMPEG_CODEC_ID, &PROP_UINT( codec_id ) );
+			gf_filter_pid_set_property(pid, GF_PROP_PID_META_DEMUX_CODEC_ID, &PROP_UINT( codec_id ) );
 			if (exdata) {
 				//expose as const data
 				gf_filter_pid_set_property(pid, GF_PROP_PID_DECODER_CONFIG, &PROP_CONST_DATA( (char *)exdata, exdata_size) );
@@ -539,25 +862,42 @@
 #endif
 
 			if (cname)
-				gf_filter_pid_set_property_str(pid, "ffmpeg:codec", &PROP_STRING(cname ) );
+				gf_filter_pid_set_property(pid, GF_PROP_PID_META_DEMUX_CODEC_NAME, &PROP_STRING(cname ) );
 		} else if (exdata_size) {
 
 			//avc/hevc read by ffmpeg is still in annex B format
 			if (ctx->demuxer->iformat) {
-				if (!strcmp(ctx->demuxer->iformat->name, "h264") || !strcmp(ctx->demuxer->iformat->name, "hevc")) {
-					force_reframer = GF_TRUE;
+				if (!strcmp(ctx->demuxer->iformat->name, "h264")
+					|| !strcmp(ctx->demuxer->iformat->name, "hevc")
+					|| !strcmp(ctx->demuxer->iformat->name, "vvc")
+				) {
+					force_reframer = 1;
 				}
 			}
 
-			if (!force_reframer) {
-				//expose as const data
-				gf_filter_pid_set_property(pid, GF_PROP_PID_DECODER_CONFIG, &PROP_CONST_DATA( (char *)exdata, exdata_size) );
+			//set extra data if desired
+			if (force_reframer!=1) {
+				ffdmx_set_decoder_config(pctx, exdata, exdata_size, gpac_codec_id);
 			}
 		}
 
 		if (force_reframer) {
 			gf_filter_pid_set_property(pid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
 		}
+#ifdef FFMPEG_NO_DOVI
+		else if (!gf_sys_is_test_mode() ){
+			//force reparse of nalu-base codecs if no dovi support 
+			switch (gpac_codec_id) {
+			case GF_CODECID_AVC:
+			case GF_CODECID_HEVC:
+			case GF_CODECID_LHVC:
+			case GF_CODECID_VVC:
+				gf_filter_pid_set_property(pid, GF_PROP_PID_FORCE_UNFRAME, &PROP_BOOL(GF_TRUE) );
+				gf_filter_pid_set_property(pid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
+				break;
+			}
+		}
+#endif
 
 
 		if (codec_sample_rate)
@@ -573,9 +913,10 @@
 			gf_filter_pid_set_property(pid, GF_PROP_PID_HEIGHT, &PROP_UINT( codec_height ) );
 
 		if (codec_width && codec_height) {
-			if (codec_framerate.num && codec_framerate.den)
+			if (codec_framerate.num && codec_framerate.den) {
+				gf_media_get_reduced_frame_rate(&codec_framerate.num, &codec_framerate.den);
 				gf_filter_pid_set_property(pid, GF_PROP_PID_FPS, &PROP_FRAC_INT( codec_framerate.num, codec_framerate.den ) );
-			else {
+			} else {
 				GF_LOG(GF_LOG_WARNING, ctx->log_class, ("%s Unknown frame rate, will use 25 fps - use `:#FPS=VAL` to force frame rate signaling\n", ctx->fname));
 				gf_filter_pid_set_property(pid, GF_PROP_PID_FPS, &PROP_FRAC_INT( 25, 1 ) );
 			}
@@ -606,6 +947,13 @@
 			}
 		}
 
+		if (codec_type==AVMEDIA_TYPE_SUBTITLE) {
+			gf_filter_pid_set_property(pid, GF_PROP_PID_SUBTYPE, &PROP_UINT(GF_4CC('s','b','t','l')));
+		}
+
+		ctx->pids_ctxi.mkv_webvtt = GF_FALSE;
+		if ((gpac_codec_id==GF_CODECID_WEBVTT) && strstr(ctx->demuxer->iformat->name, "matroska"))
+			ctx->pids_ctxi.mkv_webvtt = GF_TRUE;
 
 		if (codec_sample_fmt>0) {
 			u32 sfmt = 0;
@@ -630,13 +978,21 @@
 			gf_filter_pid_set_property(pid, GF_PROP_PID_BITRATE, &PROP_UINT( (u32) codec_bitrate ) );
 
 		gf_filter_pid_set_property(pid, GF_PROP_PID_URL, &PROP_STRING( AVFMT_URL(ctx->demuxer) ));
+
+		if (gf_file_exists(ctx->src)) {
+			gf_filter_pid_set_property(pid, GF_PROP_PID_FILE_CACHED, &PROP_BOOL(GF_TRUE));
+		}
+
+		if (codec_blockalign)
+			gf_filter_pid_set_property(pid, GF_PROP_PID_META_DEMUX_OPAQUE, &PROP_UINT(codec_blockalign));
+
+
+		for (j=0; j<(u32) stream->nb_side_data; j++) {
+			ffdmx_parse_side_data(&stream->side_datai, pid);
+		}
 	}
 
-	if (!nb_a && !nb_v
-#ifdef FF_SUB_SUPPORT
-		&& !nb_t
-#endif
-	)
+	if (!nb_a && !nb_v && !nb_t)
 		return GF_NOT_SUPPORTED;
 
 	return GF_OK;
@@ -664,6 +1020,7 @@
 	return (int64_t) gf_fseek(ctx->gfio, offset, whence);
 }
 
+#include <libavutil/avstring.h>
 static GF_Err ffdmx_initialize(GF_Filter *filter)
 {
 	GF_FFDemuxCtx *ctx = gf_filter_get_udta(filter);
@@ -677,11 +1034,13 @@
 
 	ffmpeg_setup_logs(ctx->log_class);
 
-	ctx->initialized = GF_TRUE;
 #ifdef GPAC_ENABLE_COVERAGE
 	if (gf_sys_is_cov_mode()) {
-		ffdmx_update_arg(filter, NULL, NULL);
+		ffdmx_update_arg(filter, "foo", &PROP_STRING_NO_COPY("bar"));
 		ffmpeg_pixfmt_from_codec_tag(0, NULL);
+#if (LIBAVCODEC_VERSION_MAJOR > 56)
+		ffmpeg_codec_par_to_gpac(NULL, NULL, 0);
+#endif
 	}
 #endif
 	if (!ctx->src) {
@@ -744,6 +1103,29 @@
 		e = GF_NOT_SUPPORTED;
 		break;
 	}
+
+	if (e && gf_filter_is_temporary(filter)) {
+		ext = strrchr(ctx->src, '.');
+		const AVInputFormat *ifmt = av_find_input_format(ctx->src);
+		if (!ifmt && ext) ifmt = av_find_input_format(ext+1);
+#if (LIBAVFORMAT_VERSION_MAJOR>=59)
+		if (!ifmt && ext) {
+			const AVInputFormat *fmt = NULL;
+			void *i = 0;
+			while ((fmt = av_demuxer_iterate(&i))) {
+				if (av_match_name(ext+1, fmt->extensions)) {
+					ifmt = fmt;
+					break;
+				}
+			}
+		}
+#endif
+		if (ifmt) {
+			gf_filter_meta_set_instances(filter, ifmt->name);
+			return GF_OK;
+		}
+	}
+
 	if (e) {
 		GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Fail to open %s - error %s\n", ctx->fname, ctx->src, av_err2str(res) ));
 		avformat_close_input(&ctx->demuxer);
@@ -758,13 +1140,14 @@
 		e = GF_NOT_SUPPORTED;
 		avformat_close_input(&ctx->demuxer);
 		avformat_free_context(ctx->demuxer);
+		ctx->demuxer = NULL;
 		if (options) av_dict_free(&options);
 		return e;
 	}
 	GF_LOG(GF_LOG_DEBUG, ctx->log_class, ("%s file %s opened - %d streams\n", ctx->fname, ctx->src, ctx->demuxer->nb_streams));
 
 	ffmpeg_report_options(filter, options, ctx->options);
-	return ffdmx_init_common(filter, ctx, GF_FALSE);
+	return ffdmx_init_common(filter, ctx, 0);
 }
 
 
@@ -774,6 +1157,24 @@
 
 	switch (evt->base.type) {
 	case GF_FEVT_PLAY:
+		if (evt->play.initial_broadcast_play==2)
+			return GF_TRUE;
+
+		ctx->nb_playing++;
+		if (ctx->nb_playing>1) {
+			Bool skip_com = GF_TRUE;
+			//PLAY/STOP may arrive at different times depending on the length of filter chains on each PID
+			//we stack number of STOP received and trigger seek when we have the same amount of play
+			if (ctx->nb_stop_pending==ctx->nb_playing) {
+				skip_com = GF_FALSE;
+				ctx->last_play_start_range = 0;
+			}
+			if (skip_com) {
+				return GF_TRUE;
+			}
+			ctx->nb_playing--;
+		}
+
 		//change in play range
 		if (!ctx->raw_data && (ctx->last_play_start_range != evt->play.start_range)) {
 			u32 i;
@@ -782,26 +1183,23 @@
 				GF_LOG(GF_LOG_WARNING, ctx->log_class, ("%s Fail to seek %s to %g - error %s\n", ctx->fname, ctx->src, evt->play.start_range, av_err2str(res) ));
 			}
 			//reset initial delay compute
-			for (i=0; i<ctx->demuxer->nb_streams; i++) {
+			for (i=0; i<ctx->nb_streams; i++) {
 				ctx->pids_ctxi.ts_offset = 0;
 			}
 			ctx->last_play_start_range = evt->play.start_range;
 		}
-		else if (!ctx->nb_playing) {
-			ctx->last_play_start_range = evt->play.start_range;
-		}
-		ctx->nb_playing++;
 		ctx->stop_seen = GF_FALSE;
 		//cancel event
 		return GF_TRUE;
 
 	case GF_FEVT_STOP:
+		if (evt->play.initial_broadcast_play==2)
+			return GF_TRUE;
+		ctx->nb_stop_pending++;
 		if (ctx->nb_playing) {
 			ctx->nb_playing--;
 			ctx->stop_seen = GF_TRUE;
 		}
-		if (ctx->nb_pck_sent)
-			ctx->last_play_start_range = -1;
 		//cancel event
 		return GF_TRUE;
 
@@ -821,6 +1219,13 @@
 	if (!strncmp(url, "audio://", 8)) return GF_FPROBE_NOT_SUPPORTED;
 	if (!strncmp(url, "av://", 5)) return GF_FPROBE_NOT_SUPPORTED;
 	if (!strncmp(url, "pipe://", 7)) return GF_FPROBE_NOT_SUPPORTED;
+
+	const char *ext = gf_file_ext_start(url);
+	if (ext) {
+		const AVInputFormat *f = av_find_input_format(ext+1);
+		if (!f)
+			return GF_FPROBE_MAYBE_NOT_SUPPORTED;
+	}
 	return GF_FPROBE_MAYBE_SUPPORTED;
 }
 
@@ -839,15 +1244,22 @@
 	//not setting this crashes some probers in ffmpeg
 	pb.filename = "";
 	if (size <= AVPROBE_PADDING_SIZE) {
-		pb.buf = gf_malloc(sizeof(char)*(size+AVPROBE_PADDING_SIZE) );
+		pb.buf = gf_malloc(sizeof(char) * (size+AVPROBE_PADDING_SIZE) );
 		memcpy(pb.buf, data, sizeof(char)*size);
+		memset(pb.buf+size, 0, sizeof(char)*AVPROBE_PADDING_SIZE);
 		pb.buf_size = size;
-		probe_fmt = av_probe_input_format3(&pb, GF_FALSE, &ffscore);
+		probe_fmt = av_probe_input_format3(&pb, GF_TRUE, &ffscore);
+		if (ffscore<=AVPROBE_SCORE_RETRY/2) probe_fmt=NULL;
+		if (!probe_fmt) probe_fmt = av_probe_input_format3(&pb, GF_FALSE, &ffscore);
+		if (ffscore<=AVPROBE_SCORE_RETRY/2) probe_fmt=NULL;
 		gf_free(pb.buf);
 	} else {
 		pb.buf = (char *) data;
 		pb.buf_size = size - AVPROBE_PADDING_SIZE;
-		probe_fmt = av_probe_input_format3(&pb, GF_FALSE, &ffscore);
+		probe_fmt = av_probe_input_format3(&pb, GF_TRUE, &ffscore);
+		if (ffscore<=AVPROBE_SCORE_RETRY/2) probe_fmt=NULL;
+		if (!probe_fmt) probe_fmt = av_probe_input_format3(&pb, GF_FALSE, &ffscore);
+		if (ffscore<=AVPROBE_SCORE_RETRY/2) probe_fmt=NULL;
 	}
 
 	if (!probe_fmt) return NULL;
@@ -856,7 +1268,8 @@
 		*score = GF_FPROBE_MAYBE_SUPPORTED;
 		return probe_fmt->mime_type;
 	}
-	return NULL;
+	*score = (ffscore==AVPROBE_SCORE_MAX) ? GF_FPROBE_MAYBE_SUPPORTED : GF_FPROBE_MAYBE_NOT_SUPPORTED;
+	return "video/x-ffmpeg";
 }
 
 #define OFFS(_n)	#_n, offsetof(GF_FFDemuxCtx, _n)
@@ -865,6 +1278,12 @@
 {
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	{0},
+	//for forced frame->unframe
+	CAP_UINT(GF_CAPS_OUTPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
+	CAP_BOOL(GF_CAPS_OUTPUT,GF_PROP_PID_FORCE_UNFRAME, GF_TRUE),
+	CAP_BOOL(GF_CAPS_OUTPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
 };
 
 
@@ -902,8 +1321,7 @@
 
 const GF_FilterRegister *ffdmx_register(GF_FilterSession *session)
 {
-	ffmpeg_build_register(session, &FFDemuxRegister, FFDemuxArgs, 2, FF_REG_TYPE_DEMUX);
-	return &FFDemuxRegister;
+	return ffmpeg_build_register(session, &FFDemuxRegister, FFDemuxArgs, 2, FF_REG_TYPE_DEMUX);
 }
 
 
@@ -925,7 +1343,7 @@
 	ffmpeg_setup_logs(ctx->log_class);
 
 	avdevice_register_all();
-	ctx->initialized = GF_TRUE;
+
 	if (!ctx->src) {
 		GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s No source URL specified, expecting video://, audio:/ or av://\n", ctx->fname));
 		return GF_SERVICE_ERROR;
@@ -936,6 +1354,8 @@
 		default_fmt = "dshow";
 #elif defined(__DARWIN) || defined(__APPLE__)
 		default_fmt = "avfoundation";
+#elif defined(GPAC_CONFIG_ANDROID)
+		default_fmt = "android_camera";
 #else
 		default_fmt = "video4linux2";
 #endif
@@ -944,11 +1364,11 @@
 	if (default_fmt) {
 		dev_fmt = av_find_input_format(default_fmt);
 		if (dev_fmt == NULL) {
-			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Cannot find the input format %s\n", ctx->fname, ctx->fmt));
+			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Cannot find the input format %s\n", ctx->fname, default_fmt));
 		}
 #if LIBAVCODEC_VERSION_MAJOR >= 58
 		else if (dev_fmt->priv_class->category != AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT && dev_fmt->priv_class->category != AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT) {
-			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s %s is neither a video nor an audio input device\n", ctx->fname, ctx->fmt));
+			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s %s is neither a video nor an audio input device\n", ctx->fname, default_fmt));
 			dev_fmt = NULL;
 		}
 #else
@@ -1011,7 +1431,8 @@
 		dev_name = (char *) szPatchedName;
 	}
 #if defined(__APPLE__) && !defined(GPAC_CONFIG_IOS)
-	else if (!strncmp(dev_fmt->priv_class->class_name, "AVFoundation", 12) && wants_audio) {
+	else if (!strncmp(dev_fmt->priv_class->class_name, "AVFoundation", 12) && wants_audio && !wants_video) {
+		//for avfoundation if no video, we must use ":audio_dev_idx"
 		if (ctx->dev0 != ':') {
 			strcpy(szPatchedName, ":");
 			strcat(szPatchedName, ctx->dev);
@@ -1030,25 +1451,53 @@
 	res = avformat_open_input(&ctx->demuxer, dev_name, FF_IFMT_CAST dev_fmt, &options);
 	if ( (res < 0) && !stricmp(ctx->dev, "screen-capture-recorder") ) {
 		GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Buggy screen capture input (open failed with code %d), retrying without specifying resolution\n", ctx->fname, res));
+		av_dict_free(&options);
+		options = NULL;
+		av_dict_copy(&options, ctx->options, 0);
 		av_dict_set(&options, "video_size", NULL, 0);
 		res = avformat_open_input(&ctx->demuxer, ctx->dev, FF_IFMT_CAST dev_fmt, &options);
 	}
 
 	if (res < 0) {
-		if (options) {
+		av_dict_free(&options);
+		options = NULL;
+		av_dict_copy(&options, ctx->options, 0);
+		av_dict_set(&options, "framerate", "30", 0);
+		ctx->fps_forced.num = 30;
+		ctx->fps_forced.den = 1;
+		GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Error %d opening input - retrying with 30 fps\n", ctx->fname, res));
+		res = avformat_open_input(&ctx->demuxer, dev_name, FF_IFMT_CAST dev_fmt, &options);
+		if (res < 0) {
 			av_dict_free(&options);
 			options = NULL;
-			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Error %d opening input - retrying without options\n", ctx->fname, res));
-			res = avformat_open_input(&ctx->demuxer, dev_name, FF_IFMT_CAST dev_fmt, NULL);
-		}
-		if (res<0) {
-			av_dict_set(&options, "framerate", "30", 0);
-			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Error %d opening input - retrying with 30 fps\n", ctx->fname, res));
+			av_dict_copy(&options, ctx->options, 0);
+			av_dict_set(&options, "framerate", "25", 0);
+			GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Error %d opening input - retrying with 25 fps\n", ctx->fname, res));
+			ctx->fps_forced.num = 25;
 			res = avformat_open_input(&ctx->demuxer, dev_name, FF_IFMT_CAST dev_fmt, &options);
-			if (res < 0) {
-				av_dict_set(&options, "framerate", "25", 0);
-				GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Error %d opening input - retrying with 25 fps\n", ctx->fname, res));
-				res = avformat_open_input(&ctx->demuxer, dev_name, FF_IFMT_CAST dev_fmt, &options);
+
+			if ((res<0) && options) {
+				av_dict_free(&options);
+				options = NULL;
+				ctx->fps_forced.num = 0;
+				GF_LOG(GF_LOG_ERROR, ctx->log_class, ("%s Error %d opening input - retrying without options\n", ctx->fname, res));
+				res = avformat_open_input(&ctx->demuxer, dev_name, FF_IFMT_CAST dev_fmt, NULL);
+			}
+		}
+	} else {
+		AVDictionaryEntry *key = NULL;
+		while (1) {
+			key = av_dict_get(ctx->options, "", key, AV_DICT_IGNORE_SUFFIX);
+			if (!key) break;
+			if (!strcmp(key->key, "framerate")) {
+				char *fps = key->value;
+				if (strchr(fps, '.')) {
+					ctx->fps_forced.num = (u32) (atoi(fps)*1000);
+					ctx->fps_forced.den = 1000;
+				} else {
+					ctx->fps_forced.num = atoi(fps);
+					ctx->fps_forced.den = 1;
+				}
 			}
 		}
 	}
@@ -1062,6 +1511,11 @@
 	av_dump_format(ctx->demuxer, 0, ctx->dev, 0);
 	ctx->raw_data = GF_TRUE;
 	ctx->audio_idx = ctx->video_idx = -1;
+	u32 grab_type = 1;
+#if defined(GPAC_CONFIG_IOS) || defined(GPAC_CONFIG_ANDROID)
+	if (!strcmp(ctx->dev, "1") || strstr(ctx->dev, "Front") || strstr(ctx->dev, "front") )
+		grab_type = 2;
+#endif
 
 	res = avformat_find_stream_info(ctx->demuxer, ctx->options ? &ctx->options : NULL);
 
@@ -1129,7 +1583,7 @@
 			GF_LOG(GF_LOG_WARNING, ctx->log_class, ("%s using muxed capture av:// without copy on %s, this might introduce packet losses due to blocking modes or delayed consumption of the frames. If experiencing problems, either set -copy() to `AV` or consider using two filters video:// and audio://\n", ctx->fname, (!ctx->copy_audio && !ctx->copy_video) ? "audio and video streams" : ctx->copy_video ? "audio stream" : "video stream"));
 		}
 	}
-	return ffdmx_init_common(filter, ctx, GF_TRUE);
+	return ffdmx_init_common(filter, ctx, grab_type);
 }
 
 static GF_FilterProbeScore ffavin_probe_url(const char *url, const char *mime)
@@ -1171,6 +1625,8 @@
 	"EX ffmpeg -f libndi_newtek -i MY_NDI_TEST ...\n"
 	"EX gpac -i av://:fmt=libndi_newtek:dev=MY_NDI_TEST ...\n"
 	"\n"
+	"You may need to escape the -dev() option if the format uses ':' as separator, as is the case for AVFoundation:\n"
+	"EX gpac -i av://::dev=0:1 ...\n"
 	)
 	.private_size = sizeof(GF_FFDemuxCtx),
 	SETCAPS(FFAVInCaps),
@@ -1206,10 +1662,146 @@
 //number of arguments defined above
 const int FFAVIN_STATIC_ARGS = (sizeof (FFAVInArgs) / sizeof (GF_FilterArgs)) - 1;
 
+
+#if (LIBAVCODEC_VERSION_MAJOR >= 58) && (LIBAVCODEC_VERSION_MINOR>=18) && !defined(GPAC_DISABLE_DOC)
+#define FF_PROBE_DEVICES
+#endif
+
+#ifdef FF_PROBE_DEVICES
+char *dev_desc = NULL;
+
+static void ffavin_enum_devices(const char *dev_name, Bool is_audio)
+{
+	const AVInputFormat *fmt;
+	AVFormatContext *ctx;
+
+ if (!dev_name) return;
+ fmt = av_find_input_format(dev_name);
+ if (!fmt) return;
+
+ if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category)) {
+		return;
+	}
+ ctx = avformat_alloc_context();
+ if (!ctx) return;
+ ctx->iformat = (AVInputFormat *)fmt;
+ if (ctx->iformat->priv_data_size > 0) {
+ ctx->priv_data = av_mallocz(ctx->iformat->priv_data_size);
+ if (!ctx->priv_data) {
+			avformat_free_context(ctx);
+ return;
+ }
+ if (ctx->iformat->priv_class) {
+ *(const AVClass**)ctx->priv_data = ctx->iformat->priv_class;
+ av_opt_set_defaults(ctx->priv_data);
+ }
+ } else {
+ ctx->priv_data = NULL;
+	}
+
+	AVDeviceInfoList *dev_list = NULL;
+
+ AVDictionary *tmp = NULL;
+	av_dict_set(&tmp, "list_devices", "1", 0);
+ av_opt_set_dict2(ctx, &tmp, AV_OPT_SEARCH_CHILDREN);
+
+	int res = avdevice_list_devices(ctx, &dev_list);
+	if (res<0) {
+		//device doesn't implement avdevice_list_devices, try loading the context using "list_devices=1" option
+		if (-res == ENOSYS) {
+			AVDictionary *opts = NULL;
+			av_dict_set(&opts, "list_devices", "1", 0);
+			res = avformat_open_input(&ctx, "dummy", FF_IFMT_CAST fmt, &opts);
+		}
+	} else if (!res && dev_list->nb_devices) {
+		if (!dev_desc) {
+			gf_dynstrcat(&dev_desc, "# Detected devices\n", NULL);
+		}
+		gf_dynstrcat(&dev_desc, dev_name, NULL);
+		gf_dynstrcat(&dev_desc, is_audio ? " audio" : " video", NULL);
+		gf_dynstrcat(&dev_desc, " devices\n", NULL);
+		for (int i=0; i<dev_list->nb_devices; i++) {
+			char szFmt20;
+			sprintf(szFmt, "%d ", i);
+			gf_dynstrcat(&dev_desc, dev_list->devicesi->device_name, szFmt);
+			gf_dynstrcat(&dev_desc, dev_list->devicesi->device_description, ": ");
+			gf_dynstrcat(&dev_desc, "\n", NULL);
+		}
+	}
+
+	if (dev_list) avdevice_free_list_devices(&dev_list);
+	avformat_free_context(ctx);
+}
+
+static void ffavin_log_none(void *avcl, int level, const char *fmt, va_list vl)
+{
+	if (level == AV_LOG_INFO) {
+		char szLogBuf2049;
+		vsnprintf(szLogBuf, 2048, fmt, vl);
+		szLogBuf2048=0;
+
+		if (!dev_desc) {
+			gf_dynstrcat(&dev_desc, "# Detected devices\n", NULL);
+		}
+		gf_dynstrcat(&dev_desc, szLogBuf, NULL);
+	}
+}
+#endif
+
 const GF_FilterRegister *ffavin_register(GF_FilterSession *session)
 {
-	ffmpeg_build_register(session, &FFAVInRegister, FFAVInArgs, FFAVIN_STATIC_ARGS, FF_REG_TYPE_DEV_IN);
-	return &FFAVInRegister;
+	GF_FilterRegister *res_reg = ffmpeg_build_register(session, &FFAVInRegister, FFAVInArgs, FFAVIN_STATIC_ARGS, FF_REG_TYPE_DEV_IN);
+
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_in_proto", FFAVInRegister.name, "video,audio,av");
+	}
+	if (!gf_opts_get_bool("temp", "helponly") || gf_opts_get_bool("temp", "gendoc"))
+		return res_reg;
+
+	//do not open devices if help is not for ffavin or a sub-filter
+	Bool found = GF_FALSE;
+	u32 i, argc = gf_sys_get_argc();
+	for (i=1; i<argc; i++) {
+		const char *a = gf_sys_get_arg(i);
+		if (!strncmp(a, "ffavin", 6)) {
+			found = GF_TRUE;
+			break;
+		}
+	}
+	if (!found)
+		return res_reg;
+
+#ifdef FF_PROBE_DEVICES
+	Bool audio_pass=GF_FALSE;
+	av_log_set_callback(ffavin_log_none);
+	const AVInputFormat *fmt = NULL;
+	while (1) {
+		if (audio_pass) {
+			fmt = av_input_audio_device_next(FF_IFMT_CAST fmt);
+		} else {
+			fmt = av_input_video_device_next(FF_IFMT_CAST fmt);
+		}
+		if (!fmt) {
+			if (audio_pass) break;
+			audio_pass = GF_TRUE;
+			continue;
+		}
+		if (!fmt->priv_class) continue;
+		if (audio_pass && (fmt->priv_class->category!=AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT)) continue;
+		else if (!audio_pass && (fmt->priv_class->category!=AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT)) continue;
+		ffavin_enum_devices(fmt->name, audio_pass);
+	}
+	av_log_set_callback(av_log_default_callback);
+	if (dev_desc) {
+		char *out_doc = NULL;
+		gf_dynstrcat(&out_doc, FFAVInRegister.help, NULL);
+		gf_dynstrcat(&out_doc, dev_desc, "\n");
+		gf_free(dev_desc);
+		res_reg->help = out_doc;
+		ffmpeg_register_set_dyn_help(res_reg);
+	}
+#endif
+	return res_reg;
 }
 
 #else

gpac-2.0.0.tar.gz/src/filters/ff_enc.c -> gpac-2.2.0.tar.gz/src/filters/ff_enc.c Changed

@@ -26,6 +26,7 @@
 #include <gpac/setup.h>
 #include <gpac/bitstream.h>
 #include <gpac/avparse.h>
+#include <gpac/internal/media_dev.h>
 
 #ifdef GPAC_HAS_FFMPEG
 
@@ -38,13 +39,13 @@
 	//opts
 	Bool all_intra;
 	char *c;
-	Bool ls;
+	Bool ls, rld;
 	u32 pfmt;
 	GF_Fraction fintra;
 	Bool rc;
 
 	//internal data
-	Bool initialized;
+	Bool gen_dsi;
 
 	u32 gop_size;
 	u32 target_rate;
@@ -85,7 +86,8 @@
 	u64 cts_first_frame_plus_one;
 
 	//audio state
-	u32 channels, sample_rate, channel_layout, bytes_per_sample;
+	u32 channels, sample_rate, bytes_per_sample;
+	u64 channel_layout;
 	//ffmpeg one
 	u32 sample_fmt;
 	//we store input audio frame in this buffer until we have enough data for one encoder frame
@@ -109,6 +111,7 @@
 	Bool infmt_negociate;
 	Bool remap_ts;
 	Bool force_reconfig;
+	u32 setup_failed;
 
 	u32 dsi_crc;
 
@@ -133,7 +136,9 @@
 	AVPacket *pkt;
 #endif
 
-	u32 premul_timescale;
+	Bool args_updated;
+
+	FILE *logfile_pass1;
 } GF_FFEncodeCtx;
 
 static GF_Err ffenc_configure_pid_ex(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove, Bool is_force_reconf);
@@ -168,7 +173,6 @@
 {
 	u32 codec_id;
 	GF_FFEncodeCtx *ctx = (GF_FFEncodeCtx *) gf_filter_get_udta(filter);
-	ctx->initialized = GF_TRUE;
 	ctx->src_packets = gf_list_new();
 	ctx->sdbs = gf_bs_new((u8*)ctx, 1, GF_BITSTREAM_READ);
 
@@ -193,6 +197,13 @@
 	}
 	if (!ctx->force_codec) return GF_NOT_SUPPORTED;
 	ffenc_override_caps(filter, ctx->force_codec->type);
+
+
+	if (gf_filter_is_temporary(filter)) {
+		gf_filter_meta_set_instances(filter, ctx->force_codec->name);
+		return GF_OK;
+	}
+
 	return GF_OK;
 }
 
@@ -214,7 +225,14 @@
 	av_packet_free(&ctx->pkt);
 #endif
 
+	if (ctx->logfile_pass1) {
+		if (ctx->encoder && ctx->encoder->stats_out) fprintf(ctx->logfile_pass1, "%s", ctx->encoder->stats_out);
+		gf_fclose(ctx->logfile_pass1);
+	}
+
 	if (ctx->encoder) {
+		if (ctx->encoder->stats_in)
+			gf_free(ctx->encoder->stats_in);
 		avcodec_free_context(&ctx->encoder);
 	}
 	if (ctx->sdbs) gf_bs_del(ctx->sdbs);
@@ -229,11 +247,11 @@
 	if (!ctx->codecid) {
 		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_FFMPEG) );
 		if (ctx->encoder) {
-			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_FFMPEG_CODEC_ID, &PROP_UINT(ctx->encoder->codec->id) );
+			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_META_DEMUX_CODEC_ID, &PROP_UINT(ctx->encoder->codec->id) );
 
 			const char *cname = avcodec_get_name(ctx->encoder->codec->id);
 			if (cname)
-				gf_filter_pid_set_property_str(ctx->out_pid, "ffmpeg:codec", &PROP_STRING(cname ) );
+				gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_META_DEMUX_CODEC_NAME, &PROP_STRING(cname ) );
 		}
 	} else {
 		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_CODECID, &PROP_UINT(ctx->codecid) );
@@ -242,16 +260,45 @@
 	gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_ISOM_SUBTYPE, NULL);
 	gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_PROFILE_LEVEL, NULL);
 
+	ctx->gen_dsi = GF_FALSE;
 	switch (ctx->codecid) {
+	//reframe all these codecs for proper ISOBMFF+DSI formating
 	case GF_CODECID_AVC:
 	case GF_CODECID_HEVC:
-	case GF_CODECID_MPEG4_PART2:
+	case GF_CODECID_VVC:
+	case GF_CODECID_AV1:
 		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
 		gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_UNFRAMED_FULL_AU, &PROP_BOOL(GF_TRUE) );
 		break;
+
+	//for these, we will need to generate dsi from first frame - this avoids using reframers only for DSI extraction
+	case GF_CODECID_MPEG1:
+	case GF_CODECID_MPEG2_422:
+	case GF_CODECID_MPEG2_SNR:
+	case GF_CODECID_MPEG2_HIGH:
+	case GF_CODECID_MPEG2_MAIN:
+	case GF_CODECID_MPEG2_SIMPLE:
+	case GF_CODECID_MPEG2_SPATIAL:
+	case GF_CODECID_MPEG4_PART2:
+	case GF_CODECID_VP8:
+	case GF_CODECID_VP9:
+	case GF_CODECID_VP10:
+	case GF_CODECID_AC3:
+	case GF_CODECID_EAC3:
+	case GF_CODECID_TRUEHD:
+		ctx->gen_dsi = GF_TRUE;
+		break;
+
+	case GF_CODECID_FLAC:
+	case GF_CODECID_OPUS:
+	case GF_CODECID_VORBIS:
 	default:
-		if (ctx->encoder && ctx->encoder->extradata_size && ctx->encoder->extradata) {
-			gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA(ctx->encoder->extradata, ctx->encoder->extradata_size) );
+		if (ctx->encoder && ctx->encoder->extradata) {
+			u8 *dsi;
+			u32 dsi_size;
+			GF_Err e = ffmpeg_extradata_to_gpac(ctx->codecid, ctx->encoder->extradata, ctx->encoder->extradata_size, &dsi, &dsi_size);
+			if (!e)
+				gf_filter_pid_set_property(ctx->out_pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, dsi_size) );
 		}
 		break;
 	}
@@ -271,6 +318,8 @@
 	}
 }
 
+
+
 static u64 ffenc_get_cts(GF_FFEncodeCtx *ctx, GF_FilterPacket *pck)
 {
 	u64 cts = gf_filter_pck_get_cts(pck);
@@ -372,11 +421,21 @@
 	pck = gf_filter_pid_get_packet(ctx->in_pid);
 
 	if (!ctx->encoder) {
-		if (ctx->infmt_negociate) return GF_OK;
+		//no encoder: if negociating input format or input pid props not known yet, wait
+		if (ctx->infmt_negociate || !ctx->setup_failed) return GF_OK;
 
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc encoder reconfiguration failed, aborting stream\n"));
-		gf_filter_pid_set_eos(ctx->out_pid);
-		return GF_EOS;
+		if (ctx->setup_failed==1) {
+			GF_FilterEvent fevt;
+
+			ctx->setup_failed = 2;
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc encoder reconfiguration failed, aborting stream\n"));
+			gf_filter_pid_set_eos(ctx->out_pid);
+
+			gf_filter_pid_set_discard(ctx->in_pid, GF_TRUE);
+			GF_FEVT_INIT(fevt, GF_FEVT_STOP, ctx->in_pid);
+			gf_filter_pid_send_event(ctx->in_pid, &fevt);
+		}
+		return GF_SERVICE_ERROR;
 	}
 
 	if (!pck) {
@@ -439,6 +498,10 @@
 	}
 
 	if (force_intra) {
+		if (ctx->args_updated) {
+			force_intra = 2;
+			ctx->args_updated = GF_FALSE;
+		}
 		//file switch we force a full reset to force injecting xPS in the stream
 		//we could also inject them manually but we don't have them !!
 		if ((ctx->rc && ctx->nb_frames_in) || (force_intra==2)) {
@@ -503,9 +566,9 @@
 		ctx->frame->pkt_duration = gf_filter_pck_get_duration(pck);
 
 //use signed version of timestamp rescale since we may have negative dts
-#define SCALE_TS(_ts) if (_ts != GF_FILTER_NO_TS) { _ts = gf_timestamp_rescale_signed(_ts, ctx->premul_timescale, ctx->encoder->time_base.den); }
-#define UNSCALE_TS(_ts) if (_ts != AV_NOPTS_VALUE) { _ts = gf_timestamp_rescale_signed(_ts, ctx->encoder->time_base.den, ctx->premul_timescale); }
-#define UNSCALE_DUR(_ts) { _ts = gf_timestamp_rescale(_ts, ctx->encoder->time_base.den, ctx->premul_timescale); }
+#define SCALE_TS(_ts) if (_ts != GF_FILTER_NO_TS) { _ts = gf_timestamp_rescale_signed(_ts, ctx->timescale, ctx->encoder->time_base.den); }
+#define UNSCALE_TS(_ts) if (_ts != AV_NOPTS_VALUE) { _ts = gf_timestamp_rescale_signed(_ts, ctx->encoder->time_base.den, ctx->timescale); }
+#define UNSCALE_DUR(_ts) { _ts = gf_timestamp_rescale(_ts, ctx->encoder->time_base.den, ctx->timescale); }
 
 		if (ctx->remap_ts) {
 			SCALE_TS(ctx->frame->pts);
@@ -600,6 +663,7 @@
 				GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("FFEnc codec flush done, triggering reconfiguration\n"));
 				avcodec_close(ctx->encoder);
 				ctx->encoder = NULL;
+				ctx->setup_failed = 0;
 				e = ffenc_configure_pid_ex(filter, ctx->in_pid, GF_FALSE, GF_TRUE);
 				ctx->init_cts_setup = bck_init_cts;
 				return e;
@@ -751,6 +815,10 @@
 			gf_filter_pck_set_duration(dst_pck, (u32) ctx->frame->pkt_duration);
 		}
 	}
+	if (ctx->gen_dsi) {
+		ffmpeg_generate_gpac_dsi(ctx->out_pid, ctx->codecid, ctx->encoder->color_primaries, ctx->encoder->color_trc, ctx->encoder->colorspace, output, size);
+		ctx->gen_dsi = GF_FALSE;
+	}
 
 	ffenc_log_video(filter, ctx, pkt, gf_filter_reporting_enabled(filter));
 
@@ -784,12 +852,10 @@
 	return GF_OK;
 }
 
-
-
 static void ffenc_audio_append_samples(struct _gf_ffenc_ctx *ctx, const u8 *data, u32 size, u32 sample_offset, u32 nb_samples)
 {
 	u8 *dst;
-	u32 f_idx, s_idx;
+	u32 f_idx, s_idx, offset, bytes;
 	u32 i, bytes_per_chan, src_frame_size;
 
 	if (!ctx->audio_buffer || !nb_samples)
@@ -818,7 +884,14 @@
 	if (s_idx) {
 		assert(s_idx + nb_samples <= (u32) ctx->encoder->frame_size);
 	}
-	dst = ctx->audio_buffer + (f_idx * ctx->channels * ctx->encoder->frame_size + s_idx) * bytes_per_chan;
+
+	offset = (f_idx * ctx->channels * ctx->encoder->frame_size + s_idx) * bytes_per_chan;
+	bytes = nb_samples * ctx->channels * bytes_per_chan;
+	if (bytes + offset > ctx->audio_buffer_size) {
+		ctx->audio_buffer_size = bytes+offset;
+		ctx->audio_buffer = gf_realloc(ctx->audio_buffer, sizeof(u8)*ctx->audio_buffer_size);
+	}
+	dst = ctx->audio_buffer + offset;
 	while (nb_samples) {
 		const u8 *src = NULL;
 		u32 nb_samples_to_copy = nb_samples;
@@ -864,11 +937,21 @@
 	pck = gf_filter_pid_get_packet(ctx->in_pid);
 
 	if (!ctx->encoder) {
-		if (ctx->infmt_negociate) return GF_OK;
-		
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc encoder reconfiguration failed, aborting stream\n"));
-		gf_filter_pid_set_eos(ctx->out_pid);
-		return GF_EOS;
+		//no encoder: if negociating input format or input pid props not known yet, wait
+		if (ctx->infmt_negociate || !ctx->setup_failed) return GF_OK;
+
+		if (ctx->setup_failed==1) {
+			GF_FilterEvent fevt;
+
+			ctx->setup_failed = 2;
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc encoder reconfiguration failed, aborting stream\n"));
+			gf_filter_pid_set_eos(ctx->out_pid);
+
+			gf_filter_pid_set_discard(ctx->in_pid, GF_TRUE);
+			GF_FEVT_INIT(fevt, GF_FEVT_STOP, ctx->in_pid);
+			gf_filter_pid_send_event(ctx->in_pid, &fevt);
+		}
+		return GF_SERVICE_ERROR;
 	}
 
 	if (!pck) {
@@ -879,7 +962,14 @@
 	if (ctx->reconfig_pending) pck = NULL;
 
 	if (ctx->encoder->frame_size && (ctx->encoder->frame_size <= (s32) ctx->samples_in_audio_buffer)) {
-		avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt, ctx->audio_buffer, ctx->bytes_per_sample * ctx->encoder->frame_size, 0);
+		ctx->frame->nb_samples = ctx->encoder->frame_size;
+		res = avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt,
+			ctx->audio_buffer, ctx->audio_buffer_size /*ctx->bytes_per_sample * ctx->encoder->frame_size*/, 0);
+		if (res<0) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc Error filling raw audio frame: %s\n", av_err2str(res) ));
+			ctx->samples_in_audio_buffer = 0;
+			return GF_SERVICE_ERROR;
+		}
 
 		from_internal_buffer_only = GF_TRUE;
 
@@ -915,8 +1005,8 @@
 			ffenc_audio_append_samples(ctx, data, size, 0, nb_copy);
 
 			ctx->frame->nb_samples = ctx->encoder->frame_size;
-			res = avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt, ctx->audio_buffer, ctx->encoder->frame_size*ctx->bytes_per_sample, 0);
-
+			res = avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt,
+				ctx->audio_buffer, ctx->audio_buffer_size/*ctx->encoder->frame_size*ctx->bytes_per_sample*/, 0);
 		} else {
 			ctx->frame->nb_samples = size / ctx->bytes_per_sample;
 			res = avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt, data, size, 0);
@@ -940,7 +1030,8 @@
 		if (ctx->encoder->frame_size) {
 			nb_samples = ctx->encoder->frame_size - ctx->samples_in_audio_buffer;
 			ffenc_audio_append_samples(ctx, NULL, 0, 0, nb_samples);
-			res = avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt, ctx->audio_buffer, ctx->encoder->frame_size * ctx->bytes_per_sample, 0);
+			res = avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt,
+				ctx->audio_buffer, ctx->audio_buffer_size/*ctx->encoder->frame_size * ctx->bytes_per_sample*/, 0);
 		} else {
 			res = avcodec_fill_audio_frame(ctx->frame, ctx->channels, ctx->sample_fmt, ctx->audio_buffer, ctx->samples_in_audio_buffer * ctx->bytes_per_sample, 0);
 		}
@@ -1035,6 +1126,7 @@
 				ctx->reconfig_pending = GF_FALSE;
 				avcodec_free_context(&ctx->encoder);
 				ctx->encoder = NULL;
+				ctx->setup_failed = 0;
 				GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("FFEnc codec flush done, triggering reconfiguration\n"));
 				e = ffenc_configure_pid_ex(filter, ctx->in_pid, GF_FALSE, GF_TRUE);
 				ctx->init_cts_setup = bck_init_cts;
@@ -1055,13 +1147,23 @@
 
 		if (ctx->samples_in_audio_buffer > nb_samples_to_drop) {
 			offset = nb_samples_to_drop * ctx->bytes_per_sample;
-			len = (ctx->samples_in_audio_buffer - nb_samples_to_drop) * ctx->bytes_per_sample;
+			len = (ctx->samples_in_audio_buffer - nb_samples_to_drop);
+			//if planar we must move entire frames
+			if (ctx->planar_audio) {
+				u32 nb_p = len / ctx->encoder->frame_size;
+				if (nb_p * ctx->encoder->frame_size < len) nb_p++;
+				len = nb_p * ctx->encoder->frame_size;
+			}
+			len *= ctx->bytes_per_sample;
+			if (len + offset > ctx->audio_buffer_size) {
+				ctx->audio_buffer_size = len+offset;
+				ctx->audio_buffer = gf_realloc(ctx->audio_buffer, sizeof(u8) * ctx->audio_buffer_size);
+			}
 			memmove(ctx->audio_buffer, ctx->audio_buffer + offset, sizeof(u8)*len);
 			ctx->samples_in_audio_buffer -= nb_samples_to_drop;
 		} else {
 			ctx->samples_in_audio_buffer = 0;
 		}
-
 	}
 
 	//increase timestamp
@@ -1146,6 +1248,10 @@
 		gf_list_del_item(ctx->src_packets, src_pck);
 		gf_filter_pck_unref(src_pck);
 	}
+	if (ctx->gen_dsi) {
+		ffmpeg_generate_gpac_dsi(ctx->out_pid, ctx->codecid, ctx->encoder->color_primaries, ctx->encoder->color_trc, ctx->encoder->colorspace, output, size);
+		ctx->gen_dsi = GF_FALSE;
+	}
 
 	gf_filter_pck_set_cts(dst_pck, pkt->pts + ctx->ts_shift);
 	gf_filter_pck_set_dts(dst_pck, pkt->dts + ctx->ts_shift);
@@ -1280,13 +1386,7 @@
 	//declare our output pid to make sure we connect the chain
 	ctx->in_pid = pid;
 	if (!ctx->out_pid) {
-		char szCodecName1000;
 		ctx->out_pid = gf_filter_pid_new(filter);
-
-		//to change once we implement on-the-fly codec change
-		sprintf(szCodecName, "ffenc:%s", codec->name ? codec->name : "unknown");
-		gf_filter_set_name(filter, szCodecName);
-		gf_filter_pid_set_framing_mode(ctx->in_pid, GF_TRUE);
 	}
 	if (type==GF_STREAM_AUDIO) {
 		ctx->process = ffenc_process_audio;
@@ -1311,10 +1411,10 @@
 			ctx->discontunity = GF_TRUE;
 		}
 	}
-
+	//macro to check if prop exists and has non-0 value
 #define GET_PROP(_a, _code, _name) \
 	prop = gf_filter_pid_get_property(pid, _code); \
-	if (!prop) {\
+	if (!prop || !prop->value.uint) {\
 		GF_LOG(GF_LOG_INFO, GF_LOG_CODEC, ("FFEnc Input %s unknown, waiting for reconfigure\n", _name)); \
 		return GF_OK; \
 	}\
@@ -1353,6 +1453,9 @@
 		GET_PROP(ctx->sample_rate, GF_PROP_PID_SAMPLE_RATE, "sample rate")
 		GET_PROP(ctx->channels, GF_PROP_PID_NUM_CHANNELS, "nb channels")
 		GET_PROP(afmt, GF_PROP_PID_AUDIO_FORMAT, "audio format")
+
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_CHANNEL_LAYOUT);
+		ctx->channel_layout = prop ? prop->value.longuint : 0;
 	}
 
 
@@ -1386,7 +1489,7 @@
 	if (type==GF_STREAM_VISUAL) {
 		u32 force_pfmt = AV_PIX_FMT_NONE;
 		if (ctx->pfmt) {
-			u32 ff_pfmt = ffmpeg_pixfmt_from_gpac(ctx->pfmt);
+			u32 ff_pfmt = ffmpeg_pixfmt_from_gpac(ctx->pfmt, GF_FALSE);
 			i=0;
 			while (codec->pix_fmts) {
 				if (codec->pix_fmtsi == AV_PIX_FMT_NONE) break;
@@ -1407,7 +1510,7 @@
 				change_input_fmt = force_pfmt;
 			}
 		}
-		ctx->pixel_fmt = ffmpeg_pixfmt_from_gpac(pfmt);
+		ctx->pixel_fmt = ffmpeg_pixfmt_from_gpac(pfmt, GF_FALSE);
 		//check pixel format
 		if (force_pfmt == AV_PIX_FMT_NONE) {
 			change_input_fmt = AV_PIX_FMT_NONE;
@@ -1476,7 +1579,7 @@
 					return GF_NOT_SUPPORTED;
 				}
 			} else if (ctx->pfmt) {
-				ff_pmft = ffmpeg_pixfmt_from_gpac(ctx->pfmt);
+				ff_pmft = ffmpeg_pixfmt_from_gpac(ctx->pfmt, GF_FALSE);
 			}
 			pfmt = ffmpeg_pixfmt_to_gpac(ff_pmft, GF_FALSE);
 			gf_filter_pid_negociate_property(ctx->in_pid, GF_PROP_PID_PIXFMT, &PROP_UINT(pfmt) );
@@ -1486,9 +1589,10 @@
 		}
 	} else {
 		u32 change_input_sr = 0;
+		u64 change_chan_layout = 0;
 		//check audio format
 		ctx->sample_fmt = ffmpeg_audio_fmt_from_gpac(afmt);
-		change_input_fmt = 0;
+		change_input_fmt = AV_SAMPLE_FMT_NONE;
 		while (codec->sample_fmts) {
 			if (codec->sample_fmtsi == AV_SAMPLE_FMT_NONE) break;
 			if (codec->sample_fmtsi == ctx->sample_fmt) {
@@ -1509,7 +1613,33 @@
 			}
 			i++;
 		}
-		if ((ctx->sample_fmt != change_input_fmt) || (ctx->sample_rate != change_input_sr)) {
+
+		i=0;
+		if (!ctx->channel_layout) {
+			ctx->channel_layout = gf_audio_fmt_get_layout_from_cicp(gf_audio_fmt_get_cicp_layout(ctx->channels, 0, 0));
+		}
+		u64 ff_ch_layout = ffmpeg_channel_layout_from_gpac(ctx->channel_layout);
+		if (!codec->channel_layouts)
+			change_chan_layout = ctx->channel_layout;
+
+		while (codec->channel_layouts) {
+			if (!codec->channel_layoutsi) break;
+			if (codec->channel_layoutsi == ff_ch_layout) {
+				change_chan_layout = ctx->channel_layout;
+				break;
+			}
+			i++;
+		}
+		//vorbis in ffmpeg currently requires stereo but channel_layouts is not set
+		if (ctx->codecid==GF_CODECID_VORBIS) {
+			change_chan_layout = gf_audio_fmt_get_layout_from_cicp(gf_audio_fmt_get_cicp_layout(2, 0, 0));
+		}
+
+
+		if ((ctx->sample_fmt != change_input_fmt)
+			|| (ctx->sample_rate != change_input_sr)
+			|| (ctx->channel_layout != change_chan_layout)
+		) {
 			if (ctx->sample_fmt != change_input_fmt) {
 				ctx->sample_fmt = codec->sample_fmts ? codec->sample_fmts0 : AV_SAMPLE_FMT_S16;
 				afmt = ffmpeg_audio_fmt_to_gpac(ctx->sample_fmt);
@@ -1518,6 +1648,13 @@
 			if (ctx->sample_rate != change_input_sr) {
 				gf_filter_pid_negociate_property(ctx->in_pid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(codec->supported_samplerates0) );
 			}
+			if (ctx->channel_layout != change_chan_layout) {
+				if (!change_chan_layout)
+					change_chan_layout = ffmpeg_channel_layout_to_gpac(codec->channel_layouts0);
+				u32 nb_chans = gf_audio_fmt_get_num_channels_from_layout(change_chan_layout);
+				gf_filter_pid_negociate_property(ctx->in_pid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(nb_chans) );
+				gf_filter_pid_negociate_property(ctx->in_pid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT(change_chan_layout) );
+			}
 			ctx->infmt_negociate = GF_TRUE;
 		} else {
 			ctx->infmt_negociate = GF_FALSE;
@@ -1535,7 +1672,10 @@
 	ctx->in_tk_delay = prop ? prop->value.longsint : 0;
 
 	ctx->encoder = avcodec_alloc_context3(codec);
-	if (! ctx->encoder) return GF_OUT_OF_MEM;
+	if (! ctx->encoder) {
+		ctx->setup_failed = 1;
+		return GF_OUT_OF_MEM;
+	}
 
 	ctx->encoder->codec_tag = ff_codectag;
 	if (type==GF_STREAM_VISUAL) {
@@ -1568,18 +1708,31 @@
 			ctx->encoder->framerate.den = prop->value.frac.den;
 			gf_media_get_reduced_frame_rate(&ctx->encoder->framerate.num, &ctx->encoder->framerate.den);
 
-			//if framerate exact or drop frame, use fps.num as timebase
-			//this is needed because some codecs in libavcodec check this value to derive the profile/levels
-			//so providing a too high time_base will increase the profile/levels ...
-			if ((ctx->encoder->framerate.den == 1) || (ctx->encoder->framerate.den == 1001)) {
+			//by default use input timescale as timebase for encoder, but:
+			//
+			// - mpeg12enc (maybe other codecs?) uses timebase to compute framerate so 1/25000 will fail, we must pass the fps
+			if ((codec->id==AV_CODEC_ID_MPEG1VIDEO)
+				|| (codec->id==AV_CODEC_ID_MPEG2VIDEO)
+				|| (codec->id==AV_CODEC_ID_H264)
+				|| (codec->id==AV_CODEC_ID_HEVC)
+#ifdef FFMPEG_ENABLE_VVC
+				|| (codec->id==AV_CODEC_ID_VVC)
+#endif
+			) {
+				ctx->encoder->time_base.num = ctx->encoder->framerate.den;
 				ctx->encoder->time_base.den = ctx->encoder->framerate.num;
 			}
-			//some codecs in libavcodec will complain if timebase is too high
-			//if fps is set and its num is quite small compared to our input timescale, use the num
-			//otherwise we try to keep the same timescale as input
-			else if ((u32) ctx->encoder->framerate.num * 100 < ctx->timescale) {
+			//- if framerate indicates drop frame, use fps.num as timebase
+			else if ((ctx->encoder->framerate.den % 1001)==0) {
 				ctx->encoder->time_base.den = ctx->encoder->framerate.num;
 			}
+			//- fps num less than input timescale
+			else if ((u32) ctx->encoder->framerate.num < ctx->timescale) {
+				//if timescale is a multiple of fps num, rescaling will not introduce rounding error so use fps num
+				if (!(ctx->timescale % ctx->encoder->framerate.num))
+					ctx->encoder->time_base.den = ctx->encoder->framerate.num;
+				//otherwise we would feed consecutive frames with same timestamp when rescaling and loose timing, so use ctx->timescale (default)
+			}
 		} else {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("FFEnc Unknown frame rate for PID %s, will use 25 fps - use `:#FPS=VAL` on input to force frame rate\n", gf_filter_pid_get_name(pid) ));
 			ctx->encoder->framerate.num = 25;
@@ -1604,6 +1757,24 @@
 			av_dict_set(&ctx->options, "forced-idr", "1", 0);
 		}
 
+
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_PRIMARIES);
+		ctx->encoder->color_primaries = prop ? prop->value.uint : AVCOL_PRI_UNSPECIFIED;
+
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_RANGE);
+		if (prop) ctx->encoder->color_range = (prop->value.uint==1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
+		else ctx->encoder->color_range = AVCOL_RANGE_UNSPECIFIED;
+
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_TRANSFER);
+		ctx->encoder->color_trc = prop ? prop->value.uint : AVCOL_TRC_UNSPECIFIED;
+
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_MX);
+		ctx->encoder->colorspace = prop ? prop->value.uint : AVCOL_SPC_UNSPECIFIED;
+
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_CHROMALOC);
+		ctx->encoder->chroma_sample_location = prop ? prop->value.uint : AVCHROMA_LOC_UNSPECIFIED;
+
+
 		//we don't use out of band headers, since x264 in ffmpeg (and likely other) do not output in MP4 format but
 		//in annexB (extradata only contains SPS/PPS/etc in annexB)
 		//so we indicate unframed for these codecs and use our own filter for annexB->MP4
@@ -1646,12 +1817,15 @@
 			ctx->timescale = ctx->sample_rate;
 		}
 
-		//for aac
+		//enable expermimental encoders
 		switch (ctx->codecid) {
 		case GF_CODECID_AAC_MPEG4:
 		case GF_CODECID_AAC_MPEG2_MP:
 		case GF_CODECID_AAC_MPEG2_LCP:
 		case GF_CODECID_AAC_MPEG2_SSRP:
+		case GF_CODECID_OPUS:
+		case GF_CODECID_TRUEHD:
+		case GF_CODECID_VORBIS:
 			av_dict_set(&ctx->options, "strict", "experimental", 0);
 			break;
 		}
@@ -1667,7 +1841,7 @@
 		ctx->frame->format = ctx->encoder->sample_fmt;
 
 		ctx->audio_buffer_size = ctx->sample_rate;
-		ctx->audio_buffer = gf_realloc(ctx->audio_buffer, sizeof(char) * ctx->enc_buffer_size);
+		ctx->audio_buffer = gf_realloc(ctx->audio_buffer, sizeof(char) * ctx->audio_buffer_size);
 		ctx->bytes_per_sample = ctx->channels * gf_audio_fmt_bit_depth(afmt) / 8;
 		ctx->init_cts_setup = GF_TRUE;
 
@@ -1702,25 +1876,76 @@
 	else if (ctx->gop_size) ctx->encoder->gop_size = ctx->gop_size;
 
 	//by default let libavcodec decide - if single thread is required, let the user define -threads option
-	if (codec->capabilities & AV_CODEC_CAP_AUTO_THREADS)
-		ctx->encoder->thread_count = 0;
-
+	ctx->encoder->thread_count = 0;
+
+	//setup 2 pass encoding
+	if (ctx->encoder->flags & (AV_CODEC_FLAG_PASS1|AV_CODEC_FLAG_PASS2)) {
+		char szLogFileGF_MAX_PATH;
+		const GF_PropertyValue *p = gf_filter_pid_get_property_str(pid, "logpass");
+		if (p && (p->type==GF_PROP_STRING) && p->value.string) {
+			sprintf(szLogFile, "%s", p->value.string);
+		} else {
+			u32 id=0;
+			p = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
+			if (p) id = p->value.uint;
+			sprintf(szLogFile, "ffenc2pass-%d.log", id);
+		}
+		if (ctx->rc) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("FFEnc Multi-pass encoding not compatible with `rc`, disabling reset coder flag\n", szLogFile));
+			ctx->rc = 0;
+		}
+		if (!strcmp(codec->name, "libx264")) {
+			av_dict_set(&options, "stats", szLogFile, AV_DICT_DONT_OVERWRITE);
+		} else {
+			if (ctx->encoder->flags & AV_CODEC_FLAG_PASS2) {
+				u32 len=0;
+				GF_Err e = gf_file_load_data(szLogFile, (u8**) &ctx->encoder->stats_in, &len);
+				if (!e && !gf_utf8_is_legal(ctx->encoder->stats_in, len)) {
+					e = GF_NON_COMPLIANT_BITSTREAM;
+				}
+				if (e) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc Error reading log file %s for pass-2 encoding: %s\n", szLogFile, gf_error_to_string(e) ));
+					if (ctx->encoder->stats_in) gf_free(ctx->encoder->stats_in);
+					return e;
+				}
+			}
+			if (ctx->encoder->flags & AV_CODEC_FLAG_PASS1) {
+				FILE *f = gf_fopen(szLogFile, "w");
+				if (!f) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc Error opening log file %s for pass-1 encoding\n", szLogFile));
+					return GF_IO_ERR;
+				}
+				ctx->logfile_pass1 = f;
+			}
+		}
+	}
 
 	av_dict_copy(&options, ctx->options, 0);
-	res = avcodec_open2(ctx->encoder, codec, &options );
+	res = avcodec_open2(ctx->encoder, codec, &options);
 	if (res < 0) {
 		if (options) av_dict_free(&options);
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc PID %s failed to open codec context: %s\n", gf_filter_pid_get_name(pid), av_err2str(res) ));
 		avcodec_free_context(&ctx->encoder);
 		ctx->encoder = NULL;
+		ctx->setup_failed = 1;
 		return GF_BAD_PARAM;
 	}
-	//precompute gpac_timescale * encoder->time_base.num for rescale operations
-	//do that AFTER opening the codec, since some codecs may touch this field ...
-	ctx->premul_timescale = ctx->timescale;
-	ctx->premul_timescale *= ctx->encoder->time_base.num;
 
-	ctx->remap_ts = (ctx->encoder->time_base.den && (ctx->encoder->time_base.den != ctx->premul_timescale)) ? GF_TRUE : GF_FALSE;
+	if (ctx->c) gf_free(ctx->c);
+	ctx->c = gf_strdup(codec->name);
+
+	{
+		char szCodecName1000;
+		if (ctx->encoder->thread_count>1)
+			sprintf(szCodecName, "ffenc:%s (%d frames)", codec->name ? codec->name : "unknown", ctx->encoder->thread_count);
+		else
+			sprintf(szCodecName, "ffenc:%s", codec->name ? codec->name : "unknown");
+		gf_filter_set_name(filter, szCodecName);
+		gf_filter_pid_set_framing_mode(ctx->in_pid, GF_TRUE);
+	}
+
+
+	ctx->remap_ts = (ctx->encoder->time_base.den != ctx->timescale) ? GF_TRUE : GF_FALSE;
 	if (!ctx->target_rate)
 		ctx->target_rate = (u32)ctx->encoder->bit_rate;
 
@@ -1740,11 +1965,12 @@
 
 static GF_Err ffenc_update_arg(GF_Filter *filter, const char *arg_name, const GF_PropertyValue *arg_val)
 {
-	s32 res;
 	char szOverrideOpt1000;
-	Bool do_override = GF_FALSE;
+	GF_PropertyValue arg_val_override;
 	GF_FFEncodeCtx *ctx = gf_filter_get_udta(filter);
 
+	if (!strcmp(arg_name, "rld")) return GF_OK;
+
 	if (!strcmp(arg_name, "global_header"))	return GF_OK;
 	else if (!strcmp(arg_name, "local_header"))	return GF_OK;
 	else if (!strcmp(arg_name, "low_delay"))	ctx->low_delay = GF_TRUE;
@@ -1768,33 +1994,54 @@
 			ctx->target_rate *= 1000;
 
 		sprintf(szOverrideOpt, "%d", ctx->target_rate);
-		do_override = GF_TRUE;
+		arg_val_override.type = GF_PROP_STRING;
+		arg_val_override.value.string = szOverrideOpt;
+		arg_val = &arg_val_override;
 	}
 
 	//initial parsing of arguments
-	if (!ctx->initialized) {
-		const char *arg_val_str;
-		switch (arg_val->type) {
-		case GF_PROP_STRING:
-			if (do_override)
-				arg_val_str = szOverrideOpt;
-			else {
-				arg_val_str = arg_val->value.string;
-				if (!arg_val_str) arg_val_str = "1";
-			}
-			res = av_dict_set(&ctx->options, arg_name, arg_val_str, 0);
-			if (res<0) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc Failed to set option %s:%s\n", arg_name, arg_val_str ));
+	if (!ctx->encoder) {
+		return ffmpeg_update_arg("FFEnc", NULL, &ctx->options, arg_name, arg_val);
+	}
+	//updates of arguments
+	u64 value=0;
+	switch (arg_val->type) {
+	case GF_PROP_STRING:
+	{
+		GF_PropertyValue res = gf_props_parse_value(GF_PROP_LUINT, arg_name, arg_val->value.string, NULL, 0);
+		value = res.value.longuint;
+	}
+		break;
+	case GF_PROP_UINT: value = arg_val->value.uint; break;
+	case GF_PROP_LUINT: value = arg_val->value.longuint; break;
+	default:
+		return GF_NOT_SUPPORTED;
+	}
+
+	if (ctx->rld) {
+		Bool skip=GF_FALSE;
+		char szVal100;
+		sprintf(szVal, LLU, value);
+		AVDictionaryEntry *key = av_dict_get(ctx->options, arg_name, NULL, 0);
+		if (key) {
+			if ((arg_val->type==GF_PROP_STRING) && !strcmp(key->value, arg_val->value.string))
+				skip=GF_TRUE;
+			else if (!strcmp(key->value, szVal))
+				skip=GF_TRUE;
+		}
+		if (!skip) {
+			av_dict_set(&ctx->options, arg_name, szVal, 0);
+			//if video and fintra is set, reload args at next intra
+			if (ctx->width && (ctx->fintra.num>=0)) {
+				ctx->args_updated = GF_TRUE;
+			} else {
+				ctx->reconfig_pending = GF_TRUE;
+				ctx->force_reconfig = GF_TRUE;
 			}
-			break;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("FFEnc Failed to set option %s, unrecognized type %d\n", arg_name, arg_val->type ));
-			return GF_NOT_SUPPORTED;
 		}
 		return GF_OK;
 	}
-	//updates of arguments, not supported for ffmpeg decoders
-	return GF_NOT_SUPPORTED;
+	return ffmpeg_update_arg("FFEnc", ctx->encoder, NULL, arg_name, arg_val);
 }
 
 static Bool ffenc_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
@@ -1849,6 +2096,12 @@
 		"\n"
 		"When forcing a closed GOP boundary, the filter will flush, destroy and recreate the encoder to make sure a clean context is used, as currently many encoders in libavcodec do not support clean reset when forcing picture types.\n"
 		"If -fintra() is not set and the output of the encoder is a DASH session in live profile without segment timeline, -fintra() will be set to the target segment duration and -rc() will be set.\n"
+		"\n"
+		"The filter will look for property `logpass` on input PID to set 2-pass log filename, otherwise defaults to `ffenc2pass-PID.log`.\n"
+		"\n"
+		"Arguments may be updated at runtime. If -rld() is set, the encoder will be flushed then reloaded with new options.\n"
+		"If codec is video and -fintra() is set, reload will happen at next forced intra; otherwise, reload happens at next encode.\n"
+		"The -rld() option is usually needed for dynamic updates of rate control parameters, since most encoders in ffmpeg do not support it.\n"
 	)
 	.private_size = sizeof(GF_FFEncodeCtx),
 	SETCAPS(FFEncodeCaps),
@@ -1858,19 +2111,20 @@
 	.process = ffenc_process,
 	.process_event = ffenc_process_event,
 	.update_arg = ffenc_update_arg,
-	.flags = GF_FS_REG_META,
+	.flags = GF_FS_REG_META | GF_FS_REG_TEMP_INIT,
 };
 
 #define OFFS(_n)	#_n, offsetof(GF_FFEncodeCtx, _n)
 static const GF_FilterArgs FFEncodeArgs =
 {
-	{ OFFS(c), "codec identifier. Can be any supported GPAC codec name or ffmpeg codec name", GF_PROP_STRING, NULL, NULL, 0},
+	{ OFFS(c), "codec identifier. Can be any supported GPAC codec name or ffmpeg codec name - updated to ffmpeg codec name after initialization", GF_PROP_STRING, NULL, NULL, 0},
 	{ OFFS(pfmt), "pixel format for input video. When not set, input format is used", GF_PROP_PIXFMT, "none", NULL, 0},
 	{ OFFS(fintra), "force intra / IDR frames at the given period in sec, e.g. `fintra=2` will force an intra every 2 seconds and `fintra=1001/1000` will force an intra every 30 frames on 30000/1001=29.97 fps video; ignored for audio", GF_PROP_FRACTION, "-1/1", NULL, 0},
 
 	{ OFFS(all_intra), "only produce intra frames", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_UPDATE|GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(ls), "log stats", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(rc), "reset encoder when forcing intra frame (some encoders might not support intra frame forcing)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(rld), "force reloading of encoder when arguments are updated", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
 
 	{ "*", -1, "any possible options defined for AVCodecContext and sub-classes. see `gpac -hx ffenc` and `gpac -hx ffenc:*`", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_META},
 	{0}
@@ -1880,8 +2134,7 @@
 
 const GF_FilterRegister *ffenc_register(GF_FilterSession *session)
 {
-	ffmpeg_build_register(session, &FFEncodeRegister, FFEncodeArgs, FFENC_STATIC_ARGS, FF_REG_TYPE_ENCODE);
-	return &FFEncodeRegister;
+	return ffmpeg_build_register(session, &FFEncodeRegister, FFEncodeArgs, FFENC_STATIC_ARGS, FF_REG_TYPE_ENCODE);
 }

gpac-2.0.0.tar.gz/src/filters/ff_mx.c -> gpac-2.2.0.tar.gz/src/filters/ff_mx.c Changed

@@ -39,16 +39,24 @@
 
 #ifdef GPAC_HAS_FFMPEG
 
+#if (LIBAVCODEC_VERSION_MAJOR>58)
+#include <libavutil/mastering_display_metadata.h>
+#endif
+
+
 typedef struct
 {
 	AVStream *stream;
 	Bool ts_rescale;
 	AVRational in_scale;
+	u32 in_timescale;
 	Bool in_seg_flush;
 	u32 cts_shift;
-
+	s64 ts_shift;
+	Bool ready;
 	Bool suspended;
 	Bool reconfig_stream;
+	Bool webvtt;
 } GF_FFMuxStream;
 
 enum{
@@ -70,10 +78,11 @@
 typedef struct
 {
 	//options
-	char *dst, *mime, *ffmt;
+	char *dst, *mime, *ffmt, *ext;
 	Double start, speed;
 	u32 block_size;
-	Bool interleave, nodisc, ffiles, noinit;
+	Bool nodisc, ffiles, noinit, keepts;
+	GF_Fraction ileave;
 
 	AVFormatContext *muxer;
 	//decode options
@@ -94,6 +103,9 @@
 	FILE *gfio;
 
 	u32 cur_file_idx_plus_one;
+	u32 probe_init;
+
+	u64 ts_regulate;
 
 #if (LIBAVCODEC_VERSION_MAJOR < 59)
 	AVPacket pkt;
@@ -107,6 +119,10 @@
 static GF_Err ffmx_init_mux(GF_Filter *filter, GF_FFMuxCtx *ctx)
 {
 	u32 i, nb_pids;
+	u64 min_ts=0;
+	u64 min_delay_skip=0;
+	u32 min_delay_ts=0;
+	u32 min_timescale=1000;
 	int res;
 
 	assert(ctx->status==FFMX_STATE_AVIO_OPEN);
@@ -136,6 +152,45 @@
 		} else {
 			st->ts_rescale = GF_TRUE;
 		}
+		if (!ctx->keepts) {
+			GF_FilterPacket *pck = gf_filter_pid_get_packet(ipid);
+			u64 ts = gf_filter_pck_get_dts(pck);
+			if (ts == GF_FILTER_NO_TS) ts = gf_filter_pck_get_cts(pck);
+			if (ts == GF_FILTER_NO_TS) continue;
+
+			if (!min_ts || (min_ts * st->in_scale.den > ts * min_timescale)) {
+				min_ts = ts;
+				min_timescale = st->in_scale.den;
+			}
+		}
+
+		const GF_PropertyValue *p = gf_filter_pid_get_property(ipid, GF_PROP_PID_DELAY);
+		if (p) {
+			if (p->value.longsint < 0) {
+				if (!min_delay_skip || (gf_timestamp_greater(-p->value.longsint, st->in_scale.den, min_delay_skip, min_delay_ts))) {
+					min_delay_skip = -p->value.longsint;
+					min_delay_ts = st->in_scale.den;
+				}
+			}
+		}
+	}
+
+	for (i=0; i<nb_pids; i++) {
+		GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
+		GF_FFMuxStream *st = gf_filter_pid_get_udta(ipid);
+
+		//get pid delay
+		const GF_PropertyValue *p = gf_filter_pid_get_property(ipid, GF_PROP_PID_DELAY);
+		s64 delay = p ? p->value.longsint : 0;
+		//add min skip, delay is now >=0
+		delay += gf_timestamp_rescale(min_delay_skip, min_delay_ts, st->in_scale.den);
+		//may happen due to rounding
+		if (delay<0) delay=0;
+		st->ts_shift = delay;
+
+		if (!ctx->keepts) {
+			st->ts_shift = st->ts_shift - gf_timestamp_rescale(min_ts, min_timescale, st->in_scale.den);
+		}
 	}
 
 	res = avformat_write_header(ctx->muxer, &options);
@@ -209,6 +264,15 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Fail to open AVIO context for %s - error %s\n", dst, av_err2str(res) ));
 			return GF_FILTER_NOT_SUPPORTED;
 		}
+
+#if (LIBAVFORMAT_VERSION_MAJOR < 59)
+		strncpy(ctx->muxer->filename, dst, 1023);
+		ctx->muxer->filename1023=0;
+#else
+		av_freep(&ctx->muxer->url);
+		ctx->muxer->url = av_strdup(dst);
+#endif
+
 	}
 	ctx->status = FFMX_STATE_AVIO_OPEN;
 	return GF_OK;
@@ -243,7 +307,7 @@
 	if (sep && strchr(sep+1, '$'))
 		use_templates = GF_TRUE;
 
-	ofmt = av_guess_format(ctx->ffmt, url, ctx->mime);
+	ofmt = av_guess_format(ctx->ext ? ctx->ext : ctx->ffmt, url, ctx->mime);
 	//if protocol is present, we may fail at guessing the format
 	if (!ofmt && !ctx->ffmt) {
 		u32 len;
@@ -268,6 +332,12 @@
 	ctx->muxer->oformat = FF_OFMT_CAST ofmt;
 
 	ctx->status = FFMX_STATE_ALLOC;
+
+	if (gf_filter_is_temporary(filter)) {
+		gf_filter_meta_set_instances(filter, ofmt->name);
+		return GF_OK;
+	}
+
 	//templates are used, we need to postpone opening the url until we have a PID and a first packet
 	if (use_templates)
 		return GF_OK;
@@ -277,6 +347,12 @@
 
 static GF_Err ffmx_initialize(GF_Filter *filter)
 {
+	GF_FFMuxCtx *ctx = (GF_FFMuxCtx *) gf_filter_get_udta(filter);
+	if (ctx->ileave.num<=0) {
+		ctx->ileave.num = 0;
+	} else {
+		ctx->ts_regulate = ctx->ileave.num;
+	}
 	return ffmx_initialize_ex(filter, GF_FALSE);
 }
 static GF_Err ffmx_start_seg(GF_Filter *filter, GF_FFMuxCtx *ctx, const char *seg_name)
@@ -427,7 +503,7 @@
 		evt.seg_size.is_init = 0;
 	}
 	evt.seg_size.media_range_start = ctx->offset_at_seg_start;
-	evt.seg_size.media_range_end = ctx->muxer->pb ? ctx->muxer->pb->written-1 : 0;
+	evt.seg_size.media_range_end = ctx->muxer->pb ? (ctx->muxer->pb->written-1) : 0;
 	ctx->offset_at_seg_start = evt.seg_size.media_range_end;
 
 	gf_filter_pid_send_event(pid, &evt);
@@ -441,9 +517,27 @@
 	if (st->reconfig_stream & FFMX_INJECT_DSI) {
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
 		if (p && (p->type==GF_PROP_DATA) && p->value.data.ptr) {
-			data = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, p->value.data.size);
-			if (data)
-				memcpy(data, p->value.data.ptr, p->value.data.size);
+			u32 dsi_size = p->value.data.size;
+			u32 codec_id = 0;
+			const GF_PropertyValue *cid = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+			if (cid) codec_id = cid->value.uint;
+
+			if (codec_id==GF_CODECID_FLAC) {
+				dsi_size-=4;
+			} else if (codec_id==GF_CODECID_OPUS) {
+				dsi_size+=8;
+			}
+			data = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, dsi_size);
+			if (data) {
+				if (codec_id==GF_CODECID_FLAC) {
+					memcpy(data, p->value.data.ptr+4, p->value.data.size-4);
+				} else if (codec_id==GF_CODECID_OPUS) {
+					memcpy(data, "OpusHead", 8);
+					memcpy(data+8, p->value.data.ptr, p->value.data.size);
+				} else {
+					memcpy(data, p->value.data.ptr, p->value.data.size);
+				}
+			}
 		}
 	}
 	if (st->reconfig_stream & FFMX_INJECT_VID_INFO) {
@@ -493,6 +587,41 @@
 		}
 	}
 }
+static void ffmx_inject_webvtt(GF_FilterPacket *ipck, AVPacket *pkt)
+{
+	u32 len;
+	u8 *data;
+	const GF_PropertyValue *p;
+	const char *vtt_pre=NULL, *vtt_cueid=NULL, *vtt_settings=NULL;
+	p = gf_filter_pck_get_property_str(ipck, "vtt_pre");
+	if (p) vtt_pre = p->value.string;
+	p = gf_filter_pck_get_property_str(ipck, "vtt_cueid");
+	if (p) vtt_cueid = p->value.string;
+	p = gf_filter_pck_get_property_str(ipck, "vtt_settings");
+	if (p) vtt_settings = p->value.string;
+
+	if (vtt_cueid) {
+		len = (u32) strlen(vtt_cueid);
+		data = av_packet_new_side_data(pkt, AV_PKT_DATA_WEBVTT_IDENTIFIER, len);
+		if (data) memcpy(data, vtt_cueid, len);
+	}
+	if (vtt_settings) {
+		len = (u32) strlen(vtt_settings);
+		data = av_packet_new_side_data(pkt, AV_PKT_DATA_WEBVTT_SETTINGS, len);
+		if (data) memcpy(data, vtt_settings, len);
+	}
+	if (vtt_pre) {
+		len = (u32) strlen(vtt_pre);
+		data = av_packet_new_side_data(pkt, AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, len+8);
+		if (data) {
+			//set additional blockID = 1 (64 BE int)
+			memset(data, 0, 7);
+			data7 = 1;
+			memcpy(data+8, vtt_pre, len);
+		}
+	}
+}
+
 
 static GF_Err ffmx_process(GF_Filter *filter)
 {
@@ -504,17 +633,42 @@
 		Bool all_ready = GF_TRUE;
 		Bool needs_reinit = (ctx->status==FFMX_STATE_ALLOC) ? GF_TRUE : GF_FALSE;
 
+		//potpone until no pending connections so that we don't write header before all streams are declared
+		if (gf_filter_connections_pending(filter))
+			return GF_OK;
+
+		if (!ctx->probe_init) ctx->probe_init = gf_sys_clock();
+		else if (gf_sys_clock() - ctx->probe_init > 10000) {
+			for (i=0; i<nb_pids; i++) {
+				GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
+				gf_filter_pid_set_discard(ipid, GF_TRUE);
+			}
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Could not initialize stream list in 10s, aborting\n"));
+			return GF_SERVICE_ERROR;
+		}
+
 		for (i=0; i<nb_pids; i++) {
 			GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
-			GF_FFMuxStream *st = gf_filter_pid_get_udta(ipid);
 			GF_FilterPacket *ipck = gf_filter_pid_get_packet(ipid);
+			GF_FFMuxStream *st = gf_filter_pid_get_udta(ipid);
+			if (!st) continue;
+
+			if (!st->ready) {
+				const GF_PropertyValue *p = gf_filter_pid_get_property(ipid, GF_PROP_PID_DECODER_CONFIG);
+				if (!p) return GF_OK;
+			}
 
-			if (needs_reinit) {
+			if (needs_reinit || !st->ready) {
 				e = ffmx_configure_pid(filter, ipid, GF_FALSE);
 				if (e) return e;
 			}
 			if (!ipck) {
-				all_ready = GF_FALSE;
+				//don't wait for subtitles & other streams
+				if ((st->stream->codecpar->codec_type==AVMEDIA_TYPE_VIDEO)
+					|| (st->stream->codecpar->codec_type==AVMEDIA_TYPE_VIDEO)
+				) {
+					all_ready = GF_FALSE;
+				}
 				continue;
 			}
 
@@ -536,6 +690,7 @@
 	if (ctx->status==FFMX_STATE_EOS) return GF_EOS;
 	else if (ctx->status==FFMX_STATE_ERROR) return GF_SERVICE_ERROR;
 
+	u32 nb_skip = 0;
 	nb_segs_done = 0;
 	nb_done = 0;
 	nb_suspended = 0;
@@ -581,6 +736,12 @@
 				continue;
 			}
 
+			//ahead of our interleaving window, don't write yet - av_interleaved_write_frame is not enough for performing regulation
+			if (ctx->ileave.num && gf_timestamp_greater(cts+st->ts_shift, st->in_timescale, ctx->ts_regulate, ctx->ileave.den)) {
+				nb_skip++;
+				break;
+			}
+
 			p = gf_filter_pck_get_property(ipck, GF_PROP_PCK_FILENUM);
 			if (ctx->dash_mode) {
 				if (p) {
@@ -627,15 +788,21 @@
 			if (sap==GF_FILTER_SAP_1) pkt->flags = AV_PKT_FLAG_KEY;
 			pkt->data = (u8 *) gf_filter_pck_get_data(ipck, &pkt->size);
 
+			if (st->ts_shift) {
+				pkt->dts = pkt->dts + st->ts_shift;
+				pkt->pts = pkt->pts + st->ts_shift;
+			}
 			if (st->ts_rescale) {
 				av_packet_rescale_ts(pkt, st->in_scale, st->stream->time_base);
 			}
 
 			if (st->reconfig_stream) {
 				ffmx_inject_config(ipid, st, pkt);
+			} else if (st->webvtt) {
+				ffmx_inject_webvtt(ipck, pkt);
 			}
 
-			if (ctx->interleave) {
+			if (ctx->ileave.num) {
 				res = av_interleaved_write_frame(ctx->muxer, pkt);
 			} else {
 				res = av_write_frame(ctx->muxer, pkt);
@@ -644,10 +811,9 @@
 				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Fail to write packet %sto %s - error %s\n", st->reconfig_stream ? "with reconfig side data " : "", AVFMT_URL(ctx->muxer), av_err2str(res) ));
 				e = GF_IO_ERR;
 			}
-			if (st->reconfig_stream) {
-				av_packet_free_side_data(pkt);
-				st->reconfig_stream = 0;
-			}
+
+			if (pkt->side_data) av_packet_free_side_data(pkt);
+			st->reconfig_stream = 0;
 
 			gf_filter_pid_drop_packet(ipid);
 			ctx->nb_pck_in_seg++;
@@ -655,9 +821,18 @@
 		}
 	}
 
+	if (nb_skip + nb_done >= nb_pids) {
+		ctx->ts_regulate += ctx->ileave.num;
+	}
+
 	//done writing file
 	if (nb_suspended && (nb_suspended==nb_pids)) {
-		av_write_trailer(ctx->muxer);
+		int res = av_write_trailer(ctx->muxer);
+		if (res) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Failed to write trailer for %s: %s\n", ctx->dst, av_err2str(res) ));
+			e = GF_SERVICE_ERROR;
+		}
+
 		if (ctx->muxer)	avformat_free_context(ctx->muxer);
 		ctx->muxer = NULL;
 		ctx->status = FFMX_STATE_ALLOC;
@@ -691,7 +866,11 @@
 			if (ctx->dash_mode) {
 				ffmx_close_seg(filter, ctx, GF_FALSE);
 			} else {
-				av_write_trailer(ctx->muxer);
+				int res = av_write_trailer(ctx->muxer);
+				if (res) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Failed to write trailer for %s: %s\n", ctx->dst, av_err2str(res) ));
+					return GF_SERVICE_ERROR;
+				}
 			}
 			ctx->status = FFMX_STATE_EOS;
 		}
@@ -700,6 +879,19 @@
 	return GF_OK;
 }
 
+//dovi_meta.h not exported in old releases, just redefine
+typedef struct {
+ u8 dv_version_major;
+ u8 dv_version_minor;
+ u8 dv_profile;
+ u8 dv_level;
+ u8 rpu_present_flag;
+ u8 el_present_flag;
+ u8 bl_present_flag;
+ u8 dv_bl_signal_compatibility_id;
+} Ref_FFAVDoviRecord;
+
+
 static GF_Err ffmx_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
 {
 	int res;
@@ -707,6 +899,7 @@
 	Bool check_disc = GF_FALSE;
 	u32 streamtype, codec_id;
 	u32 ff_codec_id, ff_st, ff_codec_tag;
+	GF_Err e;
 	const GF_PropertyValue *p, *dsi;
 	GF_FFMuxStream *st;
 	GF_FFMuxCtx *ctx = (GF_FFMuxCtx *) gf_filter_get_udta(filter);
@@ -740,6 +933,38 @@
 	if (!p) return GF_NOT_SUPPORTED;
 	codec_id = p->value.uint;
 
+	Bool stream_ready = GF_TRUE;
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+	if (!p) {
+		//we must wait for decoder config to be present for these codecs
+		switch (codec_id) {
+		case GF_CODECID_MPEG1:
+		case GF_CODECID_MPEG2_422:
+		case GF_CODECID_MPEG2_SNR:
+		case GF_CODECID_MPEG2_HIGH:
+		case GF_CODECID_MPEG2_MAIN:
+		case GF_CODECID_MPEG2_SIMPLE:
+		case GF_CODECID_MPEG2_SPATIAL:
+		case GF_CODECID_MPEG4_PART2:
+		case GF_CODECID_AVC:
+		case GF_CODECID_HEVC:
+		case GF_CODECID_VVC:
+		case GF_CODECID_AV1:
+		case GF_CODECID_VP8:
+		case GF_CODECID_VP9:
+		case GF_CODECID_VP10:
+		case GF_CODECID_AC3:
+		case GF_CODECID_EAC3:
+		case GF_CODECID_FLAC:
+		case GF_CODECID_OPUS:
+		case GF_CODECID_VORBIS:
+			stream_ready = GF_FALSE;
+			break;
+		default:
+			break;
+		}
+	}
+
 	ff_st = ffmpeg_stream_type_from_gpac(streamtype);
 	if (codec_id==GF_CODECID_RAW) {
 		ff_codec_tag = 0;
@@ -801,6 +1026,11 @@
 	if (!st) {
 		GF_FilterEvent evt;
 
+		if (ctx->status > FFMX_STATE_HDR_DONE) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Cannot add new stream to container, header already written\n"));
+			return GF_NOT_SUPPORTED;
+		}
+
 		GF_SAFEALLOC(st, GF_FFMuxStream);
 		if (!st) return GF_OUT_OF_MEM;
 		gf_filter_pid_set_udta(pid, st);
@@ -809,6 +1039,7 @@
 		gf_filter_pid_init_play_event(pid, &evt, ctx->start, ctx->speed, "FFMux");
 		gf_filter_pid_send_event(pid, &evt);
 	}
+	st->ready = stream_ready;
 
 	if (ctx->status==FFMX_STATE_ALLOC) {
 		char szPathGF_MAX_PATH;
@@ -836,6 +1067,9 @@
 		if (!st->stream) return GF_NOT_SUPPORTED;
 	}
 	avst = st->stream;
+	st->webvtt = GF_FALSE;
+	if ((codec_id==GF_CODECID_WEBVTT) && !strcmp( ctx->muxer->oformat->name, "matroska"))
+		st->webvtt = GF_TRUE;
 
 	dsi = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
 
@@ -889,13 +1123,8 @@
 	avst->codecpar->codec_tag = ff_codec_tag;
 
 	if (dsi && dsi->value.data.ptr) {
-		if (avst->codecpar->extradata) av_free(avst->codecpar->extradata);
-		avst->codecpar->extradata_size = dsi->value.data.size;
-		avst->codecpar->extradata = av_malloc(avst->codecpar->extradata_size+ AV_INPUT_BUFFER_PADDING_SIZE);
-		if (avst->codecpar->extradata) {
-			memcpy(avst->codecpar->extradata, dsi->value.data.ptr, avst->codecpar->extradata_size);
-			memset(avst->codecpar->extradata + dsi->value.data.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
-		}
+		e = ffmpeg_extradata_from_gpac(codec_id, dsi->value.data.ptr, dsi->value.data.size, &avst->codecpar->extradata, &avst->codecpar->extradata_size);
+		if (e) return e;
 	}
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
 	if (p) avst->id = p->value.uint;
@@ -906,12 +1135,13 @@
 		avst->time_base.num = 1;
 	}
 	st->in_scale = avst->time_base;
+	st->in_timescale = avst->time_base.den;
 
 	avst->start_time = 0;
 	avst->duration = 0;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
 	if (p && p->value.lfrac.den) {
-		avst->duration = p->value.lfrac.num;
+		avst->duration = (p->value.lfrac.num<0) ? -p->value.lfrac.num : p->value.lfrac.num;
 		avst->duration *= avst->time_base.den;
 		avst->duration /= p->value.lfrac.den;
 	}
@@ -920,56 +1150,19 @@
 	if (p) avst->codecpar->bit_rate = p->value.uint;
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CTS_SHIFT);
-	if (p) st->cts_shift = p->value.uint;
+	st->cts_shift = p ? p->value.uint : 0;
 
-	if (streamtype==GF_STREAM_VISUAL) {
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_WIDTH);
-		if (p) avst->codecpar->width = p->value.uint;
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_HEIGHT);
-		if (p) avst->codecpar->height = p->value.uint;
+	e = ffmpeg_codec_par_from_gpac(pid, avst->codecpar, st->in_scale.den);
+	if (e) return e;
 
+	if (streamtype==GF_STREAM_VISUAL) {
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_FPS);
 		if (p) {
 			avst->r_frame_rate.num = p->value.frac.num;
 			avst->r_frame_rate.den = p->value.frac.den;
 			avst->avg_frame_rate = avst->r_frame_rate;
 		}
-		if (codec_id==GF_CODECID_RAW) {
-			p = gf_filter_pid_get_property(pid, GF_PROP_PID_PIXFMT);
-			if (p) {
-				avst->codecpar->format = ffmpeg_pixfmt_from_gpac(p->value.uint);
-				avst->codecpar->codec_tag = avcodec_pix_fmt_to_codec_tag(avst->codecpar->format);
-			}
-		}
-
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAR);
-		if (p) {
-			avst->codecpar->sample_aspect_ratio.num = p->value.frac.num;
-			avst->codecpar->sample_aspect_ratio.den = p->value.frac.den;
-		}
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_PRIMARIES);
-		if (p) avst->codecpar->color_primaries = p->value.uint;
-
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_RANGE);
-		if (p) avst->codecpar->color_range = (p->value.uint==1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
-
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_TRANSFER);
-		if (p) avst->codecpar->color_trc = p->value.uint;
-
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_MX);
-		if (p) avst->codecpar->color_space = p->value.uint;
-
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_CHROMALOC);
-		if (p) avst->codecpar->chroma_location = p->value.uint;
-
-		p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
-		if (p && avst->r_frame_rate.num && avst->r_frame_rate.den) {
-			s64 delay = p->value.longsint;
-			delay *= avst->r_frame_rate.num;
-			delay /= avst->r_frame_rate.den;
-			avst->codecpar->video_delay = (s32) delay;
-		}
-
+		avst->sample_aspect_ratio = avst->codecpar->sample_aspect_ratio;
 	}
 	else if (streamtype==GF_STREAM_AUDIO) {
 		u64 ch_layout;
@@ -988,17 +1181,20 @@
 			if (p) avst->codecpar->format = ffmpeg_audio_fmt_from_gpac(p->value.uint);
 		}
 
-		ch_layout = AV_CH_LAYOUT_MONO;
+		ch_layout = 0;
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_CHANNEL_LAYOUT);
 		if (p)
 			ch_layout = p->value.longuint;
 		else if (avst->codecpar->channels==2)
-			ch_layout = AV_CH_LAYOUT_STEREO;
-		avst->codecpar->channel_layout = ffmpeg_channel_layout_from_gpac(ch_layout);
+			ch_layout = GF_AUDIO_CH_FRONT_LEFT|GF_AUDIO_CH_FRONT_RIGHT;
+		else if (avst->codecpar->channels==1)
+			ch_layout = GF_AUDIO_CH_FRONT_CENTER;
+
+		avst->codecpar->channel_layout = ch_layout ? ffmpeg_channel_layout_from_gpac(ch_layout) : 0;
 
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
 		if (p && (p->value.sint<0) && samplerate) {
-			s64 pad = p->value.longsint;
+			s64 pad = -p->value.longsint;
 			if (st->in_scale.den != samplerate) {
 				pad *= samplerate;
 				pad /= st->in_scale.den;
@@ -1011,6 +1207,93 @@
 		*/
 	}
 
+	ffmpeg_tags_from_gpac(pid, &avst->metadata);
+
+	//remap our props to side data
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ISOM_TRACK_MATRIX);
+	if (p && (p->type==GF_PROP_UINT_LIST) && (p->value.uint_list.nb_items==9)) {
+		u8 *data = av_malloc(sizeof(u32) * 9);
+		if (data) {
+			memcpy(data, p->value.uint_list.vals, sizeof(u32)*9);
+			av_stream_add_side_data(st->stream, AV_PKT_DATA_DISPLAYMATRIX, data, 32*9);
+		}
+	}
+#if (LIBAVCODEC_VERSION_MAJOR>58)
+	//icc profile if any
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ICC_PROFILE);
+	if (p && ((p->type==GF_PROP_DATA) || (p->type==GF_PROP_CONST_DATA))) {
+		u8 *data = av_malloc(p->value.data.size);
+		if (data) {
+			memcpy(data, p->value.data.ptr, p->value.data.size);
+			av_stream_add_side_data(st->stream, AV_PKT_DATA_ICC_PROFILE, data, p->value.data.size);
+		}
+	}
+	//clli
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CONTENT_LIGHT_LEVEL);
+	if (p && ((p->type==GF_PROP_DATA) || (p->type==GF_PROP_CONST_DATA)) && (p->value.data.size==4)) {
+		GF_BitStream *bs = gf_bs_new(p->value.data.ptr, p->value.data.size, GF_BITSTREAM_READ);
+		AVContentLightMetadata *data = av_malloc(sizeof(AVContentLightMetadata));
+		if (data) {
+			data->MaxCLL = gf_bs_read_u16(bs);
+			data->MaxFALL = gf_bs_read_u16(bs);;
+			av_stream_add_side_data(st->stream, AV_PKT_DATA_CONTENT_LIGHT_LEVEL, (u8*) data, sizeof(AVContentLightMetadata));
+		}
+		gf_bs_del(bs);
+	}
+	//mdcv
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_MASTER_DISPLAY_COLOUR);
+	if (p && ((p->type==GF_PROP_DATA) || (p->type==GF_PROP_CONST_DATA)) && (p->value.data.size==24)) {
+		u8 mdcv24;
+		const int chroma_den = 50000;
+		const int luma_den = 10000;
+		memset(mdcv, 0, sizeof(u8)*24);
+		AVMasteringDisplayMetadata *data = av_malloc(sizeof(AVMasteringDisplayMetadata));
+		GF_BitStream *bs = gf_bs_new(p->value.data.ptr, p->value.data.size, GF_BITSTREAM_READ);
+		if (data) {
+			data->display_primaries10.num = gf_bs_read_u16(bs);
+			data->display_primaries10.den = chroma_den;
+			data->display_primaries11.num = gf_bs_read_u16(bs);
+			data->display_primaries11.den = chroma_den;
+			data->display_primaries20.num = gf_bs_read_u16(bs);
+			data->display_primaries20.den = chroma_den;
+			data->display_primaries21.num = gf_bs_read_u16(bs);
+			data->display_primaries21.den = chroma_den;
+			data->display_primaries00.num = gf_bs_read_u16(bs);
+			data->display_primaries00.den = chroma_den;
+			data->display_primaries01.num = gf_bs_read_u16(bs);
+			data->display_primaries01.den = chroma_den;
+			data->white_point0.num = gf_bs_read_u16(bs);
+			data->white_point0.den = chroma_den;
+			data->white_point1.num = gf_bs_read_u16(bs);
+			data->white_point1.den = chroma_den;
+			data->max_luminance.num = gf_bs_read_u32(bs);
+			data->max_luminance.den = luma_den;
+			data->min_luminance.num = gf_bs_read_u32(bs);
+			data->min_luminance.den = luma_den;
+			av_stream_add_side_data(st->stream, AV_PKT_DATA_MASTERING_DISPLAY_METADATA, (u8*) data, sizeof(AVMasteringDisplayMetadata));
+ 	}
+ 	gf_bs_del(bs);
+	}
+	//dolby vision
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DOLBY_VISION);
+	if (p && ((p->type==GF_PROP_DATA) || (p->type==GF_PROP_CONST_DATA)) && (p->value.data.size==24)) {
+		GF_BitStream *bs = gf_bs_new(p->value.data.ptr, p->value.data.size, GF_BITSTREAM_READ);
+		Ref_FFAVDoviRecord *data = av_malloc(sizeof(Ref_FFAVDoviRecord));
+		if (data) {
+			data->dv_version_major = gf_bs_read_u8(bs);
+			data->dv_version_minor = gf_bs_read_u8(bs);
+			data->dv_profile = gf_bs_read_int(bs, 7);
+			data->dv_level = gf_bs_read_int(bs, 6);
+			data->rpu_present_flag = gf_bs_read_int(bs, 1);
+			data->el_present_flag = gf_bs_read_int(bs, 1);
+			data->bl_present_flag = gf_bs_read_int(bs, 1);
+			data->dv_bl_signal_compatibility_id = gf_bs_read_int(bs, 4);
+			av_stream_add_side_data(st->stream, AV_PKT_DATA_DOVI_CONF, (u8*) data, sizeof(Ref_FFAVDoviRecord));
+		}
+		gf_bs_del(bs);
+	}
+#endif
+
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DASH_MODE);
 	if (p && (p->value.uint==1)) {
 		ctx->dash_mode = GF_TRUE;
@@ -1029,7 +1312,10 @@
 		if (ctx->dash_mode) {
 			ffmx_close_seg(filter, ctx, GF_FALSE);
 		} else {
-			av_write_trailer(ctx->muxer);
+			int res = av_write_trailer(ctx->muxer);
+			if (res) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Failed to write trailer for %s: %s\n", ctx->dst, av_err2str(res) ));
+			}
 		}
 		ctx->status = FFMX_STATE_TRAILER_DONE;
 	} 
@@ -1058,26 +1344,8 @@
 
 static GF_Err ffmx_update_arg(GF_Filter *filter, const char *arg_name, const GF_PropertyValue *arg_val)
 {
-	s32 res;
 	GF_FFMuxCtx *ctx = gf_filter_get_udta(filter);
-
-	//initial parsing of arguments
-	if (!ctx->muxer) {
-		switch (arg_val->type) {
-		case GF_PROP_STRING:
-			res = av_dict_set(&ctx->options, arg_name, arg_val->value.string, 0);
-			if (res<0) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Failed to set option %s:%s\n", arg_name, arg_val ));
-			}
-			break;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("FFMux Failed to set option %s:%s, unrecognized type %d\n", arg_name, arg_val, arg_val->type ));
-			return GF_NOT_SUPPORTED;
-		}
-		return GF_OK;
-	}
-	//updates of arguments, not supported for ffmpeg decoders
-	return GF_NOT_SUPPORTED;
+	return ffmpeg_update_arg("FFMux", ctx->muxer, &ctx->options, arg_name, arg_val);
 }
 
 static GF_FilterProbeScore ffmx_probe_url(const char *url, const char *mime)
@@ -1110,14 +1378,20 @@
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
-	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE),
-
-#ifdef FF_SUB_SUPPORT
+	{0},
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
-#endif
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_SUBS_TEXT),
+	{0},
+	//these ones are framed (DVB subs, simple text)
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_DVB_SUBS),
 };
 
 GF_FilterRegister FFMuxRegister = {
@@ -1162,12 +1436,14 @@
 	{ OFFS(dst), "location of destination file or remote URL", GF_PROP_NAME, NULL, NULL, 0},
 	{ OFFS(start), "set playback start offset. A negative value means percent of media duration with -1 equal to duration", GF_PROP_DOUBLE, "0.0", NULL, 0},
 	{ OFFS(speed), "set playback speed. If negative and start is 0, start is set to -1", GF_PROP_DOUBLE, "1.0", NULL, 0},
-	{ OFFS(interleave), "write frame in interleave mode", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(ileave), "interleave window duration in second, a value of 0 disable interleaving", GF_PROP_FRACTION, "1", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(nodisc), "ignore stream configuration changes while multiplexing, may result in broken streams", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(mime), "set mime type for graph resolution", GF_PROP_NAME, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(ffiles), "force complete files to be created for each segment in DASH modes", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(ffmt), "force ffmpeg output format for the given URL", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(block_size), "block size used to read file when using avio context", GF_PROP_UINT, "4096", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(keepts), "do not shift input timeline back to 0", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(ext), "force ffmpeg output format for the given URL", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_HIDE},
 	{ "*", -1, "any possible options defined for AVFormatContext and sub-classes (see `gpac -hx ffmx` and `gpac -hx ffmx:*`)", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_META},
 	{0}
 };
@@ -1176,8 +1452,7 @@
 
 const GF_FilterRegister *ffmx_register(GF_FilterSession *session)
 {
-	ffmpeg_build_register(session, &FFMuxRegister, FFMuxArgs, FFMX_STATIC_ARGS, FF_REG_TYPE_MUX);
-	return &FFMuxRegister;
+	return ffmpeg_build_register(session, &FFMuxRegister, FFMuxArgs, FFMX_STATIC_ARGS, FF_REG_TYPE_MUX);
 }
 
 #else

gpac-2.0.0.tar.gz/src/filters/ff_rescale.c -> gpac-2.2.0.tar.gz/src/filters/ff_rescale.c Changed

@@ -67,13 +67,31 @@
 	Bool fullrange;
 
 	u32 o_bpp, offset_w, offset_h;
+
+	Bool unpack_v410, repack_v410, unpack_v210, repack_v210;
+	u32 orig_in_stride, repack_stride;
+	u8 *unpack_buf, *repack_buf;
+
+	u32 unpack_generic, unpack_depth;
+	Bool unpack_yuv, unpack_alpha;
+
+	u32 repack_generic, repack_depth;
+	Bool repack_yuv, repack_alpha;
+
 	GF_EVGSurface *surf;
+	GF_EVGStencil *tx;
+	GF_Path *path;
 } GF_FFSWScaleCtx;
 
+#include <libavutil/intreadwrite.h>
+
+u32 gf_evg_stencil_get_pixel_fast(GF_EVGStencil *st, s32 x, s32 y);
+u64 gf_evg_stencil_get_pixel_wide_fast(GF_EVGStencil *st, s32 x, s32 y);
+
 static GF_Err ffsws_process(GF_Filter *filter)
 {
 	const char *data;
-	u8 *output;
+	u8 *output, *pck_data;
 	u32 osize;
 	s32 res;
 	u8 *src_planes5;
@@ -111,7 +129,7 @@
 	frame_ifce = gf_filter_pck_get_frame_interface(pck);
 	//we may have buffer input (padding) but shall not have smaller
 	if (osize && (ctx->out_src_size > osize) ) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFSWS Mismatched in source osize, expected %d got %d - stride issue ?\n", ctx->out_src_size, osize));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFSWS Mismatch in source osize, expected %d got %d - stride issue ?\n", ctx->out_src_size, osize));
 		gf_filter_pid_drop_packet(ctx->ipid);
 		return GF_NOT_SUPPORTED;
 	}
@@ -126,17 +144,194 @@
 	if (data) {
 		src_planes0 = (u8 *) data;
 
-		if (ctx->nb_src_planes==1) {
-		} else if (ctx->nb_src_planes==2) {
+		if (ctx->unpack_v410) {
+			u32 i, j;
+			for (j=0; j<ctx->h; j++) {
+				const u8 *p_src = data + j * ctx->orig_in_stride;
+				u8 *p_y = ctx->unpack_buf + j * ctx->w * 2;
+				u8 *p_u = p_y + ctx->h * ctx->w * 2;
+				u8 *p_v = p_u + ctx->h * ctx->w * 2;
+
+				for (i=0; i<ctx->w; i++) {
+					u32 val = AV_RL32(p_src);
+					*(u16*) p_u = (val>>2) & 0x3FF;
+					*(u16*) p_y = (val>>12) & 0x3FF;
+					*(u16*) p_v = (val>>22);
+
+					p_u+=2;
+					p_v+=2;
+					p_y+=2;
+					p_src+=4;
+				}
+			}
+			src_planes0 = ctx->unpack_buf;
+			src_planes1 = src_planes0 + ctx->src_stride0*ctx->h;
+			src_planes2 = src_planes1 + ctx->src_stride1*ctx->h;
+		} else if (ctx->unpack_v210) {
+			u32 i, j;
+			for (j=0; j<ctx->h; j++) {
+				u32 cur_w = 0;
+				const u8 *p_src = data + j * ctx->orig_in_stride;
+				u8 *p_y = ctx->unpack_buf + j * ctx->w * 2;
+				u8 *p_u = ctx->unpack_buf + j * ctx->w + ctx->h * ctx->w * 2;
+				u8 *p_v = p_u + ctx->h * ctx->w;
+
+				for (i=0; i<ctx->w; i+=6) {
+					u32 val;
+					u16 u, v, y;
+					//first word is xx Cr0 Y0 Cb0
+					val = AV_RL32(p_src);
+					u = (val) & 0x3FF;
+					*(u16*) p_y = (val>>10) & 0x3FF;
+					v = (val>>20) & 0x3FF;
+					*(u16*) p_u = u;
+					*(u16*) p_v = v;
+					p_u+=2;
+					p_v+=2;
+					p_y+=2;
+					p_src+=4;
+					cur_w++;
+					if (cur_w>=ctx->w) break;
+
+					//second word is xx Y2 Cb1 Y1
+					val = AV_RL32(p_src);
+					y = (val) & 0x3FF;
+
+					*(u16*) p_y = y;
+					p_y+=2;
+					cur_w++;
+					if (cur_w>=ctx->w) break;
+
+					u = (val>>10) & 0x3FF;
+					y = (val>>20) & 0x3FF;
+					p_src+=4;
+
+					//third word is xx Cb2 Y3 Cr1
+					val = AV_RL32(p_src);
+					v = (val) & 0x3FF;
+					*(u16*) p_y = y;
+					*(u16*) p_u = u;
+					*(u16*) p_v = v;
+					p_u+=2;
+					p_v+=2;
+					p_y+=2;
+					cur_w++;
+					if (cur_w>=ctx->w) break;
+
+					y = (val>>10) & 0x3FF;
+					*(u16*) p_y = y;
+					p_y+=2;
+					cur_w++;
+					if (cur_w>=ctx->w) break;
+
+					u = (val>>20) & 0x3FF;
+					p_src+=4;
+
+					//fourth word is xx Y5 Cr2 Y4
+					val = AV_RL32(p_src);
+					y = (val) & 0x3FF;
+					v = (val>>10) & 0x3FF;
+
+					*(u16*) p_y = y;
+					*(u16*) p_u = u;
+					*(u16*) p_v = v;
+					p_u+=2;
+					p_v+=2;
+					p_y+=2;
+					cur_w++;
+					if (cur_w>=ctx->w) break;
+
+					y = (val>>20) & 0x3FF;
+					*(u16*) p_y = y;
+					p_y+=2;
+					p_src+=4;
+					cur_w++;
+					if (cur_w>=ctx->w) break;
+				}
+			}
+			src_planes0 = ctx->unpack_buf;
 			src_planes1 = src_planes0 + ctx->src_stride0*ctx->h;
-		} else if (ctx->nb_src_planes==3) {
-			src_planes1 = src_planes0 + ctx->src_stride0 * ctx->h;
-			src_planes2 = src_planes1 + ctx->src_stride1 * ctx->src_uv_height;
-		} else if (ctx->nb_src_planes==4) {
-			src_planes1 = src_planes0 + ctx->src_stride0 * ctx->h;
-			src_planes2 = src_planes1 + ctx->src_stride1 * ctx->src_uv_height;
-			src_planes3 = src_planes2 + ctx->src_stride2 * ctx->src_uv_height;
+			src_planes2 = src_planes1 + ctx->src_stride1*ctx->h;
+		} else if (ctx->unpack_generic) {
+			GF_Err e = gf_evg_stencil_set_texture_planes(ctx->tx, ctx->w, ctx->h, ctx->s_pfmt, data, ctx->orig_in_stride, NULL, NULL, 0, NULL, 0);
+			if (e) return e;
+
+			u32 i, j;
+			Bool wide = GF_FALSE;
+			Bool alpha = ctx->unpack_alpha;
+			u32 Bpp = ctx->unpack_yuv ? 1 : (alpha ? 4 : 3);
+			u32 bshift = 0;
+			if (ctx->unpack_yuv && (ctx->unpack_depth>8)) {
+				wide = GF_TRUE;
+				Bpp = 2;
+				bshift = 16 - ctx->unpack_depth;
+			}
+			for (j=0; j<ctx->h; j++) {
+				u8 *p_u=NULL, *p_v=NULL, *p_a=NULL;
+				u8 *p_y = ctx->unpack_buf + j * ctx->w * Bpp;
+				if (ctx->unpack_yuv) {
+					p_u = p_y + ctx->h * ctx->w * Bpp;
+					p_v = p_u + ctx->h * ctx->w * Bpp;
+					if (alpha)
+						p_a = p_v + ctx->h * ctx->w * Bpp;
+				}
+
+				for (i=0; i<ctx->w; i++) {
+					if (ctx->unpack_yuv) {
+						if (wide) {
+							u64 col = gf_evg_stencil_get_pixel_wide_fast(ctx->tx, i ,j);
+							*(u16*)p_y = GF_COLW_R(col) >> bshift;
+							*(u16*)p_u = GF_COLW_G(col) >> bshift;
+							*(u16*)p_v = GF_COLW_B(col) >> bshift;
+							if (alpha)
+								*(u16*)p_a = GF_COLW_A(col) >> bshift;
+						} else {
+							u32 col = gf_evg_stencil_get_pixel_fast(ctx->tx, i ,j);
+							*p_y = GF_COL_R(col);
+							*p_u = GF_COL_G(col);
+							*p_v = GF_COL_B(col);
+							if (alpha)
+								*p_a = GF_COL_A(col);
+						}
+						p_y+=Bpp;
+						p_u+=Bpp;
+						p_v+=Bpp;
+						if (alpha)
+							p_a+=Bpp;
+					} else {
+						u32 col = gf_evg_stencil_get_pixel_fast(ctx->tx, i ,j);
+						p_y0 = GF_COL_R(col);
+						p_y1 = GF_COL_G(col);
+						p_y2 = GF_COL_B(col);
+						if (alpha) {
+							p_y3 = GF_COL_A(col);
+							p_y+=4;
+						} else {
+							p_y+=3;
+						}
+					}
+				}
+			}
+
+			src_planes0 = ctx->unpack_buf;
+			if (ctx->unpack_yuv) {
+				src_planes1 = src_planes0 + ctx->src_stride0*ctx->h;
+				src_planes2 = src_planes1 + ctx->src_stride1*ctx->h;
+			}
+		} else {
+			if (ctx->nb_src_planes==1) {
+			} else if (ctx->nb_src_planes==2) {
+				src_planes1 = src_planes0 + ctx->src_stride0*ctx->h;
+			} else if (ctx->nb_src_planes==3) {
+				src_planes1 = src_planes0 + ctx->src_stride0 * ctx->h;
+				src_planes2 = src_planes1 + ctx->src_stride1 * ctx->src_uv_height;
+			} else if (ctx->nb_src_planes==4) {
+				src_planes1 = src_planes0 + ctx->src_stride0 * ctx->h;
+				src_planes2 = src_planes1 + ctx->src_stride1 * ctx->src_uv_height;
+				src_planes3 = src_planes2 + ctx->src_stride2 * ctx->src_uv_height;
+			}
 		}
+
 	} else if (frame_ifce && frame_ifce->get_plane) {
 		u32 i=0;
 		for (i=0; i<ctx->nb_src_planes; i++) {
@@ -148,6 +343,12 @@
 		gf_filter_pid_drop_packet(ctx->ipid);
 		return GF_NOT_SUPPORTED;
 	}
+
+	pck_data = output;
+	if (ctx->repack_v410 || ctx->repack_v210 || ctx->repack_generic) {
+		output = ctx->repack_buf;
+	}
+
 	dst_planes0 = output;
 	dst_planes0 += ctx->dst_stride0 * ctx->offset_h + ctx->offset_w*ctx->o_bpp;
 
@@ -194,7 +395,113 @@
 		return GF_NOT_SUPPORTED;
 	}
 
-	if (ctx->swap_idx_1 || ctx->swap_idx_2) {
+
+	if (ctx->repack_v410) {
+		u32 i, j;
+		output = pck_data;
+		for (j=0; j<ctx->oh; j++) {
+			u8 *p_dst = output + j * ctx->repack_stride;
+			u8 *p_y = ctx->repack_buf + j * ctx->ow * 2;
+			u8 *p_u = p_y + ctx->oh * ctx->ow * 2;
+			u8 *p_v = p_u + ctx->oh * ctx->ow * 2;
+
+			for (i=0; i<ctx->ow; i++) {
+				u32 val = 0;
+				val = *(u16 *) p_v; val<<=10;
+				val |= *(u16 *) p_y; val<<=10;
+				val |= *(u16 *) p_u; val<<=2;
+
+				p_dst0 = val & 0xFF;
+				p_dst1 = (val>>8) & 0xFF;
+				p_dst2 = (val>>16) & 0xFF;
+				p_dst3 = (val>>24) & 0xFF;
+
+				p_u+=2;
+				p_v+=2;
+				p_y+=2;
+				p_dst+=4;
+			}
+		}
+	}
+	else if (ctx->repack_v210) {
+		u32 i, j;
+		output = pck_data;
+		for (j=0; j<ctx->oh; j++) {
+			u8 *p_dst = output + j * ctx->repack_stride;
+			u8 *p_y = ctx->repack_buf + j * ctx->ow * 2;
+			u8 *p_u = ctx->repack_buf + ctx->oh * ctx->ow * 2 + j * ctx->ow;
+			u8 *p_v = p_u + ctx->oh * ctx->ow;
+			u32 cur_uv_w=0;
+
+			for (i=0; i<ctx->ow; i+=6) {
+				u32 val = 0;
+				val = *(u16 *) p_u;
+				p_u+=2;
+				val |= ((u32) *(u16 *) p_y) << 10;
+				p_y+=2;
+				val |= ((u32) *(u16 *) p_v) << 20;
+				p_v+=2;
+
+#define PUT_WORD_LE \
+				p_dst0 = val & 0xFF;\
+				p_dst1 = (val>>8) & 0xFF;\
+				p_dst2 = (val>>16) & 0xFF;\
+				p_dst3 = (val>>24) & 0xFF;\
+				p_dst+=4;\
+
+				PUT_WORD_LE
+
+				val = *(u16 *) p_y;
+				p_y+=2;
+
+				cur_uv_w+=2;
+				if (cur_uv_w>=ctx->ow) {
+					PUT_WORD_LE
+					break;
+				}
+				val |= ((u32) *(u16 *) p_u) << 10;
+				p_u+=2;
+				val |= ((u32) *(u16 *) p_y) << 20;
+				p_y+=2;
+
+				PUT_WORD_LE
+
+				val = *(u16 *) p_v;
+				p_v+=2;
+				val |= ((u32) *(u16 *) p_y) << 10;
+				p_y+=2;
+
+				cur_uv_w+=2;
+				if (cur_uv_w>=ctx->ow) {
+					PUT_WORD_LE
+					break;
+				}
+
+				val |= ((u32) *(u16 *) p_u) << 20;
+				p_u+=2;
+
+				PUT_WORD_LE
+
+				val = *(u16 *) p_y;
+				p_y+=2;
+				val |= ((u32) *(u16 *) p_v) << 10;
+				p_v+=2;
+				val |= ((u32) *(u16 *) p_y) << 20;
+				p_y+=2;
+
+				PUT_WORD_LE
+
+				cur_uv_w+=2;
+				if (cur_uv_w>=ctx->ow)
+					break;
+			}
+		}
+	} else if (ctx->repack_generic) {
+		gf_evg_surface_attach_to_buffer(ctx->surf, pck_data, ctx->ow, ctx->oh, 0, ctx->repack_stride, ctx->ofmt);
+		gf_evg_stencil_set_texture(ctx->tx, ctx->repack_buf, ctx->ow, ctx->oh, ctx->dst_stride0, ctx->repack_generic);
+		gf_evg_surface_set_path(ctx->surf, ctx->path);
+		gf_evg_surface_fill(ctx->surf, ctx->tx);
+	} else if (ctx->swap_idx_1 || ctx->swap_idx_2) {
 		u32 i, j;
 		for (i=0; i<ctx->h; i++) {
 			u8 *dst = output + ctx->dst_stride0*i;
@@ -400,8 +707,62 @@
 		nb_par = 0;
 		Bool res;
 		u32 mode = get_sws_mode(ctx->scale, &nb_par);
-		u32 ff_src_pfmt = ffmpeg_pixfmt_from_gpac(ofmt);
-		u32 ff_dst_pfmt = ffmpeg_pixfmt_from_gpac(ctx->ofmt);
+
+		u32 ff_src_pfmt, ff_dst_pfmt;
+		ctx->unpack_v410 = ctx->repack_v410 = GF_FALSE;
+		ctx->unpack_v210 = ctx->repack_v210 = GF_FALSE;
+		ctx->unpack_generic = ctx->repack_generic = 0;
+
+		//v410 and v210 as treated as codecs in ffmpeg, we deal with them as pixel formats
+		if (ofmt == GF_PIXEL_YUV444_10_PACK) {
+			ctx->unpack_v410 = GF_TRUE;
+			ff_src_pfmt = ffmpeg_pixfmt_from_gpac(GF_PIXEL_YUV444_10, GF_FALSE);
+		} else if (ofmt == GF_PIXEL_V210) {
+			ctx->unpack_v210 = GF_TRUE;
+			ff_src_pfmt = ffmpeg_pixfmt_from_gpac(GF_PIXEL_YUV422_10, GF_FALSE);
+		} else {
+			ff_src_pfmt = ffmpeg_pixfmt_from_gpac(ofmt, GF_TRUE);
+			if (ff_src_pfmt==AV_PIX_FMT_NONE) {
+				if (gf_evg_stencil_set_texture(ctx->tx, (u8*)ctx, 4, 2, 0, ofmt)==GF_OK) {
+					ctx->unpack_yuv = gf_pixel_fmt_is_yuv(ofmt);
+					ctx->unpack_depth = gf_pixel_is_wide_depth(ofmt);
+					ctx->unpack_alpha = gf_pixel_fmt_is_transparent(ofmt);
+					if (ctx->unpack_yuv) {
+						if (ctx->unpack_alpha) ctx->unpack_generic = GF_PIXEL_YUVA444;
+						else ctx->unpack_generic = (ctx->unpack_depth>8) ? GF_PIXEL_YUV444_10 : GF_PIXEL_YUV444;
+					} else {
+						ctx->unpack_generic = ctx->unpack_alpha ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
+					}
+					ff_src_pfmt = ffmpeg_pixfmt_from_gpac(ctx->unpack_generic, GF_FALSE);
+				}
+			}
+		}
+		if (ctx->ofmt == GF_PIXEL_YUV444_10_PACK) {
+			ctx->repack_v410 = GF_TRUE;
+			ff_dst_pfmt = ffmpeg_pixfmt_from_gpac(GF_PIXEL_YUV444_10, GF_FALSE);
+		} else if (ctx->ofmt == GF_PIXEL_V210) {
+			ctx->repack_v210 = GF_TRUE;
+			ff_dst_pfmt = ffmpeg_pixfmt_from_gpac(GF_PIXEL_YUV422_10, GF_FALSE);
+		} else {
+			ff_dst_pfmt = ffmpeg_pixfmt_from_gpac(ctx->ofmt, GF_TRUE);
+			if (ff_dst_pfmt == AV_PIX_FMT_NONE) {
+				if (gf_evg_surface_attach_to_buffer(ctx->surf, (u8 *) ctx, 4, 2, 0, 0, ctx->ofmt)==GF_OK) {
+					ctx->repack_yuv = gf_pixel_fmt_is_yuv(ctx->ofmt);
+					ctx->repack_depth = gf_pixel_is_wide_depth(ctx->ofmt);
+					ctx->repack_alpha = gf_pixel_fmt_is_transparent(ctx->ofmt);
+					if (ctx->repack_yuv) {
+						if (ctx->repack_alpha) ctx->repack_generic = GF_PIXEL_YUVA444;
+						else ctx->repack_generic = (ctx->repack_depth>8) ? GF_PIXEL_YUV444_10 : GF_PIXEL_YUV444;
+					} else {
+						ctx->repack_generic = ctx->repack_alpha ? GF_PIXEL_RGBA : GF_PIXEL_RGB;
+					}
+					ff_dst_pfmt = ffmpeg_pixfmt_from_gpac(ctx->repack_generic, GF_FALSE);
+				}
+			}
+		}
+
+		if ((ff_src_pfmt==AV_PIX_FMT_NONE) || (ff_dst_pfmt==AV_PIX_FMT_NONE))
+			return GF_NOT_SUPPORTED;
 
 		//get layout info for source
 		memset(ctx->src_stride, 0, sizeof(ctx->src_stride));
@@ -413,8 +774,31 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("FFSWS Failed to query source pixel format characteristics\n"));
 			return GF_NOT_SUPPORTED;
 		}
-		if (ctx->nb_src_planes==3) ctx->src_stride2 = ctx->src_stride1;
-		if (ctx->nb_src_planes==4) ctx->src_stride3 = ctx->src_stride0;
+		if (ctx->unpack_v410) {
+			ctx->unpack_buf = gf_realloc(ctx->unpack_buf, w*h*3*2);
+			ctx->nb_src_planes = 3;
+			ctx->orig_in_stride = ctx->src_stride0;
+			ctx->src_stride2 = ctx->src_stride1 = ctx->src_stride0 = 2*w;
+			ctx->src_uv_height = h;
+		} else if (ctx->unpack_v210) {
+			ctx->unpack_buf = gf_realloc(ctx->unpack_buf, w*h*2*2);
+			ctx->nb_src_planes = 3;
+			ctx->orig_in_stride = ctx->src_stride0;
+			ctx->src_stride0 = 2*w;
+			ctx->src_stride2 = ctx->src_stride1 = w;
+			ctx->src_uv_height = h;
+		} else if (ctx->unpack_generic) {
+			u32 planes = ctx->unpack_alpha ? 4 : 3;
+			u32 Bpp = (ctx->unpack_depth>8) ? 2 : 1;
+			ctx->unpack_buf = gf_realloc(ctx->unpack_buf, w*h*planes*Bpp);
+			ctx->nb_src_planes = ctx->unpack_yuv ? planes : 1;
+			ctx->orig_in_stride = ctx->src_stride0;
+			ctx->src_stride2 = ctx->src_stride1 = ctx->src_stride0 = Bpp*w;
+			ctx->src_uv_height = h;
+		} else {
+			if (ctx->nb_src_planes==3) ctx->src_stride2 = ctx->src_stride1;
+			if (ctx->nb_src_planes==4) ctx->src_stride3 = ctx->src_stride0;
+		}
 
 		ctx->o_bpp = gf_pixel_get_bytes_per_pixel(ofmt);
 		//get layout info for dest
@@ -427,7 +811,36 @@
 		if (ctx->nb_planes==3) ctx->dst_stride2 = ctx->dst_stride1;
 		if (ctx->nb_planes==4) ctx->dst_stride3 = ctx->dst_stride0;
 
-
+		if (ctx->repack_v410) {
+			ctx->nb_planes = 3;
+			ctx->repack_stride = ctx->dst_stride0;
+			ctx->repack_buf = gf_realloc(ctx->repack_buf, ctx->ow * ctx->oh * 3 * 2);
+			ctx->dst_stride2 = ctx->dst_stride1 = ctx->dst_stride0 = 2 * ctx->ow;
+			ctx->dst_uv_height = ctx->oh;
+			ctx->o_bpp = 2;
+		}
+		else if (ctx->repack_v210) {
+			ctx->nb_planes = 3;
+			ctx->repack_stride = ctx->dst_stride0;
+			ctx->repack_buf = gf_realloc(ctx->repack_buf, ctx->ow * ctx->oh * 2 * 2);
+			ctx->dst_stride0 = 2 * ctx->ow;
+			ctx->dst_stride2 = ctx->dst_stride1 = ctx->ow;
+			ctx->dst_uv_height = ctx->oh;
+			ctx->o_bpp = 2;
+		}
+		else if (ctx->repack_generic) {
+			u32 osize;
+			ctx->repack_stride = ctx->dst_stride0;
+			ctx->dst_stride0 = ctx->dst_stride1 = ctx->dst_stride2 = ctx->dst_stride3 = 0;
+			gf_pixel_get_size_info(ctx->repack_generic, ctx->ow, ctx->oh, &osize, &ctx->dst_stride0 , &ctx->dst_stride1, &ctx->nb_planes, &ctx->dst_uv_height);
+			ctx->repack_buf = gf_realloc(ctx->repack_buf, osize);
+			ctx->dst_stride2 = ctx->dst_stride1;
+			if (ctx->repack_alpha)
+				ctx->dst_stride3 = ctx->dst_stride0;
+
+			gf_path_reset(ctx->path);
+			gf_path_add_rect_center(ctx->path, 0, 0, INT2FIX(ctx->ow), INT2FIX(ctx->oh));
+		}
 		if (nb_par) {
 			if ((nb_par==1) && (ctx->p1!=GF_MAX_DOUBLE) ) {
 				par0 = ctx->p1;
@@ -490,9 +903,17 @@
 
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_WIDTH, &PROP_UINT(ctx->ow));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_HEIGHT, &PROP_UINT(ctx->oh));
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE, &PROP_UINT(ctx->dst_stride0));
-	if (ctx->nb_planes>1)
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE_UV, &PROP_UINT(ctx->dst_stride1));
+
+	if (ctx->repack_v410 || ctx->repack_v210 || ctx->repack_generic) {
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE, &PROP_UINT(ctx->repack_stride));
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE_UV, NULL );
+	} else {
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE, &PROP_UINT(ctx->dst_stride0));
+		if (ctx->nb_planes>1)
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE_UV, &PROP_UINT(ctx->dst_stride1));
+		else
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STRIDE_UV, NULL );
+	}
 
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->ofmt));
@@ -504,6 +925,12 @@
 	} else {
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_SAR, NULL );
 	}
+
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CLAP_X, NULL);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CLAP_Y, NULL);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CLAP_W, NULL);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CLAP_H, NULL);
+
 	return GF_OK;
 }
 
@@ -511,7 +938,9 @@
 {
 	GF_FFSWScaleCtx *ctx = gf_filter_get_udta(filter);
 	ffmpeg_setup_logs(GF_LOG_MEDIA);
-	ctx->surf = gf_evg_surface_new(GF_FALSE);
+	ctx->surf = gf_evg_surface_new(GF_TRUE);
+	ctx->tx = gf_evg_stencil_new(GF_STENCIL_TEXTURE);
+	ctx->path = gf_path_new();
 
 	if (ctx->osar.num &&
 	 ((ctx->osar.num<0) || (ctx->osar.num < (s32) ctx->osar.den))
@@ -525,7 +954,11 @@
 {
 	GF_FFSWScaleCtx *ctx = gf_filter_get_udta(filter);
 	if (ctx->swscaler) sws_freeContext(ctx->swscaler);
+	if (ctx->unpack_buf) gf_free(ctx->unpack_buf);
+	if (ctx->repack_buf) gf_free(ctx->repack_buf);
 	gf_evg_surface_delete(ctx->surf);
+	gf_evg_stencil_delete(ctx->tx);
+	gf_path_del(ctx->path);
 	return;
 }
 
@@ -618,6 +1051,7 @@
 	.args = FFSWSArgs,
 	.configure_pid = ffsws_configure_pid,
 	SETCAPS(FFSWSCaps),
+	.flags = GF_FS_REG_ALLOW_CYCLIC,
 	.initialize = ffsws_initialize,
 	.finalize = ffsws_finalize,
 	.process = ffsws_process,

gpac-2.0.0.tar.gz/src/filters/filelist.c -> gpac-2.2.0.tar.gz/src/filters/filelist.c Changed

@@ -154,6 +154,7 @@
 	Bool is_eos;
 
 	GF_Fraction64 cts_offset, dts_offset, wait_dts_plus_one, dts_sub_plus_one;
+	u32 sync_init_time;
 
 	u32 nb_repeat;
 	Double start, stop;
@@ -199,6 +200,14 @@
 	u32 init_flags_splice_start, init_flags_splice_end;
 	Double init_start, init_stop;
 	Bool force_splice_resume;
+
+	u32 sigfrag_mode;
+	//for isobmf cat mode in sigfrag
+	char *rel_url, *abs_url, *init_url;
+
+
+	GF_PropUIntList chap_times;
+	GF_PropStringList chap_names;
 } GF_FileListCtx;
 
 static const GF_FilterCapability FileListCapsSrc =
@@ -450,8 +459,10 @@
 	opid = iopid->opid;
 
 	if (ctx->keep_splice && (ctx->splice_state==FL_SPLICE_ACTIVE) && iopid->splice_ipid) {
-		assert(!iopid->opid_aux);
-		iopid->opid_aux = gf_filter_pid_new(filter);
+		//we may already have opid_aux setup (in case of reconfig)
+		if (!iopid->opid_aux)
+			iopid->opid_aux = gf_filter_pid_new(filter);
+
 		opid = iopid->opid_aux;
 
 		gf_filter_pid_set_property_str(iopid->opid, "period_switch", &PROP_BOOL(GF_TRUE));
@@ -470,6 +481,12 @@
 
 	gf_filter_pid_copy_properties(opid, iopid->ipid);
 
+	if (ctx->sigfrag_mode && ctx->file_path) {
+		gf_filter_pid_set_property_str(iopid->opid, "manifest_url", &PROP_STRING(ctx->file_path));
+		if (ctx->init_url)
+			gf_filter_pid_set_property_str(iopid->opid, "init_url", &PROP_STRING(ctx->init_url));
+	}
+
 	//if file pid is defined, merge its properties. This will allow forwarding user-defined properties,
 	// eg -i list.txt:#MyProp=toto to all PIDs coming from the sources
 	if (ctx->file_pid) {
@@ -554,6 +571,21 @@
 		}
 	}
 
+	if (ctx->chap_times.nb_items) {
+		GF_PropertyValue prop;
+		prop.type = GF_PROP_UINT_LIST;
+		prop.value.uint_list = ctx->chap_times;
+		gf_filter_pid_set_property(opid, GF_PROP_PID_CHAP_TIMES, &prop);
+
+		prop.type = GF_PROP_STRING_LIST_COPY;
+		prop.value.string_list = ctx->chap_names;
+		gf_filter_pid_set_property(opid, GF_PROP_PID_CHAP_NAMES, &prop);
+	} else {
+		//we don't concatenate chapters for now
+		gf_filter_pid_set_property(opid, GF_PROP_PID_CHAP_TIMES, NULL);
+		gf_filter_pid_set_property(opid, GF_PROP_PID_CHAP_NAMES, NULL);
+	}
+
 	if (ctx->splice_state==FL_SPLICE_BEFORE) {
 		if (!ctx->splice_ctrl) ctx->splice_ctrl = iopid;
 		else if (iopid->stream_type==GF_STREAM_VISUAL) ctx->splice_ctrl = iopid;
@@ -630,7 +662,7 @@
 static void filelist_check_implicit_cat(GF_FileListCtx *ctx, char *szURL)
 {
 	char *res_url = NULL;
-	char *sep;
+	char *sep, *o_url = szURL;
 	if (ctx->file_path) {
 		res_url = gf_url_concatenate(ctx->file_path, szURL);
 		szURL = res_url;
@@ -638,12 +670,18 @@
 	//we use default session separator set in filelist
 	sep = gf_url_colon_suffix(szURL, '=');
 	if (sep) sep0 = 0;
-
-	switch (gf_isom_probe_file(szURL)) {
+#ifndef GPAC_DISABLE_ISOM
+	u32 isom_mode = gf_isom_probe_file(szURL);
+#else
+	u32 isom_mode=0;
+#endif
+	switch (isom_mode) {
 	//this is a fragment
 	case 3:
 		if (ctx->last_is_isom) {
 			ctx->do_cat = GF_TRUE;
+			if (ctx->sigfrag_mode == 1)
+				ctx->sigfrag_mode = 2;
 		}
 		break;
 	//this is a movie, reload
@@ -651,11 +689,43 @@
 	case 1:
 		ctx->do_cat = GF_FALSE;
 		ctx->last_is_isom = GF_TRUE;
+		if (sep && strstr(sep+1, "sigfrag")) {
+			ctx->sigfrag_mode = 1;
+		}
 		break;
 	default:
 		ctx->do_cat = GF_FALSE;
 		ctx->last_is_isom = GF_FALSE;
+		ctx->sigfrag_mode = 0;
+		if (ctx->rel_url) {
+			gf_free(ctx->rel_url);
+			ctx->rel_url = NULL;
+		}
+		if (ctx->abs_url) {
+			gf_free(ctx->abs_url);
+			ctx->abs_url = NULL;
+		}
+		if (ctx->init_url) {
+			gf_free(ctx->init_url);
+			ctx->init_url = NULL;
+		}
+	}
+
+	if (ctx->sigfrag_mode) {
+		if (ctx->rel_url) gf_free(ctx->rel_url);
+		ctx->rel_url = gf_strdup(o_url);
+		char *sep2 = gf_url_colon_suffix(ctx->rel_url, '=');
+		if (sep2) sep20 = 0;
+		if (ctx->sigfrag_mode==1) {
+			if (ctx->init_url) gf_free(ctx->init_url);
+			ctx->init_url = ctx->rel_url;
+			ctx->rel_url = NULL;
+		}
+
+		if (ctx->abs_url) gf_free(ctx->abs_url);
+		ctx->abs_url = gf_strdup(szURL);
 	}
+
 	if (sep) sep0 = ':';
 	if (res_url)
 		gf_free(res_url);
@@ -694,6 +764,19 @@
 	gf_parse_lfrac(aval, frac);
 }
 
+static void push_chapter(GF_FileListCtx *ctx, char *chap_name)
+{
+	u64 start = gf_timestamp_rescale(ctx->dts_offset.num, ctx->dts_offset.den, 1000);
+
+	ctx->chap_times.vals = gf_realloc(ctx->chap_times.vals, sizeof(u32)*(ctx->chap_times.nb_items+1));
+	ctx->chap_names.vals = gf_realloc(ctx->chap_names.vals, sizeof(char*)*(ctx->chap_names.nb_items+1));
+	ctx->chap_times.valsctx->chap_times.nb_items = (u32) start;
+	ctx->chap_names.valsctx->chap_names.nb_items = gf_strdup(chap_name);
+	ctx->chap_times.nb_items++;
+	ctx->chap_names.nb_items++;
+}
+
+
 static Bool filelist_next_url(GF_Filter *filter, GF_FileListCtx *ctx, char szURLGF_MAX_PATH, Bool is_splice_update)
 {
 	u32 len;
@@ -704,6 +787,7 @@
 	u64 start_range=0, end_range=0;
 	Double start=0, stop=0;
 	GF_Fraction64 splice_start, splice_end;
+	char chap_name1024;
 	Bool do_cat=0;
 	Bool do_del=0;
 	Bool is_end=0;
@@ -759,6 +843,7 @@
 
 	splice_start.num = splice_end.num = 0;
 	splice_start.den = splice_end.den = 0;
+	chap_name0=0;
 
 	f = gf_fopen(ctx->file_path, "rt");
 	while (f) {
@@ -814,6 +899,7 @@
 
 			while (args) {
 				char c;
+				Bool skip_first=GF_FALSE;
 				char *sep, *aval = NULL;
 				while (args0==' ') args++;
 
@@ -821,6 +907,11 @@
 				if (strncmp(args, "props", 5))
 					aval = strchr(args, ',');
 
+				if (!strncmp(args, "chap=\"", 6)) {
+					sep = strchr(args+7, '\"');
+					if (sep) skip_first = GF_TRUE;
+				}
+
 				if (sep && aval && (aval < sep))
 					sep = aval;
 				else if (aval)
@@ -834,6 +925,7 @@
 				if (aval) {
 					aval0 = 0;
 					aval++;
+					if (skip_first) aval++;
 				}
 
 				if (!strcmp(args, "repeat")) {
@@ -889,6 +981,9 @@
 				} else if (!strcmp(args, "sprops")) {
 					if (ctx->splice_props) gf_free(ctx->splice_props);
 					ctx->splice_props = aval ? gf_strdup(aval) : NULL;
+				} else if (!strcmp(args, "chap") && aval) {
+					strncpy(chap_name, aval, 1023);
+					chap_name1023=0;
 				} else {
 					if (!ctx->unknown_params || !strstr(ctx->unknown_params, args)) {
 						GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("FileList Unrecognized directive %s, ignoring\n", args));
@@ -1024,6 +1119,8 @@
 	ctx->start_range = start_range;
 	ctx->end_range = end_range;
 	filelist_check_implicit_cat(ctx, szURL);
+	if (chap_name0)
+		push_chapter(ctx, chap_name);
 	return GF_TRUE;
 }
 
@@ -1773,6 +1870,15 @@
 		}
 	}
 
+	if (ctx->sigfrag_mode && ctx->abs_url) {
+		gf_filter_pck_set_property(dst_pck, GF_PROP_PID_URL, &PROP_STRING(ctx->abs_url));
+		if (ctx->rel_url) {
+			gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENAME, &PROP_STRING(ctx->rel_url));
+		}
+		gf_free(ctx->abs_url);
+		ctx->abs_url = NULL;
+	}
+
 	gf_filter_pck_send(dst_pck);
 
 	if (!iopid->audio_samples_to_keep) {
@@ -1839,7 +1945,7 @@
 	//init first timestamp
 	if (!ctx->dts_sub_plus_one.num) {
 		u32 nb_eos = 0;
-
+		u32 nb_ready_av=0, nb_not_ready_av=0, nb_not_ready_sparse=0;
 		for (i=0; i<gf_list_count(ctx->filter_srcs); i++) {
 			GF_Filter *fsrc = gf_list_get(ctx->filter_srcs, i);
 			if (gf_filter_has_pid_connection_pending(fsrc, filter)) {
@@ -1869,10 +1975,15 @@
 					nb_eos++;
 					continue;
 				}
-				ctx->dts_sub_plus_one.num = 0;
-				return GF_OK;
+				if ((iopid->stream_type==GF_STREAM_AUDIO) || (iopid->stream_type==GF_STREAM_VISUAL))
+					nb_not_ready_av++;
+				else
+					nb_not_ready_sparse++;
+				continue;
+			}
+			if ((iopid->stream_type==GF_STREAM_AUDIO) || (iopid->stream_type==GF_STREAM_VISUAL)) {
+				nb_ready_av++;
 			}
-
 
 			dts = gf_filter_pck_get_dts(pck);
 			if (dts==GF_FILTER_NO_TS)
@@ -1920,6 +2031,19 @@
 				ctx->dts_sub_plus_one.den = iopid->timescale;
 			}
 	 	}
+
+		if (nb_not_ready_av || (!nb_ready_av && nb_not_ready_sparse)) {
+			u32 now = gf_sys_clock();
+			if (!ctx->sync_init_time) {
+				ctx->sync_init_time = now;
+			} else if (now - ctx->sync_init_time < 5000) {
+				ctx->dts_sub_plus_one.num = 0;
+				return GF_OK;
+			} else {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("FileList Failed to fetch one sample on each stream after %d ms, skipping initial sync\n", now - ctx->sync_init_time));
+			}
+		}
+		ctx->sync_init_time = 0;
 	 	ctx->src_error = GF_FALSE;
 	 	if (nb_eos) {
 			if (nb_eos==count) {
@@ -2009,8 +2133,9 @@
 				break;
 			}
 
-			if (gf_filter_pid_would_block(iopid->opid) && (!iopid->opid_aux || gf_filter_pid_would_block(iopid->opid_aux)))
+			if (gf_filter_pid_would_block(iopid->opid) && (!iopid->opid_aux || gf_filter_pid_would_block(iopid->opid_aux))) {
 				break;
+			}
 
 			cts = gf_filter_pck_get_cts(pck);
 			if (ctx->splice_state && (cts != GF_FILTER_NO_TS)) {
@@ -2705,6 +2830,15 @@
 	if (ctx->dyn_period_id) gf_free(ctx->dyn_period_id);
 	if (ctx->splice_props) gf_free(ctx->splice_props);
 	if (ctx->splice_pid_props) gf_free(ctx->splice_pid_props);
+	if (ctx->init_url) gf_free(ctx->init_url);
+	if (ctx->rel_url) gf_free(ctx->rel_url);
+	if (ctx->abs_url) gf_free(ctx->abs_url);
+
+	if (ctx->chap_times.vals) gf_free(ctx->chap_times.vals);
+	GF_PropertyValue p;
+	p.type = GF_PROP_STRING_LIST;
+	p.value.string_list = ctx->chap_names;
+	gf_props_reset_single(&p);
 }
 
 static const char *filelist_probe_data(const u8 *data, u32 size, GF_FilterProbeScore *score)
@@ -2788,7 +2922,6 @@
 	"- av: force decoding of audio and video inputs\n"
 	"- a: force decoding of audio inputs\n"
 	"- v: force decoding of video inputs", GF_PROP_UINT, "no", "av|a|v|no", GF_FS_ARG_HINT_NORMAL},
-
 	{0}
 };
 
@@ -2796,7 +2929,7 @@
 static const GF_FilterCapability FileListCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "txt|m3u|pl"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "m3u|pl"),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "application/x-gpac-playlist"),
 	CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 };
@@ -2820,7 +2953,7 @@
 		"\n"
 		"The resulting file list can be sorted using -fsort().\n"
 		"If the sort mode is `datex` and source files are images or single frame files, the following applies:\n"
-		"- options -floop(), -revert() and -dur() are ignored\n"
+		"- options -floop(), -revert() and -fdur() are ignored\n"
 		"- the files are sorted by modification time\n"
 		"- the first frame is assigned a timestamp of 0\n"
 		"- each frame (coming from each file) is assigned a duration equal to the difference of modification time between the file and the next file\n"
@@ -2859,6 +2992,7 @@
 		"- keep: keeps spliced period in output (cf below).\n"
 		"- mark: only inject marker for the splice period and do not load any replacement content (cf below).\n"
 		"- sprops=STR: assigns properties described in `STR` to all PIDs of the main content during a splice (cf below). `STR` is formatted according to `gpac -h doc` using the default parameter set.\n"
+		"- chap=NAME: assigns chapter name at the start of next URL (filter always removes source chapter names).\n"
 		"\n"
 		"The following global options (applying to the filter, not the sources) may also be set in the playlist:\n"
 		"- ka=N: force -ka() option to `N` millisecond refresh.\n"

gpac-2.0.0.tar.gz/src/filters/hevcmerge.c -> gpac-2.2.0.tar.gz/src/filters/hevcmerge.c Changed

gpac-2.0.0.tar.gz/src/filters/in_dvb4linux.c -> gpac-2.2.0.tar.gz/src/filters/in_dvb4linux.c Changed

gpac-2.0.0.tar.gz/src/filters/in_file.c -> gpac-2.2.0.tar.gz/src/filters/in_file.c Changed

@@ -42,6 +42,7 @@
 	char *src;
 	char *ext, *mime;
 	u32 block_size;
+	GF_PropData pck;
 	GF_Fraction64 range;
 
 	//only one output pid declared
@@ -71,8 +72,18 @@
 	char *src, *path;
 	const char *prev_url=NULL;
 
-	if (!ctx || !ctx->src) return GF_BAD_PARAM;
+	if (!ctx || (!ctx->src && !ctx->pck.size) ) return GF_BAD_PARAM;
 
+	if (ctx->pck.size) {
+		GF_FilterPacket *opck;
+		GF_Err e = gf_filter_pid_raw_new(filter, NULL, NULL, NULL, NULL, ctx->pck.ptr, ctx->pck.size, GF_FALSE, &ctx->pid);
+		if (e) return e;
+		opck = gf_filter_pck_new_shared(ctx->pid, ctx->pck.ptr, ctx->pck.size, NULL);
+		gf_filter_pck_send(opck);
+		gf_filter_pid_set_eos(ctx->pid);
+		ctx->is_end = GF_TRUE;
+		return GF_OK;
+	}
 	if (!strcmp(ctx->src, "null")) {
 		ctx->pid = gf_filter_pid_new(filter);
 		gf_filter_pid_set_property(ctx->pid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_FILE));
@@ -570,6 +581,7 @@
 	{ OFFS(range), "byte range", GF_PROP_FRACTION64, "0-0", NULL, 0},
 	{ OFFS(ext), "override file extension", GF_PROP_NAME, NULL, NULL, 0},
 	{ OFFS(mime), "set file mime type", GF_PROP_NAME, NULL, NULL, 0},
+	{ OFFS(pck), "data to use instead of file", GF_PROP_DATA, NULL, NULL, 0},
 	{0}
 };
 
@@ -605,6 +617,9 @@
 
 const GF_FilterRegister *filein_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_in_proto", FileInRegister.name, "file,isobmf,gmem,gfio");
+	}
 	return &FileInRegister;
 }

gpac-2.0.0.tar.gz/src/filters/in_http.c -> gpac-2.2.0.tar.gz/src/filters/in_http.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2017-2021
+ *			Copyright (c) Telecom ParisTech 2017-2022
 *					All rights reserved
 *
 * This file is part of GPAC / HTTP input filter using GPAC http stack
@@ -28,10 +28,10 @@
 #include <gpac/constants.h>
 #include <gpac/download.h>
 
-
 typedef enum
 {
-	GF_HTTPIN_STORE_DISK=0,
+	GF_HTTPIN_STORE_AUTO=0,
+	GF_HTTPIN_STORE_DISK,
 	GF_HTTPIN_STORE_DISK_KEEP,
 	GF_HTTPIN_STORE_MEM,
 	GF_HTTPIN_STORE_MEM_KEEP,
@@ -55,6 +55,8 @@
 	GF_Fraction64 range;
 	char *ext;
 	char *mime;
+	Bool blockio;
+
 
 	//internal
 	Bool initial_ack_done;
@@ -112,6 +114,8 @@
 		flags |= GF_NETIO_SESSION_NOT_CACHED;
 	else if (ctx->cache==GF_HTTPIN_STORE_DISK_KEEP)
 		flags |= GF_NETIO_SESSION_KEEP_CACHE;
+	else if (ctx->cache==GF_HTTPIN_STORE_AUTO)
+		flags |= GF_NETIO_SESSION_AUTO_CACHE;
 	else if (ctx->cache==GF_HTTPIN_STORE_MEM_KEEP) {
 		flags |= GF_NETIO_SESSION_MEMORY_CACHE|GF_NETIO_SESSION_KEEP_FIRST_CACHE;
 		ctx->cache = GF_HTTPIN_STORE_MEM;
@@ -120,6 +124,10 @@
 		flags |= GF_NETIO_SESSION_NOT_CACHED|GF_NETIO_SESSION_MEMORY_CACHE|GF_NETIO_SESSION_KEEP_FIRST_CACHE;
 		ctx->cache = GF_HTTPIN_STORE_NONE;
 	}
+	gf_filter_set_blocking(filter, GF_TRUE);
+
+	if (!ctx->blockio)
+		flags |= GF_NETIO_SESSION_NO_BLOCK;
 
 	server = strstr(ctx->src, "://");
 	if (server) server += 3;
@@ -275,6 +283,7 @@
 			GF_FilterPacket *pck;
 			gf_filter_pid_raw_new(filter, ctx->src, ctx->src, NULL, NULL, NULL, 0, GF_FALSE, &ctx->pid);
 			ctx->is_end = GF_TRUE;
+			ctx->prev_was_init_segment = GF_TRUE;
 			pck = gf_filter_pck_new_shared(ctx->pid, ctx->block, 0, httpin_rel_pck);
 			if (!pck) return GF_TRUE;
 			gf_filter_pck_set_framing(pck, GF_TRUE, GF_TRUE);
@@ -600,16 +609,18 @@
 	{ OFFS(src), "URL of source content", GF_PROP_NAME, NULL, NULL, 0},
 	{ OFFS(block_size), "block size used to read file", GF_PROP_UINT, "100000", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(cache), "set cache mode\n"
+	"- auto: cache to disk if content length is known, no cache otherwise\n"
 	"- disk: cache to disk, discard once session is no longer used\n"
 	"- keep: cache to disk and keep\n"
 	"- mem: stores to memory, discard once session is no longer used\n"
 	"- mem_keep: stores to memory, keep after session is reassigned but move to `mem` after first download\n"
 	"- none: no cache\n"
 	"- none_keep: stores to memory, keep after session is reassigned but move to `none` after first download"
-	, GF_PROP_UINT, "disk", "disk|keep|mem|mem_keep|none|none_keep", GF_FS_ARG_HINT_ADVANCED},
+	, GF_PROP_UINT, "disk", "auto|disk|keep|mem|mem_keep|none|none_keep", GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(range), "set byte range, as fraction", GF_PROP_FRACTION64, "0-0", NULL, 0},
 	{ OFFS(ext), "override file extension", GF_PROP_NAME, NULL, NULL, 0},
 	{ OFFS(mime), "set file mime type", GF_PROP_NAME, NULL, NULL, 0},
+	{ OFFS(blockio), "use blocking IO", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -624,6 +635,9 @@
 	GF_FS_SET_HELP("This filter dispatch raw blocks from a remote HTTP resource into a filter chain.\n"
 	"Block size can be adjusted using -block_size(), and disk caching policies can be adjusted.\n"
 	"Content format can be forced through -mime() and file extension can be changed through -ext().\n"
+	"\n"
+	"The filter supports both http and https schemes, and will attempt reconnecting as TLS if TCP connection fails.\n"
+	"\n"
 	"Note: Unless disabled at session level (see -no-probe(CORE) ), file extensions are usually ignored and format probing is done on the first data block.")
 	.private_size = sizeof(GF_HTTPInCtx),
 	.args = HTTPInArgs,
@@ -638,6 +652,9 @@
 
 const GF_FilterRegister *httpin_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_in_proto", HTTPInRegister.name, "http,https,gmem");
+	}
 	return &HTTPInRegister;
 }

gpac-2.0.0.tar.gz/src/filters/in_pipe.c -> gpac-2.2.0.tar.gz/src/filters/in_pipe.c Changed

gpac-2.0.0.tar.gz/src/filters/in_route.c -> gpac-2.2.0.tar.gz/src/filters/in_route.c Changed

gpac-2.0.0.tar.gz/src/filters/in_rtp.c -> gpac-2.2.0.tar.gz/src/filters/in_rtp.c Changed

@@ -57,8 +57,10 @@
 	/*we need rtsp/tcp , rtsp/udp or direct RTP sender (no control)*/
 	if (!strnicmp(url, "rtsp://", 7)
 		|| !strnicmp(url, "rtspu://", 8)
+		|| !strnicmp(url, "rtsph://", 8)
+		|| !strnicmp(url, "rtsps://", 8)
 		|| !strnicmp(url, "rtp://", 6)
-		|| !strnicmp(url, "satip://", 6))
+		|| !strnicmp(url, "satip://", 8))
 	{
 		return GF_FPROBE_SUPPORTED;
 	}
@@ -301,6 +303,7 @@
 
 	stream = rtpin_find_stream(ctx, evt->base.on_pid, 0, NULL, GF_FALSE);
 	if (!stream) return GF_TRUE;
+	if (stream->last_err) return GF_TRUE;
 
 	switch (evt->base.type) {
 	case GF_FEVT_PLAY:
@@ -317,6 +320,7 @@
 		/*is this RTSP or direct RTP?*/
 		stream->flags &= ~RTP_EOS;
 		stream->flags &= ~RTP_EOS_FLUSHED;
+		stream->last_udp_time = 0;
 
 		if (!(stream->flags & RTP_INTERLEAVED)) {
 			if (stream->rtp_ch->rtp)
@@ -342,6 +346,7 @@
 					ctx->postponed_play_stream = stream;
 					ctx->last_start_range = evt->play.start_range;
 				}
+				stream->flags &= ~RTP_SKIP_NEXT_COM;
 				return GF_TRUE;
 			}
 		} else {
@@ -399,10 +404,11 @@
 		}
 		break;
 	case GF_FEVT_SET_SPEED:
+		break;
 	case GF_FEVT_PAUSE:
 	case GF_FEVT_RESUME:
-		assert(stream->rtsp);
-		rtpin_rtsp_usercom_send(stream->rtsp, stream, evt);
+		if (stream->rtsp)
+			rtpin_rtsp_usercom_send(stream->rtsp, stream, evt);
 		break;
 	case GF_FEVT_CONNECT_FAIL:
 		//stream canceled due to setup failure, prevent any further setup on PLAY
@@ -412,23 +418,33 @@
 		break;
 	}
 
-	//flush rtsp commands
-	if (ctx->session && !skip_rtsp_teardown) {
-		rtpin_rtsp_process_commands(ctx->session);
+	if (!ctx->creds) {
+		//flush rtsp commands
+		if (ctx->session && !skip_rtsp_teardown) {
+			rtpin_rtsp_process_commands(ctx->session);
+		}
 	}
-
 	if (reset_stream) rtpin_stream_reset_queue(stream);
+
 	//cancel event
 	return GF_TRUE;
 }
 
-static void rtpin_rtsp_flush(GF_RTPInRTSP *session)
+static void rtpin_rtsp_flush(GF_RTPInRTSP *session, Bool reset_only)
 {
 	/*process teardown on all sessions*/
 	while (!session->connect_error) {
 		if (!gf_list_count(session->rtsp_commands))
 			break;
-		rtpin_rtsp_process_commands(session);
+
+		if (reset_only) {
+			GF_RTSPCommand *com = gf_list_pop_back(session->rtsp_commands);
+			com->Session = NULL;
+			gf_rtsp_command_del(com);
+			session->flags &= ~RTSP_WAIT_REPLY;
+		} else {
+			rtpin_rtsp_process_commands(session);
+		}
 	}
 }
 
@@ -439,6 +455,11 @@
 	GF_RTPIn *ctx = gf_filter_get_udta(filter);
 
 	if (ctx->is_eos) return GF_EOS;
+	if (ctx->notif_error) {
+		GF_Err e = ctx->notif_error;
+		ctx->notif_error = GF_OK;
+		return e;
+	}
 
 	if (ctx->ipid) {
 		GF_FilterPacket *pck = gf_filter_pid_get_packet(ctx->ipid);
@@ -469,27 +490,125 @@
 		rtpin_rtsp_usercom_send(stream->rtsp, stream, &evt);
 	}
 
+	if (ctx->session) {
+		GF_Err e = gf_rtsp_check_connection(ctx->session->session);
+		if (e==GF_IP_NETWORK_EMPTY) {
+			gf_filter_post_process_task(filter);
+			return GF_OK;
+		} else if (e) {
+
+			if (e==GF_IP_CONNECTION_CLOSED) {
+				if (gf_rtsp_session_reset(ctx->session->session, 1)<10) {
+#ifdef GPAC_HAS_SSL
+					if (gf_rtsp_session_needs_ssl(ctx->session->session) ) {
+						gf_rtsp_set_ssl_ctx(ctx->session->session, gf_dm_ssl_init(ctx->dm, 0) );
+					}
+#endif
+					e = GF_OK;
+				} else {
+					e = GF_IP_CONNECTION_FAILURE;
+				}
+			}
+
+			if (e==GF_IP_CONNECTION_FAILURE) {
+				gf_filter_setup_failure(filter, e);
+				gf_rtsp_session_del(ctx->session->session);
+				ctx->session->session = NULL;
+			}
+			return e;
+		}
+
+		if (ctx->check_creds) {
+			Bool force = (ctx->check_creds==2) ? GF_TRUE : GF_FALSE;
+			const char *user = gf_rtsp_get_user(ctx->session->session);
+			ctx->check_creds = 0;
+			if (user || force) {
+				const char *server_name = gf_rtsp_get_server_name(ctx->session->session);
+				const char *pass = gf_rtsp_get_password(ctx->session->session);
+				Bool secure = gf_rtsp_use_tls(ctx->session->session);
+				ctx->creds = gf_user_credentials_register(ctx->dm, secure, server_name, user, pass, GF_TRUE);
+				if (!ctx->creds) {
+					gf_filter_setup_failure(filter, GF_AUTHENTICATION_FAILURE);
+					return GF_AUTHENTICATION_FAILURE;
+				}
+			}
+		}
+
+		if (ctx->creds) {
+			if (ctx->creds->req_state==GF_CREDS_STATE_PENDING)
+				return GF_OK;
+
+			if (!ctx->creds->valid) {
+				ctx->creds = NULL;
+				gf_filter_setup_failure(filter, GF_AUTHENTICATION_FAILURE);
+				return GF_AUTHENTICATION_FAILURE;
+			}
+			gf_dynstrcat(&ctx->auth_string, "Basic ", NULL);
+			gf_dynstrcat(&ctx->auth_string, ctx->creds->digest, NULL);
+			ctx->creds = NULL;
+
+			if (ctx->auth_stream) {
+				stream = ctx->auth_stream;
+				ctx->auth_stream = NULL;
+				//send a setup if needed
+				stream->flags |= RTP_AUTH_RESETUP;
+				rtpin_check_setup(stream);
+				stream->flags &= ~RTP_AUTH_RESETUP;
+
+				//if not aggregated control or no more queued events send a play
+				if (! (stream->rtsp->flags & RTSP_AGG_CONTROL) ) {
+					GF_FilterEvent evt;
+					evt.base.on_pid = stream->opid;
+					evt.base.type = GF_FEVT_PLAY;
+					evt.play.start_range = ctx->last_start_range;
+					rtpin_rtsp_usercom_send(stream->rtsp, stream, &evt);
+				}
+			} else {
+				rtpin_rtsp_describe_send(ctx->session, 0, NULL);
+			}
+			return GF_OK;
+		}
+
+
+	}
+
 
-	if (ctx->retry_tcp && ctx->session) {
+	if (ctx->retry_rtsp && ctx->session) {
 		GF_FilterEvent evt;
 		Bool send_agg_play = GF_TRUE;
+		Bool force_tcp = GF_FALSE;
 		GF_List *streams = gf_list_new();
-		ctx->retry_tcp = GF_FALSE;
-		ctx->interleave = 1;
+
+		if (ctx->retry_rtsp==RETRY_RTSP_FORCE_TCP) {
+			ctx->transport = RTP_TRANSPORT_TCP_ONLY;
+			force_tcp = GF_TRUE;
+		}
+
 		i=0;
 		while ((stream = (GF_RTPInStream *)gf_list_enum(ctx->streams, &i))) {
 			if (stream->status >= RTP_Setup) {
 				gf_list_add(streams, stream);
 			}
 		}
-		rtpin_rtsp_flush(ctx->session);
-		/*send teardown*/
-		rtpin_rtsp_teardown(ctx->session, NULL);
-		rtpin_rtsp_flush(ctx->session);
-		//for safety reset the session, some servers don't handle teardown that well
-		gf_rtsp_session_reset(ctx->session->session, GF_TRUE);
+		if (!(ctx->retry_rtsp & RETRY_RTSP_PENDING)) {
+			rtpin_rtsp_flush(ctx->session, GF_TRUE);
+			/*send teardown*/
+			rtpin_rtsp_teardown(ctx->session, NULL);
+			rtpin_rtsp_flush(ctx->session, GF_FALSE);
+			//for safety reset the session, some servers don't handle teardown that well
+			gf_rtsp_session_reset(ctx->session->session, GF_TRUE);
+			ctx->retry_rtsp |= RETRY_RTSP_PENDING;
+		}
+		GF_Err e = gf_rtsp_check_connection(ctx->session->session);
+		if (e==GF_IP_NETWORK_EMPTY) {
+			gf_filter_post_process_task(filter);
+			return GF_OK;
+		}
+		ctx->retry_rtsp = RETRY_RTSP_NONE;
+
+		if (force_tcp)
+			ctx->session->flags |= RTSP_FORCE_INTER;
 
-		ctx->session->flags |= RTSP_FORCE_INTER;
 		evt.play = ctx->postponed_play;
 		if (!evt.base.type) evt.base.type = GF_FEVT_PLAY;
 		gf_rtsp_set_buffer_size(ctx->session->session, ctx->block_size);
@@ -502,13 +621,14 @@
 			//reset all dynamic flags
 			stream->flags &= ~(RTP_EOS | RTP_EOS_FLUSHED | RTP_SKIP_NEXT_COM | RTP_CONNECTED);
 			//mark as interleaved
-			stream->flags |= RTP_INTERLEAVED;
+			if (force_tcp)
+				stream->flags |= RTP_INTERLEAVED;
 			//reset SSRC since some servers don't include it in interleave response
 			gf_rtp_reset_ssrc(stream->rtp_ch);
 
 			//send setup
 			rtpin_check_setup(stream);
-			rtpin_rtsp_flush(ctx->session);
+			rtpin_rtsp_flush(ctx->session, GF_FALSE);
 
 			//if not aggregated control or no more queued events send a play
 			if (! (stream->rtsp->flags & RTSP_AGG_CONTROL) ) {
@@ -516,7 +636,7 @@
 				rtpin_rtsp_usercom_send(stream->rtsp, stream, &evt);
 				send_agg_play = GF_FALSE;
 			}
-			rtpin_rtsp_flush(ctx->session);
+			rtpin_rtsp_flush(ctx->session, GF_FALSE);
 		}
 		if (stream && send_agg_play) {
 			evt.base.on_pid = stream->opid;
@@ -539,8 +659,6 @@
 			break;
 		}
 
-		ctx->eos_probe_start = 0;
-
 		i=0;
 		while ((stream = (GF_RTPInStream *)gf_list_enum(ctx->streams, &i))) {
 			if (stream->status==RTP_Running) {
@@ -548,23 +666,28 @@
 				read += rtpin_stream_read(stream);
 			}
 
-			if (stream->flags & RTP_EOS) {
+			if ((stream->flags & RTP_EOS) && !ctx->eos_probe_start)
 				ctx->eos_probe_start = gf_sys_clock();
-			}
 		}
 
 		if (!read) {
 			break;
 		}
 		tot_read+=read;
+		ctx->eos_probe_start = 0;
 	}
 
 	//we wait max 300ms to detect eos
-	if (ctx->eos_probe_start && (gf_sys_clock() - ctx->eos_probe_start > 300) ) {
+	if (ctx->eos_probe_start && (gf_sys_clock() - ctx->eos_probe_start > 1000) ) {
 		u32 nb_eos=0;
 		i=0;
 		while ((stream = (GF_RTPInStream *)gf_list_enum(ctx->streams, &i))) {
-			if (! (stream->flags & RTP_EOS)) break;
+			if (! (stream->flags & RTP_EOS) ) {
+				if (stream->status!=RTP_Running) {
+					nb_eos++;
+				}
+				break;
+			}
 			if (stream->flags & RTP_EOS_FLUSHED) {
 				nb_eos++;
 				continue;
@@ -589,10 +712,20 @@
 		if (nb_eos==gf_list_count(ctx->streams)) {
 			if (!ctx->is_eos) {
 				ctx->is_eos = GF_TRUE;
+
+				//signal eos on all streams not yet signaled
+				i=0;
+				while ((stream = (GF_RTPInStream *)gf_list_enum(ctx->streams, &i))) {
+					if (! (stream->flags & RTP_EOS_FLUSHED)) {
+						gf_filter_pid_set_eos(stream->opid);
+						stream->flags |= RTP_EOS_FLUSHED;
+					}
+				}
+
 				if (ctx->session) {
 					/*send teardown*/
 					rtpin_rtsp_teardown(ctx->session, NULL);
-					rtpin_rtsp_flush(ctx->session);
+					rtpin_rtsp_flush(ctx->session, GF_FALSE);
 				}
 			}
 			return GF_EOS;
@@ -609,7 +742,7 @@
 			ctx->session->connect_error = GF_OK;
 		}
 	}
-
+	ctx->nb_bytes_rcv += tot_read;
 	//we had data, ask for immediate re-process
 	if (tot_read) {
 		gf_filter_post_process_task(filter);
@@ -619,7 +752,7 @@
 	if (ctx->max_sleep<0)
 		gf_filter_ask_rt_reschedule(filter, (u32) ((-ctx->max_sleep) *1000) );
 	else if (!ctx->min_frame_dur_ms) {
-		gf_filter_ask_rt_reschedule(filter, 1000);
+		gf_filter_ask_rt_reschedule(filter, ctx->nb_bytes_rcv ? 1000 : 10000);
 	}
 	else {
 		assert(ctx->min_frame_dur_ms <= (u32) ctx->max_sleep);
@@ -629,6 +762,11 @@
 	return GF_OK;
 }
 
+void rtpin_do_authenticate(GF_RTPIn *ctx)
+{
+	if (!ctx->session) return;
+	ctx->check_creds = 2;
+}
 
 static GF_Err rtpin_initialize(GF_Filter *filter)
 {
@@ -638,8 +776,12 @@
 	ctx->streams = gf_list_new();
 	ctx->filter = filter;
 	//turn on interleave on http port
-	if ((ctx->default_port == 80) || (ctx->default_port == 8080))
-		ctx->interleave = 1;
+	if (ctx->transport==RTP_TRANSPORT_AUTO) {
+		if ((ctx->default_port == 80) || (ctx->default_port == 8080))
+			ctx->transport = RTP_TRANSPORT_TCP_ONLY;
+		if (ctx->src && !strnicmp(ctx->src, "rtsph://", 8))
+			ctx->transport = RTP_TRANSPORT_TCP_ONLY;
+	}
 
 	ctx->last_start_range = -1.0;
 
@@ -699,11 +841,36 @@
 		rtpin_satip_get_server_ip(ctx->src, ctx->session->satip_server);
 	}
 
-	if (!ctx->session) {
+	if (!ctx->session)
 		return GF_NOT_SUPPORTED;
-	} else {
-		rtpin_rtsp_describe_send(ctx->session, 0, NULL);
+
+	ctx->dm = gf_filter_get_download_manager(filter);
+	if (!strnicmp(ctx->src, "rtsps://", 8)
+		|| (!strnicmp(ctx->src, "rtsph://", 8) && 
+			((gf_rtsp_get_session_port(ctx->session->session) == 443) || (gf_rtsp_get_session_port(ctx->session->session) == 8443)))
+	) {
+#ifdef GPAC_HAS_SSL
+
+#ifdef GPAC_ENABLE_COVERAGE
+		//all our tests directly detect ssl from above conditions
+		if (gf_sys_is_cov_mode())
+			gf_rtsp_session_needs_ssl(ctx->session->session);
+#endif
+
+		GF_Err e = gf_rtsp_set_ssl_ctx(ctx->session->session, gf_dm_ssl_init(ctx->dm, 0) );
+		if (e) return e;
+#else
+		return GF_NOT_SUPPORTED;
+#endif
+	}
+
+	const char *user = gf_rtsp_get_user(ctx->session->session);
+	if (user) {
+		ctx->check_creds = 1;
+		return GF_OK;
 	}
+
+	rtpin_rtsp_describe_send(ctx->session, 0, NULL);
 	return GF_OK;
 }
 
@@ -714,16 +881,17 @@
 	ctx->done = GF_TRUE;
 	if (ctx->session) {
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("RTP Closing RTSP service\n"));
-		rtpin_rtsp_flush(ctx->session);
+		rtpin_rtsp_flush(ctx->session, GF_FALSE);
 		if (!ctx->is_eos) {
 			/*send teardown*/
 			rtpin_rtsp_teardown(ctx->session, NULL);
-			rtpin_rtsp_flush(ctx->session);
+			rtpin_rtsp_flush(ctx->session, GF_FALSE);
 		}
 	}
 
 	rtpin_reset(ctx, GF_TRUE);
 	gf_list_del(ctx->streams);
+	if (ctx->auth_string) gf_free(ctx->auth_string);
 
 	gf_sk_group_del(ctx->sockgroup);
 }
@@ -773,7 +941,7 @@
 	{ OFFS(ttl), "multicast TTL", GF_PROP_UINT, "127", "0-127", GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(reorder_len), "reorder length in packets", GF_PROP_UINT, "1000", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(reorder_delay), "max delay in RTP re-orderer, packets will be dispatched after that", GF_PROP_UINT, "50", NULL, GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(block_size), "buffer size for RTP/UDP or RTSP when interleaved", GF_PROP_UINT, "0x200000", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(block_size), "buffer size for RTP/UDP or RTSP when interleaved", GF_PROP_UINT, "0x100000", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(disable_rtcp), "disable RTCP reporting", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(nat_keepalive), "delay in ms of NAT keepalive, disabled by default (except for SatIP, set to 30s by default)", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(force_mcast), "force multicast on indicated IP in RTSP setup", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
@@ -781,13 +949,15 @@
 	{ OFFS(bandwidth), "set bandwidth param for RTSP requests", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(default_port), "set default RTSP port", GF_PROP_UINT, "554", "0-65535", 0},
 	{ OFFS(satip_port), "set default port for SATIP", GF_PROP_UINT, "1400", "0-65535", 0},
-	{ OFFS(interleave), "set RTP over RTSP", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(transport), "set RTP over RTSP\n"
+		"- auto: set interleave on if HTTP tunnel is used, off otherwise and retry in interleaved mode if UDP timeout\n"
+		"- tcp: enable RTP over RTSP\n"
+		"- udp: disable RTP over RTSP", GF_PROP_UINT, "auto", "auto|tcp|udp", GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(udp_timeout), "default timeout before considering UDP is down", GF_PROP_UINT, "10000", NULL, 0},
-	{ OFFS(rtsp_timeout), "default timeout before considering RTSP is down", GF_PROP_UINT, "3000", NULL, 0},
 	{ OFFS(rtcp_timeout), "default timeout for RTCP traffic in ms. After this timeout, playback will start out of sync. If 0 always wait for RTCP", GF_PROP_UINT, "5000", NULL, GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(autortsp), "automatically reconfig RTSP interleaving if UDP timeout", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(first_packet_drop), "set number of first RTP packet to drop (0 if no drop)", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_EXPERT},
-	{ OFFS(frequency_drop), "drop 1 out of N packet (0 disable dropping)", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(first_packet_drop), "set number of first RTP packet to drop (0 if no drop)", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+	{ OFFS(frequency_drop), "drop 1 out of N packet (0 disable dropping)", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
+	{ OFFS(loss_rate), "loss rate to signal in RTCP, -1 means real loss rate, otherwise a per-thousand of packet lost", GF_PROP_SINT, "-1", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
 	{ OFFS(user_agent), "user agent string, by default solved from GPAC preferences", GF_PROP_STRING, "$GUA", NULL, 0},
 	{ OFFS(languages), "user languages, by default solved from GPAC preferences", GF_PROP_STRING, "$GLANG", NULL, 0},
 	{ OFFS(stats), "update statistics to the user every given MS (0 disables reporting)", GF_PROP_UINT, "500", NULL, GF_FS_ARG_HINT_ADVANCED},
@@ -796,6 +966,8 @@
 	"- a positive value `N` means to sleep at most `N` ms but will sleep less if frame duration is shorter", GF_PROP_SINT, "1000", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(rtcpsync), "use RTCP to adjust synchronization", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(forceagg), "force RTSP control aggregation (patch for buggy servers)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(ssm), "list of IP to include for source-specific multicast", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(ssmx), "list of IP to exclude for source-specific multicast", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -808,7 +980,15 @@
 	"- RTP direct url through `rtp://` protocol scheme\n"
 	"- RTSP session processing through `rtsp://` and `satip://` protocol schemes\n"
 	" \n"
-	"The filter produces either PIDs with media frames, or file PIDs with multiplexed data (e.g. MPEG-2 TS).")
+	"The filter produces either PIDs with media frames, or file PIDs with multiplexed data (e.g. MPEG-2 TS)."
+	" \n"
+	"The filter will use:\n"
+	"- RTSP over HTTP tunnel if server port is 80 or 8080 or if protocol scheme is `rtsph://`.\n"
+	"- RTSP over TLS if server port is 322 or if protocol scheme is `rtsps://`.\n"
+	"- RTSP over HTTPS tunnel if server port is 443 and if protocol scheme is `rtsph://`.\n"
+	" \n"
+	"The filter will attempt reconnecting in TLS mode after two consecutive initial connection failures.\n"
+	)
 	.private_size = sizeof(GF_RTPIn),
 	.args = RTPInArgs,
 	.initialize = rtpin_initialize,
@@ -827,6 +1007,9 @@
 const GF_FilterRegister *rtpin_register(GF_FilterSession *session)
 {
 #ifndef GPAC_DISABLE_STREAMING
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_in_proto", RTPInRegister.name, "rtp,rtsp,rtspu,rtsph,satip,rtsps");
+	}
 	return &RTPInRegister;
 #else
 	return NULL;

gpac-2.0.0.tar.gz/src/filters/in_rtp.h -> gpac-2.2.0.tar.gz/src/filters/in_rtp.h Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2017
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / RTP/RTSP input filter
@@ -36,12 +36,28 @@
 /*IETF lib*/
 #include <gpac/internal/ietf_dev.h>
 
+#include <gpac/download.h>
 
 #define RTSP_BUFFER_SIZE		5000
 
 typedef struct _rtsp_session GF_RTPInRTSP;
 typedef struct __rtpin_stream GF_RTPInStream;
 
+enum
+{
+	RTP_TRANSPORT_AUTO=0,
+	RTP_TRANSPORT_TCP_ONLY,
+	RTP_TRANSPORT_UDP_ONLY,
+};
+
+enum
+{
+	RETRY_RTSP_NONE=0,
+	RETRY_RTSP_NORMAL,
+	RETRY_RTSP_FORCE_TCP,
+	RETRY_RTSP_PENDING = 1<<8,
+};
+
 /*the rtsp/rtp client*/
 typedef struct
 {
@@ -53,12 +69,13 @@
 	u32 bandwidth, reorder_len, reorder_delay, nat_keepalive, block_size;
 	Bool disable_rtcp;
 	u32 default_port;
-	u32 rtsp_timeout, udp_timeout, rtcp_timeout, stats;
+	u32 udp_timeout, rtcp_timeout, stats;
 	Bool forceagg;
 	/*transport mode. 0 is udp, 1 is tcp, 3 is tcp if unreliable media */
-	u32 interleave;
-	s32 max_sleep;
-	Bool autortsp, rtcpsync;
+	u32 transport;
+	s32 max_sleep, loss_rate;
+	Bool rtcpsync;
+	GF_PropStringList ssm, ssmx;
 
 	//internal
 
@@ -94,7 +111,8 @@
 
 	Double last_ntp;
 
-	Bool is_scalable, done, retry_tcp;
+	Bool is_scalable, done;
+	u32 retry_rtsp;
 
 	Double last_start_range;
 
@@ -105,6 +123,15 @@
 	GF_SockGroup *sockgroup;
 	Bool is_eos;
 	u32 eos_probe_start;
+	u32 nb_bytes_rcv;
+
+	GF_DownloadManager *dm;
+	char *auth_string;
+	//for async user pass
+	u32 check_creds;
+	GF_UserCredentials *creds;
+	GF_Err notif_error;
+	struct __rtpin_stream *auth_stream;
 } GF_RTPIn;
 
 enum
@@ -155,6 +182,8 @@
 
 void rtpin_rtsp_process_commands(GF_RTPInRTSP *sess);
 
+void rtpin_do_authenticate(GF_RTPIn *ctx);
+
 /*RTP channel state*/
 enum
 {
@@ -199,6 +228,8 @@
 	/*EOS signaled (RTCP or range-based)*/
 	RTP_EOS = (1<<6),
 	RTP_EOS_FLUSHED = (1<<7),
+
+	RTP_AUTH_RESETUP = (1<<8),
 };
 
 enum
@@ -231,7 +262,7 @@
 	GF_FilterPid *opid;
 
 	u32 status;
-
+	u32 ts_offset;
 	u32 last_stats_time;
 	
 	u32 ES_ID, OD_ID;
@@ -269,13 +300,16 @@
 	u32 rtcp_check_start;
 	u32 first_rtp_ts;
 	s64 ts_adjust;
-	//source NTP of first packet received, ercomputed at first RTCP sender report
+	//source NTP of first packet received, recomputed at first RTCP sender report
 	u64 init_ntp_us;
 
 	u32 min_dur_us, min_dur_rtp;
 	u32 prev_cts;
 
 	u32 sr, nb_ch;
+	Bool map_utc, map_media_time;
+
+	GF_Err last_err;
 };
 
 /*creates new RTP stream from SDP info*/
@@ -353,6 +387,12 @@
 
 void rtpin_satip_get_server_ip(const char *sURL, char *Server);
 
+#ifdef GPAC_HAS_SSL
+void *gf_dm_ssl_init(GF_DownloadManager *dm, u32 mode);
+GF_Err gf_rtsp_set_ssl_ctx(GF_RTSPSession *sess, void *ssl_CTX);
+Bool gf_rtsp_session_needs_ssl(GF_RTSPSession *sess);
+#endif
+
 #endif /*GPAC_DISABLE_STREAMING*/
 
 #endif //_IN_RTP_H_

gpac-2.0.0.tar.gz/src/filters/in_rtp_rtsp.c -> gpac-2.2.0.tar.gz/src/filters/in_rtp_rtsp.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2017
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / RTP/RTSP input filter
@@ -59,7 +59,7 @@
 	/*handle response or announce*/
 	if ( (com && (sess->flags & RTSP_WAIT_REPLY) ) /*|| (!com && sess->rtpin->handle_announce)*/) {
 		e = gf_rtsp_get_response(sess->session, sess->rtsp_rsp);
-		if (e!= GF_IP_NETWORK_EMPTY) {
+		if ((e!= GF_IP_NETWORK_EMPTY) && (e!= GF_IP_CONNECTION_CLOSED)) {
 			e = rtpin_rtsp_process_response(sess, com, e);
 			/*this is a service connect error -> plugin may be discarded */
 			if (e!=GF_OK) {
@@ -74,7 +74,9 @@
 			sess->flags &= ~RTSP_WAIT_REPLY;
 			sess->command_time = 0;
 		} else {
-			u32 time_out = sess->rtpin->rtsp_timeout;
+			u32 time_out = gf_opts_get_int("core", "req-timeout");
+			if (!time_out) time_out = 10000;
+
 			/*evaluate timeout*/
 			time = gf_sys_clock() - sess->command_time;
 
@@ -99,6 +101,19 @@
 				sess->command_time = 0;
 				gf_rtsp_reset_aggregation(sess->session);
 			}
+			//resend
+			else if (e == GF_IP_CONNECTION_CLOSED) {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTSP Connection lost, resending last command\n"));
+				com->is_resend = GF_TRUE;
+				sess->flags &= ~RTSP_WAIT_REPLY;
+
+#ifdef GPAC_HAS_SSL
+				if (gf_rtsp_session_needs_ssl(sess->session) ) {
+					gf_rtsp_set_ssl_ctx(sess->session, gf_dm_ssl_init(sess->rtpin->dm, 0) );
+				}
+#endif
+				return;
+			}
 		}
 		return;
 	}
@@ -122,6 +137,8 @@
 	if (!com->User_Agent) com->User_Agent = (char *) sess->rtpin->user_agent;
 	com->Accept_Language = (char *) sess->rtpin->languages;
 
+	com->Authorization = sess->rtpin->auth_string;
+
 	/*if no session assigned but session-level ID was required, use it*/
 	if (!com->Session && com->user_flags) {
 		com->Session = sess->session_id;
@@ -135,6 +152,7 @@
 			goto exit;
 		}
 	}
+
 	/*preprocess play/stop/pause before sending (aggregation)*/
 	if (!strcmp(com->method, GF_RTSP_PLAY)
 	        || !strcmp(com->method, GF_RTSP_PAUSE)
@@ -144,11 +162,21 @@
 			e = GF_BAD_PARAM;
 			goto exit;
 		}
+		//session was destroyed, skip command
+		if (com->Session && !sess->session_id) {
+			e = GF_BAD_PARAM;
+			goto exit;
+		}
 	}
 	e = gf_rtsp_send_command(sess->session, com);
 	if (e) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSPIn Cannot send %s\n", com->method ));
-		rtpin_rtsp_process_response(sess, com, e);
+		if (e==GF_IP_CONNECTION_CLOSED) {
+			e = GF_OK;
+			com->is_resend = GF_TRUE;
+		} else {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSPIn Cannot send %s: %s\n", com->method, gf_error_to_string(e) ));
+			rtpin_rtsp_process_response(sess, com, e);
+		}
 	} else {
 		sess->command_time = gf_sys_clock();
 		sess->flags |= RTSP_WAIT_REPLY;
@@ -159,6 +187,8 @@
 	com->User_Agent = NULL;
 	com->Accept_Language = NULL;
 	com->Session = NULL;
+	com->Authorization = NULL;
+
 	/*remove command*/
 	if (e) {
 		gf_list_rem(sess->rtsp_commands, 0);
@@ -233,7 +263,7 @@
 	tmp->rtpin = rtp;
 	tmp->session = rtsp;
 
-	if (rtp->interleave) {
+	if (rtp->transport==RTP_TRANSPORT_TCP_ONLY) {
 		gf_rtsp_set_buffer_size(rtsp, rtp->block_size);
 	} else {
 		gf_rtsp_set_buffer_size(rtsp, RTSP_BUFFER_SIZE);
@@ -268,7 +298,12 @@
 	/*setup through SDP with control - assume this is RTSP and try to create a session*/
 	if (stream->control) {
 		/*stream control is relative to main session*/
-		if (strnicmp(stream->control, "rtsp://", 7) && strnicmp(stream->control, "rtspu://", 8) && strnicmp(stream->control, "satip://", 8)) {
+		if (strnicmp(stream->control, "rtsp://", 7)
+			&& strnicmp(stream->control, "rtspu://", 8)
+			&& strnicmp(stream->control, "rtsps://", 8)
+			&& strnicmp(stream->control, "rtsph://", 8)
+			&& strnicmp(stream->control, "satip://", 8)
+		) {
 			/*locate session by control - if no control was provided for the session, use default
 			session*/
 			if (!in_session) in_session = rtpin_rtsp_check(rtp, session_control ? session_control : "*");
@@ -348,7 +383,8 @@
 		//first = 0;
 	}
 	/*reset session state*/
-	gf_rtsp_session_reset(sess->session, GF_TRUE);
+	if (sess->session)
+		gf_rtsp_session_reset(sess->session, GF_TRUE);
 	sess->flags &= ~RTSP_WAIT_REPLY;
 }

gpac-2.0.0.tar.gz/src/filters/in_rtp_sdp.c -> gpac-2.2.0.tar.gz/src/filters/in_rtp_sdp.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2020
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / RTP/RTSP input filter
@@ -95,20 +95,9 @@
 
 		/*force interleaving whenever needed*/
 		if (stream->rtsp) {
-			switch (stream->depacketizer->sl_map.StreamType) {
-			case GF_STREAM_VISUAL:
-			case GF_STREAM_AUDIO:
-				if ((rtp->interleave==1) && ! (stream->rtsp->flags & RTSP_FORCE_INTER) ) {
-					gf_rtsp_set_buffer_size(stream->rtsp->session, stream->rtpin->block_size);
-					stream->rtsp->flags |= RTSP_FORCE_INTER;
-				}
-				break;
-			default:
-				if (rtp->interleave && ! (stream->rtsp->flags & RTSP_FORCE_INTER) ) {
-					gf_rtsp_set_buffer_size(stream->rtsp->session, stream->rtpin->block_size);
-					stream->rtsp->flags |= RTSP_FORCE_INTER;
-				}
-				break;
+			if ((rtp->transport==RTP_TRANSPORT_TCP_ONLY) && ! (stream->rtsp->flags & RTSP_FORCE_INTER) ) {
+				gf_rtsp_set_buffer_size(stream->rtsp->session, stream->rtpin->block_size);
+				stream->rtsp->flags |= RTSP_FORCE_INTER;
 			}
 		}
 
@@ -340,6 +329,9 @@
 
 	if (e == GF_OK) e = rtpin_setup_sdp(rtp, sdp, stream);
 
+	if (!gf_list_count(rtp->streams))
+		e = GF_NOT_SUPPORTED;
+
 	if (e != GF_OK) {
 		if (!stream) {
 			gf_filter_setup_failure(rtp->filter, e);

gpac-2.0.0.tar.gz/src/filters/in_rtp_signaling.c -> gpac-2.2.0.tar.gz/src/filters/in_rtp_signaling.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2017
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / RTP/RTSP input filter
@@ -63,7 +63,10 @@
 			com->user_flags = 1;
 		}
 	}
-	gf_list_add(sess->rtsp_commands, com);
+	if (stream && (stream->flags & RTP_AUTH_RESETUP))
+		gf_list_insert(sess->rtsp_commands, com, 0);
+	else
+		gf_list_add(sess->rtsp_commands, com);
 }
 
 
@@ -81,7 +84,7 @@
 	com->method = gf_strdup(GF_RTSP_SETUP);
 
 	//setup ports if unicast non interleaved or multicast
-	if (gf_rtp_is_unicast(stream->rtp_ch) && (stream->rtpin->interleave != 1) && !gf_rtp_is_interleaved(stream->rtp_ch) ) {
+	if (gf_rtp_is_unicast(stream->rtp_ch) && (stream->rtpin->transport != RTP_TRANSPORT_TCP_ONLY) && !gf_rtp_is_interleaved(stream->rtp_ch) ) {
 		gf_rtp_set_ports(stream->rtp_ch, stream->rtpin->firstport);
 	} else if (stream->rtpin->force_mcast) {
 		gf_rtp_set_ports(stream->rtp_ch, stream->rtpin->firstport);
@@ -130,7 +133,8 @@
 	through RTP/AVP/TCP profile so it's OK)*/
 //	trans->IsInterleaved = 0;
 	gf_list_add(com->Transports, trans);
-	if (strlen(stream->control)) com->ControlString = gf_strdup(stream->control);
+	if (strlen(stream->control))
+		com->ControlString = gf_strdup(stream->control);
 
 	com->user_data = stream;
 	stream->status = RTP_WaitingForAck;
@@ -190,6 +194,29 @@
 	case NC_RTSP_Not_Found:
 		e = GF_STREAM_NOT_FOUND;
 		goto exit;
+	case NC_RTSP_Unsupported_Transport:
+		if (stream && !stream->rtp_ch->net_info.IsInterleaved) {
+			if (!stream->rtpin->retry_rtsp) {
+				stream->rtpin->retry_rtsp = RETRY_RTSP_FORCE_TCP;
+				GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSP UDP transport not available, retrying with TCP\n"));
+			}
+			stream->status = RTP_Setup;
+		}
+		e = GF_STREAM_NOT_FOUND;
+		goto exit;
+	case NC_RTSP_Unauthorized:
+		e = GF_AUTHENTICATION_FAILURE;
+		if (!sess->rtpin->auth_string && sess->rtsp_rsp->WWW_Authenticate && strstr(sess->rtsp_rsp->WWW_Authenticate, "Basic")) {
+			stream->status = RTP_Setup;
+			sess->rtpin->auth_stream = stream;
+			rtpin_do_authenticate(sess->rtpin);
+			com->user_data = NULL;
+			return;
+		}
+		goto exit;
+	case NC_RTSP_Forbidden:
+		e = GF_URL_ERROR;
+		goto exit;
 	default:
 		e = GF_SERVICE_ERROR;
 		goto exit;
@@ -316,6 +343,16 @@
 		goto exit;
 	case NC_RTSP_OK:
 		break;
+	case NC_RTSP_Unauthorized:
+		if (sess->rtsp_rsp->WWW_Authenticate && strstr(sess->rtsp_rsp->WWW_Authenticate, "Basic"))
+			e = GF_AUTHENTICATION_FAILURE;
+		else
+			e = GF_URL_ERROR;
+		goto exit;
+	case NC_RTSP_Forbidden:
+		e = GF_URL_ERROR;
+		goto exit;
+
 	default:
 		//we should have a basic error code mapping here
 		e = GF_SERVICE_ERROR;
@@ -343,6 +380,10 @@
 	com->user_data = NULL;
 	if (e) {
 		if (!ch_desc) {
+			if (e==GF_AUTHENTICATION_FAILURE) {
+				rtpin_do_authenticate(sess->rtpin);
+				return GF_OK;
+			}
 			sess->connect_error = e;
 			return e;
 		} else if (stream) {
@@ -500,7 +541,7 @@
 	if (!com->Session) {
 		/*re-SETUP failed*/
 		if (!strcmp(com->method, GF_RTSP_PLAY) || !strcmp(com->method, GF_RTSP_PAUSE)) {
-			e = GF_SERVICE_ERROR;
+			e = stream->last_err ? stream->last_err : GF_SERVICE_ERROR;
 			goto err_exit;
 		}
 		/*this is a stop, no need for SessionID just skip*/
@@ -575,6 +616,15 @@
 		goto err_exit;
 	case NC_RTSP_OK:
 		break;
+
+	case NC_RTSP_Session_Not_Found:
+		if (!sess->rtpin->retry_rtsp) {
+			sess->rtpin->retry_rtsp = RETRY_RTSP_NORMAL;
+			gf_rtsp_session_reset(sess->session, GF_TRUE);
+		}
+		e = GF_OK;
+		goto err_exit;
+
 	default:
 		//we should have a basic error code mapping here
 		e = GF_SERVICE_ERROR;
@@ -594,6 +644,19 @@
 
 		//process all RTP infos
 		count = gf_list_count(sess->rtsp_rsp->RTP_Infos);
+
+		u32 rtp_t=0, rtp_ts=0;
+		for (i=0; i<count; i++) {
+			info = (GF_RTPInfo*)gf_list_get(sess->rtsp_rsp->RTP_Infos, i);
+			agg_st = rtpin_find_stream(sess->rtpin, NULL, 0, info->url, GF_FALSE);
+
+			if (!agg_st || (agg_st->rtsp != sess) ) continue;
+			if (!rtp_ts || gf_timestamp_less(info->rtp_time, agg_st->rtp_ch->TimeScale, rtp_t, rtp_ts)) {
+				rtp_ts = agg_st->rtp_ch->TimeScale;
+				rtp_t = info->rtp_time;
+			}
+		}
+
 		for (i=0; i<count; i++) {
 			info = (GF_RTPInfo*)gf_list_get(sess->rtsp_rsp->RTP_Infos, i);
 			agg_st = rtpin_find_stream(sess->rtpin, NULL, 0, info->url, GF_FALSE);
@@ -619,9 +682,13 @@
 
 			gf_rtp_set_info_rtp(agg_st->rtp_ch, info->seq, info->rtp_time, info->ssrc);
 			agg_st->status = RTP_Running;
+			agg_st->ts_offset = (u32) ( info->rtp_time - gf_timestamp_rescale(rtp_t, rtp_ts, agg_st->rtp_ch->TimeScale) );
+			if (sess->rtsp_rsp->Range)
+				agg_st->current_start = sess->rtsp_rsp->Range->start;
 
 			/*skip next play command on this channel if aggregated control*/
-			if ((stream != agg_st) && stream && (stream->rtsp->flags & RTSP_AGG_CONTROL) ) agg_st->flags |= RTP_SKIP_NEXT_COM;
+			if ((stream != agg_st) && stream && (stream->rtsp->flags & RTSP_AGG_CONTROL) )
+				agg_st->flags |= RTP_SKIP_NEXT_COM;
 
 
 			if (gf_rtp_is_interleaved(agg_st->rtp_ch)) {
@@ -632,7 +699,7 @@
 			}
 		}
 		/*no rtp info (just in case), no time mapped - set to 0 and specify we're not interactive*/
-		if (stream && !i) {
+		if (stream && !i && (ch_ctrl->evt.base.type==GF_FEVT_PLAY)) {
 			stream->current_start = 0.0;
 			stream->check_rtp_time = RTP_SET_TIME_RTP;
 			rtpin_stream_init(stream, GF_TRUE);
@@ -653,7 +720,7 @@
 		sess->rtpin->eos_probe_start = gf_sys_clock();
 
 		if (sess->flags & RTSP_AGG_CONTROL) {
-			u32 i, count = gf_list_count(sess->rtpin->streams);
+			count = gf_list_count(sess->rtpin->streams);
 			for (i=0; i<count; i++) {
 				stream = gf_list_get(sess->rtpin->streams, i);
 				if (stream->rtsp == sess)
@@ -675,7 +742,9 @@
 		gf_rtsp_reset_aggregation(stream->rtsp->session);
 		stream->check_rtp_time = RTP_SET_TIME_NONE;
 	}
-	GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSP Error processing user command %s\n", gf_error_to_string(e) ));
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSP Error processing user command %s\n", gf_error_to_string(e) ));
+	}
 	gf_free(ch_ctrl);
 	com->user_data = NULL;
 	if (sess->flags & RTSP_TCP_FLUSH) {
@@ -736,6 +805,7 @@
 		com->method = gf_strdup(GF_RTSP_PLAY);
 
 		stream->paused = GF_FALSE;
+		stream->last_udp_time = 0;
 
 		/*specify pause range on resume - this is not mandatory but most servers need it*/
 		if (evt->base.type == GF_FEVT_RESUME) {
@@ -767,22 +837,24 @@
 		- a range was given in initial describe
 		- the command is not a RESUME
 		*/
-		if (!(stream->flags & RTP_HAS_RANGE) && (evt->base.type != GF_FEVT_RESUME) ) {
+		if ((evt->base.type == GF_FEVT_RESUME) || !(stream->flags & RTP_HAS_RANGE)) {
 			gf_rtsp_range_del(range);
 			com->Range = NULL;
 		} else {
 			com->Range = range;
 		}
 
-		if (sess->flags & RTSP_AGG_CONTROL)
+		if (sess->flags & RTSP_AGG_CONTROL) {
 			rtpin_rtsp_skip_command(stream);
-		else if (stream->control && strlen(stream->control))
-			com->ControlString = gf_strdup(stream->control);
+		} else {
+			if (stream->control && strlen(stream->control))
+				com->ControlString = gf_strdup(stream->control);
 
-		if (rtpin_rtsp_is_active(stream)) {
-			if (!com->ControlString && stream->control) com->ControlString = gf_strdup(stream->control);
+			if (rtpin_rtsp_is_active(stream)) {
+				if (!com->ControlString && stream->control)
+					com->ControlString = gf_strdup(stream->control);
+			}
 		}
-
 	} else if (evt->base.type == GF_FEVT_PAUSE) {
 		com->method = gf_strdup(GF_RTSP_PAUSE);
 		if (stream) {
@@ -842,7 +914,8 @@
 			com->method = gf_strdup(GF_RTSP_PAUSE);
 			com->Range = range;
 			/*only pause the specified stream*/
-			if (stream->control) com->ControlString = gf_strdup(stream->control);
+			if (stream->control)
+				com->ControlString = gf_strdup(stream->control);
 		}
 	} else {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSP Unsupported command %s\n", gf_filter_event_name(evt->base.type) ));
@@ -873,6 +946,12 @@
 		if (sess->session_id) gf_free(sess->session_id);
 		sess->session_id = NULL;
 	}
+	//reset all pending commands
+	u32 i, count = gf_list_count(sess->rtsp_commands);
+	for (i=0; i<count; i++) {
+		GF_RTSPCommand *acom = gf_list_get(sess->rtsp_commands, i);
+		acom->Session = NULL;
+	}
 }
 
 void rtpin_rtsp_teardown(GF_RTPInRTSP *sess, GF_RTPInStream *stream)

gpac-2.0.0.tar.gz/src/filters/in_rtp_stream.c -> gpac-2.2.0.tar.gz/src/filters/in_rtp_stream.c Changed

@@ -34,7 +34,12 @@
 	clean up the command stack*/
 	if (!stream->opid) return;
 
-	if (e != GF_OK || !stream->rtp_ch) return;
+	if (e != GF_OK || !stream->rtp_ch) {
+		stream->last_err = e;
+		if (!stream->rtpin->notif_error) stream->rtpin->notif_error = e;
+		return;
+	}
+	stream->last_err = GF_OK;
 }
 
 GF_Err rtpin_stream_init(GF_RTPInStream *stream, Bool ResetOnly)
@@ -44,7 +49,7 @@
 	if (!ResetOnly) {
 		GF_Err e;
 		const char *ip_ifce = NULL;
-		if (!stream->rtpin->interleave) {
+		if (stream->rtpin->transport!=RTP_TRANSPORT_TCP_ONLY) {
 			ip_ifce = stream->rtpin->ifce;
 		}
 		if (stream->rtp_ch->rtp)
@@ -52,6 +57,8 @@
 		if (stream->rtp_ch->rtcp)
 			gf_sk_group_unregister(stream->rtpin->sockgroup, stream->rtp_ch->rtcp);
 
+		gf_rtp_set_ssm(stream->rtp_ch, (const char **) stream->rtpin->ssm.vals, stream->rtpin->ssm.nb_items, (const char **) stream->rtpin->ssmx.vals, stream->rtpin->ssmx.nb_items);
+
 		e = gf_rtp_initialize(stream->rtp_ch, stream->rtpin->block_size, GF_FALSE, 0, stream->rtpin->reorder_len, stream->rtpin->reorder_delay, (char *)ip_ifce);
 		if (e) return e;
 
@@ -102,7 +109,7 @@
 static void rtpin_stream_queue_pck(GF_RTPInStream *stream, GF_FilterPacket *pck, u64 cts)
 {
 	//get all packets in queue, dispatch all packets with a cts less than the cts of the packet being queued
-	//if this is teh first packet in the RTP packet
+	//if this is the first packet in the RTP packet
 	//This is only used for MPEG4, and we are sure we only have AU(n),AU(n+i).., AU(n+j), AU(n+k) ...
 	//with i,j,k >0
 	while (stream->first_in_rtp_pck) {
@@ -116,6 +123,11 @@
 	}
 	stream->first_in_rtp_pck = GF_FALSE;
 	gf_list_add(stream->pck_queue, pck);
+	//flush if too high, in case we had a msimatch filtering out packets from a previous PLAY or we have TS loop
+	while (gf_list_count(stream->pck_queue)>30) {
+		GF_FilterPacket *prev = gf_list_pop_front(stream->pck_queue);
+		gf_filter_pck_send(prev);
+	}
 }
 
 static void rtp_sl_packet_cbk(void *udta, u8 *payload, u32 size, GF_SLHeader *hdr, GF_Err e)
@@ -168,9 +180,9 @@
 	
 	memcpy(pck_data, payload, size);
 	if (hdr->decodingTimeStampFlag)
-		gf_filter_pck_set_dts(pck, hdr->decodingTimeStamp);
+		gf_filter_pck_set_dts(pck, hdr->decodingTimeStamp - stream->ts_offset);
 
-	gf_filter_pck_set_cts(pck, hdr->compositionTimeStamp);
+	gf_filter_pck_set_cts(pck, hdr->compositionTimeStamp - stream->ts_offset);
 
 	diff = (s64) hdr->compositionTimeStamp - (s64) stream->prev_cts;
 	if ((stream->rtpin->max_sleep>0) && stream->prev_cts && diff) {
@@ -202,6 +214,38 @@
 	}
 	gf_filter_pck_set_framing(pck, hdr->accessUnitStartFlag, hdr->accessUnitEndFlag);
 
+	if (stream->depacketizer && stream->depacketizer->sl_map.config_updated) {
+		stream->depacketizer->sl_map.config_updated = 0;
+		gf_filter_pid_set_property(stream->opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA(stream->depacketizer->sl_map.config, stream->depacketizer->sl_map.configSize) );
+	}
+	if (stream->map_utc) {
+		u64 utc_time = stream->rtp_ch->last_SR_NTP_sec;
+		utc_time <<= 32;
+		utc_time |= stream->rtp_ch->last_SR_NTP_frac;
+		utc_time = gf_net_ntp_to_utc(utc_time);
+
+		s64 ts_diff = (s64) cts;
+		ts_diff -= stream->rtp_ch->last_SR_rtp_time;
+		ts_diff = gf_timestamp_rescale_signed(ts_diff, stream->rtp_ch->TimeScale, 1000);
+		utc_time += ts_diff;
+		gf_filter_pck_set_property(pck, GF_PROP_PCK_UTC_TIME, & PROP_LONGUINT(utc_time) );
+		stream->map_utc = GF_FALSE;
+	}
+
+	if (stream->map_media_time) {
+		Double media_time = 0;
+		if (stream->rtsp) {
+			//gf_rtp_get_current_time is from init with rtsp rtp_info, so it matches current packet NPT time
+			media_time = stream->current_start + gf_rtp_get_current_time(stream->rtp_ch);
+		}
+		gf_filter_pck_set_property(pck, GF_PROP_PCK_MEDIA_TIME, &PROP_DOUBLE(media_time) );
+
+		GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTP Mapping RTP Time seq %d TS %d Media Time %g - rtp info seq %d TS %d\n",
+										 hdr->packetSequenceNumber, cts, media_time, stream->rtp_ch->rtp_first_SN, stream->rtp_ch->rtp_time
+										));
+		stream->map_media_time = GF_FALSE;
+	}
+
 	if (stream->rtp_ch->packet_loss)
 		gf_filter_pck_set_corrupted(pck, 1);
 
@@ -211,7 +255,7 @@
 #endif
 
 	if (stream->depacketizer->sl_map.IndexDeltaLength) {
-		rtpin_stream_queue_pck(stream, pck, hdr->compositionTimeStamp);
+		rtpin_stream_queue_pck(stream, pck, hdr->compositionTimeStamp+stream->ts_offset);
 	} else {
 		gf_filter_pck_send(pck);
 	}
@@ -469,15 +513,15 @@
 	Float bps;
 	if (!stream->rtp_ch) return;
 
-	gf_filter_pid_set_info_str(stream->opid, "nets:loss", &PROP_FLOAT( gf_rtp_get_loss(stream->rtp_ch) ) );
+	gf_filter_pid_set_info_str(stream->opid, "rtp:loss", &PROP_FLOAT( gf_rtp_get_loss(stream->rtp_ch) ) );
 	if (stream->rtsp && (stream->flags & RTP_INTERLEAVED)) {
-		gf_filter_pid_set_info_str(stream->opid, "nets:interleaved", &PROP_UINT( gf_rtsp_get_session_port(stream->rtsp->session) ) );
-		gf_filter_pid_set_info_str(stream->opid, "nets:rtpid", &PROP_UINT( gf_rtp_get_low_interleave_id(stream->rtp_ch) ) );
-		gf_filter_pid_set_info_str(stream->opid, "nets:rctpid", &PROP_UINT( gf_rtp_get_hight_interleave_id(stream->rtp_ch) ) );
+		gf_filter_pid_set_info_str(stream->opid, "rtp:interleaved", &PROP_UINT( gf_rtsp_get_session_port(stream->rtsp->session) ) );
+		gf_filter_pid_set_info_str(stream->opid, "rtp:rtpid", &PROP_UINT( gf_rtp_get_low_interleave_id(stream->rtp_ch) ) );
+		gf_filter_pid_set_info_str(stream->opid, "rtp:rctpid", &PROP_UINT( gf_rtp_get_hight_interleave_id(stream->rtp_ch) ) );
 
 	} else {
-		gf_filter_pid_set_info_str(stream->opid, "nets:rtpp", &PROP_UINT( stream->rtp_ch->net_info.client_port_first ) );
-		gf_filter_pid_set_info_str(stream->opid, "nets:rtcpp", &PROP_UINT( stream->rtp_ch->net_info.client_port_last ) );
+		gf_filter_pid_set_info_str(stream->opid, "rtp:rtpp", &PROP_UINT( stream->rtp_ch->net_info.client_port_first ) );
+		gf_filter_pid_set_info_str(stream->opid, "rtp:rtcpp", &PROP_UINT( stream->rtp_ch->net_info.client_port_last ) );
 	}
 	if (stream->stat_stop_time) {
 		time = stream->stat_stop_time - stream->stat_start_time;
@@ -489,17 +533,17 @@
 	bps = 8.0f * stream->rtp_bytes;
 	bps *= 1000;
 	bps /= time;
-	gf_filter_pid_set_info_str(stream->opid, "nets:bw_down", &PROP_UINT( (u32) bps ) );
+	gf_filter_pid_set_info_str(stream->opid, "rtp:bw_down", &PROP_UINT( (u32) bps ) );
 
 	bps = 8.0f * stream->rtcp_bytes;
 	bps *= 1000;
 	bps /= time;
-	gf_filter_pid_set_info_str(stream->opid, "nets:ctrl_bw_down", &PROP_UINT( (u32) bps ) );
+	gf_filter_pid_set_info_str(stream->opid, "rtp:ctrl_bw_down", &PROP_UINT( (u32) bps ) );
 
 	bps = 8.0f * gf_rtp_get_tcp_bytes_sent(stream->rtp_ch);
 	bps *= 1000;
 	bps /= time;
-	gf_filter_pid_set_info_str(stream->opid, "nets:ctrl_bw_up", &PROP_UINT( (u32) bps ) );
+	gf_filter_pid_set_info_str(stream->opid, "rtp:ctrl_bw_up", &PROP_UINT( (u32) bps ) );
 }
 
 
@@ -549,29 +593,23 @@
 
 		/*it may happen that we still receive packets from a previous "play" request. If this is the case,
 		filter until we reach the indicated rtptime*/
-		if (stream->rtp_ch->rtp_time
-		 && (stream->rtp_ch->rtp_first_SN > hdr.SequenceNumber)
-		 && (stream->rtp_ch->rtp_time > hdr.TimeStamp)
-		 ) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTP Rejecting too early packet (TS %d vs signaled rtp time %d - diff %d ms)\n",
+		if (stream->rtp_ch->rtp_time) {
+			s32 sn_diff = stream->rtp_ch->rtp_first_SN; sn_diff -= (s32) hdr.SequenceNumber;
+			s32 ts_diff = stream->rtp_ch->rtp_time; ts_diff -= (s32) hdr.TimeStamp;
+			if (sn_diff<0) sn_diff = -sn_diff;
+			if (ts_diff<0) ts_diff = -ts_diff;
+			if ((sn_diff > 100) || ((u32) ts_diff > stream->rtp_ch->TimeScale)) {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTP Rejecting too early packet (TS %d vs signaled rtp time %d - diff %d ms)\n",
 			 hdr.TimeStamp, stream->rtp_ch->rtp_time, ((hdr.TimeStamp - stream->rtp_ch->rtp_time)*1000) / stream->rtp_ch->TimeScale));
-			return;
+				return;
+			}
 		}
 
 		ch_time = gf_rtp_get_current_time(stream->rtp_ch);
 
 		/*this is the first packet on the channel (no PAUSE)*/
 		if (stream->check_rtp_time == RTP_SET_TIME_RTP) {
-			Double media_time = 0;
-			if (stream->rtsp) {
-				media_time = stream->current_start + ch_time;
-			}
-			gf_filter_pid_set_property_str(stream->opid, "time:timestamp", &PROP_LONGUINT(hdr.TimeStamp) );
-			gf_filter_pid_set_property_str(stream->opid, "time:media", &PROP_DOUBLE(media_time) );
-
-			GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTP Mapping RTP Time seq %d TS %d Media Time %g - rtp info seq %d TS %d\n",
-			 hdr.SequenceNumber, hdr.TimeStamp, stream->current_start + ch_time, stream->rtp_ch->rtp_first_SN, stream->rtp_ch->rtp_time
-			 ));
+			stream->map_media_time = GF_TRUE;
 
 			/*skip RTCP clock init when RTSP is used*/
 			if (stream->rtsp) stream->rtcp_init = GF_TRUE;
@@ -672,6 +710,9 @@
 		if (stream->rtpin->rtcpsync)
 			rtpin_adjust_sync(stream->rtpin);
 	}
+	if (has_sr && stream->opid && (stream->status==RTP_Running)) {
+		stream->map_utc = GF_TRUE;
+	}
 
 	if (e == GF_EOS) {
 		stream->flags |= RTP_EOS;
@@ -709,34 +750,50 @@
 		size = gf_rtp_read_rtp(stream->rtp_ch, stream->buffer, stream->rtpin->block_size);
 		if (size) {
 			tot_size += size;
-			stream->rtpin->udp_timeout = 0;
 			rtpin_stream_on_rtp_pck(stream, stream->buffer, size);
 		}
 	}
 
 	/*and send the report*/
-	if (tot_size && (stream->flags & RTP_ENABLE_RTCP))
-		gf_rtp_send_rtcp_report(stream->rtp_ch);
+	if (tot_size) {
+		if (stream->flags & RTP_ENABLE_RTCP) {
+			if (stream->rtpin->loss_rate>=0)
+				gf_rtp_set_loss_rate(stream->rtp_ch, (u32) stream->rtpin->loss_rate);
+			gf_rtp_send_rtcp_report(stream->rtp_ch);
+		}
+		stream->last_udp_time = 0;
+		return tot_size;
+	}
+	if (stream->paused) return 0;
 
 	/*detect timeout*/
 	if (stream->rtpin->udp_timeout) {
 		if (!stream->last_udp_time) {
 			stream->last_udp_time = gf_sys_clock();
-		} else if (stream->rtp_ch->net_info.IsUnicast) {
+		} else if (stream->rtp_bytes || !stream->rtp_ch->net_info.IsInterleaved) {
 			u32 diff = gf_sys_clock() - stream->last_udp_time;
 			if (diff >= stream->rtpin->udp_timeout) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTP UDP Timeout after %d ms on stream %d%s\n", diff, stream->ES_ID,
-					(stream->rtpin->session && stream->rtpin->autortsp) ? ", retrying using TCP" : ""));
-
-				if (stream->rtpin->autortsp && stream->rtpin->session && !stream->rtpin->retry_tcp) {
-					stream->rtpin->retry_tcp = GF_TRUE;
+				if (stream->rtp_bytes) {
+					if (! (stream->flags & RTP_EOS)) {
+						GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTP No packet received for %d ms on stream %d, assuming EOS\n", diff, stream->ES_ID));
+						stream->flags |= RTP_EOS;
+					}
 				} else {
-					gf_filter_pid_set_eos(stream->opid);
+					if (! (stream->flags & RTP_EOS) && !stream->rtpin->retry_rtsp) {
+						GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTP UDP Timeout after %d ms on stream %d%s\n", diff, stream->ES_ID,
+						(stream->rtpin->session && (stream->rtpin->transport==RTP_TRANSPORT_AUTO)) ? ", retrying using TCP" : ""));
+					}
+
+					if ((stream->rtpin->transport==RTP_TRANSPORT_AUTO) && stream->rtpin->session && !stream->rtpin->retry_rtsp) {
+						stream->rtpin->retry_rtsp = RETRY_RTSP_FORCE_TCP;
+					} else {
+						stream->flags |= RTP_EOS;
+					}
 				}
 			}
 		}
 	}
-	return tot_size;
+	return 0;
 }
 
 #endif /*GPAC_DISABLE_STREAMING*/

gpac-2.0.0.tar.gz/src/filters/in_sock.c -> gpac-2.2.0.tar.gz/src/filters/in_sock.c Changed

@@ -45,9 +45,9 @@
 	char addressGF_MAX_IP_NAME_LEN;
 
 	u64 start_time, last_stats_time;
+	u32 init_time;
 	u64 nb_bytes;
 	Bool done;
-
 } GF_SockInClient;
 
 typedef struct
@@ -65,16 +65,19 @@
 	u32 reorder_pck;
 	u32 reorder_delay;
 #endif
+	GF_PropStringList ssm, ssmx;
 
 	GF_SockInClient sock_c;
 	GF_List *clients;
 	Bool had_clients;
 	Bool is_udp;
+	Bool is_stop;
 
 	char *buffer;
 
 	GF_SockGroup *active_sockets;
-	u64 last_rcv_time;
+	u32 last_rcv_time;
+	u32 last_timeout_sec;
 } GF_SockInCtx;
 
 
@@ -117,7 +120,6 @@
 		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("SockIn Failed to open socket for %s\n", ctx->src));
 		return GF_IO_ERR;
 	}
-	gf_sk_group_register(ctx->active_sockets, ctx->sock_c.socket);
 
 	/*setup port and src*/
 	port = ctx->port;
@@ -129,9 +131,10 @@
 		str0 = 0;
 	}
 
+
 	/*do we have a source ?*/
 	if (gf_sk_is_multicast_address(url)) {
-		e = gf_sk_setup_multicast(ctx->sock_c.socket, url, port, 0, 0, ctx->ifce);
+		e = gf_sk_setup_multicast_ex(ctx->sock_c.socket, url, port, 0, 0, ctx->ifce, (const char **)ctx->ssm.vals, ctx->ssm.nb_items, (const char **)ctx->ssmx.vals, ctx->ssmx.nb_items);
 		ctx->listen = GF_FALSE;
 	} else if ((sock_type==GF_SOCK_TYPE_UDP) 
 #ifdef GPAC_HAS_SOCK_UN 
@@ -155,6 +158,9 @@
 		e = gf_sk_connect(ctx->sock_c.socket, url, port, NULL);
 	}
 
+	strcpy(ctx->sock_c.address, "unknown");
+	gf_sk_get_remote_address(ctx->sock_c.socket, ctx->sock_c.address);
+
 	if (str) str0 = ':';
 
 	if (e) {
@@ -163,6 +169,8 @@
 		return e;
 	}
 
+	gf_sk_group_register(ctx->active_sockets, ctx->sock_c.socket);
+
 	GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("SockIn opening %s%s\n", ctx->src, ctx->listen ? " in server mode" : ""));
 
 	if (ctx->block_size<2000)
@@ -176,6 +184,9 @@
 	gf_sk_set_buffer_size(ctx->sock_c.socket, 0, ctx->block_size);
 	gf_sk_set_block_mode(ctx->sock_c.socket, (!ctx->is_udp && ctx->block) ? GF_FALSE : GF_TRUE);
 
+	if (!ctx->is_udp)
+		gf_filter_set_blocking(filter, GF_TRUE);
+
 	ctx->buffer = gf_malloc(ctx->block_size + 1);
 	if (!ctx->buffer) return GF_OUT_OF_MEM;
 	//ext/mime given and not mpeg2, disable probe
@@ -186,6 +197,9 @@
 		ctx->clients = gf_list_new();
 		if (!ctx->clients) return GF_OUT_OF_MEM;
 	}
+
+	ctx->sock_c.init_time = gf_sys_clock();
+
 	return GF_OK;
 }
 
@@ -243,11 +257,14 @@
 static Bool sockin_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
 {
 	if (!evt->base.on_pid) return GF_FALSE;
+	GF_SockInCtx *ctx = (GF_SockInCtx *) gf_filter_get_udta(filter);
 
 	switch (evt->base.type) {
 	case GF_FEVT_PLAY:
+		ctx->is_stop = GF_FALSE;
 		return GF_TRUE;
 	case GF_FEVT_STOP:
+		ctx->is_stop = GF_TRUE;
 		return GF_TRUE;
 	default:
 		break;
@@ -273,7 +290,6 @@
 	}
 
 	if (!sock_c->start_time) sock_c->start_time = gf_sys_clock_high_res();
-
 	pos = 0;
 	nb_read=0;
 	while (pos < ctx->block_size) {
@@ -308,6 +324,11 @@
 		pos += read;
 	}
 	if (!nb_read) return GF_OK;
+
+	if (!sock_c->nb_bytes) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("SockIn Reception started after %u ms\n", gf_sys_clock() - sock_c->init_time));
+	}
+
 	sock_c->nb_bytes += nb_read;
 	sock_c->done = GF_FALSE;
 
@@ -399,24 +420,37 @@
 	return GF_OK;
 }
 
-static Bool sockin_check_eos(GF_SockInCtx *ctx)
+static GF_Err sockin_check_eos(GF_Filter *filter, GF_SockInCtx *ctx)
 {
-	u64 now;
-	if (!ctx->timeout) return GF_FALSE;
+	u32 now;
+	if (!ctx->timeout) return GF_OK;
 
-	now = gf_sys_clock_high_res();
+	now = gf_sys_clock();
 	if (!ctx->last_rcv_time) {
 		ctx->last_rcv_time = now;
-		return GF_FALSE;
+		return GF_OK;
 	}
-	if (now - ctx->last_rcv_time < ctx->timeout*1000) {
-		return GF_FALSE;
+	if (now - ctx->last_rcv_time < ctx->timeout) {
+		u32 tout = (ctx->timeout - (now - ctx->last_rcv_time)) / 1000;
+		if (tout != ctx->last_timeout_sec) {
+			ctx->last_timeout_sec = tout;
+			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("SockIn Waiting for %u seconds\r", tout));
+		}
+		return GF_OK;
 	}
-	if (ctx->sock_c.pid && !ctx->sock_c.done) {
-		gf_filter_pid_set_eos(ctx->sock_c.pid);
+	if (!ctx->sock_c.done) {
+		if (ctx->sock_c.pid)
+			gf_filter_pid_set_eos(ctx->sock_c.pid);
 		ctx->sock_c.done = GF_TRUE;
+		if (ctx->sock_c.nb_bytes) {
+			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("SockIn No data received for %d ms, assuming end of stream\n", ctx->timeout));
+		} else {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("SockIn No data received after %d ms, aborting\n", ctx->timeout));
+			gf_filter_setup_failure(filter, GF_IP_NETWORK_FAILURE);
+			return GF_IP_NETWORK_FAILURE;
+		}
 	}
-	return GF_TRUE;
+	return GF_EOS;
 }
 
 static GF_Err sockin_process(GF_Filter *filter)
@@ -426,11 +460,17 @@
 	u32 i, count;
 	GF_SockInCtx *ctx = (GF_SockInCtx *) gf_filter_get_udta(filter);
 
+	if (ctx->is_stop) return GF_EOS;
+
 	e = gf_sk_group_select(ctx->active_sockets, 1, GF_SK_SELECT_READ);
 	if (e==GF_IP_NETWORK_EMPTY) {
 		if (ctx->is_udp) {
-			if (sockin_check_eos(ctx) )
-				return GF_EOS;
+			e = sockin_check_eos(filter, ctx);
+			if (e) return e;
+			if (!ctx->sock_c.nb_bytes) {
+				gf_filter_ask_rt_reschedule(filter, 10000);
+				return GF_OK;
+			}
 		} else if (!gf_list_count(ctx->clients)) {
 			gf_filter_ask_rt_reschedule(filter, 1000);
 			return GF_OK;
@@ -467,6 +507,7 @@
 				gf_list_add(ctx->clients, sc);
 				ctx->had_clients = GF_TRUE;
 				gf_sk_group_register(ctx->active_sockets, sc->socket);
+				sc->init_time = gf_sys_clock();
 			}
 		}
 	}
@@ -537,6 +578,9 @@
 	{ OFFS(reorder_pck), "number of packets delay for RTP reordering (M2TS over RTP) ", GF_PROP_UINT, "100", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(reorder_delay), "number of ms delay for RTP reordering (M2TS over RTP)", GF_PROP_UINT, "10", NULL, GF_FS_ARG_HINT_ADVANCED},
 #endif
+
+	{ OFFS(ssm), "list of IP to include for source-specific multicast", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(ssmx), "list of IP to exclude for source-specific multicast", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -583,6 +627,13 @@
 
 const GF_FilterRegister *sockin_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+#ifdef GPAC_HAS_SOCK_UN
+		gf_opts_set_key("temp_in_proto", SockInRegister.name, "tcp,udp,tcpu,udpu");
+#else
+		gf_opts_set_key("temp_in_proto", SockInRegister.name, "tcp,udp");
+#endif
+	}
 	return &SockInRegister;
 }

gpac-2.0.0.tar.gz/src/filters/inspect.c -> gpac-2.2.0.tar.gz/src/filters/inspect.c Changed

@@ -65,9 +65,11 @@
 	u32 tmcd_flags;
 	u32 tmcd_fpt;
 
+	u32 opus_channel_count;
+
 	u32 csize;
 	Bool buffer_done, no_analysis;
-
+	u32 buf_start_time;
 	u64 last_pcr;
 	GF_FilterClockType last_clock_type;
 } PidCtx;
@@ -115,9 +117,10 @@
 	GF_Fraction dur;
 	Bool crc, dtype;
 	Bool fftmcd;
-	u32 buffer;
+	u32 buffer, mbuffer, rbuffer;
 
 	FILE *dump;
+	Bool dump_log;
 
 	GF_List *src_pids;
 
@@ -129,41 +132,59 @@
 
 GF_Err gf_bs_set_logger(GF_BitStream *bs, void (*on_bs_log)(void *udta, const char *field_name, u32 nb_bits, u64 field_val, s32 idx1, s32 idx2, s32 idx3), void *udta);
 
+static void inspect_printf(FILE *dump, const char *fmt, ...)
+{
+	va_list list;
+	if (dump == NULL) {
+#ifndef GPAC_DISABLE_LOG
+		if (gf_log_tool_level_on(GF_LOG_APP, GF_LOG_INFO) ) {
+			gf_log_lt(GF_LOG_INFO, GF_LOG_APP);
+			va_start(list, fmt);
+			gf_log_va_list(GF_LOG_INFO, GF_LOG_APP, fmt, list);
+			va_end(list);
+		}
+#endif
+	} else {
+		va_start(list, fmt);
+		gf_vfprintf(dump, fmt, list);
+		va_end(list);
+	}
+}
 
 #define DUMP_ATT_STR(_name, _val) if (ctx->xml) { \
-		gf_fprintf(dump, " %s=\"%s\"", _name, _val); \
+		inspect_printf(dump, " %s=\"%s\"", _name, _val); \
 	} else { \
-		gf_fprintf(dump, " %s %s", _name, _val); \
+		inspect_printf(dump, " %s %s", _name, _val); \
 	}
 
 #define DUMP_ATT_LLU(_name, _val) if (ctx->xml) { \
-		gf_fprintf(dump, " %s=\""LLU"\"", _name, _val);\
+		inspect_printf(dump, " %s=\""LLU"\"", _name, _val);\
 	} else {\
-		gf_fprintf(dump, " %s "LLU, _name, _val);\
+		inspect_printf(dump, " %s "LLU, _name, _val);\
 	}
 
 #define DUMP_ATT_U(_name, _val) if (ctx->xml) { \
-		gf_fprintf(dump, " %s=\"%u\"", _name, _val);\
+		inspect_printf(dump, " %s=\"%u\"", _name, _val);\
 	} else {\
-		gf_fprintf(dump, " %s %u", _name, _val);\
+		inspect_printf(dump, " %s %u", _name, _val);\
 	}
 
 #define DUMP_ATT_D(_name, _val) if (ctx->xml) { \
-		gf_fprintf(dump, " %s=\"%d\"", _name, _val);\
+		inspect_printf(dump, " %s=\"%d\"", _name, _val);\
 	} else {\
-		gf_fprintf(dump, " %s %d", _name, _val);\
+		inspect_printf(dump, " %s %d", _name, _val);\
 	}
 
 #define DUMP_ATT_X(_name, _val) if (ctx->xml) { \
-		gf_fprintf(dump, " %s=\"0x%08X\"", _name, _val);\
+		inspect_printf(dump, " %s=\"0x%08X\"", _name, _val);\
 	} else {\
-		gf_fprintf(dump, " %s 0x%08X", _name, _val);\
+		inspect_printf(dump, " %s 0x%08X", _name, _val);\
 	}
 
 #define DUMP_ATT_FRAC(_name, _val) if (ctx->xml) { \
-		gf_fprintf(dump, " %s=\"%d/%u\"", _name, _val.num, _val.den);\
+		inspect_printf(dump, " %s=\"%d/%u\"", _name, _val.num, _val.den);\
 	} else {\
-		gf_fprintf(dump, " %s %d/%u", _name, _val.num, _val.den);\
+		inspect_printf(dump, " %s %d/%u", _name, _val.num, _val.den);\
 	}
 
 
@@ -313,8 +334,8 @@
 	{GF_HEVC_NALU_SEI_SUFFIX, "SEI Suffix"},
 	{GF_HEVC_NALU_FF_AGGREGATOR, "HEVCAggregator"},
 	{GF_HEVC_NALU_FF_EXTRACTOR, "HEVCExtractor"},
-	{GF_HEVC_NALU_DV_RPU, "UNSPEC_DolbiVision_RPU"},
-	{GF_HEVC_NALU_DV_EL, "UNSPEC_DolbiVision_EL"}
+	{GF_HEVC_NALU_DV_RPU, "UNSPEC_DolbyVision_RPU"},
+	{GF_HEVC_NALU_DV_EL, "UNSPEC_DolbyVision_EL"}
 };
 
 static const char *get_hevc_nal_name(u32 nal_type)
@@ -337,6 +358,7 @@
 	{GF_VVC_NALU_SLICE_CRA, "CRA"},
 	{GF_VVC_NALU_SLICE_GDR, "GDR"},
 	{GF_VVC_NALU_OPI, "OperationPointInfo"},
+	{GF_VVC_NALU_DEC_PARAM, "DecoderParameterSet"},
 	{GF_VVC_NALU_VID_PARAM, "VideoParameterSet"},
 	{GF_VVC_NALU_SEQ_PARAM, "SequenceParameterSet"},
 	{GF_VVC_NALU_PIC_PARAM, "PictureParameterSet"},
@@ -408,24 +430,24 @@
 		return;
 
 	if (is_nalu)
-		gf_fprintf(cbk->dump, "\"");
+		inspect_printf(cbk->dump, "\"");
 
-	gf_fprintf(cbk->dump, " %s", field_name);
+	inspect_printf(cbk->dump, " %s", field_name);
 	if (idx1>=0) {
-		gf_fprintf(cbk->dump, "_%d", idx1);
+		inspect_printf(cbk->dump, "_%d", idx1);
 		if (idx2>=0) {
-			gf_fprintf(cbk->dump, "_%d", idx2);
+			inspect_printf(cbk->dump, "_%d", idx2);
 			if (idx3>=0) {
-				gf_fprintf(cbk->dump, "_%d", idx3);
+				inspect_printf(cbk->dump, "_%d", idx3);
 			}
 		}
 	}
-	gf_fprintf(cbk->dump, "=\""LLD, field_val);
+	inspect_printf(cbk->dump, "=\""LLD, field_val);
 	if (cbk->dump_bits && ((s32) nb_bits > 1) )
-		gf_fprintf(cbk->dump, "(%u)", nb_bits);
+		inspect_printf(cbk->dump, "(%u)", nb_bits);
 
 	if (!is_nalu)
-		gf_fprintf(cbk->dump, "\"");
+		inspect_printf(cbk->dump, "\"");
 }
 
 static void shifted_bs_log(void *udta, const char *field_name, u32 nb_bits, u64 field_val, s32 idx1, s32 idx2, s32 idx3)
@@ -441,7 +463,7 @@
 {
 	u16 max_content_light_level = gf_bs_read_int(bs, 16);
 	u16 max_pic_average_light_level = gf_bs_read_int(bs, 16);
-	gf_fprintf(dump, " max_content_light_level=\"%u\" max_pic_average_light_level=\"%u\"", max_content_light_level, max_pic_average_light_level);
+	inspect_printf(dump, " max_content_light_level=\"%u\" max_pic_average_light_level=\"%u\"", max_content_light_level, max_pic_average_light_level);
 }
 
 static void dump_mdcv(FILE *dump, GF_BitStream *bs, Bool isMPEG)
@@ -461,7 +483,7 @@
 	white_point_y = gf_bs_read_int(bs, 16);
 	max_display_mastering_luminance = gf_bs_read_int(bs, 32);
 	min_display_mastering_luminance = gf_bs_read_int(bs, 32);
-	gf_fprintf(dump, " display_primaries_x=\"%.04f %.04f %.04f\" display_primaries_y=\"%.04f %.04f %.04f\" white_point_x=\"%.04f\" white_point_y=\"%.04f\" max_display_mastering_luminance=\"%.04f\" min_display_mastering_luminance=\"%.04f\"",
+	inspect_printf(dump, " display_primaries_x=\"%.04f %.04f %.04f\" display_primaries_y=\"%.04f %.04f %.04f\" white_point_x=\"%.04f\" white_point_y=\"%.04f\" max_display_mastering_luminance=\"%.04f\" min_display_mastering_luminance=\"%.04f\"",
 			 display_primaries_x0*1.0/(isMPEG?50000:65536),
 			 display_primaries_x1*1.0/(isMPEG?50000:65536),
 			 display_primaries_x2*1.0/(isMPEG?50000:65536),
@@ -478,11 +500,11 @@
 {
 	u32 read_bytes = 1;
 	u32 country_code = gf_bs_read_u8(bs);
-	gf_fprintf(dump, " country_code=\"0x%x\"", country_code);
+	inspect_printf(dump, " country_code=\"0x%x\"", country_code);
 	if (country_code == 0xFF) {
 		u32 country_code_extension = gf_bs_read_u8(bs);
 		read_bytes++;
-		gf_fprintf(dump, " country_code_extension=\"0x%x\"", country_code_extension);
+		inspect_printf(dump, " country_code_extension=\"0x%x\"", country_code_extension);
 	}
 	if (country_code == 0xB5) { // USA
 		u32 terminal_provider_code = gf_bs_read_u16(bs);
@@ -490,7 +512,7 @@
 		u32 application_identifier = gf_bs_read_u8(bs);
 		u32 application_mode = gf_bs_read_u8(bs);
 		read_bytes+=6;
-		gf_fprintf(dump, " terminal_provider_code=\"0x%x\" terminal_provider_oriented_code=\"0x%x\" application_identifier=\"%u\" application_mode=\"%u\"",
+		inspect_printf(dump, " terminal_provider_code=\"0x%x\" terminal_provider_oriented_code=\"0x%x\" application_identifier=\"%u\" application_mode=\"%u\"",
 				 terminal_provider_code, terminal_provider_oriented_code,
 				 application_identifier, application_mode);
 	}
@@ -519,7 +541,7 @@
 		}
 		sei_size += gf_bs_read_int(bs, 8);
 
-		gf_fprintf(dump, " <SEIMessage ptype=\"%u\" psize=\"%u\" type=\"%s\"", sei_type, sei_size, get_sei_name(sei_type, is_hevc) );
+		inspect_printf(dump, " <SEIMessage ptype=\"%u\" psize=\"%u\" type=\"%s\"", sei_type, sei_size, get_sei_name(sei_type, is_hevc) );
 		if (sei_type == 144) {
 			dump_clli(dump, bs);
 		} else if (sei_type == 137) {
@@ -537,7 +559,7 @@
 				i++;
 			}
 		}
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 		if (gf_bs_peek_bits(bs, 8, 0) == 0x80) {
 			break;
 		}
@@ -566,17 +588,17 @@
 	}
 
 	if (!ptr_size) {
-		gf_fprintf(dump, "error=\"invalid nal size 0\"/>\n");
+		inspect_printf(dump, "error=\"invalid nal size 0\"/>\n");
 		return;
 	}
 
-	if (dump_crc) gf_fprintf(dump, "crc=\"%u\" ", gf_crc_32(ptr, ptr_size) );
+	if (dump_crc) inspect_printf(dump, "crc=\"%u\" ", gf_crc_32(ptr, ptr_size) );
 
 	if (hevc) {
 #ifndef GPAC_DISABLE_HEVC
 
 		if (ptr_size<=1) {
-			gf_fprintf(dump, "error=\"invalid nal size 1\"/>\n");
+			inspect_printf(dump, "error=\"invalid nal size 1\"/>\n");
 			return;
 		}
 
@@ -595,185 +617,185 @@
 		} else {
 			bs = NULL;
 			res = gf_hevc_parse_nalu(ptr, ptr_size, hevc, &type, &temporal_id, &quality_id);
-			gf_fprintf(dump, "code=\"%d\"", type);
+			inspect_printf(dump, "code=\"%d\"", type);
 		}
 
 		if (res==-1) {
-			gf_fprintf(dump, " status=\"error parsing\"", type);
+			inspect_printf(dump, " status=\"error parsing\"", type);
 		}
-		gf_fprintf(dump, " type=\"", type);
+		inspect_printf(dump, " type=\"", type);
 		nal_name = get_hevc_nal_name(type);
 		if (nal_name)
 			gf_fputs(nal_name, dump);
 		else
-			gf_fprintf(dump, "UNKNOWN (parsing return %d)", res);
+			inspect_printf(dump, "UNKNOWN (parsing return %d)", res);
 
 		//specific dump
 		switch (type) {
 		case GF_HEVC_NALU_VID_PARAM:
 			if (full_bs_dump) break;
 			idx = gf_hevc_read_vps(ptr, ptr_size, hevc);
-			if (idx<0) gf_fprintf(dump, "\" vps_id=\"PARSING FAILURE");
-			else gf_fprintf(dump, "\" vps_id=\"%d", idx);
+			if (idx<0) inspect_printf(dump, "\" vps_id=\"PARSING FAILURE");
+			else inspect_printf(dump, "\" vps_id=\"%d", idx);
 			break;
 		case GF_HEVC_NALU_SEQ_PARAM:
 			if (full_bs_dump) break;
 			idx = gf_hevc_read_sps(ptr, ptr_size, hevc);
 			if (idx<0) {
-				gf_fprintf(dump, "\" sps_id=\"PARSING FAILURE");
+				inspect_printf(dump, "\" sps_id=\"PARSING FAILURE");
 				break;
 			}
 			{
 			HEVC_SPS *sps= &hevc->spsidx;
-			gf_fprintf(dump, "\" sps_id=\"%d", idx);
+			inspect_printf(dump, "\" sps_id=\"%d", idx);
 
-			gf_fprintf(dump, "\" aspect_ratio_info_present_flag=\"%d", sps->aspect_ratio_info_present_flag);
-			gf_fprintf(dump, "\" bit_depth_chroma=\"%d", sps->bit_depth_chroma);
-			gf_fprintf(dump, "\" bit_depth_luma=\"%d", sps->bit_depth_luma);
-			gf_fprintf(dump, "\" chroma_format_idc=\"%d", sps->chroma_format_idc);
-			gf_fprintf(dump, "\" colour_description_present_flag=\"%d", sps->colour_description_present_flag);
-			gf_fprintf(dump, "\" colour_primaries=\"%d", sps->colour_primaries);
-			gf_fprintf(dump, "\" cw_flag=\"%d", sps->cw_flag);
+			inspect_printf(dump, "\" aspect_ratio_info_present_flag=\"%d", sps->aspect_ratio_info_present_flag);
+			inspect_printf(dump, "\" bit_depth_chroma=\"%d", sps->bit_depth_chroma);
+			inspect_printf(dump, "\" bit_depth_luma=\"%d", sps->bit_depth_luma);
+			inspect_printf(dump, "\" chroma_format_idc=\"%d", sps->chroma_format_idc);
+			inspect_printf(dump, "\" colour_description_present_flag=\"%d", sps->colour_description_present_flag);
+			inspect_printf(dump, "\" colour_primaries=\"%d", sps->colour_primaries);
+			inspect_printf(dump, "\" cw_flag=\"%d", sps->cw_flag);
 			if (sps->cw_flag) {
-				gf_fprintf(dump, "\" cw_bottom=\"%d", sps->cw_bottom);
-				gf_fprintf(dump, "\" cw_top=\"%d", sps->cw_top);
-				gf_fprintf(dump, "\" cw_left=\"%d", sps->cw_left);
-				gf_fprintf(dump, "\" cw_right=\"%d", sps->cw_right);
-			}
-			gf_fprintf(dump, "\" height=\"%d", sps->height);
-			gf_fprintf(dump, "\" width=\"%d", sps->width);
-			gf_fprintf(dump, "\" log2_max_pic_order_cnt_lsb=\"%d", sps->log2_max_pic_order_cnt_lsb);
-			gf_fprintf(dump, "\" long_term_ref_pics_present_flag=\"%d", sps->long_term_ref_pics_present_flag);
-			gf_fprintf(dump, "\" matrix_coeffs=\"%d", sps->matrix_coeffs);
-			gf_fprintf(dump, "\" max_CU_depth=\"%d", sps->max_CU_depth);
-			gf_fprintf(dump, "\" max_CU_width=\"%d", sps->max_CU_width);
-			gf_fprintf(dump, "\" max_CU_height=\"%d", sps->max_CU_height);
-			gf_fprintf(dump, "\" num_long_term_ref_pic_sps=\"%d", sps->num_long_term_ref_pic_sps);
-			gf_fprintf(dump, "\" num_short_term_ref_pic_sets=\"%d", sps->num_short_term_ref_pic_sets);
-			gf_fprintf(dump, "\" has_timing_info=\"%d", sps->has_timing_info);
+				inspect_printf(dump, "\" cw_bottom=\"%d", sps->cw_bottom);
+				inspect_printf(dump, "\" cw_top=\"%d", sps->cw_top);
+				inspect_printf(dump, "\" cw_left=\"%d", sps->cw_left);
+				inspect_printf(dump, "\" cw_right=\"%d", sps->cw_right);
+			}
+			inspect_printf(dump, "\" height=\"%d", sps->height);
+			inspect_printf(dump, "\" width=\"%d", sps->width);
+			inspect_printf(dump, "\" log2_max_pic_order_cnt_lsb=\"%d", sps->log2_max_pic_order_cnt_lsb);
+			inspect_printf(dump, "\" long_term_ref_pics_present_flag=\"%d", sps->long_term_ref_pics_present_flag);
+			inspect_printf(dump, "\" matrix_coeffs=\"%d", sps->matrix_coeffs);
+			inspect_printf(dump, "\" max_CU_depth=\"%d", sps->max_CU_depth);
+			inspect_printf(dump, "\" max_CU_width=\"%d", sps->max_CU_width);
+			inspect_printf(dump, "\" max_CU_height=\"%d", sps->max_CU_height);
+			inspect_printf(dump, "\" num_long_term_ref_pic_sps=\"%d", sps->num_long_term_ref_pic_sps);
+			inspect_printf(dump, "\" num_short_term_ref_pic_sets=\"%d", sps->num_short_term_ref_pic_sets);
+			inspect_printf(dump, "\" has_timing_info=\"%d", sps->has_timing_info);
 			if (sps->has_timing_info) {
-				gf_fprintf(dump, "\" time_scale=\"%d", sps->time_scale);
-				gf_fprintf(dump, "\" num_ticks_poc_diff_one_minus1=\"%d", sps->num_ticks_poc_diff_one_minus1);
-				gf_fprintf(dump, "\" num_units_in_tick=\"%d", sps->num_units_in_tick);
-				gf_fprintf(dump, "\" poc_proportional_to_timing_flag=\"%d", sps->poc_proportional_to_timing_flag);
-			}
-			gf_fprintf(dump, "\" rep_format_idx=\"%d", sps->rep_format_idx);
-			gf_fprintf(dump, "\" sample_adaptive_offset_enabled_flag=\"%d", sps->sample_adaptive_offset_enabled_flag);
-			gf_fprintf(dump, "\" sar_idc=\"%d", sps->sar_idc);
-			gf_fprintf(dump, "\" separate_colour_plane_flag=\"%d", sps->separate_colour_plane_flag);
-			gf_fprintf(dump, "\" temporal_mvp_enable_flag=\"%d", sps->temporal_mvp_enable_flag);
-			gf_fprintf(dump, "\" transfer_characteristic=\"%d", sps->transfer_characteristic);
-			gf_fprintf(dump, "\" video_full_range_flag=\"%d", sps->video_full_range_flag);
-			gf_fprintf(dump, "\" sps_ext_or_max_sub_layers_minus1=\"%d", sps->sps_ext_or_max_sub_layers_minus1);
-			gf_fprintf(dump, "\" max_sub_layers_minus1=\"%d", sps->max_sub_layers_minus1);
-			gf_fprintf(dump, "\" update_rep_format_flag=\"%d", sps->update_rep_format_flag);
-			gf_fprintf(dump, "\" sub_layer_ordering_info_present_flag=\"%d", sps->sub_layer_ordering_info_present_flag);
-			gf_fprintf(dump, "\" scaling_list_enable_flag=\"%d", sps->scaling_list_enable_flag);
-			gf_fprintf(dump, "\" infer_scaling_list_flag=\"%d", sps->infer_scaling_list_flag);
-			gf_fprintf(dump, "\" scaling_list_ref_layer_id=\"%d", sps->scaling_list_ref_layer_id);
-			gf_fprintf(dump, "\" scaling_list_data_present_flag=\"%d", sps->scaling_list_data_present_flag);
-			gf_fprintf(dump, "\" asymmetric_motion_partitions_enabled_flag=\"%d", sps->asymmetric_motion_partitions_enabled_flag);
-			gf_fprintf(dump, "\" pcm_enabled_flag=\"%d", sps->pcm_enabled_flag);
-			gf_fprintf(dump, "\" strong_intra_smoothing_enable_flag=\"%d", sps->strong_intra_smoothing_enable_flag);
-			gf_fprintf(dump, "\" vui_parameters_present_flag=\"%d", sps->vui_parameters_present_flag);
-			gf_fprintf(dump, "\" log2_diff_max_min_luma_coding_block_size=\"%d", sps->log2_diff_max_min_luma_coding_block_size);
-			gf_fprintf(dump, "\" log2_min_transform_block_size=\"%d", sps->log2_min_transform_block_size);
-			gf_fprintf(dump, "\" log2_min_luma_coding_block_size=\"%d", sps->log2_min_luma_coding_block_size);
-			gf_fprintf(dump, "\" log2_max_transform_block_size=\"%d", sps->log2_max_transform_block_size);
-			gf_fprintf(dump, "\" max_transform_hierarchy_depth_inter=\"%d", sps->max_transform_hierarchy_depth_inter);
-			gf_fprintf(dump, "\" max_transform_hierarchy_depth_intra=\"%d", sps->max_transform_hierarchy_depth_intra);
-			gf_fprintf(dump, "\" pcm_sample_bit_depth_luma_minus1=\"%d", sps->pcm_sample_bit_depth_luma_minus1);
-			gf_fprintf(dump, "\" pcm_sample_bit_depth_chroma_minus1=\"%d", sps->pcm_sample_bit_depth_chroma_minus1);
-			gf_fprintf(dump, "\" pcm_loop_filter_disable_flag=\"%d", sps->pcm_loop_filter_disable_flag);
-			gf_fprintf(dump, "\" log2_min_pcm_luma_coding_block_size_minus3=\"%d", sps->log2_min_pcm_luma_coding_block_size_minus3);
-			gf_fprintf(dump, "\" log2_diff_max_min_pcm_luma_coding_block_size=\"%d", sps->log2_diff_max_min_pcm_luma_coding_block_size);
-			gf_fprintf(dump, "\" overscan_info_present=\"%d", sps->overscan_info_present);
-			gf_fprintf(dump, "\" overscan_appropriate=\"%d", sps->overscan_appropriate);
-			gf_fprintf(dump, "\" video_signal_type_present_flag=\"%d", sps->video_signal_type_present_flag);
-			gf_fprintf(dump, "\" video_format=\"%d", sps->video_format);
-			gf_fprintf(dump, "\" chroma_loc_info_present_flag=\"%d", sps->chroma_loc_info_present_flag);
-			gf_fprintf(dump, "\" chroma_sample_loc_type_top_field=\"%d", sps->chroma_sample_loc_type_top_field);
-			gf_fprintf(dump, "\" chroma_sample_loc_type_bottom_field=\"%d", sps->chroma_sample_loc_type_bottom_field);
-			gf_fprintf(dump, "\" neutra_chroma_indication_flag=\"%d", sps->neutra_chroma_indication_flag);
-			gf_fprintf(dump, "\" field_seq_flag=\"%d", sps->field_seq_flag);
-			gf_fprintf(dump, "\" frame_field_info_present_flag=\"%d", sps->frame_field_info_present_flag);
-			gf_fprintf(dump, "\" default_display_window_flag=\"%d", sps->default_display_window_flag);
-			gf_fprintf(dump, "\" left_offset=\"%d", sps->left_offset);
-			gf_fprintf(dump, "\" right_offset=\"%d", sps->right_offset);
-			gf_fprintf(dump, "\" top_offset=\"%d", sps->top_offset);
-			gf_fprintf(dump, "\" bottom_offset=\"%d", sps->bottom_offset);
-			gf_fprintf(dump, "\" hrd_parameters_present_flag=\"%d", sps->hrd_parameters_present_flag);
+				inspect_printf(dump, "\" time_scale=\"%d", sps->time_scale);
+				inspect_printf(dump, "\" num_ticks_poc_diff_one_minus1=\"%d", sps->num_ticks_poc_diff_one_minus1);
+				inspect_printf(dump, "\" num_units_in_tick=\"%d", sps->num_units_in_tick);
+				inspect_printf(dump, "\" poc_proportional_to_timing_flag=\"%d", sps->poc_proportional_to_timing_flag);
+			}
+			inspect_printf(dump, "\" rep_format_idx=\"%d", sps->rep_format_idx);
+			inspect_printf(dump, "\" sample_adaptive_offset_enabled_flag=\"%d", sps->sample_adaptive_offset_enabled_flag);
+			inspect_printf(dump, "\" sar_idc=\"%d", sps->sar_idc);
+			inspect_printf(dump, "\" separate_colour_plane_flag=\"%d", sps->separate_colour_plane_flag);
+			inspect_printf(dump, "\" temporal_mvp_enable_flag=\"%d", sps->temporal_mvp_enable_flag);
+			inspect_printf(dump, "\" transfer_characteristic=\"%d", sps->transfer_characteristic);
+			inspect_printf(dump, "\" video_full_range_flag=\"%d", sps->video_full_range_flag);
+			inspect_printf(dump, "\" sps_ext_or_max_sub_layers_minus1=\"%d", sps->sps_ext_or_max_sub_layers_minus1);
+			inspect_printf(dump, "\" max_sub_layers_minus1=\"%d", sps->max_sub_layers_minus1);
+			inspect_printf(dump, "\" update_rep_format_flag=\"%d", sps->update_rep_format_flag);
+			inspect_printf(dump, "\" sub_layer_ordering_info_present_flag=\"%d", sps->sub_layer_ordering_info_present_flag);
+			inspect_printf(dump, "\" scaling_list_enable_flag=\"%d", sps->scaling_list_enable_flag);
+			inspect_printf(dump, "\" infer_scaling_list_flag=\"%d", sps->infer_scaling_list_flag);
+			inspect_printf(dump, "\" scaling_list_ref_layer_id=\"%d", sps->scaling_list_ref_layer_id);
+			inspect_printf(dump, "\" scaling_list_data_present_flag=\"%d", sps->scaling_list_data_present_flag);
+			inspect_printf(dump, "\" asymmetric_motion_partitions_enabled_flag=\"%d", sps->asymmetric_motion_partitions_enabled_flag);
+			inspect_printf(dump, "\" pcm_enabled_flag=\"%d", sps->pcm_enabled_flag);
+			inspect_printf(dump, "\" strong_intra_smoothing_enable_flag=\"%d", sps->strong_intra_smoothing_enable_flag);
+			inspect_printf(dump, "\" vui_parameters_present_flag=\"%d", sps->vui_parameters_present_flag);
+			inspect_printf(dump, "\" log2_diff_max_min_luma_coding_block_size=\"%d", sps->log2_diff_max_min_luma_coding_block_size);
+			inspect_printf(dump, "\" log2_min_transform_block_size=\"%d", sps->log2_min_transform_block_size);
+			inspect_printf(dump, "\" log2_min_luma_coding_block_size=\"%d", sps->log2_min_luma_coding_block_size);
+			inspect_printf(dump, "\" log2_max_transform_block_size=\"%d", sps->log2_max_transform_block_size);
+			inspect_printf(dump, "\" max_transform_hierarchy_depth_inter=\"%d", sps->max_transform_hierarchy_depth_inter);
+			inspect_printf(dump, "\" max_transform_hierarchy_depth_intra=\"%d", sps->max_transform_hierarchy_depth_intra);
+			inspect_printf(dump, "\" pcm_sample_bit_depth_luma_minus1=\"%d", sps->pcm_sample_bit_depth_luma_minus1);
+			inspect_printf(dump, "\" pcm_sample_bit_depth_chroma_minus1=\"%d", sps->pcm_sample_bit_depth_chroma_minus1);
+			inspect_printf(dump, "\" pcm_loop_filter_disable_flag=\"%d", sps->pcm_loop_filter_disable_flag);
+			inspect_printf(dump, "\" log2_min_pcm_luma_coding_block_size_minus3=\"%d", sps->log2_min_pcm_luma_coding_block_size_minus3);
+			inspect_printf(dump, "\" log2_diff_max_min_pcm_luma_coding_block_size=\"%d", sps->log2_diff_max_min_pcm_luma_coding_block_size);
+			inspect_printf(dump, "\" overscan_info_present=\"%d", sps->overscan_info_present);
+			inspect_printf(dump, "\" overscan_appropriate=\"%d", sps->overscan_appropriate);
+			inspect_printf(dump, "\" video_signal_type_present_flag=\"%d", sps->video_signal_type_present_flag);
+			inspect_printf(dump, "\" video_format=\"%d", sps->video_format);
+			inspect_printf(dump, "\" chroma_loc_info_present_flag=\"%d", sps->chroma_loc_info_present_flag);
+			inspect_printf(dump, "\" chroma_sample_loc_type_top_field=\"%d", sps->chroma_sample_loc_type_top_field);
+			inspect_printf(dump, "\" chroma_sample_loc_type_bottom_field=\"%d", sps->chroma_sample_loc_type_bottom_field);
+			inspect_printf(dump, "\" neutral_chroma_indication_flag=\"%d", sps->neutral_chroma_indication_flag);
+			inspect_printf(dump, "\" field_seq_flag=\"%d", sps->field_seq_flag);
+			inspect_printf(dump, "\" frame_field_info_present_flag=\"%d", sps->frame_field_info_present_flag);
+			inspect_printf(dump, "\" default_display_window_flag=\"%d", sps->default_display_window_flag);
+			inspect_printf(dump, "\" left_offset=\"%d", sps->left_offset);
+			inspect_printf(dump, "\" right_offset=\"%d", sps->right_offset);
+			inspect_printf(dump, "\" top_offset=\"%d", sps->top_offset);
+			inspect_printf(dump, "\" bottom_offset=\"%d", sps->bottom_offset);
+			inspect_printf(dump, "\" hrd_parameters_present_flag=\"%d", sps->hrd_parameters_present_flag);
 			}
 			break;
 		case GF_HEVC_NALU_PIC_PARAM:
 			if (full_bs_dump) break;
 			idx = gf_hevc_read_pps(ptr, ptr_size, hevc);
 			if (idx<0) {
-				gf_fprintf(dump, "\" pps_id=\"PARSING FAILURE");
+				inspect_printf(dump, "\" pps_id=\"PARSING FAILURE");
 				break;
 			}
 			{
 			HEVC_PPS *pps= &hevc->ppsidx;
-			gf_fprintf(dump, "\" pps_id=\"%d", idx);
+			inspect_printf(dump, "\" pps_id=\"%d", idx);
 
-			gf_fprintf(dump, "\" cabac_init_present_flag=\"%d", pps->cabac_init_present_flag);
-			gf_fprintf(dump, "\" dependent_slice_segments_enabled_flag=\"%d", pps->dependent_slice_segments_enabled_flag);
-			gf_fprintf(dump, "\" entropy_coding_sync_enabled_flag=\"%d", pps->entropy_coding_sync_enabled_flag);
-			gf_fprintf(dump, "\" lists_modification_present_flag=\"%d", pps->lists_modification_present_flag);
-			gf_fprintf(dump, "\" loop_filter_across_slices_enabled_flag=\"%d", pps->loop_filter_across_slices_enabled_flag);
-			gf_fprintf(dump, "\" loop_filter_across_tiles_enabled_flag=\"%d", pps->loop_filter_across_tiles_enabled_flag);
-			gf_fprintf(dump, "\" num_extra_slice_header_bits=\"%d", pps->num_extra_slice_header_bits);
-			gf_fprintf(dump, "\" num_ref_idx_l0_default_active=\"%d", pps->num_ref_idx_l0_default_active);
-			gf_fprintf(dump, "\" num_ref_idx_l1_default_active=\"%d", pps->num_ref_idx_l1_default_active);
-			gf_fprintf(dump, "\" tiles_enabled_flag=\"%d", pps->tiles_enabled_flag);
+			inspect_printf(dump, "\" cabac_init_present_flag=\"%d", pps->cabac_init_present_flag);
+			inspect_printf(dump, "\" dependent_slice_segments_enabled_flag=\"%d", pps->dependent_slice_segments_enabled_flag);
+			inspect_printf(dump, "\" entropy_coding_sync_enabled_flag=\"%d", pps->entropy_coding_sync_enabled_flag);
+			inspect_printf(dump, "\" lists_modification_present_flag=\"%d", pps->lists_modification_present_flag);
+			inspect_printf(dump, "\" loop_filter_across_slices_enabled_flag=\"%d", pps->loop_filter_across_slices_enabled_flag);
+			inspect_printf(dump, "\" loop_filter_across_tiles_enabled_flag=\"%d", pps->loop_filter_across_tiles_enabled_flag);
+			inspect_printf(dump, "\" num_extra_slice_header_bits=\"%d", pps->num_extra_slice_header_bits);
+			inspect_printf(dump, "\" num_ref_idx_l0_default_active=\"%d", pps->num_ref_idx_l0_default_active);
+			inspect_printf(dump, "\" num_ref_idx_l1_default_active=\"%d", pps->num_ref_idx_l1_default_active);
+			inspect_printf(dump, "\" tiles_enabled_flag=\"%d", pps->tiles_enabled_flag);
 			if (pps->tiles_enabled_flag) {
-				gf_fprintf(dump, "\" uniform_spacing_flag=\"%d", pps->uniform_spacing_flag);
+				inspect_printf(dump, "\" uniform_spacing_flag=\"%d", pps->uniform_spacing_flag);
 				if (!pps->uniform_spacing_flag) {
 					u32 k;
-					gf_fprintf(dump, "\" num_tile_columns=\"%d", pps->num_tile_columns);
-					gf_fprintf(dump, "\" num_tile_rows=\"%d", pps->num_tile_rows);
-					gf_fprintf(dump, "\" colomns_width=\"");
+					inspect_printf(dump, "\" num_tile_columns=\"%d", pps->num_tile_columns);
+					inspect_printf(dump, "\" num_tile_rows=\"%d", pps->num_tile_rows);
+					inspect_printf(dump, "\" colomns_width=\"");
 					for (k=0; k<pps->num_tile_columns-1; k++)
-						gf_fprintf(dump, "%d ", pps->column_widthk);
-					gf_fprintf(dump, "\" rows_height=\"");
+						inspect_printf(dump, "%d ", pps->column_widthk);
+					inspect_printf(dump, "\" rows_height=\"");
 					for (k=0; k<pps->num_tile_rows-1; k++)
-						gf_fprintf(dump, "%d ", pps->row_heightk);
+						inspect_printf(dump, "%d ", pps->row_heightk);
 				}
 			}
-			gf_fprintf(dump, "\" output_flag_present_flag=\"%d", pps->output_flag_present_flag);
-			gf_fprintf(dump, "\" pic_init_qp_minus26=\"%d", pps->pic_init_qp_minus26);
-			gf_fprintf(dump, "\" slice_chroma_qp_offsets_present_flag=\"%d", pps->slice_chroma_qp_offsets_present_flag);
-			gf_fprintf(dump, "\" slice_segment_header_extension_present_flag=\"%d", pps->slice_segment_header_extension_present_flag);
-			gf_fprintf(dump, "\" weighted_pred_flag=\"%d", pps->weighted_pred_flag);
-			gf_fprintf(dump, "\" weighted_bipred_flag=\"%d", pps->weighted_bipred_flag);
-
-			gf_fprintf(dump, "\" sign_data_hiding_flag=\"%d", pps->sign_data_hiding_flag);
-			gf_fprintf(dump, "\" constrained_intra_pred_flag=\"%d", pps->constrained_intra_pred_flag);
-			gf_fprintf(dump, "\" transform_skip_enabled_flag=\"%d", pps->transform_skip_enabled_flag);
-			gf_fprintf(dump, "\" cu_qp_delta_enabled_flag=\"%d", pps->cu_qp_delta_enabled_flag);
+			inspect_printf(dump, "\" output_flag_present_flag=\"%d", pps->output_flag_present_flag);
+			inspect_printf(dump, "\" pic_init_qp_minus26=\"%d", pps->pic_init_qp_minus26);
+			inspect_printf(dump, "\" slice_chroma_qp_offsets_present_flag=\"%d", pps->slice_chroma_qp_offsets_present_flag);
+			inspect_printf(dump, "\" slice_segment_header_extension_present_flag=\"%d", pps->slice_segment_header_extension_present_flag);
+			inspect_printf(dump, "\" weighted_pred_flag=\"%d", pps->weighted_pred_flag);
+			inspect_printf(dump, "\" weighted_bipred_flag=\"%d", pps->weighted_bipred_flag);
+
+			inspect_printf(dump, "\" sign_data_hiding_flag=\"%d", pps->sign_data_hiding_flag);
+			inspect_printf(dump, "\" constrained_intra_pred_flag=\"%d", pps->constrained_intra_pred_flag);
+			inspect_printf(dump, "\" transform_skip_enabled_flag=\"%d", pps->transform_skip_enabled_flag);
+			inspect_printf(dump, "\" cu_qp_delta_enabled_flag=\"%d", pps->cu_qp_delta_enabled_flag);
 			if (pps->cu_qp_delta_enabled_flag)
-				gf_fprintf(dump, "\" diff_cu_qp_delta_depth=\"%d", pps->diff_cu_qp_delta_depth);
-			gf_fprintf(dump, "\" transquant_bypass_enable_flag=\"%d", pps->transquant_bypass_enable_flag);
-			gf_fprintf(dump, "\" pic_cb_qp_offset=\"%d", pps->pic_cb_qp_offset);
-			gf_fprintf(dump, "\" pic_cr_qp_offset=\"%d", pps->pic_cr_qp_offset);
+				inspect_printf(dump, "\" diff_cu_qp_delta_depth=\"%d", pps->diff_cu_qp_delta_depth);
+			inspect_printf(dump, "\" transquant_bypass_enable_flag=\"%d", pps->transquant_bypass_enable_flag);
+			inspect_printf(dump, "\" pic_cb_qp_offset=\"%d", pps->pic_cb_qp_offset);
+			inspect_printf(dump, "\" pic_cr_qp_offset=\"%d", pps->pic_cr_qp_offset);
 
-			gf_fprintf(dump, "\" deblocking_filter_control_present_flag=\"%d", pps->deblocking_filter_control_present_flag);
+			inspect_printf(dump, "\" deblocking_filter_control_present_flag=\"%d", pps->deblocking_filter_control_present_flag);
 			if (pps->deblocking_filter_control_present_flag) {
-				gf_fprintf(dump, "\" deblocking_filter_override_enabled_flag=\"%d", pps->deblocking_filter_override_enabled_flag);
-				gf_fprintf(dump, "\" pic_disable_deblocking_filter_flag=\"%d", pps->pic_disable_deblocking_filter_flag);
-				gf_fprintf(dump, "\" beta_offset_div2=\"%d", pps->beta_offset_div2);
-				gf_fprintf(dump, "\" tc_offset_div2=\"%d", pps->tc_offset_div2);
+				inspect_printf(dump, "\" deblocking_filter_override_enabled_flag=\"%d", pps->deblocking_filter_override_enabled_flag);
+				inspect_printf(dump, "\" pic_disable_deblocking_filter_flag=\"%d", pps->pic_disable_deblocking_filter_flag);
+				inspect_printf(dump, "\" beta_offset_div2=\"%d", pps->beta_offset_div2);
+				inspect_printf(dump, "\" tc_offset_div2=\"%d", pps->tc_offset_div2);
 			}
-			gf_fprintf(dump, "\" pic_scaling_list_data_present_flag=\"%d", pps->pic_scaling_list_data_present_flag);
-			gf_fprintf(dump, "\" log2_parallel_merge_level_minus2=\"%d", pps->log2_parallel_merge_level_minus2);
+			inspect_printf(dump, "\" pic_scaling_list_data_present_flag=\"%d", pps->pic_scaling_list_data_present_flag);
+			inspect_printf(dump, "\" log2_parallel_merge_level_minus2=\"%d", pps->log2_parallel_merge_level_minus2);
 			}
 			break;
 		case GF_HEVC_NALU_ACCESS_UNIT:
 			if (ptr_size<3) {
-				gf_fprintf(dump, "\" status=\"CORRUPTED NAL");
+				inspect_printf(dump, "\" status=\"CORRUPTED NAL");
 				break;
 			}
-			gf_fprintf(dump, "\" primary_pic_type=\"%d", ptr2 >> 5);
+			inspect_printf(dump, "\" primary_pic_type=\"%d", ptr2 >> 5);
 			break;
 		//extractor
 		case GF_HEVC_NALU_FF_EXTRACTOR:
@@ -790,22 +812,22 @@
 				if (mode) {
 					u32 len = s0;
 					if (len+1>remain) {
-						gf_fprintf(dump, "error=\"invalid inband data extractor size: %d vs %d remaining\"/>\n", len, remain);
+						inspect_printf(dump, "error=\"invalid inband data extractor size: %d vs %d remaining\"/>\n", len, remain);
 						return;
 					}
 					remain -= len+1;
 					s += len+1;
-					gf_fprintf(dump, "\" inband_size=\"%d", len);
+					inspect_printf(dump, "\" inband_size=\"%d", len);
 				} else {
 					if (remain < 2 + 2*nalh_size) {
-						gf_fprintf(dump, "error=\"invalid ref data extractor size: %d vs %d remaining\"/>\n", 2 + 2*nalh_size, remain);
+						inspect_printf(dump, "error=\"invalid ref data extractor size: %d vs %d remaining\"/>\n", 2 + 2*nalh_size, remain);
 						return;
 					}
 					track_ref_index = (u8) s0;
 					sample_offset = (s8) s1;
 					data_offset = inspect_get_nal_size(&s2, nalh_size);
 					data_size = inspect_get_nal_size(&s2+nalh_size, nalh_size);
-					gf_fprintf(dump, "\" track_ref_index=\"%d\" sample_offset=\"%d\" data_offset=\"%d\" data_size=\"%d", track_ref_index, sample_offset, data_offset, data_size);
+					inspect_printf(dump, "\" track_ref_index=\"%d\" sample_offset=\"%d\" data_offset=\"%d\" data_size=\"%d", track_ref_index, sample_offset, data_offset, data_size);
 
 					remain -= 2 + 2*nalh_size;
 					s += 2 + 2*nalh_size;
@@ -819,19 +841,19 @@
 		gf_fputs("\"", dump);
 
 		if (!full_bs_dump && (type < GF_HEVC_NALU_VID_PARAM)) {
-			gf_fprintf(dump, " slice=\"%s\" poc=\"%d\"", (hevc->s_info.slice_type==GF_HEVC_SLICE_TYPE_I) ? "I" : (hevc->s_info.slice_type==GF_HEVC_SLICE_TYPE_P) ? "P" : (hevc->s_info.slice_type==GF_HEVC_SLICE_TYPE_B) ? "B" : "Unknown", hevc->s_info.poc);
-			gf_fprintf(dump, " first_slice_in_pic=\"%d\"", hevc->s_info.first_slice_segment_in_pic_flag);
-			gf_fprintf(dump, " dependent_slice_segment=\"%d\"", hevc->s_info.dependent_slice_segment_flag);
+			inspect_printf(dump, " slice=\"%s\" poc=\"%d\"", (hevc->s_info.slice_type==GF_HEVC_SLICE_TYPE_I) ? "I" : (hevc->s_info.slice_type==GF_HEVC_SLICE_TYPE_P) ? "P" : (hevc->s_info.slice_type==GF_HEVC_SLICE_TYPE_B) ? "B" : "Unknown", hevc->s_info.poc);
+			inspect_printf(dump, " first_slice_in_pic=\"%d\"", hevc->s_info.first_slice_segment_in_pic_flag);
+			inspect_printf(dump, " dependent_slice_segment=\"%d\"", hevc->s_info.dependent_slice_segment_flag);
 
 			if (!gf_sys_is_test_mode()) {
-				gf_fprintf(dump, " redundant_pic_cnt=\"%d\"", hevc->s_info.redundant_pic_cnt);
-				gf_fprintf(dump, " slice_qp_delta=\"%d\"", hevc->s_info.slice_qp_delta);
-				gf_fprintf(dump, " slice_segment_address=\"%d\"", hevc->s_info.slice_segment_address);
-				gf_fprintf(dump, " slice_type=\"%d\"", hevc->s_info.slice_type);
+				inspect_printf(dump, " redundant_pic_cnt=\"%d\"", hevc->s_info.redundant_pic_cnt);
+				inspect_printf(dump, " slice_qp_delta=\"%d\"", hevc->s_info.slice_qp_delta);
+				inspect_printf(dump, " slice_segment_address=\"%d\"", hevc->s_info.slice_segment_address);
+				inspect_printf(dump, " slice_type=\"%d\"", hevc->s_info.slice_type);
 			}
 		}
 		if (!full_bs_dump)
-			gf_fprintf(dump, " layer_id=\"%d\" temporal_id=\"%d\"", quality_id, temporal_id);
+			inspect_printf(dump, " layer_id=\"%d\" temporal_id=\"%d\"", quality_id, temporal_id);
 
 		if (bs) {
 			if (!pctx)
@@ -841,7 +863,7 @@
 		}
 
 		if ((type == GF_HEVC_NALU_SEI_PREFIX) || (type == GF_HEVC_NALU_SEI_SUFFIX)) {
-			gf_fprintf(dump, ">\n");
+			inspect_printf(dump, ">\n");
 			if (pctx) {
 				if (!pctx->bs)
 					pctx->bs = gf_bs_new(ptr, ptr_size, GF_BITSTREAM_READ);
@@ -853,13 +875,13 @@
 			}
 			dump_sei(dump, bs, GF_TRUE);
 			if (!pctx) gf_bs_del(bs);
-			gf_fprintf(dump, " </NALU>\n");
+			inspect_printf(dump, " </NALU>\n");
 		} else {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		}
 
 #else
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 #endif //GPAC_DISABLE_HEVC
 		return;
 	}
@@ -868,7 +890,7 @@
 		u8 lid, tid;
 
 		if (ptr_size<=1) {
-			gf_fprintf(dump, "error=\"invalid nal size 1\"/>\n");
+			inspect_printf(dump, "error=\"invalid nal size 1\"/>\n");
 			return;
 		}
 
@@ -893,25 +915,25 @@
 			lid = (ptr0 & 0x3F);
 			tid = (ptr1 & 0x7);
 			if (forb_zero || res_zero || !tid) {
-				gf_fprintf(dump, "error=\"invalid header (forb %d res_zero %d tid %d)\"/>\n", forb_zero, res_zero, tid);
+				inspect_printf(dump, "error=\"invalid header (forb %d res_zero %d tid %d)\"/>\n", forb_zero, res_zero, tid);
 				return;
 			}
 			tid -= 1;
 			type = ptr1>>3;
 
 			res = gf_vvc_parse_nalu(ptr, ptr_size, vvc, &type, &lid, &tid);
-			gf_fprintf(dump, "code=\"%d\" temporalid=\"%d\" layerid=\"%d\"", type, tid, lid);
+			inspect_printf(dump, "code=\"%d\" temporalid=\"%d\" layerid=\"%d\"", type, tid, lid);
 		}
 		if (res==-1) {
-			gf_fprintf(dump, " status=\"error parsing\"", type);
+			inspect_printf(dump, " status=\"error parsing\"", type);
 		}
 
-		gf_fprintf(dump, " type=\"");
+		inspect_printf(dump, " type=\"");
 		nal_name = get_vvc_nal_name(type);
 		if (nal_name)
-			gf_fprintf(dump, nal_name);
+			inspect_printf(dump, nal_name);
 		else {
-			gf_fprintf(dump, "Unknwon");
+			inspect_printf(dump, "unknown");
 			res = -2;
 		}
 		//specific dump
@@ -920,16 +942,16 @@
 			if ((res>=0) && !full_bs_dump) {
 				u32 j;
 				VVC_VPS *vps = &vvc->vpsvvc->last_parsed_vps_id;
-				gf_fprintf(dump, "\" id=\"%d\" num_ptl=\"%d\" max_layers=\"%d\" max_sublayers=\"%d", vps->id, vps->num_ptl, vps->max_layers, vps->max_sub_layers);
+				inspect_printf(dump, "\" id=\"%d\" num_ptl=\"%d\" max_layers=\"%d\" max_sublayers=\"%d", vps->id, vps->num_ptl, vps->max_layers, vps->max_sub_layers);
 				if (vps->max_layers>1) {
-					gf_fprintf(dump, "\" max_layer_id=\"%d\" all_layers_independent=\"%d\" each_layer_is_ols=\"%d", vps->max_layer_id, vps->all_layers_independent, vps->each_layer_is_ols);
+					inspect_printf(dump, "\" max_layer_id=\"%d\" all_layers_independent=\"%d\" each_layer_is_ols=\"%d", vps->max_layer_id, vps->all_layers_independent, vps->each_layer_is_ols);
 				}
 				for (j=0; j<vps->num_ptl; j++) {
 					VVC_ProfileTierLevel *ptl = &vps->ptlj;
-					gf_fprintf(dump, "\" general_level_idc=\"%d\" frame_only_constraint=\"%d\" multilayer_enabled=\"%d\" max_tid=\"%d", ptl->general_level_idc, ptl->frame_only_constraint, ptl->multilayer_enabled, ptl->ptl_max_tid);
+					inspect_printf(dump, "\" general_level_idc=\"%d\" frame_only_constraint=\"%d\" multilayer_enabled=\"%d\" max_tid=\"%d", ptl->general_level_idc, ptl->frame_only_constraint, ptl->multilayer_enabled, ptl->ptl_max_tid);
 
 					if (ptl->pt_present) {
-						gf_fprintf(dump, "\" general_profile_idc=\"%d\" general_tier_flag=\"%d\" gci_present=\"%d", ptl->general_profile_idc, ptl->general_tier_flag, ptl->gci_present);
+						inspect_printf(dump, "\" general_profile_idc=\"%d\" general_tier_flag=\"%d\" gci_present=\"%d", ptl->general_profile_idc, ptl->general_tier_flag, ptl->gci_present);
 					}
 				}
 			}
@@ -939,22 +961,22 @@
 			if ((res>=0) && !full_bs_dump) {
 				VVC_SPS *sps = &vvc->spsvvc->last_parsed_sps_id;
 
-				gf_fprintf(dump, "\" id=\"%d\" vps_id=\"%d\" max_sublayers=\"%d\" chroma_idc=\"%d\" bit_depth=\"%d\" CTBsizeY=\"%d\" gdr_enabled=\"%d\" ref_pic_sampling=\"%d\" subpic_info_present=\"%d\" poc_msb_cycle_flag=\"%d", sps->id, sps->vps_id, sps->max_sublayers, sps->chroma_format_idc, sps->bitdepth, 1<<sps->log2_ctu_size, sps->gdr_enabled, sps->ref_pic_resampling, sps->subpic_info_present, sps->poc_msb_cycle_flag);
+				inspect_printf(dump, "\" id=\"%d\" vps_id=\"%d\" max_sublayers=\"%d\" chroma_idc=\"%d\" bit_depth=\"%d\" CTBsizeY=\"%d\" gdr_enabled=\"%d\" ref_pic_sampling=\"%d\" subpic_info_present=\"%d\" poc_msb_cycle_flag=\"%d", sps->id, sps->vps_id, sps->max_sublayers, sps->chroma_format_idc, sps->bitdepth, 1<<sps->log2_ctu_size, sps->gdr_enabled, sps->ref_pic_resampling, sps->subpic_info_present, sps->poc_msb_cycle_flag);
 				if (sps->ref_pic_resampling) {
-					gf_fprintf(dump, "\" res_change_in_clvs=\"%d", sps->res_change_in_clvs);
+					inspect_printf(dump, "\" res_change_in_clvs=\"%d", sps->res_change_in_clvs);
 				}
-				gf_fprintf(dump, "\" width=\"%d\" height=\"%d", sps->width, sps->height);
+				inspect_printf(dump, "\" width=\"%d\" height=\"%d", sps->width, sps->height);
 				if (!sps->vps_id) {
 					VVC_ProfileTierLevel *ptl = &vvc->vps0.ptl0;
-					gf_fprintf(dump, "\" general_level_idc=\"%d\" frame_only_constraint=\"%d\" multilayer_enabled=\"%d\" max_tid=\"%d", ptl->general_level_idc, ptl->frame_only_constraint, ptl->multilayer_enabled, ptl->ptl_max_tid);
+					inspect_printf(dump, "\" general_level_idc=\"%d\" frame_only_constraint=\"%d\" multilayer_enabled=\"%d\" max_tid=\"%d", ptl->general_level_idc, ptl->frame_only_constraint, ptl->multilayer_enabled, ptl->ptl_max_tid);
 
 					if (ptl->pt_present) {
-						gf_fprintf(dump, "\" general_profile_idc=\"%d\" general_tier_flag=\"%d\" gci_present=\"%d", ptl->general_profile_idc, ptl->general_tier_flag, ptl->gci_present);
+						inspect_printf(dump, "\" general_profile_idc=\"%d\" general_tier_flag=\"%d\" gci_present=\"%d", ptl->general_profile_idc, ptl->general_tier_flag, ptl->gci_present);
 					}
 				}
-				gf_fprintf(dump, "\" conf_window=\"%d", sps->conf_window);
+				inspect_printf(dump, "\" conf_window=\"%d", sps->conf_window);
 				if (sps->conf_window) {
-					gf_fprintf(dump, "\" cw_left=\"%d\" cw_right=\"%d\" cw_top=\"%d\" cw_bottom=\"%d", sps->cw_left, sps->cw_right, sps->cw_top, sps->cw_bottom);
+					inspect_printf(dump, "\" cw_left=\"%d\" cw_right=\"%d\" cw_top=\"%d\" cw_bottom=\"%d", sps->cw_left, sps->cw_right, sps->cw_top, sps->cw_bottom);
 				}
 			}
 			res=-2;
@@ -962,38 +984,38 @@
 		case GF_VVC_NALU_PIC_PARAM:
 			if ((res>=0) && !full_bs_dump) {
 				VVC_PPS *pps = &vvc->ppsvvc->last_parsed_pps_id;
-				gf_fprintf(dump, "\" id=\"%d\" sps_id=\"%d\" width=\"%d\" height=\"%d\" mixed_nal_types=\"%d\" conf_window=\"%d", pps->id, pps->sps_id, pps->width, pps->height, pps->mixed_nal_types, pps->conf_window);
+				inspect_printf(dump, "\" id=\"%d\" sps_id=\"%d\" width=\"%d\" height=\"%d\" mixed_nal_types=\"%d\" conf_window=\"%d", pps->id, pps->sps_id, pps->width, pps->height, pps->mixed_nal_types, pps->conf_window);
 
 				if (pps->conf_window) {
-					gf_fprintf(dump, "\" cw_left=\"%d\" cw_right=\"%d\" cw_top=\"%d\" cw_bottom=\"%d", pps->cw_left, pps->cw_right, pps->cw_top, pps->cw_bottom);
+					inspect_printf(dump, "\" cw_left=\"%d\" cw_right=\"%d\" cw_top=\"%d\" cw_bottom=\"%d", pps->cw_left, pps->cw_right, pps->cw_top, pps->cw_bottom);
 				}
-				gf_fprintf(dump, "\" output_flag_present_flag=\"%d\" no_pic_partition_flag=\"%d\" subpic_id_mapping_present_flag=\"%d", pps->output_flag_present_flag, pps->no_pic_partition_flag, pps->subpic_id_mapping_present_flag);
+				inspect_printf(dump, "\" output_flag_present_flag=\"%d\" no_pic_partition_flag=\"%d\" subpic_id_mapping_present_flag=\"%d", pps->output_flag_present_flag, pps->no_pic_partition_flag, pps->subpic_id_mapping_present_flag);
 			}
 			res=-2;
 			break;
 		default:
 			break;
 		}
-		gf_fprintf(dump, "\"");
+		inspect_printf(dump, "\"");
 
 		//picture header or slice
 		if ((type!=GF_VVC_NALU_PIC_HEADER) && (type>GF_VVC_NALU_SLICE_GDR))
 			res = -2;
 		if ((res>=0) && !full_bs_dump) {
 			if (type!=GF_VVC_NALU_PIC_HEADER)
-				gf_fprintf(dump, " picture_header_in_slice_header_flag=\"%d\"", vvc->s_info.picture_header_in_slice_header_flag);
+				inspect_printf(dump, " picture_header_in_slice_header_flag=\"%d\"", vvc->s_info.picture_header_in_slice_header_flag);
 
 			if ((type==GF_VVC_NALU_PIC_HEADER) || vvc->s_info.picture_header_in_slice_header_flag) {
-				gf_fprintf(dump, " pps_id=\"%d\" poc=\"%d\" irap_or_gdr_pic=\"%d\" non_ref_pic=\"%d\" inter_slice_allowed_flag=\"%d\" poc_lsb=\"%d\"", vvc->s_info.pps->id, vvc->s_info.poc, vvc->s_info.irap_or_gdr_pic, vvc->s_info.non_ref_pic, vvc->s_info.inter_slice_allowed_flag, vvc->s_info.poc_lsb);
+				inspect_printf(dump, " pps_id=\"%d\" poc=\"%d\" irap_or_gdr_pic=\"%d\" non_ref_pic=\"%d\" inter_slice_allowed_flag=\"%d\" poc_lsb=\"%d\"", vvc->s_info.pps->id, vvc->s_info.poc, vvc->s_info.irap_or_gdr_pic, vvc->s_info.non_ref_pic, vvc->s_info.inter_slice_allowed_flag, vvc->s_info.poc_lsb);
 				if (vvc->s_info.irap_or_gdr_pic)
-					gf_fprintf(dump, " gdr_pic=\"%d\" gdr_recovery_count=\"%d\"", vvc->s_info.gdr_pic, vvc->s_info.gdr_recovery_count);
+					inspect_printf(dump, " gdr_pic=\"%d\" gdr_recovery_count=\"%d\"", vvc->s_info.gdr_pic, vvc->s_info.gdr_recovery_count);
 				if (vvc->s_info.inter_slice_allowed_flag)
-					gf_fprintf(dump, " intra_slice_allowed_flag=\"%d\"", vvc->s_info.intra_slice_allowed_flag);
+					inspect_printf(dump, " intra_slice_allowed_flag=\"%d\"", vvc->s_info.intra_slice_allowed_flag);
 				if (vvc->s_info.sps->poc_msb_cycle_flag && vvc->s_info.poc_msb_cycle_present_flag)
-					gf_fprintf(dump, " poc_msb_cycle=\"%d\"", vvc->s_info.poc_msb_cycle);
+					inspect_printf(dump, " poc_msb_cycle=\"%d\"", vvc->s_info.poc_msb_cycle);
 			}
 			if (type!=GF_VVC_NALU_PIC_HEADER)
-				gf_fprintf(dump, " slice_type=\"%d\"", vvc->s_info.slice_type);
+				inspect_printf(dump, " slice_type=\"%d\"", vvc->s_info.slice_type);
 		}
 
 		if (bs) {
@@ -1004,7 +1026,7 @@
 		}
 
 		if ((type == GF_VVC_NALU_SEI_PREFIX) || (type == GF_VVC_NALU_SEI_SUFFIX)) {
-			gf_fprintf(dump, ">\n");
+			inspect_printf(dump, ">\n");
 			if (pctx) {
 				if (!pctx->bs)
 					pctx->bs = gf_bs_new(ptr, ptr_size, GF_BITSTREAM_READ);
@@ -1016,32 +1038,32 @@
 			}
 			dump_sei(dump, bs, GF_TRUE);
 			if (!pctx) gf_bs_del(bs);
-			gf_fprintf(dump, " </NALU>\n");
+			inspect_printf(dump, " </NALU>\n");
 		} else {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		}
 		return;
 	}
 
 	//avc
 	if (!ptr_size) {
-		gf_fprintf(dump, "error=\"invalid nal size 1\"/>\n");
+		inspect_printf(dump, "error=\"invalid nal size 1\"/>\n");
 		return;
 	}
 	type = ptr0 & 0x1F;
 	nal_ref_idc = ptr0 & 0x60;
 	nal_ref_idc>>=5;
 	if (! full_bs_dump)
-		gf_fprintf(dump, "code=\"%d\" ", type);
+		inspect_printf(dump, "code=\"%d\" ", type);
 
-	gf_fprintf(dump, "type=\"");
+	inspect_printf(dump, "type=\"");
 	res = -2;
 	nal_name = get_avc_nal_name(type);
 	if (type == GF_AVC_NALU_SVC_SLICE) nal_name = is_svc ? "SVCSlice" : "CodedSliceExtension";
 	if (nal_name) {
 		gf_fputs(nal_name, dump);
 	} else {
-		gf_fputs("UNKNWON", dump);
+		gf_fputs("unknown", dump);
 	}
 
 	if (pctx) {
@@ -1071,119 +1093,119 @@
 		if (is_encrypted) break;
 		idx = gf_avc_read_sps_bs(bs, avc, 0, NULL);
 		if (idx<0) {
-			gf_fprintf(dump, "\" sps_id=\"PARSING FAILURE");
+			inspect_printf(dump, "\" sps_id=\"PARSING FAILURE");
 			break;
 		}
 		if (full_bs_dump) break;
-		gf_fprintf(dump, "\" sps_id=\"%d", idx);
-		gf_fprintf(dump, "\" frame_mbs_only_flag=\"%d", avc->sps->frame_mbs_only_flag);
-		gf_fprintf(dump, "\" mb_adaptive_frame_field_flag=\"%d", avc->sps->mb_adaptive_frame_field_flag);
-		gf_fprintf(dump, "\" vui_parameters_present_flag=\"%d", avc->sps->vui_parameters_present_flag);
-		gf_fprintf(dump, "\" max_num_ref_frames=\"%d", avc->sps->max_num_ref_frames);
-		gf_fprintf(dump, "\" gaps_in_frame_num_value_allowed_flag=\"%d", avc->sps->gaps_in_frame_num_value_allowed_flag);
-		gf_fprintf(dump, "\" chroma_format_idc=\"%d", avc->sps->chroma_format);
-		gf_fprintf(dump, "\" bit_depth_luma_minus8=\"%d", avc->sps->luma_bit_depth_m8);
-		gf_fprintf(dump, "\" bit_depth_chroma_minus8=\"%d", avc->sps->chroma_bit_depth_m8);
-		gf_fprintf(dump, "\" width=\"%d", avc->sps->width);
-		gf_fprintf(dump, "\" height=\"%d", avc->sps->height);
-		gf_fprintf(dump, "\" crop_top=\"%d", avc->sps->crop.top);
-		gf_fprintf(dump, "\" crop_left=\"%d", avc->sps->crop.left);
-		gf_fprintf(dump, "\" crop_bottom=\"%d", avc->sps->crop.bottom);
-		gf_fprintf(dump, "\" crop_right=\"%d", avc->sps->crop.right);
+		inspect_printf(dump, "\" sps_id=\"%d", idx);
+		inspect_printf(dump, "\" frame_mbs_only_flag=\"%d", avc->sps->frame_mbs_only_flag);
+		inspect_printf(dump, "\" mb_adaptive_frame_field_flag=\"%d", avc->sps->mb_adaptive_frame_field_flag);
+		inspect_printf(dump, "\" vui_parameters_present_flag=\"%d", avc->sps->vui_parameters_present_flag);
+		inspect_printf(dump, "\" max_num_ref_frames=\"%d", avc->sps->max_num_ref_frames);
+		inspect_printf(dump, "\" gaps_in_frame_num_value_allowed_flag=\"%d", avc->sps->gaps_in_frame_num_value_allowed_flag);
+		inspect_printf(dump, "\" chroma_format_idc=\"%d", avc->sps->chroma_format);
+		inspect_printf(dump, "\" bit_depth_luma_minus8=\"%d", avc->sps->luma_bit_depth_m8);
+		inspect_printf(dump, "\" bit_depth_chroma_minus8=\"%d", avc->sps->chroma_bit_depth_m8);
+		inspect_printf(dump, "\" width=\"%d", avc->sps->width);
+		inspect_printf(dump, "\" height=\"%d", avc->sps->height);
+		inspect_printf(dump, "\" crop_top=\"%d", avc->sps->crop.top);
+		inspect_printf(dump, "\" crop_left=\"%d", avc->sps->crop.left);
+		inspect_printf(dump, "\" crop_bottom=\"%d", avc->sps->crop.bottom);
+		inspect_printf(dump, "\" crop_right=\"%d", avc->sps->crop.right);
 		if (avc->sps->vui_parameters_present_flag) {
-			gf_fprintf(dump, "\" vui_video_full_range_flag=\"%d", avc->sps->vui.video_full_range_flag);
-			gf_fprintf(dump, "\" vui_video_signal_type_present_flag=\"%d", avc->sps->vui.video_signal_type_present_flag);
-			gf_fprintf(dump, "\" vui_aspect_ratio_info_present_flag=\"%d", avc->sps->vui.aspect_ratio_info_present_flag);
-			gf_fprintf(dump, "\" vui_aspect_ratio_num=\"%d", avc->sps->vui.par_num);
-			gf_fprintf(dump, "\" vui_aspect_ratio_den=\"%d", avc->sps->vui.par_den);
-			gf_fprintf(dump, "\" vui_overscan_info_present_flag=\"%d", avc->sps->vui.overscan_info_present_flag);
-			gf_fprintf(dump, "\" vui_colour_description_present_flag=\"%d", avc->sps->vui.colour_description_present_flag);
-			gf_fprintf(dump, "\" vui_colour_primaries=\"%d", avc->sps->vui.colour_primaries);
-			gf_fprintf(dump, "\" vui_transfer_characteristics=\"%d", avc->sps->vui.transfer_characteristics);
-			gf_fprintf(dump, "\" vui_matrix_coefficients=\"%d", avc->sps->vui.matrix_coefficients);
-			gf_fprintf(dump, "\" vui_low_delay_hrd_flag=\"%d", avc->sps->vui.low_delay_hrd_flag);
-		}
-		gf_fprintf(dump, "\" log2_max_poc_lsb=\"%d", avc->sps->log2_max_poc_lsb);
-		gf_fprintf(dump, "\" log2_max_frame_num=\"%d", avc->sps->log2_max_frame_num);
-		gf_fprintf(dump, "\" delta_pic_order_always_zero_flag=\"%d", avc->sps->delta_pic_order_always_zero_flag);
-		gf_fprintf(dump, "\" offset_for_non_ref_pic=\"%d", avc->sps->offset_for_non_ref_pic);
+			inspect_printf(dump, "\" vui_video_full_range_flag=\"%d", avc->sps->vui.video_full_range_flag);
+			inspect_printf(dump, "\" vui_video_signal_type_present_flag=\"%d", avc->sps->vui.video_signal_type_present_flag);
+			inspect_printf(dump, "\" vui_aspect_ratio_info_present_flag=\"%d", avc->sps->vui.aspect_ratio_info_present_flag);
+			inspect_printf(dump, "\" vui_aspect_ratio_num=\"%d", avc->sps->vui.par_num);
+			inspect_printf(dump, "\" vui_aspect_ratio_den=\"%d", avc->sps->vui.par_den);
+			inspect_printf(dump, "\" vui_overscan_info_present_flag=\"%d", avc->sps->vui.overscan_info_present_flag);
+			inspect_printf(dump, "\" vui_colour_description_present_flag=\"%d", avc->sps->vui.colour_description_present_flag);
+			inspect_printf(dump, "\" vui_colour_primaries=\"%d", avc->sps->vui.colour_primaries);
+			inspect_printf(dump, "\" vui_transfer_characteristics=\"%d", avc->sps->vui.transfer_characteristics);
+			inspect_printf(dump, "\" vui_matrix_coefficients=\"%d", avc->sps->vui.matrix_coefficients);
+			inspect_printf(dump, "\" vui_low_delay_hrd_flag=\"%d", avc->sps->vui.low_delay_hrd_flag);
+		}
+		inspect_printf(dump, "\" log2_max_poc_lsb=\"%d", avc->sps->log2_max_poc_lsb);
+		inspect_printf(dump, "\" log2_max_frame_num=\"%d", avc->sps->log2_max_frame_num);
+		inspect_printf(dump, "\" delta_pic_order_always_zero_flag=\"%d", avc->sps->delta_pic_order_always_zero_flag);
+		inspect_printf(dump, "\" offset_for_non_ref_pic=\"%d", avc->sps->offset_for_non_ref_pic);
 
 		break;
 	case GF_AVC_NALU_PIC_PARAM:
 		if (is_encrypted) break;
 		idx = gf_avc_read_pps_bs(bs, avc);
 		if (idx<0) {
-			gf_fprintf(dump, "\" pps_id=\"PARSING FAILURE");
+			inspect_printf(dump, "\" pps_id=\"PARSING FAILURE");
 			break;
 		}
 		if (full_bs_dump) break;
-		gf_fprintf(dump, "\" pps_id=\"%d\" sps_id=\"%d", idx, avc->ppsidx.sps_id);
-		gf_fprintf(dump, "\" entropy_coding_mode_flag=\"%d", avc->ppsidx.entropy_coding_mode_flag);
-		gf_fprintf(dump, "\" deblocking_filter_control_present_flag=\"%d", avc->ppsidx.deblocking_filter_control_present_flag);
-		gf_fprintf(dump, "\" mb_slice_group_map_type=\"%d", avc->ppsidx.mb_slice_group_map_type);
-		gf_fprintf(dump, "\" num_ref_idx_l0_default_active_minus1=\"%d", avc->ppsidx.num_ref_idx_l0_default_active_minus1);
-		gf_fprintf(dump, "\" num_ref_idx_l1_default_active_minus1=\"%d", avc->ppsidx.num_ref_idx_l1_default_active_minus1);
-		gf_fprintf(dump, "\" pic_order_present=\"%d", avc->ppsidx.pic_order_present);
-		gf_fprintf(dump, "\" pic_size_in_map_units_minus1=\"%d", avc->ppsidx.pic_size_in_map_units_minus1);
-		gf_fprintf(dump, "\" redundant_pic_cnt_present=\"%d", avc->ppsidx.redundant_pic_cnt_present);
-		gf_fprintf(dump, "\" slice_group_change_rate_minus1=\"%d", avc->ppsidx.slice_group_change_rate_minus1);
-		gf_fprintf(dump, "\" slice_group_count=\"%d", avc->ppsidx.slice_group_count);
-		gf_fprintf(dump, "\" weighted_pred_flag=\"%d", avc->ppsidx.weighted_pred_flag);
-		gf_fprintf(dump, "\" weighted_bipred_idc=\"%d", avc->ppsidx.weighted_bipred_idc);
+		inspect_printf(dump, "\" pps_id=\"%d\" sps_id=\"%d", idx, avc->ppsidx.sps_id);
+		inspect_printf(dump, "\" entropy_coding_mode_flag=\"%d", avc->ppsidx.entropy_coding_mode_flag);
+		inspect_printf(dump, "\" deblocking_filter_control_present_flag=\"%d", avc->ppsidx.deblocking_filter_control_present_flag);
+		inspect_printf(dump, "\" mb_slice_group_map_type=\"%d", avc->ppsidx.mb_slice_group_map_type);
+		inspect_printf(dump, "\" num_ref_idx_l0_default_active_minus1=\"%d", avc->ppsidx.num_ref_idx_l0_default_active_minus1);
+		inspect_printf(dump, "\" num_ref_idx_l1_default_active_minus1=\"%d", avc->ppsidx.num_ref_idx_l1_default_active_minus1);
+		inspect_printf(dump, "\" pic_order_present=\"%d", avc->ppsidx.pic_order_present);
+		inspect_printf(dump, "\" pic_size_in_map_units_minus1=\"%d", avc->ppsidx.pic_size_in_map_units_minus1);
+		inspect_printf(dump, "\" redundant_pic_cnt_present=\"%d", avc->ppsidx.redundant_pic_cnt_present);
+		inspect_printf(dump, "\" slice_group_change_rate_minus1=\"%d", avc->ppsidx.slice_group_change_rate_minus1);
+		inspect_printf(dump, "\" slice_group_count=\"%d", avc->ppsidx.slice_group_count);
+		inspect_printf(dump, "\" weighted_pred_flag=\"%d", avc->ppsidx.weighted_pred_flag);
+		inspect_printf(dump, "\" weighted_bipred_idc=\"%d", avc->ppsidx.weighted_bipred_idc);
 		break;
 	case GF_AVC_NALU_ACCESS_UNIT:
 		if (is_encrypted) break;
 		if (full_bs_dump) break;
-		gf_fprintf(dump, "\" primary_pic_type=\"%d", gf_bs_read_u8(bs) >> 5);
+		inspect_printf(dump, "\" primary_pic_type=\"%d", gf_bs_read_u8(bs) >> 5);
 		break;
 	case GF_AVC_NALU_SVC_SUBSEQ_PARAM:
 		if (is_encrypted) break;
 		idx = gf_avc_read_sps_bs(bs, avc, 1, NULL);
 		if (idx<0) {
-			gf_fprintf(dump, "\" status=\"CORRUPTED NAL");
+			inspect_printf(dump, "\" status=\"CORRUPTED NAL");
 			break;
 		}
 		if (full_bs_dump) break;
-		gf_fprintf(dump, "\" sps_id=\"%d", idx - GF_SVC_SSPS_ID_SHIFT);
+		inspect_printf(dump, "\" sps_id=\"%d", idx - GF_SVC_SSPS_ID_SHIFT);
 		break;
 	case GF_AVC_NALU_SVC_SLICE:
 		if (is_encrypted) break;
 		gf_avc_parse_nalu(bs, avc);
 		if (full_bs_dump) break;
 		if (ptr_size<4) {
-			gf_fprintf(dump, "\" status=\"CORRUPTED NAL");
+			inspect_printf(dump, "\" status=\"CORRUPTED NAL");
 			break;
 		}
 		dependency_id = (ptr2 & 0x70) >> 4;
 		quality_id = (ptr2 & 0x0F);
 		temporal_id = (ptr3 & 0xE0) >> 5;
-		gf_fprintf(dump, "\" dependency_id=\"%d\" quality_id=\"%d\" temporal_id=\"%d", dependency_id, quality_id, temporal_id);
-		gf_fprintf(dump, "\" poc=\"%d", avc->s_info.poc);
+		inspect_printf(dump, "\" dependency_id=\"%d\" quality_id=\"%d\" temporal_id=\"%d", dependency_id, quality_id, temporal_id);
+		inspect_printf(dump, "\" poc=\"%d", avc->s_info.poc);
 		break;
 	case GF_AVC_NALU_SVC_PREFIX_NALU:
 		if (is_encrypted) break;
 		if (full_bs_dump) break;
 		if (ptr_size<4) {
-			gf_fprintf(dump, "\" status=\"CORRUPTED NAL");
+			inspect_printf(dump, "\" status=\"CORRUPTED NAL");
 			break;
 		}
 		dependency_id = (ptr2 & 0x70) >> 4;
 		quality_id = (ptr2 & 0x0F);
 		temporal_id = (ptr3 & 0xE0) >> 5;
-		gf_fprintf(dump, "\" dependency_id=\"%d\" quality_id=\"%d\" temporal_id=\"%d", dependency_id, quality_id, temporal_id);
+		inspect_printf(dump, "\" dependency_id=\"%d\" quality_id=\"%d\" temporal_id=\"%d", dependency_id, quality_id, temporal_id);
 		break;
 	//extractor
 	case GF_AVC_NALU_FF_EXTRACTOR:
 		if (is_encrypted) break;
 		if (ptr_size<7+nalh_size+nalh_size) {
-			gf_fprintf(dump, "\" status=\"CORRUPTED NAL");
+			inspect_printf(dump, "\" status=\"CORRUPTED NAL");
 			break;
 		}
 		track_ref_index = (u8) ptr4;
 		sample_offset = (s8) ptr5;
 		data_offset = inspect_get_nal_size(&ptr6, nalh_size);
 		data_size = inspect_get_nal_size(&ptr6+nalh_size, nalh_size);
-		gf_fprintf(dump, "\" track_ref_index=\"%d\" sample_offset=\"%d\" data_offset=\"%d\" data_size=\"%d\"", track_ref_index, sample_offset, data_offset, data_size);
+		inspect_printf(dump, "\" track_ref_index=\"%d\" sample_offset=\"%d\" data_offset=\"%d\" data_size=\"%d\"", track_ref_index, sample_offset, data_offset, data_size);
 		break;
 	default:
 		break;
@@ -1192,23 +1214,23 @@
 
 	if (!full_bs_dump) {
 		if (nal_ref_idc) {
-			gf_fprintf(dump, " nal_ref_idc=\"%d\"", nal_ref_idc);
+			inspect_printf(dump, " nal_ref_idc=\"%d\"", nal_ref_idc);
 		}
 		if (res>=0) {
-			gf_fprintf(dump, " poc=\"%d\" pps_id=\"%d\" field_pic_flag=\"%d\"", avc->s_info.poc, avc->s_info.pps->id, (int)avc->s_info.field_pic_flag);
+			inspect_printf(dump, " poc=\"%d\" pps_id=\"%d\" field_pic_flag=\"%d\"", avc->s_info.poc, avc->s_info.pps->id, (int)avc->s_info.field_pic_flag);
 		}
 	}
 
 	if (res == -1)
-		gf_fprintf(dump, " status=\"error decoding slice\"");
+		inspect_printf(dump, " status=\"error decoding slice\"");
 
 	if (!is_encrypted && (type == GF_AVC_NALU_SEI)) {
-		gf_fprintf(dump, ">\n");
+		inspect_printf(dump, ">\n");
 		gf_bs_set_logger(bs, NULL, NULL);
 		dump_sei(dump, bs, GF_FALSE);
-		gf_fprintf(dump, " </NALU>\n");
+		inspect_printf(dump, " </NALU>\n");
 	} else {
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 	}
 
 	if (bs) {
@@ -1222,12 +1244,13 @@
 GF_EXPORT
 void gf_inspect_dump_nalu(FILE *dump, u8 *ptr, u32 ptr_size, Bool is_svc, HEVCState *hevc, AVCState *avc, VVCState *vvc, u32 nalh_size, Bool dump_crc, Bool is_encrypted)
 {
+	if (!dump) return;
 	gf_inspect_dump_nalu_internal(dump, ptr, ptr_size, is_svc, hevc, avc, vvc, nalh_size, dump_crc, is_encrypted, 0, NULL);
 }
 
 static void av1_dump_tile(FILE *dump, u32 idx, AV1Tile *tile)
 {
-	gf_fprintf(dump, " <Tile number=\"%d\" start=\"%d\" size=\"%d\"/>\n", idx, tile->obu_start_offset, tile->size);
+	inspect_printf(dump, " <Tile number=\"%d\" start=\"%d\" size=\"%d\"/>\n", idx, tile->obu_start_offset, tile->size);
 }
 
 static u64 gf_inspect_dump_obu_internal(FILE *dump, AV1State *av1, u8 *obu_ptr, u64 obu_ptr_length, ObuType obu_type, u64 obu_size, u32 hdr_size, Bool dump_crc, PidCtx *pctx, u32 full_dump)
@@ -1243,7 +1266,7 @@
 			lcbk.dump_bits = (full_dump==INSPECT_ANALYZE_BS_BITS) ? GF_TRUE : GF_FALSE;
 			gf_bs_set_logger(pctx->bs, regular_bs_log, &lcbk);
 
-			gf_fprintf(dump, " <OBU");
+			inspect_printf(dump, " <OBU");
 		}
 		gf_av1_parse_obu(pctx->bs, &obu_type, &obu_size, &hdr_size, pctx->av1_state);
 
@@ -1256,21 +1279,21 @@
 	}
 
 	if (!full_dump) {
-		gf_fprintf(dump, " <OBU");
+		inspect_printf(dump, " <OBU");
 	}
 
 
-#define DUMP_OBU_INT(_v) gf_fprintf(dump, #_v"=\"%d\" ", av1->_v);
-#define DUMP_OBU_INT2(_n, _v) gf_fprintf(dump, _n"=\"%d\" ", _v);
+#define DUMP_OBU_INT(_v) inspect_printf(dump, #_v"=\"%d\" ", av1->_v);
+#define DUMP_OBU_INT2(_n, _v) inspect_printf(dump, _n"=\"%d\" ", _v);
 
-	gf_fprintf(dump, " size=\""LLU"\" type=\"%s\" header_size=\"%d\" ", obu_size, gf_av1_get_obu_name(obu_type), hdr_size);
+	inspect_printf(dump, " size=\""LLU"\" type=\"%s\" header_size=\"%d\" ", obu_size, gf_av1_get_obu_name(obu_type), hdr_size);
 
 	if (!full_dump) {
-		gf_fprintf(dump, "has_size_field=\"%d\" has_ext=\"%d\" temporalID=\"%d\" spatialID=\"%d\" ", av1->obu_has_size_field, av1->obu_extension_flag, av1->temporal_id , av1->spatial_id);
+		inspect_printf(dump, "has_size_field=\"%d\" has_ext=\"%d\" temporalID=\"%d\" spatialID=\"%d\" ", av1->obu_has_size_field, av1->obu_extension_flag, av1->temporal_id , av1->spatial_id);
 	}
 
 	if (dump_crc && (obu_size<0xFFFFFFFFUL))
-		gf_fprintf(dump, "crc=\"%u\" ", gf_crc_32(obu_ptr, (u32) obu_size) );
+		inspect_printf(dump, "crc=\"%u\" ", gf_crc_32(obu_ptr, (u32) obu_size) );
 	switch (obu_type) {
 	case OBU_SEQUENCE_HEADER:
 		if (full_dump) break;
@@ -1303,14 +1326,18 @@
 			}
 			DUMP_OBU_INT2("uncompressed_header_bytes", av1->frame_state.uncompressed_header_bytes);
 			if (av1->frame_state.uncompressed_header_bytes) {
-				if (av1->frame_state.frame_type==AV1_KEY_FRAME) gf_fprintf(dump, "frame_type=\"key\" ");
-				else if (av1->frame_state.frame_type==AV1_INTER_FRAME) gf_fprintf(dump, "frame_type=\"inter\" ");
-				else if (av1->frame_state.frame_type==AV1_INTRA_ONLY_FRAME) gf_fprintf(dump, "frame_type=\"intra_only\" ");
-				else if (av1->frame_state.frame_type==AV1_SWITCH_FRAME) gf_fprintf(dump, "frame_type=\"switch\" ");
-				gf_fprintf(dump, "refresh_frame_flags=\"%d\" ", av1->frame_state.refresh_frame_flags);
+				if (av1->frame_state.frame_type==AV1_KEY_FRAME) inspect_printf(dump, "frame_type=\"key\" ");
+				else if (av1->frame_state.frame_type==AV1_INTER_FRAME) inspect_printf(dump, "frame_type=\"inter\" ");
+				else if (av1->frame_state.frame_type==AV1_INTRA_ONLY_FRAME) inspect_printf(dump, "frame_type=\"intra_only\" ");
+				else if (av1->frame_state.frame_type==AV1_SWITCH_FRAME) inspect_printf(dump, "frame_type=\"switch\" ");
+				inspect_printf(dump, "refresh_frame_flags=\"%d\" ", av1->frame_state.refresh_frame_flags);
 
-				DUMP_OBU_INT2("show_frame", av1->frame_state.show_frame);
-				DUMP_OBU_INT2("show_existing_frame", av1->frame_state.show_existing_frame);
+				if (!av1->frame_state.show_existing_frame) {
+					DUMP_OBU_INT2("show_frame", av1->frame_state.show_frame);
+				} else {
+					DUMP_OBU_INT2("show_existing_frame", av1->frame_state.show_existing_frame);
+					DUMP_OBU_INT2("frame_to_show_map_idx", av1->frame_state.frame_to_show_map_idx);
+				}
 				DUMP_OBU_INT(width);
 				DUMP_OBU_INT(height);
 			}
@@ -1327,9 +1354,9 @@
 				av1_dump_tile(dump, i, &av1->frame_state.tilesi);
 			}
 		} else {
-			gf_fprintf(dump, "nb_tiles=\"unknown\">\n");
+			inspect_printf(dump, "nb_tiles=\"unknown\">\n");
 		}
-		gf_fprintf(dump, " </OBU>\n");
+		inspect_printf(dump, " </OBU>\n");
 		break;
 	case OBU_METADATA:
 		{
@@ -1357,7 +1384,7 @@
 
 	}
 	if ((obu_type != OBU_TILE_GROUP) && (obu_type != OBU_FRAME) )
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 
 	return obu_size;
 }
@@ -1365,6 +1392,7 @@
 GF_EXPORT
 void gf_inspect_dump_obu(FILE *dump, AV1State *av1, u8 *obu_ptr, u64 obu_ptr_length, ObuType obu_type, u64 obu_size, u32 hdr_size, Bool dump_crc)
 {
+	if (!dump) return;
 	gf_inspect_dump_obu_internal(dump, av1, obu_ptr, obu_ptr_length, obu_type, obu_size, hdr_size, dump_crc, NULL, 0);
 }
 
@@ -1383,122 +1411,178 @@
 	if (!pctx) gf_bs_del(bs);
 
 	if (e) {
-		gf_fprintf(dump, " \n", gf_error_to_string(e) );
+		inspect_printf(dump, " \n", gf_error_to_string(e) );
 		return;
 	}
-	gf_fprintf(dump, " <ProResFrame framesize=\"%d\" frameID=\"%s\" version=\"%d\""
+	inspect_printf(dump, " <ProResFrame framesize=\"%d\" frameID=\"%s\" version=\"%d\""
 		, prores_frame.frame_size
 		, gf_4cc_to_str(prores_frame.frame_identifier)
 		, prores_frame.version
 	);
-	gf_fprintf(dump, " encoderID=\"%s\" width=\"%d\" height=\"%d\""
+	inspect_printf(dump, " encoderID=\"%s\" width=\"%d\" height=\"%d\""
 		, gf_4cc_to_str(prores_frame.encoder_id)
 		, prores_frame.width
 		, prores_frame.height
 	);
 	switch (prores_frame.chroma_format) {
-	case 0: gf_fprintf(dump, " chromaFormat=\"reserved(0)\""); break;
-	case 1: gf_fprintf(dump, " chromaFormat=\"reserved(1)\""); break;
-	case 2: gf_fprintf(dump, " chromaFormat=\"4:2:2\""); break;
-	case 3: gf_fprintf(dump, " chromaFormat=\"4:4:4\""); break;
+	case 0: inspect_printf(dump, " chromaFormat=\"reserved(0)\""); break;
+	case 1: inspect_printf(dump, " chromaFormat=\"reserved(1)\""); break;
+	case 2: inspect_printf(dump, " chromaFormat=\"4:2:2\""); break;
+	case 3: inspect_printf(dump, " chromaFormat=\"4:4:4\""); break;
 	}
 	switch (prores_frame.interlaced_mode) {
-	case 0: gf_fprintf(dump, " interlacedMode=\"progressive\""); break;
-	case 1: gf_fprintf(dump, " interlacedMode=\"interlaced_top_first\""); break;
-	case 2: gf_fprintf(dump, " interlacedMode=\"interlaced_bottom_first\""); break;
-	case 3: gf_fprintf(dump, " interlacedMode=\"reserved\""); break;
+	case 0: inspect_printf(dump, " interlacedMode=\"progressive\""); break;
+	case 1: inspect_printf(dump, " interlacedMode=\"interlaced_top_first\""); break;
+	case 2: inspect_printf(dump, " interlacedMode=\"interlaced_bottom_first\""); break;
+	case 3: inspect_printf(dump, " interlacedMode=\"reserved\""); break;
 	}
 	switch (prores_frame.aspect_ratio_information) {
-	case 0: gf_fprintf(dump, " aspectRatio=\"unknown\""); break;
-	case 1: gf_fprintf(dump, " aspectRatio=\"1:1\""); break;
-	case 2: gf_fprintf(dump, " aspectRatio=\"4:3\""); break;
-	case 3: gf_fprintf(dump, " aspectRatio=\"16:9\""); break;
-	default: gf_fprintf(dump, " aspectRatio=\"reserved(%d)\"", prores_frame.aspect_ratio_information); break;
+	case 0: inspect_printf(dump, " aspectRatio=\"unknown\""); break;
+	case 1: inspect_printf(dump, " aspectRatio=\"1:1\""); break;
+	case 2: inspect_printf(dump, " aspectRatio=\"4:3\""); break;
+	case 3: inspect_printf(dump, " aspectRatio=\"16:9\""); break;
+	default: inspect_printf(dump, " aspectRatio=\"reserved(%d)\"", prores_frame.aspect_ratio_information); break;
 	}
 	switch (prores_frame.framerate_code) {
-	case 0: gf_fprintf(dump, " framerate=\"unknown\""); break;
-	case 1: gf_fprintf(dump, " framerate=\"23.976\""); break;
-	case 2: gf_fprintf(dump, " framerate=\"24\""); break;
-	case 3: gf_fprintf(dump, " framerate=\"25\""); break;
-	case 4: gf_fprintf(dump, " framerate=\"29.97\""); break;
-	case 5: gf_fprintf(dump, " framerate=\"30\""); break;
-	case 6: gf_fprintf(dump, " framerate=\"50\""); break;
-	case 7: gf_fprintf(dump, " framerate=\"59.94\""); break;
-	case 8: gf_fprintf(dump, " framerate=\"60\""); break;
-	case 9: gf_fprintf(dump, " framerate=\"100\""); break;
-	case 10: gf_fprintf(dump, " framerate=\"119.88\""); break;
-	case 11: gf_fprintf(dump, " framerate=\"120\""); break;
-	default: gf_fprintf(dump, " framerate=\"reserved(%d)\"", prores_frame.framerate_code); break;
+	case 0: inspect_printf(dump, " framerate=\"unknown\""); break;
+	case 1: inspect_printf(dump, " framerate=\"23.976\""); break;
+	case 2: inspect_printf(dump, " framerate=\"24\""); break;
+	case 3: inspect_printf(dump, " framerate=\"25\""); break;
+	case 4: inspect_printf(dump, " framerate=\"29.97\""); break;
+	case 5: inspect_printf(dump, " framerate=\"30\""); break;
+	case 6: inspect_printf(dump, " framerate=\"50\""); break;
+	case 7: inspect_printf(dump, " framerate=\"59.94\""); break;
+	case 8: inspect_printf(dump, " framerate=\"60\""); break;
+	case 9: inspect_printf(dump, " framerate=\"100\""); break;
+	case 10: inspect_printf(dump, " framerate=\"119.88\""); break;
+	case 11: inspect_printf(dump, " framerate=\"120\""); break;
+	default: inspect_printf(dump, " framerate=\"reserved(%d)\"", prores_frame.framerate_code); break;
 	}
 	switch (prores_frame.color_primaries) {
-	case 0: case 2: gf_fprintf(dump, " colorPrimaries=\"unknown\""); break;
-	case 1: gf_fprintf(dump, " colorPrimaries=\"BT.709\""); break;
-	case 5: gf_fprintf(dump, " colorPrimaries=\"BT.601-625\""); break;
-	case 6: gf_fprintf(dump, " colorPrimaries=\"BT.601-525\""); break;
-	case 9: gf_fprintf(dump, " colorPrimaries=\"BT.2020\""); break;
-	case 11: gf_fprintf(dump, " colorPrimaries=\"P3\""); break;
-	case 12: gf_fprintf(dump, " colorPrimaries=\"P3-D65\""); break;
-	default: gf_fprintf(dump, " colorPrimaries=\"reserved(%d)\"", prores_frame.color_primaries); break;
+	case 0: case 2: inspect_printf(dump, " colorPrimaries=\"unknown\""); break;
+	case 1: inspect_printf(dump, " colorPrimaries=\"BT.709\""); break;
+	case 5: inspect_printf(dump, " colorPrimaries=\"BT.601-625\""); break;
+	case 6: inspect_printf(dump, " colorPrimaries=\"BT.601-525\""); break;
+	case 9: inspect_printf(dump, " colorPrimaries=\"BT.2020\""); break;
+	case 11: inspect_printf(dump, " colorPrimaries=\"P3\""); break;
+	case 12: inspect_printf(dump, " colorPrimaries=\"P3-D65\""); break;
+	default: inspect_printf(dump, " colorPrimaries=\"reserved(%d)\"", prores_frame.color_primaries); break;
 	}
 	switch (prores_frame.matrix_coefficients) {
-	case 0: case 2: gf_fprintf(dump, " matrixCoefficients=\"unknown\""); break;
-	case 1: gf_fprintf(dump, " matrixCoefficients=\"BT.709\""); break;
-	case 6: gf_fprintf(dump, " matrixCoefficients=\"BT.601\""); break;
-	case 9: gf_fprintf(dump, " matrixCoefficients=\"BT.2020\""); break;
-	default: gf_fprintf(dump, " matrixCoefficients=\"reserved(%d)\"", prores_frame.matrix_coefficients); break;
+	case 0: case 2: inspect_printf(dump, " matrixCoefficients=\"unknown\""); break;
+	case 1: inspect_printf(dump, " matrixCoefficients=\"BT.709\""); break;
+	case 6: inspect_printf(dump, " matrixCoefficients=\"BT.601\""); break;
+	case 9: inspect_printf(dump, " matrixCoefficients=\"BT.2020\""); break;
+	default: inspect_printf(dump, " matrixCoefficients=\"reserved(%d)\"", prores_frame.matrix_coefficients); break;
 	}
 	switch (prores_frame.transfer_characteristics) {
-	case 0: gf_fprintf(dump, " transferCharacteristics=\"unknown\""); break;
-	case 1: gf_fprintf(dump, " transferCharacteristics=\"BT-709\""); break;
-	case 16: gf_fprintf(dump, " transferCharacteristics=\"ST-2084\""); break;
-	case 18: gf_fprintf(dump, " transferCharacteristics=\"STD-B67\""); break;
+	case 0: inspect_printf(dump, " transferCharacteristics=\"unknown\""); break;
+	case 1: inspect_printf(dump, " transferCharacteristics=\"BT-709\""); break;
+	case 16: inspect_printf(dump, " transferCharacteristics=\"ST-2084\""); break;
+	case 18: inspect_printf(dump, " transferCharacteristics=\"STD-B67\""); break;
 	case 2:
 	default:
-		gf_fprintf(dump, " transferCharacteristics=\"unspecified\""); break;
+		inspect_printf(dump, " transferCharacteristics=\"unspecified\""); break;
 	}
 	switch (prores_frame.alpha_channel_type) {
-	case 0: gf_fprintf(dump, " alphaChannel=\"none\""); break;
-	case 1: gf_fprintf(dump, " alphaChannel=\"8bits\""); break;
-	case 2: gf_fprintf(dump, " alphaChannel=\"16bits\""); break;
-	default: gf_fprintf(dump, " alphaChannel=\"reserved(%d)\"", prores_frame.alpha_channel_type); break;
+	case 0: inspect_printf(dump, " alphaChannel=\"none\""); break;
+	case 1: inspect_printf(dump, " alphaChannel=\"8bits\""); break;
+	case 2: inspect_printf(dump, " alphaChannel=\"16bits\""); break;
+	default: inspect_printf(dump, " alphaChannel=\"reserved(%d)\"", prores_frame.alpha_channel_type); break;
 	}
-	gf_fprintf(dump, " numPictures=\"%d\"" , prores_frame.transfer_characteristics, prores_frame.nb_pic);
+	inspect_printf(dump, " numPictures=\"%d\"" , prores_frame.transfer_characteristics, prores_frame.nb_pic);
 
 	if (dump_crc) {
-		gf_fprintf(dump, " crc=\"%d\"" , gf_crc_32(ptr, (u32) frame_size) );
+		inspect_printf(dump, " crc=\"%d\"" , gf_crc_32(ptr, (u32) frame_size) );
 	}
 	if (!prores_frame.load_luma_quant_matrix && !prores_frame.load_chroma_quant_matrix) {
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 	} else {
 		u32 j, k;
-		gf_fprintf(dump, ">\n");
+		inspect_printf(dump, ">\n");
 		if (prores_frame.load_luma_quant_matrix) {
-			gf_fprintf(dump, " <LumaQuantMatrix coefs=\"");
+			inspect_printf(dump, " <LumaQuantMatrix coefs=\"");
 			for (j=0; j<8; j++) {
 				for (k=0; k<8; k++) {
-					gf_fprintf(dump, " %02X", prores_frame.luma_quant_matrixjk);
+					inspect_printf(dump, " %02X", prores_frame.luma_quant_matrixjk);
 				}
 			}
-			gf_fprintf(dump, "\">\n");
+			inspect_printf(dump, "\">\n");
 		}
 		if (prores_frame.load_chroma_quant_matrix) {
-			gf_fprintf(dump, " <ChromaQuantMatrix coefs=\"");
+			inspect_printf(dump, " <ChromaQuantMatrix coefs=\"");
 			for (j=0; j<8; j++) {
 				for (k=0; k<8; k++) {
-					gf_fprintf(dump, " %02X", prores_frame.chroma_quant_matrixjk);
+					inspect_printf(dump, " %02X", prores_frame.chroma_quant_matrixjk);
 				}
 			}
-			gf_fprintf(dump, "\">\n");
+			inspect_printf(dump, "\">\n");
 		}
-		gf_fprintf(dump, " </ProResFrame>\n");
+		inspect_printf(dump, " </ProResFrame>\n");
 	}
 }
 
 GF_EXPORT
 void gf_inspect_dump_prores(FILE *dump, u8 *ptr, u64 frame_size, Bool dump_crc)
 {
+	if (!dump) return;
 	gf_inspect_dump_prores_internal(dump, ptr, frame_size, dump_crc, NULL);
 }
+
+static void gf_inspect_dump_opus_internal(FILE *dump, u8 *ptr, u32 size, u32 channel_count, Bool dump_crc, PidCtx *pctx)
+{
+	u32 pck_offset=0;
+	u32 k;
+
+	if (pctx) channel_count = pctx->opus_channel_count;
+
+	for (k=0; k<channel_count; k++) {
+		u8 self_delimited = (k != channel_count-1);
+		GF_OpusPacketHeader pckh;
+		u8 headerres;
+
+		headerres = gf_opus_parse_packet_header(ptr+pck_offset, size-pck_offset, self_delimited, &pckh);
+		if (!headerres) break;
+
+		inspect_printf(dump, " <OpusPacket offset=\"%d\" self_delimited=\"%d\"", pck_offset, pckh.self_delimited);
+		inspect_printf(dump, " header_size=\"%d\" config=\"%d\" stereo=\"%d\" code=\"%d\"", pckh.size, pckh.TOC_config, pckh.TOC_stereo, pckh.TOC_code);
+		if (pckh.TOC_code == 0) {
+			inspect_printf(dump, " nb_frames=\"%d\" frame_lengths=\"%d\"/>\n", pckh.nb_frames, pckh.frame_lengths0);
+		} else if (pckh.TOC_code == 1) {
+			inspect_printf(dump, " nb_frames=\"%d\" frame_lengths=\"%d %d\"/>\n", pckh.nb_frames, pckh.frame_lengths0, pckh.frame_lengths1);
+		} else if (pckh.TOC_code == 2) {
+			inspect_printf(dump, " nb_frames=\"%d\" frame_lengths=\"%d %d\"/>\n", pckh.nb_frames, pckh.frame_lengths0, pckh.frame_lengths1);
+		} else if (pckh.TOC_code == 3) {
+			u32 j;
+			inspect_printf(dump, " vbr=\"%d\" padding=\"%d\" padding_length=\"%d\" nb_frames=\"%d\"", pckh.code3_vbr, pckh.code3_padding, pckh.code3_padding_length, pckh.nb_frames);
+			inspect_printf(dump, " frame_lengths=\"");
+			for(j=0;j<pckh.nb_frames;j++) {
+				if (j!=0) fprintf(dump, " ");
+				inspect_printf(dump, "%d", pckh.frame_lengthsj);
+			}
+			inspect_printf(dump, "\"");
+			if (dump_crc) {
+				inspect_printf(dump, " crc=\"%d\"" , gf_crc_32(ptr, (u32) size) );
+			}
+			inspect_printf(dump, "/>\n");
+		}
+
+		if (self_delimited) {
+			if (pck_offset+pckh.packet_size >= size) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Opus Not enough data to parse next self-delimited packet!\n"));
+			}
+			pck_offset += pckh.packet_size;
+		}
+	}
+}
+
+GF_EXPORT
+void gf_inspect_dump_opus(FILE *dump, u8 *ptr, u64 size, u32 channel_count, Bool dump_crc)
+{
+	if (!dump) return;
+ gf_inspect_dump_opus_internal(dump, ptr, (u32) size, channel_count, dump_crc, NULL);
+}
+
 enum {
 	MHAS_FILLER = 0,
 	MHAS_CONFIG,
@@ -1547,29 +1631,29 @@
 static void dump_mha_config(FILE *dump, GF_BitStream *bs, const char *indent)
 {
 	u32 val;
-	gf_fprintf(dump, "%s<MPEGHConfig", indent);
+	inspect_printf(dump, "%s<MPEGHConfig", indent);
 	val = gf_bs_read_int(bs, 8);
-	gf_fprintf(dump, " ProfileLevelIndication=\"%d\"", val);
+	inspect_printf(dump, " ProfileLevelIndication=\"%d\"", val);
 	val = gf_bs_read_int(bs, 5);
-	gf_fprintf(dump, " usacSamplerateIndex=\"%d\"", val);
+	inspect_printf(dump, " usacSamplerateIndex=\"%d\"", val);
 	if (val==0x1f) {
 		val = gf_bs_read_int(bs, 24);
-		gf_fprintf(dump, " usacSamplerate=\"%d\"", val);
+		inspect_printf(dump, " usacSamplerate=\"%d\"", val);
 	}
 	val = gf_bs_read_int(bs, 3);
-	gf_fprintf(dump, " coreSbrFrameLengthIndex=\"%d\"", val);
+	inspect_printf(dump, " coreSbrFrameLengthIndex=\"%d\"", val);
 	gf_bs_read_int(bs, 1);
 	val = gf_bs_read_int(bs, 1);
-	gf_fprintf(dump, " receiverDelayCompensation=\"%d\"", val);
-	gf_fprintf(dump, "/>\n");
+	inspect_printf(dump, " receiverDelayCompensation=\"%d\"", val);
+	inspect_printf(dump, "/>\n");
 }
 static void gf_inspect_dump_mha_frame(FILE *dump, GF_BitStream *bs, const char *indent)
 {
 	u32 val;
-	gf_fprintf(dump, "%s<MPEGHFrame", indent);
+	inspect_printf(dump, "%s<MPEGHFrame", indent);
 	val = gf_bs_read_int(bs, 1);
-	gf_fprintf(dump, " usacIndependencyFlag=\"%d\"", val);
-	gf_fprintf(dump, "/>\n");
+	inspect_printf(dump, " usacIndependencyFlag=\"%d\"", val);
+	inspect_printf(dump, "/>\n");
 }
 static void gf_inspect_dump_mhas(FILE *dump, u8 *ptr, u64 frame_size, Bool dump_crc, PidCtx *pctx)
 {
@@ -1577,11 +1661,11 @@
 	gf_bs_reassign_buffer(pctx->bs, ptr, frame_size);
 	GF_BitStream *bs = pctx->bs;
 
-	gf_fprintf(dump, " <MHASFrame>\n");
+	inspect_printf(dump, " <MHASFrame>\n");
 
 	while (gf_bs_available(bs)) {
 		u32 i, count;
-		const char *type_name="uknown";
+		const char *type_name="unknown";
 		u64 pos;
 		u32 type = (u32) gf_mpegh_escaped_value(bs, 3, 8, 8);
 		u64 label = gf_mpegh_escaped_value(bs, 2, 8, 32);
@@ -1594,44 +1678,44 @@
 				break;
 			}
 		}
-		gf_fprintf(dump, " <MHASPacket type=\"%s\" label=\""LLU"\" size=\""LLU"\"", type_name, label, size);
+		inspect_printf(dump, " <MHASPacket type=\"%s\" label=\""LLU"\" size=\""LLU"\"", type_name, label, size);
 
 		pos = gf_bs_get_position(bs);
 		switch (type) {
 		case MHAS_CONFIG:
-			gf_fprintf(dump, ">\n");
+			inspect_printf(dump, ">\n");
 			dump_mha_config(dump, bs, " ");
-			gf_fprintf(dump, " </MHASPacket>\n");
+			inspect_printf(dump, " </MHASPacket>\n");
 			break;
 		case MHAS_FRAME:
-			gf_fprintf(dump, ">\n");
+			inspect_printf(dump, ">\n");
 			gf_inspect_dump_mha_frame(dump, bs, " ");
-			gf_fprintf(dump, " </MHASPacket>\n");
+			inspect_printf(dump, " </MHASPacket>\n");
 			break;
 		case MHAS_BUFFER_INFO:
 			if (gf_bs_read_int(bs, 1)) {
-				gf_fprintf(dump, " buffer_fullness_present=\"1\" buffer_fullness=\""LLU"\"", gf_mpegh_escaped_value(bs, 15,24,32) );
+				inspect_printf(dump, " buffer_fullness_present=\"1\" buffer_fullness=\""LLU"\"", gf_mpegh_escaped_value(bs, 15,24,32) );
 			} else {
-				gf_fprintf(dump, " buffer_fullness_present=\"0\"");
+				inspect_printf(dump, " buffer_fullness_present=\"0\"");
 
 			}
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			break;
 		case MHAS_SYNC:
-			gf_fprintf(dump, " sync=\"0x%02X\"/>\n", gf_bs_read_u8(bs) );
+			inspect_printf(dump, " sync=\"0x%02X\"/>\n", gf_bs_read_u8(bs) );
 			break;
 		case MHAS_SYNC_GAP:
-			gf_fprintf(dump, " syncSpacingLength=\"0x%02" LLX_SUF "\"/>\n", gf_mpegh_escaped_value(bs, 16, 24, 24) );
+			inspect_printf(dump, " syncSpacingLength=\"0x%02" LLX_SUF "\"/>\n", gf_mpegh_escaped_value(bs, 16, 24, 24) );
 			break;
 		case MHAS_MARKER:
 		case MHAS_DESCRIPTOR:
-			gf_fprintf(dump, " %s=\"0x", (type==MHAS_MARKER) ? "markers" : "descriptors");
+			inspect_printf(dump, " %s=\"0x", (type==MHAS_MARKER) ? "markers" : "descriptors");
 			for (i=0; i<size; i++)
-				gf_fprintf(dump, "%02X", gf_bs_read_u8(bs) );
-			gf_fprintf(dump, "\"/>\n");
+				inspect_printf(dump, "%02X", gf_bs_read_u8(bs) );
+			inspect_printf(dump, "\"/>\n");
 			break;
 		default:
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			break;
 		}
 		gf_bs_align(bs);
@@ -1640,7 +1724,7 @@
 			gf_bs_skip_bytes(bs, size - pos);
 
 	}
-	gf_fprintf(dump, " </MHASFrame>\n");
+	inspect_printf(dump, " </MHASFrame>\n");
 }
 
 #endif
@@ -1661,12 +1745,20 @@
 			gf_fseek(pctx->tmp, 0, SEEK_SET);
 			while (!gf_feof(pctx->tmp)) {
 				u32 read = (u32) gf_fread(szLine, 1024, pctx->tmp);
-				gf_fwrite(szLine, read, ctx->dump);
+				if (ctx->dump_log) {
+					szLine1024 = 0;
+					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s", szLine));
+				} else {
+					if (gf_fwrite(szLine, read, ctx->dump) != read) {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Inspect failed to concatenate trace: %s\n", gf_error_to_string(GF_IO_ERR)));
+						break;
+					}
+				}
 			}
 		}
 		gf_fclose(pctx->tmp);
 		if (ctx->xml)
-			gf_fprintf(ctx->dump, "</PIDInspect>\n");
+			inspect_printf(ctx->dump, "</PIDInspect>\n");
 		pctx->tmp = NULL;
 	}
 }
@@ -1687,7 +1779,7 @@
 			do_close = GF_TRUE;
 		}
 		if (fout) {
-			gf_fprintf(fout, "%u\n", gf_list_count(ctx->src_pids));
+			inspect_printf(fout, "%u\n", gf_list_count(ctx->src_pids));
 			if (do_close) gf_fclose(fout);
 		}
 	} else {
@@ -1697,7 +1789,7 @@
 		}
 
 
-		if (!ctx->interleave) {
+		if (!ctx->interleave && ctx->dump) {
 			finalize_dump(ctx, GF_STREAM_AUDIO, concat);
 			finalize_dump(ctx, GF_STREAM_VISUAL, concat);
 			finalize_dump(ctx, GF_STREAM_SCENE, concat);
@@ -1727,7 +1819,7 @@
 	gf_list_del(ctx->src_pids);
 
 	if (ctx->dump) {
-		if (ctx->xml) gf_fprintf(ctx->dump, "</GPACInspect>\n");
+		if (ctx->xml) inspect_printf(ctx->dump, "</GPACInspect>\n");
 		if ((ctx->dump!=stderr) && (ctx->dump!=stdout)) {
 
 #ifdef GPAC_ENABLE_COVERAGE
@@ -1747,9 +1839,9 @@
 	Bool is_announce = GF_FALSE;
 
 	if (ctx->xml) {
-		gf_fprintf(dump, " <TEMILocation");
+		inspect_printf(dump, " <TEMILocation");
 	} else {
-		gf_fprintf(dump, " TEMILocation");
+		inspect_printf(dump, " TEMILocation");
 	}
 	if (!pctx->bs)
 		pctx->bs = gf_bs_new(att->value.data.ptr, att->value.data.size, GF_BITSTREAM_READ);
@@ -1785,9 +1877,9 @@
 	}
 
 	if (ctx->xml) {
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 	} else {
-		gf_fprintf(dump, "\n");
+		inspect_printf(dump, "\n");
 	}
 }
 
@@ -1796,9 +1888,9 @@
 	u32 val;
 	u64 lval;
 	if (ctx->xml) {
-		gf_fprintf(dump, " <TEMITiming");
+		inspect_printf(dump, " <TEMITiming");
 	} else {
-		gf_fprintf(dump, " TEMITiming");
+		inspect_printf(dump, " TEMITiming");
 	}
 	val = atoi(pname+7);
 	if (!pctx->bs)
@@ -1831,25 +1923,26 @@
 		DUMP_ATT_LLU("ntp", lval)
 	}
 	if (ctx->xml) {
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 	} else {
-		gf_fprintf(dump, "\n");
+		inspect_printf(dump, "\n");
 	}
 }
 
+#ifndef GPAC_DISABLE_AV_PARSERS
 static void gf_inspect_dump_truehd_frame(FILE *dump, GF_BitStream *bs)
 {
 	u8 nibble;
 	u16 frame_size, timing;
 	u32 sync;
-	gf_fprintf(dump, " <TrueHDAudioFrame");
+	inspect_printf(dump, " <TrueHDAudioFrame");
 	nibble = gf_bs_read_int(bs, 4);
 	frame_size = gf_bs_read_int(bs, 12);
 	timing = gf_bs_read_u16(bs);
 	sync = gf_bs_read_u32(bs);
-	gf_fprintf(dump, " nibble=\"%u\" size=\"%u\" timing=\"%u\"", nibble, frame_size, timing);
+	inspect_printf(dump, " nibble=\"%u\" size=\"%u\" timing=\"%u\"", nibble, frame_size, timing);
 	if (sync != 0xF8726FBA) {
-		gf_fprintf(dump, " major_sync=\"no\"/>\n");
+		inspect_printf(dump, " major_sync=\"no\"/>\n");
 		return;
 	}
 	u32 fmt = gf_bs_read_u32(bs);
@@ -1861,10 +1954,11 @@
 	u32 nb_substreams = gf_bs_read_int(bs, 4);
 	gf_bs_read_int(bs, 2);
 	u32 ext_substream_info = gf_bs_read_int(bs, 2);
-	gf_fprintf(dump, " major_sync=\"yes\" format=\"%u\" signature=\"%u\" flags=\"0x%04X\" vrate=\"%u\" peak_data_rate=\"%u\" substreams=\"%u\" extended_substream_info=\"%u\" ", fmt, sig, flags, vrate, prate, nb_substreams, ext_substream_info);
+	inspect_printf(dump, " major_sync=\"yes\" format=\"%u\" signature=\"%u\" flags=\"0x%04X\" vrate=\"%u\" peak_data_rate=\"%u\" substreams=\"%u\" extended_substream_info=\"%u\" ", fmt, sig, flags, vrate, prate, nb_substreams, ext_substream_info);
 
-	gf_fprintf(dump, "/>\n");
+	inspect_printf(dump, "/>\n");
 }
+#endif
 
 static void inspect_dump_property(GF_InspectCtx *ctx, FILE *dump, u32 p4cc, const char *pname, const GF_PropertyValue *att, PidCtx *pctx)
 {
@@ -1880,10 +1974,19 @@
 			return;
 	}
 
-	if (p4cc==GF_PROP_PID_DOWNLOAD_SESSION)
-		return;
-	if (p4cc==GF_PROP_PCK_END_RANGE)
+	switch (p4cc) {
+	case GF_PROP_PID_DOWNLOAD_SESSION:
+	case GF_PROP_PCK_END_RANGE:
 		return;
+	case GF_PROP_PCK_SENDER_NTP:
+	case GF_PROP_PCK_RECEIVER_NTP:
+	case GF_PROP_PCK_UTC_TIME:
+	case GF_PROP_PCK_MEDIA_TIME:
+	case GF_PROP_PID_CENC_HAS_ROLL:
+		if (gf_sys_is_test_mode())
+			return;
+		break;
+	}
 
 	if ((att->type==GF_PROP_DATA) && (ctx->analyze || ctx->xml)) {
 #ifndef GPAC_DISABLE_AV_PARSERS
@@ -1909,13 +2012,13 @@
 		u8 *data;
 		if (ctx->xml) {
 			if (ctx->dtype)
-				gf_fprintf(dump, " type=\"%s\"", gf_props_get_type_name(att->type) );
-			gf_fprintf(dump, " %s=\"", pname);
+				inspect_printf(dump, " type=\"%s\"", gf_props_get_type_name(att->type) );
+			inspect_printf(dump, " %s=\"", pname);
 		} else {
 			if (ctx->dtype) {
-				gf_fprintf(dump, "\t%s (%s): ", pname, gf_props_get_type_name(att->type));
+				inspect_printf(dump, "\t%s (%s): ", pname, gf_props_get_type_name(att->type));
 			} else {
-				gf_fprintf(dump, "\t%s: ", pname);
+				inspect_printf(dump, "\t%s: ", pname);
 			}
 		}
 		data = att->value.data.ptr;
@@ -1925,36 +2028,36 @@
 			nb_keys <<= 8;
 			nb_keys |= data2;
 		}
-		if (nb_keys>1) gf_fprintf(dump, "");
+		if (nb_keys>1) inspect_printf(dump, "");
 		kpos = 3;
 		for (i=0; i<nb_keys; i++) {
 			u32 j;
 			bin128 KID;
 			u8 iv_size = datakpos;
 			memcpy(KID, data+kpos+1, 16);
-			gf_fprintf(dump, "IV_size:%d,KID:0x", iv_size);
+			inspect_printf(dump, "IV_size:%d,KID:0x", iv_size);
 			for (j=0; j<16; j++) {
-				gf_fprintf(dump, "%02X", (unsigned char) datakpos + 1 + j);
+				inspect_printf(dump, "%02X", (unsigned char) datakpos + 1 + j);
 			}
 			kpos+=17;
 			if (!iv_size) {
 				iv_size = datakpos;
-				gf_fprintf(dump, ",const_IV_size:%d", iv_size);
+				inspect_printf(dump, ",const_IV_size:%d", iv_size);
 				if (iv_size) {
-					gf_fprintf(dump, ",const_IV:0x");
+					inspect_printf(dump, ",const_IV:0x");
 					for (j=0; j<iv_size; j++) {
-						gf_fprintf(dump, "%02X", (unsigned char) datakpos + 1 + j);
+						inspect_printf(dump, "%02X", (unsigned char) datakpos + 1 + j);
 					}
 				}
 				kpos += iv_size+1;
 			}
 		}
 
-		if (nb_keys>1) gf_fprintf(dump, "");
+		if (nb_keys>1) inspect_printf(dump, "");
 		if (ctx->xml) {
-			gf_fprintf(dump, "\"");
+			inspect_printf(dump, "\"");
 		} else {
-			gf_fprintf(dump, "\n");
+			inspect_printf(dump, "\n");
 		}
 
 		return;
@@ -2009,7 +2112,7 @@
 
 	if (ctx->xml) {
 		if (ctx->dtype)
-			gf_fprintf(dump, " type=\"%s\"", gf_props_get_type_name(att->type) );
+			inspect_printf(dump, " type=\"%s\"", gf_props_get_type_name(att->type) );
 			
 		if (pname && (strchr(pname, ' ') || strchr(pname, ':'))) {
 			u32 i=0, k;
@@ -2022,69 +2125,68 @@
 
 			if ((att->type==GF_PROP_UINT_LIST) || (att->type==GF_PROP_4CC_LIST)) {
 				for (k=0; k < att->value.uint_list.nb_items; k++) {
-					if (k) gf_fprintf(dump, ", ");
+					if (k) inspect_printf(dump, ", ");
 					if ((att->type==GF_PROP_4CC_LIST) && ! gf_sys_is_test_mode()) {
-						gf_fprintf(dump, "%s", gf_4cc_to_str(att->value.uint_list.valsk) );
+						inspect_printf(dump, "%s", gf_4cc_to_str(att->value.uint_list.valsk) );
 					} else {
-						gf_fprintf(dump, "%d", att->value.uint_list.valsk);
+						inspect_printf(dump, "%d", att->value.uint_list.valsk);
 					}
 				}
 			} else if (att->type==GF_PROP_STRING_LIST) {
 				for (k=0; k < att->value.string_list.nb_items; k++) {
-					if (k) gf_fprintf(dump, ", ");
+					if (k) inspect_printf(dump, ", ");
 					gf_xml_dump_string(dump, NULL, (char *) att->value.string_list.valsk, NULL);
 				}
 			} else if ((att->type==GF_PROP_STRING) || (att->type==GF_PROP_STRING_NO_COPY)) {
 				gf_xml_dump_string(dump, NULL, att->value.string, NULL);
 			} else {
-				gf_fprintf(dump, " %s=\"%s\"", pname_no_space, gf_props_dump(p4cc, att, szDump, (GF_PropDumDataMode) ctx->dump_data));
+				inspect_printf(dump, " %s=\"%s\"", pname_no_space, gf_props_dump(p4cc, att, szDump, (GF_PropDumpDataMode) ctx->dump_data));
 			}
 			gf_free(pname_no_space);
 		} else {
-			gf_fprintf(dump, " %s=\"%s\"", pname ? pname : gf_4cc_to_str(p4cc), gf_props_dump(p4cc, att, szDump, (GF_PropDumDataMode) ctx->dump_data));
+			inspect_printf(dump, " %s=\"%s\"", pname ? pname : gf_4cc_to_str(p4cc), gf_props_dump(p4cc, att, szDump, (GF_PropDumpDataMode) ctx->dump_data));
 		}
 	} else {
 		if (ctx->dtype) {
-			gf_fprintf(dump, "\t%s (%s): ", pname ? pname : gf_4cc_to_str(p4cc), gf_props_get_type_name(att->type));
+			inspect_printf(dump, "\t%s (%s): ", pname ? pname : gf_4cc_to_str(p4cc), gf_props_get_type_name(att->type));
 		} else {
 			if (!p4cc && !strncmp(pname, "temi_l", 6))
 				dump_temi_loc(ctx, pctx, dump, pname, att);
 			else if (!p4cc && !strncmp(pname, "temi_t", 6))
 				dump_temi_time(ctx, pctx, dump, pname, att);
 			else
-				gf_fprintf(dump, "\t%s: ", pname ? pname : gf_4cc_to_str(p4cc));
+				inspect_printf(dump, "\t%s: ", pname ? pname : gf_4cc_to_str(p4cc));
 		}
 
 		if ((att->type==GF_PROP_UINT_LIST) || (att->type==GF_PROP_4CC_LIST)) {
 			u32 k;
 			for (k=0; k < att->value.uint_list.nb_items; k++) {
-				if (k) gf_fprintf(dump, ", ");
+				if (k) inspect_printf(dump, ", ");
 				if ((att->type==GF_PROP_4CC_LIST) && ! gf_sys_is_test_mode()) {
-					gf_fprintf(dump, "%s", gf_4cc_to_str(att->value.uint_list.valsk) );
+					inspect_printf(dump, "%s", gf_4cc_to_str(att->value.uint_list.valsk) );
 				} else {
-					gf_fprintf(dump, "%d", att->value.uint_list.valsk);
+					inspect_printf(dump, "%d", att->value.uint_list.valsk);
 				}
 			}
 		} else if (att->type==GF_PROP_STRING_LIST) {
 			u32 k;
 			for (k=0; k < att->value.string_list.nb_items; k++) {
-				if (k) gf_fprintf(dump, ", ");
-				gf_fprintf(dump, "%s", (const char *) att->value.string_list.valsk);
+				if (k) inspect_printf(dump, ", ");
+				inspect_printf(dump, "%s", (const char *) att->value.string_list.valsk);
 			}
 		}else{
-			gf_fprintf(dump, "%s", gf_props_dump(p4cc, att, szDump, (GF_PropDumDataMode) ctx->dump_data) );
+			inspect_printf(dump, "%s", gf_props_dump(p4cc, att, szDump, (GF_PropDumpDataMode) ctx->dump_data) );
 		}
-		gf_fprintf(dump, "\n");
+		inspect_printf(dump, "\n");
 	}
 }
 
-static void inspect_dump_packet_fmt(GF_InspectCtx *ctx, FILE *dump, GF_FilterPacket *pck, PidCtx *pctx, u64 pck_num)
+static void inspect_dump_packet_fmt(GF_Filter *filter, GF_InspectCtx *ctx, FILE *dump, GF_FilterPacket *pck, PidCtx *pctx, u64 pck_num)
 {
 	char szDumpGF_PROP_DUMP_ARG_SIZE;
 	u32 size=0;
 	const char *data=NULL;
 	char *str = ctx->fmt;
-	if (!dump) return;
 	assert(str);
 
 	if (pck) {
@@ -2098,19 +2200,19 @@
 		if (!str0) break;
 
 		if ((str0 != '$') && (str0 != '%') && (str0 != '@')) {
-			gf_fprintf(dump, "%c", str0);
+			inspect_printf(dump, "%c", str0);
 			str = str+1;
 			continue;
 		}
 		csep = str0;
 		if (str1 == csep) {
-			gf_fprintf(dump, "%c", str0);
+			inspect_printf(dump, "%c", str0);
 			str = str+2;
 			continue;
 		}
 		sep = strchr(str+1, csep);
 		if (!sep) {
-			gf_fprintf(dump, "%c", str0);
+			inspect_printf(dump, "%c", str0);
 			str = str+1;
 			continue;
 		}
@@ -2118,45 +2220,45 @@
 		key = str+1;
 
 		if (!pck) {
-			if (!strcmp(key, "lf") || !strcmp(key, "n")) gf_fprintf(dump, "\n" );
-			else if (!strcmp(key, "t")) gf_fprintf(dump, "\t" );
-			else if (!strncmp(key, "pid.", 4)) gf_fprintf(dump, "%s", key+4);
-			else gf_fprintf(dump, "%s", key);
+			if (!strcmp(key, "lf") || !strcmp(key, "n")) inspect_printf(dump, "\n" );
+			else if (!strcmp(key, "t")) inspect_printf(dump, "\t" );
+			else if (!strncmp(key, "pid.", 4)) inspect_printf(dump, "%s", key+4);
+			else inspect_printf(dump, "%s", key);
 			sep0 = csep;
 			str = sep+1;
 			continue;
 		}
 
-		if (!strcmp(key, "pn")) gf_fprintf(dump, LLU, pck_num);
+		if (!strcmp(key, "pn")) inspect_printf(dump, LLU, pck_num);
 		else if (!strcmp(key, "dts")) {
 			u64 ts = gf_filter_pck_get_dts(pck);
-			if (ts==GF_FILTER_NO_TS) gf_fprintf(dump, "N/A");
-			else gf_fprintf(dump, LLU, ts );
+			if (ts==GF_FILTER_NO_TS) inspect_printf(dump, "N/A");
+			else inspect_printf(dump, LLU, ts );
 		}
 		else if (!strcmp(key, "cts")) {
 			u64 ts = gf_filter_pck_get_cts(pck);
-			if (ts==GF_FILTER_NO_TS) gf_fprintf(dump, "N/A");
-			else gf_fprintf(dump, LLU, ts );
+			if (ts==GF_FILTER_NO_TS) inspect_printf(dump, "N/A");
+			else inspect_printf(dump, LLU, ts );
 		}
 		else if (!strcmp(key, "ddts")) {
 			u64 ts = gf_filter_pck_get_dts(pck);
-			if ((ts==GF_FILTER_NO_TS) || (pctx->prev_dts==GF_FILTER_NO_TS)) gf_fprintf(dump, "N/A");
-			else if (pctx->pck_num<=1) gf_fprintf(dump, "N/A");
+			if ((ts==GF_FILTER_NO_TS) || (pctx->prev_dts==GF_FILTER_NO_TS)) inspect_printf(dump, "N/A");
+			else if (pctx->pck_num<=1) inspect_printf(dump, "N/A");
 			else {
 				s64 diff = ts;
 				diff -= pctx->prev_dts;
-				gf_fprintf(dump, LLD, diff);
+				inspect_printf(dump, LLD, diff);
 			}
 			pctx->prev_dts = ts;
 		}
 		else if (!strcmp(key, "dcts")) {
 			u64 ts = gf_filter_pck_get_cts(pck);
-			if ((ts==GF_FILTER_NO_TS) || (pctx->prev_cts==GF_FILTER_NO_TS)) gf_fprintf(dump, "N/A");
-			else if (pctx->pck_num<=1) gf_fprintf(dump, "N/A");
+			if ((ts==GF_FILTER_NO_TS) || (pctx->prev_cts==GF_FILTER_NO_TS)) inspect_printf(dump, "N/A");
+			else if (pctx->pck_num<=1) inspect_printf(dump, "N/A");
 			else {
 				s64 diff = ts;
 				diff -= pctx->prev_cts;
-				gf_fprintf(dump, LLD, diff);
+				inspect_printf(dump, LLD, diff);
 			}
 			pctx->prev_cts = ts;
 		}
@@ -2164,74 +2266,101 @@
 			u64 dts = gf_filter_pck_get_dts(pck);
 			u64 cts = gf_filter_pck_get_cts(pck);
 			if (dts==GF_FILTER_NO_TS) dts = cts;
-			if (cts==GF_FILTER_NO_TS) gf_fprintf(dump, "N/A");
-			else gf_fprintf(dump, LLD, ((s64)cts) - ((s64)dts) );
+			if (cts==GF_FILTER_NO_TS) inspect_printf(dump, "N/A");
+			else inspect_printf(dump, LLD, ((s64)cts) - ((s64)dts) );
 		}
 
-		else if (!strcmp(key, "dur")) gf_fprintf(dump, "%u", gf_filter_pck_get_duration(pck) );
+		else if (!strcmp(key, "dur")) inspect_printf(dump, "%u", gf_filter_pck_get_duration(pck) );
 		else if (!strcmp(key, "frame")) {
 			Bool start, end;
 			gf_filter_pck_get_framing(pck, &start, &end);
-			if (start && end) gf_fprintf(dump, "frame_full");
-			else if (start) gf_fprintf(dump, "frame_start");
-			else if (end) gf_fprintf(dump, "frame_end");
-			else gf_fprintf(dump, "frame_cont");
+			if (start && end) inspect_printf(dump, "frame_full");
+			else if (start) inspect_printf(dump, "frame_start");
+			else if (end) inspect_printf(dump, "frame_end");
+			else inspect_printf(dump, "frame_cont");
 		}
 		else if (!strcmp(key, "sap") || !strcmp(key, "rap")) {
 			u32 sap = gf_filter_pck_get_sap(pck);
 			if (sap==GF_FILTER_SAP_4_PROL) {
-				gf_fprintf(dump, "4 (prol)");
+				inspect_printf(dump, "4 (prol)");
 			} else {
-				gf_fprintf(dump, "%u", sap );
+				inspect_printf(dump, "%u", sap );
 			}
 		}
-		else if (!strcmp(key, "ilace")) gf_fprintf(dump, "%d", gf_filter_pck_get_interlaced(pck) );
-		else if (!strcmp(key, "corr")) gf_fprintf(dump, "%d", gf_filter_pck_get_corrupted(pck) );
-		else if (!strcmp(key, "seek")) gf_fprintf(dump, "%d", gf_filter_pck_get_seek_flag(pck) );
+		else if (!strcmp(key, "ilace")) inspect_printf(dump, "%d", gf_filter_pck_get_interlaced(pck) );
+		else if (!strcmp(key, "corr")) inspect_printf(dump, "%d", gf_filter_pck_get_corrupted(pck) );
+		else if (!strcmp(key, "seek")) inspect_printf(dump, "%d", gf_filter_pck_get_seek_flag(pck) );
 		else if (!strcmp(key, "bo")) {
 			u64 bo = gf_filter_pck_get_byte_offset(pck);
-			if (bo==GF_FILTER_NO_BO) gf_fprintf(dump, "N/A");
-			else gf_fprintf(dump, LLU, bo);
+			if (bo==GF_FILTER_NO_BO) inspect_printf(dump, "N/A");
+			else inspect_printf(dump, LLU, bo);
 		}
-		else if (!strcmp(key, "roll")) gf_fprintf(dump, "%d", gf_filter_pck_get_roll_info(pck) );
-		else if (!strcmp(key, "crypt")) gf_fprintf(dump, "%d", gf_filter_pck_get_crypt_flags(pck) );
-		else if (!strcmp(key, "vers")) gf_fprintf(dump, "%d", gf_filter_pck_get_carousel_version(pck) );
-		else if (!strcmp(key, "size")) gf_fprintf(dump, "%d", size );
-		else if (!strcmp(key, "csize")) gf_fprintf(dump, "%d", pctx->csize);
-		else if (!strcmp(key, "crc")) gf_fprintf(dump, "0x%08X", gf_crc_32(data, size) );
-		else if (!strcmp(key, "lf") || !strcmp(key, "n")) gf_fprintf(dump, "\n" );
-		else if (!strcmp(key, "t")) gf_fprintf(dump, "\t" );
+		else if (!strcmp(key, "roll")) inspect_printf(dump, "%d", gf_filter_pck_get_roll_info(pck) );
+		else if (!strcmp(key, "crypt")) inspect_printf(dump, "%d", gf_filter_pck_get_crypt_flags(pck) );
+		else if (!strcmp(key, "vers")) inspect_printf(dump, "%d", gf_filter_pck_get_carousel_version(pck) );
+		else if (!strcmp(key, "size")) inspect_printf(dump, "%d", size );
+		else if (!strcmp(key, "csize")) inspect_printf(dump, "%d", pctx->csize);
+		else if (!strcmp(key, "crc")) inspect_printf(dump, "0x%08X", gf_crc_32(data, size) );
+		else if (!strcmp(key, "lf") || !strcmp(key, "n")) inspect_printf(dump, "\n" );
+		else if (!strcmp(key, "t")) inspect_printf(dump, "\t" );
 		else if (!strcmp(key, "data")) {
 			u32 i;
-			for (i=0; i<size; i++) {
-				gf_fprintf(dump, "%02X", (unsigned char) datai);
+			if ((pctx->stream_type==GF_STREAM_TEXT) && gf_utf8_is_legal(data, size)) {
+				for (i=0; i<size; i++) {
+					inspect_printf(dump, "%c", datai);
+				}
+			} else {
+				for (i=0; i<size; i++) {
+					inspect_printf(dump, "%02X", (unsigned char) datai);
+				}
 			}
 		}
 		else if (!strcmp(key, "lp")) {
 			u8 flags = gf_filter_pck_get_dependency_flags(pck);
 			flags >>= 6;
-			gf_fprintf(dump, "%u", flags);
+			inspect_printf(dump, "%u", flags);
 		}
 		else if (!strcmp(key, "depo")) {
 			u8 flags = gf_filter_pck_get_dependency_flags(pck);
 			flags >>= 4;
 			flags &= 0x3;
-			gf_fprintf(dump, "%u", flags);
+			inspect_printf(dump, "%u", flags);
 		}
 		else if (!strcmp(key, "depf")) {
 			u8 flags = gf_filter_pck_get_dependency_flags(pck);
 			flags >>= 2;
 			flags &= 0x3;
-			gf_fprintf(dump, "%u", flags);
+			inspect_printf(dump, "%u", flags);
 		}
 		else if (!strcmp(key, "red")) {
 			u8 flags = gf_filter_pck_get_dependency_flags(pck);
 			flags &= 0x3;
-			gf_fprintf(dump, "%u", flags);
+			inspect_printf(dump, "%u", flags);
+		}
+		else if (!strcmp(key, "start") || !strcmp(key, "end") || !strcmp(key, "startc") || !strcmp(key, "endc")) {
+			u64 ts = gf_filter_pck_get_cts(pck);
+			if (ts==GF_FILTER_NO_TS) inspect_printf(dump, "N/A");
+			else {
+				if (!strcmp(key, "end"))
+					ts += gf_filter_pck_get_duration(pck);
+				ts *= 1000;
+				ts /= gf_filter_pid_get_timescale(pctx->src_pid);
+
+				u32 h, m, s, ms;
+				u64 time = ts/1000;
+				h = (u32) (time/3600);
+				m = (u32) (time/60 - h*60);
+				s = (u32) (time - m*60 - h*3660);
+				ms = (u32) (ts - 1000*time);
+				if (!strcmp(key, "startc") || !strcmp(key, "endc"))
+					inspect_printf(dump, "%02d:%02d:%02d,%03d", h, m, s, ms);
+				else
+					inspect_printf(dump, "%02d:%02d:%02d.%03d", h, m, s, ms);
+			}
 		}
 		else if (!strcmp(key, "ck")) {
 			GF_FilterClockType ck_type = gf_filter_pck_get_clock_type(pck);
-			gf_fprintf(dump, "%d", ck_type );
+			inspect_printf(dump, "%d", ck_type );
 		} else if (!strcmp(key, "pcr") || !strcmp(key, "pcrd") || !strcmp(key, "pcrc")) {
 			u64 clock_val;
 			u32 ck_timescale;
@@ -2261,14 +2390,14 @@
 				}
 				if (dump_diff) {
 					if (ts>clock_val)
-						gf_fprintf(dump, "-"LLU, ts - clock_val);
+						inspect_printf(dump, "-"LLU, ts - clock_val);
 					else
-						gf_fprintf(dump, LLU, clock_val - ts);
+						inspect_printf(dump, LLU, clock_val - ts);
 				} else {
-					gf_fprintf(dump, LLU, clock_val);
+					inspect_printf(dump, LLU, clock_val);
 				}
 			} else {
-				gf_fprintf(dump, "N/A");
+				inspect_printf(dump, "N/A");
 			}
 		}
 		else if (!strncmp(key, "pid.", 4)) {
@@ -2284,11 +2413,14 @@
 			if (!prop) prop = gf_filter_pid_get_property_str(pctx->src_pid, key);
 
 			if (prop) {
-				gf_fprintf(dump, "%s", gf_props_dump(prop_4cc, prop, szDump, (GF_PropDumDataMode) ctx->dump_data) );
+				inspect_printf(dump, "%s", gf_props_dump(prop_4cc, prop, szDump, (GF_PropDumpDataMode) ctx->dump_data) );
 			} else {
-				gf_fprintf(dump, "N/A");
+				inspect_printf(dump, "N/A");
 			}
 		}
+		else if (!strcmp(key, "fn")) {
+			inspect_printf(dump, "%s", gf_filter_get_name(filter) );
+		}
 		else {
 			const GF_PropertyValue *prop = NULL;
 			u32 prop_4cc = gf_props_get_id(key);
@@ -2300,9 +2432,9 @@
 			if (!prop) prop = gf_filter_pck_get_property_str(pck, key);
 
 			if (prop) {
-				gf_fprintf(dump, "%s", gf_props_dump(prop_4cc, prop, szDump, (GF_PropDumDataMode) ctx->dump_data) );
+				inspect_printf(dump, "%s", gf_props_dump(prop_4cc, prop, szDump, (GF_PropDumpDataMode) ctx->dump_data) );
 			} else {
-				gf_fprintf(dump, "N/A");
+				inspect_printf(dump, "N/A");
 			}
 		}
 
@@ -2315,6 +2447,15 @@
 u32 gf_m4v_parser_get_obj_type(GF_M4VParser *m4v);
 
 #ifndef GPAC_DISABLE_AV_PARSERS
+static const char *get_frame_type_name(u32 ftype)
+{
+	switch (ftype) {
+	case 2: return "B";
+	case 1: return "P";
+	case 0: return "I";
+	default: return "unknown";
+	}
+}
 static void inspect_dump_mpeg124(PidCtx *pctx, char *data, u32 size, FILE *dump)
 {
 	u8 ftype;
@@ -2334,64 +2475,64 @@
 
 		o_type = gf_m4v_parser_get_obj_type(m4v);
 		if (is_m4v) {
-			gf_fprintf(dump, "<MPEG4P2VideoObj type=\"0x%02X\"", o_type);
+			inspect_printf(dump, "<MPEG4P2VideoObj type=\"0x%02X\"", o_type);
 			switch (o_type) {
 			/*vosh*/
 			case M4V_VOS_START_CODE:
-				gf_fprintf(dump, " name=\"VOS\" PL=\"%d\"", pctx->dsi.VideoPL);
+				inspect_printf(dump, " name=\"VOS\" PL=\"%d\"", pctx->dsi.VideoPL);
 				break;
 			case M4V_VOL_START_CODE:
-				gf_fprintf(dump, " name=\"VOL\" RAPStream=\"%d\" objectType=\"%d\" par=\"%d/%d\" hasShape=\"%d\"", pctx->dsi.RAP_stream, pctx->dsi.objectType, pctx->dsi.par_num, pctx->dsi.par_den, pctx->dsi.has_shape);
+				inspect_printf(dump, " name=\"VOL\" RAPStream=\"%d\" objectType=\"%d\" par=\"%d/%d\" hasShape=\"%d\"", pctx->dsi.RAP_stream, pctx->dsi.objectType, pctx->dsi.par_num, pctx->dsi.par_den, pctx->dsi.has_shape);
 				if (pctx->dsi.clock_rate)
-					gf_fprintf(dump, " clockRate=\"%d\"", pctx->dsi.clock_rate);
+					inspect_printf(dump, " clockRate=\"%d\"", pctx->dsi.clock_rate);
 				if (pctx->dsi.time_increment)
-					gf_fprintf(dump, " timeIncrement=\"%d\"", pctx->dsi.time_increment);
+					inspect_printf(dump, " timeIncrement=\"%d\"", pctx->dsi.time_increment);
 				if (!pctx->dsi.has_shape)
-					gf_fprintf(dump, " width=\"%d\" height=\"%d\"", pctx->dsi.width, pctx->dsi.height);
+					inspect_printf(dump, " width=\"%d\" height=\"%d\"", pctx->dsi.width, pctx->dsi.height);
 
 				break;
 
 			case M4V_VOP_START_CODE:
-				gf_fprintf(dump, " name=\"VOP\" RAP=\"%d\" frameType=\"%d\" timeInc=\"%d\" isCoded=\"%d\"", (ftype==0) ? 1 : 0, ftype, tinc, is_coded);
+				inspect_printf(dump, " name=\"VOP\" RAP=\"%d\" frameType=\"%s\" timeInc=\"%d\" isCoded=\"%d\"", (ftype==1) ? 1 : 0, get_frame_type_name(ftype), tinc, is_coded);
 				break;
 			case M4V_GOV_START_CODE:
-				gf_fprintf(dump, " name=\"GOV\"");
+				inspect_printf(dump, " name=\"GOV\"");
 				break;
 			/*don't interest us*/
 			case M4V_UDTA_START_CODE:
-				gf_fprintf(dump, " name=\"UDTA\"");
+				inspect_printf(dump, " name=\"UDTA\"");
 				break;
 
 	 		case M4V_VO_START_CODE:
-				gf_fprintf(dump, " name=\"VO\"");
+				inspect_printf(dump, " name=\"VO\"");
 				break;
 	 		case M4V_VISOBJ_START_CODE:
-				gf_fprintf(dump, " name=\"VisObj\"");
+				inspect_printf(dump, " name=\"VisObj\"");
 				break;
 			default:
 				break;
 			}
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		} else {
-			gf_fprintf(dump, "<MPEG12VideoObj type=\"0x%02X\"", o_type);
+			inspect_printf(dump, "<MPEG12VideoObj type=\"0x%02X\"", o_type);
 			switch (o_type) {
 			case M2V_SEQ_START_CODE:
-				gf_fprintf(dump, " name=\"SeqStart\" width=\"%d\" height=\"%d\" sar=\"%d/%d\" fps=\"%f\"", pctx->dsi.width, pctx->dsi.height, pctx->dsi.par_num, pctx->dsi.par_den, pctx->dsi.fps);
+				inspect_printf(dump, " name=\"SeqStart\" width=\"%d\" height=\"%d\" sar=\"%d/%d\" fps=\"%f\"", pctx->dsi.width, pctx->dsi.height, pctx->dsi.par_num, pctx->dsi.par_den, pctx->dsi.fps);
 				break;
 
 			case M2V_EXT_START_CODE:
-				gf_fprintf(dump, " name=\"SeqStartEXT\" width=\"%d\" height=\"%d\" PL=\"%d\"", pctx->dsi.width, pctx->dsi.height, pctx->dsi.VideoPL);
+				inspect_printf(dump, " name=\"SeqStartEXT\" width=\"%d\" height=\"%d\" PL=\"%d\"", pctx->dsi.width, pctx->dsi.height, pctx->dsi.VideoPL);
 				break;
 			case M2V_PIC_START_CODE:
-				gf_fprintf(dump, " name=\"PicStart\" frameType=\"%d\" isCoded=\"%d\"", ftype, is_coded);
+				inspect_printf(dump, " name=\"PicStart\" frameType=\"%s\" isCoded=\"%d\"", get_frame_type_name(ftype), is_coded);
 				break;
 			case M2V_GOP_START_CODE:
-				gf_fprintf(dump, " name=\"GOPStart\"");
+				inspect_printf(dump, " name=\"GOPStart\"");
 				break;
 			default:
 				break;
 			}
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		}
 	}
 	gf_m4v_parser_del(m4v);
@@ -2429,7 +2570,7 @@
 		neg = GF_TRUE;
 
 	if (dump)
-		gf_fprintf(dump, "<TimeCode");
+		inspect_printf(dump, "<TimeCode");
 
 	if (!force_ff && !(tmcd_flags & 0x00000008)) {
 		h = gf_bs_read_u8(bs);
@@ -2494,7 +2635,7 @@
 		}
 	}
 	if (dump)
-		gf_fprintf(dump, " time=\"%s%02d:%02d:%02d%c%02d\"/>\n", neg ? "-" : "", h, m, s, is_drop ? ';' : ':', f);
+		inspect_printf(dump, " time=\"%s%02d:%02d:%02d%c%02d\"/>\n", neg ? "-" : "", h, m, s, is_drop ? ';' : ':', f);
 	else if (szFmt)
 		sprintf(szFmt, "%s%02d:%02d:%02d%c%02d", neg ? "-" : "", h, m, s, is_drop ? ';' : ':', f);
 
@@ -2508,12 +2649,12 @@
 	inspect_format_tmcd_internal(data, size, tmcd_flags, tc_num, tc_den, tmcd_fpt, szFmt, NULL, GF_FALSE, NULL);
 }
 
+#ifndef GPAC_DISABLE_AV_PARSERS
 static void inspect_dump_tmcd(GF_InspectCtx *ctx, PidCtx *pctx, const u8 *data, u32 size, FILE *dump)
 {
 	inspect_format_tmcd_internal(data, size, pctx->tmcd_flags, pctx->tmcd_rate.num, pctx->tmcd_rate.den, pctx->tmcd_fpt, NULL, pctx->bs, ctx->fftmcd, dump);
 }
 
-#ifndef GPAC_DISABLE_AV_PARSERS
 static void inspect_dump_vpx(GF_InspectCtx *ctx, FILE *dump, u8 *ptr, u64 frame_size, Bool dump_crc, PidCtx *pctx, u32 vpversion)
 {
 	GF_Err e;
@@ -2533,14 +2674,14 @@
 	/*check if it is a superframe*/
 	e = gf_vp9_parse_superframe(pctx->bs, frame_size, &num_frames_in_superframe, frame_sizes, &superframe_index_size);
 
-	gf_fprintf(dump, "<VP%d%sFrame", vpversion, superframe_index_size ? "Super" : "");
+	inspect_printf(dump, "<VP%d%sFrame", vpversion, superframe_index_size ? "Super" : "");
 	if (e) {
-		gf_fprintf(dump, " status=\"error parsing superframe\"/>\n");
+		inspect_printf(dump, " status=\"error parsing superframe\"/>\n");
 		gf_bs_set_logger(pctx->bs, NULL, NULL);
 		return;
 	}
 	if (superframe_index_size)
-		gf_fprintf(dump, " nb_frames=\"%u\" index_size=\"%u\">\n", num_frames_in_superframe, superframe_index_size);
+		inspect_printf(dump, " nb_frames=\"%u\" index_size=\"%u\">\n", num_frames_in_superframe, superframe_index_size);
 	else {
 		assert(num_frames_in_superframe==1);
 	}
@@ -2548,26 +2689,26 @@
 		u64 pos2 = gf_bs_get_position(pctx->bs);
 
 		if (superframe_index_size)
-			gf_fprintf(dump, "<VP%dFrame", vpversion);
+			inspect_printf(dump, "<VP%dFrame", vpversion);
 
-		gf_fprintf(dump, " size=\"%u\"", frame_sizesi);
+		inspect_printf(dump, " size=\"%u\"", frame_sizesi);
 		if (gf_vp9_parse_sample(pctx->bs, pctx->vpcc, &key_frame, &width, &height, &renderWidth, &renderHeight) != GF_OK) {
-			gf_fprintf(dump, " status=\"error parsing frame\"/>\n");
+			inspect_printf(dump, " status=\"error parsing frame\"/>\n");
 			goto exit;
 		}
-		gf_fprintf(dump, " key_frame=\"%u\" width=\"%u\" height=\"%u\" renderWidth=\"%u\" renderHeight=\"%u\"", key_frame, width, height, renderWidth, renderHeight);
+		inspect_printf(dump, " key_frame=\"%u\" width=\"%u\" height=\"%u\" renderWidth=\"%u\" renderHeight=\"%u\"", key_frame, width, height, renderWidth, renderHeight);
 		e = gf_bs_seek(pctx->bs, pos2 + frame_sizesi);
 		if (e) {
-			gf_fprintf(dump, " status=\"error seeking %s (offset "LLU")\"/>\n", gf_error_to_string(e), pos2 + frame_sizesi);
+			inspect_printf(dump, " status=\"error seeking %s (offset "LLU")\"/>\n", gf_error_to_string(e), pos2 + frame_sizesi);
 			goto exit;
 		}
 
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 	}
 
 exit:
 	if (superframe_index_size)
-		gf_fprintf(dump, "</VP%dSuperFrame>\n", vpversion);
+		inspect_printf(dump, "</VP%dSuperFrame>\n", vpversion);
 	gf_bs_set_logger(pctx->bs, NULL, NULL);
 }
 
@@ -2584,17 +2725,17 @@
 		lcbk.dump_bits = ctx->analyze==INSPECT_ANALYZE_BS_BITS ? GF_TRUE : GF_FALSE;
 		gf_bs_set_logger(pctx->bs, regular_bs_log, &lcbk);
 	}
-	gf_fprintf(dump, "<%sSample ", is_ec3 ? "EC3" : "AC3");
+	inspect_printf(dump, "<%sSample ", is_ec3 ? "EC3" : "AC3");
 	memset(&hdr, 0, sizeof(GF_AC3Header));
 	gf_ac3_parser_bs(pctx->bs, &hdr, GF_TRUE);
 	if (ctx->analyze<INSPECT_ANALYZE_BS) {
-		gf_fprintf(dump, "bitrate=\"%u\" channels=\"%u\" framesize=\"%u\"", hdr.bitrate, hdr.channels, hdr.framesize);
+		inspect_printf(dump, "bitrate=\"%u\" channels=\"%u\" framesize=\"%u\"", hdr.is_ec3 ? hdr.brcode*1000 : gf_ac3_get_bitrate(hdr.brcode), hdr.streams0.channels, hdr.framesize);
 		if (hdr.is_ec3) {
-			gf_fprintf(dump, " nb_streams=\"%u\" ", hdr.nb_streams);
+			inspect_printf(dump, " nb_streams=\"%u\" ", hdr.nb_streams);
 		}
 	}
 
-	gf_fprintf(dump, "/>\n");
+	inspect_printf(dump, "/>\n");
 	gf_bs_set_logger(pctx->bs, NULL, NULL);
 }
 
@@ -2607,51 +2748,53 @@
 	GF_FilterClockType ck_type;
 	GF_FilterFrameInterface *fifce=NULL;
 
+	if (!ctx->dump_log && !dump) return;
+
 	gf_filter_pck_get_data(pck, &size);
 	ck_type = ctx->pcr ? gf_filter_pck_get_clock_type(pck) : 0;
 	if (!size && !ck_type) {
 		fifce = gf_filter_pck_get_frame_interface(pck);
 	}
 
-	gf_fprintf(dump, "PID %d PCK "LLU, pid_idx, pck_num);
+	inspect_printf(dump, "PID %d PCK "LLU, pid_idx, pck_num);
 
 	if (ck_type) {
 		ts = gf_filter_pck_get_cts(pck);
 		if (ts!=GF_FILTER_NO_TS)
-			gf_fprintf(dump, " PCR%s "LLU"\n", (ck_type==GF_FILTER_CLOCK_PCR) ? "" : " discontinuity", ts );
+			inspect_printf(dump, " PCR%s "LLU"\n", (ck_type==GF_FILTER_CLOCK_PCR) ? "" : " discontinuity", ts );
 		return;
 	}
 
 	ts = gf_filter_pck_get_cts(pck);
-	if (ts==GF_FILTER_NO_TS) gf_fprintf(dump, " cts N/A");
-	else gf_fprintf(dump, " cts "LLU, ts);
+	if (ts==GF_FILTER_NO_TS) inspect_printf(dump, " cts N/A");
+	else inspect_printf(dump, " cts "LLU, ts);
 
 	dts = gf_filter_pck_get_dts(pck);
-	if ((dts!=GF_FILTER_NO_TS) && (dts!= ts)) gf_fprintf(dump, " dts "LLU, dts);
+	if ((dts!=GF_FILTER_NO_TS) && (dts!= ts)) inspect_printf(dump, " dts "LLU, dts);
 
 	flag = gf_filter_pck_get_duration(pck);
-	if (flag) gf_fprintf(dump, " dur %u", flag);
+	if (flag) inspect_printf(dump, " dur %u", flag);
 
 	sap = gf_filter_pck_get_sap(pck);
 	if (sap==GF_FILTER_SAP_4_PROL) {
-		gf_fprintf(dump, " sap 4 (prol)");
+		inspect_printf(dump, " sap 4 (prol)");
 	} else if (sap) {
-		gf_fprintf(dump, " sap %u", sap);
+		inspect_printf(dump, " sap %u", sap);
 	}
 	flag = gf_filter_pck_get_interlaced(pck);
-	if (flag) gf_fprintf(dump, " ilace %u", flag);
+	if (flag) inspect_printf(dump, " ilace %u", flag);
 	flag = gf_filter_pck_get_corrupted(pck);
-	if (flag) gf_fprintf(dump, " corr %u", flag);
+	if (flag) inspect_printf(dump, " corr %u", flag);
 	flag = gf_filter_pck_get_seek_flag(pck);
-	if (flag) gf_fprintf(dump, " seek %u", flag);
+	if (flag) inspect_printf(dump, " seek %u", flag);
 	flag = gf_filter_pck_get_crypt_flags(pck);
-	if (flag) gf_fprintf(dump, " crypt %u", flag);
+	if (flag) inspect_printf(dump, " crypt %u", flag);
 	flag = gf_filter_pck_get_carousel_version(pck);
-	if (flag) gf_fprintf(dump, " vers %u", flag);
+	if (flag) inspect_printf(dump, " vers %u", flag);
 
-	if (!fifce) gf_fprintf(dump, " size %u", size);
+	if (!fifce) inspect_printf(dump, " size %u", size);
 
-	gf_fprintf(dump, "\n");
+	inspect_printf(dump, "\n");
 }
 static void inspect_dump_packet(GF_InspectCtx *ctx, FILE *dump, GF_FilterPacket *pck, u32 pid_idx, u64 pck_num, PidCtx *pctx)
 {
@@ -2662,7 +2805,8 @@
 	GF_FilterFrameInterface *fifce=NULL;
 	Bool start, end;
 	u8 *data;
-	if (!dump) return;
+
+	if (!ctx->dump_log && !dump) return;
 
 	if (!ctx->deep && !ctx->fmt) return;
 	if (!ctx->full) {
@@ -2679,37 +2823,37 @@
 	}
 
 	if (ctx->xml) {
-		gf_fprintf(dump, "<Packet number=\""LLU"\"", pck_num);
+		inspect_printf(dump, "<Packet number=\""LLU"\"", pck_num);
 		if (ctx->interleave)
-			gf_fprintf(dump, " PID=\"%d\"", pid_idx);
+			inspect_printf(dump, " PID=\"%d\"", pid_idx);
 	} else {
-		gf_fprintf(dump, "PID %d PCK "LLU" - ", pid_idx, pck_num);
+		inspect_printf(dump, "PID %d PCK "LLU" - ", pid_idx, pck_num);
 	}
 	if (ck_type) {
 		ts = gf_filter_pck_get_cts(pck);
 		if (ctx->xml) {
-			if (ts==GF_FILTER_NO_TS) gf_fprintf(dump, " PCR=\"N/A\"");
-			else gf_fprintf(dump, " PCR=\""LLU"\" ", ts );
-			if (ck_type!=GF_FILTER_CLOCK_PCR) gf_fprintf(dump, " discontinuity=\"true\"");
-			gf_fprintf(dump, "/>");
+			if (ts==GF_FILTER_NO_TS) inspect_printf(dump, " PCR=\"N/A\"");
+			else inspect_printf(dump, " PCR=\""LLU"\" ", ts );
+			if (ck_type!=GF_FILTER_CLOCK_PCR) inspect_printf(dump, " discontinuity=\"true\"");
+			inspect_printf(dump, "/>");
 		} else {
-			if (ts==GF_FILTER_NO_TS) gf_fprintf(dump, " PCR N/A");
-			else gf_fprintf(dump, " PCR%s "LLU"\n", (ck_type==GF_FILTER_CLOCK_PCR) ? "" : " discontinuity", ts );
+			if (ts==GF_FILTER_NO_TS) inspect_printf(dump, " PCR N/A");
+			else inspect_printf(dump, " PCR%s "LLU"\n", (ck_type==GF_FILTER_CLOCK_PCR) ? "" : " discontinuity", ts );
 		}
 		return;
 	}
 	if (ctx->xml) {
-		if (fifce) gf_fprintf(dump, " framing=\"interface\"");
-		else if (start && end) gf_fprintf(dump, " framing=\"complete\"");
-		else if (start) gf_fprintf(dump, " framing=\"start\"");
-		else if (end) gf_fprintf(dump, " framing=\"end\"");
-		else gf_fprintf(dump, " framing=\"continuation\"");
+		if (fifce) inspect_printf(dump, " framing=\"interface\"");
+		else if (start && end) inspect_printf(dump, " framing=\"complete\"");
+		else if (start) inspect_printf(dump, " framing=\"start\"");
+		else if (end) inspect_printf(dump, " framing=\"end\"");
+		else inspect_printf(dump, " framing=\"continuation\"");
 	} else {
-		if (fifce) gf_fprintf(dump, "interface");
-		else if (start && end) gf_fprintf(dump, "full frame");
-		else if (start) gf_fprintf(dump, "frame start");
-		else if (end) gf_fprintf(dump, "frame end");
-		else gf_fprintf(dump, "frame continuation");
+		if (fifce) inspect_printf(dump, "interface");
+		else if (start && end) inspect_printf(dump, "full frame");
+		else if (start) inspect_printf(dump, "frame start");
+		else if (end) inspect_printf(dump, "frame end");
+		else inspect_printf(dump, "frame continuation");
 	}
 	ts = gf_filter_pck_get_dts(pck);
 	if (ts==GF_FILTER_NO_TS) DUMP_ATT_STR("dts", "N/A")
@@ -2752,16 +2896,16 @@
 		u32 i;
 		DUMP_ATT_STR("data", "")
 		for (i=0; i<size; i++) {
-			gf_fprintf(dump, "%02X", (unsigned char) datai);
+			inspect_printf(dump, "%02X", (unsigned char) datai);
 		}
-		if (ctx->xml) gf_fprintf(dump, "\"");
+		if (ctx->xml) inspect_printf(dump, "\"");
 	} else if (fifce) {
 		u32 i;
 		char *name = fifce->get_gl_texture ? "Interface_GLTexID" : "Interface_NumPlanes";
 		if (ctx->xml) {
-			gf_fprintf(dump, " %s=\"", name);
+			inspect_printf(dump, " %s=\"", name);
 		} else {
-			gf_fprintf(dump, " %s ", name);
+			inspect_printf(dump, " %s ", name);
 		}
 		for (i=0; i<4; i++) {
 			if (fifce->get_gl_texture) {
@@ -2770,8 +2914,8 @@
 				u32 gl_tex_format, gl_tex_id;
 				if (fifce->get_gl_texture(fifce, i, &gl_tex_format, &gl_tex_id, &mx) != GF_OK)
 					break;
-				if (i) gf_fprintf(dump, ",");
-				gf_fprintf(dump, "%d", gl_tex_id);
+				if (i) inspect_printf(dump, ",");
+				inspect_printf(dump, "%d", gl_tex_id);
 			} else {
 				u32 stride;
 				const u8 *plane;
@@ -2780,11 +2924,11 @@
 			}
 		}
 		if (!fifce->get_gl_texture) {
-			gf_fprintf(dump, "%d", i);
+			inspect_printf(dump, "%d", i);
 		}
 
 		if (ctx->xml) {
-			gf_fprintf(dump, "\"");
+			inspect_printf(dump, "\"");
 		}
 	} else if (data && (ctx->test!=INSPECT_TEST_NOCRC) ) {
 		DUMP_ATT_X("CRC32", gf_crc_32(data, size) )
@@ -2793,7 +2937,7 @@
 		if (!ctx->props) goto props_done;
 
 	} else {
-		gf_fprintf(dump, "\n");
+		inspect_printf(dump, "\n");
 	}
 
 	if (!ctx->props) return;
@@ -2802,7 +2946,7 @@
 		const char *prop_name;
 		const GF_PropertyValue * p = gf_filter_pck_enum_properties(pck, &idx, &prop_4cc, &prop_name);
 		if (!p) break;
-		if (idx==0) gf_fprintf(dump, "properties:\n");
+		if (idx==0) inspect_printf(dump, "properties:\n");
 
 		inspect_dump_property(ctx, dump, prop_4cc, prop_name, p, pctx);
 	}
@@ -2811,11 +2955,11 @@
 props_done:
 	if (!ctx->analyze || !size) {
 		if (ctx->xml) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		}
 		return;
 	}
-	gf_fprintf(dump, ">\n");
+	inspect_printf(dump, ">\n");
 
 #ifndef GPAC_DISABLE_AV_PARSERS
 	if (pctx->hevc_state || pctx->avc_state || pctx->vvc_state) {
@@ -2824,8 +2968,8 @@
 		if (pctx->is_adobe_protected) {
 			u8 encrypted_au = data0;
 			if (encrypted_au) {
-				gf_fprintf(dump, " \n");
-				gf_fprintf(dump, "</Packet>\n");
+				inspect_printf(dump, " \n");
+				inspect_printf(dump, "</Packet>\n");
 				return;
 			}
 			else {
@@ -2838,10 +2982,10 @@
 			data += pctx->nalu_size_length;
 
 			if (pctx->nalu_size_length + nal_size > size) {
-				gf_fprintf(dump, " \n", nal_size, size);
+				inspect_printf(dump, " \n", nal_size, size);
 				break;
 			} else {
-				gf_fprintf(dump, " <NALU size=\"%d\" ", nal_size);
+				inspect_printf(dump, " <NALU size=\"%d\" ", nal_size);
 				gf_inspect_dump_nalu_internal(dump, data, nal_size, pctx->has_svcc ? 1 : 0, pctx->hevc_state, pctx->avc_state, pctx->vvc_state, pctx->nalu_size_length, ctx->crc, pctx->is_cenc_protected, ctx->analyze, pctx);
 			}
 			idx++;
@@ -2858,7 +3002,7 @@
 			obu_size = gf_inspect_dump_obu_internal(dump, pctx->av1_state, (char *) data, obu_size, obu_type, obu_size, hdr_size, ctx->crc, pctx, ctx->analyze);
 
 			if (obu_size > size) {
-				gf_fprintf(dump, " \n", (u32) obu_size, size);
+				inspect_printf(dump, " \n", (u32) obu_size, size);
 				break;
 			}
 			data += obu_size;
@@ -2884,7 +3028,7 @@
 			while (size) {
 				hdr = gf_mp3_get_next_header_mem(data, size, &pos);
 				fsize = gf_mp3_frame_size(hdr);
-				gf_fprintf(dump, "<MPEGAudioFrame size=\"%d\" layer=\"%d\" version=\"%d\" bitrate=\"%d\" channels=\"%d\" samplesPerFrame=\"%d\" samplerate=\"%d\"/>\n", fsize, gf_mp3_layer(hdr), gf_mp3_version(hdr), gf_mp3_bit_rate(hdr), gf_mp3_num_channels(hdr), gf_mp3_window_size(hdr), gf_mp3_sampling_rate(hdr));
+				inspect_printf(dump, "<MPEGAudioFrame size=\"%d\" layer=\"%d\" version=\"%d\" bitrate=\"%d\" channels=\"%d\" samplesPerFrame=\"%d\" samplerate=\"%d\"/>\n", fsize, gf_mp3_layer(hdr), gf_mp3_version(hdr), gf_mp3_bit_rate(hdr), gf_mp3_num_channels(hdr), gf_mp3_window_size(hdr), gf_mp3_sampling_rate(hdr));
 				if (size<pos+fsize) break;
 				data += pos + fsize;
 				size -= pos + fsize;
@@ -2899,12 +3043,12 @@
 		case GF_CODECID_SUBS_XML:
 		case GF_CODECID_META_XML:
 			if (dflag)
-				gf_fprintf(dump, "<!CDATA");
+				inspect_printf(dump, "<!CDATA");
 			for (i=0; i<size; i++) {
 				gf_fputc(datai, dump);
 			}
 			if (dflag)
-				gf_fprintf(dump, ">\n");
+				inspect_printf(dump, ">\n");
 			break;
 		case GF_CODECID_APCH:
 		case GF_CODECID_APCO:
@@ -2937,21 +3081,51 @@
 			gf_bs_reassign_buffer(pctx->bs, data, size);
 			gf_inspect_dump_truehd_frame(dump, pctx->bs);
 			break;
+		case GF_CODECID_OPUS:
+			gf_inspect_dump_opus_internal(dump, data, size, 0, ctx->crc, pctx);
+			break;
+		case GF_CODECID_ALAC:
+		{
+			gf_bs_reassign_buffer(pctx->bs, data, size);
+			u32 val, partial;
+
+#define get_and_print(name, bits) \
+			val = gf_bs_read_int(pctx->bs, bits); \
+			inspect_printf(dump, " "name"=\"%u\"", val);
+
+			inspect_printf(dump, " <ALACSegment");
+
+			get_and_print("type", 3);
+			get_and_print("reserved", 12);
+			get_and_print("partial", 1);
+			partial=val;
+			get_and_print("shift_off", 2);
+			get_and_print("escape", 1);
+			if (partial) {
+				get_and_print("frameLength", 32);
+			}
+			inspect_printf(dump, "/>\n");
+
+#undef get_and_print
+
+		}
+			break;
+
 		}
 	}
 #endif
-	gf_fprintf(dump, "</Packet>\n");
+	inspect_printf(dump, "</Packet>\n");
 }
 
 #define DUMP_ARRAY(arr, name, loc, _is_svc)\
 	if (arr && gf_list_count(arr)) {\
-		gf_fprintf(dump, " <%sArray location=\"%s\">\n", name, loc);\
+		inspect_printf(dump, " <%sArray location=\"%s\">\n", name, loc);\
 		for (i=0; i<gf_list_count(arr); i++) {\
 			slc = gf_list_get(arr, i);\
-			gf_fprintf(dump, " <NALU size=\"%d\" ", slc->size);\
+			inspect_printf(dump, " <NALU size=\"%d\" ", slc->size);\
 			gf_inspect_dump_nalu_internal(dump, slc->data, slc->size, _is_svc, pctx->hevc_state, pctx->avc_state, pctx->vvc_state, nalh_size, ctx->crc, GF_FALSE, ctx->analyze, pctx);\
 		}\
-		gf_fprintf(dump, " </%sArray>\n", name);\
+		inspect_printf(dump, " </%sArray>\n", name);\
 	}\
 
 
@@ -2983,13 +3157,22 @@
 }
 #endif
 
-static void format_duration(u64 dur, u64 timescale, FILE *dump)
+static void format_duration(s64 dur, u64 timescale, FILE *dump)
 {
 	u32 h, m, s, ms;
-	if ((dur==(u64) -1) || (dur==(u32) -1)) {
-		gf_fprintf(dump, " duration unknown");
+	const char *name = "duration";
+	if (dur==-1) {
+		inspect_printf(dump, " duration unknown");
 		return;
 	}
+	//duration probing was disabled
+	if (!timescale)
+		return;
+	if (dur<0) {
+		dur = -dur;
+		name = "estimated duration";
+	}
+
 	dur = (u64) (( ((Double) (s64) dur)/timescale)*1000);
 	h = (u32) (dur / 3600000);
 	m = (u32) (dur/ 60000) - h*60;
@@ -2997,14 +3180,14 @@
 	ms = (u32) (dur) - h*3600000 - m*60000 - s*1000;
 	if (h<=24) {
 		if (h)
-			gf_fprintf(dump, " duration %02d:%02d:%02d.%03d", h, m, s, ms);
+			inspect_printf(dump, " %s %02d:%02d:%02d.%03d", name, h, m, s, ms);
 		else
-			gf_fprintf(dump, " duration %02d:%02d.%03d", m, s, ms);
+			inspect_printf(dump, " %s %02d:%02d.%03d", name, m, s, ms);
 	} else {
 		u32 d = (u32) (dur / 3600000 / 24);
 		h = (u32) (dur/3600000)-24*d;
 		if (d<=365) {
-			gf_fprintf(dump, " duration %d Days, %02d:%02d:%02d.%03d", d, h, m, s, ms);
+			inspect_printf(dump, " %s %d Days, %02d:%02d:%02d.%03d", name, d, h, m, s, ms);
 		} else {
 			u32 y=0;
 			while (d>365) {
@@ -3012,7 +3195,7 @@
 				d-=365;
 				if (y%4) d--;
 			}
-			gf_fprintf(dump, " duration %d Years %d Days, %02d:%02d:%02d.%03d", y, d, h, m, s, ms);
+			inspect_printf(dump, " %s %d Years %d Days, %02d:%02d:%02d.%03d", name, y, d, h, m, s, ms);
 		}
 	}
 }
@@ -3024,17 +3207,20 @@
 	Bool is_raw=GF_FALSE;
 	Bool is_protected=GF_FALSE;
 	u32 codec_id=0;
-	gf_fprintf(dump, "PID");
+
+	if (!ctx->dump_log && !dump) return;
+
+	inspect_printf(dump, "PID");
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ID);
 	if (!p) p = gf_filter_pid_get_property(pid, GF_PROP_PID_ESID);
-	if (p) gf_fprintf(dump, " %d", p->value.uint);
+	if (p) inspect_printf(dump, " %d", p->value.uint);
 
 	if (is_remove) {
-		gf_fprintf(dump, " removed\n");
+		inspect_printf(dump, " removed\n");
 		return;
 	}
 	if (!is_connect) {
-		gf_fprintf(dump, " reconfigure");
+		inspect_printf(dump, " reconfigure");
 	}
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
 	if (p) {
@@ -3043,42 +3229,42 @@
 			p = gf_filter_pid_get_property(pid, GF_PROP_PID_ORIG_STREAM_TYPE);
 		}
 		if (p)
-			gf_fprintf(dump, " %s", gf_stream_type_short_name(p->value.uint));
+			inspect_printf(dump, " %s", gf_stream_type_short_name(p->value.uint));
 	}
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_SERVICE_ID);
 	if (p) {
-		gf_fprintf(dump, " service %d", p->value.uint);
+		inspect_printf(dump, " service %d", p->value.uint);
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SERVICE_NAME);
-		if (p) gf_fprintf(dump, " \"%s\"", p->value.string);
+		if (p) inspect_printf(dump, " \"%s\"", p->value.string);
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SERVICE_PROVIDER);
-		if (p) gf_fprintf(dump, " (%s)", p->value.string);
+		if (p) inspect_printf(dump, " (%s)", p->value.string);
 	}
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DISABLED);
-	if (p && p->value.boolean) gf_fprintf(dump, " disabled");
+	if (p && p->value.boolean) inspect_printf(dump, " disabled");
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ISOM_TRACK_FLAGS);
 	if (p && p->value.uint) {
-		if (p->value.uint & (1<<1)) gf_fprintf(dump, " inMovie");
-		if (p->value.uint & (1<<2)) gf_fprintf(dump, " inPreview");
+		if (p->value.uint & (1<<1)) inspect_printf(dump, " inMovie");
+		if (p->value.uint & (1<<2)) inspect_printf(dump, " inPreview");
 	}
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_LANGUAGE);
-	if (p) gf_fprintf(dump, " language \"%s\"", p->value.string);
+	if (p && stricmp(p->value.string, "und")) inspect_printf(dump, " language \"%s\"", p->value.string);
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
-	if (p && (p->value.lfrac.num>0)) format_duration((u64) p->value.lfrac.num, (u32) p->value.lfrac.den, dump);
+	if (p) format_duration((s64) p->value.lfrac.num, (u32) p->value.lfrac.den, dump);
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
-	if (p) gf_fprintf(dump, " timescale %d", p->value.uint);
+	if (p) inspect_printf(dump, " timescale %d", p->value.uint);
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
-	if (p) gf_fprintf(dump, " delay "LLD, p->value.longsint);
+	if (p) inspect_printf(dump, " delay "LLD, p->value.longsint);
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
 	if (p) {
 		if (p->value.uint==GF_CODECID_RAW) {
 			is_raw = GF_TRUE;
-			gf_fprintf(dump, " raw");
+			inspect_printf(dump, " raw");
 		} else {
 			codec_id = p->value.uint;
 			//fprintf(dump, " codec \"%s\"", gf_codecid_name(codec_id));
@@ -3087,70 +3273,71 @@
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_WIDTH);
 	if (p) {
-		gf_fprintf(dump, " %dx", p->value.uint);
+		inspect_printf(dump, " %dx", p->value.uint);
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_HEIGHT);
-		gf_fprintf(dump, "%d", p ? p->value.uint : 0);
+		inspect_printf(dump, "%d", p ? p->value.uint : 0);
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_FPS);
 		if (p) {
 			u32 tscale = p->value.frac.num;
 			u32 sdur = p->value.frac.den;
 			gf_media_get_reduced_frame_rate(&tscale, &sdur);
-			gf_fprintf(dump, " fps %d", tscale);
-			if (sdur!=1) gf_fprintf(dump, "/%u", sdur);
+			inspect_printf(dump, " fps %d", tscale);
+			if (sdur!=1) inspect_printf(dump, "/%u", sdur);
 		}
 
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAR);
 		if (p && p->value.frac.num!=p->value.frac.den)
-			gf_fprintf(dump, " SAR %d/%u", p->value.frac.num, p->value.frac.den);
+			inspect_printf(dump, " SAR %d/%u", p->value.frac.num, p->value.frac.den);
 		else
-			gf_fprintf(dump, " SAR 1/1");
+			inspect_printf(dump, " SAR 1/1");
 		if (is_raw) {
 			p = gf_filter_pid_get_property(pid, GF_PROP_PID_PIXFMT);
-			if (p) gf_fprintf(dump, " raw format %s", gf_pixel_fmt_name(p->value.uint) );
+			if (p) inspect_printf(dump, " raw format %s", gf_pixel_fmt_name(p->value.uint) );
 		}
 	}
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAMPLE_RATE);
 	if (p) {
-		gf_fprintf(dump, " %d Hz", p->value.uint);
+		inspect_printf(dump, " %d Hz", p->value.uint);
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_CHANNEL_LAYOUT);
 		if (p) {
-			gf_fprintf(dump, " %s", gf_audio_fmt_get_layout_name(p->value.longuint));
+			inspect_printf(dump, " %s", gf_audio_fmt_get_layout_name(p->value.longuint));
 		} else {
 			p = gf_filter_pid_get_property(pid, GF_PROP_PID_NUM_CHANNELS);
-			if (p) gf_fprintf(dump, " %d channels", p->value.uint);
+			if (p) inspect_printf(dump, " %d channels", p->value.uint);
 		}
 		if (is_raw) {
 			p = gf_filter_pid_get_property(pid, GF_PROP_PID_AUDIO_FORMAT);
-			if (p) gf_fprintf(dump, " raw format %s", gf_audio_fmt_name(p->value.uint) );
+			if (p) inspect_printf(dump, " raw format %s", gf_audio_fmt_name(p->value.uint) );
 		}
 	}
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_BITRATE);
 	if (p) {
-		if (p->value.uint<5000) gf_fprintf(dump, " %d bps", p->value.uint );
-		else gf_fprintf(dump, " %d kbps", p->value.uint/1000 );
+		if (p->value.uint<5000) inspect_printf(dump, " %d bps", p->value.uint );
+		else inspect_printf(dump, " %d kbps", p->value.uint/1000 );
 	}
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_NB_FRAMES);
-	if (p && (p->value.uint>1)) gf_fprintf(dump, " %d frames", p->value.uint);
+	if (p && (p->value.uint>1)) inspect_printf(dump, " %d frames", p->value.uint);
 
 
 	if (is_protected) {
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_PROTECTION_SCHEME_TYPE);
-		gf_fprintf(dump, " encryption %s", p ? gf_4cc_to_str(p->value.uint) : "unknown");
+		inspect_printf(dump, " encryption %s", p ? gf_4cc_to_str(p->value.uint) : "unknown");
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_CENC_PATTERN);
 		if (p)
-			gf_fprintf(dump, " %d/%d pattern", p->value.frac.num, p->value.frac.den);
+			inspect_printf(dump, " %d/%d pattern", p->value.frac.num, p->value.frac.den);
 	}
 
 	dsi = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
 	dsi_enh = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT);
 	if (is_raw) {
-		gf_fprintf(dump, "\n");
+		inspect_printf(dump, "\n");
 		return;
 	}
 
-	gf_fprintf(dump, " codec");
+	inspect_printf(dump, " codec");
 
+#ifndef GPAC_DISABLE_AV_PARSERS
 	if ((codec_id==GF_CODECID_HEVC) || (codec_id==GF_CODECID_LHVC) || (codec_id==GF_CODECID_HEVC_TILES)) {
 		u32 i, j, k;
 		HEVCState *hvcs = NULL;
@@ -3171,21 +3358,21 @@
 		} else if (dsi_enh) {
 			hvcc = gf_odf_hevc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size, GF_TRUE);
 		}
-		gf_fprintf(dump, " %s", (codec_id==GF_CODECID_LHVC) ? "L-HEVC" : "HEVC");
-		if (codec_id==GF_CODECID_HEVC_TILES) gf_fprintf(dump, " tile");
+		inspect_printf(dump, " %s", (codec_id==GF_CODECID_LHVC) ? "L-HEVC" : "HEVC");
+		if (codec_id==GF_CODECID_HEVC_TILES) inspect_printf(dump, " tile");
 
 		if (hvcc) {
 			if (hvcc->interlaced_source_flag)
-				gf_fprintf(dump, " interlaced");
+				inspect_printf(dump, " interlaced");
 			if (!hvcc->is_lhvc) {
-				gf_fprintf(dump, " PL %s@%g %s %d bpp compatibility 0x%08X", gf_hevc_get_profile_name(hvcc->profile_idc), ((Double)hvcc->level_idc) / 30.0, gf_avc_hevc_get_chroma_format_name(hvcc->chromaFormat), hvcc->luma_bit_depth, hvcc->general_profile_compatibility_flags);
+				inspect_printf(dump, " PL %s@%g %s %d bpp compatibility 0x%08X", gf_hevc_get_profile_name(hvcc->profile_idc), ((Double)hvcc->level_idc) / 30.0, gf_avc_hevc_get_chroma_format_name(hvcc->chromaFormat), hvcc->luma_bit_depth, hvcc->general_profile_compatibility_flags);
 			}
 			gf_odf_hevc_cfg_del(hvcc);
 		}
 		if (dsi && dsi_enh) {
 			hvcc = gf_odf_hevc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size, GF_TRUE);
 			if (hvcc) {
-				gf_fprintf(dump, " scalable");
+				inspect_printf(dump, " scalable");
 				for (k=0; k<2; k++) {
 				u32 ntype = k ? GF_HEVC_NALU_SEQ_PARAM : GF_HEVC_NALU_VID_PARAM;
 				for (i=0; i<gf_list_count(hvcc->param_array); i++) {
@@ -3197,7 +3384,7 @@
 						s32 idx = gf_hevc_parse_nalu(sl->data, sl->size, hvcs, &nut, &tid, &lid);
 						if ((idx>=0) && (pa->type==GF_HEVC_NALU_SEQ_PARAM)) {
 							idx = hvcs->last_parsed_sps_id;
-							gf_fprintf(dump, " %dx%d", hvcs->spsidx.width, hvcs->spsidx.height);
+							inspect_printf(dump, " %dx%d", hvcs->spsidx.width, hvcs->spsidx.height);
 						}
 					}
 				}
@@ -3214,16 +3401,16 @@
 		} else if (dsi_enh) {
 			avcc = gf_odf_avc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size);
 		}
-		if (codec_id==GF_CODECID_AVC) gf_fprintf(dump, " %s", "AVC|H264");
-		else if (codec_id==GF_CODECID_SVC) gf_fprintf(dump, " %s", "SVC");
-		else if (codec_id==GF_CODECID_MVC) gf_fprintf(dump, " %s", "MVC");
+		if (codec_id==GF_CODECID_AVC) inspect_printf(dump, " %s", "AVC|H264");
+		else if (codec_id==GF_CODECID_SVC) inspect_printf(dump, " %s", "SVC");
+		else if (codec_id==GF_CODECID_MVC) inspect_printf(dump, " %s", "MVC");
 
 		if (avcc) {
-			gf_fprintf(dump, " PL %s@%g %s %d bpp", gf_avc_get_profile_name(avcc->AVCProfileIndication), ((Double)avcc->AVCLevelIndication)/10.0, gf_avc_hevc_get_chroma_format_name(avcc->chroma_format), avcc->luma_bit_depth );
+			inspect_printf(dump, " PL %s@%g %s %d bpp", gf_avc_get_profile_name(avcc->AVCProfileIndication), ((Double)avcc->AVCLevelIndication)/10.0, gf_avc_hevc_get_chroma_format_name(avcc->chroma_format), avcc->luma_bit_depth );
 			gf_odf_avc_cfg_del(avcc);
 		}
 		if (dsi && dsi_enh) {
-			gf_fprintf(dump, " scalable");
+			inspect_printf(dump, " scalable");
 			avcc = gf_odf_avc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size);
 			if (avcc) {
 				AVCState *avcs;
@@ -3231,7 +3418,7 @@
 				for (u32 i=0; i<gf_list_count(avcc->sequenceParameterSets); i++) {
 					GF_NALUFFParam *sl = gf_list_get(avcc->sequenceParameterSets, i);
 					s32 idx = gf_avc_read_sps(sl->data, sl->size, avcs, 0, NULL);
-					if (idx>=0) gf_fprintf(dump, " %dx%d", avcs->spsidx.width, avcs->spsidx.height);
+					if (idx>=0) inspect_printf(dump, " %dx%d", avcs->spsidx.width, avcs->spsidx.height);
 				}
 				gf_free(avcs);
 				gf_odf_avc_cfg_del(avcc);
@@ -3245,12 +3432,12 @@
 		} else if (dsi_enh) {
 			vvcc = gf_odf_vvc_cfg_read(dsi_enh->value.data.ptr, dsi_enh->value.data.size);
 		}
-		if (codec_id==GF_CODECID_VVC) gf_fprintf(dump, " VVC%s", (codec_id==GF_CODECID_VVC) ? "" : " subpictures");
+		if (codec_id==GF_CODECID_VVC) inspect_printf(dump, " VVC%s", (codec_id==GF_CODECID_VVC) ? "" : " subpictures");
 
 		if (vvcc) {
-			gf_fprintf(dump, " PL %s@%.1g %s %d bpp", gf_vvc_get_profile_name(vvcc->general_profile_idc), ((Double)vvcc->general_level_idc)/16.0, gf_avc_hevc_get_chroma_format_name(vvcc->chroma_format), vvcc->bit_depth );
+			inspect_printf(dump, " PL %s@%.1g %s %d bpp", gf_vvc_get_profile_name(vvcc->general_profile_idc), ((Double)vvcc->general_level_idc)/16.0, gf_avc_hevc_get_chroma_format_name(vvcc->chroma_format), vvcc->bit_depth );
 			if (vvcc->numTemporalLayers>1)
-			gf_fprintf(dump, " %d sublayers", vvcc->numTemporalLayers);
+			inspect_printf(dump, " %d sublayers", vvcc->numTemporalLayers);
 
 			gf_odf_vvc_cfg_del(vvcc);
 		}
@@ -3259,15 +3446,15 @@
 		GF_AV1Config *av1c = NULL;
 		if (dsi)
 			av1c = gf_odf_av1_cfg_read(dsi->value.data.ptr, dsi->value.data.size);
-		gf_fprintf(dump, " AV1");
+		inspect_printf(dump, " AV1");
 		if (av1c) {
-			gf_fprintf(dump, " PL %d@%d", av1c->seq_profile, av1c->seq_level_idx_0);
+			inspect_printf(dump, " PL %d@%d", av1c->seq_profile, av1c->seq_level_idx_0);
 			if (av1c->chroma_subsampling_x) {
-				if (av1c->chroma_subsampling_y) gf_fprintf(dump, " YUV 4:2:0");
-				else gf_fprintf(dump, " YUV 4:2:2");
-			} else gf_fprintf(dump, " YUV 4:4:4");
-			if (av1c->monochrome) gf_fprintf(dump, " monochrome");
-			if (av1c->twelve_bit) gf_fprintf(dump, " 12 bpp");
+				if (av1c->chroma_subsampling_y) inspect_printf(dump, " YUV 4:2:0");
+				else inspect_printf(dump, " YUV 4:2:2");
+			} else inspect_printf(dump, " YUV 4:4:4");
+			if (av1c->monochrome) inspect_printf(dump, " monochrome");
+			if (av1c->twelve_bit) inspect_printf(dump, " 12 bpp");
 
 			gf_odf_av1_cfg_del(av1c);
 		}
@@ -3293,42 +3480,44 @@
 			sep = strstr(name, "Audio");
 			if (sep) name = sep+6;
 
-			gf_fprintf(dump, " %s (aot=%d %s)%s", name, a_cfg.base_object_type, signaling, heaac);
-			if (a_cfg.has_sbr) gf_fprintf(dump, " SBR %d Hz aot %s", a_cfg.sbr_sr, gf_m4a_object_type_name(a_cfg.sbr_object_type));
-			if (a_cfg.has_ps) gf_fprintf(dump, " PS");
+			inspect_printf(dump, " %s (aot=%d %s)%s", name, a_cfg.base_object_type, signaling, heaac);
+			if (a_cfg.has_sbr) inspect_printf(dump, " SBR %d Hz aot %s", a_cfg.sbr_sr, gf_m4a_object_type_name(a_cfg.sbr_object_type));
+			if (a_cfg.has_ps) inspect_printf(dump, " PS");
 		} else {
-			gf_fprintf(dump, " AAC");
+			inspect_printf(dump, " AAC");
 		}
 	} else if (codec_id==GF_CODECID_MPEG4_PART2) {
-		gf_fprintf(dump, " MPEG-4 Visual");
+		inspect_printf(dump, " MPEG-4 Visual");
 		if (dsi) {
 			GF_M4VDecSpecInfo vcfg;
 			gf_m4v_get_config(dsi->value.data.ptr, dsi->value.data.size, &vcfg);
-			gf_fprintf(dump, " PL %s", gf_m4v_get_profile_name(vcfg.VideoPL));
-			if (vcfg.chroma_fmt) gf_fprintf(dump, " %s", gf_avc_hevc_get_chroma_format_name(vcfg.chroma_fmt) );
-			if (!vcfg.progresive) gf_fprintf(dump, " interlaced");
-		}
-	} else {
+			inspect_printf(dump, " PL %s", gf_m4v_get_profile_name(vcfg.VideoPL));
+			if (vcfg.chroma_fmt) inspect_printf(dump, " %s", gf_avc_hevc_get_chroma_format_name(vcfg.chroma_fmt) );
+			if (!vcfg.progresive) inspect_printf(dump, " interlaced");
+		}
+	} else
+#endif//GPAC_DISABLE_AV_PARSERS
+	{
 		if (codec_id==GF_CODECID_FFMPEG) {
-			p = gf_filter_pid_get_property_str(pid, "ffmpeg:codec");
+			p = gf_filter_pid_get_property(pid, GF_PROP_PID_META_DEMUX_CODEC_NAME);
 			if (p) {
-				gf_fprintf(dump, " %s", p->value.string);
+				inspect_printf(dump, " %s", p->value.string);
 			} else {
-				p = gf_filter_pid_get_property(pid, GF_PROP_PID_FFMPEG_CODEC_ID);
+				p = gf_filter_pid_get_property(pid, GF_PROP_PID_META_DEMUX_CODEC_ID);
 				if (p && (p->type==GF_PROP_UINT)) codec_id = p->value.uint;
-				gf_fprintf(dump, " FFMPEG %d", codec_id);
+				inspect_printf(dump, " FFMPEG %d", codec_id);
 			}
 		} else {
-			gf_fprintf(dump, " %s", gf_codecid_name(codec_id));
+			inspect_printf(dump, " %s", gf_codecid_name(codec_id));
 		}
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_PROFILE_LEVEL);
-		if (p) gf_fprintf(dump, " PL %d", p->value.uint);
+		if (p) inspect_printf(dump, " PL %d", p->value.uint);
 
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_CHROMAFMT);
-		if (p) gf_fprintf(dump, " %s", gf_avc_hevc_get_chroma_format_name(p->value.uint) );
+		if (p) inspect_printf(dump, " %s", gf_avc_hevc_get_chroma_format_name(p->value.uint) );
 
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_INTERLACED);
-		if (p && p->value.boolean) gf_fprintf(dump, " interlaced");
+		if (p && p->value.boolean) inspect_printf(dump, " interlaced");
 	}
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CLAP_W);
@@ -3340,7 +3529,7 @@
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CLAP_Y);
 	s32 clap_y = p ? p->value.sint : 0;
 	if (clap_w && clap_h) {
-		gf_fprintf(dump, " clap %dx%d@%ux%u", clap_x, clap_y, clap_w, clap_h);
+		inspect_printf(dump, " clap %dx%d@%ux%u", clap_x, clap_y, clap_w, clap_h);
 	}
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DOLBY_VISION);
 	if (p) {
@@ -3348,16 +3537,25 @@
 		GF_DOVIDecoderConfigurationRecord *dovi = gf_odf_dovi_cfg_read_bs(bs);
 		gf_bs_del(bs);
 		if (dovi) {
-			gf_fprintf(dump, " DolbyVision %d.%d PL %d@%d",
+			inspect_printf(dump, " DolbyVision %d.%d PL %d@%d",
 				dovi->dv_version_major, dovi->dv_version_minor, dovi->dv_profile, dovi->dv_level);
-			if (dovi->rpu_present_flag) gf_fprintf(dump, " rpu");
-			if (dovi->bl_present_flag) gf_fprintf(dump, " base");
-			if (dovi->el_present_flag) gf_fprintf(dump, " el");
-			if (dovi->dv_bl_signal_compatibility_id) gf_fprintf(dump, " compat %d", dovi->dv_bl_signal_compatibility_id);
+			if (dovi->rpu_present_flag) inspect_printf(dump, " rpu");
+			if (dovi->bl_present_flag) inspect_printf(dump, " base");
+			if (dovi->el_present_flag) inspect_printf(dump, " el");
+			if (dovi->dv_bl_signal_compatibility_id) inspect_printf(dump, " compatID %d", dovi->dv_bl_signal_compatibility_id);
 			gf_odf_dovi_cfg_del(dovi);
 		}
 	}
-	gf_fprintf(dump, "\n");
+
+	if (dsi && (codec_id==GF_CODECID_EAC3)) {
+		GF_AC3Config ac3cfg;
+		gf_odf_ac3_config_parse(dsi->value.data.ptr, dsi->value.data.size, GF_TRUE, &ac3cfg);
+		if (ac3cfg.atmos_ec3_ext)
+			inspect_printf(dump, " Atmos (CIT %d)", ac3cfg.complexity_index_type);
+	}
+
+
+	inspect_printf(dump, "\n");
 }
 
 static void inspect_dump_pid(GF_InspectCtx *ctx, FILE *dump, GF_FilterPid *pid, u32 pid_idx, Bool is_connect, Bool is_remove, u64 pck_for_config, Bool is_info, PidCtx *pctx)
@@ -3374,8 +3572,8 @@
 	char *elt_name = NULL;
 	const GF_PropertyValue *p, *dsi, *dsi_enh;
 
-	if (!ctx->dump) return;
 	if (ctx->test==INSPECT_TEST_NOPROP) return;
+	if (!ctx->dump_log && !dump) return;
 
 	if (!ctx->full) {
 		inspect_dump_pid_as_info(ctx, dump, pid, pid_idx, is_connect, is_remove, pck_for_config, is_info, pctx);
@@ -3391,20 +3589,20 @@
 		} else {
 			elt_name = is_connect ? "PIDConfigure" : "PIDReconfigure";
 		}
-		gf_fprintf(dump, "<%s PID=\"%d\" name=\"%s\"",elt_name, pid_idx, gf_filter_pid_get_name(pid) );
+		inspect_printf(dump, "<%s PID=\"%d\" name=\"%s\"",elt_name, pid_idx, gf_filter_pid_get_name(pid) );
 
 		if (pck_for_config)
-			gf_fprintf(dump, " packetsSinceLastConfig=\""LLU"\"", pck_for_config);
+			inspect_printf(dump, " packetsSinceLastConfig=\""LLU"\"", pck_for_config);
 	} else {
 		if (is_info) {
-			gf_fprintf(dump, "PID %d name %s info update\n", pid_idx, gf_filter_pid_get_name(pid) );
+			inspect_printf(dump, "PID %d name %s info update\n", pid_idx, gf_filter_pid_get_name(pid) );
 		} else if (is_remove) {
-			gf_fprintf(dump, "PID %d name %s delete\n", pid_idx, gf_filter_pid_get_name(pid) );
+			inspect_printf(dump, "PID %d name %s delete\n", pid_idx, gf_filter_pid_get_name(pid) );
 		} else {
-			gf_fprintf(dump, "PID %d name %s %sonfigure", pid_idx, gf_filter_pid_get_name(pid), is_connect ? "C" : "Rec" );
+			inspect_printf(dump, "PID %d name %s %sonfigure", pid_idx, gf_filter_pid_get_name(pid), is_connect ? "C" : "Rec" );
 			if (pck_for_config)
-				gf_fprintf(dump, " after "LLU" packets", pck_for_config);
-			gf_fprintf(dump, " - properties:\n");
+				inspect_printf(dump, " after "LLU" packets", pck_for_config);
+			inspect_printf(dump, " - properties:\n");
 		}
 	}
 
@@ -3438,14 +3636,14 @@
 
 	if (!ctx->analyze) {
 		if (ctx->xml) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		}
 		return;
 	}
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
 	if (!p) {
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 		return;
 	}
 	pctx->codec_id = p->value.uint;
@@ -3467,7 +3665,7 @@
 	case GF_CODECID_AVC:
 	case GF_CODECID_AVC_PS:
 		if (!dsi && !dsi_enh) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 #ifndef GPAC_DISABLE_AV_PARSERS
@@ -3478,8 +3676,8 @@
 			if (!pctx->avc_state) return;
 		}
 #endif
-		gf_fprintf(dump, ">\n");
-		gf_fprintf(dump, "<AVCParameterSets>\n");
+		inspect_printf(dump, ">\n");
+		inspect_printf(dump, "<AVCParameterSets>\n");
 		if (dsi) {
 			if (is_enh) {
 				svcc = gf_odf_avc_cfg_read(dsi->value.data.ptr, dsi->value.data.size);
@@ -3510,14 +3708,14 @@
 			pctx->has_svcc = 1;
 		}
 #endif
-		gf_fprintf(dump, "</AVCParameterSets>\n");
+		inspect_printf(dump, "</AVCParameterSets>\n");
 		break;
 	case GF_CODECID_LHVC:
 		is_enh = GF_TRUE;
 	case GF_CODECID_HEVC:
 	case GF_CODECID_HEVC_TILES:
 		if (!dsi && !dsi_enh) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 
@@ -3548,8 +3746,8 @@
 		}
 		nalh_size = pctx->nalu_size_length;
 
-		gf_fprintf(dump, ">\n");
-		gf_fprintf(dump, "<HEVCParameterSets>\n");
+		inspect_printf(dump, ">\n");
+		inspect_printf(dump, "<HEVCParameterSets>\n");
 #ifndef GPAC_DISABLE_AV_PARSERS
 		if (hvcc) {
 			for (idx=0; idx<gf_list_count(hvcc->param_array); idx++) {
@@ -3580,13 +3778,13 @@
 			}
 		}
 #endif
-		gf_fprintf(dump, "</HEVCParameterSets>\n");
+		inspect_printf(dump, "</HEVCParameterSets>\n");
 		break;
 
 	case GF_CODECID_VVC:
 	case GF_CODECID_VVC_SUBPIC:
 		if (!dsi) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 
@@ -3605,8 +3803,8 @@
 
 		nalh_size = pctx->nalu_size_length;
 
-		gf_fprintf(dump, ">\n");
-		gf_fprintf(dump, "<VVCParameterSets>\n");
+		inspect_printf(dump, ">\n");
+		inspect_printf(dump, "<VVCParameterSets>\n");
 #ifndef GPAC_DISABLE_AV_PARSERS
 		if (vvcC) {
 			for (idx=0; idx<gf_list_count(vvcC->param_array); idx++) {
@@ -3629,7 +3827,7 @@
 			}
 		}
 #endif
-		gf_fprintf(dump, "</VVCParameterSets>\n");
+		inspect_printf(dump, "</VVCParameterSets>\n");
 		break;
 
 	case GF_CODECID_AV1:
@@ -3642,14 +3840,14 @@
 		}
 #endif
 		if (!dsi) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 #ifndef GPAC_DISABLE_AV_PARSERS
 		if (pctx->av1_state->config) gf_odf_av1_cfg_del(pctx->av1_state->config);
 		pctx->av1_state->config = gf_odf_av1_cfg_read(dsi->value.data.ptr, dsi->value.data.size);
-		gf_fprintf(dump, ">\n");
-		gf_fprintf(dump, " <OBUConfig>\n");
+		inspect_printf(dump, ">\n");
+		inspect_printf(dump, " <OBUConfig>\n");
 
 		idx = 1;
 		for (i=0; i<gf_list_count(pctx->av1_state->config->obu_array); i++) {
@@ -3667,7 +3865,7 @@
 			idx++;
 		}
 #endif
-		gf_fprintf(dump, " </OBUConfig>\n");
+		inspect_printf(dump, " </OBUConfig>\n");
 		break;
 
 	case GF_CODECID_MPEG1:
@@ -3681,15 +3879,15 @@
 		inspect_reset_parsers(pctx, &pctx->mv124_state);
 #endif
 		if (!dsi) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
-		gf_fprintf(dump, ">\n");
-		gf_fprintf(dump, " <MPEGVideoConfig>\n");
+		inspect_printf(dump, ">\n");
+		inspect_printf(dump, " <MPEGVideoConfig>\n");
 #ifndef GPAC_DISABLE_AV_PARSERS
 		inspect_dump_mpeg124(pctx, dsi->value.data.ptr, dsi->value.data.size, dump);
 #endif
-		gf_fprintf(dump, " </MPEGVideoConfig>\n");
+		inspect_printf(dump, " </MPEGVideoConfig>\n");
 #ifndef GPAC_DISABLE_AV_PARSERS
 		if (pctx->mv124_state) gf_m4v_parser_del(pctx->mv124_state);
 #endif
@@ -3698,33 +3896,33 @@
 	case GF_CODECID_MPEG2_PART3:
 	case GF_CODECID_MPEG_AUDIO_L1:
 	case GF_CODECID_TMCD:
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 		return;
 	case GF_CODECID_SUBS_XML:
 	case GF_CODECID_META_XML:
 		if (!dsi) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
-		gf_fprintf(dump, " <XMLTextConfig>\n");
+		inspect_printf(dump, " <XMLTextConfig>\n");
 		for (i=0; i<dsi->value.data.size; i++) {
 			gf_fputc(dsi->value.data.ptri, dump);
 		}
-		gf_fprintf(dump, "\n </XMLTextConfig>\n");
+		inspect_printf(dump, "\n </XMLTextConfig>\n");
 		break;
 	case GF_CODECID_SUBS_TEXT:
 	case GF_CODECID_META_TEXT:
 		if (!dsi) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
-		gf_fprintf(dump, " <TextConfig>\n");
-		gf_fprintf(dump, "<!CDATA");
+		inspect_printf(dump, " <TextConfig>\n");
+		inspect_printf(dump, "<!CDATA");
 		for (i=0; i<dsi->value.data.size; i++) {
 			gf_fputc(dsi->value.data.ptri, dump);
 		}
-		gf_fprintf(dump, ">\n");
-		gf_fprintf(dump, " </TextConfig>\n");
+		inspect_printf(dump, ">\n");
+		inspect_printf(dump, " </TextConfig>\n");
 		break;
 	case GF_CODECID_APCH:
 	case GF_CODECID_APCN:
@@ -3732,12 +3930,12 @@
 	case GF_CODECID_APCO:
 	case GF_CODECID_AP4H:
 	case GF_CODECID_AP4X:
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 		return;
 	case GF_CODECID_MPHA:
 	case GF_CODECID_MHAS:
 		if (!dsi) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 		{
@@ -3747,27 +3945,27 @@
 		else
 			gf_bs_reassign_buffer(pctx->bs, dsi->value.data.ptr, dsi->value.data.size);
 
-		gf_fprintf(dump, " <MPEGHAudioConfig");
-		gf_fprintf(dump, " version=\"%d\"", gf_bs_read_u8(pctx->bs) );
-		gf_fprintf(dump, " ProfileLevelIndication=\"%d\"", gf_bs_read_u8(pctx->bs) );
-		gf_fprintf(dump, " ReferenceChannelLayout=\"%d\"", gf_bs_read_u8(pctx->bs) );
+		inspect_printf(dump, " <MPEGHAudioConfig");
+		inspect_printf(dump, " version=\"%d\"", gf_bs_read_u8(pctx->bs) );
+		inspect_printf(dump, " ProfileLevelIndication=\"%d\"", gf_bs_read_u8(pctx->bs) );
+		inspect_printf(dump, " ReferenceChannelLayout=\"%d\"", gf_bs_read_u8(pctx->bs) );
 		size = gf_bs_read_u16(pctx->bs);
 		if (size) {
-			gf_fprintf(dump, ">\n");
+			inspect_printf(dump, ">\n");
 #ifndef GPAC_DISABLE_AV_PARSERS
 			dump_mha_config(dump, pctx->bs, " ");
 #endif
-			gf_fprintf(dump, " </MPEGHAudioConfig>\n");
+			inspect_printf(dump, " </MPEGHAudioConfig>\n");
 		} else {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		}
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 		}
 		break;
 	case GF_CODECID_VP8:
 	case GF_CODECID_VP9:
 		if (!dsi) {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 
@@ -3776,19 +3974,19 @@
 #endif
 
 		pctx->vpcc = gf_odf_vp_cfg_read(dsi->value.data.ptr, dsi->value.data.size);
-		gf_fprintf(dump, ">\n");
+		inspect_printf(dump, ">\n");
 		if (pctx->vpcc) {
 			u32 v = (pctx->codec_id==GF_CODECID_VP9) ? 9 : 8;
-			gf_fprintf(dump, "<VP%dConfiguration profile=\"%d\" level=\"%d\" bit_depth=\"%u\" chroma_subsampling=\"%u\" colour_primaries=\"%u\" transfer_characteristics=\"%u\" matrix_coefficients=\"%u\" video_full_range=\"%u\"", v,
+			inspect_printf(dump, "<VP%dConfiguration profile=\"%d\" level=\"%d\" bit_depth=\"%u\" chroma_subsampling=\"%u\" colour_primaries=\"%u\" transfer_characteristics=\"%u\" matrix_coefficients=\"%u\" video_full_range=\"%u\"", v,
 				pctx->vpcc->profile, pctx->vpcc->level, pctx->vpcc->bit_depth, pctx->vpcc->chroma_subsampling, pctx->vpcc->colour_primaries, pctx->vpcc->transfer_characteristics, pctx->vpcc->matrix_coefficients, pctx->vpcc->video_fullRange_flag
 			);
 			if (pctx->vpcc->codec_initdata && pctx->vpcc->codec_initdata_size) {
-				gf_fprintf(dump, " init_data=\"");
+				inspect_printf(dump, " init_data=\"");
 				for (idx=0; idx<pctx->vpcc->codec_initdata_size; idx++)
-					gf_fprintf(dump, "%02X", (unsigned char) pctx->vpcc->codec_initdataidx);
-				gf_fprintf(dump, "\"");
+					inspect_printf(dump, "%02X", (unsigned char) pctx->vpcc->codec_initdataidx);
+				inspect_printf(dump, "\"");
 			}
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		}
 		break;
 
@@ -3806,8 +4004,8 @@
 			GF_M4ADecSpecInfo acfg;
 			InspectLogCbk lcbk;
 
-			gf_fprintf(dump, ">\n");
-			gf_fprintf(dump, "<MPEG4AudioConfiguration ");
+			inspect_printf(dump, ">\n");
+			inspect_printf(dump, "<MPEG4AudioConfiguration ");
 
 			if (!pctx->bs)
 				pctx->bs = gf_bs_new(dsi->value.data.ptr, dsi->value.data.size, GF_BITSTREAM_READ);
@@ -3822,31 +4020,31 @@
 
 			gf_m4a_parse_config(pctx->bs, &acfg, GF_TRUE);
 			if (ctx->analyze<INSPECT_ANALYZE_BS) {
-				gf_fprintf(dump, "base_object_type=\"%u\" sample_rate=\"%u\" channels=\"%u\" ", acfg.base_object_type, acfg.base_sr, acfg.nb_chan);
+				inspect_printf(dump, "base_object_type=\"%u\" sample_rate=\"%u\" channels=\"%u\" ", acfg.base_object_type, acfg.base_sr, acfg.nb_chan);
 				if (acfg.has_sbr)
-					gf_fprintf(dump, "sbr_sample_rate=\"%u\" ", acfg.sbr_sr);
+					inspect_printf(dump, "sbr_sample_rate=\"%u\" ", acfg.sbr_sr);
 				if (acfg.has_ps)
-					gf_fprintf(dump, "parametricStereo=\"yes\" ");
+					inspect_printf(dump, "parametricStereo=\"yes\" ");
 			}
 			if (acfg.comments0)
-				gf_fprintf(dump, "comments=\"%s\" ", acfg.comments);
+				inspect_printf(dump, "comments=\"%s\" ", acfg.comments);
 #endif /*GPAC_DISABLE_AV_PARSERS*/
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 		} else {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 		break;
 	case GF_CODECID_AC3:
 	case GF_CODECID_EAC3:
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 		return;
 
 	case GF_CODECID_TRUEHD:
 		if (dsi) {
 			u16 fmt, prate;
-			gf_fprintf(dump, ">\n");
-			gf_fprintf(dump, "<TrueHDAudioConfiguration");
+			inspect_printf(dump, ">\n");
+			inspect_printf(dump, "<TrueHDAudioConfiguration");
 
 			if (!pctx->bs)
 				pctx->bs = gf_bs_new(dsi->value.data.ptr, dsi->value.data.size, GF_BITSTREAM_READ);
@@ -3856,9 +4054,79 @@
 			fmt = gf_bs_read_u32(pctx->bs);
 			prate = gf_bs_read_int(pctx->bs, 15);
 
-			gf_fprintf(dump, " format=\"%u\" peak_data_rate=\"%u\"/>\n", fmt, prate);
+			inspect_printf(dump, " format=\"%u\" peak_data_rate=\"%u\"/>\n", fmt, prate);
+		} else {
+			inspect_printf(dump, "/>\n");
+			return;
+		}
+		break;
+
+	case GF_CODECID_OPUS:
+		if (dsi) {
+			GF_OpusConfig opcfg;
+			inspect_printf(dump, ">\n");
+			inspect_printf(dump, "<OpusConfiguration");
+			gf_odf_opus_cfg_parse(dsi->value.data.ptr, dsi->value.data.size, &opcfg);
+
+			inspect_printf(dump, " version=\"%d\" OutputChannelCount=\"%d\" PreSkip=\"%d\" InputSampleRate=\"%d\" OutputGain=\"%d\" ChannelMappingFamily=\"%d\"",
+					opcfg.version, opcfg.OutputChannelCount, opcfg.PreSkip, opcfg.InputSampleRate, opcfg.OutputGain, opcfg.ChannelMappingFamily);
+			if (opcfg.ChannelMappingFamily) {
+				inspect_printf(dump, " StreamCount=\"%d\" CoupledStreamCount=\"%d\" channelMapping=\"", opcfg.StreamCount, opcfg.CoupledCount);
+				for (i=0; i<opcfg.OutputChannelCount; i++) {
+					inspect_printf(dump, "%s%d", i ? " " : "", opcfg.ChannelMappingi);
+				}
+				inspect_printf(dump, "\"");
+			}
+			pctx->opus_channel_count = opcfg.StreamCount;
+			pctx->opus_channel_count = (opcfg.StreamCount ? opcfg.StreamCount : 1);
+			inspect_printf(dump, "/>\n");
+		} else {
+			inspect_printf(dump, "/>\n");
+			return;
+		}
+		break;
+
+	case GF_CODECID_ALAC:
+		if (dsi) {
+			GF_BitStream *bs = gf_bs_new(dsi->value.data.ptr, dsi->value.data.size, GF_BITSTREAM_READ);
+			inspect_printf(dump, ">\n");
+			inspect_printf(dump, "<ALACConfiguration");
+			while (gf_bs_available(bs)) {
+				u32 val;
+
+#define get_and_print(name, bits) \
+				val = gf_bs_read_int(bs, bits); \
+				inspect_printf(dump, " "name"=\"%u\"", val);
+
+				u32 size = gf_bs_read_u32(bs);
+				u32 type = gf_bs_read_u32(bs);
+				if (type==GF_4CC('a','l','a','c') && (size==36)) {
+
+					get_and_print("version", 32)
+					get_and_print("frameLength", 32)
+					get_and_print("compatibleVersion", 8)
+					get_and_print("bitDepth", 8)
+					get_and_print("pb", 8)
+					get_and_print("mb", 8)
+					get_and_print("kb", 8)
+					get_and_print("numChannels", 8)
+					get_and_print("maxRun", 16)
+					get_and_print("maxFrameBytes", 32)
+					get_and_print("avgBitRate", 32)
+					get_and_print("sampleRate", 32)
+				} else if (type==GF_4CC('c','h','a','n') && (size==24)) {
+					get_and_print("version", 32)
+					get_and_print("channelLayoutTag", 32)
+					get_and_print("reserved1", 32)
+					get_and_print("reserved2", 32)
+				}
+			}
+#undef get_and_print
+
+			inspect_printf(dump, "/>\n");
+			gf_bs_del(bs);
 		} else {
-			gf_fprintf(dump, "/>\n");
+			inspect_printf(dump, "/>\n");
 			return;
 		}
 		break;
@@ -3868,7 +4136,7 @@
 			pctx->no_analysis = GF_TRUE;
 			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Inspect bitstream analysis for codec %s not supported\n", gf_codecid_name(pctx->codec_id)));
 		}
-		gf_fprintf(dump, "/>\n");
+		inspect_printf(dump, "/>\n");
 		return;
 	}
 
@@ -3877,7 +4145,7 @@
 	if (hvcc) gf_odf_hevc_cfg_del(hvcc);
 	if (lhcc) gf_odf_hevc_cfg_del(lhcc);
 	if (vvcC) gf_odf_vvc_cfg_del(vvcC);
-	gf_fprintf(dump, "</%s>\n", elt_name);
+	inspect_printf(dump, "</%s>\n", elt_name);
 }
 
 static GF_Err inspect_process(GF_Filter *filter)
@@ -3926,14 +4194,31 @@
 		if (pctx->aborted)
 			continue;
 
-		if (!pctx->buffer_done) {
-			if (pck && !ctx->has_seen_eos) {
-				u64 dur = gf_filter_pid_query_buffer_duration(pctx->src_pid, GF_FALSE);
-				if ((dur < ctx->buffer * 1000) && !gf_filter_pid_has_seen_eos(pctx->src_pid)) {
+		if (!pctx->buffer_done || ctx->rbuffer) {
+			u64 dur=0;
+			if (pck && !ctx->has_seen_eos && !gf_filter_pid_eos_received(pctx->src_pid)) {
+				dur = gf_filter_pid_query_buffer_duration(pctx->src_pid, GF_FALSE);
+				if (!pctx->buffer_done) {
+					if ((dur < ctx->buffer * 1000)) {
+						GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("Inspect PID %d buffering buffer %u ms %.02f %%\n", pctx->idx, (u32) (dur/1000), dur*1.0/(ctx->buffer * 10.0)));
+						continue;
+					}
+				} else if (ctx->rbuffer && (dur < ctx->rbuffer * 1000)) {
+					pctx->buffer_done = GF_FALSE;
+					pctx->buf_start_time = gf_sys_clock();
+					GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Inspect PID %d rebuffering buffer %u ms less than rebuffer %u\n", pctx->idx, (u32) (dur/1000), ctx->rbuffer));
 					continue;
 				}
 			}
-			pctx->buffer_done = GF_TRUE;
+			if (!pctx->buffer_done) {
+				if (!dur) {
+					dur = gf_filter_pid_query_buffer_duration(pctx->src_pid, GF_FALSE);
+					GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Inspect PID %d buffering aborted after %u ms - level %u ms %.02f %%\n", pctx->idx, gf_sys_clock() - pctx->buf_start_time, (u32) (dur/1000), dur*1.0/(ctx->buffer * 10.0)));
+				} else {
+					GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Inspect PID %d buffering done in %u ms - level %u ms %.02f %%\n", pctx->idx, gf_sys_clock() - pctx->buf_start_time, (u32) (dur/1000), dur*1.0/(ctx->buffer * 10.0)));
+				}
+				pctx->buffer_done = GF_TRUE;
+			}
 		}
 
 		if (pctx->dump_pid) {
@@ -3946,7 +4231,7 @@
 				ctx->hdr_done=GF_TRUE;
 				//dump header on main output file, not on pid one!
 				if (ctx->hdr && ctx->fmt && !ctx->xml)
-					inspect_dump_packet_fmt(ctx, ctx->dump, NULL, 0, 0);
+					inspect_dump_packet_fmt(filter, ctx, ctx->dump, NULL, 0, 0);
 			}
 		}
 		if (!pck) continue;
@@ -3959,9 +4244,8 @@
 			if (ctx->is_prober) {
 				nb_done++;
 			} else {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("Inspect PID %d (codec %s) dump packet CTS "LLU"\n", pctx->idx, gf_codecid_name(pctx->codec_id), gf_filter_pck_get_cts(pck) ));
 				if (ctx->fmt) {
-					inspect_dump_packet_fmt(ctx, pctx->tmp, pck, pctx, pctx->pck_num);
+					inspect_dump_packet_fmt(filter, ctx, pctx->tmp, pck, pctx, pctx->pck_num);
 				} else {
 					inspect_dump_packet(ctx, pctx->tmp, pck, pctx->idx, pctx->pck_num, pctx);
 				}
@@ -4029,14 +4313,6 @@
 	if (!pctx) return GF_OUT_OF_MEM;
 	if (ctx->analyze)
 		pctx->bs = gf_bs_new((u8 *)pctx, 0, GF_BITSTREAM_READ);
-	if (!ctx->buffer) {
-		pctx->buffer_done = GF_TRUE;
-	} else {
-		GF_FEVT_INIT(evt, GF_FEVT_BUFFER_REQ, pid);
-		evt.buffer_req.max_buffer_us = ctx->buffer * 1000;
-		evt.buffer_req.pid_only = GF_TRUE;
-		gf_filter_pid_send_event(pid, &evt);
-	}
 
 	pctx->src_pid = pid;
 	gf_filter_pid_set_udta(pid, pctx);
@@ -4047,6 +4323,26 @@
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
 	pctx->codec_id = p ? p->value.uint : 0;
 
+	if (!ctx->buffer) {
+		pctx->buffer_done = GF_TRUE;
+	} else {
+		GF_FEVT_INIT(evt, GF_FEVT_BUFFER_REQ, pid);
+		evt.buffer_req.max_playout_us = evt.buffer_req.max_buffer_us = ctx->buffer * 1000;
+		if (ctx->mbuffer >= ctx->buffer)
+			evt.buffer_req.max_buffer_us = ctx->mbuffer * 1000;
+		if (ctx->rbuffer<ctx->buffer)
+			evt.buffer_req.min_playout_us = ctx->rbuffer * 1000;
+		else
+			ctx->rbuffer = 0;
+
+		//if pid is decoded media, don't ask for buffer requirement on pid, set it at decoder level
+		evt.buffer_req.pid_only = gf_filter_pid_has_decoder(pid) ? GF_FALSE : GF_TRUE;
+		gf_filter_pid_send_event(pid, &evt);
+		pctx->buf_start_time = gf_sys_clock();
+	}
+
+
+
 	w = h = sr = ch = 0;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_WIDTH);
 	if (p) w = p->value.uint;
@@ -4112,7 +4408,7 @@
 	if (! ctx->interleave && !pctx->tmp && ctx->dump) {
 		pctx->tmp = gf_file_temp(NULL);
 		if (ctx->xml)
-			gf_fprintf(pctx->tmp, "<PIDInspect ID=\"%d\" name=\"%s\">\n", pctx->idx, gf_filter_pid_get_name(pid) );
+			inspect_printf(pctx->tmp, "<PIDInspect ID=\"%d\" name=\"%s\">\n", pctx->idx, gf_filter_pid_get_name(pid) );
 	}
 
 	switch (ctx->mode) {
@@ -4174,6 +4470,9 @@
 	const char *name = gf_filter_get_name(filter);
 	GF_InspectCtx *ctx = (GF_InspectCtx *) gf_filter_get_udta(filter);
 
+	if (ctx->log && !strcmp(ctx->log, "GLOG"))
+		ctx->dump_log = GF_TRUE;
+
 	if (name && !strcmp(name, "probe") ) {
 		ctx->is_prober = GF_TRUE;
 		return GF_OK;
@@ -4187,25 +4486,11 @@
 #endif
 
 	if (!ctx->log) return GF_BAD_PARAM;
-	if (!strcmp(ctx->log, "stderr")) ctx->dump = stderr;
-	else if (!strcmp(ctx->log, "stdout")) ctx->dump = stdout;
-	else if (!strcmp(ctx->log, "null")) ctx->dump = NULL;
-	else {
-		ctx->dump = gf_fopen(ctx->log, "wt");
-		if (!ctx->dump) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Inspect Failed to open file %s\n", ctx->log));
-			return GF_IO_ERR;
-		}
-	}
+
 	if (ctx->analyze) {
 		ctx->xml = GF_TRUE;
 	}
 
-	if (ctx->xml && ctx->dump) {
-		ctx->fmt = NULL;
-		gf_fprintf(ctx->dump, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
-		gf_fprintf(ctx->dump, "<GPACInspect>\n");
-	}
 
 	if (ctx->xml || ctx->analyze || gf_sys_is_test_mode() || ctx->fmt) {
 		ctx->full = GF_TRUE;
@@ -4224,6 +4509,24 @@
 		gf_filter_override_caps(filter, InspecterDemuxedCaps, sizeof(InspecterDemuxedCaps)/sizeof(GF_FilterCapability) );
 		break;
 	}
+	if (gf_filter_is_temporary(filter))
+		return GF_OK;
+
+	if (!strcmp(ctx->log, "stderr")) ctx->dump = stderr;
+	else if (!strcmp(ctx->log, "stdout")) ctx->dump = stdout;
+	else if (!strcmp(ctx->log, "null")) ctx->dump = NULL;
+	else if (!ctx->dump_log) {
+		ctx->dump = gf_fopen(ctx->log, "wt");
+		if (!ctx->dump) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Inspect Failed to open file %s\n", ctx->log));
+			return GF_IO_ERR;
+		}
+	}
+	if (ctx->xml && ctx->dump) {
+		ctx->fmt = NULL;
+		inspect_printf(ctx->dump, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+		inspect_printf(ctx->dump, "<GPACInspect>\n");
+	}
 
 #ifdef GPAC_ENABLE_COVERAGE
 	if (gf_sys_is_cov_mode()) {
@@ -4248,7 +4551,13 @@
 #define OFFS(_n)	#_n, offsetof(GF_InspectCtx, _n)
 static const GF_FilterArgs InspectArgs =
 {
-	{ OFFS(log), "set inspect log filename", GF_PROP_STRING, "stdout", "fileName, stderr, stdout or null", 0},
+	{ OFFS(log), "set probe log filename to print number of streams, GLOG uses GPAC logs `app@info`(default for android)", GF_PROP_STRING,
+#ifdef GPAC_CONFIG_ANDROID
+		"GLOG"
+#else
+		"stdout"
+#endif
+		, "fileName, stderr, stdout, GLOG or null", 0},
 	{ OFFS(mode), "dump mode\n"
 	"- pck: dump full packet\n"
 	"- blk: dump packets before reconstruction\n"
@@ -4276,7 +4585,10 @@
 	{ OFFS(crc), "dump crc of samples of subsamples (NALU or OBU) when analyzing", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(fftmcd), "consider timecodes use ffmpeg-compatible signaling rather than QT compliant one", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
 	{ OFFS(dtype), "dump property type", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_UPDATE},
-	{ OFFS(buffer), "set buffer in ms (mostly used for testing DASH algo)", GF_PROP_UINT, "0", NULL, GF_ARG_HINT_EXPERT},
+	{ OFFS(buffer), "set playback buffer in ms", GF_PROP_UINT, "0", NULL, GF_ARG_HINT_EXPERT},
+	{ OFFS(mbuffer), "set max buffer occupancy in ms. If less than buffer, use buffer", GF_PROP_UINT, "0", NULL, 0},
+	{ OFFS(rbuffer), "rebuffer trigger in ms. If 0 or more than buffer, disable rebuffering", GF_PROP_UINT, "0", NULL, GF_FS_ARG_UPDATE},
+
 	{ OFFS(test), "skip predefined set of properties, used for test mode\n"
 		"- no: no properties skipped\n"
 		"- noprop: all properties/info changes on PID are skipped, only packets are dumped\n"
@@ -4306,6 +4618,7 @@
 	"Otherwise, all properties are dumped.\n"
 	"Note: specifying -xml(), -analyze(), -fmt() or using `-for-test` will force -full() to true.\n"
 	"\n"
+	"# Custom property duming\n"
 	"The packet inspector can be configured to dump specific properties of packets using -fmt().\n"
 	"When the option is not present, all properties are dumped. Otherwise, only properties identified by `$TOKEN$` "
 	"are printed. You may use '$', '@' or '%' for `TOKEN` separator. `TOKEN` can be:\n"
@@ -4335,11 +4648,15 @@
 	"- crc: 32 bit CRC of packet\n"
 	"- lf or n: insert new line\n"
 	"- t: insert tab\n"
-	"- data: hex dump of packet (__big output!__)\n"
+	"- data: hex dump of packet (__big output!__) or as string if legal UTF-8\n"
 	"- lp: leading picture flag\n"
 	"- depo: depends on other packet flag\n"
 	"- depf: is depended on other packet flag\n"
 	"- red: redundant coding flag\n"
+	"- start: packet composition time as HH:MM:SS.ms\n"
+	"- startc: packet composition time as HH:MM:SS,ms\n"
+	"- end: packet end time as HH:MM:SS.ms\n"
+	"- endc: packet end time as HH:MM:SS,ms\n"
 	"- ck: clock type used for PCR discontinuities\n"
 	"- pcr: MPEG-2 TS last PCR, n/a if not available\n"
 	"- pcrd: difference between last PCR and decoding time, n/a if no PCR available\n"
@@ -4348,13 +4665,24 @@
 	"- PropName: Name of packet property\n"
 	"- pid.P4CC: 4CC of PID property\n"
 	"- pid.PropName: Name of PID property\n"
+	"- fn: Filter name\n"
 	"\n"
 	"EX fmt=\"PID $pid.ID$ packet $pn$ DTS $dts$ CTS $cts$ $lf$\"\n"
 	"This dumps packet number, cts and dts as follows: `PID 1 packet 10 DTS 100 CTS 108 \\n`\n"
 	" \n"
 	"An unrecognized keyword or missing property will resolve to an empty string.\n"
 	"\n"
-	"Note: when dumping in interleaved mode, there is no guarantee that the packets will be dumped in their original sequence order since the inspector fetches one packet at a time on each PID.\n")
+	"Note: when dumping in interleaved mode, there is no guarantee that the packets will be dumped in their original sequence order since the inspector fetches one packet at a time on each PID.\n"
+	"\n"
+	"# Note on playback\n"
+	"Buffering can be enabled to check the input filter chain behaviour, e.g. check HAS adaptation logic.\n"
+	"The various buffering options control when packets are consumed. Buffering events are logged using `media@info` for state changes and `media@debug` for media filling events.\n"
+	"The -speed() option is only used to configure the filter chain but is ignored by the filter when consuming packets.\n"
+	"If real-time consumption is required, a reframer filter must be setup before the inspect filter.\n"
+	"EX gpac -i SRC reframer:rt=on inspect:buffer=10000:rbuffer=1000:mbuffer=30000:speed=2\n"
+	"This will play the session at 2x speed, using 30s of maximum buffering, consumming packets after 10s of media are ready and rebuffering if less than 1s of media.\n"
+	"\n"
+	)
 	.private_size = sizeof(GF_InspectCtx),
 	.flags = GF_FS_REG_EXPLICIT_ONLY,
 	.max_extra_pids = (u32) -1,
@@ -4389,7 +4717,13 @@
 
 static const GF_FilterArgs ProbeArgs =
 {
-	{ OFFS(log), "set probe log filename to print number of streams", GF_PROP_STRING, "stdout", "fileName, stderr, stdout or null", 0},
+	{ OFFS(log), "set probe log filename to print number of streams, GLOG uses GPAC logs `app@info`(default for android)", GF_PROP_STRING,
+#ifdef GPAC_CONFIG_ANDROID
+		"GLOG"
+#else
+		"stdout"
+#endif
+	, "fileName, stderr, stdout GLOG or null", 0},
 	{0}
 };
 
@@ -4401,7 +4735,7 @@
 	"The filter outputs the number of input PIDs in the file specified by -log().\n"
 	"It is up to the app developer to query input PIDs of the prober and take appropriated decisions.")
 	.private_size = sizeof(GF_InspectCtx),
-	.flags = GF_FS_REG_EXPLICIT_ONLY,
+	.flags = GF_FS_REG_EXPLICIT_ONLY | GF_FS_REG_TEMP_INIT,
 	.max_extra_pids = (u32) -1,
 	.initialize = inspect_initialize,
 	.args = ProbeArgs,

gpac-2.0.0.tar.gz/src/filters/io_fcryp.c -> gpac-2.2.0.tar.gz/src/filters/io_fcryp.c Changed

gpac-2.0.0.tar.gz/src/filters/isoffin.h -> gpac-2.2.0.tar.gz/src/filters/isoffin.h Changed

@@ -58,7 +58,7 @@
 typedef struct
 {
 	//options
-	char *src;
+	char *src, *initseg;
 	Bool allt, noedit, itt, itemid;
 	u32 smode;
 	u32 stsd;
@@ -107,7 +107,6 @@
 	Bool in_data_flush;
 	u32 has_pending_segments, nb_force_flush;
 
-	Bool clock_discontinuity;
 	Bool disconnected;
 	Bool no_order_check;
 	u32 moov_not_loaded;
@@ -124,6 +123,7 @@
 	u32 mem_load_mode;
 	u8 *mem_url;
 	GF_Blob mem_blob;
+	u32 mem_blob_alloc;
 	u64 bytes_removed;
 	u64 last_min_offset;
 	GF_Err in_error;
@@ -140,7 +140,6 @@
 	GF_FilterPid *pid;
 	ISOMReader *owner;
 	u64 duration;
-	Bool last_has_tfrf;
 
 	/*current sample*/
 	GF_ISOSample *static_sample;
@@ -152,43 +151,46 @@
 	s32 roll;
 	u32 xps_mask;
 	
-	Bool has_edit_list;
 	u32 sample_num;
 	s64 ts_offset;
-/*
-	s64 dts_offset;
-	Bool do_dts_shift_test;
-*/
 
 	/*for edit lists*/
 	u32 edit_sync_frame;
 	u64 sample_time, last_rap_sample_time, start, end;
-	Double speed;
+	Double speed, orig_start;
 
 	u32 timescale;
-	Bool to_init, has_rap;
-	//0: not playing, 1: playing 2: playing but end of range reached
-	u32 playing;
-	Bool eos_sent;
+	u32 clock_id;
 	u8 streamType;
-	Bool initial_play_seen;
-
-	Bool is_encrypted, is_cenc;
-
-	Bool disable_seek;
-	u32 nalu_extract_mode;
+	//flags
+	u8 has_edit_list;
+	u8 last_has_tfrf;
+	//0: not playing, 1: playing 2: playing but end of range reached
+	u8 playing;
+	u8 to_init, has_rap;
+	u8 eos_sent;
+	u8 initial_play_seen;
+	u8 midrun_tune;
+	u8 is_encrypted, is_cenc;
+	u8 disable_seek, set_disc;
+	u8 skip_next_play;
+	u8 seek_flag;
+	u8 check_avc_ps, check_hevc_ps, check_vvc_ps, check_mhas_pl;
+	u8 needs_pid_reconfig;
+	u8 check_has_rap;
+	//0: no drop, 1: only keeps sap, 2: only keeps saps until next sap, then regular mode
+	u8 sap_only;
+
+	GF_ISONaluExtractMode nalu_extract_mode;
 
 	//channel sample state
 	u32 last_sample_desc_index;
 	u32 isLeading, dependsOn, dependedOn, redundant;
 	u64 dts, cts;
 	u8 skip_byte_block, crypt_byte_block;
-	Bool is_protected;
 	u32 au_seq_num;
 	u64 sender_ntp, ntp_at_server_ntp;
-	u32 seek_flag;
 	u32 au_duration;
-	Bool set_disc;
 
 	u64 isma_BSO;
 	Bool pck_encrypted;
@@ -199,16 +201,10 @@
 	u8 *sai_buffer;
 	u32 sai_alloc_size, sai_buffer_size;
 
-	Bool check_avc_ps, check_hevc_ps, check_vvc_ps, check_mhas_pl;
 	GF_HEVCConfig *hvcc;
 	GF_AVCConfig *avcc;
 	GF_VVCConfig *vvcc;
-	GF_BitStream *nal_bs;
 	u32 dsi_crc;
-
-	Bool needs_pid_reconfig;
-	u32 sap_only;
-	Bool check_has_rap;
 } ISOMChannel;
 
 void isor_reset_reader(ISOMChannel *ch);

gpac-2.0.0.tar.gz/src/filters/isoffin_load.c -> gpac-2.2.0.tar.gz/src/filters/isoffin_load.c Changed

@@ -30,51 +30,36 @@
 
 #ifndef GPAC_DISABLE_ISOM
 
-#if 0	//deprecated - we need to rework chapter information to deal with static chapters and chapter tracks
-void isor_emulate_chapters(GF_ISOFile *file, GF_InitialObjectDescriptor *iod)
+static void isor_get_chapters(GF_ISOFile *file, GF_FilterPid *opid)
 {
-	GF_Segment *prev_seg;
-	u64 prev_start;
-	u64 start;
 	u32 i, count;
-	if (!iod || gf_list_count(iod->OCIDescriptors)) return;
+	GF_PropertyValue p;
+	GF_PropUIntList times;
+	GF_PropStringList names;
 	count = gf_isom_get_chapter_count(file, 0);
 	if (!count) return;
 
-	prev_seg = NULL;
-	start = prev_start = 0;
+	times.vals = gf_malloc(sizeof(u32)*count);
+	names.vals = gf_malloc(sizeof(char *)*count);
+	times.nb_items = names.nb_items = count;
+
 	for (i=0; i<count; i++) {
 		const char *name;
-		GF_Segment *seg;
+		u64 start;
 		gf_isom_get_chapter(file, 0, i+1, &start, &name);
-		seg = (GF_Segment *) gf_odf_desc_new(GF_ODF_SEGMENT_TAG);
-		seg->startTime = (Double) (s64) start;
-		seg->startTime /= 1000;
-		seg->SegmentName = gf_strdup(name);
-		gf_list_add(iod->OCIDescriptors, seg);
-		if (prev_seg) {
-			prev_seg->Duration = (Double) (s64) (start - prev_start);
-			prev_seg->Duration /= 1000;
-		} else if (start) {
-			prev_seg = (GF_Segment *) gf_odf_desc_new(GF_ODF_SEGMENT_TAG);
-			prev_seg->startTime = 0;
-			prev_seg->Duration = (Double) (s64) (start);
-			prev_seg->Duration /= 1000;
-			gf_list_insert(iod->OCIDescriptors, prev_seg, 0);
-		}
-		prev_seg = seg;
-		prev_start = start;
-	}
-	if (prev_seg) {
-		start = 1000*gf_isom_get_duration(file);
-		start /= gf_isom_get_timescale(file);
-		if (start>prev_start) {
-			prev_seg->Duration = (Double) (s64) (start - prev_start);
-			prev_seg->Duration /= 1000;
-		}
+		times.valsi = (u32) start;
+		names.valsi = gf_strdup(name);
 	}
+	p.type = GF_PROP_UINT_LIST;
+	p.value.uint_list = times;
+	gf_filter_pid_set_property(opid, GF_PROP_PID_CHAP_TIMES, &p);
+	gf_free(times.vals);
+
+	p.type = GF_PROP_STRING_LIST;
+	p.value.string_list = names;
+	gf_filter_pid_set_property(opid, GF_PROP_PID_CHAP_NAMES, &p);
+	//no free for string lists
 }
-#endif
 
 static void isor_export_ref(ISOMReader *read, ISOMChannel *ch, u32 rtype, char *rname)
 {
@@ -117,6 +102,9 @@
 	GF_GenericSampleDescription *udesc = NULL;
 	GF_Err e;
 	u32 ocr_es_id;
+	u32 meta_codec_id = 0;
+	char *meta_codec_name = NULL;
+	u32 meta_opaque=0;
 	Bool first_config = GF_FALSE;
 
 
@@ -261,9 +249,6 @@
 			else
 				pix_fmt = GF_PIXEL_RGB;
 			break;
-		case GF_QT_SUBTYPE_YUV422_10:
-			codec_id = GF_CODECID_V210;
-			break;
 
 		case GF_ISOM_SUBTYPE_IPCM:
 			if (gf_isom_get_pcm_config(read->mov, track, stsd_idx, &pcm_flags, &pcm_size) == GF_OK) {
@@ -349,10 +334,23 @@
 			break;
 		}
 
+		case GF_ISOM_SUBTYPE_DVB_SUBS:
+			codec_id = GF_CODECID_DVB_SUBS;
+			load_default = GF_TRUE;
+			break;
+		case GF_ISOM_SUBTYPE_DVB_TELETEXT:
+			codec_id = GF_CODECID_DVB_TELETEXT;
+			load_default = GF_TRUE;
+			break;
+
+		case GF_4CC('G','M','C','W'):
+			codec_id = m_subtype;
+			load_default = GF_TRUE;
+			break;
 
 		default:
 			codec_id = gf_codec_id_from_isobmf(m_subtype);
-			if (!codec_id) {
+			if (!codec_id || (codec_id==GF_CODECID_RAW)) {
 				pix_fmt=0;
 				if (streamtype==GF_STREAM_VISUAL) {
 					pix_fmt = gf_pixel_fmt_from_qt_type(m_subtype);
@@ -362,12 +360,17 @@
 
 				if (pix_fmt) {
 					codec_id = GF_CODECID_RAW;
+					if (pix_fmt==GF_PIXEL_UNCV)
+						load_default = GF_TRUE;
 				} else {
 					load_default = GF_TRUE;
 				}
 			}
-			else if (codec_id==GF_CODECID_FFV1)
+			//load dsi in any other case
+			else {
+			//if ((codec_id==GF_CODECID_FFV1) || (codec_id==GF_CODECID_ALAC))
 				load_default = GF_TRUE;
+			}
 			break;
 		}
 
@@ -383,6 +386,20 @@
 					dsi = gf_malloc(udesc->extension_buf_size-8);
 					if (dsi) memcpy(dsi, udesc->extension_buf+8, udesc->extension_buf_size-8);
 					dsi_size = udesc->extension_buf_size - 8;
+				} else if ((codec_id==GF_4CC('G','M','C','W')) && (udesc->extension_buf_size>=16)) {
+					GF_BitStream *bs = gf_bs_new(udesc->extension_buf, udesc->extension_buf_size, GF_BITSTREAM_READ);
+					if (udesc->ext_box_wrap == GF_4CC('G','M','C','C')) {
+						codec_id = gf_bs_read_u32(bs);
+						meta_codec_id = gf_bs_read_u32(bs);
+						meta_codec_name = gf_bs_read_utf8(bs);
+						meta_opaque = gf_bs_read_u32(bs);
+						if (gf_bs_available(bs)) {
+							u32 pos = (u32) gf_bs_get_position(bs);
+							dsi = udesc->extension_buf+pos;
+							dsi_size = udesc->extension_buf_size-pos;
+						}
+					}
+					gf_bs_del(bs);
 				} else {
 					dsi = udesc->extension_buf;
 					dsi_size = udesc->extension_buf_size;
@@ -517,34 +534,24 @@
 		if (!gf_sys_is_test_mode())
 			gf_filter_pid_set_property(pid, GF_PROP_PID_TRACK_NUM, &PROP_UINT(track) );
 
-		//Dolby Vision
-		switch (m_subtype) {
-		case GF_ISOM_SUBTYPE_DVHE:
-		case GF_ISOM_SUBTYPE_DVH1:
-		case GF_ISOM_SUBTYPE_DVA1:
-		case GF_ISOM_SUBTYPE_DVAV:
-		case GF_ISOM_SUBTYPE_DAV1:
-		{
-			GF_DOVIDecoderConfigurationRecord *dovi = gf_isom_dovi_config_get(read->mov, track, stsd_idx);
-			if (dovi) {
-				u8 *data = NULL;
-				u32 size = 0;
-				GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-				gf_odf_dovi_cfg_write_bs(dovi, bs);
-				gf_bs_get_content(bs, &data, &size);
-				gf_filter_pid_set_property(pid, GF_PROP_PID_DOLBY_VISION, &PROP_DATA_NO_COPY(data, size));
-				gf_bs_del(bs);
-				gf_odf_dovi_cfg_del(dovi);
+		//Dolby Vision - check for any video type
+		GF_DOVIDecoderConfigurationRecord *dovi = gf_isom_dovi_config_get(read->mov, track, stsd_idx);
+		if (dovi) {
+			u8 *data = NULL;
+			u32 size = 0;
+			GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+			gf_odf_dovi_cfg_write_bs(dovi, bs);
+			gf_bs_get_content(bs, &data, &size);
+			gf_filter_pid_set_property(pid, GF_PROP_PID_DOLBY_VISION, &PROP_DATA_NO_COPY(data, size));
+			gf_bs_del(bs);
+			gf_odf_dovi_cfg_del(dovi);
 
-				if (gf_isom_get_reference_count(read->mov, track, GF_4CC('v','d','e','p'))) {
-					GF_ISOTrackID ref_id=0;
-					gf_isom_get_reference_ID(read->mov, track, GF_4CC('v','d','e','p'), 1, &ref_id);
-					if (ref_id) gf_filter_pid_set_property(pid, GF_PROP_PID_DEPENDENCY_ID, &PROP_UINT(ref_id));
-				}
+			if (gf_isom_get_reference_count(read->mov, track, GF_4CC('v','d','e','p'))) {
+				GF_ISOTrackID ref_id=0;
+				gf_isom_get_reference_ID(read->mov, track, GF_4CC('v','d','e','p'), 1, &ref_id);
+				if (ref_id) gf_filter_pid_set_property(pid, GF_PROP_PID_DEPENDENCY_ID, &PROP_UINT(ref_id));
 			}
 		}
-			break;
-		}
 
 		//create our channel
 		ch = isor_create_channel(read, pid, track, 0, (codec_id==GF_CODECID_LHVC) ? GF_TRUE : GF_FALSE);
@@ -560,6 +567,7 @@
 		}
 
 		ch->streamType = streamtype;
+//		ch->clock_id = ocr_es_id;
 
 		if (has_scalable_layers)
 			gf_filter_pid_set_property(pid, GF_PROP_PID_SCALABLE, &PROP_BOOL(GF_TRUE));
@@ -628,10 +636,18 @@
 		if (sample_count && (streamtype==GF_STREAM_VISUAL)) {
 			u64 mdur = gf_isom_get_media_duration(read->mov, track);
 			//if ts_offset is negative (skip), update media dur before computing fps
-			if (!gf_sys_old_arch_compat() && (ch->ts_offset<0))
-				mdur -= (u32) -ch->ts_offset;
-
-			mdur /= sample_count;
+			if (!gf_sys_old_arch_compat()) {
+				u32 sdur = gf_isom_get_avg_sample_delta(read->mov, ch->track);
+				if (sdur) {
+					mdur = sdur;
+				} else {
+					if (ch->ts_offset<0)
+						mdur -= (u32) -ch->ts_offset;
+					mdur /= sample_count;
+				}
+			} else {
+				mdur /= sample_count;
+			}
 			gf_filter_pid_set_property(pid, GF_PROP_PID_FPS, &PROP_FRAC_INT(ch->timescale, (u32) mdur));
 		}
 
@@ -910,10 +926,18 @@
 				}
 			}
 		}
+
+		if (read->sigfrag) {
+			u64 start, end;
+			if (gf_isom_get_root_sidx_offsets(read->mov, &start, &end)) {
+				if (end)
+					gf_filter_pid_set_property(ch->pid, GF_PROP_PCK_SIDX_RANGE, &PROP_FRAC64_INT(start , end));
+			}
+		}
 	}
 
 	//update decoder configs
-	ch->check_avc_ps = ch->check_hevc_ps = ch->check_vvc_ps = GF_FALSE;
+	ch->check_avc_ps = ch->check_hevc_ps = ch->check_vvc_ps = 0;
 	if (ch->avcc) gf_odf_avc_cfg_del(ch->avcc);
 	ch->avcc = NULL;
 	if (ch->hvcc) gf_odf_hevc_cfg_del(ch->hvcc);
@@ -1004,13 +1028,53 @@
 			gf_filter_pid_set_property_str(ch->pid, "isom:modification_date", &PROP_LONGUINT(modif_date));
 		}
 
+		isor_get_chapters(read->mov, ch->pid);
+
+		if (!gf_sys_is_test_mode()) {
+			Bool has_roll=GF_FALSE;
+			gf_isom_has_cenc_sample_group(read->mov, track, NULL, &has_roll);
+			if (has_roll)
+				gf_filter_pid_set_property(ch->pid, GF_PROP_PID_CENC_HAS_ROLL, &PROP_BOOL(GF_TRUE));
+		}
 	}
 
 	//all stsd specific init/reconfig
 	gf_filter_pid_set_property(ch->pid, GF_PROP_PID_CODECID, &PROP_UINT(codec_id));
+
+	if (meta_codec_name || meta_codec_id) {
+		if (meta_codec_id)
+			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_META_DEMUX_CODEC_ID, &PROP_UINT(meta_codec_id));
+
+		if (meta_codec_name) {
+			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_META_DEMUX_CODEC_NAME, &PROP_STRING(meta_codec_name ) );
+			gf_free(meta_codec_name);
+		}
+		if (meta_opaque)
+			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_META_DEMUX_OPAQUE, &PROP_UINT(meta_opaque));
+
+		if (dsi) {
+			ch->dsi_crc = gf_crc_32(dsi, dsi_size);
+			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA(dsi, dsi_size)); //copy
+			dsi = NULL; //do not free it
+		}
+		m_subtype = 0;
+		if (udesc) {
+			if (udesc->extension_buf) gf_free(udesc->extension_buf);
+			gf_free(udesc);
+			udesc = NULL;
+		}
+	}
+
 	if (dsi) {
 		ch->dsi_crc = gf_crc_32(dsi, dsi_size);
-		gf_filter_pid_set_property(ch->pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, dsi_size));
+		//strip box header for these codecs
+		if (codec_id==GF_CODECID_SMPTE_VC1) {
+			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA(dsi+8, dsi_size-8));
+			gf_free(dsi);
+			dsi=NULL;
+		} else {
+			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, dsi_size));
+		}
 	}
 	if (enh_dsi) {
 		gf_filter_pid_set_property(ch->pid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, &PROP_DATA_NO_COPY(enh_dsi, enh_dsi_size));
@@ -1040,6 +1104,8 @@
 			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_SAR, &PROP_FRAC_INT(hspace, vspace) );
 
 		{
+			const u8 *icc;
+			u32 icc_size;
 			u32 colour_type;
 			u16 colour_primaries, transfer_characteristics, matrix_coefficients;
 			Bool full_range_flag;
@@ -1050,6 +1116,10 @@
 				gf_filter_pid_set_property(ch->pid, GF_PROP_PID_COLR_MX, &PROP_UINT(matrix_coefficients));
 				gf_filter_pid_set_property(ch->pid, GF_PROP_PID_COLR_RANGE, &PROP_BOOL(full_range_flag));
 			}
+			if (gf_isom_get_icc_profile(read->mov, track, stsd_idx, NULL, &icc, &icc_size)==GF_OK) {
+				if (icc && icc_size)
+					gf_filter_pid_set_property(ch->pid, GF_PROP_PID_ICC_PROFILE, &PROP_DATA((u8*)icc, icc_size) );
+			}
 		}
 
 		e = gf_isom_get_y3d_info(ch->owner->mov, ch->track, stsd_idx, &yt3d);
@@ -1164,7 +1234,9 @@
 	if (!gf_sys_is_test_mode() && (m_subtype==GF_ISOM_SUBTYPE_MPEG4))
 		m_subtype = gf_isom_get_mpeg4_subtype(read->mov, ch->track, stsd_idx);
 
-	gf_filter_pid_set_property(ch->pid, GF_PROP_PID_ISOM_SUBTYPE, &PROP_4CC(m_subtype) );
+	if (m_subtype)
+		gf_filter_pid_set_property(ch->pid, GF_PROP_PID_ISOM_SUBTYPE, &PROP_4CC(m_subtype) );
+
 	if (stxtcfg) gf_filter_pid_set_property(ch->pid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA((char *)stxtcfg, (u32) strlen(stxtcfg) ));
 
 
@@ -1202,21 +1274,21 @@
 			gf_filter_pid_set_property_str(ch->pid, "meta:mime", &PROP_STRING(dims.mime_type));
 	}
 	else if (codec_id==GF_CODECID_AVC)
-		ch->check_avc_ps = (ch->owner->xps_check==MP4DMX_XPS_REMOVE) ? GF_TRUE : GF_FALSE;
+		ch->check_avc_ps = (ch->owner->xps_check==MP4DMX_XPS_REMOVE) ? 1 : 0;
 	else if (codec_id==GF_CODECID_HEVC)
-		ch->check_hevc_ps = (ch->owner->xps_check==MP4DMX_XPS_REMOVE) ? GF_TRUE : GF_FALSE;
+		ch->check_hevc_ps = (ch->owner->xps_check==MP4DMX_XPS_REMOVE) ? 1 : 0;
 	else if (codec_id==GF_CODECID_VVC)
-		ch->check_vvc_ps = (ch->owner->xps_check==MP4DMX_XPS_REMOVE) ? GF_TRUE : GF_FALSE;
+		ch->check_vvc_ps = (ch->owner->xps_check==MP4DMX_XPS_REMOVE) ? 1 : 0;
 	else if (codec_id==GF_CODECID_MHAS) {
 		if (!dsi) {
-			ch->check_mhas_pl = GF_TRUE;
+			ch->check_mhas_pl = 1;
 			GF_ISOSample *samp = gf_isom_get_sample(ch->owner->mov, ch->track, 1, NULL);
 			if (samp) {
 				u64 ch_layout=0;
 				s32 PL = gf_mpegh_get_mhas_pl(samp->data, samp->dataLength, &ch_layout);
 				if (PL>0) {
 					gf_filter_pid_set_property(ch->pid, GF_PROP_PID_PROFILE_LEVEL, &PROP_UINT((u32) PL));
-					ch->check_mhas_pl = GF_FALSE;
+					ch->check_mhas_pl = 0;
 					if (ch_layout)
 						gf_filter_pid_set_property(ch->pid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT(ch_layout));
 				}
@@ -1230,8 +1302,12 @@
 		gf_filter_pid_set_property_str(ch->pid, "codec_version", &PROP_UINT(udesc->version));
 		gf_filter_pid_set_property_str(ch->pid, "codec_revision", &PROP_UINT(udesc->revision));
 		gf_filter_pid_set_property_str(ch->pid, "compressor_name", &PROP_STRING(udesc->compressor_name));
-		gf_filter_pid_set_property_str(ch->pid, "temporal_quality", &PROP_UINT(udesc->temporal_quality));
-		gf_filter_pid_set_property_str(ch->pid, "spatial_quality", &PROP_UINT(udesc->spatial_quality));
+		if (udesc->temporal_quality)
+			gf_filter_pid_set_property_str(ch->pid, "temporal_quality", &PROP_UINT(udesc->temporal_quality));
+
+		if (udesc->spatial_quality)
+			gf_filter_pid_set_property_str(ch->pid, "spatial_quality", &PROP_UINT(udesc->spatial_quality));
+
 		if (udesc->h_res) {
 			gf_filter_pid_set_property_str(ch->pid, "hres", &PROP_UINT(udesc->h_res));
 			gf_filter_pid_set_property_str(ch->pid, "vres", &PROP_UINT(udesc->v_res));
@@ -1255,7 +1331,8 @@
 				break;
 			}
 		}
-		gf_filter_pid_set_property(ch->pid, GF_PROP_PID_BIT_DEPTH_Y, &PROP_UINT(udesc->depth));
+		if (udesc->depth)
+			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_BIT_DEPTH_Y, &PROP_UINT(udesc->depth));
 
 		gf_free(udesc);
 	}
@@ -1295,7 +1372,7 @@
 
 			for(c=0;c<3;c++) {
 				gf_bs_write_u16(bs, mdcv->display_primariesc.x);
-				gf_bs_write_u16(bs, mdcv->display_primariesc.x);
+				gf_bs_write_u16(bs, mdcv->display_primariesc.y);
 			}
 			gf_bs_write_u16(bs, mdcv->white_point_x);
 			gf_bs_write_u16(bs, mdcv->white_point_y);
@@ -1333,6 +1410,7 @@
 	Bool highest_stream;
 	Bool single_media_found = GF_FALSE;
 	Bool use_iod = GF_FALSE;
+	Bool tk_found = GF_FALSE;
 	GF_Err e;
 	Bool isom_contains_video = GF_FALSE;
 	GF_Descriptor *od = gf_isom_get_root_od(read->mov);
@@ -1359,6 +1437,8 @@
 				if (mtype!=GF_ISOM_MEDIA_AUDIO) continue;
 			} else if (!strcmp(read->tkid, "video")) {
 				if (mtype!=GF_ISOM_MEDIA_VISUAL) continue;
+			} else if (!strcmp(read->tkid, "text")) {
+				if ((mtype!=GF_ISOM_MEDIA_TEXT) && (mtype!=GF_ISOM_MEDIA_SUBT)) continue;
 			} else if (strlen(read->tkid)==4) {
 				u32 t = GF_4CC(read->tkid0, read->tkid1, read->tkid2, read->tkid3);
 				if (mtype!=t) continue;
@@ -1366,6 +1446,7 @@
 				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia Bad format for tkid option %s, no match\n", read->tkid));
 				return GF_BAD_PARAM;
 			}
+			tk_found = GF_TRUE;
 		}
 
 		switch (mtype) {
@@ -1473,6 +1554,15 @@
 
 			if (read->itt) break;
 		}
+	} else {
+		if (!tk_found) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia TrackID %s not found in file\n", read->tkid ));
+			return GF_BAD_PARAM;
+		}
+	}
+	if (! gf_list_count(read->channels)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia No suitable tracks in file\n"));
+		return GF_NOT_SUPPORTED;
 	}
 	
 	/*if cover art, declare a video pid*/
@@ -1486,7 +1576,7 @@
 			GF_FilterPid *cover_pid=NULL;
 			e = gf_filter_pid_raw_new(read->filter, NULL, NULL, NULL, NULL, (char *) tag, tlen, GF_FALSE, &cover_pid);
 			if (e) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP3Dmx error setting up video pid for cover art: %s\n", gf_error_to_string(e) ));
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia error setting up video pid for cover art: %s\n", gf_error_to_string(e) ));
 			}
 			if (cover_pid) {
 				u8 *out_buffer;
@@ -1525,8 +1615,9 @@
 
 	if (!item_id) return GF_FALSE;
 	if (item_type==GF_ISOM_ITEM_TYPE_AUXI) return GF_FALSE;
+	if (read->play_only_track_id && (read->play_only_track_id!=item_id)) return GF_FALSE;
 
-	gf_isom_get_meta_image_props(read->mov, GF_TRUE, 0, item_id, &props);
+	gf_isom_get_meta_image_props(read->mov, GF_TRUE, 0, item_id, &props, NULL);
 
 	//check we support the protection scheme
 	switch (scheme_type) {
@@ -1617,6 +1708,10 @@
 	gf_filter_pid_set_property_str(pid, "meta:name", item_name ? &PROP_STRING(item_name) : NULL );
 	gf_filter_pid_set_property_str(pid, "meta:encoding", item_encoding ? &PROP_STRING(item_encoding) : NULL );
 
+	if ((item_type == GF_4CC('u','n','c','v')) || (item_type == GF_4CC('u','n','c','i'))) {
+		gf_filter_pid_set_property(pid, GF_PROP_PID_PIXFMT, &PROP_UINT(GF_PIXEL_UNCV) );
+	}
+
 
 	//setup cenc
 	if (scheme_type) {
@@ -1633,8 +1728,8 @@
 	if (!ch) {
 		ch = isor_create_channel(read, pid, 0, item_id, GF_FALSE);
 		if (ch && scheme_type) {
-			ch->is_cenc = GF_TRUE;
-			ch->is_encrypted = GF_TRUE;
+			ch->is_cenc = 1;
+			ch->is_encrypted = 1;
 
 			isor_declare_pssh(ch);

gpac-2.0.0.tar.gz/src/filters/isoffin_read.c -> gpac-2.2.0.tar.gz/src/filters/isoffin_read.c Changed

@@ -53,7 +53,7 @@
 }
 
 
-static GF_Err isoffin_setup(GF_Filter *filter, ISOMReader *read)
+static GF_Err isoffin_setup(GF_Filter *filter, ISOMReader *read, Bool input_is_eos)
 {
 	char *url;
 	char *tmp, *src;
@@ -111,6 +111,8 @@
 				read->play_only_first_media = GF_ISOM_MEDIA_TEXT;
 			} else if (!strnicmp(tmp, "#trackID=", 9)) {
 				read->play_only_track_id = atoi(tmp+9);
+			} else if (!strnicmp(tmp, "#itemID=", 8)) {
+				read->play_only_track_id = atoi(tmp+8);
 			} else if (!strnicmp(tmp, "#ID=", 4)) {
 				read->play_only_track_id = atoi(tmp+4);
 			} else {
@@ -125,7 +127,7 @@
 		return GF_NOT_SUPPORTED;
 	}
 	read->start_range = read->end_range = 0;
-	prop = gf_filter_pid_get_property(read->pid, GF_PROP_PID_FILE_RANGE);
+	prop = read->pid ? gf_filter_pid_get_property(read->pid, GF_PROP_PID_FILE_RANGE) : NULL;
 	if (prop) {
 		read->start_range = prop->value.lfrac.num;
 		read->end_range = prop->value.lfrac.den;
@@ -135,9 +137,13 @@
 	e = gf_isom_open_progressive(url, read->start_range, read->end_range, read->sigfrag, &read->mov, &read->missing_bytes);
 
 	if (e == GF_ISOM_INCOMPLETE_FILE) {
-		gf_free(url);
-		read->moov_not_loaded = 1;
-		return GF_OK;
+		if (input_is_eos) {
+			e = GF_ISOM_INVALID_FILE;
+		} else {
+			gf_free(url);
+			read->moov_not_loaded = 1;
+			return GF_OK;
+		}
 	}
 
 	read->input_loaded = GF_TRUE;
@@ -172,13 +178,17 @@
 		gf_isom_text_set_streaming_mode(read->mov, GF_TRUE);
 
 	gf_free(url);
-	return isor_declare_objects(read);
+	e = isor_declare_objects(read);
+	if (e && (e!= GF_ISOM_INCOMPLETE_FILE)) {
+		gf_filter_setup_failure(filter, e);
+		e = GF_FILTER_NOT_SUPPORTED;
+	}
+	return e;
 }
 
 static void isoffin_delete_channel(ISOMChannel *ch)
 {
 	isor_reset_reader(ch);
-	if (ch->nal_bs) gf_bs_del(ch->nal_bs);
 	if (ch->avcc) gf_odf_avc_cfg_del(ch->avcc);
 	if (ch->hvcc) gf_odf_hevc_cfg_del(ch->hvcc);
 	if (ch->vvcc) gf_odf_vvc_cfg_del(ch->vvcc);
@@ -242,12 +252,17 @@
 		//but still further fragments to be pushed
 		if (!read->start_range && !read->end_range)
 			read->refresh_fragmented = GF_TRUE;
-		read->seg_name_changed = GF_TRUE;
 
 		for (i=0; i<gf_list_count(read->channels); i++) {
 			ISOMChannel *ch = gf_list_get(read->channels, i);
 			if (ch->last_state==GF_EOS)
 				ch->last_state=GF_OK;
+
+			//if we have an init seg set, set sample count
+			if (read->initseg) {
+				u32 nb_samples = gf_isom_get_sample_count(read->mov, ch->track);
+				gf_filter_pid_set_property(ch->pid, GF_PROP_PID_NB_FRAMES, &PROP_UINT(nb_samples));
+			}
 		}
 
 #ifndef GPAC_DISABLE_LOG
@@ -323,7 +338,7 @@
 			ISOMChannel *ch = gf_list_get(read->channels, i);
 if (ch) {
 ch->sample_num = 0;
- ch->eos_sent = GF_FALSE;
+ ch->eos_sent = 0;
 }
 		}
 GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("IsoMedia Error opening current segment %s: %s\n", next_url, gf_error_to_string(e) ));
@@ -341,7 +356,7 @@
 	for (i=0; i<count; i++) {
 		ISOMChannel *ch = gf_list_get(read->channels, i);
 		ch->last_state = GF_OK;
-		ch->eos_sent = GF_FALSE;
+		ch->eos_sent = 0;
 
 		//old code from master, currently no longer used
 		//in filters we don't use extractors for the time being, we only do implicit reconstruction at the decoder side
@@ -404,6 +419,9 @@
 		isoffin_disconnect(read);
 		return GF_OK;
 	}
+	if (read->initseg) {
+		read->pid = pid;
+	}
 	//check if we have a file path; if not, this is a pure stream of boxes (no local file cache)
 	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_FILEPATH);
 	if (!prop || !prop->value.string) {
@@ -450,7 +468,7 @@
 		evt.play.full_file_only=1;
 		gf_filter_pid_send_event(pid, &evt);
 	}
-	return isoffin_setup(filter, read);
+	return isoffin_setup(filter, read, GF_FALSE);
 }
 
 GF_Err isoffin_initialize(GF_Filter *filter)
@@ -466,7 +484,7 @@
 
 	if (read->src) {
 		read->input_loaded = GF_TRUE;
-		return isoffin_setup(filter, read);
+		return isoffin_setup(filter, read, GF_TRUE);
 	}
 	else if (read->mov) {
 		read->extern_mov = GF_TRUE;
@@ -486,6 +504,11 @@
 
 		gf_filter_post_process_task(filter);
 	}
+	else if (read->initseg) {
+		read->src = read->initseg;
+		e = isoffin_setup(filter, read, GF_TRUE);
+		read->src = NULL;
+	}
 	return e;
 }
 
@@ -507,7 +530,10 @@
 	read->mov = NULL;
 
 	if (read->mem_blob.data) gf_free(read->mem_blob.data);
-	if (read->mem_url) gf_free(read->mem_url);
+	if (read->mem_url) {
+		gf_blob_unregister(&read->mem_blob);
+		gf_free(read->mem_url);
+	}
 }
 
 void isor_declare_pssh(ISOMChannel *ch)
@@ -605,7 +631,7 @@
 
 		//gf_media_get_file_hash(gf_isom_get_filename(mov), hash);
 	} else if (gf_isom_is_cenc_media(mov, track, stsd_idx)) {
-		ch->is_cenc = GF_TRUE;
+		ch->is_cenc = 1;
 
 		gf_isom_get_cenc_info(ch->owner->mov, ch->track, stsd_idx, NULL, &scheme_type, &scheme_version);
 
@@ -669,7 +695,7 @@
 	}
 	ch->owner = read;
 	ch->pid = pid;
-	ch->to_init = GF_TRUE;
+	ch->to_init = 1;
 	gf_list_add(read->channels, ch);
 	ch->track = track;
 	ch->item_id = item_id;
@@ -701,21 +727,21 @@
 	}
 	if (!read->noedit) {
 		ch->ts_offset = 0;
-		ch->has_edit_list = gf_isom_get_edit_list_type(ch->owner->mov, ch->track, &ch->ts_offset) ? GF_TRUE : GF_FALSE;
+		ch->has_edit_list = gf_isom_get_edit_list_type(ch->owner->mov, ch->track, &ch->ts_offset) ? 1 : 0;
 		if (!ch->has_edit_list && ch->ts_offset) {
 			//if >0 this is a hold, we signal positive delay
 			//if <0 this is a skip, we signal negative delay
 			gf_filter_pid_set_property(pid, GF_PROP_PID_DELAY, &PROP_LONGSINT( ch->ts_offset) );
 		}
 	} else
-		ch->has_edit_list = GF_FALSE;
+		ch->has_edit_list = 0;
 
-	ch->has_rap = (gf_isom_has_sync_points(ch->owner->mov, ch->track)==1) ? GF_TRUE : GF_FALSE;
+	ch->has_rap = (gf_isom_has_sync_points(ch->owner->mov, ch->track)==1) ? 1 : 0;
 	gf_filter_pid_set_property(pid, GF_PROP_PID_HAS_SYNC, &PROP_BOOL(ch->has_rap) );
 	//some fragmented files do not advertize a sync sample table (legal) so we need to update as soon as we fetch a fragment
 	//to see if we are all-intra (as detected here) or not
 	if (!ch->has_rap && ch->owner->frag_type)
-		ch->check_has_rap = GF_TRUE;
+		ch->check_has_rap = 1;
 	ch->timescale = gf_isom_get_media_timescale(ch->owner->mov, ch->track);
 
 	ts_shift = gf_isom_get_cts_to_dts_shift(ch->owner->mov, ch->track);
@@ -745,10 +771,10 @@
 		return ch;
 	}
 	if (ch->owner->nocrypt) {
-		ch->is_encrypted = GF_FALSE;
+		ch->is_encrypted = 0;
 		return ch;
 	}
-	ch->is_encrypted = GF_TRUE;
+	ch->is_encrypted = 1;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
 	if (p) gf_filter_pid_set_property(pid, GF_PROP_PID_ORIG_STREAM_TYPE, &PROP_UINT(p->value.uint) );
 
@@ -793,7 +819,7 @@
 		}
 		/*this is the highest quality*/
 		if (!next_track) {
-			ch->playing = GF_TRUE;
+			ch->playing = 1;
 			ref_count = gf_isom_get_reference_count(the_file, ch->track, GF_ISOM_REF_BASE);
 			trackID = 0;
 			if (ref_count) {
@@ -836,8 +862,8 @@
 			return cur_track;
 
 		if (ch->track != next_track) {
-			ch->playing = GF_FALSE;
-			ch->eos_sent = GF_TRUE;
+			ch->playing = 0;
+			ch->eos_sent = 1;
 			gf_filter_pid_set_eos(ch->pid);
 		}
 	}
@@ -853,7 +879,8 @@
 {
 	u32 count, i;
 	Bool cancel_event = GF_TRUE;
-	ISOMChannel *ch;
+	Double start_range, speed;
+	ISOMChannel *ch, *ref_ch;
 	ISOMReader *read = gf_filter_get_udta(filter);
 
 	if (!read || read->disconnected) return GF_FALSE;
@@ -878,10 +905,15 @@
 
 	switch (evt->base.type) {
 	case GF_FEVT_PLAY:
+		if (ch->skip_next_play) {
+			ch->skip_next_play = 0;
+			return GF_TRUE;
+		}
+
 		isor_reset_reader(ch);
-		ch->eos_sent = GF_FALSE;
+		ch->eos_sent = 0;
 		ch->speed = evt->play.speed;
-		ch->initial_play_seen = GF_TRUE;
+		ch->initial_play_seen = 1;
 		read->reset_frag_state = 1;
 		//it can happen that input_is_stop is still TRUE because we did not get called back after the stop - reset to FALSE since we now play
 		read->input_is_stop = GF_FALSE;
@@ -889,14 +921,45 @@
 			read->frag_type = 1;
 
 		ch->start = ch->end = 0;
-		if (evt->play.speed>=0) {
+		start_range = evt->play.start_range;
+		speed = evt->play.speed;
+		//compute closest range if channel was disconnected
+		if (read->nb_playing && ch->midrun_tune) {
+			ref_ch = NULL;
+			count = gf_list_count(read->channels);
+			for (i = 0; i < count; i++) {
+				ISOMChannel *ach = (ISOMChannel *)gf_list_get(read->channels, i);
+				if (!ach->playing) continue;
+				//check sync ID if multiple timelines
+				if (ach->clock_id != ch->clock_id) continue;
+				ref_ch = ach;
+				break;
+			}
+			//we have a ref, if computed last sample clock is 1s greater than start range of channel, use current time
+			if (ref_ch && ref_ch->timescale) {
+				Double diff, orig_range = ref_ch->orig_start;
+				speed = ref_ch->speed;
+				if (ref_ch->has_edit_list) {
+					start_range = (Double) ref_ch->sample_time;
+				} else {
+					start_range = (Double) ref_ch->cts;
+				}
+				start_range /= ref_ch->timescale;
+				diff = orig_range - start_range;
+				if (ABS(diff)<1.0)
+					start_range = orig_range;
+			}
+		}
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("IsoMedia channel start is %f - requested %f\n", start_range, evt->play.start_range));
+
+		if (speed>=0) {
 			Double t;
-			if (evt->play.start_range>=0) {
-				t = evt->play.start_range;
+			if (start_range>=0) {
+				t = start_range;
 				t *= ch->timescale;
 				ch->start = (u64) t;
 			}
-			if (evt->play.end_range >= evt->play.start_range) {
+			if (evt->play.end_range >= start_range) {
 				ch->end = (u64) -1;
 				if (evt->play.end_range<FLT_MAX) {
 					t = evt->play.end_range;
@@ -907,16 +970,17 @@
 		} else {
 			Double end = evt->play.end_range;
 			if (end==-1) end = 0;
-			ch->start = (u64) (s64) (evt->play.start_range * ch->timescale);
-			if (end <= evt->play.start_range)
+			ch->start = (u64) (s64) (start_range * ch->timescale);
+			if (end <= start_range)
 				ch->end = (u64) (s64) (end * ch->timescale);
 		}
-		ch->playing = GF_TRUE;
+		ch->playing = 1;
 		ch->sample_num = evt->play.from_pck;
+		ch->orig_start = start_range;
 
-		ch->sap_only = evt->play.drop_non_ref ? GF_TRUE : GF_FALSE;
+		ch->sap_only = evt->play.drop_non_ref ? 1 : 0;
 
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("IsoMedia Starting channel playback "LLD" to "LLD" (%g to %g)\n", ch->start, ch->end, evt->play.start_range, evt->play.end_range));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("IsoMedia Starting channel playback "LLD" to "LLD" (%g to %g)\n", ch->start, ch->end, start_range, evt->play.end_range));
 
 		if (!read->nb_playing)
 			gf_isom_reset_seq_num(read->mov);
@@ -980,7 +1044,6 @@
 			}
 
 			if ((evt->play.start_range || read->is_partial_download) && (max_offset != GF_FILTER_NO_BO) ) {
-
 				//send a seek request
 				read->is_partial_download = GF_TRUE;
 				read->wait_for_source = GF_TRUE;
@@ -990,24 +1053,56 @@
 				fevt.seek.start_offset = max_offset;
 				gf_filter_pid_send_event(read->pid, &fevt);
 				gf_isom_set_byte_offset(read->mov, is_sidx_seek ? 0 : max_offset);
+			}
+		}
+
 
+		read->nb_playing++;
+		//trigger play on all "disconnected" channels
+		if ((read->nb_playing>1) && !ch->midrun_tune) {
+			count = gf_list_count(read->channels);
+			for (i=0; i<count;i++) {
+				ISOMChannel *ach = gf_list_get(read->channels, i);
+				//locate disconnected channels playing
+				if (ach == ch) continue;
+				if (ach->clock_id != ch->clock_id) continue;
+				if (!ach->playing || !ach->timescale || !ach->midrun_tune) continue;
+				isor_reset_reader(ach);
+				ach->playing = 1;
+				ach->sample_num = 0;
+				ach->start = gf_timestamp_rescale(ch->start, ch->timescale, ach->timescale);
+				ach->orig_start = ch->orig_start;
+				ach->start = (u64) (ach->orig_start * ach->timescale);
+				ach->eos_sent = 0;
+				ach->speed = evt->play.speed;
+				ach->initial_play_seen = 1;
+				ach->skip_next_play = 1;
+				ach->set_disc = 1;
 			}
 		}
+
 		//always request a process task upon a play
 		gf_filter_post_process_task(read->filter);
-		read->nb_playing++;
 		//cancel event unless dash mode
 		return cancel_event;
 
 	case GF_FEVT_STOP:
 		if (read->nb_playing) read->nb_playing--;
 		isor_reset_reader(ch);
+
+		//stop is due to a deconnection, mark channel as not active
+		if (evt->play.initial_broadcast_play==2)
+			ch->midrun_tune = 1;
+		else
+			ch->midrun_tune = 0;
+
 		//don't send a stop if some of our channels are still waiting for initial play
 		for (i=0; i<gf_list_count(read->channels); i++) {
 			ISOMChannel *a_ch = gf_list_get(read->channels, i);
 			if (ch==a_ch) continue;
 			if (!a_ch->initial_play_seen) return GF_TRUE;
 		}
+		ch->skip_next_play = 0;
 		//cancel event if nothing playing
 		if (read->nb_playing) return GF_TRUE;
 		read->input_is_stop = GF_TRUE;
@@ -1019,7 +1114,7 @@
 		if (ch->sap_only && !evt->play.drop_non_ref) {
 			ch->sap_only = 2;
 		} else {
-			ch->sap_only = evt->play.drop_non_ref ? GF_TRUE : GF_FALSE;
+			ch->sap_only = evt->play.drop_non_ref ? 1 : 0;
 		}
 		//cancel event
 		return GF_TRUE;
@@ -1036,11 +1131,12 @@
 	GF_Err e;
 
 	if (!read->mem_url) {
-		char szPath200;
-		sprintf(szPath, "gmem://%p", &read->mem_blob);
-		read->mem_url = gf_strdup(szPath);
+		read->mem_url = gf_blob_register(&read->mem_blob);
+	}
+	if (read->mem_blob_alloc < read->mem_blob.size + data_size) {
+		read->mem_blob.data = gf_realloc(read->mem_blob.data, read->mem_blob.size + data_size);
+		read->mem_blob_alloc = read->mem_blob.size + data_size;
 	}
-	read->mem_blob.data = gf_realloc(read->mem_blob.data, read->mem_blob.size + data_size);
 	memcpy(read->mem_blob.data + read->mem_blob.size, pck_data, data_size);
 	read->mem_blob.size += data_size;
 
@@ -1224,7 +1320,7 @@
 continue;
 }
 if (!ch->eos_sent) {
- ch->eos_sent = GF_TRUE;
+ ch->eos_sent = 1;
 gf_filter_pid_set_eos(ch->pid);
 }
 }
@@ -1239,7 +1335,7 @@
 		if (read->mem_load_mode)
 			return GF_OK;
 		read->moov_not_loaded = GF_FALSE;
-		return isoffin_setup(filter, read);
+		return isoffin_setup(filter, read, in_is_eos);
 	}
 
 	if (read->refresh_fragmented) {
@@ -1262,7 +1358,7 @@
 
 			e = gf_isom_refresh_fragmented(read->mov, &bytesMissing, new_url);
 
-			if (e && (e!= GF_ISOM_INCOMPLETE_FILE)) {
+			if (e && (e != GF_ISOM_INCOMPLETE_FILE)) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("IsoMedia Failed to refresh current segment: %s\n", gf_error_to_string(e) ));
 				read->refresh_fragmented = GF_FALSE;
 			} else {
@@ -1323,13 +1419,13 @@
 				GF_FilterPacket *pck;
 				if (ch->needs_pid_reconfig) {
 					isor_update_channel_config(ch);
-					ch->needs_pid_reconfig = GF_FALSE;
+					ch->needs_pid_reconfig = 0;
 				}
 
 				//we have at least two samples, update GF_PROP_PID_HAS_SYNC if needed
 				if (ch->check_has_rap && (gf_isom_get_sample_count(ch->owner->mov, ch->track)>1) && (gf_isom_has_sync_points(ch->owner->mov, ch->track)==1)) {
-					ch->check_has_rap = GF_FALSE;
-					ch->has_rap = GF_TRUE;
+					ch->check_has_rap = 0;
+					ch->has_rap = 1;
 					gf_filter_pid_set_property(ch->pid, GF_PROP_PID_HAS_SYNC, &PROP_BOOL(ch->has_rap) );
 				}
 
@@ -1416,14 +1512,6 @@
 						if (finfo.sidx_end) {
 							gf_filter_pck_set_property(pck, GF_PROP_PCK_SIDX_RANGE, &PROP_FRAC64_INT(finfo.sidx_start , finfo.sidx_end));
 						}
-
-						if (read->seg_name_changed) {
-							const GF_PropertyValue *p = gf_filter_pid_get_property(read->pid, GF_PROP_PID_URL);
-							read->seg_name_changed = GF_FALSE;
-							if (p && p->value.string) {
-								gf_filter_pck_set_property(pck, GF_PROP_PID_URL, &PROP_STRING(p->value.string));
-							}
-						}
 					}
 				}
 				if (ch->sender_ntp) {
@@ -1432,16 +1520,23 @@
 						gf_filter_pck_set_property(pck, GF_PROP_PCK_RECEIVER_NTP, &PROP_LONGUINT(ch->ntp_at_server_ntp));
 					}
 				}
-				ch->eos_sent = GF_FALSE;
+				ch->eos_sent = 0;
 
 				//this might not be the true end of stream
 				if ((ch->streamType==GF_STREAM_AUDIO) && (ch->sample_num == gf_isom_get_sample_count(read->mov, ch->track))) {
 					gf_filter_pck_set_property(pck, GF_PROP_PCK_END_RANGE, &PROP_BOOL(GF_TRUE));
 				}
 
-				if (!ch->item_id)
+				if (!ch->item_id) {
 					isor_set_sample_groups_and_aux_data(read, ch, pck);
+				}
+				if (ch->sample_data_offset && !gf_sys_is_test_mode())
+					gf_filter_pck_set_byte_offset(pck, ch->sample_data_offset);
 
+				if (ch->set_disc) {
+					ch->set_disc = 0;
+					gf_filter_pck_set_clock_type(pck, GF_FILTER_CLOCK_PCR_DISC);
+				}
 				gf_filter_pck_send(pck);
 				isor_reader_release_sample(ch);
 
@@ -1450,7 +1545,7 @@
 			} else if (ch->last_state==GF_EOS) {
 				if (ch->playing == 2) {
 					if (in_is_eos) {
-						ch->playing = GF_FALSE;
+						ch->playing = 0;
 					} else {
 						nb_forced_end++;
 						check_forced_end = GF_TRUE;
@@ -1460,16 +1555,16 @@
 					void *tfrf;
 					const void *gf_isom_get_tfrf(GF_ISOFile *movie, u32 trackNumber);
 
-					ch->eos_sent = GF_TRUE;
+					ch->eos_sent = 1;
 					read->eos_signaled = GF_TRUE;
 
 					tfrf = (void *) gf_isom_get_tfrf(read->mov, ch->track);
 					if (tfrf) {
 						gf_filter_pid_set_info_str(ch->pid, "smooth_tfrf", &PROP_POINTER(tfrf) );
-						ch->last_has_tfrf = GF_TRUE;
+						ch->last_has_tfrf = 1;
 					} else if (ch->last_has_tfrf) {
 						gf_filter_pid_set_info_str(ch->pid, "smooth_tfrf", NULL);
-						ch->last_has_tfrf = GF_FALSE;
+						ch->last_has_tfrf = 0;
 					}
 
 					gf_filter_pid_set_eos(ch->pid);
@@ -1477,12 +1572,15 @@
 				break;
 			} else if (ch->last_state==GF_ISOM_INVALID_FILE) {
 				if (!ch->eos_sent) {
-					ch->eos_sent = GF_TRUE;
+					ch->eos_sent = 1;
 					read->eos_signaled = GF_TRUE;
 					gf_filter_pid_set_eos(ch->pid);
 				}
 				return ch->last_state;
 			} else {
+				if ((ch->last_state==GF_OK) && ch->sap_only)
+					gf_filter_ask_rt_reschedule(filter, 1);
+
 				read->force_fetch = GF_TRUE;
 				break;
 			}
@@ -1559,14 +1657,15 @@
 	"- auto: resolves to `keep` for `smode=splix` (dasher mode), `rem` otherwise"
 	, GF_PROP_UINT, "auto", "auto|keep|rem", GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(nodata), "do not load sample data", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(initseg), "local init segment name when input is a single ISOBMFF segment", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
 static const GF_FilterCapability ISOFFInCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "mp4|mpg4|m4a|m4i|3gp|3gpp|3g2|3gp2|iso|m4s|heif|heic|avci|mj2|mov|qt"),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "application/x-isomedia|application/mp4|video/mp4|audio/mp4|video/3gpp|audio/3gpp|video/3gp2|audio/3gp2|video/iso.segment|audio/iso.segment|image/heif|image/heic|image/avci|video/quicktime"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "mp4|mpg4|m4a|m4i|3gp|3gpp|3g2|3gp2|iso|m4s|iff|heif|heic|avif|avci|mj2|ismv|mov|qt"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "video/mp4|audio/mp4|application/mp4|video/3gpp|audio/3gpp|video/3gp2|audio/3gp2|video/iso.segment|audio/iso.segment|image/heif|image/heic|image/avci|video/jp2|video/quicktime"),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_SCENE),
@@ -1595,8 +1694,9 @@
 		" - #pict: only use the first picture track\n"
 		" - #text: only use the first text track\n"
 		" - #trackID=VAL: only use the track with given ID\n"
-		" - #ID=VAL: only use the track with given ID\n"
-		" - #VAL: only use the track with given ID\n"
+		" - #itemID=VAL: only use the item with given ID\n"
+		" - #ID=VAL: only use the track/item with given ID\n"
+		" - #VAL: only use the track/item with given ID\n"
 		"\n"
 		"# Scalable Tracks\n"
 		"When scalable tracks are present in a file, the reader can operate in 3 modes using -smode() option:\n"

gpac-2.0.0.tar.gz/src/filters/isoffin_read_ch.c -> gpac-2.2.0.tar.gz/src/filters/isoffin_read_ch.c Changed

@@ -45,7 +45,7 @@
 	ch->speed = 1.0;
 	ch->start = ch->end = 0;
 	ch->to_init = 1;
-	ch->playing = GF_FALSE;
+	ch->playing = 0;
 	if (ch->sai_buffer) gf_free(ch->sai_buffer);
 	ch->sai_buffer = NULL;
 	ch->sai_alloc_size = 0;
@@ -104,7 +104,7 @@
 		ch->last_state=GF_OK;
 	} else if (ch->sample_num) {
 		ch->sample = gf_isom_get_sample_ex(ch->owner->mov, ch->track, ch->sample_num, &sample_desc_index, ch->static_sample, &ch->sample_data_offset);
-		ch->disable_seek = GF_TRUE;
+		ch->disable_seek = 1;
 		ch->au_seq_num = ch->sample_num;
 	} else {
 		//if seek is disabled, get the next closest sample for this time; otherwise, get the previous RAP sample for this time
@@ -161,7 +161,7 @@
 
 	ch->sample_time = ch->sample->DTS;
 
-	ch->to_init = GF_FALSE;
+	ch->to_init = 0;
 
 	ch->seek_flag = 0;
 	if (ch->disable_seek) {
@@ -303,6 +303,7 @@
 void isor_reader_get_sample(ISOMChannel *ch)
 {
 	GF_Err e;
+	Bool skip_sample=GF_FALSE;
 	u32 sample_desc_index;
 	if (ch->sample) return;
 
@@ -455,6 +456,8 @@
 				isor_reader_get_sample(ch);
 				return;
 			}
+		} else {
+			skip_sample = GF_TRUE;
 		}
 	}
 
@@ -485,7 +488,9 @@
 					GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia Failed to fetch initial sample %d for track %d\n", ch->sample_num, ch->track));
 					ch->last_state = GF_ISOM_INVALID_FILE;
 				} else {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia File truncated, aborting read for track %d\n", ch->track));
+					if (!ch->eos_sent) {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia File truncated, aborting read for track %d\n", ch->track));
+					}
 					ch->last_state = GF_EOS;
 				}
 			}
@@ -506,7 +511,7 @@
 			} else {
 				if (ch->sample_num>sample_count) ch->sample_num = sample_count;
 			}
-		} else {
+		} else if (!skip_sample) {
 			e = gf_isom_last_error(ch->owner->mov);
 			GF_LOG((e==GF_ISOM_INCOMPLETE_FILE) ? GF_LOG_DEBUG : GF_LOG_WARNING, GF_LOG_CONTAINER, ("IsoMedia Track #%d fail to fetch sample %d / %d: %s\n", ch->track, ch->sample_num, gf_isom_get_sample_count(ch->owner->mov, ch->track), gf_error_to_string(e) ));
 
@@ -524,7 +529,7 @@
 			if (!ch->last_sample_desc_index && (sample_desc_index==1)) {
 
 			} else {
-				ch->needs_pid_reconfig = GF_TRUE;
+				ch->needs_pid_reconfig = 1;
 			}
 		}
 		ch->last_sample_desc_index = sample_desc_index;
@@ -536,8 +541,6 @@
 	ch->sap_3 = GF_FALSE;
 	ch->sap_4_type = 0;
 	ch->roll = 0;
-	ch->set_disc = ch->owner->clock_discontinuity ? 2 : 0;
-	ch->owner->clock_discontinuity = 0;
 
 	if (ch->sample) {
 		gf_isom_get_sample_rap_roll_info(ch->owner->mov, ch->track, ch->sample_num, &ch->sap_3, &ch->sap_4_type, &ch->roll);
@@ -798,7 +801,7 @@
 
 void isor_reader_check_config(ISOMChannel *ch)
 {
-	u32 nalu_len, reset_state;
+	u32 nalu_len, reset_state, pos;
 	if (!ch->check_hevc_ps && !ch->check_avc_ps && !ch->check_vvc_ps && !ch->check_mhas_pl) return;
 
 	if (!ch->sample) return;
@@ -815,7 +818,7 @@
 		s32 PL = gf_mpegh_get_mhas_pl(ch->sample->data, ch->sample->dataLength, &ch_layout);
 		if (PL>0) {
 			gf_filter_pid_set_property(ch->pid, GF_PROP_PID_PROFILE_LEVEL, &PROP_UINT((u32) PL));
-			ch->check_mhas_pl = GF_FALSE;
+			ch->check_mhas_pl = 0;
 			if (ch_layout)
 				gf_filter_pid_set_property(ch->pid, GF_PROP_PID_CHANNEL_LAYOUT, &PROP_LONGUINT(ch_layout));
 		}
@@ -833,22 +836,30 @@
 	else if (ch->hvcc) nalu_len = ch->hvcc->nal_unit_size;
 	else if (ch->vvcc) nalu_len = ch->vvcc->nal_unit_size;
 
+	if (!nalu_len) return;
 	reset_state = 0;
 
-	if (!ch->nal_bs) ch->nal_bs = gf_bs_new(ch->sample->data, ch->sample->dataLength, GF_BITSTREAM_READ);
-	else gf_bs_reassign_buffer(ch->nal_bs, ch->sample->data, ch->sample->dataLength);
+	pos = 0;
 
 	while (1) {
 		Bool replace_nal = GF_FALSE;
 		u8 nal_type=0;
-		u32 pos = (u32) gf_bs_get_position(ch->nal_bs);
 		if (pos + nalu_len >= ch->sample->dataLength) break;
-		u32 size = gf_bs_read_int(ch->nal_bs, nalu_len*8);
+		u32 tmp=0, size = 0;
+		while (tmp<nalu_len-1) {
+			size |= ch->sample->datapos+tmp;
+			tmp++;
+			size<<=8;
+		}
+		size |= ch->sample->datapos+tmp;
+		//we allow nal_size=0 for incomplete files, abort as soon as we see one to avoid parsing thousands of 0 bytes
+		if (!size) break;
+
 		//this takes care of size + pos + nalu_len > 0 but (s32) size < 0 ...
 		if (ch->sample->dataLength < size) break;
 		if (ch->sample->dataLength < size + pos + nalu_len) break;
 		if (ch->check_avc_ps) {
-			u8 hdr = gf_bs_peek_bits(ch->nal_bs, 8, 0);
+			u8 hdr = ch->sample->datapos + nalu_len;
 			nal_type = hdr & 0x1F;
 			switch (nal_type) {
 			case GF_AVC_NALU_SEQ_PARAM:
@@ -859,7 +870,7 @@
 			}
 		}
 		else if (ch->check_hevc_ps) {
-			u8 hdr = gf_bs_peek_bits(ch->nal_bs, 8, 0);
+			u8 hdr = ch->sample->datapos + nalu_len;
 			nal_type = (hdr & 0x7E) >> 1;
 			switch (nal_type) {
 			case GF_HEVC_NALU_VID_PARAM:
@@ -870,18 +881,18 @@
 			}
 		}
 		else if (ch->check_vvc_ps) {
-			u8 hdr = gf_bs_peek_bits(ch->nal_bs, 8, 1);
+			u8 hdr = ch->sample->datapos + nalu_len + 1;
 			nal_type = hdr >> 3;
 			switch (nal_type) {
 			case GF_VVC_NALU_VID_PARAM:
 			case GF_VVC_NALU_SEQ_PARAM:
 			case GF_VVC_NALU_PIC_PARAM:
 			case GF_VVC_NALU_DEC_PARAM:
+			case GF_VVC_NALU_OPI:
 				replace_nal = GF_TRUE;
 				break;
 			}
 		}
-		gf_bs_skip_bytes(ch->nal_bs, size);
 
 		if (replace_nal) {
 			u32 move_size = ch->sample->dataLength - size - pos - nalu_len;
@@ -890,13 +901,15 @@
 				memmove(ch->sample->data + pos, ch->sample->data + pos + size + nalu_len, ch->sample->dataLength - size - pos - nalu_len);
 
 			ch->sample->dataLength -= size + nalu_len;
-			gf_bs_reassign_buffer(ch->nal_bs, ch->sample->data, ch->sample->dataLength);
-			gf_bs_seek(ch->nal_bs, pos);
 
 			//remove nal from clear subsample range
 			if (ch->pck_encrypted)
 				isor_sai_bytes_removed(ch, pos, nalu_len+size);
 		}
+		//not skipped, increase pos
+		else {
+			pos += nalu_len + size;
+		}
 	}
 
 	if (reset_state) {
@@ -934,8 +947,7 @@
 		u32 grp_type=0, grp_size=0, grp_parameter=0;
 		const u8 *grp_data=NULL;
 		GF_Err e = gf_isom_enum_sample_group(read->mov, ch->track, ch->sample_num, &grp_idx, &grp_type, &grp_parameter, &grp_data, &grp_size);
-		if (e) continue;
-		if (!grp_type) break;
+		if (e || !grp_type) break;
 		if (!grp_size || !grp_data) continue;
 
 		if (grp_type == GF_4CC('P','S','S','H')) {

gpac-2.0.0.tar.gz/src/filters/jsfilter.c -> gpac-2.2.0.tar.gz/src/filters/jsfilter.c Changed

@@ -155,6 +155,7 @@
 	JSF_PID_EOS_SEEN,
 	JSF_PID_EOS_RECEIVED,
 	JSF_PID_WOULD_BLOCK,
+	JSF_PID_SPARSE,
 	JSF_PID_FILTER_NAME,
 	JSF_PID_FILTER_SRC,
 	JSF_PID_FILTER_ARGS,
@@ -178,6 +179,7 @@
 	JSF_PID_MIN_PCK_DUR,
 	JSF_PID_IS_PLAYING,
 	JSF_PID_NEXT_TS,
+	JSF_PID_HAS_DECODER,
 };
 typedef struct
 {
@@ -411,7 +413,7 @@
 
 	return gf_filter_request_opengl(jsf->filter);
 }
-GF_Err jsf_set_gl_active(JSContext *c)
+GF_Err jsf_set_gl_active(JSContext *c, Bool do_activate)
 {
 	GF_JSFilterCtx *jsf;
 	JSValue global = JS_GetGlobalObject(c);
@@ -422,7 +424,7 @@
 	jsf = JS_GetOpaque(filter_obj, jsf_filter_class_id);
 	JS_FreeValue(c, filter_obj);
 
-	return gf_filter_set_active_opengl_context(jsf->filter);
+	return gf_filter_set_active_opengl_context(jsf->filter, do_activate);
 }
 
 Bool jsf_is_packet(JSContext *c, JSValue obj)
@@ -2077,6 +2079,8 @@
 		return JS_NewBool (ctx, gf_filter_pid_eos_received(pctx->pid) );
 	case JSF_PID_WOULD_BLOCK:
 		return JS_NewBool(ctx, gf_filter_pid_would_block(pctx->pid) );
+	case JSF_PID_SPARSE:
+		return JS_NewBool(ctx, gf_filter_pid_is_sparse(pctx->pid) );
 	case JSF_PID_FILTER_NAME:
 		return JS_NewString(ctx, gf_filter_pid_get_filter_name(pctx->pid) );
 	case JSF_PID_FILTER_SRC:
@@ -2129,6 +2133,9 @@
 		dur = gf_filter_pid_get_next_ts(pctx->pid);
 		if (dur==GF_FILTER_NO_TS) return JS_NULL;
 		return JS_NewInt64(ctx, dur);
+
+	case JSF_PID_HAS_DECODER:
+		return JS_NewBool(ctx, gf_filter_pid_has_decoder(pctx->pid) );
 	}
 return JS_UNDEFINED;
 }
@@ -2433,7 +2440,7 @@
 	SET_PROPB(disconnected)
 	SET_PROP32(average_process_rate)
 	SET_PROP32(max_process_rate)
-	SET_PROP32(avgerage_bitrate)
+	SET_PROP32(average_bitrate)
 	SET_PROP32(max_bitrate)
 	SET_PROP32(nb_processed)
 	SET_PROP32(max_process_time)
@@ -2464,9 +2471,16 @@
 		GF_JSPckCtx *pckc = gf_list_get(pctx->shared_pck, i);
 		if (pckc->pck == pck) {
 			if (!JS_IsUndefined(pckc->cbck_val)) {
-				JSValue res = JS_Call(pctx->jsf->ctx, pckc->cbck_val, pctx->jsobj, 0, NULL);
+				JSValue args2;
+				args0 = JS_DupValue(pctx->jsf->ctx, pctx->jsobj);
+				args1 = JS_DupValue(pctx->jsf->ctx, pckc->jsobj);
+				JSValue res = JS_Call(pctx->jsf->ctx, pckc->cbck_val, pctx->jsobj, 1, args);
+				JS_FreeValue(pctx->jsf->ctx, args0);
+				JS_FreeValue(pctx->jsf->ctx, args1);
+
 				JS_FreeValue(pctx->jsf->ctx, res);
 				JS_FreeValue(pctx->jsf->ctx, pckc->cbck_val);
+				JS_FreeValue(pctx->jsf->ctx, pckc->jsobj);
 				pckc->cbck_val = JS_UNDEFINED;
 			}
 			JS_FreeValue(pctx->jsf->ctx, pckc->ref_val);
@@ -2481,6 +2495,79 @@
 	gf_js_lock(pctx->jsf->ctx, GF_FALSE);
 }
 
+typedef struct
+{
+	GF_JSPidCtx *pctx;
+	GF_JSPckCtx *pck_ctx;
+	JSValue fun;
+	GF_FilterFrameInterface f_ifce;
+} JSGLFIfce;
+
+static void jsf_pck_gl_ifce_del(GF_Filter *filter, GF_FilterPid *PID, GF_FilterPacket *pck)
+{
+	GF_JSPidCtx *pctx = gf_filter_pid_get_udta(PID);
+	gf_js_lock(pctx->jsf->ctx, GF_TRUE);
+	GF_FilterFrameInterface *f_ifce = gf_filter_pck_get_frame_interface(pck);
+	if (f_ifce) {
+		JSGLFIfce *jsgl = f_ifce->user_data;
+		JS_FreeValue(pctx->jsf->ctx, jsgl->fun);
+		JS_FreeValue(pctx->jsf->ctx, jsgl->pck_ctx->jsobj);
+		gf_free(jsgl);
+	}
+	gf_js_lock(pctx->jsf->ctx, GF_FALSE);
+
+	jsf_pck_shared_del(filter, PID, pck);
+}
+
+#if !defined(GPAC_DISABLE_3D) && !defined(GPAC_USE_TINYGL) && !defined(GPAC_USE_GLES1X)
+Bool wgl_texture_get_id(JSContext *ctx, JSValueConst txval, u32 *tx_id);
+#endif
+
+static GF_Err jsf_pck_gl_get_texture(GF_FilterFrameInterface *frame, u32 plane_idx, u32 *gl_tex_format, u32 *gl_tex_id, GF_Matrix_unexposed * texcoordmatrix)
+{
+	JSValue arg3, ret, v;
+	GF_Err e = GF_OK;
+	JSGLFIfce *jsgl = frame->user_data;
+	JSContext *ctx = jsgl->pctx->jsf->ctx;
+	if (!gl_tex_format || !gl_tex_id)
+		return GF_NOT_SUPPORTED;
+
+	gf_js_lock(ctx, GF_TRUE);
+
+	arg0 = JS_DupValue(ctx, jsgl->pctx->jsobj);
+	arg1 = JS_DupValue(ctx, jsgl->pck_ctx->jsobj);
+	arg2 = JS_NewInt32(ctx, plane_idx);
+	ret = JS_Call(ctx, jsgl->fun, jsgl->pctx->jsobj, 3, arg);
+	if (JS_IsException(ret)) {
+		js_dump_error(ctx);
+		e = GF_NOT_SUPPORTED;
+	} else if (JS_IsNull(ret) || !JS_IsObject(ret)) {
+		e = GF_NOT_SUPPORTED;
+	} else {
+		v = JS_GetPropertyStr(ctx, ret, "id");
+		if (JS_IsObject(v)) {
+#if !defined(GPAC_DISABLE_3D) && !defined(GPAC_USE_TINYGL) && !defined(GPAC_USE_GLES1X)
+			if (! wgl_texture_get_id(ctx, v, gl_tex_id))
+#endif
+				e = GF_NOT_SUPPORTED;
+		} else if (JS_ToInt32(ctx, gl_tex_id, v)) {
+			e = GF_NOT_SUPPORTED;
+		}
+		JS_FreeValue(ctx, v);
+		v = JS_GetPropertyStr(ctx, ret, "fmt");
+		if (JS_ToInt32(ctx, gl_tex_format, v))
+			e = GF_NOT_SUPPORTED;
+		JS_FreeValue(ctx, v);
+
+		//todo matrix
+	}
+	JS_FreeValue(ctx, arg0);
+	JS_FreeValue(ctx, arg1);
+	JS_FreeValue(ctx, ret);
+	gf_js_lock(ctx, GF_FALSE);
+	return e;
+}
+
 
 #if !defined(GPAC_DISABLE_3D) && !defined(GPAC_USE_TINYGL) && !defined(GPAC_USE_GLES1X)
 JSValue webgl_get_frame_interface(JSContext *ctx, int argc, JSValueConst *argv, GF_FilterPid *for_pid, gf_fsess_packet_destructor *pck_del, GF_FilterFrameInterface **f_ifce);
@@ -2492,6 +2579,7 @@
 	u8 *data, *ab_data;
 	JSValue obj;
 	Bool use_shared=GF_FALSE;
+	Bool use_gl_ifce=GF_FALSE;
 	GF_JSPckCtx *pckc;
 	GF_JSPidCtx *pctx = JS_GetOpaque(this_val, jsf_pid_class_id);
 
@@ -2518,8 +2606,13 @@
 	pckc->ref_val = JS_UNDEFINED;
 	pckc->data_ab = JS_UNDEFINED;
 
-	if (argc>1)
-		use_shared = JS_ToBool(ctx, argv1);
+	if (argc>1) {
+		if (JS_IsFunction(ctx, argv0)) {
+			use_gl_ifce = GF_TRUE;
+		} else {
+			use_shared = JS_ToBool(ctx, argv1);
+		}
+	}
 
 	if (!argc) {
 		pckc->pck = gf_filter_pck_new_alloc(pctx->pid, 0, NULL);
@@ -2547,8 +2640,11 @@
 			if (!pctx->shared_pck) pctx->shared_pck = gf_list_new();
 			gf_list_add(pctx->shared_pck, pckc);
 			pckc->flags = GF_JS_PCK_IS_SHARED;
-			if ((argc>2) && JS_IsFunction(ctx, argv2))
+			if ((argc>2) && JS_IsFunction(ctx, argv2)) {
 				pckc->cbck_val = JS_DupValue(ctx, argv2);
+				//dup packet obj, it must be kept alive until destructor is called
+				pckc->jsobj = JS_DupValue(ctx, pckc->jsobj);
+			}
 		} else {
 			u8 *pdata=NULL;
 			pckc->pck = gf_filter_pck_new_alloc(pctx->pid, len, &pdata);
@@ -2591,8 +2687,11 @@
 			if (!pctx->shared_pck) pctx->shared_pck = gf_list_new();
 			gf_list_add(pctx->shared_pck, pckc);
 			pckc->flags = GF_JS_PCK_IS_SHARED;
-			if ((argc>2) && JS_IsFunction(ctx, argv2))
+			if ((argc>2) && JS_IsFunction(ctx, argv2)) {
 				pckc->cbck_val = JS_DupValue(ctx, argv2);
+				//dup packet obj, it must be kept alive until destructor is called
+				pckc->jsobj = JS_DupValue(ctx, pckc->jsobj);
+			}
 		} else {
 			pckc->pck = gf_filter_pck_new_alloc(pctx->pid, (u32) ab_size, &data);
 			if (!data) {
@@ -2603,6 +2702,34 @@
 		}
 		goto pck_done;
 	}
+	/*try GL interface*/
+	if (use_gl_ifce) {
+		JSGLFIfce *gl_ifce;
+		GF_SAFEALLOC(gl_ifce, JSGLFIfce);
+		gl_ifce->pctx = pctx;
+		gl_ifce->pck_ctx = pckc;
+		gl_ifce->fun = JS_DupValue(ctx, argv0 );
+		gl_ifce->f_ifce.user_data = gl_ifce;
+		gl_ifce->f_ifce.get_gl_texture = jsf_pck_gl_get_texture;
+		gl_ifce->f_ifce.flags = GF_FRAME_IFCE_BLOCKING;
+		pckc->pck = gf_filter_pck_new_frame_interface(pctx->pid, &gl_ifce->f_ifce, jsf_pck_gl_ifce_del);
+		if (!pctx->shared_pck) pctx->shared_pck = gf_list_new();
+		gf_list_add(pctx->shared_pck, pckc);
+		//dup packet obj since se need it in the fetch texture callback
+		pckc->jsobj = JS_DupValue(ctx, pckc->jsobj);
+		if ((argc>1) && JS_IsFunction(ctx, argv1)) {
+			pckc->cbck_val = JS_DupValue(ctx, argv1);
+			//dup packet obj, it must be kept alive until destructor is called
+			pckc->jsobj = JS_DupValue(ctx, pckc->jsobj);
+			if ((argc>2) && JS_ToBool(ctx, argv2)) {
+				pckc->flags = GF_JS_PCK_IS_SHARED;
+			}
+		}
+		if ((argc>1) && JS_IsBool(argv1) && JS_ToBool(ctx, argv1)) {
+			pckc->flags = GF_JS_PCK_IS_SHARED;
+		}
+		goto pck_done;
+	}
 	/*try WebGL canvas*/
 #if !defined(GPAC_DISABLE_3D) && !defined(GPAC_USE_TINYGL) && !defined(GPAC_USE_GLES1X)
 	gf_fsess_packet_destructor pck_del = NULL;
@@ -2779,6 +2906,7 @@
 JS_CGETSET_MAGIC_DEF("eos_seen", jsf_pid_get_prop, NULL, JSF_PID_EOS_SEEN),
 JS_CGETSET_MAGIC_DEF("eos_received", jsf_pid_get_prop, NULL, JSF_PID_EOS_RECEIVED),
 JS_CGETSET_MAGIC_DEF("would_block", jsf_pid_get_prop, NULL, JSF_PID_WOULD_BLOCK),
+ JS_CGETSET_MAGIC_DEF("sparse", jsf_pid_get_prop, NULL, JSF_PID_SPARSE),
 JS_CGETSET_MAGIC_DEF("filter_name", jsf_pid_get_prop, NULL, JSF_PID_FILTER_NAME),
 JS_CGETSET_MAGIC_DEF("src_name", jsf_pid_get_prop, NULL, JSF_PID_FILTER_SRC),
 JS_CGETSET_MAGIC_DEF("args", jsf_pid_get_prop, NULL, JSF_PID_FILTER_ARGS),
@@ -2802,6 +2930,7 @@
 JS_CGETSET_MAGIC_DEF("min_pck_dur", jsf_pid_get_prop, NULL, JSF_PID_MIN_PCK_DUR),
 JS_CGETSET_MAGIC_DEF("playing", jsf_pid_get_prop, NULL, JSF_PID_IS_PLAYING),
 JS_CGETSET_MAGIC_DEF("next_ts", jsf_pid_get_prop, NULL, JSF_PID_NEXT_TS),
+ JS_CGETSET_MAGIC_DEF("has_decoder", jsf_pid_get_prop, NULL, JSF_PID_HAS_DECODER),
 JS_CFUNC_DEF("send_event", 0, jsf_pid_send_event),
 JS_CFUNC_DEF("enum_properties", 0, jsf_pid_enum_properties),
 JS_CFUNC_DEF("get_prop", 0, jsf_pid_get_property),
@@ -2877,6 +3006,7 @@
 	JSF_EVENT_USER_KEYCODE,
 	JSF_EVENT_USER_KEYNAME,
 	JSF_EVENT_USER_KEYMODS,
+	JSF_EVENT_USER_TEXT_CHAR,
 	JSF_EVENT_USER_MOUSE_X,
 	JSF_EVENT_USER_MOUSE_Y,
 	JSF_EVENT_USER_WHEEL,
@@ -2896,6 +3026,7 @@
 	JSF_EVENT_USER_MOVE_ALIGN_X,
 	JSF_EVENT_USER_MOVE_ALIGN_Y,
 	JSF_EVENT_USER_CAPTION,
+	JSF_EVENT_USER_WINDOW_ID,
 };
 
 static Bool jsf_check_evt(u32 evt_type, u8 ui_type, int magic)
@@ -2997,6 +3128,7 @@
 			case JSF_EVENT_USER_MOUSE_Y:
 			case JSF_EVENT_USER_WHEEL:
 			case JSF_EVENT_USER_BUTTON:
+			case JSF_EVENT_USER_WINDOW_ID:
 				return GF_TRUE;
 			default:
 				break;
@@ -3009,6 +3141,7 @@
 			case JSF_EVENT_USER_MT_ROTATION:
 			case JSF_EVENT_USER_MT_PINCH:
 			case JSF_EVENT_USER_MT_FINGERS:
+			case JSF_EVENT_USER_WINDOW_ID:
 				return GF_TRUE;
 			default:
 				break;
@@ -3024,7 +3157,9 @@
 			case JSF_EVENT_USER_KEYNAME:
 			case JSF_EVENT_USER_KEYMODS:
 			case JSF_EVENT_USER_HWKEY:
+			case JSF_EVENT_USER_TEXT_CHAR:
 			case JSF_EVENT_USER_DROPFILES:
+			case JSF_EVENT_USER_WINDOW_ID:
 				return GF_TRUE;
 			default:
 				break;
@@ -3033,6 +3168,7 @@
 		case GF_EVENT_DROPFILE:
 			switch (magic) {
 			case JSF_EVENT_USER_DROPFILES:
+			case JSF_EVENT_USER_WINDOW_ID:
 				return GF_TRUE;
 			default:
 				break;
@@ -3042,6 +3178,7 @@
 		case GF_EVENT_COPY_TEXT:
 			switch (magic) {
 			case JSF_EVENT_USER_TEXT:
+			case JSF_EVENT_USER_WINDOW_ID:
 				return GF_TRUE;
 			default:
 				break;
@@ -3051,6 +3188,7 @@
 			switch (magic) {
 			case JSF_EVENT_USER_WIDTH:
 			case JSF_EVENT_USER_HEIGHT:
+			case JSF_EVENT_USER_WINDOW_ID:
 				return GF_TRUE;
 			default:
 				break;
@@ -3063,14 +3201,26 @@
 			case JSF_EVENT_USER_MOVE_RELATIVE:
 			case JSF_EVENT_USER_MOVE_ALIGN_X:
 			case JSF_EVENT_USER_MOVE_ALIGN_Y:
+			case JSF_EVENT_USER_WINDOW_ID:
 				return GF_TRUE;
 			default:
 				break;
 			}
 			return GF_FALSE;
 		case GF_EVENT_SET_CAPTION:
-			if (magic==JSF_EVENT_USER_CAPTION) return GF_TRUE;
-			return GF_FALSE;
+			switch (magic) {
+			case JSF_EVENT_USER_CAPTION:
+			case JSF_EVENT_USER_WINDOW_ID:
+				return GF_TRUE;
+			default:
+				return GF_FALSE;
+			}
+			break;
+		case GF_EVENT_REFRESH:
+		case GF_EVENT_QUIT:
+		case GF_EVENT_SHOWHIDE:
+			if (magic==JSF_EVENT_USER_WINDOW_ID) return GF_TRUE;
+			break;
 		}
 	}
 	return GF_FALSE;
@@ -3344,6 +3494,29 @@
 		return JS_NULL;
 #endif
 
+	case JSF_EVENT_USER_TEXT_CHAR:
+	{
+		u32 unic = evt->user_event.event.character.unicode_char;
+		char szSTR5;
+		memset(szSTR, 0, 5);
+		if (unic<0x80) {
+			szSTR0 = (char) unic&0xFF;
+		} else if (unic<0x0800) {
+			szSTR0 = ((char) (unic>>6)&0x1F) | 0xC0;
+			szSTR1 = ((char) (unic) & 0x3F) | 0x80;
+		} else if (unic<0x010000) {
+			szSTR0 = ((char) (unic>>12)&0x0F) | 0xE0;
+			szSTR1 = ((char) (unic>>6) & 0x3F) | 0x80;
+			szSTR2 = ((char) (unic) & 0x3F) | 0x80;
+		} else {
+			szSTR0 = ((char) (unic>>24)&0x07) | 0xF0;
+			szSTR1 = ((char) (unic>>12) & 0x3F) | 0x80;
+			szSTR2 = ((char) (unic>>6) & 0x3F) | 0x80;
+			szSTR3 = ((char) (unic) & 0x3F) | 0x80;
+		}
+		return JS_NewString(ctx, szSTR);
+	}
+
 	case JSF_EVENT_USER_MOUSE_X:
 		if (evt->user_event.event.type==GF_EVENT_MULTITOUCH)
 			return JS_NewFloat64(ctx, FIX2FLT(evt->user_event.event.mtouch.x) );
@@ -3389,6 +3562,35 @@
 
 	case JSF_EVENT_USER_CAPTION:
 		return JS_NewString(ctx, evt->user_event.event.caption.caption ? evt->user_event.event.caption.caption : "");
+
+	case JSF_EVENT_USER_WINDOW_ID:
+		switch (evt->user_event.event.type) {
+		case GF_EVENT_MULTITOUCH:
+			return JS_NewInt32(ctx, evt->user_event.event.mtouch.window_id);
+		case GF_EVENT_MOUSEUP:
+		case GF_EVENT_MOUSEDOWN:
+		case GF_EVENT_MOUSEMOVE:
+		case GF_EVENT_MOUSEWHEEL:
+			return JS_NewInt32(ctx, evt->user_event.event.mouse.window_id);
+		case GF_EVENT_SHOWHIDE:
+		case GF_EVENT_QUIT:
+		case GF_EVENT_REFRESH:
+			return JS_NewInt32(ctx, evt->user_event.event.show.window_id);
+		case GF_EVENT_MOVE:
+			return JS_NewInt32(ctx, evt->user_event.event.move.window_id);
+		case GF_EVENT_KEYUP:
+		case GF_EVENT_KEYDOWN:
+			return JS_NewInt32(ctx, evt->user_event.event.key.window_id);
+		case GF_EVENT_DROPFILE:
+			return JS_NewInt32(ctx, evt->user_event.event.open_file.window_id);
+		case GF_EVENT_PASTE_TEXT:
+		case GF_EVENT_COPY_TEXT:
+			return JS_NewInt32(ctx, evt->user_event.event.clipboard.window_id);
+		case GF_EVENT_TEXTINPUT:
+			return JS_NewInt32(ctx, evt->user_event.event.character.window_id);
+		case GF_EVENT_SIZE:
+			return JS_NewInt32(ctx, evt->user_event.event.size.window_id);
+		}
 	}
 return JS_UNDEFINED;
 }
@@ -3447,6 +3649,7 @@
 JS_CGETSET_MAGIC_DEF("keycode", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_KEYCODE),
 JS_CGETSET_MAGIC_DEF("keyname", jsf_event_get_prop, NULL, JSF_EVENT_USER_KEYNAME),
 JS_CGETSET_MAGIC_DEF("keymods", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_KEYMODS),
+ JS_CGETSET_MAGIC_DEF("char", jsf_event_get_prop, NULL, JSF_EVENT_USER_TEXT_CHAR),
 JS_CGETSET_MAGIC_DEF("mouse_x", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_MOUSE_X),
 JS_CGETSET_MAGIC_DEF("mouse_y", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_MOUSE_Y),
 JS_CGETSET_MAGIC_DEF("wheel", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_WHEEL),
@@ -3454,6 +3657,7 @@
 JS_CGETSET_MAGIC_DEF("hwkey", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_HWKEY),
 JS_CGETSET_MAGIC_DEF("dropfiles", jsf_event_get_prop, NULL, JSF_EVENT_USER_DROPFILES),
 JS_CGETSET_MAGIC_DEF("clipboard", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_TEXT),
+ JS_CGETSET_MAGIC_DEF("window", jsf_event_get_prop, NULL, JSF_EVENT_USER_WINDOW_ID),
 
 JS_CGETSET_MAGIC_DEF("mt_x", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_MOUSE_X),
 JS_CGETSET_MAGIC_DEF("mt_y", jsf_event_get_prop, jsf_event_set_prop, JSF_EVENT_USER_MOUSE_Y),
@@ -3524,6 +3728,7 @@
 	JSF_PCK_SIZE,
 	JSF_PCK_DATA,
 	JSF_PCK_FRAME_IFCE,
+	JSF_PCK_FRAME_IFCE_GL,
 	JSF_PCK_HAS_PROPERTIES,
 };
 
@@ -3724,6 +3929,13 @@
 		if (gf_filter_pck_get_frame_interface(pck) != NULL)
 			return JS_NewBool(ctx, 1);
 		else return JS_NewBool(ctx, 0);
+	case JSF_PCK_FRAME_IFCE_GL:
+	{
+		GF_FilterFrameInterface *fifce = gf_filter_pck_get_frame_interface(pck);
+		if (fifce && fifce->get_gl_texture)
+			return JS_NewBool(ctx, 1);
+		return JS_NewBool(ctx, 0);
+	}
 
 	case JSF_PCK_HAS_PROPERTIES:
 		return JS_NewBool(ctx, gf_filter_pck_has_properties(pck) );
@@ -4090,6 +4302,7 @@
 JS_CGETSET_MAGIC_DEF("size", jsf_pck_get_prop, NULL, JSF_PCK_SIZE),
 JS_CGETSET_MAGIC_DEF("data", jsf_pck_get_prop, NULL, JSF_PCK_DATA),
 JS_CGETSET_MAGIC_DEF("frame_ifce", jsf_pck_get_prop, NULL, JSF_PCK_FRAME_IFCE),
+ JS_CGETSET_MAGIC_DEF("frame_ifce_gl", jsf_pck_get_prop, NULL, JSF_PCK_FRAME_IFCE_GL),
 JS_CGETSET_MAGIC_DEF("has_properties", jsf_pck_get_prop, NULL, JSF_PCK_HAS_PROPERTIES),
 
 JS_CFUNC_DEF("set_readonly", 0, jsf_pck_set_readonly),
@@ -4169,6 +4382,7 @@
 		//force cleanup of all refs
 		gf_js_call_gc(jsf->ctx);
 
+		JS_SetOpaque(pctx->jsobj, NULL);
 		JS_FreeValue(jsf->ctx, pctx->jsobj);
 		gf_list_del_item(jsf->pids, pctx);
 		gf_filter_pid_set_udta(pid, NULL);
@@ -4280,6 +4494,7 @@
 	DEF_CONST(GF_STATS_DECODER_SOURCE)
 	DEF_CONST(GF_STATS_ENCODER_SINK)
 	DEF_CONST(GF_STATS_ENCODER_SOURCE)
+	DEF_CONST(GF_STATS_SINK)
 
 	DEF_CONST(GF_FILTER_CLOCK_NONE)
 	DEF_CONST(GF_FILTER_CLOCK_PCR)
@@ -4292,6 +4507,14 @@
 	DEF_CONST(GF_FILTER_SAP_4)
 	DEF_CONST(GF_FILTER_SAP_4_PROL)
 
+	DEF_CONST(GF_STATS_LOCAL)
+	DEF_CONST(GF_STATS_LOCAL_INPUTS)
+	DEF_CONST(GF_STATS_DECODER_SINK)
+	DEF_CONST(GF_STATS_DECODER_SOURCE)
+	DEF_CONST(GF_STATS_ENCODER_SINK)
+	DEF_CONST(GF_STATS_ENCODER_SOURCE)
+	DEF_CONST(GF_STATS_SINK)
+
 	DEF_CONST(GF_EOS);
 	DEF_CONST(GF_OK)
 	DEF_CONST(GF_BAD_PARAM)
@@ -4323,7 +4546,6 @@
 	DEF_CONST(GF_IP_NETWORK_FAILURE)
 	DEF_CONST(GF_IP_CONNECTION_CLOSED)
 	DEF_CONST(GF_IP_NETWORK_EMPTY)
-	DEF_CONST(GF_IP_SOCK_WOULD_BLOCK)
 	DEF_CONST(GF_IP_UDP_TIMEOUT)
 	DEF_CONST(GF_AUTHENTICATION_FAILURE)
 	DEF_CONST(GF_SCRIPT_NOT_READY)
@@ -4363,6 +4585,8 @@
 	DEF_CONST(GF_EVENT_SET_CAPTION)
 	DEF_CONST(GF_EVENT_REFRESH)
 	DEF_CONST(GF_EVENT_QUIT)
+	DEF_CONST(GF_EVENT_CODEC_SLOW)
+	DEF_CONST(GF_EVENT_CODEC_OK)
 
 	DEF_CONST(GF_KEY_UNIDENTIFIED)
 	DEF_CONST(GF_KEY_ACCEPT)
@@ -4718,8 +4942,15 @@
 		flags = JS_EVAL_TYPE_MODULE;
 	}
 	jsf->disable_filter = GF_TRUE;
+	Bool temp_assign = GF_FALSE;
+	if (!jsf->filter->session->js_ctx) {
+		jsf->filter->session->js_ctx = jsf->ctx;
+		temp_assign = GF_TRUE;
+	}
 	ret = JS_Eval(jsf->ctx, (char *)buf, buf_len, jsf->js, flags);
 	gf_free(buf);
+	if (temp_assign)
+		jsf->filter->session->js_ctx = NULL;
 
 	if (JS_IsException(ret)) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("JSF Error loading script %s\n", jsf->js));
@@ -4778,7 +5009,6 @@
 		gf_fs_unload_script(filter->session, jsf->ctx);
 
 	if (!jsf->is_custom) {
-		u32 i, count;
 		//we created the context, detach all other filters jsvals
 		gf_mx_p(jsf->filter->session->filters_mx);
 		count = gf_list_count(jsf->filter->session->filters);
@@ -4787,6 +5017,10 @@
 			if (a_f == jsf->filter) continue;;
 			jsfs_on_filter_destroyed(a_f);
 		}
+		if (!JS_IsUndefined(jsf->filter->jsval)) {
+			JS_FreeValue(jsf->ctx, jsf->filter->jsval);
+			jsf->filter->jsval = JS_UNDEFINED;
+		}
 		gf_mx_v(jsf->filter->session->filters_mx);
 		gf_js_delete_context(jsf->ctx);
 	} else {
@@ -4871,7 +5105,7 @@
 			JS_DeleteProperty(jsf->ctx, global_obj, prop, 0);
 			JS_FreeValue(jsf->ctx, global_obj);
 			JS_FreeAtom(jsf->ctx, prop);
-			filter->disabled = GF_TRUE;
+			filter->disabled = GF_FILTER_DISABLED_HIDE;
 			jsf->filter_obj = JS_UNDEFINED;
 		}
 		gf_js_lock(jsf->ctx, GF_FALSE);
@@ -4997,7 +5231,7 @@
 	" \n"
 	"For more information on how to use JS filters, please check https://wiki.gpac.io/jsfilter\n")
 	.private_size = sizeof(GF_JSFilterCtx),
-	.flags = GF_FS_REG_SCRIPT,
+	.flags = GF_FS_REG_SCRIPT | GF_FS_REG_TEMP_INIT,
 	.args = JSFilterArgs,
 	SETCAPS(JSFilterCaps),
 	.initialize = jsfilter_initialize,

gpac-2.0.0.tar.gz/src/filters/load_bt_xmt.c -> gpac-2.2.0.tar.gz/src/filters/load_bt_xmt.c Changed

@@ -397,6 +397,7 @@
 		}
 		//init clocks
 		gf_odm_check_buffering(priv->scene->root_od, priv->in_pid);
+		gf_clock_set_time(priv->scene->root_od->ck, 0, 1000);
 		gf_filter_pck_get_framing(pck, &is_start, &is_end);
 		gf_filter_pid_drop_packet(priv->in_pid);
 	}
@@ -516,11 +517,12 @@
 
 	i=0;
 	while ((sc = (GF_StreamContext *)gf_list_enum(priv->ctx->streams, &i))) {
+		Bool flush_all = GF_FALSE;
 		u32 stream_time = gf_clock_time(priv->scene->root_od->ck);
 
 		//compositor is in end of stream mode, flush all commands
 		if (priv->scene->compositor->check_eos_state==2)
-			stream_time=0xFFFFFFFF;
+			flush_all = GF_TRUE;
 
 		/*handle SWF media extraction*/
 		if ((sc->streamType == GF_STREAM_OD) && (priv->load_flags==1)) continue;
@@ -539,9 +541,9 @@
 		/*seek*/
 		if (!sc->last_au_time) {
 			while ((au = (GF_AUContext *)gf_list_enum(sc->AUs, &j))) {
-				u32 au_time = (u32) gf_timestamp_rescale(au->timing, sc->timeScale, 1000);
+				u32 au_time = (u32) gf_timestamp_to_clocktime(au->timing, sc->timeScale);
 
-				if (au_time > stream_time)
+				if (!flush_all && (gf_clock_diff(priv->scene->root_od->ck, stream_time, au_time)>0) )
 					break;
 				if (au->flags & GF_SM_AU_RAP) last_rap = j-1;
 			}
@@ -549,7 +551,7 @@
 		}
 
 		while ((au = (GF_AUContext *)gf_list_enum(sc->AUs, &j))) {
-			u32 au_time = (u32) gf_timestamp_rescale(au->timing, sc->timeScale, 1000);
+			u32 au_time = (u32) gf_timestamp_to_clocktime(au->timing, sc->timeScale);
 
 			if (au_time + 1 <= sc->last_au_time) {
 				/*remove first replace command*/
@@ -567,17 +569,15 @@
 				continue;
 			}
 
-			if (au_time > stream_time) {
-				Double ts_offset;
-				u32 t = au_time - stream_time;
-				if (!min_next_time_ms || (min_next_time_ms>t))
-					min_next_time_ms = t;
+			s32 early = flush_all ? 0 : gf_clock_diff(priv->scene->root_od->ck, stream_time, au_time);
+			if (early>0) {
+				if (!min_next_time_ms || (min_next_time_ms > (u32) early))
+					min_next_time_ms = early;
 
 				updates_pending++;
 
-				ts_offset = (Double) au->timing;
-				ts_offset /= sc->timeScale;
-				gf_sc_sys_frame_pending(priv->scene->compositor, ts_offset, stream_time, filter);
+				u64 cts = gf_timestamp_rescale(au->timing, sc->timeScale, 1000);
+				gf_sc_sys_frame_pending(priv->scene->compositor, (u32) cts, stream_time, filter);
 				break;
 			}
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("CtxLoad %s applying AU time %d\n", priv->file_name, au_time ));
@@ -797,6 +797,7 @@
 
 	e = gf_utf_get_utf8_string_from_bom(probe_data, size, &dst, &res);
 	if (e) return NULL;
+	probe_data = res;
 
 	//strip all spaces and \r\n
 	while (probe_data0 && strchr("\n\r\t ", (char) probe_data0))

gpac-2.0.0.tar.gz/src/filters/load_svg.c -> gpac-2.2.0.tar.gz/src/filters/load_svg.c Changed

gpac-2.0.0.tar.gz/src/filters/load_text.c -> gpac-2.2.0.tar.gz/src/filters/load_text.c Changed

@@ -31,6 +31,7 @@
 #include <gpac/xml.h>
 #include <gpac/token.h>
 #include <gpac/color.h>
+#include <gpac/network.h>
 #include <gpac/internal/media_dev.h>
 #include <gpac/internal/isomedia_dev.h>
 
@@ -39,7 +40,7 @@
 #include <gpac/internal/swf_dev.h>
 #endif
 
-#if !defined(GPAC_DISABLE_ISOM_WRITE) && !defined(GPAC_DISABLE_CORE_TOOLS)
+#if !defined(GPAC_DISABLE_ISOM_WRITE)
 
 #define TTML_NAMESPACE "http://www.w3.org/ns/ttml"
 
@@ -52,16 +53,25 @@
 
 typedef struct __txtin_ctx GF_TXTIn;
 
+enum
+{
+	STXT_MODE_STXT=0,
+	STXT_MODE_TX3G,
+	STXT_MODE_VTT,
+};
+
 struct __txtin_ctx
 {
 	//opts
-	u32 width, height, txtx, txty, fontsize;
+	u32 width, height, txtx, txty, fontsize, stxtmod;
 	s32 zorder;
 	const char *fontname, *lang, *ttml_zero;
-	Bool nodefbox, noflush, webvtt, ttml_embed;
+	Bool nodefbox, noflush, webvtt, ttml_embed, no_empty;
 	u32 timescale;
 	GF_Fraction fps;
-	s32 ttml_dur;
+	Bool ttml_split;
+	GF_Fraction64 ttml_cts;
+	GF_Fraction ttml_dur, stxtdur;
 
 
 	GF_FilterPid *ipid, *opid;
@@ -72,9 +82,10 @@
 	u32 seek_state;
 	Double start_range;
 
+	Bool is_loaded;
 	Bool is_setup;
 
-	GF_Err (*text_process)(GF_Filter *filter, GF_TXTIn *ctx);
+	GF_Err (*text_process)(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck);
 
 	s32 unicode_type;
 
@@ -83,6 +94,7 @@
 	GF_BitStream *bs_w;
 	Bool first_samp;
 	Bool hdr_parsed;
+	Bool unframed, simple_text;
 
 	//state vars for srt
 	u32 state, default_color;
@@ -91,8 +103,10 @@
 	u32 curLine;
 	GF_StyleRecord style;
 
+#ifndef GPAC_DISABLE_VTT
 	//WebVTT state
 	GF_WebVTTParser *vttparser;
+#endif
 
 	//TTXT state
 	GF_DOMParser *parser;
@@ -119,8 +133,11 @@
 	Bool do_suspend;
 #endif
 
+	Bool vtt_to_tx3g;
+	Bool srt_to_tx3g;
 
 	GF_List *intervals;
+	u64 cts_first_interval;
 };
 
 typedef struct
@@ -147,6 +164,8 @@
 	GF_TXTIN_MODE_WEBVTT,
 	GF_TXTIN_MODE_TTML,
 	GF_TXTIN_MODE_SWF_SVG,
+	GF_TXTIN_MODE_SSA,
+	GF_TXTIN_MODE_SIMPLE,
 };
 
 #define REM_TRAIL_MARKS(__str, __sep) while (1) {	\
@@ -158,7 +177,7 @@
 	}	\
 
 
-s32 gf_text_get_utf_type(FILE *in_src)
+s32 gf_text_get_utf_type(GF_TXTIn *ctx, FILE *in_src)
 {
 	u32 read;
 	unsigned char BOM5;
@@ -168,13 +187,15 @@
 
 	if ((BOM0==0xFF) && (BOM1==0xFE)) {
 		/*UTF32 not supported*/
-		if (!BOM2 && !BOM3) return -1;
+		if (!BOM2 && !BOM3)
+			return -1;
 		gf_fseek(in_src, 2, SEEK_SET);
 		return 3;
 	}
 	if ((BOM0==0xFE) && (BOM1==0xFF)) {
 		/*UTF32 not supported*/
-		if (!BOM2 && !BOM3) return -1;
+		if (!BOM2 && !BOM3)
+			return -1;
 		gf_fseek(in_src, 2, SEEK_SET);
 		return 2;
 	} else if ((BOM0==0xEF) && (BOM1==0xBB) && (BOM2==0xBF)) {
@@ -185,7 +206,15 @@
 		gf_fseek(in_src, 0, SEEK_SET);
 		return 0;
 	}
-	return -1;
+	const char *opt = gf_opts_get_key("core", "charset");
+	if (opt) {
+		if (!stricmp(opt, "utf8") || !stricmp(opt, "utf-8")) return 1;
+		if (!stricmp(opt, "utf16") || !stricmp(opt, "utf-16")) return 2;
+		if (!stricmp(opt, "utf16be") || !stricmp(opt, "utf-16be") || !stricmp(opt, "utf-16-be") || !stricmp(opt, "utf16-be")) return 3;
+		return 0;
+	}
+	GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TXTIn Unknown text encoding for PID %s, defaulting to passthrough - use `-charset` to override\n", gf_filter_pid_get_name(ctx->ipid)));
+	return 0;
 }
 static void ttxt_dom_progress(void *cbk, u64 cur_samp, u64 count)
 {
@@ -193,14 +222,14 @@
 	ctx->end = count;
 }
 
-static GF_Err gf_text_guess_format(const char *filename, u32 *fmt)
+static GF_Err gf_text_guess_format(GF_TXTIn *ctx, const char *filename, u32 *fmt)
 {
-	char szLine2048;
+	char szLine2048, *line;
 	u32 val;
 	s32 uni_type;
 	FILE *test = gf_fopen(filename, "rb");
 	if (!test) return GF_URL_ERROR;
-	uni_type = gf_text_get_utf_type(test);
+	uni_type = gf_text_get_utf_type(ctx, test);
 
 	if (uni_type>1) {
 		const u16 *sptr;
@@ -221,13 +250,19 @@
 	}
 	REM_TRAIL_MARKS(szLine, "\r\n\t ")
 
+	//strip all spaces and \r\n\t
+	line = szLine;
+	while (line0 && strchr("\n\r\t ", (char) line0))
+		line ++;
+
+
 	*fmt = GF_TXTIN_MODE_NONE;
-	if ((szLine0=='{') && strstr(szLine, "}{")) *fmt = GF_TXTIN_MODE_SUB;
-	else if (szLine0 == '<') {
+	if ((line0=='{') && strstr(line, "}{")) *fmt = GF_TXTIN_MODE_SUB;
+	else if (line0 == '<') {
 		char *ext = gf_file_ext_start(filename);
 		if (ext && !strnicmp(ext, ".ttxt", 5)) *fmt = GF_TXTIN_MODE_TTXT;
 		else if (ext && !strnicmp(ext, ".ttml", 5)) *fmt = GF_TXTIN_MODE_TTML;
-		ext = strstr(szLine, "?>");
+		ext = strstr(line, "?>");
 		if (ext) ext += 2;
 		if (ext && !ext0) {
 			if (!gf_fgets(szLine, 2048, test))
@@ -235,15 +270,17 @@
 		}
 		if (strstr(szLine, "x-quicktime-tx3g") || strstr(szLine, "text3GTrack")) *fmt = GF_TXTIN_MODE_TEXML;
 		else if (strstr(szLine, "TextStream")) *fmt = GF_TXTIN_MODE_TTXT;
-		else if (strstr(szLine, "tt")) *fmt = GF_TXTIN_MODE_TTML;
+		else if (strstr(szLine, "<tt ") || strstr(szLine, ":tt ")) *fmt = GF_TXTIN_MODE_TTML;
 	}
-	else if (strstr(szLine, "WEBVTT") )
+	else if (strstr(line, "WEBVTT") )
 		*fmt = GF_TXTIN_MODE_WEBVTT;
-	else if (strstr(szLine, " --> ") )
+	else if (strstr(line, " --> ") )
 		*fmt = GF_TXTIN_MODE_SRT; /* might want to change the default to WebVTT */
 
-	else if (!strncmp(szLine, "FWS", 3) || !strncmp(szLine, "CWS", 3))
+	else if (!strncmp(line, "FWS", 3) || !strncmp(line, "CWS", 3))
 		*fmt = GF_TXTIN_MODE_SWF_SVG;
+	else if (!strncmp(line, "Script Info", 13) )
+		*fmt = GF_TXTIN_MODE_SSA;
 
 	gf_fclose(test);
 	return GF_OK;
@@ -357,7 +394,7 @@
 #endif
 		return;
 	}
-	if ((ctx->fmt == GF_TXTIN_MODE_SRT) || (ctx->fmt == GF_TXTIN_MODE_WEBVTT) || (ctx->fmt == GF_TXTIN_MODE_SUB)) {
+	if ((ctx->fmt == GF_TXTIN_MODE_SRT) || (ctx->fmt == GF_TXTIN_MODE_WEBVTT) || (ctx->fmt == GF_TXTIN_MODE_SUB) || (ctx->fmt == GF_TXTIN_MODE_SSA)) {
 		u64 pos = gf_ftell(ctx->src);
 		gf_fseek(ctx->src, 0, SEEK_SET);
 		while (!gf_feof(ctx->src)) {
@@ -377,10 +414,31 @@
 						end = 1000 * eframe / 25;
 					if (end > (u64) dur.num) dur.num = (s64) end;
 				}
+			} else if (ctx->fmt == GF_TXTIN_MODE_SSA) {
+				if (strncmp(szLine, "Dialogue: ", 10)) continue;
+				char *start_p = strchr(szLine+10, ',');
+				if (!start_p) continue;
+				char *end_p = strchr(start_p+1, ',');
+				if (!end_p) continue;
+				end_p0 = 0;
+				end_p +=1;
+				start_p = strchr(end_p, ',');
+				if (start_p) start_p0 = 0;
+
+				u32 eh, em, es, ems;
+				if (sscanf(end_p, "%u:%u:%u.%u", &eh, &em, &es, &ems) != 4) {
+					eh = 0;
+					if (sscanf(end_p, "%u:%u.%u", &em, &es, &ems) != 3) {
+						continue;
+					}
+				}
+				end = (3600*eh + 60*em + es)*1000 + ems;
+				if (end > (u64) dur.num) dur.num = (s64) end;
 			} else {
 				u32 eh, em, es, ems;
 				char *start = strstr(szLine, "-->");
 				if (!start) continue;
+				start+=3;
 				while (start0 && ((start0 == ' ') || (start0 == '\t'))) start++;
 
 				if (sscanf(start, "%u:%u:%u,%u", &eh, &em, &es, &ems) != 4) {
@@ -491,37 +549,45 @@
 	GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TXTIn Duration probing not supported for format %d\n", ctx->fmt));
 }
 
-static GF_Err txtin_setup_srt(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err txtin_setup_srt(GF_Filter *filter, GF_TXTIn *ctx, Bool gen_dsi_only)
 {
-	u32 ID, OCR_ES_ID, dsi_len, file_size;
+	u32 ID, OCR_ES_ID, dsi_len, file_size=0;
 	u8 *dsi;
 	GF_TextSampleDescriptor *sd;
 
-	ctx->src = gf_fopen(ctx->file_name, "rb");
-	if (!ctx->src) return GF_URL_ERROR;
-
-	file_size = (u32) gf_fsize(ctx->src);
-
-	ctx->unicode_type = gf_text_get_utf_type(ctx->src);
-	if (ctx->unicode_type<0) {
-		gf_fclose(ctx->src);
-		ctx->src = NULL;
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn Unsupported SRT UTF encoding\n"));
-		return GF_NOT_SUPPORTED;
+	if (!gen_dsi_only) {
+		if (!ctx->unframed)
+			ctx->src = gf_fopen(ctx->file_name, "rb");
+
+		if (!ctx->src) return GF_URL_ERROR;
+
+		file_size = (u32) gf_fsize(ctx->src);
+
+		ctx->unicode_type = gf_text_get_utf_type(ctx, ctx->src);
+		if (ctx->unicode_type<0) {
+			gf_fclose(ctx->src);
+			ctx->src = NULL;
+			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn Unsupported SRT UTF encoding\n"));
+			return GF_NOT_SUPPORTED;
+		}
 	}
 
 	if (!ctx->timescale) ctx->timescale = 1000;
 	OCR_ES_ID = ID = 0;
 
-	if (!ctx->opid) ctx->opid = gf_filter_pid_new(filter);
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT) );
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_TX3G) );
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->timescale) );
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DOWN_SIZE, &PROP_LONGUINT(file_size) );
+	if (!ctx->unframed) {
+		if (!ctx->opid) ctx->opid = gf_filter_pid_new(filter);
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT) );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_TX3G) );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->timescale) );
+		if (file_size)
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DOWN_SIZE, &PROP_LONGUINT(file_size) );
+
+		if (!ID) ID = 1;
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_ID, &PROP_UINT(ID) );
+		if (OCR_ES_ID) gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CLOCK_ID, &PROP_UINT(OCR_ES_ID) );
+	}
 
-	if (!ID) ID = 1;
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_ID, &PROP_UINT(ID) );
-	if (OCR_ES_ID) gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CLOCK_ID, &PROP_UINT(OCR_ES_ID) );
 	if (ctx->width) gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_WIDTH, &PROP_UINT(ctx->width) );
 	if (ctx->height) gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_HEIGHT, &PROP_UINT(ctx->height) );
 	if (ctx->zorder) gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_ZORDER, &PROP_SINT(ctx->zorder) );
@@ -556,14 +622,21 @@
 
 	gf_odf_desc_del((GF_Descriptor *)sd);
 
+	if (gen_dsi_only) return GF_OK;
+
 	ctx->default_color = ctx->style.text_color;
-	ctx->samp = gf_isom_new_text_sample();
-	ctx->state = 0;
-	ctx->end = ctx->prev_end = ctx->start = 0;
 	ctx->first_samp = GF_TRUE;
-	ctx->curLine = 0;
 
-	txtin_probe_duration(ctx);
+	ctx->samp = gf_isom_new_text_sample();
+	ctx->prev_end = 0;
+	if (!ctx->unframed) {
+		ctx->state = 0;
+		ctx->end = ctx->start = 0;
+		ctx->curLine = 0;
+
+		txtin_probe_duration(ctx);
+	}
+
 	return GF_OK;
 }
 
@@ -573,6 +646,11 @@
 	u8 *pck_data;
 	u32 size;
 
+	if (!txt_samp)
+		return;
+	if ((!txt_samp->text || !txt_samp->len) && ctx->no_empty)
+		return;
+
 	if (ctx->seek_state==2) {
 		Double end = (Double) (ts+duration);
 		end /= 1000;
@@ -598,22 +676,256 @@
 	gf_filter_pck_send(dst_pck);
 }
 
-static GF_Err txtin_process_srt(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err parse_srt_line(GF_TXTIn *ctx, char *szLine, u32 *char_l, Bool *set_start_c, Bool *set_end_c)
 {
-	u32 i;
-	u32 sh, sm, ss, sms, eh, em, es, ems, txt_line, char_len, char_line, j, rem_styles;
-	Bool set_start_char, set_end_char, rem_color;
-	u32 line, len;
-	char szLine2048, szText2048, *ptr;
+	u32 i, char_line, j, rem_styles, len;
+	Bool rem_color;
+	char *ptr = szLine;
 	unsigned short uniLine5000, uniText5000, *sptr;
+	char szText2048;
+
+	len = gf_utf8_mbstowcs(uniLine, 5000, (const char **) &ptr);
+	if (len == GF_UTF8_FAIL) {
+		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TXTIn Invalid UTF data (line %d)\n", ctx->curLine));
+		ctx->state = 0;
+		return GF_NON_COMPLIANT_BITSTREAM;
+	}
+
+	i=j=0;
+	rem_styles = 0;
+	rem_color = 0;
+	while (i<len) {
+		u32 font_style = 0;
+		u32 style_nb_chars = 0;
+		u32 style_def_type = 0;
+
+		if ( (uniLinei=='<') && (uniLinei+2=='>')) {
+			style_nb_chars = 3;
+			style_def_type = 1;
+		}
+		else if ( (uniLinei=='<') && (uniLinei+1=='/') && (uniLinei+3=='>')) {
+			style_def_type = 2;
+			style_nb_chars = 4;
+		}
+		else if (uniLinei=='<') {
+			const unsigned short* src = uniLine + i;
+			u32 alen = gf_utf8_wcstombs(szLine, 2048, (const unsigned short**) & src);
+			if (alen == GF_UTF8_FAIL) alen = 0;
+			szLinealen = 0;
+			strlwr(szLine);
+			if (!strncmp(szLine, "<font ", 6) ) {
+				char *a_sep = strstr(szLine, "color");
+				if (a_sep) a_sep = strstr(szLine, "=");
+				if (a_sep) a_sep++;
+				while (a_sep && a_sep0) {
+					if (a_sep0!=' ') break;
+					a_sep++;
+				}
+				if (a_sep) {
+					char *e_sep;
+					if ((a_sep0=='"') || ((a_sep0=='\''))) {
+						e_sep = strchr(a_sep+1, a_sep0);
+						a_sep++;
+					} else {
+						e_sep=a_sep;
+						while (e_sep0) {
+							if (e_sep0==' ') break;
+							if (e_sep0=='>') break;
+							e_sep++;
+						}
+					}
+
+					if (e_sep) {
+						char c_sep = e_sep0;
+						e_sep0 = 0;
+						font_style = gf_color_parse(a_sep);
+						e_sep0 = c_sep;
+						if (c_sep!='>')
+							e_sep = strchr(e_sep+1, '>');
+						if (e_sep) {
+							style_nb_chars = (u32) (1 + e_sep - szLine);
+							style_def_type = 1;
+						}
+					}
+				}
+			}
+			else if (!strncmp(szLine, "", 7) ) {
+				style_nb_chars = 7;
+				style_def_type = 2;
+				font_style = 0xFFFFFFFF;
+			}
+
+
+			else if (!strncmp(szLine, "<strike>", 8) ) {
+				style_nb_chars = 8;
+				style_def_type = 1;
+			}
+			else if (!strncmp(szLine, "</strike>", 9) ) {
+				style_nb_chars = 9;
+				style_def_type = 2;
+				font_style = 0xFFFFFFFF;
+			}
+			//skip unknown
+			else {
+				char *a_sep = strstr(szLine, ">");
+				if (a_sep) {
+					style_nb_chars = (u32) (1 + a_sep - szLine);
+					i += style_nb_chars;
+					continue;
+				}
+			}
+
+		}
+
+		/*start of new style*/
+		if (style_def_type==1) {
+			/*store prev style*/
+			if (*set_end_c) {
+				assert(*set_start_c);
+				gf_isom_text_add_style(ctx->samp, &ctx->style);
+				*set_end_c = *set_start_c = GF_FALSE;
+				ctx->style.style_flags &= ~rem_styles;
+				rem_styles = 0;
+				if (rem_color) {
+					ctx->style.text_color = ctx->default_color;
+					rem_color = 0;
+				}
+			}
+			if (*set_start_c && (ctx->style.startCharOffset != j)) {
+				ctx->style.endCharOffset = *char_l + j;
+				if (ctx->style.style_flags) gf_isom_text_add_style(ctx->samp, &ctx->style);
+			}
+			switch (uniLinei+1) {
+			case 'b':
+			case 'B':
+				ctx->style.style_flags |= GF_TXT_STYLE_BOLD;
+				*set_start_c = GF_TRUE;
+				ctx->style.startCharOffset = *char_l + j;
+				break;
+			case 'i':
+			case 'I':
+				ctx->style.style_flags |= GF_TXT_STYLE_ITALIC;
+				*set_start_c = GF_TRUE;
+				ctx->style.startCharOffset = *char_l + j;
+				break;
+			case 'u':
+			case 'U':
+				ctx->style.style_flags |= GF_TXT_STYLE_UNDERLINED;
+				*set_start_c = GF_TRUE;
+				ctx->style.startCharOffset = *char_l + j;
+				break;
+			case 's':
+			case 'S':
+				ctx->style.style_flags |= GF_TXT_STYLE_STRIKETHROUGH;
+				*set_start_c = GF_TRUE;
+				ctx->style.startCharOffset = *char_l + j;
+				break;
+			case 'f':
+			case 'F':
+				if (font_style) {
+					ctx->style.text_color = font_style;
+					*set_start_c = GF_TRUE;
+					ctx->style.startCharOffset = *char_l + j;
+				}
+				break;
+			}
+			i += style_nb_chars;
+			continue;
+		}
+
+		/*end of prev style*/
+		if (style_def_type==2) {
+			switch (uniLinei+2) {
+			case 'b':
+			case 'B':
+				rem_styles |= GF_TXT_STYLE_BOLD;
+				*set_end_c = GF_TRUE;
+				ctx->style.endCharOffset = *char_l + j;
+				break;
+			case 'i':
+			case 'I':
+				rem_styles |= GF_TXT_STYLE_ITALIC;
+				*set_end_c = GF_TRUE;
+				ctx->style.endCharOffset = *char_l + j;
+				break;
+			case 'u':
+			case 'U':
+				rem_styles |= GF_TXT_STYLE_UNDERLINED;
+				*set_end_c = GF_TRUE;
+				ctx->style.endCharOffset = *char_l + j;
+				break;
+			case 's':
+			case 'S':
+				rem_styles |= GF_TXT_STYLE_STRIKETHROUGH;
+				*set_end_c = GF_TRUE;
+				ctx->style.endCharOffset = *char_l + j;
+				break;
+			case 'f':
+			case 'F':
+				if (font_style) {
+					rem_color = 1;
+					*set_end_c = GF_TRUE;
+					ctx->style.endCharOffset = *char_l + j;
+				}
+			}
+			i+=style_nb_chars;
+			continue;
+		}
+		/*store style*/
+		if (*set_end_c) {
+			gf_isom_text_add_style(ctx->samp, &ctx->style);
+			*set_end_c = GF_FALSE;
+			*set_start_c = GF_TRUE;
+			ctx->style.startCharOffset = *char_l + j;
+			ctx->style.style_flags &= ~rem_styles;
+			rem_styles = 0;
+			ctx->style.text_color = ctx->default_color;
+			rem_color = 0;
+		}
+
+		uniTextj = uniLinei;
+		j++;
+		i++;
+	}
+	/*store last style*/
+	if (*set_end_c) {
+		gf_isom_text_add_style(ctx->samp, &ctx->style);
+		*set_end_c = GF_FALSE;
+		*set_start_c = GF_TRUE;
+		ctx->style.startCharOffset = *char_l + j;
+		ctx->style.style_flags &= ~rem_styles;
+	}
+
+	char_line = j;
+	uniTextj = 0;
+
+	sptr = (u16 *) uniText;
+	len = gf_utf8_wcstombs(szText, 5000, (const u16 **) &sptr);
+	if (len == GF_UTF8_FAIL) len = 0;
+
+	gf_isom_text_add_text(ctx->samp, szText, len);
+	*char_l += char_line;
+	return GF_OK;
+}
+
+static GF_Err txtin_process_srt(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
+{
+	u32 sh, sm, ss, sms, eh, em, es, ems, txt_line, char_len;
+	Bool set_start_char, set_end_char;
+	u32 line;
+	char szLine2048;
 
 	if (!ctx->is_setup) {
 		ctx->is_setup = GF_TRUE;
-		return txtin_setup_srt(filter, ctx);
+		GF_Err e = txtin_setup_srt(filter, ctx, GF_FALSE);
+		if (e || !ctx->unframed) return e;
 	}
 	if (!ctx->opid) return GF_NOT_SUPPORTED;
-	if (!ctx->playstate) return GF_OK;
-	else if (ctx->playstate==2) return GF_EOS;
+
+	if (!ctx->unframed) {
+		if (!ctx->playstate) return GF_OK;
+		else if (ctx->playstate==2) return GF_EOS;
+	}
 
 	txt_line = 0;
 	set_start_char = set_end_char = GF_FALSE;
@@ -680,7 +992,8 @@
 				ctx->style.startCharOffset = ctx->style.endCharOffset = 0;
 				gf_isom_text_reset(ctx->samp);
 
-				gf_filter_pid_set_info(ctx->opid, GF_PROP_PID_DOWN_BYTES, &PROP_LONGUINT( gf_ftell(ctx->src )) );
+				if (!ctx->unframed)
+					gf_filter_pid_set_info(ctx->opid, GF_PROP_PID_DOWN_BYTES, &PROP_LONGUINT( gf_ftell(ctx->src )) );
 			}
 			ctx->state = 0;
 			if (!sOK) break;
@@ -743,221 +1056,17 @@
 				char_len += 1;
 			}
 
-			ptr = (char *) szLine;
-			{
-				len = gf_utf8_mbstowcs(uniLine, 5000, (const char **) &ptr);
-				if (len == GF_UTF8_FAIL) {
-					GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TXTIn Invalid UTF data (line %d)\n", ctx->curLine));
-					ctx->state = 0;
-					len = 0;
-				}
-			}
-			i=j=0;
-			rem_styles = 0;
-			rem_color = 0;
-			while (i<len) {
-				u32 font_style = 0;
-				u32 style_nb_chars = 0;
-				u32 style_def_type = 0;
-
-				if ( (uniLinei=='<') && (uniLinei+2=='>')) {
-					style_nb_chars = 3;
-					style_def_type = 1;
-				}
-				else if ( (uniLinei=='<') && (uniLinei+1=='/') && (uniLinei+3=='>')) {
-					style_def_type = 2;
-					style_nb_chars = 4;
-				}
-				else if (uniLinei=='<') {
-					const unsigned short* src = uniLine + i;
-					u32 alen = gf_utf8_wcstombs(szLine, 2048, (const unsigned short**) & src);
-					if (alen == GF_UTF8_FAIL) alen = 0;
-					szLinealen = 0;
-					strlwr(szLine);
-					if (!strncmp(szLine, "<font ", 6) ) {
-						char *a_sep = strstr(szLine, "color");
-						if (a_sep) a_sep = strchr(a_sep, '"');
-						if (a_sep) {
-							char *e_sep = strchr(a_sep+1, '"');
-							if (e_sep) {
-								e_sep0 = 0;
-								font_style = gf_color_parse(a_sep+1);
-								e_sep0 = '"';
-								e_sep = strchr(e_sep+1, '>');
-								if (e_sep) {
-									style_nb_chars = (u32) (1 + e_sep - szLine);
-									style_def_type = 1;
-								}
-							}
-
-						}
-					}
-					else if (!strncmp(szLine, "", 7) ) {
-						style_nb_chars = 7;
-						style_def_type = 2;
-						font_style = 0xFFFFFFFF;
-					}
-
-
-					else if (!strncmp(szLine, "<strike>", 8) ) {
-						style_nb_chars = 8;
-						style_def_type = 1;
-					}
-					else if (!strncmp(szLine, "</strike>", 9) ) {
-						style_nb_chars = 9;
-						style_def_type = 2;
-						font_style = 0xFFFFFFFF;
-					}
-					//skip unknown
-					else {
-						char *a_sep = strstr(szLine, ">");
-						if (a_sep) {
-							style_nb_chars = (u32) (1 + a_sep - szLine);
-							i += style_nb_chars;
-							continue;
-						}
-					}
-
-				}
-
-				/*start of new style*/
-				if (style_def_type==1) {
-					/*store prev style*/
-					if (set_end_char) {
-						assert(set_start_char);
-						gf_isom_text_add_style(ctx->samp, &ctx->style);
-						set_end_char = set_start_char = GF_FALSE;
-						ctx->style.style_flags &= ~rem_styles;
-						rem_styles = 0;
-						if (rem_color) {
-							ctx->style.text_color = ctx->default_color;
-							rem_color = 0;
-						}
-					}
-					if (set_start_char && (ctx->style.startCharOffset != j)) {
-						ctx->style.endCharOffset = char_len + j;
-						if (ctx->style.style_flags) gf_isom_text_add_style(ctx->samp, &ctx->style);
-					}
-					switch (uniLinei+1) {
-					case 'b':
-					case 'B':
-						ctx->style.style_flags |= GF_TXT_STYLE_BOLD;
-						set_start_char = GF_TRUE;
-						ctx->style.startCharOffset = char_len + j;
-						break;
-					case 'i':
-					case 'I':
-						ctx->style.style_flags |= GF_TXT_STYLE_ITALIC;
-						set_start_char = GF_TRUE;
-						ctx->style.startCharOffset = char_len + j;
-						break;
-					case 'u':
-					case 'U':
-						ctx->style.style_flags |= GF_TXT_STYLE_UNDERLINED;
-						set_start_char = GF_TRUE;
-						ctx->style.startCharOffset = char_len + j;
-						break;
-					case 's':
-					case 'S':
-						ctx->style.style_flags |= GF_TXT_STYLE_STRIKETHROUGH;
-						set_start_char = GF_TRUE;
-						ctx->style.startCharOffset = char_len + j;
-						break;
-					case 'f':
-					case 'F':
-						if (font_style) {
-							ctx->style.text_color = font_style;
-							set_start_char = GF_TRUE;
-							ctx->style.startCharOffset = char_len + j;
-						}
-						break;
-					}
-					i += style_nb_chars;
-					continue;
-				}
-
-				/*end of prev style*/
-				if (style_def_type==2) {
-					switch (uniLinei+2) {
-					case 'b':
-					case 'B':
-						rem_styles |= GF_TXT_STYLE_BOLD;
-						set_end_char = GF_TRUE;
-						ctx->style.endCharOffset = char_len + j;
-						break;
-					case 'i':
-					case 'I':
-						rem_styles |= GF_TXT_STYLE_ITALIC;
-						set_end_char = GF_TRUE;
-						ctx->style.endCharOffset = char_len + j;
-						break;
-					case 'u':
-					case 'U':
-						rem_styles |= GF_TXT_STYLE_UNDERLINED;
-						set_end_char = GF_TRUE;
-						ctx->style.endCharOffset = char_len + j;
-						break;
-					case 's':
-					case 'S':
-						rem_styles |= GF_TXT_STYLE_STRIKETHROUGH;
-						set_end_char = GF_TRUE;
-						ctx->style.endCharOffset = char_len + j;
-						break;
-					case 'f':
-					case 'F':
-						if (font_style) {
-							rem_color = 1;
-							set_end_char = GF_TRUE;
-							ctx->style.endCharOffset = char_len + j;
-						}
-					}
-					i+=style_nb_chars;
-					continue;
-				}
-				/*store style*/
-				if (set_end_char) {
-					gf_isom_text_add_style(ctx->samp, &ctx->style);
-					set_end_char = GF_FALSE;
-					set_start_char = GF_TRUE;
-					ctx->style.startCharOffset = char_len + j;
-					ctx->style.style_flags &= ~rem_styles;
-					rem_styles = 0;
-					ctx->style.text_color = ctx->default_color;
-					rem_color = 0;
-				}
-
-				uniTextj = uniLinei;
-				j++;
-				i++;
-			}
-			/*store last style*/
-			if (set_end_char) {
-				gf_isom_text_add_style(ctx->samp, &ctx->style);
-				set_end_char = GF_FALSE;
-				set_start_char = GF_TRUE;
-				ctx->style.startCharOffset = char_len + j;
-				ctx->style.style_flags &= ~rem_styles;
-			}
-
-			char_line = j;
-			uniTextj = 0;
-
-			sptr = (u16 *) uniText;
-			len = gf_utf8_wcstombs(szText, 5000, (const u16 **) &sptr);
-			if (len == GF_UTF8_FAIL) len = 0;
-
-			gf_isom_text_add_text(ctx->samp, szText, len);
-			char_len += char_line;
+			parse_srt_line(ctx, szLine, &char_len, &set_start_char, &set_end_char);
 			txt_line ++;
 			break;
 		}
 
-		if (gf_filter_pid_would_block(ctx->opid))
+		if (!ctx->unframed && gf_filter_pid_would_block(ctx->opid))
 			return GF_OK;
 	}
 
 	/*final flush*/	
-	if (ctx->end && ! ctx->noflush) {
+	if (!ctx->unframed && ctx->end && ! ctx->noflush) {
 		gf_isom_text_reset(ctx->samp);
 		txtin_process_send_text_sample(ctx, ctx->samp, ctx->end, 0, GF_TRUE);
 		ctx->end = 0;
@@ -1010,7 +1119,11 @@
 		ctx->seek_state = 0;
 	}
 
-	s = gf_isom_webvtt_to_sample(samp);
+	if (ctx->no_empty && !gf_isom_webvtt_cues_count(samp))
+		s = NULL;
+	else
+		s = gf_isom_webvtt_to_sample(samp);
+
 	if (s) {
 		GF_FilterPacket *pck;
 		u8 *pck_data;
@@ -1046,30 +1159,38 @@
 	Bool is_srt;
 	char *ext;
 
-	ctx->src = gf_fopen(ctx->file_name, "rb");
+	if (!ctx->unframed)
+		ctx->src = gf_fopen(ctx->file_name, "rb");
+
+	if (ctx->opid && (ctx->playstate==2)) return GF_EOS;
 	if (!ctx->src) return GF_URL_ERROR;
 
 	file_size = (u32) gf_fsize(ctx->src);
 
-	ctx->unicode_type = gf_text_get_utf_type(ctx->src);
+	ctx->unicode_type = gf_text_get_utf_type(ctx, ctx->src);
 	if (ctx->unicode_type<0) {
 		gf_fclose(ctx->src);
 		ctx->src = NULL;
 		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn Unsupported SRT UTF encoding\n"));
 		return GF_NOT_SUPPORTED;
 	}
-	ext = gf_file_ext_start(ctx->file_name);
-	is_srt = (ext && !strnicmp(ext, ".srt", 4)) ? GF_TRUE : GF_FALSE;
-
+	if (!ctx->unframed) {
+		ext = gf_file_ext_start(ctx->file_name);
+		is_srt = (ext && !strnicmp(ext, ".srt", 4)) ? GF_TRUE : GF_FALSE;
+	} else {
+		is_srt = GF_TRUE;
+	}
 
 	if (!ctx->timescale) ctx->timescale = 1000;
 	OCR_ES_ID = ID = 0;
 
 	if (!ctx->opid) ctx->opid = gf_filter_pid_new(filter);
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT) );
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_WEBVTT) );
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->timescale) );
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DOWN_SIZE, &PROP_LONGUINT(file_size) );
+	if (!ctx->unframed) {
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT) );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_WEBVTT) );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->timescale) );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DOWN_SIZE, &PROP_LONGUINT(file_size) );
+	}
 
 	w = ctx->width;
 	h = ctx->height;
@@ -1092,25 +1213,44 @@
 	//get the header
 	e = gf_webvtt_parser_parse(ctx->vttparser);
 
-	txtin_probe_duration(ctx);
+	if (!ctx->unframed)
+		txtin_probe_duration(ctx);
 	return e;
 }
 
-static GF_Err txtin_process_webvtt(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err txtin_process_webvtt(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
 {
 	GF_Err e;
 
 	if (!ctx->is_setup) {
 		ctx->is_setup = GF_TRUE;
-		return txtin_webvtt_setup(filter, ctx);
+		e = txtin_webvtt_setup(filter, ctx);
+		if (e || !ctx->unframed) return e;
 	}
-	if (!ctx->vttparser) return GF_NOT_SUPPORTED;
+	if (!ctx->vttparser) return (ctx->playstate==2) ? GF_EOS : GF_NOT_SUPPORTED;
+
 	if (ctx->seek_state==1) {
 		ctx->seek_state = 2;
 		gf_webvtt_parser_restart(ctx->vttparser);
 	}
+	if (ctx->unframed) {
+		const GF_PropertyValue *p;
+		const char *vtt_pre=NULL, *vtt_cueid=NULL, *vtt_settings=NULL;
+		p = gf_filter_pck_get_property_str(ipck, "vtt_pre");
+		if (p) vtt_pre = p->value.string;
+		p = gf_filter_pck_get_property_str(ipck, "vtt_cueid");
+		if (p) vtt_cueid = p->value.string;
+		p = gf_filter_pck_get_property_str(ipck, "vtt_settings");
+		if (p) vtt_settings = p->value.string;
+
+		e = gf_webvtt_parser_parse_payload(ctx->vttparser,
+			gf_timestamp_rescale(ctx->start, ctx->timescale, 1000),
+			gf_timestamp_rescale(ctx->end, ctx->timescale, 1000),
+			vtt_pre, vtt_cueid, vtt_settings);
+	} else {
+		e = gf_webvtt_parser_parse(ctx->vttparser);
+	}
 
-	e = gf_webvtt_parser_parse(ctx->vttparser);
 	if (e < GF_OK) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn WebVTT process error %s\n", gf_error_to_string(e) ));
 	}
@@ -1194,10 +1334,10 @@
 	}
 }
 
-static s64 ttml_get_timestamp(GF_TXTIn *ctx, char *value)
+u64 ttml_get_timestamp_ex(char *value, u32 tick_rate, u32 *ttml_fps_num, u32 *ttml_fps_den, u32 *ttml_sfps)
 {
 	u32 h, m, s, ms, f, sf;
-	s64 ts = -1;
+	u64 ts = GF_FILTER_NO_TS;
 	u32 len = (u32) strlen(value);
 
 	//tick metrick - cannot be fractional
@@ -1205,8 +1345,8 @@
 		valuelen-1 = 0;
 		ts = (s64) (atoi(value) * 1000);
 		valuelen-1 = 't';
-		if (ctx->tick_rate)
-			ts /= ctx->tick_rate;
+		if (tick_rate)
+			ts /= tick_rate;
 	}
 	//hours metric, can be fractional
 	else if (len && (valuelen-1=='h')) {
@@ -1244,51 +1384,55 @@
 		}
 		valuelen-1 = 'f';
 
-		if (!ctx->ttml_fps_num) {
+		if (! *ttml_fps_num) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML EBU-TTD time indicates frames but no frame rate set, assuming 25 FPS\n"));
-			ctx->ttml_fps_num = 25;
-			ctx->ttml_fps_den = 1;
+			*ttml_fps_num = 25;
+			*ttml_fps_den = 1;
 		}
-		if (sf && !ctx->ttml_sfps) {
+		if (sf && ! *ttml_sfps) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML EBU-TTD time indicates subframes but no subFrameRate set, assuming 1\n"));
-			ctx->ttml_sfps = 1;
+			*ttml_sfps = 1;
 		}
-		ts = ((s64) 1000 * f * ctx->ttml_fps_den) / ctx->ttml_fps_num;
+		ts = ((s64) 1000 * f * *ttml_fps_den) / *ttml_fps_num;
 		if (sf)
-			ts += ((s64) 1000 * sf * ctx->ttml_fps_den / ctx->ttml_sfps) / ctx->ttml_fps_num;
+			ts += ((s64) 1000 * sf * *ttml_fps_den / *ttml_sfps) / *ttml_fps_num;
 	}
 	else if (sscanf(value, "%u:%u:%u.%u", &h, &m, &s, &ms) == 4) {
 		ts = (h*3600 + m*60+s)*1000+ms;
 	}
 	else if (sscanf(value, "%u:%u:%u:%u.%u", &h, &m, &s, &f, &sf) == 5) {
 		ts = (h*3600 + m*60+s)*1000;
-		if (!ctx->ttml_fps_num) {
+		if (! *ttml_fps_num) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML EBU-TTD time indicates frames but no frame rate set, assuming 25 FPS\n"));
-			ctx->ttml_fps_num = 25;
-			ctx->ttml_fps_den = 1;
+			*ttml_fps_num = 25;
+			*ttml_fps_den = 1;
 		}
-		if (!ctx->ttml_sfps) {
+		if (! *ttml_sfps) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML EBU-TTD time indicates subframes but no subFrameRate set, assuming 1\n"));
-			ctx->ttml_sfps = 1;
+			*ttml_sfps = 1;
 		}
-		ts += ((s64) 1000 * f * ctx->ttml_fps_den) / ctx->ttml_fps_num;
-		ts += ((s64) 1000 * sf * ctx->ttml_fps_den / ctx->ttml_sfps) / ctx->ttml_fps_num;
+		ts += ((s64) 1000 * f * *ttml_fps_den) / *ttml_fps_num;
+		ts += ((s64) 1000 * sf * *ttml_fps_den / *ttml_sfps) / *ttml_fps_num;
 	}
 	else if (sscanf(value, "%u:%u:%u:%u", &h, &m, &s, &f) == 4) {
 		ts = (h*3600 + m*60+s)*1000;
-		if (!ctx->ttml_fps_num) {
+		if (! *ttml_fps_num) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML EBU-TTD time indicates frames but no frame rate set, assuming 25 FPS\n"));
-			ctx->ttml_fps_num = 25;
-			ctx->ttml_fps_den = 1;
+			*ttml_fps_num = 25;
+			*ttml_fps_den = 1;
 		}
-		ts += ((s64) 1000 * f * ctx->ttml_fps_den) / ctx->ttml_fps_num;
+		ts += ((s64) 1000 * f * *ttml_fps_den) / *ttml_fps_num;
 	}
 	else if (sscanf(value, "%u:%u:%u", &h, &m, &s) == 3) {
 		ts = (h*3600 + m*60+s)*1000;
 	}
 	return ts;
 }
+static u64 ttml_get_timestamp(GF_TXTIn *ctx, char *value)
+{
+	return ttml_get_timestamp_ex(value, ctx->tick_rate, &ctx->ttml_fps_num, &ctx->ttml_fps_den, &ctx->ttml_sfps);
 
+}
 static GF_Err ttml_push_interval(GF_TXTIn *ctx, s64 begin, s64 end, TTMLInterval **out_interval)
 {
 	u32 i;
@@ -1306,7 +1450,7 @@
 		interval = gf_list_get(ctx->intervals, i);
 
 		//generate a single sample for the input, merge interval
-		if (ctx->ttml_dur>=0) {
+		if (! ctx->ttml_split) {
 			if (interval->begin > begin) interval->begin = begin;
 			if (interval->end < end) interval->end = end;
 			*out_interval = interval;
@@ -1669,53 +1813,20 @@
 	return GF_OK;
 }
 
-static GF_Err gf_text_ttml_setup(GF_Filter *filter, GF_TXTIn *ctx)
+GF_Err ttml_parse_root(GF_XMLNode *root, const char **lang, u32 *tick_rate, u32 *ttml_fps_num, u32 *ttml_fps_den, u32 *ttml_sfps)
 {
-	GF_Err e;
-	u32 i, nb_children, ID;
-	u64 file_size;
-	s32 sub_fps_num, sub_fps_den;
-	GF_XMLAttribute *att;
-	GF_XMLNode *root, *node, *body_node;
-	const char *lang = ctx->lang;
-
-
-	ctx->is_setup = GF_TRUE;
-	ctx->parser = gf_xml_dom_new();
-	e = gf_xml_dom_parse(ctx->parser, ctx->file_name, ttxt_dom_progress, ctx);
-	if (e) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn Error parsing TTML file: Line %d - %s. Abort.\n", gf_xml_dom_get_line(ctx->parser), gf_xml_dom_get_error(ctx->parser) ));
-		ctx->is_setup = GF_TRUE;
-		ctx->non_compliant_ttml = GF_TRUE;
-		return e;
-	}
-	root = gf_xml_dom_get_root(ctx->parser);
-	if (!root) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn Error parsing TTML file: no root XML element found. Abort.\n"));
-		ctx->non_compliant_ttml = GF_TRUE;
-		return GF_NON_COMPLIANT_BITSTREAM;
-	}
-
-	/*look for TTML*/
-	if (gf_xml_get_element_check_namespace(root, "tt", NULL) != GF_OK) {
-		if (root->ns) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML file not recognized: root element is \"%s:%s\" (check your namespaces)\n", root->ns, root->name));
-		} else {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML file not recognized: root element is \"%s\"\n", root->name));
-		}
-		ctx->non_compliant_ttml = GF_TRUE;
-		return GF_NOT_SUPPORTED;
-	}
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("TXTIn TTML EBU-TTD detected\n"));
-
-	root = gf_xml_dom_get_root(ctx->parser);
-
-
 	/*** root (including language) ***/
-	sub_fps_num = 0;
-	sub_fps_den = 0;
+	GF_XMLAttribute *att;
+	u32 i;
+	u32 sub_fps_num = 0;
+	u32 sub_fps_den = 0;
 	i=0;
+	*lang = NULL;
+	*tick_rate = 0;
+	*ttml_fps_num = 0;
+	*ttml_fps_den = 0;
+	*ttml_sfps = 0;
+
 	while ( (att = (GF_XMLAttribute *)gf_list_enum(root->attributes, &i))) {
 		const char *att_name;
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("TTML Found root attribute name %s, value %s\n", att->name, att->value));
@@ -1727,19 +1838,18 @@
 		if (!strcmp(att->name, "xmlns")) {
 			if (strcmp(att->value, TTML_NAMESPACE)) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TTML XML Namespace %s not recognized, expecting %s\n", att->name, att->value, TTML_NAMESPACE));
-				ctx->non_compliant_ttml = GF_TRUE;
 				return GF_NON_COMPLIANT_BITSTREAM;
 			}
 		}
 		else if (!strcmp(att->name, "xml:lang") && att->value && strlen(att->value)) {
-			lang = att->value;
+			*lang = att->value;
 		}
 		else if (!strcmp(att_name, "tickRate") && att->value) {
-			ctx->tick_rate = atoi(att->value);
+			*tick_rate = atoi(att->value);
 		}
 		else if (!strcmp(att_name, "frameRate") && att->value) {
-			ctx->ttml_fps_num = atoi(att->value);
-			ctx->ttml_fps_den = 1;
+			*ttml_fps_num = atoi(att->value);
+			*ttml_fps_den = 1;
 		}
 		else if (!strcmp(att_name, "frameRateMultiplier") && att->value) {
 			char *sep = strchr(att->value, ' ');
@@ -1755,15 +1865,62 @@
 			}
 		}
 		else if (!strcmp(att_name, "subFrameRate") && att->value) {
-			ctx->ttml_sfps = atoi(att->value);
+			*ttml_sfps = atoi(att->value);
 		}
 	}
 
-	if (sub_fps_num && sub_fps_den && ctx->ttml_fps_num) {
-		ctx->ttml_fps_num *= sub_fps_num;
-		ctx->ttml_fps_den = sub_fps_den;
+	if (sub_fps_num && sub_fps_den && *ttml_fps_num) {
+		*ttml_fps_num *= sub_fps_num;
+		*ttml_fps_den = sub_fps_den;
 	}
+	return GF_OK;
+}
 
+static GF_Err gf_text_ttml_setup(GF_Filter *filter, GF_TXTIn *ctx)
+{
+	GF_Err e;
+	u32 i, nb_children, ID;
+	u64 file_size;
+	GF_XMLNode *root, *node, *body_node;
+	const char *lang = ctx->lang;
+
+
+	ctx->is_setup = GF_TRUE;
+	ctx->parser = gf_xml_dom_new();
+	e = gf_xml_dom_parse(ctx->parser, ctx->file_name, ttxt_dom_progress, ctx);
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn Error parsing TTML file: Line %d - %s. Abort.\n", gf_xml_dom_get_line(ctx->parser), gf_xml_dom_get_error(ctx->parser) ));
+		ctx->is_setup = GF_TRUE;
+		ctx->non_compliant_ttml = GF_TRUE;
+		return e;
+	}
+	root = gf_xml_dom_get_root(ctx->parser);
+	if (!root) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTIn Error parsing TTML file: no root XML element found. Abort.\n"));
+		ctx->non_compliant_ttml = GF_TRUE;
+		return GF_NON_COMPLIANT_BITSTREAM;
+	}
+
+	/*look for TTML*/
+	if (gf_xml_get_element_check_namespace(root, "tt", NULL) != GF_OK) {
+		if (root->ns) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML file not recognized: root element is \"%s:%s\" (check your namespaces)\n", root->ns, root->name));
+		} else {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TTML file not recognized: root element is \"%s\"\n", root->name));
+		}
+		ctx->non_compliant_ttml = GF_TRUE;
+		return GF_NOT_SUPPORTED;
+	}
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("TXTIn TTML EBU-TTD detected\n"));
+
+	root = gf_xml_dom_get_root(ctx->parser);
+
+	e = ttml_parse_root(root, &lang, &ctx->tick_rate, &ctx->ttml_fps_num, &ctx->ttml_fps_den, &ctx->ttml_sfps);
+	if (e) {
+		ctx->non_compliant_ttml = GF_TRUE;
+		return e;
+	}
 	//locate body
 	nb_children = gf_list_count(root->content);
 	body_node = NULL;
@@ -1881,7 +2038,49 @@
 	return GF_FALSE;
 }
 
-static GF_Err gf_text_process_ttml(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err ttml_send_empty_sample(GF_TXTIn *ctx, u64 sample_start, u64 sample_end)
+{
+	//we are not splitting, don't inject empty sample
+	if (! ctx->ttml_split) return GF_OK;
+	if (ctx->no_empty) return GF_OK;
+
+	GF_List *bck = ctx->root_working_copy->content;
+	ctx->root_working_copy->content = gf_list_new();
+	char *samp_text = gf_xml_dom_serialize_root((GF_XMLNode*)ctx->root_working_copy, GF_FALSE, GF_FALSE);
+	gf_list_del(ctx->root_working_copy->content);
+	ctx->root_working_copy->content = bck;
+	if (!samp_text) return GF_OUT_OF_MEM;
+
+	char *txt_str = ttxt_parse_string(samp_text, GF_TRUE);
+	if (!txt_str) txt_str = "";
+	u32 txt_len = (u32) strlen(txt_str);
+	u8 *pck_data;
+	GF_FilterPacket *pck = gf_filter_pck_new_alloc(ctx->opid, txt_len, &pck_data);
+	if (!pck) {
+		gf_free(samp_text);
+		return GF_OUT_OF_MEM;
+	}
+	memcpy(pck_data, txt_str, txt_len);
+	gf_free(samp_text);
+
+	gf_filter_pck_set_sap(pck, GF_FILTER_SAP_1);
+
+	u64 cts = gf_timestamp_rescale(sample_start, 1000, ctx->timescale);
+	if (ctx->ttml_cts.num>=0) {
+		cts += gf_timestamp_rescale(ctx->ttml_cts.num, ctx->ttml_cts.den, ctx->timescale);
+		cts -= ctx->cts_first_interval;
+	}
+	gf_filter_pck_set_cts(pck, cts);
+
+	if (sample_end >= sample_start) {
+		u64 dur = gf_timestamp_rescale(sample_end - sample_start, 1000, ctx->timescale);
+		gf_filter_pck_set_duration(pck, (u32) dur);
+	}
+
+	return gf_filter_pck_send(pck);
+}
+
+static GF_Err gf_text_process_ttml(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
 {
 	GF_Err e;
 	GF_XMLNode *root;
@@ -2065,15 +2264,15 @@
 		}
 
 		if (ctx->first_samp) {
-			interval->begin = 0; /*in MP4 we must start at T=0*/
-			ctx->first_samp = GF_FALSE;
+			ctx->cts_first_interval = 0;
+			//start from 0
+			if (ctx->ttml_cts.num==-1) {
+				interval->begin = 0;
+			} else if (ctx->ttml_cts.num>=0) {
+				ctx->cts_first_interval = gf_timestamp_rescale(interval->begin, 1000, ctx->timescale);
+			}
 		}
 
-		ctx->last_sample_duration = interval->end - interval->begin;
-
-		ctx->end = interval->end;
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("ts_begin="LLD", ts_end="LLD", last_sample_duration="LLU" (real duration: "LLU"), last_sample_end="LLU"\n", interval->begin, interval->end, interval->end - ctx->end, ctx->last_sample_duration, ctx->end));
-
 		if (ctx->seek_state==2) {
 			Double end = (Double) interval->end;
 			end /= ctx->timescale;
@@ -2081,6 +2280,17 @@
 			else ctx->seek_state = 0;
 		}
 
+
+		if (!ctx->first_samp && ((s64)ctx->end < interval->begin)) {
+			ttml_send_empty_sample(ctx, ctx->end, interval->begin);
+		}
+
+		ctx->first_samp = GF_FALSE;
+		ctx->last_sample_duration = interval->end - interval->begin;
+
+		ctx->end = interval->end;
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("ts_begin="LLD", ts_end="LLD", last_sample_duration="LLU" (real duration: "LLU"), last_sample_end="LLU"\n", interval->begin, interval->end, interval->end - ctx->end, ctx->last_sample_duration, ctx->end));
+
 		if (!skip_pck) {
 			pck = gf_filter_pck_new_alloc(ctx->opid, txt_len+res_len, &pck_data);
 			if (!pck) {
@@ -2090,14 +2300,20 @@
 			memcpy(pck_data, txt_str, txt_len);
 			gf_filter_pck_set_sap(pck, GF_FILTER_SAP_1);
 
-			if (ctx->ttml_dur>0) {
-				gf_filter_pck_set_cts(pck, 0);
-				gf_filter_pck_set_duration(pck, (u32) ctx->ttml_dur);
-				ctx->last_sample_duration = (u64) ctx->ttml_dur * 1000 / ctx->timescale;
+			u64 cts = gf_timestamp_rescale(interval->begin, 1000, ctx->timescale);
+			if (ctx->ttml_cts.num>=0) {
+				cts += gf_timestamp_rescale(ctx->ttml_cts.num, ctx->ttml_cts.den, ctx->timescale);
+				cts -= ctx->cts_first_interval;
+			}
+			gf_filter_pck_set_cts(pck, cts);
+
+			if (!ctx->ttml_split && (ctx->ttml_dur.num>0) && ctx->ttml_dur.den) {
+				ctx->last_sample_duration = gf_timestamp_rescale(ctx->ttml_dur.num, ctx->ttml_dur.den, ctx->timescale);
+				gf_filter_pck_set_duration(pck, (u32) ctx->last_sample_duration);
 			} else {
-				gf_filter_pck_set_cts(pck, (ctx->timescale * interval->begin)/1000);
 				if (interval->end >= interval->begin) {
-					gf_filter_pck_set_duration(pck, (u32) ((ctx->timescale * (interval->end - interval->begin) )/1000) );
+					u64 dur = gf_timestamp_rescale(interval->end - interval->begin, 1000, ctx->timescale);
+					gf_filter_pck_set_duration(pck, (u32) dur);
 				}
 			}
 
@@ -2247,7 +2463,7 @@
 	return e;
 }
 
-static GF_Err gf_text_process_swf(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err gf_text_process_swf(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
 {
 	GF_Err e=GF_OK;
 
@@ -2294,17 +2510,17 @@
 
 #endif /*GPAC_DISABLE_SWF_IMPORT*/
 
-static GF_Err gf_text_process_sub(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err gf_text_process_sub(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
 {
 	u32 i, j, len, line;
 	GF_TextSample *samp;
 	Double ts_scale;
-	char szLine2048, szTime20, szText2048;
+	char szLine2048, szTime41, szText2048;
 
 	//same setup as for srt
 	if (!ctx->is_setup) {
 		ctx->is_setup = GF_TRUE;
-		return txtin_setup_srt(filter, ctx);
+		return txtin_setup_srt(filter, ctx, GF_FALSE);
 	}
 	if (!ctx->opid) return GF_NOT_SUPPORTED;
 	if (!ctx->playstate) return GF_OK;
@@ -2341,8 +2557,7 @@
 		while (szLinei+1 && szLinei+1!='}') {
 			szTimei = szLinei+1;
 			i++;
-			if (i>=19)
-				break;
+			if (i>=40) break;
 		}
 		szTimei = 0;
 		ctx->start = atoi(szTime);
@@ -2359,6 +2574,7 @@
 		while (szLinei+1+j && szLinei+1+j!='}') {
 			szTimei = szLinei+1+j;
 			i++;
+			if (i>=40) break;
 		}
 		szTimei = 0;
 		ctx->end = atoi(szTime);
@@ -2415,6 +2631,217 @@
 	return GF_EOS;
 }
 
+static GF_Err gf_text_process_ssa(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
+{
+	u32 i, j, len, line;
+	GF_TextSample *samp;
+	char szLine2048, szText2048;
+
+	//same setup as for srt
+	if (!ctx->is_setup) {
+		ctx->is_setup = GF_TRUE;
+		GF_Err e = txtin_setup_srt(filter, ctx, GF_FALSE);
+		if (e || !ctx->unframed) return e;
+	}
+	if (!ctx->opid) return GF_NOT_SUPPORTED;
+	if (!ctx->unframed) {
+		if (!ctx->playstate) return GF_OK;
+		else if (ctx->playstate==2) return GF_EOS;
+	}
+
+	if (ctx->seek_state==1) {
+		ctx->seek_state = 2;
+		gf_fseek(ctx->src, 0, SEEK_SET);
+	}
+
+	line = 0;
+
+	while (1) {
+		char *start_p, *end_p;
+		u32 eh, em, es, ems, nb_c;
+		char *sOK = gf_text_get_utf8_line(szLine, 2048, ctx->src, ctx->unicode_type);
+		if (!sOK) break;
+
+		REM_TRAIL_MARKS(szLine, "\r\n\t ")
+
+		line++;
+		len = (u32) strlen(szLine);
+		if (!len) continue;
+
+		if (!ctx->unframed) {
+			if (strncmp(szLine, "Dialogue: ", 10)) continue;
+
+			start_p = strchr(szLine+10, ',');
+			if (!start_p) continue;
+			end_p = strchr(start_p+1, ',');
+			if (!end_p) continue;
+			end_p0 = 0;
+			start_p++;
+			if (sscanf(start_p, "%u:%u:%u.%u", &eh, &em, &es, &ems) != 4) {
+				eh = 0;
+				if (sscanf(start_p, "%u:%u.%u", &em, &es, &ems) != 3) {
+					continue;
+				}
+			}
+			ctx->start = (3600*eh + 60*em + es)*1000 + ems;
+
+			start_p = end_p+1;
+			end_p = strchr(start_p, ',');
+			if (!end_p) continue;
+			end_p0 = 0;
+
+			if (sscanf(start_p, "%u:%u:%u.%u", &eh, &em, &es, &ems) != 4) {
+				eh = 0;
+				if (sscanf(start_p, "%u:%u.%u", &em, &es, &ems) != 3) {
+					continue;
+				}
+			}
+			ctx->end = (3600*eh + 60*em + es)*1000 + ems;
+			//skip 6 commas
+			start_p = end_p+1;
+			nb_c=6;
+		} else {
+			start_p = szLine;
+			nb_c=8;
+		}
+
+		while (nb_c) {
+			end_p = strchr(start_p, ',');
+			if (!end_p) break;
+			start_p = end_p+1;
+			nb_c--;
+		}
+		if (nb_c) continue;
+
+		if (ctx->start > ctx->end) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("TXTIn corrupted SSA frame (line %d) - ends (at %u ms) before start of current frame (%u ms) - skipping\n", line, ctx->end, ctx->start));
+			continue;
+		}
+
+		/*make stream start at 0 by inserting a fake AU*/
+		if (ctx->first_samp && (ctx->start > 0)) {
+			txtin_process_send_text_sample(ctx, ctx->samp, 0, (u32) ctx->start, GF_TRUE);
+			ctx->first_samp = GF_FALSE;
+		}
+		else if (ctx->prev_end && (ctx->start != ctx->prev_end) && (ctx->state<=2)) {
+			GF_TextSample * empty_samp = gf_isom_new_text_sample();
+			txtin_process_send_text_sample(ctx, empty_samp, ctx->prev_end, (u32) (ctx->start - ctx->prev_end), GF_TRUE );
+			gf_isom_delete_text_sample(empty_samp);
+		}
+
+		u32 char_len=0;
+		Bool set_start_char=GF_FALSE, set_end_char=GF_FALSE;
+		ctx->style.startCharOffset = ctx->style.endCharOffset = 0;
+		gf_isom_text_reset(ctx->samp);
+
+		memset(szText, 0, 2048);
+		i=j=0;
+		while (1) {
+			char c = start_pi;
+			if (c == 0) {
+				szTextj = 0;
+				break;
+			}
+			if (c=='\\') {
+				if ((start_pi+1 == 'N') || (start_pi+1 == 'n')) {
+					szTextj = 0;
+					parse_srt_line(ctx, szText, &char_len, &set_start_char, &set_end_char);
+
+					j=0;
+					i+=2;
+					memset(szText, 0, 2048);
+					gf_isom_text_add_text(ctx->samp, "\n", 1);
+					char_len += 1;
+					continue;
+				}
+			} else if (c=='{') {
+				if (start_pi+1 == '\\') {
+					u32 style = 0;
+					u32 color=0;
+					Bool is_end = 0;
+					if (start_pi+2 == 'i') style = 1;
+					else if (start_pi+2 == 'b') style = 2;
+					else if (start_pi+2 == 'u') style = 3;
+					else if (start_pi+2 == 'c') {
+						if ((start_pi+3 == '&') && (strlen(start_p+i+4)>8)) {
+							char *col_p = start_p + i+5;
+							style = 4;
+							char szT3;
+							u32 r, g, b;
+							szT2=0;
+							szT0=col_p0;
+							szT1=col_p1;
+							sscanf(szT, "%x", &g);
+							szT0=col_p2;
+							szT1=col_p3;
+							sscanf(szT, "%x", &b);
+							szT0=col_p4;
+							szT1=col_p5;
+							sscanf(szT, "%x", &r);
+							color = GF_COL_ARGB(0xFF, r, g, b);
+						}
+						else if (start_pi+3 == '}') {
+							is_end=GF_TRUE;
+							style = 4;
+						}
+					}
+					else if (start_pi+2 == 's') style = 5;
+
+					if (start_pi+3 == '0') is_end=GF_TRUE;
+					while (start_pi && (start_pi!='}')) i++;
+					i++;
+
+					if (style==1) {
+						if (is_end) {strcat(szText, ""); j+=4;}
+						else {strcat(szText, ""); j+=3;}
+					} else if (style==2) {
+						if (is_end) {strcat(szText, ""); j+=4;}
+						else {strcat(szText, ""); j+=3;}
+					} else if (style==3) {
+						if (is_end) {strcat(szText, ""); j+=4;}
+						else {strcat(szText, ""); j+=3;}
+					} else if (style==4) {
+						if (is_end) {strcat(szText, ""); j+=7;}
+						else {
+							char szFont100;
+							sprintf(szFont, "", color);
+							strcat(szText, szFont);
+							j+=(u32) strlen(szFont);
+						}
+					} else if (style==5) {
+						if (is_end) {strcat(szText, "</strike>"); j+=9;}
+						else {strcat(szText, "<strike>"); j+=8;}
+					}
+					continue;
+				}
+			}
+			szTextj = c;
+			j++;
+			i++;
+		}
+		if (szText0)
+			parse_srt_line(ctx, szText, &char_len, &set_start_char, &set_end_char);
+
+		txtin_process_send_text_sample(ctx, ctx->samp, ctx->start, (u32) (ctx->end - ctx->start), GF_TRUE);
+		ctx->prev_end = ctx->end;
+
+		gf_filter_pid_set_info(ctx->opid, GF_PROP_PID_DOWN_BYTES, &PROP_LONGUINT( gf_ftell(ctx->src)) );
+
+		if (gf_filter_pid_would_block(ctx->opid))
+			return GF_OK;
+	}
+	/*final flush*/
+	if (ctx->end && !ctx->noflush) {
+		samp = gf_isom_new_text_sample();
+		txtin_process_send_text_sample(ctx, samp, ctx->end, 0, GF_TRUE);
+		gf_isom_delete_text_sample(samp);
+	}
+
+	gf_filter_pid_set_info_str( ctx->opid, "ttxt:last_dur", &PROP_UINT(0) );
+
+	return GF_EOS;
+}
+
 
 
 static u32 ttxt_get_color(char *val)
@@ -2507,6 +2934,7 @@
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_TX3G) );
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, &PROP_UINT(ctx->timescale) );
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DOWN_SIZE, &PROP_LONGUINT(file_size) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, NULL);
 
 	if (!ID) ID = 1;
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_ID, &PROP_UINT(ID) );
@@ -2670,7 +3098,7 @@
 	return GF_OK;
 }
 
-static GF_Err txtin_process_ttxt(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err txtin_process_ttxt(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
 {
 	u32 j, k;
 	GF_XMLNode *root, *ext;
@@ -2834,7 +3262,32 @@
 		}
 		ctx->first_samp = GF_FALSE;
 
-		txtin_process_send_text_sample(ctx, samp, ts, 0, GF_TRUE);
+		u64 next_sample_start=0;
+		for (j=ctx->cur_child_idx+1; j < ctx->nb_children; j++) {
+			node = (GF_XMLNode*) gf_list_get(root->content, j);
+
+			if (node->type) {
+				continue;
+			}
+			/*sample text*/
+			else if (strcmp(node->name, "TextSample")) continue;
+
+			j=0;
+			while ( (att=(GF_XMLAttribute*)gf_list_enum(node->attributes, &j))) {
+				if (!strcmp(att->name, "sampleTime")) {
+					u32 h, m, s, ms;
+					if (sscanf(att->value, "%u:%u:%u.%u", &h, &m, &s, &ms) == 4) {
+						next_sample_start = (h*3600 + m*60 + s)*1000 + ms;
+					} else {
+						next_sample_start = (u32) (atof(att->value) * 1000);
+					}
+				}
+			}
+			break;
+		}
+		if (next_sample_start>=ts) next_sample_start -= ts;
+
+		txtin_process_send_text_sample(ctx, samp, ts, (u32) next_sample_start, GF_TRUE);
 
 		gf_isom_delete_text_sample(samp);
 
@@ -2979,7 +3432,7 @@
 	return GF_OK;
 }
 
-static GF_Err txtin_process_texml(GF_Filter *filter, GF_TXTIn *ctx)
+static GF_Err txtin_process_texml(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
 {
 	u32 j, k;
 	GF_StyleRecord styles50;
@@ -3330,6 +3783,56 @@
 	return GF_EOS;
 }
 
+static GF_Err txtin_process_simple(GF_Filter *filter, GF_TXTIn *ctx, GF_FilterPacket *ipck)
+{
+	GF_FilterPacket *opck=NULL;
+	if (ctx->playstate==2) return GF_EOS;
+	if (!ipck) return GF_OK;
+
+	if (ctx->stxtmod==STXT_MODE_TX3G) {
+		u32 size;
+		u8 *output;
+		const u8 *data = gf_filter_pck_get_data(ipck, &size);
+		opck = gf_filter_pck_new_alloc(ctx->opid, size+2, &output);
+		if (opck) {
+			memcpy(output+2, data, size);
+			output0 = (size>>8) & 0xFF;
+			output1 = (size) & 0xFF;
+		}
+	} else if (ctx->stxtmod==STXT_MODE_VTT) {
+		u32 size;
+		u8 *output;
+		const u8 *data = gf_filter_pck_get_data(ipck, &size);
+		opck = gf_filter_pck_new_alloc(ctx->opid, size+16, &output);
+		if (opck) {
+			GF_BitStream *bs = gf_bs_new(output, size+16, GF_BITSTREAM_WRITE);
+			gf_bs_write_u32(bs, size+16);
+			gf_bs_write_u32(bs, GF_ISOM_BOX_TYPE_VTCC_CUE);
+			gf_bs_write_u32(bs, size+8);
+			gf_bs_write_u32(bs, GF_ISOM_BOX_TYPE_PAYL);
+			gf_bs_write_data(bs, data, size);
+			gf_bs_del(bs);
+		}
+	} else {
+		opck = gf_filter_pck_new_ref(ctx->opid, 0, 0, ipck);
+	}
+	if (!opck) return GF_OUT_OF_MEM;
+	gf_filter_pck_set_sap(opck, GF_FILTER_SAP_1);
+	if (gf_filter_pck_get_cts(ipck)==GF_FILTER_NO_TS) {
+		gf_filter_pck_set_dts(opck, 0);
+		gf_filter_pck_set_cts(opck, 0);
+
+		if (!gf_filter_pck_get_duration(ipck)) {
+			s32 dur = (s32) gf_timestamp_rescale_signed(ctx->stxtdur.num, ctx->stxtdur.den, ctx->timescale);
+			if (dur<0) dur = -dur;
+			gf_filter_pck_set_duration(opck, (u32) dur);
+		} else if (ctx->stxtdur.num>0) {
+			u32 dur = (u32) gf_timestamp_rescale(ctx->stxtdur.num, ctx->stxtdur.den, ctx->timescale);
+			gf_filter_pck_set_duration(opck, dur);
+		}
+	}
+	return gf_filter_pck_send(opck);
+}
 
 static GF_Err txtin_process(GF_Filter *filter)
 {
@@ -3338,22 +3841,82 @@
 	GF_Err e;
 	Bool start, end;
 	pck = gf_filter_pid_get_packet(ctx->ipid);
+	if (pck) ctx->is_loaded = GF_FALSE;
+
 	if (!pck) {
-		return GF_OK;
+		if (ctx->unframed) {
+			if (gf_filter_pid_is_eos(ctx->ipid)) {
+				if (ctx->end) {
+#ifndef GPAC_DISABLE_VTT
+					if (ctx->vttparser) {
+						gf_webvtt_parser_flush(ctx->vttparser);
+					}
+					else
+#endif
+					if (!ctx->noflush) {
+						gf_isom_text_reset(ctx->samp);
+						txtin_process_send_text_sample(ctx, ctx->samp, ctx->end, 0, GF_TRUE);
+					}
+					ctx->end = 0;
+				}
+				gf_filter_pid_set_eos(ctx->opid);
+				return GF_EOS;
+			}
+		}
+		if (!ctx->is_loaded)
+			return GF_OK;
 	}
-	gf_filter_pck_get_framing(pck, &start, &end);
-	if (!end) {
+
+	if (ctx->unframed) {
+		if (ctx->simple_text) {
+			e = ctx->text_process(filter, ctx, pck);
+			gf_filter_pid_drop_packet(ctx->ipid);
+			return e;
+		}
+		const u8 *data;
+		u32 size;
+		data = gf_filter_pck_get_data(pck, &size);
+		e = GF_OK;
+		if (data && size) {
+			ctx->src = gf_file_temp(NULL);
+			if (gf_fwrite(data, size, ctx->src) != size)
+				e = GF_IO_ERR;
+			gf_fseek(ctx->src, 0, SEEK_SET);
+			//init state as parsing SRT payload
+			ctx->state = 2;
+			ctx->start = gf_filter_pck_get_cts(pck);
+			ctx->end = ctx->start + gf_filter_pck_get_duration(pck);
+			ctx->curLine = 0;
+
+			if (!e)
+				e = ctx->text_process(filter, ctx, pck);
+
+			if (ctx->src) {
+				gf_fclose(ctx->src);
+				ctx->src = NULL;
+			}
+			if (e==GF_EOS) e = GF_OK;
+		}
 		gf_filter_pid_drop_packet(ctx->ipid);
-		return GF_OK;
+		return e;
 	}
-	//file is loaded
-
-	e = ctx->text_process(filter, ctx);
 
+	if (pck) {
+		gf_filter_pck_get_framing(pck, &start, &end);
+		if (!end) {
+			gf_filter_pid_drop_packet(ctx->ipid);
+			return GF_OK;
+		}
+		//file is loaded
+		ctx->is_loaded = GF_TRUE;
+	}
 
+	e = ctx->text_process(filter, ctx, NULL);
 	if (e==GF_EOS) {
 		//keep input alive until end of stream, so that we keep getting called
-		gf_filter_pid_drop_packet(ctx->ipid);
+		if (pck)
+			gf_filter_pid_drop_packet(ctx->ipid);
+
 		if (gf_filter_pid_is_eos(ctx->ipid))
 			gf_filter_pid_set_eos(ctx->opid);
 	}
@@ -3366,8 +3929,10 @@
 	ctx->samp = NULL;
 	if (ctx->src) gf_fclose(ctx->src);
 	ctx->src = NULL;
+#ifndef GPAC_DISABLE_VTT
 	if (ctx->vttparser) gf_webvtt_parser_del(ctx->vttparser);
 	ctx->vttparser = NULL;
+#endif
 	if (ctx->parser) gf_xml_dom_del(ctx->parser);
 	ctx->parser = NULL;
 	if (ctx->parser_working_copy) gf_xml_dom_del(ctx->parser_working_copy);
@@ -3377,6 +3942,9 @@
 static GF_Err txtin_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
 {
 	GF_Err e;
+	u32 codec_id=0;
+	Bool gen_ttxt_dsi=GF_FALSE;
+	Bool gen_webvtt_dsi=GF_FALSE;
 	const char *src = NULL;
 	GF_TXTIn *ctx = gf_filter_get_udta(filter);
 	const GF_PropertyValue *prop;
@@ -3386,55 +3954,128 @@
 		return GF_OK;
 	}
 
+	ctx->unframed = GF_FALSE;
+	ctx->simple_text = GF_FALSE;
+
 	if (! gf_filter_pid_check_caps(pid))
 		return GF_NOT_SUPPORTED;
 
-	//we must have a file path
-	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_FILEPATH);
-	if (prop && prop->value.string) src = prop->value.string;
-	if (!src)
-		return GF_NOT_SUPPORTED;
+	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+	if (ctx->srt_to_tx3g) {
+		ctx->unframed = GF_TRUE;
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+		ctx->timescale = prop ? prop->value.uint : 1000;
+	}
+	else if (ctx->vtt_to_tx3g) {
+		ctx->unframed = GF_TRUE;
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+		ctx->timescale = prop ? prop->value.uint : 1000;
+	}
+	else if (prop && (
+		(prop->value.uint==GF_CODECID_WEBVTT)
+		|| (prop->value.uint==GF_CODECID_SUBS_SSA)
+	)) {
+		codec_id = prop->value.uint;
+		ctx->unframed = GF_TRUE;
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+		ctx->timescale = prop ? prop->value.uint : 1000;
+	} else if (prop && (
+		(prop->value.uint==GF_CODECID_SIMPLE_TEXT)
+		|| (prop->value.uint==GF_CODECID_SUBS_TEXT)
+	)) {
+		codec_id = prop->value.uint;
+		ctx->unframed = GF_TRUE;
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+		ctx->timescale = prop ? prop->value.uint : 1000;
+		gf_filter_pid_set_framing_mode(pid, GF_TRUE);
+		if (!prop) {
+			ctx->simple_text = GF_TRUE;
+			gf_filter_pid_set_framing_mode(pid, GF_TRUE);
+		}
+	} else {
+		//otherwise we must have a file path
+		prop = gf_filter_pid_get_property(pid, GF_PROP_PID_FILEPATH);
+		if (prop && prop->value.string) src = prop->value.string;
+
+		if (!src)
+			return GF_NOT_SUPPORTED;
+	}
 
 	if (!ctx->ipid) {
 		GF_FilterEvent fevt;
 		ctx->ipid = pid;
 
-		//we work with full file only, send a play event on source to indicate that
-		GF_FEVT_INIT(fevt, GF_FEVT_PLAY, pid);
-		fevt.play.start_range = 0;
-		fevt.base.on_pid = ctx->ipid;
-		fevt.play.full_file_only = GF_TRUE;
-		gf_filter_pid_send_event(ctx->ipid, &fevt);
-		ctx->file_name = gf_strdup(src);
+		if (src) {
+			//we work with full file only, send a play event on source to indicate that
+			GF_FEVT_INIT(fevt, GF_FEVT_PLAY, pid);
+			fevt.play.start_range = 0;
+			fevt.base.on_pid = ctx->ipid;
+			fevt.play.full_file_only = GF_TRUE;
+			gf_filter_pid_send_event(ctx->ipid, &fevt);
+			ctx->file_name = gf_strdup(src);
+		}
 	} else {
 		if (pid != ctx->ipid) {
 			return GF_REQUIRES_NEW_INSTANCE;
 		}
-		if (!strcmp(ctx->file_name, src)) return GF_OK;
+		if (src) {
+			if (!strcmp(ctx->file_name, src)) return GF_OK;
 
-		ttxtin_reset(ctx);
-		ctx->is_setup = GF_FALSE;
-		gf_free(ctx->file_name);
-		ctx->file_name = gf_strdup(src);
+			ttxtin_reset(ctx);
+			ctx->is_setup = GF_FALSE;
+			gf_free(ctx->file_name);
+			ctx->file_name = gf_strdup(src);
+		}
 	}
-	//guess type
-	e = gf_text_guess_format(ctx->file_name, &ctx->fmt);
-	if (e) return e;
-	if (!ctx->fmt) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTLoad Unknown text format for %s\n", ctx->file_name));
-		return GF_NOT_SUPPORTED;
+	if (src) {
+		//guess type
+		e = gf_text_guess_format(ctx, ctx->file_name, &ctx->fmt);
+		if (e) return e;
+		if (!ctx->fmt) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("TXTLoad Unknown text format for %s\n", ctx->file_name));
+			return GF_NOT_SUPPORTED;
+		}
+	} else {
+		if (ctx->vtt_to_tx3g)
+			ctx->fmt = GF_TXTIN_MODE_SRT;
+		else if (ctx->srt_to_tx3g)
+			ctx->fmt = GF_TXTIN_MODE_SRT;
+		else if (codec_id == GF_CODECID_WEBVTT)
+			ctx->fmt = GF_TXTIN_MODE_WEBVTT;
+		else if (codec_id == GF_CODECID_SUBS_SSA)
+			ctx->fmt = GF_TXTIN_MODE_SSA;
+		else
+			ctx->fmt = ctx->simple_text ? GF_TXTIN_MODE_SIMPLE : GF_TXTIN_MODE_SRT;
+		if (!ctx->opid)
+			ctx->opid = gf_filter_pid_new(filter);
 	}
 
 	if (ctx->webvtt && (ctx->fmt == GF_TXTIN_MODE_SRT))
 		ctx->fmt = GF_TXTIN_MODE_WEBVTT;
 
+	if (!src) {
+		gf_filter_pid_copy_properties(ctx->opid, pid);
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT) );
+
+		if (!ctx->simple_text)
+			codec_id = (ctx->fmt == GF_TXTIN_MODE_WEBVTT) ? GF_CODECID_WEBVTT : GF_CODECID_TX3G;
+		else if (ctx->stxtmod)
+			codec_id = (ctx->stxtmod==STXT_MODE_VTT) ? GF_CODECID_WEBVTT : GF_CODECID_TX3G;
+
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(codec_id) );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, NULL);
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, NULL);
+	}
+
 	switch (ctx->fmt) {
 	case GF_TXTIN_MODE_SRT:
 		ctx->text_process = txtin_process_srt;
+		if (!ctx->is_setup && ctx->unframed) gen_ttxt_dsi = GF_TRUE;
 		break;
 #ifndef GPAC_DISABLE_VTT
 	case GF_TXTIN_MODE_WEBVTT:
 		ctx->text_process = txtin_process_webvtt;
+		if (!ctx->is_setup && ctx->unframed) gen_webvtt_dsi = GF_TRUE;
 		break;
 #endif
 	case GF_TXTIN_MODE_TTXT:
@@ -3445,39 +4086,63 @@
 		break;
 	case GF_TXTIN_MODE_SUB:
 		ctx->text_process = gf_text_process_sub;
+		if (!ctx->is_setup && ctx->unframed) gen_ttxt_dsi = GF_TRUE;
 		break;
 	case GF_TXTIN_MODE_TTML:
 		ctx->text_process = gf_text_process_ttml;
 		break;
+	case GF_TXTIN_MODE_SSA:
+		ctx->text_process = gf_text_process_ssa;
+		if (!ctx->is_setup && ctx->unframed) gen_ttxt_dsi = GF_TRUE;
+		break;
 #ifndef GPAC_DISABLE_SWF_IMPORT
 	case GF_TXTIN_MODE_SWF_SVG:
 		ctx->text_process = gf_text_process_swf;
 		break;
 #endif
+	case GF_TXTIN_MODE_SIMPLE:
+		ctx->text_process = txtin_process_simple;
+		if (ctx->stxtmod==STXT_MODE_TX3G) gen_ttxt_dsi = 1;
+		else if (ctx->stxtmod==STXT_MODE_VTT) gen_webvtt_dsi = 1;
+		break;
 	default:
 		return GF_BAD_PARAM;
 	}
 
+	if (gen_ttxt_dsi) {
+		txtin_setup_srt(filter, ctx, GF_TRUE);
+	}
+	if (gen_webvtt_dsi) {
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA((u8 *) "WEBVTT", 7 ) );
+	}
 	return GF_OK;
 }
 
 static Bool txtin_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
 {
 	GF_TXTIn *ctx = gf_filter_get_udta(filter);
+	if (ctx->unframed) return GF_FALSE;
+
 	switch (evt->base.type) {
 	case GF_FEVT_PLAY:
-		if (ctx->playstate==1) return GF_TRUE;
+		if (ctx->playstate==1) return ctx->unframed ? GF_FALSE : GF_TRUE;
+		if ((ctx->playstate==2) && !ctx->unframed)
+			gf_filter_post_process_task(filter);
+
 		ctx->playstate = 1;
-		if ((ctx->start_range < 0.1) && (evt->play.start_range<0.1)) return GF_TRUE;
+		if ((ctx->start_range < 0.1) && (evt->play.start_range<0.1)) return ctx->unframed ? GF_FALSE : GF_TRUE;
 		ctx->start_range = evt->play.start_range;
 		ctx->seek_state = 1;
-		//cancel play event, we work with full file
-		return GF_TRUE;
+		//cancel play event if we work with full file
+		return ctx->unframed ? GF_FALSE : GF_TRUE;
 
 	case GF_FEVT_STOP:
 		ctx->playstate = 2;
-		//cancel play event, we work with full file
-		return GF_TRUE;
+
+		ttxtin_reset(ctx);
+		ctx->is_setup = GF_FALSE;
+		//cancel play event if we work with full file
+		return ctx->unframed ? GF_FALSE : GF_TRUE;
 	default:
 		return GF_FALSE;
 	}
@@ -3537,7 +4202,12 @@
 	char *res=NULL;
 	GF_Err e = gf_utf_get_utf8_string_from_bom((char *)data, data_size, &dst, &res);
 	if (e) return NULL;
-	
+
+	data = res;
+	//strip all spaces and \r\n\t
+	while (data0 && strchr("\n\r\t ", (char) data0))
+		data ++;
+
 #define PROBE_OK(_score, _mime) \
 		*score = _score;\
 		if (dst) gf_free(dst);\
@@ -3553,6 +4223,9 @@
 	if (!strncmp(data, "FWS", 3) || !strncmp(data, "CWS", 3)) {
 		PROBE_OK(GF_FPROBE_MAYBE_SUPPORTED, "application/x-shockwave-flash")
 	}
+	if (!strncmp(data, "Script Info", 12)) {
+		PROBE_OK(GF_FPROBE_MAYBE_SUPPORTED, "subtitle/ssa")
+	}
 
 	if ((data0=='{') && strstr(data, "}{")) {
 		PROBE_OK(GF_FPROBE_MAYBE_SUPPORTED, "subtitle/sub")
@@ -3581,13 +4254,38 @@
 static const GF_FilterCapability TXTInCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "srt|ttxt|sub|vtt|txml|ttml|swf"),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "x-subtitle/srt|subtitle/srt|text/srt|x-subtitle/sub|subtitle/sub|text/sub|x-subtitle/ttxt|subtitle/ttxt|text/ttxt|x-subtitle/vtt|subtitle/vtt|text/vtt|x-quicktime/text|quicktime/text|subtitle/ttml|text/ttml|application/xml+ttml|application/x-shockwave-flash"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "srt|ttxt|sub|vtt|txml|ttml|swf|ssa|ass"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "x-subtitle/srt|subtitle/srt|text/srt|x-subtitle/sub|subtitle/sub|text/sub|x-subtitle/ttxt|subtitle/ttxt|text/ttxt|x-subtitle/vtt|subtitle/vtt|text/vtt|x-quicktime/text|quicktime/text|subtitle/ttml|text/ttml|application/xml+ttml|application/x-shockwave-flash|subtitle/ssa|text/ssa"),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML),
+	{0},
+	//unframed SRT
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_TEXT),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	{0},
+	//unframed WebVTT
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	{0},
+	//unframed SSA
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_SSA),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	{0},
+	//text files
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_SUBS_TEXT),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
 };
 
 #define OFFS(_n)	#_n, offsetof(GF_TXTIn, _n)
@@ -3606,16 +4304,24 @@
 	{ OFFS(txty), "default vertical offset of text area: -1 (bottom), 0 (center) or 1 (top)", GF_PROP_UINT, "0", NULL, 0},
 	{ OFFS(zorder), "default z-order of the PID", GF_PROP_SINT, "0", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(timescale), "default timescale of the PID", GF_PROP_UINT, "1000", NULL, GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(ttml_dur), "force single sample mode", GF_PROP_SINT, "-1", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(ttml_split), "split ttml doc in non-overlapping samples", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(ttml_cts), "first sample cts - see filter help", GF_PROP_FRACTION64, "-1/1", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(ttml_dur), "sample duration when not spliting split - see filter help", GF_PROP_FRACTION, "0/1", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(ttml_embed), "force embedding TTML resources", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(ttml_zero), "set subtitle zero time for TTML", GF_PROP_STRING, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(no_empty), "do not send empty samples", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(stxtdur), "duration for simple text", GF_PROP_FRACTION, "1", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(stxtmod), "simple text stream mode"
+	"- none: declares output PID as simple text stream\n"
+	"- tx3g: declares output PID as TX3G/Apple stream\n"
+	"- vtt: declares output PID as WebVTT stream", GF_PROP_UINT, "none", "none|tx3g|vtt", GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
 GF_FilterRegister TXTInRegister = {
 	.name = "txtin",
 	GF_FS_SET_DESCRIPTION("Subtitle loader")
-	GF_FS_SET_HELP("This filter reads subtitle data from input file PID to produce subtitle frames on a single PID.\n"
+	GF_FS_SET_HELP("This filter reads subtitle data from input PID to produce subtitle frames on a single PID.\n"
 	"The filter supports the following formats:\n"
 	"- SRT: https://en.wikipedia.org/wiki/SubRip\n"
 	"- WebVTT: https://www.w3.org/TR/webvtt1/\n"
@@ -3623,6 +4329,7 @@
 	"- QT 3GPP Text XML (TexML): Apple QT6, likely deprecated\n"
 	"- TTML: https://www.w3.org/TR/ttml2/\n"
 	"- SUB: one subtitle per line formatted as `{start_frame}{end_frame}text`\n"
+	"- SSA (Substation Alpha): basic parsing support for common files\n"
 	"\n"
 	"Input files must be in UTF-8 or UTF-16 format, with or without BOM. The internal frame format is: \n"
 	"- WebVTT (and srt if desired): ISO/IEC 14496-30 VTT cues\n"
@@ -3630,10 +4337,15 @@
 	"- Others: 3GPP/QT Timed Text\n"
 	"\n"
 	"# TTML Support\n"
-	"The -ttml_dur() option controls how the TTML document is split into packets:\n"
-	"- if negative (default), TTML document is split in independent time segments by inspecting all overlapping subtitles in the body\n"
-	"- if 0, the input document is not split, forwarded as a single frame with `CTS` matching the first active time in document and a duration equal to the document duration\n"
-	"- if >0, the input document is not split, forwarded as a single frame with `CTS=0` and the specified duration in `timescale` units.\n"
+	"If -ttml_split() option is set, the TTML document is split in independent time segments by inspecting all overlapping subtitles in the body.\n"
+	"Empty periods in TTML will result in empty TTML documents or will be skipped if -no_empty() option is set.\n"
+	"\n"
+	"The first sample has a CTS assigned as indicated by -ttml_cts():\n"
+	"- a numerator of -2 indicates the first CTS is 0\n"
+	"- a numerator of -1 indicates the first CTS is the first active time in document\n"
+	"- a numerator >= 0 indicates the CTS to use for first sample\n"
+	"\n"
+	"When TTML splitting is disabled, the duration of the TTML sample is given by -ttml_dur() if not 0, or set to the document duration\n"
 	"\n"
 	"By default, media resources are kept as declared in TTML2 documents.\n"
 	"\n"
@@ -3651,9 +4363,16 @@
 	"EX gpac -i test.ttml --ttml_zero=10:00:00 ...\n"
 	"EX gpac -i test.ttml --ttml_zero=T10:00:00 ...\n"
 	"EX MP4Box -add test.ttml --ttml_zero=10:00:00 ...\n"
-
-
-
+	"\n"
+	"# Simple Text Support\n"
+	"The text loader can convert input files in simple text streams of a single packet, by forcing the codec type on the input:"
+	"EX gpac -i test.txt:#CodecID=stxt ...\n"
+	"EX gpac fin:pck=\"Text Data\":#CodecID=stxt ...\n"
+	"\n"
+	"The content of the source file will be the payload of the text sample. The -stxtmod() option allows specifying WebVTT, TX3G or simple text mode for output format.\n"
+	"In this mode, the -stxtdur() option is used to control the duration of the generated subtitle:\n"
+	"- a positive value always forces the duration\n"
+	"- a negative value forces the duration if input packet duration is not known\n"
 	)
 
 	.private_size = sizeof(GF_TXTIn),
@@ -3674,11 +4393,133 @@
 	return &TXTInRegister;
 }
 
+static GF_Err vtt2tx3g_initialize(GF_Filter *filter)
+{
+	GF_TXTIn *ctx = gf_filter_get_udta(filter);
+	txtin_initialize(filter);
+	ctx->vtt_to_tx3g = GF_TRUE;
+	return GF_OK;
+}
+
+static const GF_FilterCapability VTTTX3GCaps =
+{
+	//unframed WebVTT
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_BOOL(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+};
+
+#define OFFS(_n)	#_n, offsetof(GF_TXTIn, _n)
+
+static const GF_FilterArgs VTTTX3GArgs =
+{
+	{ OFFS(fontname), "default font", GF_PROP_STRING, NULL, NULL, 0},
+	{ OFFS(fontsize), "default font size", GF_PROP_UINT, "18", NULL, 0},
+	{0}
+};
+
+GF_FilterRegister VTTTX3GRegister = {
+	.name = "vtt2tx3g",
+	GF_FS_SET_DESCRIPTION("WebVTT to TX3G")
+	GF_FS_SET_HELP("This filter rewrites unframed WebVTT to TX3G / QT Timed Text (binary format)\n"
+	"\n"
+	"Unframed WebVTT packets consist in single cues:\n"
+	"- cue payload as packet payload\n"
+	"- prefix as packet string property `vtt_pre`\n"
+	"- cue ID as packet string property `vtt_cueid`\n"
+	"- cue settings as packet string property `vtt_settings`\n"
+	"- packet timing contains the cue timing (start and duration)\n"
+	)
+
+	.private_size = sizeof(GF_TXTIn),
+	.flags = GF_FS_REG_MAIN_THREAD,
+	.args = VTTTX3GArgs,
+	SETCAPS(VTTTX3GCaps),
+	.process = txtin_process,
+	.configure_pid = txtin_configure_pid,
+	.process_event = txtin_process_event,
+	.probe_data = txtin_probe_data,
+	.initialize = vtt2tx3g_initialize,
+	.finalize = txtin_finalize
+};
+
+const GF_FilterRegister *vtt2tx3g_register(GF_FilterSession *session)
+{
+	return &VTTTX3GRegister;
+}
+
+static GF_Err rfsrt_initialize(GF_Filter *filter)
+{
+	GF_TXTIn *ctx = gf_filter_get_udta(filter);
+	txtin_initialize(filter);
+	ctx->srt_to_tx3g = GF_TRUE;
+	return GF_OK;
+}
+
+static const GF_FilterCapability RFSRTCaps =
+{
+	//unframed WebVTT
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+//	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_TEXT),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_BOOL(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+};
+
+#define OFFS(_n)	#_n, offsetof(GF_TXTIn, _n)
+
+static const GF_FilterArgs RFSRTArgs =
+{
+	{ OFFS(fontname), "default font", GF_PROP_STRING, NULL, NULL, 0},
+	{ OFFS(fontsize), "default font size", GF_PROP_UINT, "18", NULL, 0},
+	{0}
+};
+
+GF_FilterRegister RFSRTRegister = {
+	.name = "rfsrt",
+	GF_FS_SET_DESCRIPTION("SRT reframer")
+	GF_FS_SET_HELP("This filter rewrites unframed SRT to TX3G / QT Timed Text (binary format)\n"
+	"\n"
+	"An unframed SRT packet consists in a single SRT cue as packet payload and packet timing contains the cue timing (start and duration).\n"
+	)
+
+	.private_size = sizeof(GF_TXTIn),
+	.flags = GF_FS_REG_MAIN_THREAD,
+	.args = RFSRTArgs,
+	SETCAPS(RFSRTCaps),
+	.process = txtin_process,
+	.configure_pid = txtin_configure_pid,
+	.process_event = txtin_process_event,
+	.probe_data = txtin_probe_data,
+	.initialize = rfsrt_initialize,
+	.finalize = txtin_finalize
+};
+
+const GF_FilterRegister *rfsrt_register(GF_FilterSession *session)
+{
+	return &RFSRTRegister;
+}
 
 #else
 const GF_FilterRegister *txtin_register(GF_FilterSession *session)
 {
 	return NULL;
 }
+
+const GF_FilterRegister *vtt2tx3g_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+
+const GF_FilterRegister *rfsrt_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+
 #endif // GPAC_DISABLE_ISOM_WRITE

gpac-2.0.0.tar.gz/src/filters/mux_avi.c -> gpac-2.2.0.tar.gz/src/filters/mux_avi.c Changed

gpac-2.0.0.tar.gz/src/filters/mux_gsf.c -> gpac-2.2.0.tar.gz/src/filters/mux_gsf.c Changed

gpac-2.0.0.tar.gz/src/filters/mux_isom.c -> gpac-2.2.0.tar.gz/src/filters/mux_isom.c Changed

@@ -38,7 +38,7 @@
 
 
 #define ISOM_FILE_EXT "mp4|mpg4|m4a|m4i|3gp|3gpp|3g2|3gp2|iso|ismv|m4s|heif|heic|iff|avci|avif|mj2|mov|qt"
-#define ISOM_FILE_MIME "application/x-isomedia|application/mp4|video/mp4|audio/mp4|video/3gpp|audio/3gpp|video/3gp2|audio/3gp2|video/iso.segment|audio/iso.segment|image/heif|image/heic|image/avci|video/quicktime"
+#define ISOM_FILE_MIME "video/mp4|audio/mp4|application/mp4|video/3gpp|audio/3gpp|video/3gp2|audio/3gp2|video/iso.segment|audio/iso.segment|image/heif|image/heic|image/avci|video/jp2|video/quicktime"
 
 enum{
 	NALU_NONE,
@@ -77,6 +77,7 @@
 	GF_FilterPid *ipid;
 	u32 track_num, track_id;
 	GF_ISOSample sample;
+	u32 prev_duration;
 
 	u32 src_timescale;
 	u32 tk_timescale;
@@ -98,14 +99,13 @@
 	u32 nb_samples, samples_in_stsd;
 	u32 nb_frames_per_sample;
 	u64 ts_shift;
+	u64 si_min_ts_plus_one;
 	Bool has_subs;
 
 	Bool skip_bitrate_update;
 	Bool has_open_gop;
 	GF_FilterSAPType gdr_type;
 
-	Bool next_is_first_sample;
-
 	u32 media_profile_level;
 
 	Bool import_msg_header_done;
@@ -124,7 +124,7 @@
 	s32 ts_delay, negctts_shift;
 	Bool insert_tfdt, probe_min_ctts;
 	u64 first_dts_in_seg, next_seg_cts, cts_next;
-	u64 offset_dts;
+	s64 tfdt_offset;
 	u32 samples_in_frag;
 	Bool patch_tfdt;
 
@@ -139,6 +139,7 @@
 	u32 constant_IV_size;
 	Bool cenc_multikey;
 	Bool cenc_frag_protected;
+	u32 skip_byte_block, crypt_byte_block;
 
 	Bool fake_track;
 
@@ -189,6 +190,8 @@
 	u8 *dyn_pssh;
 	u32 dyn_pssh_len;
 
+	Bool sparse_inject;
+
 	GF_FilterPacket *dgl_copy;
 } TrackWriter;
 
@@ -214,6 +217,7 @@
 {
 	MP4MX_PSSH_MOOV=0,
 	MP4MX_PSSH_MOOF,
+	MP4MX_PSSH_BOTH,
 	MP4MX_PSSH_SKIP,
 };
 
@@ -284,7 +288,8 @@
 	Bool ctrni;
 #endif
 	Bool mfra;
-	Bool forcesync, refrag;
+	Bool forcesync, refrag, pad_sparse;
+	Bool force_dv, tsalign;
 	u32 itags;
 	Double start;
 
@@ -325,7 +330,7 @@
 	Bool sidx_size_exact;
 
 	u32 *seg_sizes;
-	u32 nb_seg_sizes, alloc_seg_sizes;
+	u32 nb_seg_sizes, alloc_seg_sizes, config_retry_start;
 	Bool config_timing;
 
 	u32 major_brand_set;
@@ -367,8 +372,14 @@
 
 	u64 wait_dts_plus_one;
 	u32 wait_dts_timescale;
+	Bool force_seg_sync;
+	u32 seg_flush_state;
+	u64 flush_idx_start_range, flush_idx_end_range;
+	Bool flush_ll_hls;
 } GF_MP4MuxCtx;
 
+static void mp4_mux_update_init_edit(GF_MP4MuxCtx *ctx, TrackWriter *tkw, u64 min_ts_service, Bool skip_adjust);
+
 static void mp4_mux_set_hevc_groups(GF_MP4MuxCtx *ctx, TrackWriter *tkw);
 
 static GF_Err mp4mx_setup_dash_vod(GF_MP4MuxCtx *ctx, TrackWriter *tkw)
@@ -382,6 +393,7 @@
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_DURATION);
 		if (p && p->value.lfrac.den) {
 			Double mdur = (Double) p->value.lfrac.num;
+			if (mdur<0) mdur = -mdur;
 			mdur /= p->value.lfrac.den;
 			if (ctx->media_dur < mdur) ctx->media_dur = mdur;
 		}
@@ -519,12 +531,13 @@
 			if (!tkw->nal_unit_size) tkw->nal_unit_size = tkw->vvcc->nal_unit_size;
 			mp4_mux_write_ps_list(bs, mp4_mux_get_nalus_ps(tkw->vvcc->param_array, GF_VVC_NALU_APS_PREFIX), tkw->vvcc->nal_unit_size);
 		} else {
-			if (!for_non_rap)
+			if (!for_non_rap) {
+				mp4_mux_write_ps_list(bs, mp4_mux_get_nalus_ps(tkw->vvcc->param_array, GF_VVC_NALU_OPI), tkw->vvcc->nal_unit_size);
+				mp4_mux_write_ps_list(bs, mp4_mux_get_nalus_ps(tkw->vvcc->param_array, GF_VVC_NALU_DEC_PARAM), tkw->vvcc->nal_unit_size);
 				mp4_mux_write_ps_list(bs, mp4_mux_get_nalus_ps(tkw->vvcc->param_array, GF_VVC_NALU_VID_PARAM), tkw->vvcc->nal_unit_size);
-			if (!tkw->nal_unit_size) tkw->nal_unit_size = tkw->vvcc->nal_unit_size;
-
-			if (!for_non_rap)
 				mp4_mux_write_ps_list(bs, mp4_mux_get_nalus_ps(tkw->vvcc->param_array, GF_VVC_NALU_SEQ_PARAM), tkw->vvcc->nal_unit_size);
+			}
+			if (!tkw->nal_unit_size) tkw->nal_unit_size = tkw->vvcc->nal_unit_size;
 
 			mp4_mux_write_ps_list(bs, mp4_mux_get_nalus_ps(tkw->vvcc->param_array, GF_VVC_NALU_PIC_PARAM), tkw->vvcc->nal_unit_size);
 			mp4_mux_write_ps_list(bs, mp4_mux_get_nalus_ps(tkw->vvcc->param_array, GF_VVC_NALU_APS_PREFIX), tkw->vvcc->nal_unit_size);
@@ -665,6 +678,43 @@
 		tag_idx = gf_itags_find_by_name(tag_name);
 		if (tag_idx>=0) {
 			itag = gf_itags_get_itag(tag_idx);
+		} else if (!strnicmp(tag_name, "qtt_", 4)) {
+			tag_name += 4;
+
+			switch (tag->type) {
+			case GF_PROP_DATA:
+			case GF_PROP_CONST_DATA:
+			case GF_PROP_DATA_NO_COPY:
+			{
+				GF_QT_UDTAKey key;
+				key.type = GF_QT_KEY_OPAQUE;
+				key.name = tag_name;
+				key.ns = GF_4CC('m','d','t','a');
+				char *sep = strchr(tag_name, '@');
+				if (sep) {
+					key.name = sep+1;
+					key.ns = GF_4CC(tag_name0, tag_name1,tag_name2,tag_name3);
+				}
+				key.value.data.data = tag->value.data.ptr;
+				key.value.data.data_len = tag->value.data.size;
+				e = gf_isom_set_qt_key(ctx->file, &key);
+			}
+				break;
+			case GF_PROP_POINTER:
+				e = GF_NOT_SUPPORTED;
+				break;
+			default:
+			{
+				char szDumpGF_PROP_DUMP_ARG_SIZE;
+				const char *str = gf_props_dump_val(tag, szDump, GF_PROP_DUMP_DATA_NONE, NULL);
+				e = gf_media_isom_apply_qt_key(ctx->file, tag_name, str);
+			}
+				break;
+			}
+			if (e) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Failed to set QT tag: %s\n", gf_error_to_string(e)));
+			}
+			continue;
 		} else {
 			if (ctx->itags==TAG_STRICT)
 				continue;
@@ -788,6 +838,7 @@
 	Bool needs_track = GF_FALSE;
 	u32 needs_sample_entry = 0; //1: change of codecID, 2 change of decoder config
 	Bool use_gen_sample_entry = GF_FALSE;
+	Bool skip_crypto = GF_FALSE;
 	Bool use_3gpp_config = GF_FALSE;
 	Bool use_ac3_entry = GF_FALSE;
 	Bool use_flac_entry = GF_FALSE;
@@ -803,6 +854,7 @@
 	Bool skip_dsi = GF_FALSE;
 	Bool is_text_subs = GF_FALSE;
 	Bool force_colr = GF_FALSE;
+	u32 gen_dsi_wrap = 0;
 	u32 m_subtype=0;
 	u32 m_subtype_src=0;
 	u32 m_subtype_alt_raw=0;
@@ -821,6 +873,7 @@
 	Bool unknown_generic = GF_FALSE;
 	u32 multi_pid_final_stsd_idx = 0;
 	u32 audio_pli=0;
+	u32 prev_codecid=0;
 	Bool force_tk_layout = GF_FALSE;
 	Bool force_mix_xps = GF_FALSE;
 	Bool make_inband_headers = GF_FALSE;
@@ -975,6 +1028,7 @@
 	}
 
 	//check change of pid config
+	prev_codecid = tkw->codecid;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
 	if (p) {
 		if (p->value.uint!=tkw->codecid) needs_sample_entry = 1;
@@ -1019,6 +1073,15 @@
 			needs_sample_entry = 2;
 	}
 
+	//store current cenc pattern if any
+	p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_CENC_PATTERN);
+	if (p) {
+		tkw->skip_byte_block = p->value.frac.num;
+		tkw->crypt_byte_block = p->value.frac.den;
+	} else {
+		tkw->skip_byte_block = tkw->crypt_byte_block = 0;
+	}
+
 	//TODO: try to merge PPS/SPS for AVC and HEVC rather than creating a new sample description
 
 	switch (tkw->codecid) {
@@ -1039,6 +1102,13 @@
 	case GF_CODECID_MPEG2_MAIN:
 	case GF_CODECID_MPEG2_SIMPLE:
 	case GF_CODECID_MPEG2_SPATIAL:
+	case GF_CODECID_VP8:
+	case GF_CODECID_VP9:
+	case GF_CODECID_AV1:
+	case GF_CODECID_AC3:
+	case GF_CODECID_EAC3:
+	case GF_CODECID_OPUS:
+	case GF_CODECID_TRUEHD:
 		if (!dsi && !enh_dsi) return GF_OK;
 		break;
 	case GF_CODECID_APCH:
@@ -1056,6 +1126,11 @@
 		}
 		is_prores = GF_TRUE;
 		break;
+	case GF_CODECID_TX3G:
+	case GF_CODECID_WEBVTT:
+	case GF_CODECID_DVB_SUBS:
+		if (!dsi && !enh_dsi) return GF_OK;
+		break;
 	default:
 		break;
 	}
@@ -1102,6 +1177,12 @@
 		ctx->store = MP4MX_MODE_SFRAG;
 	}
 
+	if (ctx->dash_mode == MP4MX_DASH_ON) {
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_FORCE_SEG_SYNC);
+		if (p && p->value.boolean)
+			ctx->force_seg_sync = GF_TRUE;
+	}
+
 	if (!ctx->cdur_set) {
 		ctx->cdur_set = GF_TRUE;
 		if (ctx->cdur.num<0) {
@@ -1139,6 +1220,7 @@
 		u32 tk_idx=0;
 		u32 mtype=0;
 		u32 target_timescale = 0;
+		Bool hdlr_name_set=GF_FALSE;
 
 		if (ctx->make_qt && (tkw->stream_type==GF_STREAM_VISUAL)) {
 			p = gf_filter_pid_get_property(pid, GF_PROP_PID_FPS);
@@ -1215,6 +1297,30 @@
 			ctx->moovts = tkw->tk_timescale;
 			gf_isom_set_timescale(ctx->file, (u32) ctx->moovts);
 		}
+		if (ctx->pad_sparse) {
+			p = gf_filter_pid_get_property(pid, GF_PROP_PID_SPARSE);
+			if (p) {
+				tkw->sparse_inject = p->value.boolean;
+			} else {
+				switch (tkw->stream_type) {
+				case GF_STREAM_TEXT:
+				case GF_STREAM_METADATA:
+					switch (tkw->codecid) {
+					case GF_CODECID_TEXT_MPEG4:
+					case GF_CODECID_TX3G:
+					case GF_CODECID_WEBVTT:
+					case GF_CODECID_SUBS_XML:
+					case GF_CODECID_SUBPIC:
+					case GF_CODECID_TMCD:
+						break;
+					default:
+						tkw->sparse_inject = GF_TRUE;
+						break;
+					}
+					break;
+				}
+			}
+		}
 
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_MUX_INDEX);
 		if (p) {
@@ -1282,7 +1388,7 @@
 			//this should be removed and hashes regenerated
 			gf_isom_set_track_layout_info(ctx->file, tkw->track_num, 0, 0, 0, 0, 0);
 
-			if (!gf_sys_is_test_mode()) {
+			if (!gf_sys_is_test_mode() && !gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_ISOM_HANDLER)) {
 				p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_URL);
 				if (tkw->track_num && p && p->value.string) {
 					char szHName1025;
@@ -1300,7 +1406,6 @@
 			return e;
 		}
 		tkw->track_id = gf_isom_get_track_id(ctx->file, tkw->track_num);
-		tkw->next_is_first_sample = GF_TRUE;
 
 		if (ctx->cmaf) {
 			gf_isom_set_track_flags(ctx->file, tkw->track_num, GF_ISOM_TK_ENABLED|GF_ISOM_TK_IN_MOVIE|GF_ISOM_TK_IN_PREVIEW, GF_ISOM_TKFLAGS_SET);
@@ -1323,15 +1428,27 @@
 
 		//if we have a subtype set for the pid, use it
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SUBTYPE);
-		if (p) gf_isom_set_media_type(ctx->file, tkw->track_num, p->value.uint);
+		if (p) {
+			mtype = p->value.uint;
+			gf_isom_set_media_type(ctx->file, tkw->track_num, mtype);
+		}
 
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_ISOM_HANDLER);
 		if (p && p->value.string) {
 			gf_isom_set_handler_name(ctx->file, tkw->track_num, p->value.string);
+			hdlr_name_set = GF_TRUE;
 		}
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_ISOM_ALT_GROUP);
 		if (p && p->value.uint) {
 			gf_isom_set_alternate_group_id(ctx->file, tkw->track_num, p->value.uint);
+		} else if (!p && !gf_sys_is_test_mode()) {
+			//we by default set groups for audio and subs if group is not present
+			if (mtype==GF_ISOM_SUBTYPE_SUBTITLE) {
+				gf_isom_set_alternate_group_id(ctx->file, tkw->track_num, 2);
+			}
+			if (tkw->stream_type==GF_STREAM_AUDIO) {
+				gf_isom_set_alternate_group_id(ctx->file, tkw->track_num, 1);
+			}
 		}
 
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_ISOM_TRACK_MATRIX);
@@ -1341,7 +1458,13 @@
 
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_SRC_MAGIC);
 		if (p) {
-			gf_isom_set_track_magic(ctx->file, tkw->track_num, p->value.longuint);
+			u64 magic = 0;
+			if (hdlr_name_set) {
+				magic |= 1;
+				magic <<= 32;
+			}
+			magic |= p->value.longuint;
+			gf_isom_set_track_magic(ctx->file, tkw->track_num, magic);
 		}
 		if (tk_idx) {
 			gf_isom_set_track_index(ctx->file, tkw->track_num, tk_idx, mp4mux_track_reorder, ctx);
@@ -1517,6 +1640,16 @@
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_ISOM_SUBTYPE);
 	if (p) m_subtype_src = p->value.uint;
 
+	//if crypto scheme type changes, we will need a new sample entry
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_PROTECTION_SCHEME_TYPE);
+	if (p && (tkw->scheme_type != p->value.uint))
+		needs_sample_entry = 1;
+	else if (!p && tkw->scheme_type)
+		needs_sample_entry = 1;
+	else if (tkw->scheme_type) {
+		if (codec_id == prev_codecid)
+			skip_crypto = GF_TRUE;
+	}
 
 	//get our subtype
 	switch (codec_id) {
@@ -1675,11 +1808,15 @@
 	case GF_CODECID_AVC:
 	case GF_CODECID_SVC:
 		if (ctx->xps_inband==XPS_IB_AUTO) {
-			if (m_subtype_src == GF_ISOM_SUBTYPE_AVC3_H264) {
-				m_subtype = GF_ISOM_SUBTYPE_AVC3_H264;
+			switch (m_subtype_src) {
+			case GF_ISOM_SUBTYPE_AVC3_H264:
+			case GF_ISOM_SUBTYPE_DVAV:
+				m_subtype = m_subtype_src;
 				xps_inband = XPS_IB_ALL;
-			} else {
+				break;
+			default:
 				m_subtype = GF_ISOM_SUBTYPE_AVC_H264;
+				break;
 			}
 		} else {
 			xps_inband = ctx->xps_inband;
@@ -1696,11 +1833,15 @@
 	case GF_CODECID_HEVC:
 	case GF_CODECID_LHVC:
 		if (ctx->xps_inband==XPS_IB_AUTO) {
-			if (m_subtype_src == GF_ISOM_SUBTYPE_HEV1) {
-				m_subtype = GF_ISOM_SUBTYPE_HEV1;
+			switch (m_subtype_src) {
+			case GF_ISOM_SUBTYPE_HEV1:
+			case GF_ISOM_SUBTYPE_DVHE:
+				m_subtype = m_subtype_src;
 				xps_inband = XPS_IB_ALL;
-			} else {
+				break;
+			default:
 				m_subtype = GF_ISOM_SUBTYPE_HVC1;
+				break;
 			}
 		} else {
 			xps_inband = ctx->xps_inband;
@@ -1775,6 +1916,26 @@
 		comp_name = "WebVTT";
 		is_text_subs = GF_TRUE;
 		break;
+	case GF_CODECID_DVB_SUBS:
+		use_gen_sample_entry = GF_TRUE;
+		comp_name = "DVB Subtitles";
+		m_subtype = GF_ISOM_SUBTYPE_DVB_SUBS;
+		gen_dsi_wrap = GF_4CC('d', 'v', 's', 'C');
+		gf_isom_set_media_type(ctx->file, tkw->track_num, GF_ISOM_MEDIA_SUBT);
+		if (!width && !height) {
+			mp4_mux_get_video_size(ctx, &width, &height);
+		}
+		break;
+	case GF_CODECID_DVB_TELETEXT:
+		use_gen_sample_entry = GF_TRUE;
+		comp_name = "DVB Subtitles";
+		m_subtype = GF_ISOM_SUBTYPE_DVB_TELETEXT;
+		gf_isom_set_media_type(ctx->file, tkw->track_num, GF_ISOM_MEDIA_SUBT);
+		if (!width && !height) {
+			mp4_mux_get_video_size(ctx, &width, &height);
+		}
+		break;
+
 	case GF_CODECID_SUBPIC:
 		use_m4sys = GF_TRUE;
 		override_stype = GF_STREAM_ND_SUBPIC;
@@ -1821,6 +1982,17 @@
 		comp_name = "Dolby TrueHD";
 		break;
 
+	case GF_CODECID_DTS_CA:
+	case GF_CODECID_DTS_X:
+	case GF_CODECID_DTS_HD_HR:
+	case GF_CODECID_DTS_HD_MASTER:
+	case GF_CODECID_DTS_LBR:
+		m_subtype = GF_ISOM_SUBTYPE_DTSC;
+		break;
+	case GF_CODECID_ALAC:
+		m_subtype = GF_QT_SUBTYPE_ALAC;
+		break;
+
 
 	case GF_CODECID_BIFS:
 /* == GF_CODECID_OD_V1:*/
@@ -1830,12 +2002,6 @@
 	case GF_CODECID_LASER:
 		use_m4sys = GF_TRUE;
 		break;
-	case GF_CODECID_V210:
-		m_subtype = GF_QT_SUBTYPE_YUV422_10;
-		comp_name = "v210 YUV 422 10 bit";
-		use_gen_sample_entry = GF_TRUE;
-		unknown_generic = GF_FALSE;
-		break;
 
 	case GF_CODECID_RAW:
 		m_subtype = codec_id;
@@ -2437,6 +2603,8 @@
 
 		if (dsi) {
 			gf_odf_ac3_config_parse(dsi->value.data.ptr, dsi->value.data.size, (codec_id==GF_CODECID_EAC3) ? GF_TRUE : GF_FALSE, &ac3cfg);
+		} else {
+			if (codec_id==GF_CODECID_EAC3) ac3cfg.is_ec3 = GF_TRUE;
 		}
 		e = gf_isom_ac3_config_new(ctx->file, tkw->track_num, &ac3cfg, (char *)src_url, NULL, &tkw->stsd_idx);
 		if (e) {
@@ -2452,26 +2620,18 @@
 		}
 		tkw->use_dref = src_url ? GF_TRUE : GF_FALSE;
 	} else if (use_opus) {
-		GF_OpusSpecificBox *opus_cfg = NULL;
-		GF_BitStream *bs;
+		GF_OpusConfig opus_cfg;
 
 		if (!dsi) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux No decoder specific info found for opus\n" ));
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
+		e = gf_odf_opus_cfg_parse(dsi->value.data.ptr, dsi->value.data.size, &opus_cfg);
+		if (!e)
+			e = gf_isom_opus_config_new(ctx->file, tkw->track_num, &opus_cfg, (char *)src_url, NULL, &tkw->stsd_idx);
 
-		bs = gf_bs_new(dsi->value.data.ptr, dsi->value.data.size, GF_BITSTREAM_READ);
-		e = gf_isom_box_parse((GF_Box**)&opus_cfg, bs);
-		gf_bs_del(bs);
-		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error parsing opus configuration data: %s\n", gf_error_to_string(e) ));
-			return e;
-		}
-
-		e = gf_isom_opus_config_new(ctx->file, tkw->track_num, opus_cfg, (char *)src_url, NULL, &tkw->stsd_idx);
-		if (opus_cfg) gf_isom_box_del((GF_Box*)opus_cfg);
 		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error creating new AC3 audio sample description for stream type %d codecid %d: %s\n", tkw->stream_type, codec_id, gf_error_to_string(e) ));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error creating new Opus audio sample description for stream type %d codecid %d: %s\n", tkw->stream_type, codec_id, gf_error_to_string(e) ));
 			return e;
 		}
 		tkw->use_dref = src_url ? GF_TRUE : GF_FALSE;
@@ -2548,11 +2708,15 @@
 
 		tkw->skip_bitrate_update = GF_TRUE;
 	} else if (use_webvtt) {
+#ifndef GPAC_DISABLE_VTT
 		e = gf_isom_new_webvtt_description(ctx->file, tkw->track_num, NULL, NULL, &tkw->stsd_idx, dsi ? dsi->value.data.ptr : NULL);
 		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error creating new %s sample description: %s\n", gf_4cc_to_str(m_subtype), gf_error_to_string(e) ));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error creating new %s sample description: %s\n", gf_4cc_to_str(m_subtype), gf_error_to_string(e)));
 			return e;
 		}
+#else
+		return GF_NOT_SUPPORTED;
+#endif
 		tkw->skip_bitrate_update = GF_TRUE;
 	} else if (use_mj2) {
 		e = gf_isom_new_mj2k_description(ctx->file, tkw->track_num, NULL, NULL, &tkw->stsd_idx, dsi ? dsi->value.data.ptr : NULL, dsi ? dsi->value.data.size : 0);
@@ -2611,15 +2775,24 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error creating new DIMS sample description: %s\n", gf_error_to_string(e) ));
 			return e;
 		}
-	} else if (codec_id==GF_CODECID_MPHA) {
+	} else if ((codec_id==GF_CODECID_MPHA) || (codec_id==GF_CODECID_MHAS)) {
 		//not ready yet
-		if (!dsi) return GF_OK;
-
-		e = gf_isom_new_mpha_description(ctx->file, tkw->track_num, NULL, NULL, &tkw->stsd_idx, dsi->value.data.ptr, dsi->value.data.size);
+		u8 *pdsi=NULL;
+		u32 dsi_len=0;
+		if (codec_id==GF_CODECID_MPHA) {
+			if (!dsi) return GF_OK;
+			pdsi = dsi->value.data.ptr;
+			dsi_len = dsi->value.data.size;
+		}
+		e = gf_isom_new_mpha_description(ctx->file, tkw->track_num, NULL, NULL, &tkw->stsd_idx, pdsi, dsi_len, m_subtype);
 		if (e) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error creating new MPEG-H Audio sample description: %s\n", gf_error_to_string(e) ));
 			return e;
 		}
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_MHA_COMPATIBLE_PROFILES);
+		if (p) {
+			gf_isom_set_mpegh_compatible_profiles(ctx->file, tkw->track_num, tkw->stsd_idx, p->value.uint_list.vals, p->value.uint_list.nb_items);
+		}
 	} else if (codec_id==GF_CODECID_TRUEHD) {
 		u32 fmt=0, prate=0;
 		//not ready yet
@@ -2640,7 +2813,7 @@
 			return e;
 		}
 	} else if (use_gen_sample_entry) {
-		u8 isor_ext_buf14;
+		u8 isor_ext_buf14, *gpac_meta_dsi=NULL;
 		u32 len = 0;
 		GF_GenericSampleDescription udesc;
 		memset(&udesc, 0, sizeof(GF_GenericSampleDescription));
@@ -2680,7 +2853,7 @@
 			if (p) {
 				m_subtype = p->value.uint;
 			} else {
-				p = gf_filter_pid_get_property(pid, GF_PROP_PID_FFMPEG_CODEC_ID);
+				p = gf_filter_pid_get_property(pid, GF_PROP_PID_META_DEMUX_CODEC_ID);
 				if (p && p->type==GF_PROP_UINT)
 					m_subtype = p->value.uint;
 			}
@@ -2697,6 +2870,7 @@
 		if (dsi) {
 			udesc.extension_buf = dsi->value.data.ptr;
 			udesc.extension_buf_size = dsi->value.data.size;
+			udesc.ext_box_wrap = gen_dsi_wrap;
 			p = gf_filter_pid_get_property_str(pid, "DSIWrap");
 			if (p) {
 				if (p->type==GF_PROP_UINT) udesc.ext_box_wrap = p->value.uint;
@@ -2708,17 +2882,57 @@
 			udesc.ext_box_wrap = GF_4CC('g', 'l', 'b', 'l');
 			unknown_generic = GF_FALSE;
 		}
+		if (codec_id==GF_CODECID_SMPTE_VC1) {
+			udesc.codec_tag = GF_4CC('v', 'c', '-', '1');
+			unknown_generic = GF_FALSE;
+			if (udesc.extension_buf)
+				udesc.ext_box_wrap = GF_4CC('d', 'v', 'c', '1');
+		}
 
 		if (unknown_generic) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MP4Mux muxing unknown codec ID %s, using generic sample entry with 4CC \"%s\"\n", gf_codecid_name(codec_id), gf_4cc_to_str(m_subtype) ));
+			//check if this is a meta codec (unmapped codec from ffmpeg or other)
+			p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_META_DEMUX_CODEC_ID);
+			const GF_PropertyValue *p2 = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_META_DEMUX_CODEC_NAME);
+			if (p || p2) {
+				u32 cid = (p && (p->type==GF_PROP_UINT)) ? p->value.uint : m_subtype;
+				const char *cname = p2 ? p2->value.string : NULL;
+				GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+
+				gf_bs_write_u32(bs, codec_id);
+				gf_bs_write_u32(bs, cid);
+				gf_bs_write_utf8(bs, cname ? cname : gf_4cc_to_str(cid));
+				p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_META_DEMUX_OPAQUE);
+				gf_bs_write_u32(bs, p ? p->value.uint : 0);
+
+				if (dsi && (dsi->type != GF_PROP_DATA) && (dsi->type != GF_PROP_CONST_DATA))
+					dsi = NULL;
+
+				if (dsi) {
+					gf_bs_write_data(bs, dsi->value.data.ptr, dsi->value.data.size);
+				}
+				gf_bs_get_content(bs, &gpac_meta_dsi, &udesc.extension_buf_size);
+				udesc.extension_buf = gpac_meta_dsi;
+				udesc.ext_box_wrap = GF_FALSE;
+
+				gf_bs_del(bs);
+
+				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MP4Mux muxing %s, using generic sample entry with 4CC \"GMCW\" and \"GMCC\" config box\n", gf_codecid_name(codec_id)));
+				udesc.codec_tag = GF_4CC('G', 'M', 'C', 'W');
+				udesc.ext_box_wrap = GF_4CC('G', 'M', 'C', 'C');
+			} else {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MP4Mux muxing unknown codec ID %s, using generic sample entry with 4CC \"%s\"\n", gf_codecid_name(codec_id), gf_4cc_to_str(m_subtype) ));
+			}
 		}
 		
 		e = gf_isom_new_generic_sample_description(ctx->file, tkw->track_num, (char *)src_url, NULL, &udesc, &tkw->stsd_idx);
+		if (gpac_meta_dsi) gf_free(gpac_meta_dsi);
+
 		if (e) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Error creating new sample description for stream type %d codecid %d: %s\n", tkw->stream_type, codec_id, gf_error_to_string(e) ));
 			return e;
 		}
 		tkw->use_dref = src_url ? GF_TRUE : GF_FALSE;
+
 	} else {
 		assert(0);
 	}
@@ -2796,7 +3010,7 @@
 		}
 	}
 
-	if (tkw->is_encrypted) {
+	if (tkw->is_encrypted && !skip_crypto) {
 		const char *scheme_uri=NULL;
 		const char *kms_uri=NULL;
 		u32 scheme_version=0;
@@ -2880,7 +3094,7 @@
 			}
 			gf_isom_set_generic_protection(ctx->file, tkw->track_num, tkw->stsd_idx, scheme_type, scheme_version, (char*)scheme_uri, (char*)kms_uri);
 		}
-	} else {
+	} else if (!tkw->is_encrypted) {
 		//in case we used track template
 		gf_isom_remove_samp_enc_box(ctx->file, tkw->track_num);
 		gf_isom_remove_samp_group_box(ctx->file, tkw->track_num);
@@ -2906,6 +3120,13 @@
 		if (p && p->value.sint)
 			tkw->check_seek_ts = GF_TRUE;
 
+
+		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_DURATION);
+		if (p && p->value.lfrac.den) {
+			tkw->pid_dur = p->value.lfrac;
+			if (tkw->pid_dur.num<0) tkw->pid_dur.num = -tkw->pid_dur.num;
+		}
+
 	} else if (codec_id==GF_CODECID_HEVC_TILES) {
 		mp4_mux_write_track_refs(ctx, tkw, "isom:tbas", GF_ISOM_REF_TBAS, GF_TRUE);
 	}
@@ -3024,7 +3245,6 @@
 				else
 					colr_mode = GF_4CC('n','c','l','x');
 
-
 				//other conditions were set above, here we force 1:1 pasp box even if no sar or 1:1
 				if (!sar.den || (sar.num == 1)) {
 					gf_isom_set_pixel_aspect_ratio(ctx->file, tkw->track_num, tkw->stsd_idx, -1, -1, GF_TRUE);
@@ -3064,8 +3284,13 @@
 				if (colour_primaries || transfer_characteristics || matrix_coefficients) {
 					gf_isom_set_visual_color_info(ctx->file, tkw->track_num, tkw->stsd_idx, GF_4CC('n','c','l','x'), colour_primaries, transfer_characteristics, matrix_coefficients, full_range_flag, NULL, 0);
 				}
-
 			}
+			//check if we have an icc profile
+			p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_ICC_PROFILE);
+			if (p && (p->type==GF_PROP_DATA) && p->value.data.ptr) {
+				gf_isom_set_visual_color_info(ctx->file, tkw->track_num, tkw->stsd_idx, 0, 0, 0, 0, GF_FALSE, p->value.data.ptr, p->value.data.size);
+			}
+
 
 			p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_CONTENT_LIGHT_LEVEL);
 			const GF_PropertyValue *p2 = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_MASTER_DISPLAY_COLOUR);
@@ -3101,10 +3326,12 @@
 				GF_DOVIDecoderConfigurationRecord *dvcc = gf_odf_dovi_cfg_read_bs(bs);
 				gf_bs_del(bs);
 				if (dvcc) {
+					if (ctx->force_dv)
+						dvcc->force_dv = 1;
 					gf_isom_set_dolby_vision_profile(ctx->file, tkw->track_num, tkw->stsd_idx, dvcc);
 
 					if (!dvcc->bl_present_flag) {
-						u32 i, ref_id = 0;
+						u32 ref_id = 0;
 
 						p = gf_filter_pid_get_property(pid, GF_PROP_PID_DEPENDENCY_ID);
 						if (p) ref_id = p->value.uint;
@@ -3143,6 +3370,17 @@
 		if (ctx->tktpl && p && p->value.data.ptr) {
 			gf_isom_update_sample_description_from_template(ctx->file, tkw->track_num, tkw->stsd_idx, p->value.data.ptr, p->value.data.size);
 		}
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_CHAP_TIMES);
+		const GF_PropertyValue *p2 = gf_filter_pid_get_property(pid, GF_PROP_PID_CHAP_NAMES);
+		if (p && p2 && (p->value.uint_list.nb_items == p2->value.string_list.nb_items)) {
+			u32 j;
+			gf_isom_remove_chapter(ctx->file, 0, 0);
+			for (j=0; j<p->value.uint_list.nb_items; j++) {
+				gf_isom_add_chapter(ctx->file, 0, p->value.uint_list.valsj, p2->value.string_list.valsj);
+			}
+		}
+
 	}
 
 	if (tkw->is_encrypted) {
@@ -3317,23 +3555,23 @@
 					gf_isom_remove_edits(ctx->file, tkw->track_num);
 					tkw->patch_tfdt = GF_TRUE;
 				} else {
-					s64 dur = 100*p->value.longsint;
-					dur *= (u32) ctx->moovts;
-					dur /= tkw->src_timescale;
-					if ((ctx->moovts < (s32) tkw->src_timescale) && (dur>150)) {
-						dur /= 100;
-						dur ++;
-					} else {
-						dur /= 100;
+					s64 dur = gf_timestamp_rescale_signed(p->value.longsint, tkw->src_timescale, ctx->moovts);
+					s64 diff_low = (s64) p->value.longuint - dur * tkw->src_timescale / ctx->moovts;
+					//we are loosing precision, check if true value is closer to next representable value in movie timescale
+					if (diff_low>0) {
+						s64 diff_high = (dur+1) * tkw->src_timescale / ctx->moovts - (s64) p->value.longuint;
+						if (diff_high < diff_low) dur++;
 					}
 					if (remove_edits) {
 						gf_isom_remove_edits(ctx->file, tkw->track_num);
 					}
-					gf_isom_set_edit(ctx->file, tkw->track_num, 0, dur, 0, GF_ISOM_EDIT_EMPTY);
-					gf_isom_set_edit(ctx->file, tkw->track_num, dur, 0, 0, GF_ISOM_EDIT_NORMAL);
+					if (dur) {
+						gf_isom_set_edit(ctx->file, tkw->track_num, 0, dur, 0, GF_ISOM_EDIT_EMPTY);
+						gf_isom_set_edit(ctx->file, tkw->track_num, dur, 0, 0, GF_ISOM_EDIT_NORMAL);
+					}
 				}
 			}
-			tkw->ts_delay = p->value.sint;
+			tkw->ts_delay = (s32) p->value.longsint;
 		} else if (tkw->stream_type==GF_STREAM_VISUAL) {
 			tkw->probe_min_ctts = GF_TRUE;
 		}
@@ -3542,10 +3780,7 @@
 	const GF_PropertyValue *p;
 	GF_Err e;
 	Bool pck_is_encrypted;
-	u32 skip_byte_block=0, crypt_byte_block=0;
 	u32 IV_size=0;
-	u32 scheme_type=0;
-	u32 scheme_version=0;
 	u8 *fake_sai = NULL;
 	u8 *sai = NULL;
 	u32 sai_size = 0;
@@ -3555,11 +3790,6 @@
 	if (tkw->cenc_state == CENC_SETUP_ERROR)
 		return GF_SERVICE_ERROR;
 
-	p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_CENC_PATTERN);
-	if (p) {
-		skip_byte_block = p->value.frac.num;
-		crypt_byte_block = p->value.frac.den;
-	}
 
 	if (pck) {
 		p = gf_filter_pck_get_property(pck, GF_PROP_PCK_CENC_SAI);
@@ -3570,16 +3800,18 @@
 	}
 
 
-	p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_PROTECTION_SCHEME_TYPE);
-	if (p) scheme_type = p->value.uint;
-	p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_PROTECTION_SCHEME_VERSION);
-	if (p) scheme_version = p->value.uint;
-
 	//initial setup
 	if (tkw->cenc_state==CENC_NEED_SETUP) {
+		u32 scheme_type=0;
+		u32 scheme_version=0;
 		u32 cenc_stsd_mode=0;
 		u32 container_type = GF_ISOM_BOX_TYPE_SENC;
 
+		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_PROTECTION_SCHEME_TYPE);
+		if (p) scheme_type = p->value.uint;
+		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_PROTECTION_SCHEME_VERSION);
+		if (p) scheme_version = p->value.uint;
+
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_CENC_STSD_MODE);
 		if (p) cenc_stsd_mode = p->value.uint;
 
@@ -3609,11 +3841,13 @@
 				tkw->clear_stsd_idx = clone_stsd_idx;
 			}
 		}
+		tkw->def_crypt_byte_block = tkw->crypt_byte_block;
+		tkw->def_skip_byte_block = tkw->skip_byte_block;
 
 		tkw->cenc_state = CENC_SETUP_DONE;
 		tkw->def_cenc_key_info_crc = tkw->cenc_key_info_crc;
 		if (tkw->cenc_ki) {
-			e = gf_isom_set_cenc_protection(ctx->file, tkw->track_num, tkw->stsd_idx, scheme_type, scheme_version, pck_is_encrypted, crypt_byte_block, skip_byte_block, tkw->cenc_ki->value.data.ptr, tkw->cenc_ki->value.data.size);
+			e = gf_isom_set_cenc_protection(ctx->file, tkw->track_num, tkw->stsd_idx, scheme_type, scheme_version, pck_is_encrypted, tkw->def_crypt_byte_block, tkw->def_skip_byte_block, tkw->cenc_ki->value.data.ptr, tkw->cenc_ki->value.data.size);
 		} else {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Missing CENC Key config, cannot mux\n"));
 			tkw->cenc_state = CENC_SETUP_ERROR;
@@ -3625,12 +3859,9 @@
 			return e;
 		}
 
-		if (ctx->psshs == MP4MX_PSSH_MOOV)
+		if ((ctx->psshs == MP4MX_PSSH_MOOV) || (ctx->psshs == MP4MX_PSSH_BOTH))
 			mp4_mux_cenc_insert_pssh(ctx, tkw, NULL, GF_FALSE);
 
-		tkw->def_crypt_byte_block = crypt_byte_block;
-		tkw->def_skip_byte_block = skip_byte_block;
-
 		if (!tkw->has_brands && (scheme_type==GF_ISOM_OMADRM_SCHEME))
 			gf_isom_modify_alternate_brand(ctx->file, GF_ISOM_BRAND_OPF2, GF_TRUE);
 
@@ -3690,15 +3921,15 @@
 		//multikey ALWAYS uses seig
 		if (tkw->cenc_ki->value.data.ptr0)
 			needs_seig = GF_TRUE;
-		else if (tkw->def_crypt_byte_block != crypt_byte_block)
+		else if (tkw->def_crypt_byte_block != tkw->crypt_byte_block)
 			needs_seig = GF_TRUE;
-		else if (tkw->def_skip_byte_block != skip_byte_block)
+		else if (tkw->def_skip_byte_block != tkw->skip_byte_block)
 			needs_seig = GF_TRUE;
 		else if (tkw->def_cenc_key_info_crc != tkw->cenc_key_info_crc)
 			needs_seig = GF_TRUE;
 
 		if (needs_seig) {
-			e = gf_isom_set_sample_cenc_group(ctx->file, tkw->track_num, sample_num, 1, crypt_byte_block, skip_byte_block, tkw->cenc_ki->value.data.ptr, tkw->cenc_ki->value.data.size);
+			e = gf_isom_set_sample_cenc_group(ctx->file, tkw->track_num, sample_num, 1, tkw->crypt_byte_block, tkw->skip_byte_block, tkw->cenc_ki->value.data.ptr, tkw->cenc_ki->value.data.size);
 			tkw->has_seig = GF_TRUE;
 		} else if (tkw->has_seig) {
 			e = gf_isom_set_sample_cenc_default_group(ctx->file, tkw->track_num, sample_num);
@@ -3939,6 +4170,13 @@
 		tkw->sample.CTS_Offset = (s32) ((s64) cts - (s64) tkw->sample.DTS);
 	}
 
+	//do our best to patch init ts if timing config aborted
+	if (tkw->si_min_ts_plus_one) {
+		u64 si_min_ts = tkw->si_min_ts_plus_one - 1;
+		tkw->si_min_ts_plus_one = 0;
+		tkw->ts_shift = tkw->sample.DTS;
+		mp4_mux_update_init_edit(ctx, tkw, si_min_ts, GF_FALSE);
+	}
 	//tkw->ts_shift is in source timescale, apply it before rescaling TSs/duration
 	if (tkw->ts_shift) {
 		if (ctx->is_rewind) {
@@ -3988,7 +4226,6 @@
 		duration /= timescale;
 	}
 
-
 	tkw->sample.IsRAP = 0;
 	if (tkw->codecid==GF_CODECID_RAW) {
 		sap_type = GF_FILTER_SAP_1;
@@ -4068,12 +4305,31 @@
 		sample_desc_index = tkw->clear_stsd_idx;
 	}
 
+	if (tkw->sparse_inject && (prev_dts!=GF_FILTER_NO_TS) && (tkw->sample.DTS!=GF_FILTER_NO_TS) && tkw->prev_duration) {
+		u64 est_time = prev_dts + tkw->prev_duration;
+		if (est_time < tkw->sample.DTS) {
+			u32 ins_dur;
+			GF_ISOSample s;
+			memset(&s, 0, sizeof(GF_ISOSample));
+			s.DTS = est_time;
+
+			s.IsRAP = SAP_TYPE_1;
+			ins_dur = (u32) (tkw->sample.DTS - est_time);
+			if (for_fragment) {
+				e = gf_isom_fragment_add_sample(ctx->file, tkw->track_id, &s, tkw->stsd_idx, ins_dur, 0, 0, 0);
+			} else {
+				e = gf_isom_add_sample(ctx->file, tkw->track_num, tkw->stsd_idx, &s);
+				gf_isom_set_last_sample_duration(ctx->file, tkw->track_num, ins_dur);
+			}
+		}
+	}
+
 	if (tkw->use_dref) {
 		u64 data_offset = gf_filter_pck_get_byte_offset(pck);
 		if (data_offset != GF_FILTER_NO_BO) {
 			e = gf_isom_add_sample_reference(ctx->file, tkw->track_num, sample_desc_index, &tkw->sample, data_offset);
 			if (e) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Failed to add sample DTS "LLU" as reference: %s\n", tkw->sample.DTS, gf_error_to_string(e) ));
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Failed to add sample DTS "LLU" from %s as reference: %s\n", tkw->sample.DTS, gf_filter_pid_get_name(tkw->ipid), gf_error_to_string(e) ));
 			}
 		} else {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Cannot add sample reference at DTS "LLU" , input sample data is not continous in source\n", tkw->sample.DTS ));
@@ -4165,7 +4421,7 @@
 		}
 
 		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Failed to add sample DTS "LLU" - prev DTS "LLU": %s\n", tkw->sample.DTS, prev_dts, gf_error_to_string(e) ));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Failed to add sample DTS "LLU" from %s - prev DTS "LLU": %s\n", tkw->sample.DTS, gf_filter_pid_get_name(tkw->ipid), prev_dts, gf_error_to_string(e) ));
 		} else {
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("MP4Mux added sample DTS "LLU" - prev DTS "LLU" - prev size %d\n", tkw->sample.DTS, prev_dts, prev_size));
 		}
@@ -4174,7 +4430,6 @@
 			e = mp4_mux_cenc_update(ctx, tkw, pck, for_fragment ? CENC_ADD_FRAG : CENC_ADD_NORMAL, tkw->sample.dataLength, insert_subsample_dsi_size);
 			if (e) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Failed to set sample CENC information: %s\n", gf_error_to_string(e) ));
-				return e;
 			}
 		}
 	}
@@ -4348,9 +4603,7 @@
 		}
 	}
 
-
-	tkw->next_is_first_sample = GF_FALSE;
-
+	tkw->prev_duration = duration;
 	if (duration && !for_fragment && !tkw->raw_audio_bytes_per_sample)
 		gf_isom_set_last_sample_duration(ctx->file, tkw->track_num, duration);
 
@@ -4419,7 +4672,7 @@
 static GF_Err mp4_mux_process_item(GF_MP4MuxCtx *ctx, TrackWriter *tkw, GF_FilterPacket *pck)
 {
 	GF_Err e;
-	u32 meta_type, item_id, size, item_type, nb_items, media_brand;
+	u32 meta_type, item_id, size, item_type, nb_items, media_brand = GF_ISOM_BRAND_HEIF;
 	GF_ImageItemProperties image_props;
 	GF_ImageItemProtection cenc_info;
 	const char *data, *item_name=NULL;
@@ -4589,6 +4842,14 @@
 		}
 		media_brand = GF_ISOM_BRAND_VVIC;
 		break;
+	case GF_CODECID_RAW:
+		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_PIXFMT);
+		if (p && (p->value.uint==GF_PIXEL_UNCV)) {
+			image_props.config_ba = dsi->value.data.ptr;
+			image_props.config_ba_size = dsi->value.data.size;
+			item_type = GF_4CC('u','n','c','i');
+			break;
+		}
 	default:
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("Error: Codec %s not supported to create HEIF image items\n", gf_codecid_name(tkw->codecid) ));
 		return GF_NOT_SUPPORTED;
@@ -4734,6 +4995,7 @@
 {
 	GF_FilterEvent evt;
 	TrackWriter *tkw = NULL;
+
 	//send event on first track only
 	tkw = gf_list_get(ctx->tracks, 0);
 	GF_FEVT_INIT(evt, GF_FEVT_FRAGMENT_SIZE, tkw->ipid);
@@ -4881,11 +5143,12 @@
 		def_fake_scale = tkw->src_timescale;
 
 		p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_DURATION);
-		if (p && p->value.lfrac.num>0 && p->value.lfrac.den) {
+		if (p && p->value.lfrac.den) {
 			tkw->pid_dur = p->value.lfrac;
-			if (max_dur.num * (s64) p->value.lfrac.den < (s64) max_dur.den * p->value.lfrac.num) {
-				max_dur.num = p->value.lfrac.num;
-				max_dur.den = p->value.lfrac.den;
+			if (tkw->pid_dur.num<0) tkw->pid_dur.num = -tkw->pid_dur.num;
+			if (max_dur.num * (s64) tkw->pid_dur.den < (s64) max_dur.den * tkw->pid_dur.num) {
+				max_dur.num = tkw->pid_dur.num;
+				max_dur.den = tkw->pid_dur.den;
 			}
 		}
 #ifdef GF_ENABLE_CTRN
@@ -4897,7 +5160,7 @@
 	for (i=0; i<count; i++) {
 		u32 def_pck_dur;
 		u32 def_samp_size=0;
-		u32 def_is_rap;
+		u8 def_is_rap;
 #ifdef GF_ENABLE_CTRN
 		u32 inherit_traf_from_track = 0;
 #endif
@@ -4955,10 +5218,10 @@
 		switch (tkw->stream_type) {
 		case GF_STREAM_AUDIO:
 		case GF_STREAM_TEXT:
-			def_is_rap = GF_TRUE;
+			def_is_rap = GF_ISOM_FRAG_DEF_IS_SYNC;
 			p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_HAS_SYNC);
 			if (p && p->value.boolean)
-				def_is_rap = GF_FALSE;
+				def_is_rap = 0;
 			break;
 		case GF_STREAM_VISUAL:
 			switch (tkw->codecid) {
@@ -4976,19 +5239,23 @@
 				if (!ref_tkw) ref_tkw = tkw;
 				break;
 			}
-			def_is_rap = GF_FALSE;
+			def_is_rap = 0;
 			break;
 
 		default:
-			def_is_rap = GF_FALSE;
+			def_is_rap = 0;
 			break;
 		}
+		//CMAF 7.5.17, if non-sync sample are present stss SHALL be present and empty...
+		if (ctx->cmaf && !def_is_rap) {
+			def_is_rap |= GF_ISOM_FRAG_USE_SYNC_TABLE;
+		}
 
 		mp4_mux_set_hevc_groups(ctx, tkw);
 
 		//use 1 for the default sample description index. If no multi stsd, this is always the case
 		//otherwise we need to update the stsd idx in the traf headers
-		e = gf_isom_setup_track_fragment(ctx->file, tkw->track_id, tkw->stsd_idx, def_pck_dur, def_samp_size, (u8) def_is_rap, 0, 0, ctx->nofragdef ? GF_TRUE : GF_FALSE);
+		e = gf_isom_setup_track_fragment(ctx->file, tkw->track_id, tkw->stsd_idx, def_pck_dur, def_samp_size, def_is_rap, 0, 0, ctx->nofragdef ? GF_TRUE : GF_FALSE);
 		if (e) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MP4Mux Unable to setup fragmentation for track ID %d: %s\n", tkw->track_id, gf_error_to_string(e) ));
 			return e;
@@ -5005,7 +5272,7 @@
 
 
 		if (ctx->tfdt.den && ctx->tfdt.num) {
-			tkw->offset_dts = gf_timestamp_rescale(ctx->tfdt.num, ctx->tfdt.den, tkw->tk_timescale);
+			tkw->tfdt_offset = gf_timestamp_rescale(ctx->tfdt.num, ctx->tfdt.den, tkw->tk_timescale);
 		}
 
 		if (tkw->fake_track) {
@@ -5270,7 +5537,7 @@
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MP4Mux Unable set fragment options: %s\n", gf_error_to_string(e) ));
 		}
 		tkw->fragment_done = GF_FALSE;
-		tkw->insert_tfdt = (has_tfdt || ctx->tfdt_traf) ? GF_TRUE : ctx->insert_tfdt;
+		tkw->insert_tfdt = (has_tfdt || ctx->tfdt_traf || tkw->tfdt_offset) ? GF_TRUE : ctx->insert_tfdt;
 		tkw->dur_in_frag = 0;
 
 		if (ctx->trun_inter) {
@@ -5447,7 +5714,13 @@
 
 		ctx->segment_started = GF_TRUE;
 		ctx->insert_tfdt = GF_TRUE;
-		ctx->insert_pssh = (ctx->psshs == MP4MX_PSSH_MOOF) ? GF_TRUE : GF_FALSE;
+		switch (ctx->psshs) {
+		case MP4MX_PSSH_MOOF:
+		case MP4MX_PSSH_BOTH:
+			ctx->insert_pssh = GF_TRUE; break;
+		default:
+			ctx->insert_pssh = GF_FALSE; break;
+		}
 
 		gf_isom_start_segment(ctx->file, ctx->single_file ? NULL : "_gpac_isobmff_redirect", GF_FALSE);
 	}
@@ -5624,6 +5897,13 @@
 			if (tkw->cts_next < ncts)
 				tkw->cts_next = ncts;
 
+			//compute ts after delay/skip for fragment interleaving
+			u64 check_ts;
+			if ((tkw->ts_delay<0) && (cts < -tkw->ts_delay))
+				check_ts = 0;
+			else
+				check_ts = cts+tkw->ts_delay;
+
 			//we have samples and either a request to flush fragment or a emsg, start new fragment
 			if (tkw->samples_in_frag && (orig_frag_bounds || (gf_filter_pck_get_property_str(pck, "grp_EMSG")!=NULL))) {
 				tkw->fragment_done = GF_TRUE;
@@ -5637,7 +5917,7 @@
 				if (tkw->dur_in_frag && gf_timestamp_greater_or_equal(tkw->dur_in_frag, tkw->src_timescale, ctx->cdur.num, ctx->cdur.den)) {
 					frag_done = GF_TRUE;
 				} else if ((ctx->store==MP4MX_MODE_SFRAG)
-					&& gf_timestamp_greater_or_equal(cts - tkw->ts_delay, tkw->src_timescale, ctx->adjusted_next_frag_start, ctx->cdur.den)
+					&& gf_timestamp_greater_or_equal(check_ts, tkw->src_timescale, ctx->adjusted_next_frag_start, ctx->cdur.den)
 				) {
 					GF_FilterSAPType sap = mp4_mux_get_sap(ctx, pck);
 					if ((sap && sap<GF_FILTER_SAP_3)) {
@@ -5645,7 +5925,7 @@
 					}
 				}
 				if (frag_done) {
-					ctx->adjusted_next_frag_start = gf_timestamp_rescale(cts - tkw->ts_delay, tkw->src_timescale, ctx->cdur.den);
+					ctx->adjusted_next_frag_start = gf_timestamp_rescale(check_ts, tkw->src_timescale, ctx->cdur.den);
 //
 					tkw->fragment_done = GF_TRUE;
 					nb_done ++;
@@ -5659,15 +5939,19 @@
 					ctx->frag_timescale = tkw->src_timescale;
 				}
 			} else if (!ctx->flush_seg && !ctx->dash_mode
-				&& gf_timestamp_greater_or_equal(cts - tkw->ts_delay, tkw->src_timescale, ctx->adjusted_next_frag_start, ctx->cdur.den)
+				&& gf_timestamp_greater_or_equal(check_ts, tkw->src_timescale, ctx->adjusted_next_frag_start, ctx->cdur.den)
 			 ) {
 				GF_FilterSAPType sap = mp4_mux_get_sap(ctx, pck);
+				//consider roll SAP as sap1 for the fragmentation
+				if ((sap==GF_FILTER_SAP_4) && (tkw->stream_type==GF_STREAM_AUDIO))
+					sap = GF_FILTER_SAP_1;
+
 				if ((ctx->store==MP4MX_MODE_FRAG) || (sap && sap<GF_FILTER_SAP_3)) {
 					tkw->fragment_done = GF_TRUE;
 					tkw->samples_in_frag = 0;
 					nb_done ++;
 					if (ctx->store==MP4MX_MODE_SFRAG) {
-						ctx->adjusted_next_frag_start = gf_timestamp_rescale(cts - tkw->ts_delay, tkw->src_timescale, ctx->cdur.den);
+						ctx->adjusted_next_frag_start = gf_timestamp_rescale(check_ts, tkw->src_timescale, ctx->cdur.den);
 					}
 					break;
 				}
@@ -5680,7 +5964,7 @@
 					tkw->samples_in_frag = 0;
 					nb_done ++;
 					if (ctx->store==MP4MX_MODE_SFRAG) {
-						ctx->adjusted_next_frag_start = gf_timestamp_rescale(cts - tkw->ts_delay, tkw->src_timescale, ctx->cdur.den);
+						ctx->adjusted_next_frag_start = gf_timestamp_rescale(check_ts, tkw->src_timescale, ctx->cdur.den);
 					}
 					break;
 				}
@@ -5691,10 +5975,19 @@
 				if (odts==GF_FILTER_NO_TS)
 					odts = gf_filter_pck_get_cts(pck);
 
-				if (tkw->offset_dts) odts += tkw->offset_dts;
+				if (tkw->tfdt_offset) {
+					//first sample, set offset dts such that first sample dts - offset_dts = target time
+					if (tkw->nb_samples==0) {
+						u64 target = tkw->tfdt_offset;
+						tkw->tfdt_offset = odts - target;
+
+					}
+					odts = odts - tkw->tfdt_offset;
+				}
 
 				tkw->insert_tfdt = GF_FALSE;
 				if (tkw->patch_tfdt)
+					//if patch_tfdt is true, tkw->ts_delay is always >0
 					gf_isom_set_traf_base_media_decode_time(ctx->file, tkw->track_id, odts + tkw->ts_delay);
 				else
 					gf_isom_set_traf_base_media_decode_time(ctx->file, tkw->track_id, odts);
@@ -5804,6 +6097,12 @@
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("MP4Mux Done writing segment %d - estimated next fragment times start %g end %g\n", ctx->dash_seg_num_plus_one - 1, ((Double)next_ref_ts)/ref_timescale, ((Double)ctx->next_frag_start)/ctx->cdur.den ));
 
 			if (ctx->dash_mode != MP4MX_DASH_VOD) {
+				//we need to wait for packet to be written
+				if (ctx->seg_flush_state) {
+					ctx->flush_idx_start_range = offset + idx_start_range;
+					ctx->flush_idx_end_range = idx_end_range ? offset + idx_end_range : 0;
+					return GF_OK;
+				}
 				mp4_mux_flush_seg(ctx, GF_FALSE, offset + idx_start_range, idx_end_range ? offset + idx_end_range : 0);
 			} else if (ctx->vodcache==MP4MX_VODCACHE_REPLACE) {
 				mp4_mux_flush_seg(ctx, GF_FALSE, 0, 0);
@@ -5825,6 +6124,14 @@
 		else if (!ctx->dash_mode || ((ctx->subs_sidx<0) && (ctx->dash_mode<MP4MX_DASH_VOD) && !ctx->cloned_sidx) ) {
 			gf_isom_flush_fragments(ctx->file, GF_FALSE);
 
+			GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("MP4Mux Done writing fragment - next fragment start time %g\n", ((Double)ctx->next_frag_start)/ctx->cdur.den ));
+
+			//we need to wait for packet to be written
+			if (ctx->seg_flush_state) {
+				if (ctx->llhls_mode) ctx->flush_ll_hls = GF_TRUE;
+				return GF_OK;
+			}
+
 			if (ctx->llhls_mode) {
 				mp4_mux_flush_frag_hls(ctx);
 			}
@@ -5907,23 +6214,99 @@
 	return GF_OK;
 }
 
+struct _service_info
+{
+	u32 service_id;
+	u64 first_ts_min;
+	u32 nb_non_sparse, nb_non_sparse_ready;
+	u32 nb_sparse, nb_sparse_ready;
+};
+static struct _service_info *get_service_info(GF_List *services, TrackWriter *tkw)
+{
+	struct _service_info *si;
+	const GF_PropertyValue *p = gf_filter_pid_get_property(tkw->ipid, GF_PROP_PID_SERVICE_ID);
+	u32 ID, i, count=gf_list_count(services);
+	ID = p ? p->value.uint : 0;
+
+	for (i=0; i<count; i++) {
+		si = gf_list_get(services, i);
+		if (si->service_id == ID) return si;
+	}
+	GF_SAFEALLOC(si, struct _service_info)
+	si->service_id = ID;
+	si->first_ts_min = (u64) -1;
+	gf_list_add(services, si);
+	return si;
+}
+static void del_service_info(GF_List *services)
+{
+	while (gf_list_count(services)) {
+		struct _service_info *si = gf_list_pop_back(services);
+		gf_free(si);
+	}
+	gf_list_del(services);
+}
+
+static void mp4_mux_update_init_edit(GF_MP4MuxCtx *ctx, TrackWriter *tkw, u64 min_ts_service, Bool skip_adjust)
+{
+	//compute offsets
+	s64 dts_diff = gf_timestamp_rescale(min_ts_service, 1000000, tkw->src_timescale);
+
+	if (!skip_adjust) {
+		dts_diff = (s64) tkw->ts_shift - dts_diff;
+	}
+	if (ctx->is_rewind) dts_diff = -dts_diff;
+	//negative could happen due to rounding, ignore them
+	if (dts_diff<=0) return;
+
+	// dts_diff > 0, we need to delay the track
+	u64 dur = gf_timestamp_rescale(dts_diff, tkw->src_timescale, ctx->moovts);
+	if (dur) {
+		gf_isom_remove_edits(ctx->file, tkw->track_num);
+
+		gf_isom_set_edit(ctx->file, tkw->track_num, 0, dur, dts_diff, GF_ISOM_EDIT_EMPTY);
+		gf_isom_set_edit(ctx->file, tkw->track_num, dur, 0, 0, GF_ISOM_EDIT_NORMAL);
+		tkw->empty_init_dur = (u64) dur;
+	}
+}
+
 static void mp4_mux_config_timing(GF_MP4MuxCtx *ctx)
 {
-	u32 i, count = gf_list_count(ctx->tracks);
+	if ((ctx->store>=MP4MX_MODE_FRAG) && !ctx->tsalign) {
+		ctx->config_timing = GF_FALSE;
+		return;
+	}
+	GF_List *services = gf_list_new();
+	u32 i, count;
+	Bool not_ready, blocking_refs, has_ready;
+
+retry_all:
+	count = gf_list_count(ctx->tracks);
+	not_ready = GF_FALSE;
+	blocking_refs = GF_FALSE;
+	has_ready = GF_FALSE;
+
+	for (i=0; i<gf_list_count(services);i++) {
+		struct _service_info *si = gf_list_get(services, i);
+		si->nb_non_sparse = si->nb_non_sparse_ready = 0;
+		si->nb_sparse = si->nb_sparse_ready = 0;
+	}
+
 	//compute min dts of first packet on each track - this assume all tracks are synchronized, might need adjustment for MPEG4 Systems
-	u64 first_ts_min = (u64) -1;
 	for (i=0; i<count; i++) {
 		u64 ts, dts_min;
 		GF_FilterPacket *pck;
 		TrackWriter *tkw = gf_list_get(ctx->tracks, i);
 		if (tkw->fake_track) continue;
+		//get associated service
+		struct _service_info *si = get_service_info(services, tkw);
 
 		//already setup (happens when new PIDs are declared after a packet has already been written on other PIDs)
 		if (tkw->nb_samples) {
 			dts_min = gf_timestamp_rescale(tkw->ts_shift, tkw->src_timescale, 1000000);
 
-			if (first_ts_min > dts_min) {
-				first_ts_min = (u64) dts_min;
+			if (si->first_ts_min > dts_min) {
+				si->first_ts_min = (u64) dts_min;
 			}
 			continue;
 		}
@@ -5935,10 +6318,14 @@
 				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MP4Mux PID has no input packet and configuration not known after 10 retries, aborting initial timing sync\n"));
 				continue;
 			}
-			return;
+			not_ready = GF_TRUE;
+			tkw->ts_shift = 0;
+			continue;
 		}
 
 		if (pck) {
+			if (gf_filter_pck_is_blocking_ref(pck))
+				blocking_refs = GF_TRUE;
 			if (tkw->wait_sap) {
 				GF_FilterSAPType sap = gf_filter_pck_get_sap(pck);
 				Bool seek = gf_filter_pck_get_seek_flag(pck);
@@ -5968,6 +6355,15 @@
 				}
 			}
 		}
+		switch (tkw->stream_type) {
+		case GF_STREAM_VISUAL:
+		case GF_STREAM_AUDIO:
+			si->nb_non_sparse++;
+			break;
+		default:
+			si->nb_sparse++;
+			break;
+		}
 
 		if (!pck) {
 			if (gf_filter_pid_is_eos(tkw->ipid)) {
@@ -5984,14 +6380,24 @@
 					gf_filter_pck_discard(tkw->dgl_copy);
 					tkw->dgl_copy = NULL;
 				}
+				switch (tkw->stream_type) {
+				case GF_STREAM_VISUAL:
+				case GF_STREAM_AUDIO:
+					si->nb_non_sparse_ready++;
+					break;
+				default:
+					si->nb_sparse_ready++;
+					break;
+				}
 				continue;
 			}
-			return;
+			tkw->ts_shift = 0;
+			tkw->si_min_ts_plus_one = 1;
+			continue;
 		}
 		//we may have reorder tracks after the get_packet, redo
 		if (gf_list_find(ctx->tracks, tkw) != i) {
-			mp4_mux_config_timing(ctx);
-			return;
+			goto retry_all;
 		}
 		ts = gf_filter_pck_get_dts(pck);
 		if (ts==GF_FILTER_NO_TS)
@@ -6001,38 +6407,72 @@
 
 		dts_min = gf_timestamp_rescale(ts, tkw->src_timescale, 1000000);
 
-		if (first_ts_min > dts_min) {
-			first_ts_min = (u64) dts_min;
+		if (si->first_ts_min > dts_min) {
+			si->first_ts_min = (u64) dts_min;
+			has_ready = GF_TRUE;
 		}
+
+		switch (tkw->stream_type) {
+		case GF_STREAM_VISUAL:
+		case GF_STREAM_AUDIO:
+			si->nb_non_sparse_ready++;
+			break;
+		default:
+			si->nb_sparse_ready++;
+			break;
+		}
+
 		tkw->ts_shift = ts;
+		tkw->si_min_ts_plus_one = 0;
+	}
+
+	for (i=0; i<gf_list_count(services); i++) {
+		struct _service_info *si = gf_list_get(services, i);
+		//if some non-sparse streams are not ready, try to wait
+		if (si->nb_non_sparse) {
+			if (si->nb_non_sparse > si->nb_non_sparse_ready) not_ready = GF_TRUE;
+		}
+		//otherwise (only sparse stream), wait until first
+		else if (si->nb_sparse) {
+			if (!si->nb_sparse_ready) not_ready = GF_TRUE;
+		}
+	}
+
+	if (not_ready) {
+		if (blocking_refs && has_ready) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MP4Mux Blocking input packets present, aborting initial timing sync\n"));
+		}
+		//this may be quite long until we have a packet in case input pid is video encoding 
+		else if (ctx->config_retry_start && (gf_sys_clock() - ctx->config_retry_start > 10000)) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MP4Mux No input packets present on one or more inputs for more than 10s, aborting initial timing sync\n"));
+		} else {
+			ctx->config_retry_start = gf_sys_clock();
+			del_service_info(services);
+			return;
+		}
+	}
+	ctx->config_retry_start = 0;
+	for (i=0; i<gf_list_count(services); i++) {
+		struct _service_info *si = gf_list_get(services, i);
+		if (si->first_ts_min==(u64)-1)
+			si->first_ts_min = 0;
 	}
-	if (first_ts_min==(u64)-1)
-		first_ts_min = 0;
 
 	//for all packets with dts greater than min dts, we need to add a pause
 	for (i=0; i<count; i++) {
-		s64 dts_diff, dur;
 		TrackWriter *tkw = gf_list_get(ctx->tracks, i);
-
-		//compute offsets
-		dts_diff = gf_timestamp_rescale(first_ts_min, 1000000, tkw->src_timescale);
-		dts_diff = (s64) tkw->ts_shift - dts_diff;
-		if (ctx->is_rewind) dts_diff = -dts_diff;
-		//negative could happen due to rounding, ignore them
-		if (dts_diff<=0) continue;
-
-		// dts_diff > 0, we need to delay the track
-		dur = gf_timestamp_rescale(dts_diff, tkw->src_timescale, ctx->moovts);
-		if (dur) {
-			gf_isom_remove_edits(ctx->file, tkw->track_num);
-
-			gf_isom_set_edit(ctx->file, tkw->track_num, 0, dur, dts_diff, GF_ISOM_EDIT_EMPTY);
-			gf_isom_set_edit(ctx->file, tkw->track_num, dur, 0, 0, GF_ISOM_EDIT_NORMAL);
-			tkw->empty_init_dur = (u64) dur;
+		struct _service_info *si = get_service_info(services, tkw);
+		if (tkw->si_min_ts_plus_one) {
+			tkw->si_min_ts_plus_one = si->first_ts_min + 1;
+			continue;
 		}
+
+		//if single text track don't reset back to 0
+		mp4_mux_update_init_edit(ctx, tkw, si->first_ts_min, ((count==1) && (tkw->stream_type == GF_STREAM_TEXT)) ? GF_TRUE : GF_FALSE);
 	}
 
 	ctx->config_timing = GF_FALSE;
+	del_service_info(services);
 }
 
 void mp4_mux_format_report(GF_Filter *filter, GF_MP4MuxCtx *ctx, u64 done, u64 total)
@@ -6137,6 +6577,7 @@
 	if (status) gf_free(status);
 }
 
+static void mp4_mux_flush_seg_events(GF_MP4MuxCtx *ctx);
 
 GF_Err mp4_mux_process(GF_Filter *filter)
 {
@@ -6156,6 +6597,10 @@
 	//fragmented mode
 	if (ctx->store>=MP4MX_MODE_FRAG) {
 		u32 done=0;
+		if (ctx->seg_flush_state==1) return GF_OK;
+		else if (ctx->seg_flush_state==2)
+			mp4_mux_flush_seg_events(ctx);
+
 		GF_Err e = mp4_mux_process_fragmented(filter, ctx);
 		if (e==GF_EOS) done=100;
 		mp4_mux_format_report(filter, ctx, done, done);
@@ -6165,6 +6610,7 @@
 	//regular mode
 	nb_suspended = 0;
 	for (i=0; i<count; i++) {
+		GF_Err e;
 		TrackWriter *tkw = gf_list_get(ctx->tracks, i);
 		GF_FilterPacket *pck = gf_filter_pid_get_packet(tkw->ipid);
 
@@ -6181,6 +6627,9 @@
 			if (tkw->aborted) {
 				nb_eos++;
 			}
+			if (ctx->store==MP4MX_MODE_FASTSTART) {
+				nb_skip++;
+			}
 			continue;
 		}
 
@@ -6216,7 +6665,7 @@
 
 		//basic regulation in case we do on-the-fly interleaving
 		//we need to regulate because sources do not produce packets at the same rate
-		if ((ctx->store==MP4MX_MODE_FASTSTART) && ctx->cdur.num) {
+		if (ctx->store==MP4MX_MODE_FASTSTART) {
 			u64 cts = gf_filter_pck_get_cts(pck);
 			if (ctx->is_rewind)
 				cts = tkw->ts_shift - cts;
@@ -6237,15 +6686,16 @@
 			mp4_mux_cenc_update(ctx, tkw, pck, CENC_CONFIG, 0, 0);
 
 		if (tkw->is_item) {
-			mp4_mux_process_item(ctx, tkw, pck);
+			e = mp4_mux_process_item(ctx, tkw, pck);
 		} else {
-			mp4_mux_process_sample(ctx, tkw, pck, GF_FALSE);
+			e = mp4_mux_process_sample(ctx, tkw, pck, GF_FALSE);
 		}
 
 		gf_filter_pid_drop_packet(tkw->ipid);
 		if (tkw->aborted) {
 			nb_eos++;
 		}
+		if (e) return e;
 	}
 	mp4_mux_format_report(filter, ctx, 0, 0);
 
@@ -6261,7 +6711,7 @@
 		return GF_EOS;
 	}
 	//done with this interleaving window, start next one
-	else if (nb_skip + nb_eos == count) {
+	else if (nb_skip + nb_eos >= count) {
 		ctx->faststart_ts_regulate.num += ctx->cdur.num;
 	} else if (ctx->importer) {
 		u64 prog_done=0, prog_total=0;
@@ -6297,6 +6747,47 @@
 	return GF_OK;
 }
 
+static void mp4_mux_flush_seg_events(GF_MP4MuxCtx *ctx)
+{
+	if (ctx->flush_ll_hls) {
+		mp4_mux_flush_frag_hls(ctx);
+	}
+
+	if (!ctx->dash_mode || ctx->flush_seg) {
+		mp4_mux_flush_seg(ctx, GF_FALSE, ctx->flush_idx_start_range, ctx->flush_idx_end_range);
+	}
+
+	ctx->fragment_started = GF_FALSE;
+
+	if (ctx->flush_seg) {
+		ctx->segment_started = GF_FALSE;
+		ctx->flush_seg = GF_FALSE;
+		ctx->dash_seg_num_plus_one = 0;
+		ctx->nb_segs++;
+		ctx->nb_frags_in_seg=0;
+	}
+	ctx->seg_flush_state = 0;
+	ctx->flush_idx_start_range = 0;
+	ctx->flush_idx_end_range = 0;
+	ctx->flush_ll_hls = GF_FALSE;
+}
+
+static void mp4_mux_on_packet_destruct(GF_Filter *filter, GF_FilterPid *PID, GF_FilterPacket *pck)
+{
+	GF_MP4MuxCtx *ctx = gf_filter_get_udta(filter);
+	//no need to lock filter here, only this callback modifies the state
+	ctx->seg_flush_state = 2;
+	gf_filter_post_process_task(filter);
+}
+
+static void mp4_mux_on_last_block_start(void *cbk)
+{
+	GF_Filter *filter = (GF_Filter *) cbk;
+	GF_MP4MuxCtx *ctx = gf_filter_get_udta(filter);
+	if (ctx->force_seg_sync)
+		ctx->seg_flush_state = 1;
+}
+
 static GF_Err mp4_mux_on_data(void *cbk, u8 *data, u32 block_size)
 {
 	GF_Filter *filter = (GF_Filter *) cbk;
@@ -6361,7 +6852,11 @@
 	}
 
 	//allocate new one
-	ctx->dst_pck = gf_filter_pck_new_alloc(ctx->opid, block_size, &output);
+	if (ctx->seg_flush_state) {
+		ctx->dst_pck = gf_filter_pck_new_alloc_destructor(ctx->opid, block_size, &output, mp4_mux_on_packet_destruct);
+	} else {
+		ctx->dst_pck = gf_filter_pck_new_alloc(ctx->opid, block_size, &output);
+	}
 	if (!ctx->dst_pck) return GF_OUT_OF_MEM;
 
 	memcpy(output, data, block_size);
@@ -6388,7 +6883,7 @@
 	ctx->first_pck_sent = GF_TRUE;
 	ctx->current_size += block_size;
 	//non-frag mode, send right away
-	if (ctx->store<MP4MX_MODE_FRAG) {
+	if ((ctx->store<MP4MX_MODE_FRAG) || ctx->seg_flush_state) {
 		mp4mux_send_output(ctx);
 	}
 	return GF_OK;
@@ -6428,7 +6923,7 @@
 		ctx->file = gf_isom_open("_gpac_isobmff_redirect", open_mode, NULL);
 		if (!ctx->file) return GF_OUT_OF_MEM;
 
-		gf_isom_set_write_callback(ctx->file, mp4_mux_on_data, mp4_mux_on_data_patch, filter, ctx->block_size);
+		gf_isom_set_write_callback(ctx->file, mp4_mux_on_data, mp4_mux_on_data_patch, mp4_mux_on_last_block_start, filter, ctx->block_size);
 
 		gf_isom_set_progress_callback(ctx->file, mp4_mux_progress_cbk, filter);
 
@@ -6444,6 +6939,11 @@
 
 	if (!ctx->moovts)
 		ctx->moovts=600;
+
+	if ((ctx->store==MP4MX_MODE_FASTSTART) && (!ctx->cdur.num || !ctx->cdur.den)) {
+		ctx->cdur.num = 1;
+		ctx->cdur.den = 1;
+	}
 	if (!ctx->cdur.den) {
 		ctx->cdur.num = 0;
 		ctx->cdur.den = 1000;
@@ -6481,6 +6981,9 @@
 		gf_isom_enable_compression(ctx->file, ctx->compress, flags);
 	}
 
+	if ((ctx->store>=MP4MX_MODE_FRAG) && !ctx->tsalign)
+		ctx->insert_tfdt = GF_TRUE;
+
 	if (ctx->cmaf) {
 		//cf table 3, 4, 5 of CMAF
 		ctx->mvex = GF_TRUE;
@@ -6984,7 +7487,7 @@
 	"- inter: perform precise interleave of the file using -cdur() (requires temporary storage of all media)\n"
 	"- flat: write samples as they arrive and `moov` at end (fastest mode)\n"
 	"- fstart: write samples as they arrive and `moov` before `mdat`\n"
-	"- tight: uses per-sample interleaving of all tracks (requires temporary storage of all media)\n"
+	"- tight: uses per-sample interleaving of all tracks (requires temporary storage of all media)\n"
 	"- frag: fragments the file using cdur duration\n"
 	"- sfrag: fragments the file using cdur duration but adjusting to start with SAP1/3", GF_PROP_UINT, "inter", "inter|flat|fstart|tight|frag|sfrag", 0},
 	{ OFFS(cdur), "chunk duration for flat and interleaving modes or fragment duration for fragmentation modes\n"
@@ -7008,7 +7511,8 @@
 	{ OFFS(psshs), "set `pssh` boxes store mode\n"
 	"- moof: in first moof of each segments\n"
 	"- moov: in movie box\n"
-	"- none: pssh is discarded", GF_PROP_UINT, "moov", "moov|moof|none", GF_FS_ARG_HINT_ADVANCED},
+	"- both: in movie box and in first moof of each segment\n"
+	"- none: pssh is discarded", GF_PROP_UINT, "moov", "moov|moof|both|none", GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(sgpd_traf), "store sample group descriptions in traf (duplicated for each traf). If not used, sample group descriptions are stored in the movie box", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(vodcache), "enable temp storage for VoD dash modes\n"
 		"- on: use temp storage of complete file for sidx and ssix injection\n"
@@ -7085,6 +7589,10 @@
 		"- cmf2: use CMAF `cmf2` guidelines (turns on `nofragdef`)"
 		, GF_PROP_UINT, "no", "no|cmfc|cmf2", GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(start), "set playback start offset for MP4Box import only. A negative value means percent of media duration with -1 equal to duration", GF_PROP_DOUBLE, "0.0", NULL, GF_FS_ARG_HINT_HIDE},
+	{ OFFS(pad_sparse), "inject sample with no data (size 0) to keep durations in unknown sparse text and metadata tracks", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(force_dv), "force DV sample entry types even when AVC/HEVC compatibility is signaled", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(tsalign), "enable timeline realignment to 0 for first sample in fragmented mode", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_ADVANCED},
+
 	{0}
 };
 
@@ -7125,6 +7633,7 @@
 	"# Tagging\n"
 	"When tagging is enabled, the filter will watch the property `CoverArt` and all custom properties on incoming PID.\n"
 	"The built-in tag names are indicated by `MP4Box -h tags`.\n"
+	"QT tags can be specified using `qtt_NAME` property names, and will be added using formatting specified in `MP4Box -h tags`.\n"
 	"Other tag class may be specified using `tag_NAME` property names, and will be added if -tags() is set to `all` using:\n"
 	"- `NAME` as a box 4CC if `NAME` is four characters long\n"
 	"- `NAME` as a box 4CC if `NAME` is 3 characters long, and will be prefixed by 0xA9\n"
@@ -7154,9 +7663,15 @@
 	"# Notes\n"
 	"The filter watches the property `FileNumber` on incoming packets to create new files (regular mode) or new segments (DASH mode).\n"
 	" \n"
-	"The filter watches the property `DSIWrap` (4CC as int or string) on incoming PID to wrap decoder configuration in a box of given type (unknonw wraping)\n"
+	"The filter watches the property `DSIWrap` (4CC as int or string) on incoming PID to wrap decoder configuration in a box of given type (unknown wrapping)\n"
 	"EX -i unkn.mkv:#ISOMSubtype=VIUK:#DSIWrap=cfgv -o t.mp4\n"
-	"This will wrap the uknown stream using `VIUK` code point in `stsd` and wrap any decoder configuration data in a `cfgv` box.\n"
+	"This will wrap the unknown stream using `VIUK` code point in `stsd` and wrap any decoder configuration data in a `cfgv` box.\n"
+	"\n"
+	"If -pad_sparse() is set, the filter watches the property `Sparse` on incoming PID to decide whether empty packets should be injected to keep packet duration info.\n"
+	"Such packets are only injected when a whole in the timeline is detected.\n"
+	"- if `Sparse` is absent, empty packet is inserted for unknown text and metadata streams\n"
+	"- if `Sparse` is true, empty packet is inserted for all stream types\n"
+	"- if `Sparse` is false, empty packet is never injected\n"
 	)
 	.private_size = sizeof(GF_MP4MuxCtx),
 	.args = MP4MuxArgs,

gpac-2.2.0.tar.gz/src/filters/mux_ogg.c Added

@@ -0,0 +1,574 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / OGG muxer filter
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+
+#include <gpac/filters.h>
+#include <gpac/constants.h>
+
+#ifndef GPAC_DISABLE_OGG
+
+#include <gpac/bitstream.h>
+#include <gpac/internal/ogg.h>
+
+typedef struct
+{
+	GF_FilterPid *ipid;
+	Bool ready;
+	u32 timescale;
+	u64 init_ts, last_ts;
+	u32 theora_kgs;
+	u32 codec_id;
+	u32 nb_i, nb_p;
+	Bool inject_cfg;
+
+	GF_FilterPacket *dangling_ref;
+
+	ogg_stream_state os;
+	ogg_packet op;
+	ogg_page og;
+} OGGMuxStream;
+
+typedef struct
+{
+	GF_Fraction cdur;
+	GF_Fraction rcfg;
+
+	GF_FilterPid *opid;
+	GF_List *streams;
+	u64 nb_pck;
+	Bool is_eos, is_playing;
+	Double start_range;
+	u64 last_reconf;
+
+	u32 page_id;
+	GF_Fraction64 ts_regulate;
+	u32 dash_mode;
+
+	u32 seg_num, next_seg_num;
+	Bool wait_dash, copy_props;
+	u64 seg_start, seg_size;
+
+	Bool force_seg_sync;
+	u32 packets_pending;
+} OGGMuxCtx;
+
+static void oggmux_on_packet_del(GF_Filter *filter, GF_FilterPid *pid, GF_FilterPacket *pck)
+{
+	OGGMuxCtx *ctx = gf_filter_get_udta(filter);
+	gf_filter_lock(filter, GF_TRUE);
+	if (ctx->packets_pending) ctx->packets_pending--;
+	if (!ctx->packets_pending) gf_filter_post_process_task(filter);
+	gf_filter_lock(filter, GF_FALSE);
+}
+
+static GF_Err oggmux_send_page(OGGMuxCtx *ctx, OGGMuxStream *pctx, GF_FilterPacket *in_pck)
+{
+	if (pctx->og.header_len+pctx->og.body_len == 0) return GF_OK;
+
+	u8 *output;
+	GF_FilterPacket *pck;
+	if (ctx->force_seg_sync) {
+		pck = gf_filter_pck_new_alloc_destructor(ctx->opid, pctx->og.header_len+pctx->og.body_len, &output, oggmux_on_packet_del);
+		if (pck) ctx->packets_pending++;
+	} else {
+		pck = gf_filter_pck_new_alloc(ctx->opid, pctx->og.header_len+pctx->og.body_len, &output);
+	}
+	if (!pck) return GF_OUT_OF_MEM;
+
+	memcpy(output, pctx->og.header, pctx->og.header_len);
+	memcpy(output + pctx->og.header_len, pctx->og.body, pctx->og.body_len);
+	Bool start = ctx->nb_pck ? GF_FALSE : GF_TRUE;
+	if (in_pck && ctx->copy_props) {
+		const GF_PropertyValue *p = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_FILENUM);
+		if (p) {
+			gf_filter_pck_set_property(pck, GF_PROP_PCK_FILENUM, p);
+
+			p = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_FILENAME);
+			if (p) {
+				gf_filter_pck_set_property(pck, GF_PROP_PCK_FILENAME, p);
+				start = GF_TRUE;
+			}
+		}
+		ctx->copy_props = GF_FALSE;
+	}
+	gf_filter_pck_set_framing(pck, start, GF_FALSE);
+	gf_filter_pck_send(pck);
+	ctx->nb_pck++;
+	ctx->seg_size += pctx->og.header_len+pctx->og.body_len;
+	return GF_OK;
+}
+
+static GF_Err oggmux_send_config(OGGMuxCtx *ctx, OGGMuxStream *pctx, GF_FilterPacket *in_pck)
+{
+	const GF_PropertyValue *p = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_DECODER_CONFIG);
+	if (!p) return GF_NON_COMPLIANT_BITSTREAM;
+
+	pctx->os.b_o_s = 0;
+	pctx->os.e_o_s = 0;
+
+	if (pctx->codec_id==GF_CODECID_OPUS) {
+		GF_BitStream *bs_out = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		gf_bs_write_data(bs_out, "OpusHead", 8);
+		gf_bs_write_data(bs_out, p->value.data.ptr, p->value.data.size);
+		gf_bs_get_content(bs_out, &pctx->op.packet, &pctx->op.bytes);
+		gf_bs_del(bs_out);
+		ogg_stream_packetin(&pctx->os, &pctx->op);
+		gf_free(pctx->op.packet);
+		pctx->op.packetno ++;
+
+		//opus tags is mandatory
+		bs_out = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		gf_bs_write_data(bs_out, "OpusTags", 8);
+		const char *vendor = gf_sys_is_test_mode() ? "GPAC" : gf_gpac_version();
+		u32 vlen = (u32) strlen(vendor);
+		gf_bs_write_u32_le(bs_out, vlen);
+		gf_bs_write_data(bs_out, vendor, vlen);
+		gf_bs_write_u32_le(bs_out, 0);
+		gf_bs_get_content(bs_out, &pctx->op.packet, &pctx->op.bytes);
+		gf_bs_del(bs_out);
+		ogg_stream_packetin(&pctx->os, &pctx->op);
+		gf_free(pctx->op.packet);
+		pctx->op.packetno ++;
+	} else if (pctx->codec_id==GF_CODECID_FLAC) {
+		GF_BitStream *bs_out = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		gf_bs_write_data(bs_out, "fLaC", 4);
+		gf_bs_write_data(bs_out, p->value.data.ptr, p->value.data.size);
+		gf_bs_get_content(bs_out, &pctx->op.packet, &pctx->op.bytes);
+		gf_bs_del(bs_out);
+		ogg_stream_packetin(&pctx->os, &pctx->op);
+		gf_free(pctx->op.packet);
+		pctx->op.packetno ++;
+	} else if ((pctx->codec_id==GF_CODECID_VORBIS) || (pctx->codec_id==GF_CODECID_THEORA) || (pctx->codec_id==GF_CODECID_SPEEX)) {
+		GF_BitStream *bs = gf_bs_new(p->value.data.ptr, p->value.data.size, GF_BITSTREAM_READ);
+		while (gf_bs_available(bs)) {
+			pctx->op.bytes = gf_bs_read_u16(bs);
+			u32 pos = (u32) gf_bs_get_position(bs);
+			pctx->op.packet = p->value.data.ptr + pos;
+			gf_bs_skip_bytes(bs, pctx->op.bytes);
+			ogg_stream_packetin(&pctx->os, &pctx->op);
+
+			if ((pctx->codec_id==GF_CODECID_THEORA) && (pctx->op.packet0==0x80)){
+				u32 kff;
+				GF_BitStream *vbs = gf_bs_new((char*)pctx->op.packet, pctx->op.bytes, GF_BITSTREAM_READ);
+				gf_bs_skip_bytes(vbs, 40);
+				gf_bs_read_int(vbs, 6); /* quality */
+				kff = 1 << gf_bs_read_int(vbs, 5);
+				gf_bs_del(vbs);
+
+				pctx->theora_kgs = 0;
+				kff--;
+				while (kff) {
+					pctx->theora_kgs ++;
+					kff >>= 1;
+				}
+			}
+			pctx->op.packetno ++;
+		}
+		gf_bs_del(bs);
+
+		if ((pctx->codec_id==GF_CODECID_THEORA) && !pctx->theora_kgs) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OGGMux Missing theora configuration\n"));
+			return GF_NON_COMPLIANT_BITSTREAM;
+		}
+	} else {
+		return GF_NOT_SUPPORTED;
+	}
+
+	while (ogg_stream_pageout(&pctx->os, &pctx->og)>0) {
+		GF_Err e = oggmux_send_page(ctx, pctx, in_pck);
+		if (e) return e;
+	}
+	return GF_OK;
+}
+
+static GF_Err oggmux_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
+{
+	const GF_PropertyValue *p;
+	u32 codec_id;
+	OGGMuxCtx *ctx = (OGGMuxCtx *) gf_filter_get_udta(filter);
+
+	OGGMuxStream *pctx = gf_filter_pid_get_udta(pid);
+	if (is_remove) {
+		if (pctx) {
+			gf_list_del_item(ctx->streams, pctx);
+			if (pctx->dangling_ref) gf_filter_pck_discard(pctx->dangling_ref);
+			ogg_stream_clear(&pctx->os);
+			gf_free(pctx);
+		}
+
+		if (!gf_list_count(ctx->streams) && ctx->opid) {
+			gf_filter_pid_remove(ctx->opid);
+			ctx->opid = NULL;
+		}
+		return GF_OK;
+	}
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+	if (!p) return GF_BAD_PARAM;
+	codec_id = p->value.uint;
+	switch (codec_id) {
+	case GF_CODECID_OPUS:
+	case GF_CODECID_VORBIS:
+	case GF_CODECID_FLAC:
+	case GF_CODECID_THEORA:
+	case GF_CODECID_DIRAC:
+	case GF_CODECID_SPEEX:
+		break;
+	default:
+		return GF_FILTER_NOT_SUPPORTED;
+	}
+
+	if (!ctx->opid) {
+		ctx->opid = gf_filter_pid_new(filter);
+	}
+	gf_filter_pid_copy_properties(ctx->opid, pid);
+	gf_filter_pid_set_name(ctx->opid, "ogg_mux");
+
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, NULL);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, NULL);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, NULL);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, NULL);
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_FILE) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("*") );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("*") );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DASH_MODE, NULL);
+
+	if (!pctx) {
+		GF_SAFEALLOC(pctx, OGGMuxStream);
+		if (!pctx) return GF_OUT_OF_MEM;
+		gf_list_add(ctx->streams, pctx);
+		gf_filter_pid_set_udta(pid, pctx);
+		pctx->ipid = pid;
+		ctx->page_id++;
+		ogg_stream_init(&pctx->os, ctx->page_id);
+		pctx->codec_id = codec_id;
+
+		if (ctx->is_playing) {
+			GF_FilterEvent evt;
+			GF_FEVT_INIT(evt, GF_FEVT_PLAY, pid);
+			evt.play.start_range = ctx->start_range;
+			gf_filter_pid_send_event(pid, &evt);
+		}
+	}
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+	pctx->timescale = p ? p->value.uint : 1000;
+
+	gf_filter_pid_set_framing_mode(pid, GF_TRUE);
+
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DASH_MODE);
+	if (p && p->value.uint) {
+		if (!ctx->dash_mode) ctx->copy_props = GF_TRUE;
+		ctx->dash_mode = p->value.uint;
+		if (ctx->dash_mode == 2) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OGGMux DASH On-demand profile not specified for OGG segments\n"));
+			return GF_FILTER_NOT_SUPPORTED;
+		}
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_FORCE_SEG_SYNC);
+		if (p && p->value.boolean)
+			ctx->force_seg_sync = GF_TRUE;
+	}
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+	if (!p) {
+		pctx->ready = GF_FALSE;
+		return GF_OK;
+	}
+	pctx->ready = GF_TRUE;
+	if (ctx->dash_mode) {
+		pctx->inject_cfg = GF_TRUE;
+		return GF_OK;
+	}
+
+	return oggmux_send_config(ctx, pctx, NULL);
+}
+
+static void oggmux_send_seg_info(OGGMuxCtx *ctx)
+{
+	if (ctx->seg_size) {
+		GF_FilterEvent evt;
+		OGGMuxStream *pctx = gf_list_get(ctx->streams, 0);
+		GF_FEVT_INIT(evt, GF_FEVT_SEGMENT_SIZE, pctx->ipid);
+		evt.seg_size.media_range_start = ctx->seg_start;
+		evt.seg_size.media_range_end = ctx->seg_start + ctx->seg_size - 1;
+		gf_filter_pid_send_event(pctx->ipid, &evt);
+
+		ctx->seg_start += ctx->seg_size;
+		ctx->seg_size = 0;
+	}
+}
+static GF_Err oggmux_process(GF_Filter *filter)
+{
+	u32 nb_skip=0;
+	OGGMuxCtx *ctx = (OGGMuxCtx *) gf_filter_get_udta(filter);
+	u32 i, nb_done = 0, count = gf_list_count(ctx->streams), nb_dash_done = 0;;
+
+	for (i=0; i<count; i++) {
+		const u8 *data=NULL;
+		u32 size;
+		OGGMuxStream *pctx = gf_list_get(ctx->streams, i);
+		GF_FilterPacket *pck = gf_filter_pid_get_packet(pctx->ipid);
+
+		if (!pctx->ready) {
+			continue;
+		}
+		if (!pck) {
+			if (gf_filter_pid_is_eos(pctx->ipid)) nb_done++;
+			continue;
+		}
+
+		if (gf_filter_pck_get_frame_interface(pck)!=NULL) {
+			pctx->dangling_ref = gf_filter_pck_dangling_copy(pck, pctx->dangling_ref);
+			if (pctx->dangling_ref) data = gf_filter_pck_get_data(pctx->dangling_ref, &size);
+		} else {
+			data = gf_filter_pck_get_data(pck, &size);
+		}
+		if (!data) {
+			continue;
+		}
+
+		if (ctx->dash_mode) {
+			const GF_PropertyValue *p = gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM);
+			if (p && (p->value.uint>ctx->seg_num)) {
+				if (!ctx->wait_dash) {
+					ctx->next_seg_num = p->value.uint;
+				}
+				ctx->wait_dash = GF_TRUE;
+				nb_dash_done ++;
+				continue;
+			}
+		} else if (count>1) {
+			u64 ts = gf_filter_pck_get_dts(pck);
+			if (ts==GF_FILTER_NO_TS)
+				ts = gf_filter_pck_get_cts(pck);
+
+			if (ts!=GF_FILTER_NO_TS) {
+				if (!pctx->init_ts) pctx->init_ts = ts+1;
+				ts -= pctx->init_ts-1;
+
+				//ahead of our interleaving window, don't write yet
+				if (gf_timestamp_greater(ts, pctx->timescale, ctx->ts_regulate.num, ctx->ts_regulate.den)) {
+					nb_skip++;
+					continue;
+				}
+			}
+		}
+
+		if (pctx->inject_cfg) {
+			if (ctx->dash_mode || gf_filter_pck_get_sap(pck)) {
+				//reinit stream
+				u32 pageno = pctx->os.serialno;
+
+				ogg_stream_clear(&pctx->os);
+				ogg_stream_init(&pctx->os, pageno);
+
+				GF_Err e = oggmux_send_config(ctx, pctx, pck);
+				if (e) return e;
+				pctx->inject_cfg = GF_FALSE;
+			}
+		}
+
+		ctx->is_eos = GF_FALSE;
+		pctx->op.bytes = size;
+		pctx->op.packet = (unsigned char*)data;
+		pctx->op.packetno ++;
+
+		if (pctx->theora_kgs) {
+ Bool is_sap = (data0 & 0x40) ? 0 : 1;
+			if (is_sap) {
+				pctx->nb_i += pctx->nb_p;
+				pctx->nb_p = 0;
+			} else {
+				pctx->nb_p++;
+			}
+			if (pctx->nb_p >= (u32) (1<<pctx->theora_kgs)) {
+				pctx->nb_i += pctx->nb_p;
+				pctx->nb_p = 0;
+			}
+			pctx->op.granulepos = (pctx->nb_i << pctx->theora_kgs) | pctx->nb_p;
+		} else {
+			u64 cts = gf_filter_pck_get_cts(pck);
+			if (cts == GF_FILTER_NO_TS) cts = pctx->last_ts;
+			else pctx->last_ts = cts;
+
+			pctx->op.granulepos = cts + gf_filter_pck_get_duration(pck);
+		}
+
+		if (gf_filter_pid_is_eos(pctx->ipid))
+			pctx->op.e_o_s = 1;
+
+		ogg_stream_packetin(&pctx->os, &pctx->op);
+
+		while (ogg_stream_pageout(&pctx->os, &pctx->og)>0) {
+			oggmux_send_page(ctx, pctx, pck);
+		}
+
+		gf_filter_pid_drop_packet(pctx->ipid);
+	}
+
+	if (nb_done == count) {
+		if (ctx->is_eos) return GF_EOS;
+		ctx->is_eos = GF_TRUE;
+		for (i=0; i<count; i++) {
+			OGGMuxStream *pctx = gf_list_get(ctx->streams, i);
+
+			while (ogg_stream_flush(&pctx->os, &pctx->og)>0) {
+				oggmux_send_page(ctx, pctx, NULL);
+			}
+			ogg_stream_clear(&pctx->os);
+		}
+		gf_filter_pid_set_eos(ctx->opid);
+		oggmux_send_seg_info(ctx);
+		return GF_EOS;
+	}
+	else if (ctx->dash_mode) {
+		if (ctx->wait_dash) {
+			OGGMuxStream *pctx;
+			if (ctx->packets_pending)
+				return GF_OK;
+			if (nb_dash_done < count) return GF_OK;
+			ctx->wait_dash = GF_FALSE;
+			ctx->seg_num = ctx->next_seg_num;
+			ctx->copy_props = GF_TRUE;
+			for (i=0; i<count; i++) {
+				pctx = gf_list_get(ctx->streams, i);
+				pctx->inject_cfg = GF_TRUE;
+
+				if (ogg_stream_flush(&pctx->os, &pctx->og)>0)
+					oggmux_send_page(ctx, pctx, NULL);
+			}
+			oggmux_send_seg_info(ctx);
+		}
+	}
+	else if ((count>1) && (nb_skip == count)) {
+		ctx->ts_regulate.num += ctx->cdur.num;
+
+		if (ctx->rcfg.num &&ctx->rcfg.den) {
+			if (gf_timestamp_greater_or_equal(ctx->ts_regulate.num, ctx->ts_regulate.den, ctx->last_reconf, ctx->rcfg.den)) {
+				ctx->last_reconf += ctx->rcfg.num;
+				for (i=0; i<count; i++) {
+					OGGMuxStream *pctx = gf_list_get(ctx->streams, i);
+					pctx->inject_cfg = GF_TRUE;
+				}
+			}
+		}
+	}
+
+	return GF_OK;
+}
+
+static Bool oggmux_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
+{
+	OGGMuxCtx *ctx = (OGGMuxCtx *) gf_filter_get_udta(filter);
+	if (evt->base.type == GF_FEVT_PLAY) {
+		ctx->is_playing = GF_TRUE;
+		ctx->start_range = evt->play.start_range;
+	} else if (evt->base.type == GF_FEVT_STOP)
+		ctx->is_playing = GF_FALSE;
+
+	return GF_FALSE;
+}
+
+static GF_Err oggmux_initialize(GF_Filter *filter)
+{
+	OGGMuxCtx *ctx = (OGGMuxCtx *) gf_filter_get_udta(filter);
+	ctx->streams = gf_list_new();
+	if (ctx->cdur.num * (s32) ctx->cdur.den <= 0) {
+		ctx->cdur.num = 1000;
+		ctx->cdur.den = 1000;
+	}
+	ctx->last_reconf = ctx->rcfg.num;
+	ctx->ts_regulate.num = ctx->cdur.num;
+	ctx->ts_regulate.den = ctx->cdur.den;
+	return GF_OK;
+}
+
+static void oggmux_finalize(GF_Filter *filter)
+{
+	OGGMuxCtx *ctx = (OGGMuxCtx *) gf_filter_get_udta(filter);
+
+	while (gf_list_count(ctx->streams)) {
+		OGGMuxStream *pctx = gf_list_pop_back(ctx->streams);
+		if (pctx->dangling_ref) gf_filter_pck_discard(pctx->dangling_ref);
+		ogg_stream_clear(&pctx->os);
+		gf_free(pctx);
+	}
+	gf_list_del(ctx->streams);
+}
+
+#define OFFS(_n)	#_n, offsetof(OGGMuxCtx, _n)
+
+static const GF_FilterArgs OGGMuxArgs =
+{
+	{ OFFS(cdur), "stream interleaving duration in seconds", GF_PROP_FRACTION, "1/10", NULL, 0},
+	{ OFFS(rcfg), "stream config re-injection frequency in seconds", GF_PROP_FRACTION, "0/1", NULL, 0},
+	{0}
+};
+
+static const GF_FilterCapability OGGMuxCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_THEORA),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_VORBIS),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_OPUS),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_FLAC),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SPEEX),
+	CAP_UINT(GF_CAPS_OUTPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "oga|spx|ogg|ogv|oggm|opus"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/ogg|audio/x-ogg|audio/x-vorbis+ogg|application/ogg|application/x-ogg|video/ogg|video/x-ogg|video/x-ogm+ogg|audio/opus|audio/x-opus"),
+	{0}
+};
+
+
+
+GF_FilterRegister OGGMuxRegister = {
+	.name = "oggmx",
+	GF_FS_SET_DESCRIPTION("OGG multiplexer")
+	GF_FS_SET_HELP("This filter multiplexes audio and video to produce an OGG stream.\n"
+		"\n"
+		"The -cdur() option allows specifiying the interleaving duration (max time difference between consecutive packets of different streams). \n"
+	)
+	.private_size = sizeof(OGGMuxCtx),
+	.max_extra_pids = -1,
+	.args = OGGMuxArgs,
+	SETCAPS(OGGMuxCaps),
+	.initialize = oggmux_initialize,
+	.finalize = oggmux_finalize,
+	.configure_pid = oggmux_configure_pid,
+	.process = oggmux_process,
+	.process_event = oggmux_process_event,
+};
+
+#endif
+
+const GF_FilterRegister *oggmux_register(GF_FilterSession *session)
+{
+#ifndef GPAC_DISABLE_OGG
+	return &OGGMuxRegister;
+#else
+	return NULL;
+#endif
+
+}
+

gpac-2.0.0.tar.gz/src/filters/mux_ts.c -> gpac-2.2.0.tar.gz/src/filters/mux_ts.c Changed

@@ -30,13 +30,6 @@
 #include <gpac/webvtt.h>
 
 
-#ifndef GPAC_DISABLE_MPEG2TS_MUX
-
-
-#define M2TS_FILE_EXTS "ts|m2t|mts|dmb|trp"
-#define M2TS_MIMES "video/mpeg-2|video/mp2t|video/mpeg|audio/mp2t"
-
-
 void mux_assign_mime_file_ext(GF_FilterPid *ipid, GF_FilterPid *opid, const char *file_exts, const char *mime_types, const char *def_ext)
 {
 	Bool found=GF_FALSE;
@@ -68,6 +61,13 @@
 		gf_filter_pid_set_property(opid, GF_PROP_PID_MIME, &PROP_STRING("*") );
 }
 
+#ifndef GPAC_DISABLE_MPEG2TS_MUX
+
+
+#define M2TS_FILE_EXTS "ts|m2t|mts|dmb|trp"
+#define M2TS_MIMES "video/mpeg-2|video/mp2t|video/mpeg|audio/mp2t"
+
+
 
 
 enum
@@ -154,6 +154,10 @@
 	u32 frag_offset, frag_size, frag_duration;
 	Bool frag_has_intra;
 
+	Bool force_seg_sync;
+	u32 pending_packets;
+
+	u32 sync_init_time;
 } GF_TSMuxCtx;
 
 typedef struct
@@ -216,6 +220,7 @@
 
 	u32 suspended;
 	u64 llhls_dts_init;
+	Bool is_sparse;
 } M2Pid;
 
 static GF_Err tsmux_format_af_descriptor(GF_BitStream *bs, u32 timeline_id, u64 timecode, u32 timescale, u32 mode_64bits, u64 ntp, const char *temi_url, u32 temi_delay, u32 *last_url_time)
@@ -410,8 +415,11 @@
 				if (tspid->ctx->dash_mode)
 					tspid->has_seen_eods = M2TS_EODS_FOUND;
 			}
+			if (tspid->is_sparse) ifce->caps |= GF_ESI_STREAM_SPARSE;
 			return GF_OK;
 		}
+		if (tspid->is_sparse) ifce->caps &= ~GF_ESI_STREAM_SPARSE;
+
 		p = gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM);
 		if (tspid->ctx->dash_mode) {
 
@@ -669,7 +677,7 @@
 		else if (tspid->codec_id == GF_CODECID_WEBVTT) {
 			u32 i;
 			u64 start_ts, end_ts;
-			void webvtt_write_cue(GF_BitStream *bs, GF_WebVTTCue *cue, Bool write_srt);
+			void webvtt_write_cue_bs(GF_BitStream *bs, GF_WebVTTCue *cue, Bool write_srt);
 			GF_List *cues;
 			GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 
@@ -679,7 +687,7 @@
 			cues = gf_webvtt_parse_cues_from_data(es_pck.data, es_pck.data_len, start_ts, end_ts);
 			for (i = 0; i < gf_list_count(cues); i++) {
 				GF_WebVTTCue *cue = (GF_WebVTTCue *)gf_list_get(cues, i);
-				webvtt_write_cue(bs, cue, GF_FALSE);
+				webvtt_write_cue_bs(bs, cue, GF_FALSE);
 				gf_webvtt_cue_del(cue);
 			}
 			gf_list_del(cues);
@@ -785,8 +793,9 @@
 	}
 
 	p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_DURATION);
-	if (p) {
+	if (p && p->value.lfrac.den) {
 		tspid->esi.duration = (Double) p->value.lfrac.num;
+		if (tspid->esi.duration<0) tspid->esi.duration=-tspid->esi.duration;
 		tspid->esi.duration /= p->value.lfrac.den;
 	}
 	p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_BITRATE);
@@ -858,6 +867,53 @@
 	else if ((tspid->esi.caps & GF_ESI_FORCE_DOLBY_VISION) != (bckp.caps & GF_ESI_FORCE_DOLBY_VISION))
 		changed = GF_TRUE;
 
+	u32 crc_old = 0, crc_new = 0;;
+	if (tspid->esi.gpac_meta_dsi) {
+		crc_old = gf_crc_32(tspid->esi.gpac_meta_dsi, tspid->esi.gpac_meta_dsi_size);
+		gf_free(tspid->esi.gpac_meta_dsi);
+		tspid->esi.gpac_meta_dsi = NULL;
+		tspid->esi.gpac_meta_dsi_size = 0;
+	}
+	p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_META_DEMUX_CODEC_ID);
+	if (p) {
+		GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		gf_bs_write_u32(bs, tspid->esi.codecid);
+		gf_bs_write_u8(bs, tspid->esi.stream_type);
+		gf_bs_write_u8(bs, 1); //version
+		gf_bs_write_u32(bs, p->value.uint);
+		p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_META_DEMUX_CODEC_NAME);
+		gf_bs_write_utf8(bs, p ? p->value.string : NULL);
+		tspid->esi.gpac_meta_name = p ? p->value.string : NULL;
+		p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_META_DEMUX_OPAQUE);
+		gf_bs_write_u32(bs, p ? p->value.uint : 0);
+
+		//DSI before stream-specific attributes so we can further extends without breaking
+		if (tspid->esi.decoder_config) {
+			gf_bs_write_u32(bs, tspid->esi.decoder_config_size);
+			gf_bs_write_data(bs, tspid->esi.decoder_config, tspid->esi.decoder_config_size);
+		} else {
+			gf_bs_write_u32(bs, 0);
+		}
+		
+		if (tspid->esi.stream_type==GF_STREAM_VISUAL) {
+			p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_WIDTH);
+			gf_bs_write_u32(bs, p ? p->value.uint : 0);
+			p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_HEIGHT);
+			gf_bs_write_u32(bs, p ? p->value.uint : 0);
+		} else if (tspid->esi.stream_type==GF_STREAM_AUDIO) {
+			p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_SAMPLE_RATE);
+			gf_bs_write_u32(bs, p ? p->value.uint : 0);
+			p = gf_filter_pid_get_property(tspid->ipid, GF_PROP_PID_NUM_CHANNELS);
+			gf_bs_write_u32(bs, p ? p->value.uint : 0);
+		}
+
+		gf_bs_get_content(bs, &tspid->esi.gpac_meta_dsi, &tspid->esi.gpac_meta_dsi_size);
+		gf_bs_del(bs);
+		crc_new = gf_crc_32(tspid->esi.gpac_meta_dsi, tspid->esi.gpac_meta_dsi_size);
+	}
+	if (crc_old != crc_new) {
+		changed = GF_TRUE;
+	}
 
 	u32 m2ts_ra = 0;
 	p = gf_filter_pid_get_property_str(tspid->ipid, "M2TSRA");
@@ -1017,6 +1073,7 @@
 
 	if (tspid->esi.sl_config) gf_free(tspid->esi.sl_config);
 	if (tspid->pck_data_buf) gf_free(tspid->pck_data_buf);
+	if (tspid->esi.gpac_meta_dsi) gf_free(tspid->esi.gpac_meta_dsi);
 	gf_free(tspid);
 }
 
@@ -1094,6 +1151,10 @@
 		if (ctx->dash_mode) {
 			ctx->mux->flush_pes_at_rap = GF_TRUE;
 			gf_m2ts_mux_set_initial_pcr(ctx->mux, 0);
+
+			p = gf_filter_pid_get_property(pid, GF_PROP_PID_FORCE_SEG_SYNC);
+			if (p && p->value.boolean)
+				ctx->force_seg_sync = GF_TRUE;
 		}
 	}
 	p = gf_filter_pid_get_info(pid, GF_PROP_PID_LLHLS, &pe);
@@ -1177,6 +1238,9 @@
 
 		GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("M2TSMux Setting up program ID %d - send rates: PSI %d ms PCR every %d ms max - PCR offset %d\n", service_id, ctx->pmt_rate, ctx->max_pcr, ctx->pcr_offset));
 	}
+	if (tspid->esi.stream_type != streamtype)
+		tspid->codec_id = 0;
+
 	//first setup
 	if (!tspid->codec_id) {
 		Bool is_pcr=GF_FALSE;
@@ -1206,6 +1270,20 @@
 		if (!ctx->mux->ref_pid || (streamtype==GF_STREAM_VISUAL))
 			ctx->mux->ref_pid = pes_pid;
 
+		tspid->is_sparse = GF_FALSE;
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_SPARSE);
+		if (p && p->value.boolean) {
+			tspid->is_sparse = GF_TRUE;
+		} else {
+			switch (tspid->esi.stream_type) {
+			case GF_STREAM_AUDIO:
+			case GF_STREAM_VISUAL:
+				break;
+			default:
+				tspid->is_sparse = GF_TRUE;
+				break;
+			}
+		}
 	}
 	//no changes in codec ID, update ifce, notify pmt update if needed and return
 	else if (tspid->codec_id == codec_id) {
@@ -1292,16 +1370,30 @@
 
 static Bool tsmux_init_buffering(GF_Filter *filter, GF_TSMuxCtx *ctx)
 {
+	u32 not_ready=0;
 	u32 mbuf = ctx->breq*1000;
-	u32 i, count = gf_filter_get_ipid_count(filter);
+	u32 i, count = gf_list_count(ctx->pids);
 	for (i=0; i<count; i++) {
 		u32 buf;
 		Bool buf_ok;
-		GF_FilterPid *pid = gf_filter_get_ipid(filter, i);
-		buf_ok = gf_filter_pid_get_buffer_occupancy(pid, NULL, NULL, NULL, &buf);
-		if (buf_ok && (buf < mbuf) && !gf_filter_pid_has_seen_eos(pid))
+		M2Pid *tspid = gf_list_get(ctx->pids, i);
+		buf_ok = gf_filter_pid_get_buffer_occupancy(tspid->ipid, NULL, NULL, NULL, &buf);
+		if (buf_ok && (buf < mbuf) && !gf_filter_pid_has_seen_eos(tspid->ipid)) {
+			if (!tspid->is_sparse) not_ready++;
+		}
+	}
+	if (not_ready) {
+		u32 now = gf_sys_clock();
+		if (!ctx->sync_init_time) {
+			ctx->sync_init_time = now;
+		} else if (now - ctx->sync_init_time < 5000) {
 			return GF_FALSE;
+		} else {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("M2TSMux Failed to fetch one sample on each stream after %d ms, skipping initial sync\n", now - ctx->sync_init_time));
+		}
 	}
+	ctx->sync_init_time=0;
+
 	ctx->init_buffering = GF_FALSE;
 	gf_m2ts_mux_update_config(ctx->mux, GF_TRUE);
 	return GF_TRUE;
@@ -1468,6 +1560,19 @@
 	ctx->frag_has_intra = GF_FALSE;
 }
 
+static void ts_mux_on_packet_del(GF_Filter *filter, GF_FilterPid *pid, GF_FilterPacket *pck)
+{
+	GF_TSMuxCtx *ctx = gf_filter_get_udta(filter);
+	if (ctx->force_seg_sync) {
+		gf_filter_lock(filter, GF_TRUE);
+		if (ctx->pending_packets)
+			ctx->pending_packets--;
+		if (!ctx->pending_packets)
+			gf_filter_post_process_task(filter);
+		gf_filter_lock(filter, GF_FALSE);
+	}
+}
+
 static GF_Err tsmux_process(GF_Filter *filter)
 {
 	u32 nb_pck_in_pack, nb_pck_in_call;
@@ -1514,6 +1619,10 @@
 
 
 	if (ctx->wait_dash_flush || ctx->wait_llhls_flush) {
+		//we are waiting for all packets to be flushed
+		if (ctx->pending_packets)
+			return GF_OK;
+
 		Bool is_llhls_flush = GF_FALSE;
 		Bool is_eods_flush = GF_FALSE;
 		u32 i, done=0, count = gf_list_count(ctx->pids);
@@ -1600,7 +1709,12 @@
 			}
 		}
 		osize = nb_pck_in_pack * 188;
-		pck = gf_filter_pck_new_alloc(ctx->opid, osize, &output);
+		if (ctx->force_seg_sync) {
+			pck = gf_filter_pck_new_alloc_destructor(ctx->opid, osize, &output, ts_mux_on_packet_del);
+			if (pck) ctx->pending_packets++;
+		} else {
+			pck = gf_filter_pck_new_alloc(ctx->opid, osize, &output);
+		}
 		if (!pck) return GF_OUT_OF_MEM;
 		
 		memcpy(output, ts_pck, osize);
@@ -1832,8 +1946,12 @@
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_HEVC),
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_LHVC),
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_VVC),
+	// For AV1, we need to split TU into 1 frame header per PES
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_AV1),
 	//for m4vp2 we want DSI reinsertion
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_MPEG4_PART2),
+	//for vc1 we want DSI reinsertion
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_CODECID, GF_CODECID_SMPTE_VC1),
 	//for AAC we use the AAC->ADTS or AAC->LATM of the mux, so don't insert here
 
 	//for MPEG-H audio MHAS we need to insert sync packets
@@ -1858,6 +1976,8 @@
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_VVC),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MPEG4_PART2),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MHAS),
+	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_AV1),
+	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_SMPTE_VC1),
 	//we don't accept MPEG-H audio without MHAS
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MPHA),
 	//no RAW support for now$
@@ -1975,7 +2095,7 @@
 		"\n"
 		"The filter watches the property `FileNumber` on incoming packets to create new files, or new segments in DASH mode.\n"
 		"The filter will look for property `M2TSRA` set on the input stream.\n"
-		"The value can either be a 4CC or a string, indicating the MP2G-2 TS Registration tag for unknwon media types.\n"
+		"The value can either be a 4CC or a string, indicating the MP2G-2 TS Registration tag for unknown media types.\n"
 	)
 	.private_size = sizeof(GF_TSMuxCtx),
 	.args = TSMuxArgs,
@@ -1994,4 +2114,11 @@
 	return &TSMuxRegister;
 }
 
+#else
+
+const GF_FilterRegister *tsmux_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+
 #endif /*GPAC_DISABLE_MPEG2TS_MUX*/

gpac-2.0.0.tar.gz/src/filters/out_audio.c -> gpac-2.2.0.tar.gz/src/filters/out_audio.c Changed

@@ -39,7 +39,8 @@
 	Double speed, start;
 	u32 vol, pan, buffer, mbuffer, rbuffer;
 	GF_Fraction adelay;
-	
+	Double media_offset;
+
 	GF_FilterPid *pid;
 	u32 sr, afmt, nb_ch, timescale;
 	u64 ch_cfg;
@@ -222,7 +223,8 @@
 		we therefore probe the first packet before probing the buffer fullness*/
 		pck = gf_filter_pid_get_packet(ctx->pid);
 		if (!pck) {
-			if (gf_filter_pid_is_eos(ctx->pid))
+			//pid may be set to NULL if removed
+			if (!ctx->pid || gf_filter_pid_is_eos(ctx->pid))
 				ctx->is_eos = GF_TRUE;
 			return 0;
 		}
@@ -289,6 +291,14 @@
 			delay += gf_timestamp_rescale(ctx->adelay.num, ctx->adelay.den, ctx->timescale);
 
 		cts = gf_filter_pck_get_cts(pck);
+
+		const GF_PropertyValue *p = gf_filter_pck_get_property(pck, GF_PROP_PCK_MEDIA_TIME);
+		if (p) {
+			Double a_ts = (Double) gf_filter_pck_get_cts(pck);
+			a_ts /= ctx->timescale;
+			ctx->media_offset = a_ts - p->value.number;
+		}
+
 		if (delay >= 0) {
 			cts += delay;
 		} else if (cts < (u64) -delay) {
@@ -372,6 +382,7 @@
 				ctx->pck_offset += nb_copy;
 				return done;
 			}
+			ctx->last_cts += (size / ctx->bytes_per_sample) * ctx->sr;
 			ctx->pck_offset = 0;
 		}
 		gf_filter_pid_drop_packet(ctx->pid);
@@ -397,8 +408,13 @@
 	GF_AudioOutCtx *ctx = (GF_AudioOutCtx *) gf_filter_get_udta(filter);
 
 	if (is_remove) {
-		assert(ctx->pid==pid);
-		ctx->pid=NULL;
+		assert(ctx->pid == pid);
+		ctx->pid = NULL;
+		//set a NULL clock hint in case other sinks using clock hints are still running
+		GF_Fraction64 mtime;
+		mtime.num = 0;
+		mtime.den = 0;
+		gf_filter_hint_single_clock(filter, 0, mtime);
 		return GF_OK;
 	}
 	assert(!ctx->pid || (ctx->pid==pid));
@@ -455,6 +471,7 @@
 			buffer_req_changed = GF_TRUE;
 		}
 	}
+	ctx->pid = pid;
 
 	if ((ctx->sr!=sr) || (ctx->afmt != afmt) || (ctx->nb_ch != nb_ch)) {
 		buffer_req_changed = GF_TRUE;
@@ -504,8 +521,6 @@
 		ctx->speed = evt.play.speed;
 		ctx->start = evt.play.start_range;
 	}
-
-	ctx->pid = pid;
 	ctx->sr = sr;
 	ctx->afmt = afmt;
 	ctx->nb_ch = nb_ch;
@@ -552,7 +567,7 @@
 	if (!ctx->bnum || !ctx->bdur) ctx->bnum = ctx->bdur = 0;
 
 	os_wnd_handler = NULL;
-	sOpt = gf_opts_get_key("Temp", "OSWnd");
+	sOpt = gf_opts_get_key("temp", "window-handle");
 	if (sOpt) sscanf(sOpt, "%p", &os_wnd_handler);
 	e = ctx->audio_out->Setup(ctx->audio_out, os_wnd_handler, ctx->bnum, ctx->bdur);
 
@@ -616,6 +631,9 @@
 	}
 
 	if (ctx->th || ctx->audio_out->SelfThreaded) {
+		//not configured, force fetching first packet
+		if (!ctx->sr && ctx->pid)
+			gf_filter_pid_get_packet(ctx->pid);
 		if (ctx->is_eos) return GF_EOS;
 		gf_filter_ask_rt_reschedule(filter, 100000);
 		return GF_OK;
@@ -693,6 +711,7 @@
 	{ OFFS(adelay), "set audio delay in sec", GF_PROP_FRACTION, "0", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
 	{ OFFS(buffer_done), "buffer done indication (readonly, for user app)", GF_PROP_BOOL, NULL, NULL, GF_ARG_HINT_EXPERT},
 	{ OFFS(rebuffer), "system time in us at which last rebuffer started, 0 if not rebuffering (readonly, for user app)", GF_PROP_LUINT, NULL, NULL, GF_ARG_HINT_EXPERT},
+	{ OFFS(media_offset), "media offset (substract this value to CTS to get media time - readonly)", GF_PROP_DOUBLE, "0", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -714,6 +733,11 @@
 	"If -clock() is set, the filter will report system time (in us) and corresponding packet CTS for other filters to use for AV sync.\n")
 	.private_size = sizeof(GF_AudioOutCtx),
 	.args = AudioOutArgs,
+#ifdef GPAC_CONFIG_ANDROID
+	//on android pin on man thread so that all events/commands come from main thread
+	//we use a dedicated thread for filling the audio
+	.flags = GF_FS_REG_MAIN_THREAD,
+#endif
 	SETCAPS(AudioOutCaps),
 	.initialize = aout_initialize,
 	.finalize = aout_finalize,

gpac-2.0.0.tar.gz/src/filters/out_file.c -> gpac-2.2.0.tar.gz/src/filters/out_file.c Changed

@@ -363,6 +363,7 @@
 
 static GF_Err fileout_process(GF_Filter *filter)
 {
+	GF_Err e=GF_OK;
 	GF_FilterPacket *pck;
 	const GF_PropertyValue *fname, *p;
 	Bool start, end;
@@ -544,6 +545,7 @@
 
 						if (nb_write!=pck_size) {
 							GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Write error, wrote %d bytes but had %d to write\n", nb_write, pck_size));
+							e = GF_IO_ERR;
 						}
 						cur_w = gf_ftell(ctx->file);
 
@@ -554,6 +556,7 @@
 						block = gf_malloc(ctx->mvbk);
 						if (!block) {
 							GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut unable to allocate block of %d bytes\n", ctx->mvbk));
+							e = GF_IO_ERR;
 						} else {
 							while (cur_r > bo) {
 								u32 move_bytes = ctx->mvbk;
@@ -565,6 +568,7 @@
 
 								if (nb_write!=move_bytes) {
 									GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Read error, got %d bytes but had %d to read\n", nb_write, move_bytes));
+									e = GF_IO_ERR;
 								}
 
 								gf_fseek(ctx->file, cur_w - move_bytes, SEEK_SET);
@@ -572,6 +576,7 @@
 
 								if (nb_write!=move_bytes) {
 									GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Write error, wrote %d bytes but had %d to write\n", nb_write, move_bytes));
+									e = GF_IO_ERR;
 								}
 								cur_r -= move_bytes;
 								cur_w -= move_bytes;
@@ -586,12 +591,14 @@
 
 					if (nb_write!=pck_size) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Write error, wrote %d bytes but had %d to write\n", nb_write, pck_size));
+						e = GF_IO_ERR;
 					}
 				}
 			} else {
 				nb_write = (u32) gf_fwrite(pck_data, pck_size, ctx->file);
 				if (nb_write!=pck_size) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Write error, wrote %d bytes but had %d to write\n", nb_write, pck_size));
+					e = GF_IO_ERR;
 				}
 				ctx->nb_write += nb_write;
 
@@ -599,6 +606,7 @@
 					nb_write = (u32) gf_fwrite(pck_data, pck_size, ctx->hls_chunk);
 					if (nb_write!=pck_size) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Write error, wrote %d bytes but had %d to write\n", nb_write, pck_size));
+						e = GF_IO_ERR;
 					}
 				}
 			}
@@ -620,7 +628,7 @@
 					u32 j, write_h, lsize;
 					const u8 *out_ptr;
 					u32 out_stride = i ? stride_uv : stride;
-					GF_Err e = hwf->get_plane(hwf, i, &out_ptr, &out_stride);
+					e = hwf->get_plane(hwf, i, &out_ptr, &out_stride);
 					if (e) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Failed to fetch plane data from hardware frame, cannot write\n"));
 						break;
@@ -636,6 +644,7 @@
 						nb_write = (u32) gf_fwrite(out_ptr, lsize, ctx->file);
 						if (nb_write!=lsize) {
 							GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("FileOut Write error, wrote %d bytes but had %d to write\n", nb_write, lsize));
+							e = GF_IO_ERR;
 						}
 						ctx->nb_write += nb_write;
 						out_ptr += out_stride;
@@ -657,7 +666,7 @@
 		snprintf(szStatus, 1024, "%s: wrote % 16"LLD_SUF" bytes", gf_file_basename(ctx->szFileName), (s64) ctx->nb_write);
 		gf_filter_update_status(filter, -1, szStatus);
 	}
-	return GF_OK;
+	return e;
 }
 
 static Bool fileout_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
@@ -746,7 +755,7 @@
 	)
 	.private_size = sizeof(GF_FileOutCtx),
 	.args = FileOutArgs,
-	.flags = GF_FS_REG_FORCE_REMUX,
+	.flags = GF_FS_REG_FORCE_REMUX | GF_FS_REG_TEMP_INIT,
 	SETCAPS(FileOutCaps),
 	.probe_url = fileout_probe_url,
 	.initialize = fileout_initialize,
@@ -759,6 +768,9 @@
 
 const GF_FilterRegister *fileout_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_out_proto", FileOutRegister.name, "file,gfio");
+	}
 	return &FileOutRegister;
 }

gpac-2.0.0.tar.gz/src/filters/out_http.c -> gpac-2.2.0.tar.gz/src/filters/out_http.c Changed

@@ -34,20 +34,24 @@
 #include <gpac/network.h>
 
 //socket and SSL context ownership is transfered to the download session object
-GF_DownloadSession *gf_dm_sess_new_server(GF_Socket *server, void *ssl_ctx, gf_dm_user_io user_io, void *usr_cbk, GF_Err *e);
+GF_DownloadSession *gf_dm_sess_new_server(GF_DownloadManager *dm, GF_Socket *server, void *ssl_ctx, gf_dm_user_io user_io, void *usr_cbk, Bool async, GF_Err *e);
 GF_DownloadSession *gf_dm_sess_new_subsession(GF_DownloadSession *sess, u32 stream_id, void *usr_cbk, GF_Err *e);
 u32 gf_dm_sess_subsession_count(GF_DownloadSession *);
 
-
+GF_Socket *gf_dm_sess_get_socket(GF_DownloadSession *);
 GF_Err gf_dm_sess_send(GF_DownloadSession *sess, u8 *data, u32 size);
 void gf_dm_sess_clear_headers(GF_DownloadSession *sess);
 void gf_dm_sess_set_header(GF_DownloadSession *sess, const char *name, const char *value);
+GF_Err gf_dm_sess_flush_async(GF_DownloadSession *sess, Bool no_select);
+u32 gf_dm_sess_async_pending(GF_DownloadSession *sess);
 
 GF_Err gf_dm_sess_send_reply(GF_DownloadSession *sess, u32 reply_code, const char *response_body, Bool no_body);
 void gf_dm_sess_server_reset(GF_DownloadSession *sess);
 Bool gf_dm_sess_is_h2(GF_DownloadSession *sess);
 void gf_dm_sess_flush_h2(GF_DownloadSession *sess);
 
+void gf_dm_sess_set_sock_group(GF_DownloadSession *sess, GF_SockGroup *sg);
+
 #ifdef GPAC_HAS_SSL
 
 void *gf_ssl_new(void *ssl_server_ctx, GF_Socket *client_sock, GF_Err *e);
@@ -71,13 +75,23 @@
 	CORS_ON,
 };
 
+
+typedef struct
+{
+	char *name;
+	u32 name_len;
+	char *path;
+	char *ru, *rg, *wu, *wg;
+	Bool is_subpath;
+} HTTP_DIRInfo;
+
 typedef struct
 {
 	//options
 	char *dst, *user_agent, *ifce, *cache_control, *ext, *mime, *wdir, *cert, *pkey, *reqlog;
 	GF_PropStringList rdirs;
-	Bool close, hold, quit, post, dlist, ice;
-	u32 port, block_size, maxc, maxp, timeout, hmode, sutc, cors, max_client_errors;
+	Bool close, hold, quit, post, dlist, ice, reopen, blockio;
+	u32 port, block_size, maxc, maxp, timeout, hmode, sutc, cors, max_client_errors, max_async_buf;
 	s32 max_cache_segs;
 
 	//internal
@@ -86,7 +100,7 @@
 	GF_List *sessions, *active_sessions;
 	GF_List *inputs;
 
-	u32 next_wake_us;
+	s32 next_wake_us;
 	char *ip;
 	Bool done;
 	struct __httpout_input *dst_in;
@@ -95,6 +109,7 @@
 	Bool no_etag;
 
 	u32 nb_connections;
+	Bool had_connections;
 
 	GF_FilterCapability in_caps2;
 	char szExt10;
@@ -109,6 +124,10 @@
 
 	const char *mem_url;
 	GF_FileIO *mem_fileio;
+	u32 nb_sess_flush_pending;
+
+	GF_List *directories;
+	Bool has_read_dir, has_write_dir;
 } GF_HTTPOutCtx;
 
 typedef struct __httpout_input
@@ -127,6 +146,7 @@
 
 	//for PUT mode, NULL in server mode
 	GF_DownloadSession *upload;
+	GF_Socket *upload_sock;
 	Bool is_h2;
 	u32 cur_header;
 
@@ -161,6 +181,8 @@
 	u32 llhls_cur_header;
 	Bool llhls_is_open;
 	char *llhls_url;
+
+	Bool flush_close, flush_close_llhls, flush_open, flush_llhls_open;
 } GF_HTTPOutInput;
 
 typedef struct
@@ -179,7 +201,6 @@
 
 	Bool headers_done;
 
-	u32 play_state;
 	Double start_range;
 
 	FILE *resource;
@@ -187,6 +208,7 @@
 	u64 file_size, file_pos, nb_bytes, bytes_in_req;
 	u8 *buffer;
 	Bool done;
+	u32 flush_close;
 	u64 last_file_modif;
 
 	u64 req_start_time;
@@ -216,6 +238,8 @@
 	Bool canceled;
 
 	Bool force_destroy;
+
+	HTTP_DIRInfo *dir_desc;
 } GF_HTTPOutSession;
 
 /*GF FileIO for mem mode*/
@@ -380,7 +404,7 @@
 {
 	Bool last_connection = GF_TRUE;
 	if (!sess->http_sess) return;
-
+	assert(!sess->flush_close);
 	if (sess->is_h2) {
 		u32 nb_sub_sess = gf_dm_sess_subsession_count(sess->http_sess);
 		if (nb_sub_sess > 1) {
@@ -401,10 +425,43 @@
 	gf_dm_sess_del(sess->http_sess);
 	sess->http_sess = NULL;
 	sess->socket = NULL;
+	sess->done = 1;
 
 	if (sess->in_source) sess->in_source->nb_dest--;
 }
 
+static void log_request_done(GF_HTTPOutSession *sess);
+
+static Bool httpout_sess_flush_close(GF_HTTPOutSession *sess, Bool close_session)
+{
+	if (!sess->ctx->blockio) {
+		//first attempt at closing, remember close_session flag
+		if (!sess->flush_close) {
+			sess->flush_close = close_session ? 2 : 1;
+			sess->ctx->nb_sess_flush_pending++;
+		}
+		if (gf_dm_sess_flush_async(sess->http_sess, GF_TRUE) == GF_IP_NETWORK_EMPTY)
+			return GF_FALSE;
+		//done closing, restore close_session flag
+		if (sess->flush_close == 2)
+			close_session = GF_TRUE;
+		sess->flush_close = 0;
+		sess->ctx->nb_sess_flush_pending--;
+	}
+	log_request_done(sess);
+	sess->done = GF_TRUE;
+
+	if (close_session) {
+		httpout_close_session(sess);
+	}
+	//might be NULL if quit was set
+	else if (sess->http_sess) {
+		sess->headers_done = GF_FALSE;
+		gf_dm_sess_server_reset(sess->http_sess);
+	}
+	return GF_TRUE;
+}
+
 static void httpout_format_date(u64 time, char szDate200, Bool for_listing)
 {
 	time_t gtime;
@@ -449,13 +506,21 @@
 	}
 }
 
+typedef struct
+{
+	HTTP_DIRInfo *di;
+	char **listing;
+} HTTP_DirEnum;
+
 static Bool httpout_dir_file_enum(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info, Bool is_dir)
 {
 	char szFmt200;
 	u64 size;
 	u32 name_len;
 	char *unit=NULL;
-	char **listing = (char **) cbck;
+	Bool add_slash=GF_FALSE;
+	HTTP_DirEnum *denum = (HTTP_DirEnum *) cbck;
+	char **listing = (char **) denum->listing;
 
 	if (file_info && (file_info->hidden || file_info->system))
 		return GF_FALSE;
@@ -465,13 +530,17 @@
 	else
 		gf_dynstrcat(listing, " <a href=\"", NULL);
 
+	if (is_dir) {
+		u32 len = (u32) strlen(item_name);
+		if (len && (item_namelen-1!='/')) add_slash = GF_TRUE;
+	}
 	name_len = (u32) strlen(item_name);
-	if (is_dir) name_len++;
+	if (add_slash) name_len++;
 	gf_dynstrcat(listing, item_name, NULL);
-	if (is_dir) gf_dynstrcat(listing, "/", NULL);
+	if (add_slash) gf_dynstrcat(listing, "/", NULL);
 	gf_dynstrcat(listing, "\">", NULL);
 	gf_dynstrcat(listing, item_name, NULL);
-	if (is_dir) gf_dynstrcat(listing, "/", NULL);
+	if (add_slash) gf_dynstrcat(listing, "/", NULL);
 	gf_dynstrcat(listing, "</a>", NULL);
 	while (name_len<60) {
 		name_len++;
@@ -507,82 +576,85 @@
 	return httpout_dir_file_enum(cbck, item_name, item_path, file_info, GF_FALSE);
 }
 
-static char *httpout_create_listing(GF_HTTPOutCtx *ctx, char *full_path)
+static char *httpout_create_listing(GF_HTTPOutCtx *ctx, char *full_path, HTTP_DIRInfo *di)
 {
 	char szHostGF_MAX_IP_NAME_LEN;
-	char *has_par, *dir;
-	u32 i, count = ctx->rdirs.nb_items;
+	char *has_par;
+	u32 len, i, count = gf_list_count(ctx->directories);
 	char *listing = NULL;
-	char *name = full_path;
-
-	if (full_path && (full_path0=='.'))
+	char *name;
+	char *www_name = NULL;
+	HTTP_DirEnum denum;
+
+	len = di ? (u32) strlen(di->path) : 0;
+	if (di && di->name && !strncmp(full_path, di->path, len)) {
+		gf_dynstrcat(&www_name, "/", NULL);
+		gf_dynstrcat(&www_name, di->name, NULL);
+		if (full_pathlen=='/')
+			gf_dynstrcat(&www_name, full_path+len+1, NULL);
+		else
+			gf_dynstrcat(&www_name, full_path+len, NULL);
+		len = (u32) strlen(www_name);
+		if ((len>2) && (www_namelen-1=='/') && (www_namelen-2=='/'))
+			www_namelen-1 = 0;
+	} else {
+		www_name = gf_strdup(full_path);
+	}
+	name = www_name;
+	while (name && (name0=='.'))
 		name++;
 
+	denum.listing = &listing;
 	gf_dynstrcat(&listing, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n<html>\n<head>\n<title>Index of ", NULL);
 	gf_dynstrcat(&listing, name, NULL);
 	gf_dynstrcat(&listing, "</title>\n</head>\n<body><h1>Index of ", NULL);
 	gf_dynstrcat(&listing, name, NULL);
 	gf_dynstrcat(&listing, "</h1>\n<pre>Name Last modified Size\n<hr>\n", NULL);
 
-	if (!full_path) {
+	has_par=NULL;
+	if (full_path) {
+		len = (u32) strlen(www_name);
 		has_par=NULL;
-	} else {
-		u32 len = (u32) strlen(full_path);
-		if (len && strchr("/\\", full_pathlen-1))
-			full_pathlen-1 = 0;
-		has_par = strrchr(full_path, '/');
+		if (len && strchr("/\\", www_namelen-1))
+			www_namelen-1 = 0;
+
+		has_par = strrchr(www_name+1, '/');
 	}
+
 	if (has_par) {
 		u8 c = has_par1;
 		has_par1 = 0;
 
 		//retranslate server root
 		gf_dynstrcat(&listing, ".. <a href=\"", NULL);
-		for (i=0; i<count; i++) {
-			dir = ctx->rdirs.valsi;
-			u32 dlen = (u32) strlen(dir);
-			if (!strncmp(dir, name, dlen) && ((namedlen=='/') || (namedlen==0))) {
-				gf_dynstrcat(&listing, "/", NULL);
-				if (count==1) name = NULL;
-				break;
-			}
-		}
-
 		if (name)
 			gf_dynstrcat(&listing, name, NULL);
 
 		gf_dynstrcat(&listing, "\">Parent Directory</a>\n", NULL);
 		has_par1 = c;
+	} else if (di) {
+		gf_dynstrcat(&listing, ".. <a href=\"/", NULL);
+		gf_dynstrcat(&listing, "\">Parent Directory</a>\n", NULL);
 	}
+	gf_free(www_name);
 
-	if (!full_path || !strlen(full_path)) {
-		count = ctx->rdirs.nb_items;
-		if (count==1) {
-			dir = ctx->rdirs.vals0;
-			gf_enum_directory(dir, GF_TRUE, httpout_dir_enum, &listing, NULL);
-			gf_enum_directory(dir, GF_FALSE, httpout_file_enum, &listing, NULL);
-		} else {
-			for (i=0; i<count; i++) {
-				dir = ctx->rdirs.valsi;
-				httpout_dir_file_enum(&listing, dir, NULL, NULL, GF_TRUE);
+
+	if (!full_path || !strlen(full_path) || !strcmp(full_path, "/")) {
+		for (i=0; i<count; i++) {
+			HTTP_DIRInfo *a_di = gf_list_get(ctx->directories, i);
+			if (a_di->is_subpath) continue;
+			denum.di = a_di;
+			if (a_di->name) {
+				httpout_dir_file_enum(&denum, a_di->name, a_di->name, NULL, GF_TRUE);
+			} else {
+				gf_enum_directory(a_di->path, GF_TRUE, httpout_dir_enum, &denum, NULL);
+				gf_enum_directory(a_di->path, GF_FALSE, httpout_file_enum, &denum, NULL);
 			}
 		}
 	} else {
-		Bool insert_root = GF_FALSE;
-		if (count>1) {
-			for (i=0; i<count; i++) {
-				dir = ctx->rdirs.valsi;
-				if (!strcmp(full_path, dir)) {
-					insert_root=GF_TRUE;
-					break;
-				}
-			}
-			if (insert_root) {
-				gf_dynstrcat(&listing, ".. <a href=\"/\">Parent Directory</a> -\n", NULL);
-			}
-		}
-		gf_enum_directory(full_path, GF_TRUE, httpout_dir_enum, &listing, NULL);
-		gf_enum_directory(full_path, GF_FALSE, httpout_file_enum, &listing, NULL);
+		denum.di = NULL;
+		gf_enum_directory(full_path, GF_TRUE, httpout_dir_enum, &denum, NULL);
+		gf_enum_directory(full_path, GF_FALSE, httpout_file_enum, &denum, NULL);
 	}
 
 	gf_dynstrcat(&listing, "\n<hr></pre>\n<address>", NULL);
@@ -604,9 +676,9 @@
 	u32 len;
 	assert(in->path);
 	//not recording
-	if (!ctx->rdirs.nb_items) return;
-
-	dir = ctx->rdirs.vals0;
+	if (!ctx->has_read_dir) return;
+	HTTP_DIRInfo *di = gf_list_get(ctx->directories, 0);
+	dir = di->path;
 	if (!dir) return;
 	len = (u32) strlen(dir);
 	if (in->local_path) gf_free(in->local_path);
@@ -632,7 +704,7 @@
 	sess->range_idx = 0;
 	if (!range) return GF_TRUE;
 
-	if (sess->in_source && !sess->ctx->rdirs.nb_items)
+	if (sess->in_source && !sess->ctx->has_read_dir)
 		return GF_FALSE;
 
 	while (range) {
@@ -811,6 +883,7 @@
 	if (!sub_sess) return GF_OUT_OF_MEM;
 	sub_sess->socket = sess->socket;
 	sub_sess->ctx = sess->ctx;
+	sub_sess->last_active_time = gf_sys_clock_high_res();
 	//mark the subsession as being h2 right away so that we can process it even if no pending data on socket (cf httpout_process_session)
 	sub_sess->is_h2 = GF_TRUE;
 	strcpy(sub_sess->peer_address, sess->peer_address);
@@ -826,6 +899,46 @@
 }
 
 
+static u32 httpout_auth_check(HTTP_DIRInfo *di, const char *auth_header, Bool for_write)
+{
+	char *c_u=NULL, *c_g=NULL;
+	if (for_write) {
+		if (!di->wu && !di->wg) return 403;
+		if (di->wu && !strcmp(di->wu, "$NONE")) return 403;
+
+		if (di->wu && strcmp(di->wu, "$ALL")) c_u=di->wu;
+		if (di->wg && strcmp(di->wg, "$ALL")) c_g=di->wg;
+	} else {
+		if (di->ru && !strcmp(di->ru, "$NONE")) return 403;
+		c_u=di->ru;
+		c_g=di->rg;
+	}
+	if (!c_u && !c_g)
+		return 200;
+
+	//no auth info, return unauthorized
+	if (!auth_header)
+		return 401;
+
+	char *sep = strstr(auth_header, "Basic ");
+	if (!sep) return 403; //no support for other auth schemes, return forbidden
+
+	char szUsrPass200, *user=NULL, *pass=NULL;
+
+	u32 len = gf_base64_decode(sep+6, (u32) strlen(sep)-6, szUsrPass, 100);
+	szUsrPasslen=0;
+	sep = strchr(szUsrPass, ':');
+	if (!sep) return 400; //return bad request
+
+	pass = sep+1;
+	sep0 = 0;
+	user = szUsrPass;
+	GF_Err creds_ok = gf_creds_check_password(user, pass);
+	if (creds_ok==GF_OK) return 200;
+	//return forbidden
+	return 403;
+}
+
 static void httpout_sess_io(void *usr_cbk, GF_NETIO_Parameter *parameter)
 {
 	const char *durl="";
@@ -853,6 +966,7 @@
 	Bool source_pid_is_ll_hls_chunk = GF_FALSE;
 	GF_HTTPOutSession *source_sess = NULL;
 	GF_HTTPOutSession *sess = usr_cbk;
+	HTTP_DIRInfo *the_dir=NULL;
 
 	if (parameter->msg_type == GF_NETIO_REQUEST_SESSION) {
 		parameter->error = httpout_new_subsession(sess, parameter->reply);
@@ -899,20 +1013,51 @@
 	sess->bytes_in_req = 0;
 	sess->nb_ranges = 0;
 	sess->do_log = httpout_do_log(sess, parameter->reply);
+	sess->dir_desc = NULL;
 
 	//resolve name against upload dir
 	if (is_upload) {
-		if (!sess->ctx->wdir && (sess->ctx->hmode!=MODE_SOURCE)) {
+		if (!sess->ctx->has_write_dir && (sess->ctx->hmode!=MODE_SOURCE)) {
 			sess->reply_code = 405;
 			gf_dynstrcat(&response_body, "No write directory enabled on server", NULL);
 			goto exit;
 		}
-		if (sess->ctx->wdir) {
-			u32 len = (u32) strlen(sess->ctx->wdir);
-			gf_dynstrcat(&full_path, sess->ctx->wdir, NULL);
-			if (!strchr("/\\", sess->ctx->wdirlen-1))
+		if (sess->ctx->has_write_dir) {
+			HTTP_DIRInfo *di=NULL;
+			u32 di_len=0;
+			for (i=0; i<gf_list_count(sess->ctx->directories); i++) {
+				HTTP_DIRInfo *adi = gf_list_get(sess->ctx->directories, i);
+				if (!adi->wu && !adi->wg) continue;
+				if (adi->name && strncmp(adi->name, url+1, adi->name_len))
+					continue;
+				if (!adi->name || (adi->name_len>di_len)) {
+					di = adi;
+					di_len = adi->name_len;
+				}
+			}
+			if (!di) {
+				sess->reply_code = 400;
+				goto exit;
+			}
+
+			u32 len = (u32) strlen(di->path);
+			gf_dynstrcat(&full_path, di->path, NULL);
+			if (!strchr("/\\", di->pathlen-1))
 				gf_dynstrcat(&full_path, "/", NULL);
-			gf_dynstrcat(&full_path, url+1, NULL);
+
+			if (di->name) {
+				gf_dynstrcat(&full_path, url+di->name_len+1, NULL);
+			} else {
+				gf_dynstrcat(&full_path, url+1, NULL);
+			}
+			sess->dir_desc = di;
+
+			sess->reply_code = httpout_auth_check(di, gf_dm_sess_get_header(sess->http_sess, "Authorization"), GF_TRUE);
+			if (sess->reply_code != 200) {
+				gf_free(full_path);
+				full_path=NULL;
+				goto exit;
+			}
 		} else if (sess->ctx->hmode==MODE_SOURCE) {
 			full_path = gf_strdup(url+1);
 		}
@@ -1020,14 +1165,20 @@
 	if (parameter->reply == GF_HTTP_DELETE)
 		count = 0;
 
+	Bool no_longer_avail = GF_FALSE;
 	for (i=0; i<count; i++) {
 		GF_HTTPOutInput *in = gf_list_get(sess->ctx->inputs, i);
 		assert(in->path0 == '/');
 		//matching name and input pid not done: file has been created and is in progress
 		//if input pid done, try from file
-		if (!strcmp(in->path, url) && !in->done) {
-			source_pid = in;
-			break;
+		if (!strcmp(in->path, url)) {
+			//source done in server mode with no storage, no longer available unless reopen is set
+			if (in->done && !sess->ctx->has_read_dir && (!sess->ctx->reopen || gf_filter_pid_is_eos(in->ipid))) {
+				no_longer_avail = GF_TRUE;
+			} else if (!in->done) {
+				source_pid = in;
+				break;
+			}
 		}
 		if (in->hls_chunk_path && !strcmp(in->hls_chunk_path, url) && !in->done) {
 			source_pid = in;
@@ -1052,23 +1203,48 @@
 
 	/*not resolved and no source matching, check file on disk*/
 	if (!source_pid && !full_path) {
-		count = sess->ctx->rdirs.nb_items;
+		count = gf_list_count(sess->ctx->directories);
 		for (i=0; i<count; i++) {
-			char *mdir = sess->ctx->rdirs.valsi;
+			HTTP_DIRInfo *adi = gf_list_get(sess->ctx->directories, i);
+			//only check roots
+			if (adi->is_subpath) continue;
+			char *res_url = url+1;
+			if (adi->name) {
+				if (strncmp(adi->name, url+1, adi->name_len)) continue;
+				res_url += adi->name_len;
+			}
+
+			char *mdir = adi->path;
 			u32 len = (u32) strlen(mdir);
 			if (!len) continue;
-			if (count==1) {
-				gf_dynstrcat(&full_path, mdir, NULL);
-				if (!strchr("/\\", mdirlen-1))
-					gf_dynstrcat(&full_path, "/", NULL);
-			}
-			gf_dynstrcat(&full_path, url+1, NULL);
+			gf_dynstrcat(&full_path, mdir, NULL);
+			if (!strchr("/\\", mdirlen-1))
+				gf_dynstrcat(&full_path, "/", NULL);
 
-			if (gf_file_exists(full_path) || gf_dir_exists(full_path) )
+			gf_dynstrcat(&full_path, res_url, NULL);
+
+			if (gf_file_exists(full_path) || gf_dir_exists(full_path) ) {
+				the_dir = adi;
 				break;
+			}
 			gf_free(full_path);
 			full_path = NULL;
 		}
+		//browse for permissions
+		if (full_path) {
+			HTTP_DIRInfo *di = NULL;
+			u32 di_len = 0;
+			for (i=0; i<count; i++) {
+				HTTP_DIRInfo *adi = gf_list_get(sess->ctx->directories, i);
+				u32 adi_len = (u32) strlen(adi->path);
+				if (strncmp(adi->path, full_path, adi_len)) continue;
+				if (!di || (di_len < adi_len)) {
+					di_len = adi_len;
+					di = adi;
+				}
+			}
+			sess->dir_desc = di;
+		}
 	}
 
 	cors_origin = (char *) gf_dm_sess_get_header(sess->http_sess, "Origin");
@@ -1090,12 +1266,23 @@
 		goto exit;
 	}
 
+	if (sess->dir_desc) {
+		sess->reply_code = httpout_auth_check(sess->dir_desc, gf_dm_sess_get_header(sess->http_sess, "Authorization"), GF_FALSE);
+		if (sess->reply_code != 200) {
+			if (full_path) gf_free(full_path);
+			goto exit;
+		}
+	}
+
 	if (!full_path && !source_pid) {
 		if (!sess->ctx->dlist || strcmp(url, "/")) {
 			sess->reply_code = 404;
 			gf_dynstrcat(&response_body, "Resource ", NULL);
 			gf_dynstrcat(&response_body, url, NULL);
-			gf_dynstrcat(&response_body, " cannot be resolved", NULL);
+			if (no_longer_avail)
+				gf_dynstrcat(&response_body, " is no longer available", NULL);
+			else
+				gf_dynstrcat(&response_body, " cannot be resolved", NULL);
 			goto exit;
 		}
 	}
@@ -1233,9 +1420,9 @@
 			if (sess->ctx->dlist) {
 				range = NULL;
 				if (!strcmp(url, "/")) {
-					response_body = httpout_create_listing(sess->ctx, (char *) url);
+					response_body = httpout_create_listing(sess->ctx, (char *) url, NULL);
 				} else {
-					response_body = httpout_create_listing(sess->ctx, full_path);
+					response_body = httpout_create_listing(sess->ctx, full_path, the_dir ? the_dir : sess->dir_desc);
 				}
 				sess->file_size = sess->file_pos = 0;
 			} else {
@@ -1368,7 +1555,7 @@
 			if (sess->ctx->cache_control) {
 				gf_dm_sess_set_header(sess->http_sess, "Cache-Control", sess->ctx->cache_control);
 			}
-		} else if (sess->in_source && !sess->ctx->rdirs.nb_items) {
+		} else if (sess->in_source && !sess->ctx->has_read_dir) {
 			sess->nb_ranges = 0;
 			gf_dm_sess_set_header(sess->http_sess, "Cache-Control", "no-cache, no-store");
 		}
@@ -1515,12 +1702,16 @@
 
 	gf_dm_sess_clear_headers(sess->http_sess);
 
+	if (sess->done) {
+		sess->done = GF_FALSE;
+		httpout_sess_flush_close(sess, GF_FALSE);
+	}
 	sess->last_active_time = gf_sys_clock_high_res();
 	return;
 
 exit:
 
-	if (cors_origin && (sess->reply_code==200))
+	if (cors_origin && ((sess->reply_code==200) || (sess->reply_code==401)))
 		send_cors = GF_TRUE;
 
 	gf_dm_sess_clear_headers(sess->http_sess);
@@ -1540,7 +1731,7 @@
 	if (is_options) {
 		if (sess->ctx->hmode==MODE_SOURCE) {
 			gf_dm_sess_set_header(sess->http_sess, "Allow", "POST,PUT,OPTIONS");
-		} else if (sess->ctx->wdir) {
+		} else if (sess->ctx->has_write_dir) {
 			gf_dm_sess_set_header(sess->http_sess, "Allow", "GET,POST,PUT,DELETE,HEAD,OPTIONS");
 		} else {
 			gf_dm_sess_set_header(sess->http_sess, "Allow", "GET,HEAD,OPTIONS");
@@ -1556,6 +1747,10 @@
 		}
 	}
 
+	if (sess->reply_code == 401) {
+		gf_dm_sess_set_header(sess->http_sess, "WWW-Authenticate", "Basic");
+	}
+
 	if (response_body) {
 		body_size = (u32) strlen(response_body);
 		gf_dm_sess_set_header(sess->http_sess, "Content-Type", "text/plain");
@@ -1584,10 +1779,11 @@
 
 	if (url) gf_free(url);
 	sess->upload_type = 0;
-	sess->done = GF_TRUE;
 	sess->canceled = GF_FALSE;
 	sess->headers_done = GF_FALSE;
 
+	httpout_sess_flush_close(sess, GF_FALSE);
+
 	if (!sess->is_h2 && (sess->ctx->close || (sess->nb_consecutive_errors == sess->ctx->max_client_errors))) {
 		sess->force_destroy = GF_TRUE;
 	} else if (sess->http_sess) {
@@ -1721,26 +1917,38 @@
 		if (ctx->mem_fileio) {
 			pctx->mem_files = gf_list_new();
 			pctx->max_segs = (u32) ctx->max_cache_segs;
-		} else {
-			pctx->past_files = gf_list_new();
+		} else if (ctx->max_cache_segs) {
 			if (ctx->max_cache_segs<0) {
 				pctx->max_segs = (u32) (-ctx->max_cache_segs);
 				p = NULL;
 			} else if (p) {
 				pctx->max_segs = (u32) ctx->max_cache_segs;
 			}
+
+			if (pctx->max_segs)
+				pctx->past_files = gf_list_new();
 		}
+
 		if (p && p->value.uint) {
 			if (ctx->mem_fileio && (p->value.uint > (u32) ctx->max_cache_segs)) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("HTTPOut Timeshift buffer of %d segments but max segments cache set to %d, may result in client errors\n\tTry increasing segemnt buffer using --max_cache_segs\n", p->value.uint, ctx->max_cache_segs));
+				GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("HTTPOut Timeshift buffer of %d segments but max segments cache set to %d, may result in client errors\n\tTry increasing segment buffer using --max_cache_segs\n", p->value.uint, ctx->max_cache_segs));
 			} else {
 				pctx->max_segs = p->value.uint;
 			}
 		}
 
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_IS_MANIFEST);
-		if (p && p->value.boolean) pctx->is_manifest = GF_TRUE;
-
+		if (p && p->value.boolean) {
+			pctx->is_manifest = GF_TRUE;
+			if (!ctx->hmode && !ctx->has_read_dir) {
+				if (!ctx->reopen) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Using DASH/HLS in server mode with no directory set is meaningless\n"));
+					return GF_FILTER_NOT_SUPPORTED;
+				} else {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Using DASH/HLS in server mode with no directory set will result in unconsistent file states, use at your own risks\n"));
+				}
+			}
+		}
 res_path = NULL;
 		if (ctx_orig->dst) {
 res_path = ctx_orig->dst;
@@ -1758,14 +1966,18 @@
 
 			if (ctx->hmode==MODE_PUSH) {
 				GF_Err e;
+				u32 flags = GF_NETIO_SESSION_NOT_THREADED|GF_NETIO_SESSION_NOT_CACHED|GF_NETIO_SESSION_PERSISTENT;
+				if (!ctx->blockio)
+					flags |= GF_NETIO_SESSION_NO_BLOCK;
+
 				//note that ctx_orig->dst might be wrong (eg indicating MPD url rather than segment), but this is fixed in httpout_open_input by resetting up the session
 				//with the correct URL
-				pctx->upload = gf_dm_sess_new(gf_filter_get_download_manager(filter), ctx_orig->dst, GF_NETIO_SESSION_NOT_THREADED|GF_NETIO_SESSION_NOT_CACHED|GF_NETIO_SESSION_PERSISTENT, httpout_in_io, pctx, &e);
+				pctx->upload = gf_dm_sess_new(gf_filter_get_download_manager(filter), ctx_orig->dst, flags, httpout_in_io, pctx, &e);
 				if (!pctx->upload) {
 					gf_free(pctx);
 					return e;
 				}
-//				gf_sk_group_register(ctx->sg, pctx->socket);
+				gf_dm_sess_set_sock_group(pctx->upload, ctx->sg);
 			} else {
 				if (!pctx->path) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Output path not specified\n"));
@@ -1823,12 +2035,18 @@
 	char peer_addressGF_MAX_IP_NAME_LEN;
 	GF_HTTPOutSession *sess;
 	GF_Err e;
-	void *ssl_c = NULL;
-	GF_Socket *new_conn = NULL;
+	void *ssl_c;
+	GF_Socket *new_conn;
+
+check_next_conn:
+	ssl_c = NULL;
+	new_conn = NULL;
 
 	e = gf_sk_accept(ctx->server_sock, &new_conn);
-	if (e==GF_IP_SOCK_WOULD_BLOCK) return;
-	else if (e) {
+	if (e==GF_IP_NETWORK_EMPTY)
+		return;
+
+	if (e) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Accept failure %s\n", gf_error_to_string(e) ));
 		return;
 	}
@@ -1863,6 +2081,7 @@
 	//we keep track of the socket for sock group (un)register
 	sess->socket = new_conn;
 	sess->ctx = ctx;
+	sess->last_active_time = gf_sys_clock_high_res();
 
 #ifdef GPAC_HAS_SSL
 	if (ctx->ssl_ctx) {
@@ -1876,7 +2095,7 @@
 	}
 #endif
 
-	sess->http_sess = gf_dm_sess_new_server(new_conn, ssl_c, httpout_sess_io, sess, &e);
+	sess->http_sess = gf_dm_sess_new_server(gf_filter_get_download_manager(ctx->filter), new_conn, ssl_c, httpout_sess_io, sess, !ctx->blockio, &e);
 	if (!sess->http_sess) {
 		gf_sk_del(new_conn);
 		GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTPOut Failed to create HTTP server session from %s: %s\n", sess->peer_address, gf_error_to_string(e) ));
@@ -1884,6 +2103,8 @@
 		return;
 	}
 	ctx->nb_connections++;
+	if (ctx->quit)
+		ctx->had_connections = GF_TRUE;
 
 	gf_list_add(ctx->sessions, sess);
 	gf_list_add(ctx->active_sessions, sess);
@@ -1896,6 +2117,8 @@
 	GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTPOut Accepting new connection from %s\n", sess->peer_address));
 	//ask immediate reschedule
 	ctx->next_wake_us = 1;
+
+	goto check_next_conn;
 }
 
 static GF_Err httpout_initialize(GF_Filter *filter)
@@ -1971,27 +2194,114 @@
 		}
 	}
 	/*this is an alias for our main filter, nothing to initialize*/
-	if (gf_filter_is_alias(filter)) {
+	if (gf_filter_is_alias(filter) || gf_filter_is_temporary(filter) ) {
 		return GF_OK;
 	}
 
-	if (ctx->wdir)
-		ctx->hmode = MODE_DEFAULT;
-
-	if (!url && !ctx->rdirs.nb_items && !ctx->wdir && (ctx->hmode!=MODE_SOURCE)) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut No root dir(s) for server, no URL set and not configured as source, cannot run!\n" ));
-		return GF_BAD_PARAM;
-	}
-
+	//configure directories
 	if (ctx->rdirs.nb_items || ctx->wdir) {
 		gf_filter_make_sticky(filter);
 
-		if (ctx->rdirs.nb_items && !strcmp(ctx->rdirs.vals0, "gmem")) {
+		u32 i;
+		Bool has_gmem = GF_FALSE;
+		ctx->has_read_dir = GF_FALSE;
+		ctx->has_write_dir = GF_FALSE;
+		ctx->directories = gf_list_new();
+		for (i=0; i<ctx->rdirs.nb_items; i++) {
+			char *dpath = ctx->rdirs.valsi;
+			if (gf_file_exists(dpath)) {
+				GF_Config *rules = gf_cfg_new(NULL, dpath);
+				u32 j, count = gf_cfg_get_section_count(rules);
+				for (j=0; j<count; j++) {
+					const char *dname = gf_cfg_get_section_name(rules, j);
+					if (!strcmp(dpath, "gmem")) {
+						if (has_gmem) {
+							GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("HTTPOut Only a single gmem directory can be specified, ignoring rule\n"));
+							continue;
+						}
+						has_gmem = GF_TRUE;
+					} else if (!gf_dir_exists(dname)) {
+						GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("HTTPOut No such directory %s, ignoring rule\n", dname));
+						continue;
+					}
+					const char *fnames = gf_cfg_get_key(rules, dname, "filters");
+					if (fnames && strcmp(fnames, "*") && strcmp(fnames, "all")) {
+						if (!strstr(fnames, "httpout")) continue;
+					}
+					HTTP_DIRInfo *di;
+					GF_SAFEALLOC(di, HTTP_DIRInfo);
+					di->path = gf_strdup(dname);
+					gf_list_add(ctx->directories, di);
+					di->name = (char*)gf_cfg_get_key(rules, dname, "name");
+					if (di->name) {
+						di->name = gf_strdup(di->name);
+						di->name_len = (u32) strlen(di->name);
+						if (di->namedi->name_len-1 != '/') {
+							gf_dynstrcat(&di->name, "/", NULL);
+							di->name_len += 1;
+						}
+					}
+					di->ru = (char*)gf_cfg_get_key(rules, dname, "ru");
+					if (di->ru) di->ru = gf_strdup(di->ru);
+					di->rg = (char*)gf_cfg_get_key(rules, dname, "rg");
+					if (di->rg) di->rg = gf_strdup(di->rg);
+					di->wu = (char*)gf_cfg_get_key(rules, dname, "wu");
+					if (di->wu) di->wu = gf_strdup(di->wu);
+					di->wg = (char*)gf_cfg_get_key(rules, dname, "wg");
+					if (di->wg) di->wg = gf_strdup(di->wg);
+
+					if (di->wu || di->wg) ctx->has_write_dir = GF_TRUE;
+					ctx->has_read_dir = GF_TRUE;
+				}
+				gf_cfg_del(rules);
+			} else if (gf_dir_exists(dpath) || !strcmp(dpath, "gmem")) {
+				HTTP_DIRInfo *di;
+				if (!strcmp(dpath, "gmem")) {
+					if (has_gmem) continue;
+					has_gmem = GF_TRUE;
+				}
+				GF_SAFEALLOC(di, HTTP_DIRInfo);
+				di->path = gf_strdup(dpath);
+				gf_list_add(ctx->directories, di);
+				ctx->has_read_dir = GF_TRUE;
+			} else {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("HTTPOut No such directory %s, ignoring rule\n", dpath));
+			}
+		}
+		if (ctx->wdir) {
+			HTTP_DIRInfo *di;
+			GF_SAFEALLOC(di, HTTP_DIRInfo);
+			di->path = gf_strdup(ctx->wdir);
+			di->wu = gf_strdup("$ALL");
+			gf_list_add(ctx->directories, di);
+			ctx->has_write_dir = GF_TRUE;
+		}
+
+		u32 count = gf_list_count(ctx->directories);
+		for (i=0; i<count; i++) {
+			HTTP_DIRInfo *di = gf_list_get(ctx->directories, i);
+			u32 j, len = (u32) strlen(di->path);
+			for (j=0; j<count; j++) {
+				if (i==j) continue;
+				HTTP_DIRInfo *adi = gf_list_get(ctx->directories, j);
+				if (adi->is_subpath) continue;
+				u32 alen = (u32) strlen(adi->path);
+				if (alen>len) {
+					if (!strncmp(di->path, adi->path, len)) adi->is_subpath = GF_TRUE;
+				} else if (alen<len) {
+					if (!strncmp(adi->path, di->path, alen)) di->is_subpath = GF_TRUE;
+				}
+			}
+		}
+
+		if (has_gmem) {
 			ctx->mem_fileio = gf_fileio_new("gmem", NULL, httpio_open, httpio_seek, httpio_read, httpio_write, httpio_tell, httpio_eof, NULL);
 			ctx->mem_url = gf_fileio_url(ctx->mem_fileio);
 			if (ctx->max_cache_segs==0) ctx->max_cache_segs = 1;
 			else if (ctx->max_cache_segs<0) ctx->max_cache_segs = -ctx->max_cache_segs;
 
+			ctx->has_read_dir = GF_TRUE;
+
 #ifdef GPAC_ENABLE_COVERAGE
 			if (gf_sys_is_cov_mode()) {
 				httpio_eof(ctx->mem_fileio);
@@ -2003,6 +2313,14 @@
 		ctx->single_mode = GF_TRUE;
 	}
 
+	if (ctx->has_write_dir)
+		ctx->hmode = MODE_DEFAULT;
+
+	if (!url && !ctx->has_read_dir && !ctx->has_write_dir && (ctx->hmode!=MODE_SOURCE)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut No root dir(s) for server, no URL set and not configured as source, cannot run!\n" ));
+		return GF_BAD_PARAM;
+	}
+
 	ctx->sessions = gf_list_new();
 	ctx->active_sessions = gf_list_new();
 	ctx->inputs = gf_list_new();
@@ -2059,6 +2377,11 @@
 	if (!ctx->port)
 		ctx->port = 80;
 
+	gf_filter_set_blocking(filter, GF_TRUE);
+	//load DM if we are pushing (for rate limit)
+	if (ctx->hmode==MODE_SOURCE)
+		gf_filter_get_download_manager(ctx->filter);
+
 	ctx->server_sock = gf_sk_new(GF_SOCK_TYPE_TCP);
 	e = gf_sk_bind(ctx->server_sock, NULL, ctx->port, ip, 0, GF_SOCK_REUSE_PORT);
 	if (!e) e = gf_sk_listen(ctx->server_sock, ctx->maxc);
@@ -2117,6 +2440,8 @@
 {
 	if (!in->hls_chunk) return;
 
+	GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTPOut Closing LL-HLS %s output\n", in->hls_chunk_path));
+
 	gf_fclose(in->hls_chunk);
 	in->hls_chunk = NULL;
 
@@ -2181,7 +2506,11 @@
 		if (in->resource) gf_fclose(in->resource);
 		if (in->llhls_upload) gf_dm_sess_del(in->llhls_upload);
 		if (in->llhls_url) gf_free(in->llhls_url);
-		if (in->upload) gf_dm_sess_del(in->upload);
+		if (in->upload) {
+			if (in->upload_sock)
+				gf_sk_group_unregister(ctx->sg, in->upload_sock);
+			gf_dm_sess_del(in->upload);
+		}
 		if (in->file_deletes) {
 			while (gf_list_count(in->file_deletes)) {
 				char *url = gf_list_pop_back(in->file_deletes);
@@ -2216,6 +2545,19 @@
 		gf_ssl_server_context_del(ctx->ssl_ctx);
 	}
 #endif
+
+
+	while (gf_list_count(ctx->directories)) {
+		HTTP_DIRInfo *di = gf_list_pop_back(ctx->directories);
+		gf_free(di->path);
+		if (di->name) gf_free(di->name);
+		if (di->ru) gf_free(di->ru);
+		if (di->rg) gf_free(di->rg);
+		if (di->wu) gf_free(di->wu);
+		if (di->wg) gf_free(di->wg);
+		gf_free(di);
+	}
+	gf_list_del(ctx->directories);
 }
 
 static GF_Err httpout_sess_data_upload(GF_HTTPOutSession *sess, const u8 *data, u32 size)
@@ -2267,6 +2609,9 @@
 			break;
 		}
 		write = (u32) gf_fwrite(data, to_write, sess->resource);
+		if (write!=to_write)
+			return GF_IO_ERR;
+
 		sess->nb_bytes += write;
 		remain -= to_write;
 		sess->range_idx++;
@@ -2354,8 +2699,8 @@
 
 			if (!write_e) {
 				sess->last_active_time = gf_sys_clock_high_res();
-				//don't reschedule in upload, let server decide
-				ctx->next_wake_us = 0;
+				//reschedule asap
+				ctx->next_wake_us = 1;
 				//we way be in end of stream
 				if (e==GF_OK)
 					return;
@@ -2364,7 +2709,7 @@
 			}
 		} else if (e==GF_IP_NETWORK_EMPTY) {
 			//don't reschedule in upload, let server decide
-			ctx->next_wake_us = 0;
+			ctx->next_wake_us = 100;
 			sess->last_active_time = gf_sys_clock_high_res();
 			httpout_check_connection(sess);
 			return;
@@ -2431,19 +2776,28 @@
 					gf_dm_sess_set_header(sess->http_sess, "Content-Location", loc);
 					gf_free(loc);
 				} else {
+					char *dpath=NULL;
 					char *spath = strchr(sess->path, '/');
 					if (spath) spath = spath+1;
 					else spath = sess->path;
 
-					if (ctx->wdir) {
-						u32 plen = (u32) strlen(ctx->wdir);
-						if ((ctx->wdirplen-1 == '/') || (ctx->wdirplen-1 == '\\'))
+					if (sess->dir_desc) {
+						char *path = sess->dir_desc->path;
+						u32 plen = (u32) strlen(path);
+						if ((pathplen-1 == '/') || (pathplen-1 == '\\'))
 							plen--;
-						if (!strncmp(ctx->wdir, sess->path, plen))
+						if (!strncmp(path, sess->path, plen)) {
 							spath = sess->path + plen;
+							if (sess->dir_desc->name) {
+								gf_dynstrcat(&dpath, "/", NULL);
+								gf_dynstrcat(&dpath, sess->dir_desc->name, NULL);
+								gf_dynstrcat(&dpath, spath, NULL);
+								spath = dpath;
+							}
+						}
 					}
-
 					gf_dm_sess_set_header(sess->http_sess, "Content-Location", spath);
+					if (dpath) gf_free(dpath);
 				}
 			}
 
@@ -2455,7 +2809,6 @@
 		}
 
 		sess->last_active_time = gf_sys_clock_high_res();
-		sess->done = GF_TRUE;
 		sess->canceled = GF_FALSE;
 		sess->upload_type = 0;
 		sess->nb_consecutive_errors = 0;
@@ -2473,11 +2826,7 @@
 			}
 		}
 
-		if (close_session) {
-			httpout_close_session(sess);
-		} else {
-			gf_dm_sess_server_reset(sess->http_sess);
-		}
+		httpout_sess_flush_close(sess, close_session);
 		return;
 	}
 
@@ -2487,6 +2836,7 @@
 		//check we have something to read if not http2
 		//if http2, data might have been received on this session while processing another session
 		if (!sess->is_h2 && !gf_sk_group_sock_is_set(ctx->sg, sess->socket, GF_SK_SELECT_READ)) {
+			ctx->next_wake_us = 2000;
 			return;
 		}
 		e = gf_dm_sess_process(sess->http_sess);
@@ -2523,7 +2873,9 @@
 	if (!sess->http_sess) return;
 
 	//H2 session, keep on processing inputs
-	if (sess->is_h2 && gf_sk_group_sock_is_set(ctx->sg, sess->socket, GF_SK_SELECT_READ)) {
+	if (sess->is_h2
+//		&& gf_sk_group_sock_is_set(ctx->sg, sess->socket, GF_SK_SELECT_READ)
+	) {
 		gf_dm_sess_process(sess->http_sess);
 	}
 
@@ -2537,6 +2889,12 @@
 	}
 
 	if (!gf_sk_group_sock_is_set(ctx->sg, sess->socket, GF_SK_SELECT_WRITE)) {
+		ctx->next_wake_us=1;
+		return;
+	}
+	//flush session if async, with no select
+	if (gf_dm_sess_flush_async(sess->http_sess, GF_TRUE)==GF_IP_NETWORK_EMPTY) {
+		ctx->next_wake_us=1;
 		return;
 	}
 	//resource is not set
@@ -2613,7 +2971,7 @@
 		sess->nb_bytes += read;
 
 		if (e) {
-			if (e==GF_IP_CONNECTION_CLOSED) {
+			if ((e==GF_IP_CONNECTION_CLOSED) || (e==GF_URL_REMOVED)) {
 				GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("HTTPOut Connection to %s for %s closed\n", sess->peer_address, sess->path));
 				sess->done = GF_TRUE;
 				sess->canceled = GF_FALSE;
@@ -2625,7 +2983,7 @@
 		} else {
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("HTTPOut sending data to %s for %s: "LLU"/"LLU" bytes\n", sess->peer_address, sess->path, sess->nb_bytes, sess->bytes_in_req));
 
-			if (gf_sk_select(sess->socket, GF_SK_SELECT_WRITE)==GF_OK) {
+			if (gf_dm_sess_flush_async(sess->http_sess, GF_FALSE)==GF_OK) {
 				goto resend;
 			}
 		}
@@ -2666,9 +3024,10 @@
 		log_request_done(sess);
 
 		//keep resource active
-		sess->done = GF_TRUE;
 		sess->canceled = GF_FALSE;
 
+		httpout_sess_flush_close(sess, close_session);
+		return;
 	}
 	if (close_session) {
 		httpout_close_session(sess);
@@ -2680,6 +3039,33 @@
 	}
 }
 
+static Bool httpout_close_upload(GF_HTTPOutCtx *ctx, GF_HTTPOutInput *in, Bool for_llhls)
+{
+	Bool res = GF_TRUE;
+	GF_Err e = gf_dm_sess_process(for_llhls ? in->llhls_upload : in->upload);
+	if (e) {
+		if (!ctx->blockio && (e==GF_IP_NETWORK_EMPTY)) {
+			res = GF_FALSE;
+		} else {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Error closing output %s: %s\n", in->local_path ? in->local_path : in->path, gf_error_to_string(e) ));
+		}
+	}
+	if (for_llhls) in->flush_close_llhls = !res;
+	else in->flush_close = !res;
+	if (res) {
+		if (for_llhls) in->flush_llhls_open = GF_FALSE;
+		else in->flush_open = GF_FALSE;
+	}
+
+	if (!for_llhls && in->is_delete && res) {
+		in->done = GF_TRUE;
+		in->is_open = GF_FALSE;
+		in->is_delete = GF_FALSE;
+	}
+	return res;
+}
+
+
 static Bool httpout_open_input(GF_HTTPOutCtx *ctx, GF_HTTPOutInput *in, const char *name, Bool is_delete, Bool is_static)
 {
 //	Bool reassign_clients = GF_TRUE;
@@ -2690,7 +3076,7 @@
 
 if (in->is_open && !is_delete) return GF_FALSE;
 if (!in->upload) {
- //singe session mode, not recording, nothing to do
+ //single session mode, not recording, nothing to do
 if (ctx->single_mode) {
 			in->done = GF_FALSE;
 			in->is_open = GF_TRUE;
@@ -2698,11 +3084,12 @@
 		}
 //server mode not recording, nothing to do
 		if (!ctx->rdirs.nb_items) return GF_FALSE;
-		dir = ctx->rdirs.vals0;
-		if (!dir) return GF_FALSE;
-		len = (u32) strlen(dir);
+ //otherwise pickup first dir - this should be refined
+ HTTP_DIRInfo *di = gf_list_get(ctx->directories, 0);
+		if (!di || !di->path) return GF_FALSE;
+		len = (u32) strlen(di->path);
 		if (!len) return GF_FALSE;
-
+		dir = di->path;
 if (in->resource) return GF_FALSE;
 }
 
@@ -2739,19 +3126,25 @@
 		} else {
 			sep = name;
 		}
-		if (sep && (sep0 != '/')) {
-			char *new_url = NULL;
-			gf_dynstrcat(&new_url, "/", NULL);
-			gf_dynstrcat(&new_url, sep, NULL);
-			if (o_url) gf_free(o_url);
-			sep = o_url = new_url;
-		}
+ }
+ //default to name
+ if (!sep && ctx->dst && in->path) {
+		sep = name;
 }
 if (!sep) {
 GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut %s output file %s but cannot guess path !\n", is_delete ? "Deleting" : "Opening", name));
 		return GF_FALSE;
 	}
 
+	if (sep0 != '/') {
+		char *new_url = NULL;
+		gf_dynstrcat(&new_url, "/", NULL);
+		gf_dynstrcat(&new_url, sep, NULL);
+		if (o_url) gf_free(o_url);
+		sep = o_url = new_url;
+	}
+
+
 	GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTPOut %s output file %s\n", is_delete ? "Deleting" : "Opening", sep+1));
 	if (in->upload) {
 		GF_Err e;
@@ -2765,12 +3158,20 @@
 			if (old) gf_free(old);
 		}
 		if (o_url) gf_free(o_url);
-		
+
+		if (in->upload_sock) {
+			gf_sk_group_unregister(ctx->sg, in->upload_sock);
+			in->upload_sock = NULL;
+		}
 		e = gf_dm_sess_setup_from_url(in->upload, in->path, GF_TRUE);
 		if (!e) {
 			in->cur_header = 0;
 			e = gf_dm_sess_process(in->upload);
 		}
+		if (!ctx->blockio && (e==GF_IP_NETWORK_EMPTY)) {
+			in->flush_open = GF_TRUE;
+			e = GF_OK;
+		}
 
 		if (e) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Failed to open output file %s: %s\n", in->path, gf_error_to_string(e) ));
@@ -2778,13 +3179,8 @@
 			return GF_FALSE;
 		}
 		in->is_h2 = gf_dm_sess_is_h2(in->upload);
-
 		if (is_delete) {
-			//get response
-			gf_dm_sess_process(in->upload);
-			in->done = GF_TRUE;
-			in->is_open = GF_FALSE;
-			in->is_delete = GF_FALSE;
+			httpout_close_upload(ctx, in, GF_FALSE);
 		}
 		return GF_TRUE;
 	}
@@ -2871,18 +3267,30 @@
 		if (!in->file_deletes)
 			in->file_deletes = gf_list_new();
 
-		//move pas files beyond our timeshift to list of files to delete
+		//move past files beyond our timeshift to list of files to delete
 		//we don't call delete directly since the file could still be used by a session
 		while (gf_list_count(in->past_files)>in->max_segs) {
 			char *url = gf_list_pop_front(in->past_files);
 			gf_list_add(in->file_deletes, url);
 		}
 		if (!is_static)
-			gf_list_add(in->past_files, gf_strdup(in->path));
+			gf_list_add(in->past_files, gf_strdup(name));
 	}
 	return GF_TRUE;
 }
 
+static void httpout_input_in_error(GF_HTTPOutInput *in)
+{
+	if (!in->in_error) {
+		GF_FilterEvent evt;
+		in->in_error = GF_TRUE;
+		gf_filter_pid_set_discard(in->ipid, GF_TRUE);
+		GF_FEVT_INIT(evt, GF_FEVT_STOP, in->ipid);
+		gf_filter_pid_send_event(in->ipid, &evt);
+	}
+}
+
+
 static void httpout_close_input(GF_HTTPOutCtx *ctx, GF_HTTPOutInput *in)
 {
 	if (!in->is_open) return;
@@ -2897,16 +3305,16 @@
 			e = gf_dm_sess_send(in->upload, "0\r\n\r\n", 5);
 			if (e) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Error sending last chunk to %s: %s\n", in->local_path ? in->local_path : in->path, gf_error_to_string(e) ));
+				if (e==GF_IP_CONNECTION_CLOSED) {
+					httpout_input_in_error(in);
+					return;
+				}
 			}
 		}
 		//signal we're done sending the body
 		gf_dm_sess_send(in->upload, NULL, 0);
 
-		//fetch reply (blocking)
-		e = gf_dm_sess_process(in->upload);
-		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Error closing output %s: %s\n", in->local_path ? in->local_path : in->path, gf_error_to_string(e) ));
-		}
+		httpout_close_upload(ctx, in, GF_FALSE);
 
 	} else {
 		u32 i, count;
@@ -2946,15 +3354,19 @@
 			count = gf_list_count(ctx->active_sessions);
 			for (i=0; i<count; i++) {
 				GF_HTTPOutSession *sess = gf_list_get(ctx->active_sessions, i);
+				if (!sess->http_sess || sess->done) continue;
 				if (sess->in_source != in) continue;
-				assert(sess->nb_bytes);
-				if (!sess->is_h2)
-					gf_dm_sess_send(sess->http_sess, "0\r\n\r\n", 5);
+				//if we sent bytes, flush - otherwise session has just started
+				if (sess->nb_bytes) {
+					if (!sess->is_h2)
+						gf_dm_sess_send(sess->http_sess, "0\r\n\r\n", 5);
 
-				//signal we're done sending the body
-				gf_dm_sess_send(sess->http_sess, NULL, 0);
+					//signal we're done sending the body
+					gf_dm_sess_send(sess->http_sess, NULL, 0);
 
-				log_request_done(sess);
+					//flush session
+					httpout_sess_flush_close(sess, GF_FALSE);
+				}
 			}
 		}
 	}
@@ -2966,22 +3378,21 @@
 {
 	GF_Err e;
 	if (!in->llhls_is_open) return;
+
+	GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTPOut Closing LL-HLS %s upload\n", in->llhls_url));
+
 	in->llhls_is_open = GF_FALSE;
 	//close prev session
 	if (!in->is_h2) {
 		e = gf_dm_sess_send(in->llhls_upload, "0\r\n\r\n", 5);
 		if (e) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Error sending last chunk of LLHLS part from %s: %s\n", in->local_path ? in->local_path : in->path, gf_error_to_string(e) ));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Error sending last chunk of LLHLS part %s: %s\n", in->llhls_url, gf_error_to_string(e) ));
 		}
 	}
 	//signal we're done sending the body
 	gf_dm_sess_send(in->llhls_upload, NULL, 0);
 
-	//fetch reply (blocking)
-	e = gf_dm_sess_process(in->llhls_upload);
-	if (e) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Error closing output %s: %s\n", in->local_path ? in->local_path : in->path, gf_error_to_string(e) ));
-	}
+	httpout_close_upload(ctx, in, GF_TRUE);
 }
 
 //for upload of LLHLS in seperate file mode only
@@ -2992,6 +3403,10 @@
 		in->llhls_cur_header = 0;
 		e = gf_dm_sess_process(in->llhls_upload);
 	}
+	if (!ctx->blockio && (e==GF_IP_NETWORK_EMPTY)) {
+		in->flush_llhls_open = GF_TRUE;
+		e = GF_OK;
+	}
 	if (e) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Failed to open output file %s: %s\n", in->path, gf_error_to_string(e) ));
 		in->llhls_is_open = GF_FALSE;
@@ -3003,10 +3418,10 @@
 		if (in->llhls_url) gf_free(in->llhls_url);
 		in->llhls_url = gf_strdup(dst);
 	}
+
 	return GF_TRUE;
 }
 
-
 u32 httpout_write_input(GF_HTTPOutCtx *ctx, GF_HTTPOutInput *in, const u8 *pck_data, u32 pck_size, Bool file_start)
 {
 	u32 out=0;
@@ -3035,24 +3450,57 @@
 retry:
 			if (!in->is_h2) {
 				e = gf_dm_sess_send(up_sess, szChunkHdr, chunk_hdr_len);
-				if (!e) e = gf_dm_sess_send(up_sess, (u8 *) pck_data, pck_size);
-				if (!e) e = gf_dm_sess_send(up_sess, "\r\n", 2);
+				e |= gf_dm_sess_send(up_sess, (u8 *) pck_data, pck_size);
+				e |= gf_dm_sess_send(up_sess, "\r\n", 2);
 			} else {
 				e = gf_dm_sess_send(up_sess, (u8 *) pck_data, pck_size);
 			}
-			if (e==GF_IP_CONNECTION_CLOSED) {
+			if ((e==GF_IP_CONNECTION_CLOSED) || (e==GF_URL_REMOVED)) {
 				if (file_start && (nb_retry<10) ) {
 					in->is_open = GF_FALSE;
 					nb_retry++;
+					//reopen
 					if (s_idx) {
-						if (httpout_open_input_llhls(ctx, in, in->llhls_url))
-							goto retry;
+						if (httpout_open_input_llhls(ctx, in, in->llhls_url)) {
+							//force sync
+							while (in->flush_llhls_open) {
+								e = gf_dm_sess_process(in->llhls_upload);
+								if (e==GF_IP_NETWORK_EMPTY) {
+									gf_sleep(1);
+									continue;
+								}
+								if (!e) in->flush_llhls_open = GF_FALSE;
+								break;
+							}
+							if (!in->flush_llhls_open)
+								goto retry;
+						}
 					} else {
-						if (httpout_open_input(ctx, in, in->path, GF_FALSE, GF_FALSE))
-							goto retry;
+						if (httpout_open_input(ctx, in, in->path, GF_FALSE, GF_FALSE)) {
+							//force sync
+							while (in->flush_open) {
+								e = gf_dm_sess_process(in->upload);
+								if (e==GF_IP_NETWORK_EMPTY) {
+									gf_sleep(1);
+									continue;
+								}
+								if (!e) in->flush_open = GF_FALSE;
+								break;
+							}
+							if (!in->flush_open)
+								goto retry;
+						}
 					}
 				}
+				if (s_idx) in->flush_llhls_open = GF_FALSE;
+				else in->flush_open = GF_FALSE;
+
+				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Connection lost, aborting source %s\n", in->local_path ? in->local_path : in->path));
+				httpout_input_in_error(in);
+				httpout_close_input(ctx, in);
+				return 0;
 			}
+
 			if (e) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Error writing to output file %s: %s\n", in->local_path ? in->local_path : in->path, gf_error_to_string(e) ));
 				out = 0;
@@ -3072,14 +3520,18 @@
 				u32 wb = (u32) gf_fwrite(pck_data, pck_size, in->hls_chunk);
 				if (wb != pck_size) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Write error for HLS chunk, wrote %d bytes but had %d to write\n", wb, pck_size));
+					out = 0; //to trigger IO err in process
 				}
 				gf_fflush(in->hls_chunk);
 			}
+		} else {
+			out = pck_size;
 		}
 
 		for (i=0; i<count; i++) {
 			GF_HTTPOutSession *sess = gf_list_get(ctx->active_sessions, i);
 			if (sess->in_source != in) continue;
+			if (sess->done) continue;
 
 			if (sess->send_init_data && in->tunein_data_size && !sess->file_in_progress) {
 				if (!sess->is_h2) {
@@ -3095,7 +3547,6 @@
 				sess->nb_bytes += in->tunein_data_size;
 			}
 			sess->send_init_data = GF_FALSE;
-			out = pck_size;
 
 			/*source is read from disk but a different file handle is used, force refresh by using fseek (so use fsize and seek back to current pos)*/
 			if (sess->file_in_progress) {
@@ -3104,48 +3555,83 @@
 			}
 			/*source is not read from disk, write data*/
 			else {
+				GF_Err e;
 				if (!sess->is_h2) {
 					if (!chunk_hdr_len) {
 						sprintf(szChunkHdr, "%X\r\n", pck_size);
 						chunk_hdr_len = (u32) strlen(szChunkHdr);
 					}
-					gf_dm_sess_send(sess->http_sess, szChunkHdr, chunk_hdr_len);
-					gf_dm_sess_send(sess->http_sess, (u8*) pck_data, pck_size);
-					gf_dm_sess_send(sess->http_sess, "\r\n", 2);
+					e = gf_dm_sess_send(sess->http_sess, szChunkHdr, chunk_hdr_len);
+					e |= gf_dm_sess_send(sess->http_sess, (u8*) pck_data, pck_size);
+					e |= gf_dm_sess_send(sess->http_sess, "\r\n", 2);
 				} else {
-					gf_dm_sess_send(sess->http_sess, (u8*) pck_data, pck_size);
+					e = gf_dm_sess_send(sess->http_sess, (u8*) pck_data, pck_size);
+				}
+				if ((e==GF_IP_CONNECTION_CLOSED) || (e==GF_URL_REMOVED)) {
+					httpout_close_session(sess);
 				}
-				sess->nb_bytes += pck_size;
+				if (!e)
+					sess->nb_bytes += pck_size;
 			}
 		}
 	}
 	//don't reschedule, we will be notified when new packets are ready
-	ctx->next_wake_us = 0;
+	ctx->next_wake_us = -1;
 	return out;
 }
 
 static Bool httpout_input_write_ready(GF_HTTPOutCtx *ctx, GF_HTTPOutInput *in)
 {
 	u32 i, count;
-	if (ctx->rdirs.nb_items)
+	if (ctx->has_read_dir)
 		return GF_TRUE;
 
 	if (in->upload) {
-/*		if (!gf_sk_group_sock_is_set(ctx->sg, in->socket, GF_SK_SELECT_WRITE))
+		if (!in->upload_sock) {
+			in->upload_sock = gf_dm_sess_get_socket(in->upload);
+			if (!in->upload_sock) return GF_FALSE;
+			gf_sk_group_register(ctx->sg, in->upload_sock);
+			gf_sk_group_select(ctx->sg, 10, GF_SK_SELECT_BOTH);
+			gf_sk_set_buffer_size(in->upload_sock, GF_FALSE, ctx->block_size);
+			gf_sk_set_buffer_size(in->upload_sock, GF_TRUE, ctx->block_size);
+
+		}
+		if (!gf_sk_group_sock_is_set(ctx->sg, in->upload_sock, GF_SK_SELECT_WRITE))
+			return GF_FALSE;
+		//flush session if async, with no select
+		if (gf_dm_sess_flush_async(in->upload, GF_TRUE) == GF_IP_NETWORK_EMPTY)
 			return GF_FALSE;
-*/
 		return GF_TRUE;
 	}
 
 	count = gf_list_count(ctx->active_sessions);
+	if (!count) return GF_FALSE;
+
+	u32 nb_ready=0;
 	for (i=0; i<count; i++) {
 		GF_HTTPOutSession *sess = gf_list_get(ctx->active_sessions, i);
 		if (sess->in_source != in) continue;
+		if (sess->done) continue;
+		//file-based upload
+		if (sess->file_in_progress) continue;
+		//direct stream write, check if ready
 
-		if (!sess->file_in_progress && !gf_sk_group_sock_is_set(ctx->sg, sess->socket, GF_SK_SELECT_WRITE))
-			return GF_FALSE;
+		if (!gf_sk_group_sock_is_set(ctx->sg, sess->socket, GF_SK_SELECT_WRITE))
+			continue;
+		nb_ready++;
+		//data still pending, flush. If flush not full, check how many btes are still pending
+		if (gf_dm_sess_flush_async(sess->http_sess, GF_TRUE)==GF_IP_NETWORK_EMPTY) {
+			//decide what to do if one source is not reading fast enough
+			u32 bytes_pending = gf_dm_sess_async_pending(sess->http_sess);
+			if (bytes_pending > ctx->max_async_buf) {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("HTTPOut Peer %s not reading fast enough on shared output connection (%d bytes in async buffer), disconnecting it\n", sess->peer_address, bytes_pending ));
+				httpout_del_session(sess);
+				count--;
+				i--;
+			}
+		}
 	}
-	return count ? GF_TRUE : GF_FALSE;
+	return nb_ready ? GF_TRUE : GF_FALSE;
 }
 
 static void httpin_send_seg_info(GF_HTTPOutInput *in)
@@ -3172,36 +3658,67 @@
 static void httpout_prune_files(GF_HTTPOutCtx *ctx, GF_HTTPOutInput *in)
 {
 	//not sending/writing anything, delete files
-	if (!in->is_open && in->file_deletes) {
+	if (!in->is_open && in->file_deletes && !in->flush_close) {
 		while (gf_list_count(in->file_deletes)) {
 			char *url = gf_list_pop_front(in->file_deletes);
 			httpout_open_input(ctx, in, url, GF_TRUE, GF_FALSE);
+			//URL may be queued for later delete, remove it
+			if (in->past_files) {
+				u32 i, count = gf_list_count(in->past_files);
+				for (i=0; i<count; i++) {
+					char *past_url = gf_list_get(in->past_files, i);
+					if (!strcmp(past_url, url)) {
+						gf_list_rem(in->past_files, i);
+						gf_free(past_url);
+						break;
+					}
+				}
+			}
 			gf_free(url);
+			if (in->flush_open)
+				return;
 		}
 		gf_list_del(in->file_deletes);
 		in->file_deletes = NULL;
 	}
 }
+
 static void httpout_process_inputs(GF_HTTPOutCtx *ctx)
 {
+	Bool keep_alive=GF_FALSE;
 	u32 i, nb_eos=0, nb_nopck=0, count = gf_list_count(ctx->inputs);
 	for (i=0; i<count; i++) {
-		Bool start, end;
+		Bool start, end, skip_start;
 		const GF_PropertyValue *p;
 		const u8 *pck_data;
 		u32 pck_size, nb_write;
 		GF_FilterPacket *pck;
 		GF_HTTPOutInput *in = gf_list_get(ctx->inputs, i);
-		if (in->in_error) continue;
 
+		//prune files (does nothing if waiting for reply
 		httpout_prune_files(ctx, in);
 
+next_pck:
+		skip_start = GF_FALSE;
+		//if waiting for reply (llhls or regular), flush if possible, otherwise postpone
+		if (in->flush_close_llhls && !httpout_close_upload(ctx, in, GF_TRUE)) {
+			keep_alive=GF_TRUE;
+			continue;
+		}
+		if (in->flush_close && !httpout_close_upload(ctx, in, GF_FALSE)) {
+			keep_alive=GF_TRUE;
+			continue;
+		}
+
 		//no destination and holding for first connect, don't drop
-		if (!ctx->hmode && !ctx->rdirs.nb_items && !in->nb_dest && in->hold) {
+		if (!ctx->hmode && !ctx->has_read_dir && !in->nb_dest && in->hold) {
 			continue;
 		}
+		if (gf_dm_sess_flush_async(in->upload, GF_TRUE) == GF_IP_NETWORK_EMPTY)
+			continue;
+		if (gf_dm_sess_flush_async(in->llhls_upload, GF_TRUE) == GF_IP_NETWORK_EMPTY)
+			continue;
 
-next_pck:
 		pck = gf_filter_pid_get_packet(in->ipid);
 		if (!pck) {
 			nb_nopck++;
@@ -3212,9 +3729,15 @@
 					httpin_send_seg_info(in);
 				}
 				httpout_close_input(ctx, in);
+
+				if (in->flush_close || in->flush_close_llhls)
+					keep_alive = GF_TRUE;
 			}
 			continue;
 		}
+		if (in->in_error) {
+			continue;
+		}
 
 
 		gf_filter_pck_get_framing(pck, &start, &end);
@@ -3228,8 +3751,29 @@
 					start = GF_TRUE;
 			}
 		}
+		//we are waiting for open ack
+		if (in->flush_open) {
+			GF_Err e = gf_dm_sess_process(in->upload);
+			if (e==GF_IP_NETWORK_EMPTY) continue;
+			if (e) {
+				httpout_input_in_error(in);
+				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Failed to open output file %s: %s\n", in->path, gf_error_to_string(e) ));
+				in->is_open = GF_FALSE;
+				continue;
+			}
+			in->flush_open = GF_FALSE;
+			//disable start since this setup for this output is already done done
+			skip_start = GF_TRUE;
+			//in case we had an upgrade
+			if (!in->is_h2)
+				in->is_h2 = gf_dm_sess_is_h2(in->upload);
+		}
+		//we are waiting for llhls open ack - this means that we already processed open for this packet (always before llhls), disable start
+		if (in->flush_llhls_open) {
+			skip_start = GF_TRUE;
+		}
 
-		if (start) {
+		if (start && !skip_start) {
 			Bool is_static = in->is_manifest;
 			const GF_PropertyValue *fnum, *fname;
 			const char *name = NULL;
@@ -3240,6 +3784,10 @@
 
 			httpout_prune_files(ctx, in);
 
+			//both calls above may trigger waiting for reply on session, postpone
+			if (in->flush_close)
+				continue;
+
 			//file num increased per packet, open new file
 			fnum = gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM);
 			if (fnum) {
@@ -3266,9 +3814,7 @@
 
 				if (orig_ctx->dst_in && (orig_ctx->dst_in != in) ) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Mutliple input PIDs with no file name set, broken graph, discarding input %s\n\tYou may retry by adding a new http output filter\n", gf_filter_pid_get_name(in->ipid) ));
-
-					gf_filter_pid_set_discard(in->ipid, GF_TRUE);
-					in->in_error = GF_TRUE;
+					httpout_input_in_error(in);
 					continue;
 				} else {
 					name = orig_ctx->dst;
@@ -3279,8 +3825,12 @@
 			}
 
 			httpout_open_input(ctx, in, name, GF_FALSE, is_static);
+			if (!in->is_open) {
+				httpout_input_in_error(in);
+				continue;
+			}
 
-			if (!ctx->hmode && !ctx->rdirs.nb_items && !in->nb_dest) {
+			if (!ctx->hmode && !ctx->has_read_dir && !in->nb_dest) {
 				if ((gf_filter_pck_get_dependency_flags(pck)==0xFF) && (gf_filter_pck_get_carousel_version(pck)==1)) {
 					pck_data = gf_filter_pck_get_data(pck, &pck_size);
 					if (pck_data) {
@@ -3290,6 +3840,10 @@
 					}
 				}
 			}
+
+			if (in->flush_open) {
+				continue;
+			}
 		}
 
 		p = gf_filter_pck_get_property(pck, GF_PROP_PCK_HLS_FRAG_NUM);
@@ -3315,23 +3869,56 @@
 			snprintf(szHLSChunk, GF_MAX_PATH-1, "%s.%d", in->path, p->value.uint);
 
 			if (!in->llhls_upload) {
-				in->llhls_upload = gf_dm_sess_new(gf_filter_get_download_manager(ctx->filter), ctx->dst, GF_NETIO_SESSION_NOT_THREADED|GF_NETIO_SESSION_NOT_CACHED|GF_NETIO_SESSION_PERSISTENT, httpout_in_io_llhls, in, &e);
+				u32 flags = GF_NETIO_SESSION_NOT_THREADED|GF_NETIO_SESSION_NOT_CACHED|GF_NETIO_SESSION_PERSISTENT;
+				if (!ctx->blockio)
+					flags |= GF_NETIO_SESSION_NO_BLOCK;
+
+				in->llhls_upload = gf_dm_sess_new(gf_filter_get_download_manager(ctx->filter), ctx->dst, flags, httpout_in_io_llhls, in, &e);
+
+				if (in->llhls_upload) {
+					gf_dm_sess_set_sock_group(in->llhls_upload, ctx->sg);
+				}
 			}
 
 			if (in->llhls_upload) {
-				httpout_close_input_llhls(ctx, in);
+				if (in->flush_llhls_open) {
+					e = gf_dm_sess_process(in->llhls_upload);
+					if (e==GF_IP_NETWORK_EMPTY) {
+						continue;
+					} else if (e) {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Failed to open output file %s: %s\n", in->path, gf_error_to_string(e) ));
+						in->llhls_is_open = GF_FALSE;
+						continue;
+					}
+					in->flush_llhls_open = GF_FALSE;
+				} else {
+					//close llhls file - if cannot be done sync, abort (we will resume here at next call)
+					httpout_close_input_llhls(ctx, in);
+					if (in->flush_close_llhls)
+						continue;
 
-				httpout_open_input_llhls(ctx, in, szHLSChunk);
+					httpout_open_input_llhls(ctx, in, szHLSChunk);
+					if (in->flush_llhls_open) continue;
+				}
 			}
 		}
 
 		//no destination and not holding packets (either first connection not here or disabled), trash packet
-		if (!ctx->hmode && !ctx->rdirs.nb_items && !in->nb_dest && !in->hold) {
+		if (!ctx->hmode && !ctx->has_read_dir && !in->nb_dest && !in->hold) {
+			if (end) {
+				httpout_close_input(ctx, in);
+				httpout_close_input_llhls(ctx, in);
+			}
 			gf_filter_pid_drop_packet(in->ipid);
+			if (in->nb_write && ctx->quit) {
+				httpout_input_in_error(in);
+				nb_eos++;
+			}
 			continue;
 		}
 
 		if (!httpout_input_write_ready(ctx, in)) {
+			ctx->next_wake_us = 1;
 			continue;
 		}
 
@@ -3349,18 +3936,36 @@
 							GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Cannot patch file by byte insertion, not supported by HTTP\n"));
 						} else {
 							u64 pos = in->nb_write;
-							//close file
-							httpout_close_input(ctx, in);
-							//re-open file
-							in->write_start_range = bo;
-							in->write_end_range = bo + pck_size - 1;
-							httpout_open_input(ctx, in, in->path, GF_FALSE, GF_FALSE);
+							//file open pending, flush
+							if (in->flush_open) {
+								GF_Err e = gf_dm_sess_process(in->upload);
+								if (e==GF_IP_NETWORK_EMPTY) continue;
+								in->flush_open = GF_FALSE;
+								if (e) {
+									GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Failed to open output file %s: %s\n", in->path, gf_error_to_string(e) ));
+									in->is_open = GF_FALSE;
+									continue;
+								}
+							} else {
+								//close file - if cannot be done sync, abort (we will resume here at next call)
+								httpout_close_input(ctx, in);
+								if (in->flush_close)
+									continue;
+
+								//re-open file
+								in->write_start_range = bo;
+								in->write_end_range = bo + pck_size - 1;
+								//we muse use sync open here
+								httpout_open_input(ctx, in, in->path, GF_FALSE, GF_FALSE);
+								if (in->flush_open) continue;
+							}
 
 							nb_write = httpout_write_input(ctx, in, pck_data, pck_size, start);
 							if (nb_write!=pck_size) {
 								GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Write error, wrote %d bytes but had %d to write\n", nb_write, pck_size));
 							}
 							httpout_close_input(ctx, in);
+							//no pb if waiting for reply since we are done with the packet
 
 							in->write_start_range = pos;
 							in->write_end_range = 0;
@@ -3368,7 +3973,19 @@
 					}
 				} else {
 					if (in->write_start_range) {
-						httpout_open_input(ctx, in, in->path, GF_FALSE, GF_FALSE);
+						if (in->flush_open) {
+							GF_Err e = gf_dm_sess_process(in->upload);
+							if (e==GF_IP_NETWORK_EMPTY) continue;
+							in->flush_open = GF_FALSE;
+							if (e) {
+								GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut Failed to open output file %s: %s\n", in->path, gf_error_to_string(e) ));
+								in->is_open = GF_FALSE;
+								continue;
+							}
+						} else {
+							httpout_open_input(ctx, in, in->path, GF_FALSE, GF_FALSE);
+							if (in->flush_open) continue;
+						}
 					}
 
 					nb_write = httpout_write_input(ctx, in, pck_data, pck_size, start);
@@ -3429,12 +4046,14 @@
 			httpout_close_input(ctx, in);
 			httpout_close_input_llhls(ctx, in);
 		}
+		if (!ctx->blockio && in->upload && gf_dm_sess_async_pending(in->upload))
+			continue;
 
 		goto next_pck;
 	}
 
 	if (count && (nb_eos==count)) {
-		if (ctx->rdirs.nb_items) {
+		if (ctx->has_read_dir) {
 			if (gf_list_count(ctx->active_sessions))
 				gf_filter_post_process_task(ctx->filter);
 			else
@@ -3445,7 +4064,10 @@
 	}
 	//push mode and no packets on inputs, do not ask for RT reschedule (we will get called if new packets are to be processed)
 	if ((nb_nopck==count) && (ctx->hmode==MODE_PUSH))
-		ctx->next_wake_us = 0;
+		ctx->next_wake_us = -1;
+
+	if (keep_alive)
+		gf_filter_post_process_task(ctx->filter);
 }
 
 static GF_Err httpout_process(GF_Filter *filter)
@@ -3454,7 +4076,7 @@
 	u32 i, count;
 	GF_HTTPOutCtx *ctx = gf_filter_get_udta(filter);
 
-	if (ctx->done)
+	if (ctx->done && !ctx->nb_sess_flush_pending)
 		return GF_EOS;
 
 	//wakeup every 50ms when inactive
@@ -3470,12 +4092,19 @@
 		count = gf_list_count(ctx->active_sessions);
 		for (i=0; i<count; i++) {
 			GF_HTTPOutSession *sess = gf_list_get(ctx->active_sessions, i);
+			if (sess->flush_close && !httpout_sess_flush_close(sess, GF_FALSE)) {
+				ctx->next_wake_us = 1;
+				gf_filter_post_process_task(filter);
+				continue;
+			}
 			//push
 			if (sess->in_source) continue;
 
 			//regular download
-			httpout_process_session(filter, ctx, sess);
-			//closed, remove
+			if (sess->http_sess)
+				httpout_process_session(filter, ctx, sess);
+
+			//closed, remove - the session may have been closed previously but not removed from our list
 			if (! sess->http_sess) {
 				httpout_del_session(sess);
 				i--;
@@ -3491,20 +4120,23 @@
 				i = -1;
 			}
 		}
+	} else if ((e==GF_IP_NETWORK_EMPTY) && gf_list_count(ctx->active_sessions)) {
+		ctx->next_wake_us = 1;
 	}
 
 	httpout_process_inputs(ctx);
 
 	if (ctx->timeout && ctx->server_sock) {
+		u32 nb_active=0;
 		count = gf_list_count(ctx->active_sessions);
 		for (i=0; i<count; i++) {
 			u32 diff_sec;
 			GF_HTTPOutSession *sess = gf_list_get(ctx->active_sessions, i);
-			if (!sess->done) continue;
+			if (sess->http_sess) nb_active++;
 
 			diff_sec = (u32) (gf_sys_clock_high_res() - sess->last_active_time)/1000000;
 			if (diff_sec>ctx->timeout) {
-				GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTPOut Timeout for peer %s after %d sec, closing connection (last request %s)\n", sess->peer_address, diff_sec, sess->in_source ? sess->in_source->path : sess->path ));
+				GF_LOG(sess->done ? GF_LOG_INFO : GF_LOG_WARNING, GF_LOG_HTTP, ("HTTPOut Timeout for peer %s after %d sec, closing connection (last request %s)\n", sess->peer_address, diff_sec, sess->in_source ? sess->in_source->path : sess->path ));
 
 				httpout_close_session(sess);
 
@@ -3513,6 +4145,14 @@
 				count--;
 			}
 		}
+		if (count && !nb_active && (ctx->hmode==MODE_SOURCE)) {
+			ctx->done = GF_TRUE;
+			return GF_EOS;
+		}
+		if (ctx->had_connections && !count) {
+			ctx->done = GF_TRUE;
+			return GF_EOS;
+		}
 	}
 
 	if (e==GF_EOS) {
@@ -3521,12 +4161,12 @@
 	}
 
 	//reschedule was canceled but we still have active sessions, reschedule for our default timeout
-	if (!ctx->next_wake_us && gf_list_count(ctx->active_sessions)) {
+	if (!ctx->hmode && !ctx->next_wake_us && gf_list_count(ctx->active_sessions)) {
 		ctx->next_wake_us = 50000;
 	}
 
-	if (ctx->next_wake_us) {
-		gf_filter_ask_rt_reschedule(filter, ctx->next_wake_us);
+	if (ctx->next_wake_us>0) {
+		gf_filter_ask_rt_reschedule(filter, (u32) ctx->next_wake_us);
 	}
 
 	return e;
@@ -3535,7 +4175,21 @@
 static Bool httpout_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
 {
 	GF_HTTPOutInput *in;
-	GF_HTTPOutCtx *ctx;
+	GF_HTTPOutCtx *ctx = (GF_HTTPOutCtx *) gf_filter_get_udta(filter);
+
+	if (ctx->hmode==MODE_SOURCE) {
+		if (evt->base.type==GF_FEVT_STOP) {
+			u32 i, count = gf_list_count(ctx->sessions);
+			for (i=0; i<count; i++) {
+				GF_HTTPOutSession *sess = gf_list_get(ctx->sessions, i);
+				if (sess->opid == evt->base.on_pid) {
+					httpout_close_session(sess);
+				}
+			}
+		}
+		return GF_FALSE;
+	}
+
 	if (evt->base.type!=GF_FEVT_FILE_DELETE)
 		return GF_FALSE;
 
@@ -3543,9 +4197,8 @@
 	in = gf_filter_pid_get_udta(evt->base.on_pid);
 	if (!in) return GF_TRUE;
 
-	ctx = (GF_HTTPOutCtx *) gf_filter_get_udta(filter);
 	//simple server mode (no record, no push), nothing to do
-	if (!in->upload && !ctx->rdirs.nb_items) return GF_TRUE;
+	if (!in->upload && !ctx->has_read_dir) return GF_TRUE;
 
 	if (!in->file_deletes)
 		in->file_deletes = gf_list_new();
@@ -3611,7 +4264,7 @@
 	"- default: run in server mode\n"
 	"- push: run in client mode using PUT or POST\n"
 	"- source: use server as source filter on incoming PUT/POST", GF_PROP_UINT, "default", "default|push|source", GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(timeout), "timeout in seconds for persistent connections (0 disable timeout)", GF_PROP_UINT, "30", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(timeout), "timeout in seconds for persistent connections (0 disable timeout)", GF_PROP_UINT, "5", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(ext), "set extension for graph resolution, regardless of file extension", GF_PROP_NAME, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(mime), "set mime type for graph resolution", GF_PROP_NAME, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(quit), "exit server once all input PIDs are done and client disconnects (for test purposes)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
@@ -3626,7 +4279,9 @@
 	{ OFFS(ice), "insert ICE meta-data in response headers in sink mode", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(max_client_errors), "force disconnection after specified number of consecutive errors from HTTTP 1.1 client (ignored in H/2 or when `close` is set)", GF_PROP_UINT, "20", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(max_cache_segs), "maximum number of segments cached per HAS quality (see filter help)", GF_PROP_SINT, "5", NULL, GF_FS_ARG_HINT_EXPERT},
-
+	{ OFFS(reopen), "in server mode with no read dir, accept requests on files already over but with input pid not in end of stream", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(max_async_buf), "maximum async buffer size in bytes when sharing output over multiple connection without file IO", GF_PROP_UINT, "100000", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(blockio), "use blocking IO in push or source mode or in server mode with no read dir", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -3653,6 +4308,14 @@
 		"When multiple read directories are specified, the server root `/` contains the list of the mount points with their directory names.\n"
 		"When a write directory is specified, the upload resource name identifies a file in this directory (the write directory name is not present in the URL).\n"
 		" \n"
+		"A directory rule file (cf `gpac -h creds`) can be specified in -rdirs() but NOT in -wdir(). When rules are used:\n"
+		"- if a directory has a `name` rule, it will be used in the URL\n"
+		"- otherwise, the directory is directly available under server root `/`\n"
+		"- read and write access rights are checked\n"
+		"EX foodir\n"
+		"EX name=bar\n"
+		"Content `RES` of this directory is exposed as `http://SERVER/bar/RES`.\n"
+		" \n"
 		"Listing can be enabled on server using -dlist().\n"
 		"When disabled, a GET on a directory will fail.\n"
 		"When enabled, a GET on a directory will return a simple HTML listing of the content inspired from Apache.\n"
@@ -3684,6 +4347,10 @@
 		"EX gpac -i source.mp3:#ice-Genre=CoolRock -o http://IP/live.mp3 --ice\n"
 		"This will inject the header `ice-Genre: CoolRock` in the response."
 		" \n"
+		"Once one complete input file is sent, it is no longer available for download unless -reopen() is set and input PID is not over.\n"
+		" \n"
+		"This mode should not be used with multiple files muxers such as DASH or HLS.\n"
+		" \n"
 		"# HTTP server file sink\n"
 		"In this mode, the filter will write input PIDs to files in the first read directory specified, acting as a file output sink.\n"
 		"The filter uses a read directory in this mode, which must be writable.\n"
@@ -3699,10 +4366,11 @@
 		"The server can store incoming files to memory mode by setting the read directory to `gmem`.\n"
 		"In this mode, -max_cache_segs() is always at least 1.\n"
 		" \n"
-		"If -max_cache_segs() valeu `N` is not 0, each incoming PID will store at most:\n"
+		"If -max_cache_segs() value `N` is not 0, each incoming PID will store at most:\n"
 		"- `MIN(N, time-shift depth)` files if stored in memory\n"
-		"- `MAX(N, time-shift depth)` files if stored locally and `N` is positive\n"
 		"- `-N` files if stored locally and `N` is negative\n"
+		"- `MAX(N, time-shift depth)` files if stored locally and `N` is positive\n"
+		"- unlimited otherwise (files stored locally, `N` is positive and no time-shift info)\n"
 		" \n"
 		"# HTTP client sink\n"
 		"In this mode, the filter will upload input PIDs data to remote server using PUT (or POST if -post() is set).\n"
@@ -3743,12 +4411,16 @@
 	.configure_pid = httpout_configure_pid,
 	.process = httpout_process,
 	.process_event = httpout_process_event,
-	.use_alias = httpout_use_alias
+	.use_alias = httpout_use_alias,
+	.flags = GF_FS_REG_TEMP_INIT
 };
 
 
 const GF_FilterRegister *httpout_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_out_proto", HTTPOutRegister.name, "http,https");
+	}
 	return &HTTPOutRegister;
 }

gpac-2.0.0.tar.gz/src/filters/out_pipe.c -> gpac-2.2.0.tar.gz/src/filters/out_pipe.c Changed

@@ -54,7 +54,7 @@
 	//options
 	Double start, speed;
 	char *dst, *mime, *ext;
-	Bool dynext, mkp;
+	Bool dynext, mkp, ka;
 	u32 block_size;
 
 
@@ -313,7 +313,7 @@
 {
 	GF_FilterPacket *pck;
 	const GF_PropertyValue *fname, *p;
-	Bool start, end;
+	Bool start, end, broken=GF_FALSE;
 	const char *pck_data;
 	u32 pck_size;
 	s32 nb_write;
@@ -383,11 +383,16 @@
 			if (! WriteFile(ctx->pipe, pck_data, pck_size, (LPDWORD) &nb_write, NULL)) {
 				nb_write = 0;
 				GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("PipeOut Write error, wrote %d bytes but had %u to write: error %d\n", nb_write, pck_size, GetLastError() ));
+
+				if (GetLastError() == ERROR_BROKEN_PIPE)
+					broken = GF_TRUE;
 			}
 #else
 			nb_write = (s32) write(ctx->fd, pck_data, pck_size);
 			if (nb_write != pck_size) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("PipeOut Write error, wrote %d bytes but had %u to write: %s\n", nb_write, pck_size, gf_errno_str(errno)));
+				if (errno == EPIPE)
+					broken = GF_TRUE;
 			}
 #endif
 		} else if (hwf) {
@@ -426,11 +431,16 @@
 						if (!WriteFile(ctx->pipe, out_ptr, lsize, (LPDWORD) &nb_write, NULL)) {
 							nb_write = 0;
 							GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("PipeOut Write error, wrote %d bytes but had %u to write: %d\n", nb_write, pck_size, GetLastError()));
+
+							if (GetLastError() == ERROR_BROKEN_PIPE)
+								broken = GF_TRUE;
 						}
 #else
 						nb_write = (s32) write(ctx->fd, out_ptr, lsize);
 						if (nb_write != lsize) {
 							GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("PipeOut Write error, wrote %d bytes but had %u to write: %s\n", nb_write, lsize, gf_errno_str(errno)));
+							if (errno == EPIPE)
+								broken = GF_TRUE;
 						}
 #endif
 						out_ptr += out_stride;
@@ -444,6 +454,12 @@
 		GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("PipeOut Output file handle is not opened, discarding %d bytes\n", pck_size));
 	}
 	gf_filter_pid_drop_packet(ctx->pid);
+
+	if (broken && !ctx->ka) {
+		gf_filter_pid_set_discard(ctx->pid, GF_TRUE);
+		end = GF_TRUE;
+	}
+
 	if (end) {
 		pipeout_open_close(ctx, NULL, NULL, 0, GF_FALSE);
 	}
@@ -470,6 +486,7 @@
 	{ OFFS(speed), "set playback speed. If negative and start is 0, start is set to -1", GF_PROP_DOUBLE, "1.0", NULL, 0},
 	{ OFFS(mkp), "create pipe if not found", GF_PROP_BOOL, "false", NULL, 0 },
 	{ OFFS(block_size), "buffer size used to write to pipe, windows only", GF_PROP_UINT, "5000", NULL, GF_FS_ARG_HINT_ADVANCED },
+	{ OFFS(ka), "keep pipe alive when broken pipe is detected", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{0}
 };
 
@@ -497,6 +514,10 @@
 		"\n"
 		"The pipe input can create the pipe if not found using -mkp(). On windows hosts, this will create a pipe server.\n"
 		"On non windows hosts, the created pipe will delete the pipe file upon filter destruction."
+		"\n"
+		"The pipe can be kept alive after a broken pipe is detected using -ka(). This is typically used when clients crash/exits and resumes.\n"
+		"When a keep-alive pipe is broken, input data is discarded and the filter will keep trashing data as fast as possible.\n"
+		"It is therefore recommended to use this mode with real-time inputs (use a reframer(reframer) if needed)."
 	"")
 	.private_size = sizeof(GF_PipeOutCtx),
 	.args = PipeOutArgs,
@@ -505,12 +526,16 @@
 	.initialize = pipeout_initialize,
 	.finalize = pipeout_finalize,
 	.configure_pid = pipeout_configure_pid,
-	.process = pipeout_process
+	.process = pipeout_process,
+	.flags = GF_FS_REG_TEMP_INIT
 };
 
 
 const GF_FilterRegister *pipeout_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_out_proto", PipeOutRegister.name, "pipe");
+	}
 	return &PipeOutRegister;
 }

gpac-2.0.0.tar.gz/src/filters/out_route.c -> gpac-2.2.0.tar.gz/src/filters/out_route.c Changed

gpac-2.0.0.tar.gz/src/filters/out_rtp.c -> gpac-2.2.0.tar.gz/src/filters/out_rtp.c Changed

@@ -146,8 +146,9 @@
 			if (!stream->rtp) continue;
 
 			p = gf_filter_pid_get_property(stream->pid, GF_PROP_PID_DURATION);
-			if (p) {
+			if (p && p->value.lfrac.den) {
 				Double dur = (Double) p->value.lfrac.num;
+				if (dur<0) dur = -dur;
 				dur /= p->value.lfrac.den;
 				if (dur>max_dur) max_dur = dur;
 			}
@@ -182,6 +183,7 @@
 		s16 tl;
 		u32 dsi_len = 0;
 		u32 dsi_enh_len = 0;
+		u32 nb_chan = 0;
 const GF_PropertyValue *p;
 		GF_RTPOutStream *stream = gf_list_get(streams, i);
 		if (!stream->rtp) continue;
@@ -208,6 +210,9 @@
 		p = gf_filter_pid_get_property(stream->pid, GF_PROP_PID_HEIGHT);
 		if (p) h = p->value.uint;
 
+		p = gf_filter_pid_get_property(stream->pid, GF_PROP_PID_NUM_CHANNELS);
+		if (p) nb_chan = p->value.uint;
+
 		p = gf_filter_pid_get_property(stream->pid, GF_PROP_PID_PROTECTION_KMS_URI);
 		if (p) KMS = p->value.string;
 
@@ -228,11 +233,13 @@
 			if (p) h = p->value.uint;
 		}
 
-		gf_rtp_streamer_append_sdp_extended(stream->rtp, stream->id, dsi, dsi_len, dsi_enh, dsi_enh_len, (char *)KMS, w, h, tw, th, tx, ty, tl, is_rtsp, &sdp_media);
+		gf_rtp_streamer_append_sdp_extended(stream->rtp, stream->id, dsi, dsi_len, dsi_enh, dsi_enh_len, (char *)KMS, w, h, tw, th, tx, ty, tl, nb_chan, is_rtsp, &sdp_media);
 
 		if (sdp_media) {
 			gf_fprintf(sdp_out, "%s", sdp_media);
 			gf_free(sdp_media);
+		} else {
+			continue;
 		}
 		if (base_pid_id) {
 			u32 j;
@@ -261,7 +268,7 @@
 		}
 
 		if (is_rtsp) {
-			gf_fprintf(sdp_out, "a=control:trackID=%d\n", stream->ctrl_id);
+			gf_fprintf(sdp_out, "a=control:%s=%d\n", stream->ctrl_name ? stream->ctrl_name : "trackID", stream->ctrl_id);
 		}
 	}
 	gf_fprintf(sdp_out, "\n");
@@ -300,7 +307,7 @@
 
 		p = gf_filter_pid_get_property(stream->pid, GF_PROP_PID_PROTECTION_SCHEME_TYPE);
 		if (!p || (p->value.uint != GF_ISOM_ISMACRYP_SCHEME)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTPOut Protected track with scheme type %s, cannot stream (only ISMA over RTP is supported !\n", p ? gf_4cc_to_str(p->value.uint) : "unknwon" ));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTPOut Protected track with scheme type %s, cannot stream (only ISMA over RTP is supported !\n", p ? gf_4cc_to_str(p->value.uint) : "unknown" ));
 			return GF_FILTER_NOT_SUPPORTED;
 		}
 	}
@@ -527,6 +534,9 @@
 	p = gf_filter_pid_get_property(stream->pid, GF_PROP_PID_DELAY);
 	stream->ts_delay = p ? p->value.longsint : 0;
 
+	stream->rtp_timescale = gf_rtp_streamer_get_timescale(stream->rtp);
+
+
 	payt++;
 	stream->microsec_ts_scale_frac.num = 1000000;
 	stream->microsec_ts_scale_frac.den = stream->timescale;
@@ -599,7 +609,7 @@
 void rtpout_del_stream(GF_RTPOutStream *st)
 {
 	if (st->rtp) gf_rtp_streamer_del(st->rtp);
-	if (st->pck) gf_filter_pid_drop_packet(st->pid);
+	if (st->has_pck) gf_filter_pid_drop_packet(st->pid);
 	if (st->avcc)
 		gf_odf_avc_cfg_del(st->avcc);
 	if (st->hvcc)
@@ -817,6 +827,8 @@
 		for (i=0; i<count; i++) {
 			GF_RTPOutStream *stream = gf_list_get(ctx->streams, i);
 			stream->rtp_ts_offset = gf_rand();
+			while (stream->rtp_ts_offset>0xFFFFFFF)
+				stream->rtp_ts_offset/=2;
 			GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTPOut RTP stream %d initial RTP TS set to %d\n", i+1, stream->rtp_ts_offset));
 		}
 	}
@@ -834,6 +846,21 @@
 	return GF_TRUE;
 }
 
+static void rtpout_process_rtcp(void *cbk, u32 ssrc, u32 rtt_ms, u64 jitter_rtp_ts, u32 loss_rate)
+{
+	GF_RTPOutStream *stream = cbk;
+	if (ssrc) return;
+	u64 jitter_us = gf_timestamp_rescale(jitter_rtp_ts, stream->rtp_timescale, 1000000);
+	GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTPOut RTCP stats for PID %s: rtt %u ms jitter "LLU" us loss rate %d / 1000\n\n", gf_filter_pid_get_name(stream->pid), rtt_ms, jitter_us, loss_rate));
+
+	gf_filter_pid_set_rt_stats(stream->pid, rtt_ms, (u32) jitter_us, loss_rate);
+
+	if (stream->on_rtcp) {
+		stream->on_rtcp(stream->on_rtcp_udta);
+	}
+}
+
+
 GF_Err rtpout_process_rtp(GF_List *streams, GF_RTPOutStream **active_stream, Bool loop, s32 delay, u32 *active_stream_idx, u64 sys_clock_at_init, u64 *active_min_ts_microsec, u64 microsec_ts_init, Bool *wait_for_loop, u32 *repost_delay_us, Bool *first_RTCP_sent, u32 base_pid_id)
 {
 	GF_Err e = GF_OK;
@@ -842,7 +869,7 @@
 	s64 diff;
 	u64 clock;
 	const char *pck_data;
-	u32 pck_size;
+	u32 pck_size=0;
 	u32 dts, cts;
 
 	/*browse all inputs and locate most mature stream*/
@@ -853,33 +880,41 @@
 		*active_min_ts_microsec = (u64) -1;
 		for (i=0; i<count; i++) {
 			stream = gf_list_get(streams, i);
-			if (!stream->rtp) continue;
+			if (!stream->rtp) {
+				if (stream->state==RTPOUT_STREAM_STOP) nb_eos++;
+				continue;
+			}
+
+			//process rtcp (we only do that once we are done sending a full au
+			gf_rtp_streamer_read_rtcp(stream->rtp, rtpout_process_rtcp, stream);
 
 			/*load next AU*/
-			if (!stream->pck) {
+			if (!stream->has_pck) {
 				u64 ts;
-				stream->pck = gf_filter_pid_get_packet(stream->pid);
+				GF_FilterPacket *pck = gf_filter_pid_get_packet(stream->pid);
 
-				if (!stream->pck) {
-					if (gf_filter_pid_is_eos(stream->pid)) {
+				if (!pck) {
+					if (gf_filter_pid_is_eos(stream->pid) || (stream->state==RTPOUT_STREAM_STOP)) {
 						//flush stream
 						if (!stream->bye_sent) {
 							stream->bye_sent = GF_TRUE;
-							gf_rtp_streamer_send_au(stream->rtp, NULL, 0, 0, 0, GF_FALSE);
-							gf_rtp_streamer_send_bye(stream->rtp);
+							if (stream->rtp) {
+								gf_rtp_streamer_send_au(stream->rtp, NULL, 0, 0, 0, GF_FALSE);
+								gf_rtp_streamer_send_bye(stream->rtp);
+							}
 						}
 						nb_eos++;
 					}
 					continue;
 				}
-				stream->current_dts = gf_filter_pck_get_dts(stream->pck);
+				stream->current_dts = gf_filter_pck_get_dts(pck);
 				//if CTS is not set, use prev packet CTS
-				ts = gf_filter_pck_get_cts(stream->pck);
+				ts = gf_filter_pck_get_cts(pck);
 				if (ts==GF_FILTER_NO_TS) ts = stream->current_cts;
 				stream->current_cts = ts;
 
-				stream->current_sap = gf_filter_pck_get_sap(stream->pck);
-				duration = gf_filter_pck_get_duration(stream->pck);
+				stream->current_sap = gf_filter_pck_get_sap(pck);
+				duration = gf_filter_pck_get_duration(pck);
 				if (duration) stream->current_duration = duration;
 				if (stream->current_dts==GF_FILTER_NO_TS)
 					stream->current_dts = stream->current_cts;
@@ -902,10 +937,11 @@
 				if (stream->current_sap>GF_FILTER_SAP_3) stream->current_sap = 0;
 				stream->pck_num++;
 				*wait_for_loop = GF_FALSE;
+				stream->has_pck = GF_TRUE;
 			}
 
 			/*check timing*/
-			if (stream->pck) {
+			if (stream->has_pck) {
 				if (*active_min_ts_microsec > stream->microsec_dts) {
 					*active_min_ts_microsec = stream->microsec_dts;
 					*active_stream = stream;
@@ -973,17 +1009,19 @@
 		*repost_delay_us = (u32) repost_in;
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("RTPOut next RTP packet (stream %d DTS "LLU") scheduled in "LLU" us, requesting filter reschedule in "LLU" us - clock "LLU" us\n", *active_stream_idx, stream->current_dts, diff, repost_in, clock));
 		return GF_OK;
-	} else if (diff<=-1000) {
-		GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTPOut RTP session stream %d - sending packet %d (DTS "LLU") too late by %d us - clock "LLU" us\n", *active_stream_idx, stream->pck_num, stream->current_dts, -diff, clock));
+	} else if (diff<=-2000) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTPOut RTP session stream %d - sending packet %d (DTS "LLU") too late by %d us - clock "LLU" us\n", *active_stream_idx, stream->pck_num, stream->current_dts, -diff, clock));
+		*repost_delay_us=0;
 	} else if (diff>0){
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("RTPOut RTP session stream %d - sending packet %d (DTS "LLU") ahead of %d us - clock "LLU" us\n", *active_stream_idx, stream->pck_num, stream->current_dts, diff, clock));
 	}
 
 	/*send packets*/
-	pck_data = gf_filter_pck_get_data(stream->pck, &pck_size);
+	GF_FilterPacket *pck = gf_filter_pid_get_packet(stream->pid);
+	pck_data = pck ? gf_filter_pck_get_data(pck, &pck_size) : NULL;
 	if (!pck_size) {
 		gf_filter_pid_drop_packet(stream->pid);
-		stream->pck = NULL;
+		stream->has_pck = GF_FALSE;
 		*active_stream = NULL;
 		return GF_OK;
 	}
@@ -1028,7 +1066,7 @@
 
 		for (i=0; i<count; i++) {
 			GF_RTPOutStream *astream = gf_list_get(streams, i);
-			if (!astream->pck) break;
+			if (!astream->has_pck) break;
 
 			u32 ts = (u32) (astream->current_cts + astream->ts_offset + astream->rtp_ts_offset);
 			gf_rtp_streamer_send_rtcp(stream->rtp, GF_TRUE, ts, ntp_type, ntp_sec, ntp_frac);
@@ -1089,12 +1127,11 @@
 		e = gf_rtp_streamer_send_data(stream->rtp, (char *) pck_data, pck_size, pck_size, cts, dts, stream->current_sap ? 1 : 0, 1, 1, stream->pck_num, duration, stream->sample_desc_index);
 	}
 	gf_filter_pid_drop_packet(stream->pid);
-	stream->pck = NULL;
+	stream->has_pck = GF_FALSE;
 
 	if (e) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTPOut Error sending RTP packet %d: %s\n", stream->pck_num, gf_error_to_string(e) ));
 	}
-
 	*active_stream = NULL;
 	return e;
 
@@ -1120,7 +1157,7 @@
 			for (i=0; i<count; i++) {
 				GF_RTPOutStream *stream = gf_list_get(ctx->streams, i);
 				gf_filter_pid_set_discard(stream->pid, GF_TRUE);
-				stream->pck = NULL;
+				stream->has_pck = GF_FALSE;
 			}
 			if (ctx->opid) gf_filter_pid_set_eos(ctx->opid);
 			return GF_EOS;
@@ -1206,12 +1243,14 @@
 	" - mapping this media time to the system clock\n"
 	"- determine the earliest packet to send next on each input PID, adding -delay() if any\n"
 	"- finally compare the packet mapped timestamp __TS__ to the system clock __SC__. When __TS__ - __SC__ is less than -tt(), the RTP packets for the source packet are sent\n"
+	"\n"
+	"The filter does not check for RTCP timeout and will run until all input PIDs reach end of stream.\n"
 	)
 	.private_size = sizeof(GF_RTPOutCtx),
 	.max_extra_pids = -1,
 	.args = RTPOutArgs,
 	//dynamic redirect since RTP may be dynamically loaded when solving .sdp destinations
-	.flags = GF_FS_REG_DYNAMIC_REDIRECT,
+	.flags = GF_FS_REG_DYNAMIC_REDIRECT | GF_FS_REG_TEMP_INIT,
 	.initialize = rtpout_initialize,
 	.finalize = rtpout_finalize,
 	SETCAPS(RTPOutCaps),
@@ -1223,6 +1262,9 @@
 
 const GF_FilterRegister *rtpout_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_out_proto", RTPOutRegister.name, "rtp");
+	}
 	return &RTPOutRegister;
 }

gpac-2.0.0.tar.gz/src/filters/out_rtp.h -> gpac-2.2.0.tar.gz/src/filters/out_rtp.h Changed

gpac-2.0.0.tar.gz/src/filters/out_rtsp.c -> gpac-2.2.0.tar.gz/src/filters/out_rtsp.c Changed

@@ -38,6 +38,15 @@
 //common functions for rtpout and rtspout
 #include "out_rtp.h"
 
+#ifdef GPAC_HAS_SSL
+
+void *gf_ssl_new(void *ssl_server_ctx, GF_Socket *client_sock, GF_Err *e);
+void *gf_ssl_server_context_new(const char *cert, const char *key);
+void gf_ssl_server_context_del(void *ssl_server_ctx);
+Bool gf_ssl_init_lib();
+
+#endif
+
 enum
 {
 	SDP_NONE = 0,
@@ -49,16 +58,33 @@
 {
 	MCAST_OFF = 0,
 	MCAST_ON,
-	MCAST_MIRROR
+	MCAST_MIRROR,
+	//describe does not ened authenticate but multicast setup does
+	MCAST_AUTHENTICATE_SETUP,
+};
+
+enum
+{
+	TRP_BOTH=0,
+	TRP_UDP_ONLY,
+	TRP_TCP_ONLY
 };
 
+typedef struct
+{
+	char *name;
+	u32 name_len;
+	char *path;
+	char *ru, *rg;
+	char *mcast;
+} RTSP_DIRInfo;
 
 typedef struct
 {
 	//options
-	char *dst, *user_agent;
+	char *dst, *user_agent, *cert, *pkey;
 	GF_PropStringList mounts;
-	u32 port, firstport;
+	u32 port, firstport, timeout;
 	Bool xps;
 	u32 mtu;
 	u32 ttl;
@@ -69,8 +95,8 @@
 	s32 runfor, tso;
 	u32 maxc;
 	u32 block_size;
-	Bool close, loop, dynurl, mpeg4;
-	u32 mcast;
+	Bool close, loop, mpeg4, quit, htun, dynurl;
+	u32 mcast, trp;
 	Bool latm;
 
 	GF_Socket *server_sock;
@@ -78,9 +104,13 @@
 
 	u32 next_wake_us;
 	char *ip;
-	Bool done;
-} GF_RTSPOutCtx;
+	Bool done, is_active;
+
+	GF_List *directories;
 
+	void *ssl_ctx;
+	u32 ms_timeout;
+} GF_RTSPOutCtx;
 
 typedef struct __rtspout_session
 {
@@ -98,11 +128,12 @@
 	char *service_name;
 	char *sessionID;
 	char peer_addressGF_MAX_IP_NAME_LEN;
+	char ctrl_name10;
 
 	u32 play_state;
 	Double start_range;
 	u32 last_cseq;
-	Bool interleave;
+	Bool interleave, is_tunnel;
 
 	/*base stream if this stream contains a media decoding dependency, 0 otherwise*/
 	u32 base_pid_id;
@@ -131,19 +162,26 @@
 	Bool request_pending;
 	char *multicast_ip;
 	u64 sdp_id;
+	u32 mcast_mode;
+	char *mcast_sname;
+
+	u32 last_active_time;
+	char *setup_ctrl;
 } GF_RTSPOutSession;
 
+static GF_Err rtspout_process_setup(GF_RTSPOutCtx *ctx, GF_RTSPOutSession *sess, char *ctrl);
 
 static void rtspout_send_response(GF_RTSPOutCtx *ctx, GF_RTSPOutSession *sess)
 {
 	sess->response->User_Agent = ctx->user_agent;
 	sess->response->Session = sess->sessionID;
-	if (ctx->close && !sess->interleave)
+	if (ctx->close && !sess->interleave && !sess->is_tunnel)
 		sess->response->Connection = "close";
 	gf_rtsp_send_response(sess->rtsp, sess->response);
 	sess->response->User_Agent = NULL;
 	sess->response->Session = NULL;
-	if (ctx->close && !sess->interleave) {
+	sess->last_active_time = gf_sys_clock();
+	if (ctx->close && !sess->interleave && !sess->is_tunnel) {
 		sess->response->Connection = NULL;
 		gf_rtsp_session_del(sess->rtsp);
 		sess->rtsp = NULL;
@@ -153,7 +191,7 @@
 static void rtspout_check_last_sess(GF_RTSPOutCtx *ctx)
 {
 	if (gf_list_count(ctx->sessions) ) return;
-
+	ctx->is_active = GF_FALSE;
 	if (ctx->dst)
 		ctx->done = GF_TRUE;
 	else if (ctx->runfor>0)
@@ -165,6 +203,24 @@
 	FILE *sdp_out;
 	u32 fsize;
 	GF_Err e;
+
+	if (sess->setup_ctrl) {
+		sess->response->CSeq = sess->last_cseq;
+		//setup on resource not loaded, reassign control string based on setup query
+		//this typically happen after a seek when we teardown the session right away
+		if (!sess->sessionID || !sess->ctrl_name0) {
+			char *sep = strchr(sess->setup_ctrl, '=');
+			if (sep) sep0 = 0;
+			strncpy(sess->ctrl_name, sess->setup_ctrl+1, 9);
+			sess->ctrl_name9 = 0;
+			if (sep) sep0 = '=';
+		}
+		e = rtspout_process_setup(sess->ctx, sess, sess->setup_ctrl);
+		gf_free(sess->setup_ctrl);
+		sess->setup_ctrl = NULL;
+		return e;
+	}
+
 	const char *ip = sess->ctx->ip;
 	if (!ip) ip = sess->ctx->ifce;
 	if (!ip) ip = "127.0.0.1";
@@ -199,11 +255,18 @@
 
 static void rtspout_del_stream(GF_RTPOutStream *st)
 {
+	if (st->pid) {
+		GF_FilterEvent fevt;
+		gf_filter_pid_set_discard(st->pid, GF_TRUE);
+		GF_FEVT_INIT(fevt, GF_FEVT_STOP, st->pid);
+		gf_filter_pid_send_event(st->pid, &fevt);
+		st->has_pck = GF_FALSE;
+	}
 	rtpout_del_stream(st);
 }
 
 
-static void rtspout_del_session(GF_RTSPOutSession *sess)
+static void rtspout_del_session(GF_Filter *filter, GF_RTSPOutSession *sess)
 {
 	//server mode, cleanup
 	while (gf_list_count(sess->streams)) {
@@ -216,12 +279,23 @@
 		gf_free(sess->service_name);
 	if (sess->sessionID)
 		gf_free(sess->sessionID);
+
+	if (filter) {
+		while (gf_list_count(sess->filter_srcs)) {
+			GF_Filter *fsrc = gf_list_pop_back(sess->filter_srcs);
+			gf_filter_remove_src(filter, fsrc);
+		}
+	}
 	gf_list_del(sess->filter_srcs);
 	gf_rtsp_session_del(sess->rtsp);
 	gf_rtsp_command_del(sess->command);
 	gf_rtsp_response_del(sess->response);
 	gf_list_del_item(sess->ctx->sessions, sess);
+	if (sess->ctx->quit && !gf_list_count(sess->ctx->sessions))
+		sess->ctx->done = GF_TRUE;
+
 	if (sess->multicast_ip) gf_free(sess->multicast_ip);
+	if (sess->setup_ctrl) gf_free(sess->setup_ctrl);
 	gf_free(sess);
 }
 
@@ -251,6 +325,12 @@
 	return NULL;
 }
 
+static void rtspout_on_rtcp(void *udta)
+{
+	GF_RTSPOutSession *sess = (GF_RTSPOutSession *) udta;
+	sess->last_active_time = gf_sys_clock();
+}
+
 static GF_Err rtspout_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
 {
 	GF_RTSPOutCtx *ctx = (GF_RTSPOutCtx *) gf_filter_get_udta(filter);
@@ -261,9 +341,9 @@
 	const GF_PropertyValue *p;
 
 	sess = rtspout_locate_session_for_pid(filter, ctx, pid);
-	if (!sess) return GF_SERVICE_ERROR;
 
 	if (is_remove) {
+		if (!sess) return GF_OK;
 		GF_RTPOutStream *t = gf_filter_pid_get_udta(pid);
 		if (t) {
 			if (sess->active_stream==t) sess->active_stream = NULL;
@@ -271,10 +351,11 @@
 			rtspout_del_stream(t);
 		}
 		if (!gf_list_count(sess->streams)) {
-			rtspout_del_session(sess);
+			rtspout_del_session(filter, sess);
 		}
 		return GF_OK;
 	}
+	if (!sess) return GF_SERVICE_ERROR;
 	stream = gf_filter_pid_get_udta(pid);
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
@@ -302,11 +383,18 @@
 		stream->pid = pid;
 		stream->streamtype = streamType;
 		stream->min_dts = GF_FILTER_NO_TS;
+		stream->on_rtcp = rtspout_on_rtcp;
+		stream->on_rtcp_udta = sess;
+
+#ifdef GPAC_ENABLE_COVERAGE
+		if (gf_sys_is_cov_mode())
+			rtspout_on_rtcp(stream->on_rtcp_udta);
+#endif
 	 	gf_filter_pid_set_udta(pid, stream);
 	}
-
 	stream->ctrl_id = sess->next_stream_id+1;
 	sess->next_stream_id++;
+	stream->ctrl_name = sess->ctrl_name;
 
 	payt = ctx->payt + gf_list_find(sess->streams, stream);
 
@@ -330,7 +418,7 @@
 	GF_RTSPSession *new_sess = NULL;
 
 	if (!single_session) {
-		new_sess = gf_rtsp_session_new_server(ctx->server_sock);
+		new_sess = gf_rtsp_session_new_server(ctx->server_sock, ctx->htun, ctx->ssl_ctx);
 		if (!new_sess) return GF_OK;
 	}
 
@@ -344,16 +432,30 @@
 	sess->response = gf_rtsp_response_new();
 	sess->streams = gf_list_new();
 	sess->filter_srcs = gf_list_new();
+	if (gf_sys_is_test_mode()) {
+		strcpy(sess->ctrl_name, "trackID");
+	} else {
+		u32 seed = gf_rand();
+#ifndef GPAC_64_BITS
+		seed |= (u32) sess;
+#else
+		seed |= (u32) (u64) sess;
+#endif
+		seed |= gf_sys_clock();
+		sprintf(sess->ctrl_name, "s%08X", seed);
+	}
 
 	if (new_sess) {
 		gf_rtsp_set_buffer_size(new_sess, ctx->block_size);
 		gf_rtsp_get_remote_address(new_sess, sess->peer_address);
 		GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSP Accepting new connection from %s\n", sess->peer_address));
+		sess->last_active_time = gf_sys_clock();
 	} else {
 		sess->single_session = GF_TRUE;
 	}
 	sess->ctx = ctx;
 	gf_list_add(ctx->sessions, sess);
+	ctx->is_active = GF_TRUE;
 	return GF_OK;
 }
 
@@ -361,20 +463,20 @@
 {
 	char szIP1024;
 	GF_Err e;
-	u16 port;
+	u32 i;
+	u16 port = 0;
 	char *ip;
 	GF_RTSPOutCtx *ctx = (GF_RTSPOutCtx *) gf_filter_get_udta(filter);
 	if (!ctx->payt) ctx->payt = 96;
-	if (!ctx->port) ctx->port = 554;
 	if (!ctx->firstport) ctx->firstport = 7000;
 	if (!ctx->mtu) ctx->mtu = 1450;
 	if (ctx->payt<96) ctx->payt = 96;
 	if (ctx->payt>127) ctx->payt = 127;
 	ctx->sessions = gf_list_new();
 
-	port = ctx->port;
 	ip = ctx->ifce;
-
+	//move to sec
+	ctx->ms_timeout = ctx->timeout * 1000;
 	if (!ctx->dst) {
 		if (! ctx->mounts.nb_items) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSPOut No root dir for server, cannot run\n" ));
@@ -392,7 +494,6 @@
 			sep = strchr(szIP, ':');
 			if (sep) {
 				port = atoi(sep+1);
-				if (!port) port = ctx->port;
 				sep0 = 0;
 			}
 			if (strlen(szIP)) ip = szIP;
@@ -407,6 +508,46 @@
 	if (ip)
 		ctx->ip = gf_strdup(ip);
 
+	if (ctx->cert && !ctx->pkey) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("RTSPOut missing server private key file\n"));
+		return GF_BAD_PARAM;
+	}
+	if (!ctx->cert && ctx->pkey) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("RTSPOut missing server certificate file\n"));
+		return GF_BAD_PARAM;
+	}
+	if (ctx->cert && ctx->pkey) {
+#ifdef GPAC_HAS_SSL
+		if (!gf_file_exists(ctx->cert)) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("RTSPOut Certificate file %s not found\n", ctx->cert));
+			return GF_IO_ERR;
+		}
+		if (!gf_file_exists(ctx->pkey)) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("RTSPOut Private key file %s not found\n", ctx->pkey));
+			return GF_IO_ERR;
+		}
+		if (gf_ssl_init_lib()) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("RTSPOut Failed to initialize OpenSSL library\n"));
+			return GF_IO_ERR;
+		}
+		ctx->ssl_ctx = gf_ssl_server_context_new(ctx->cert, ctx->pkey);
+		if (!ctx->ssl_ctx) return GF_IO_ERR;
+
+		if (!ctx->port || (ctx->port==554))
+			ctx->port = 322;
+#else
+		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTPOut TLS key/certificate set but GPAC compiled without TLS support\n"));
+		return GF_NOT_SUPPORTED;
+
+#endif
+	}
+
+	if (!ctx->port)
+		ctx->port = 554;
+
+	if (!port)
+		port = ctx->port;
+
 	ctx->server_sock = gf_sk_new(GF_SOCK_TYPE_TCP);
 	e = gf_sk_bind(ctx->server_sock, NULL, port, ip, 0, GF_SOCK_REUSE_PORT);
 	if (!e) e = gf_sk_listen(ctx->server_sock, ctx->maxc);
@@ -416,8 +557,60 @@
 	}
 
 	gf_sk_server_mode(ctx->server_sock, GF_TRUE);
+
 	GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSPOut Server running on port %d\n", ctx->port));
 	gf_filter_post_process_task(filter);
+
+	ctx->directories = gf_list_new();
+	for (i=0; i<ctx->mounts.nb_items; i++) {
+		char *dpath = ctx->mounts.valsi;
+		if (gf_dir_exists(dpath)) {
+			RTSP_DIRInfo *di;
+			GF_SAFEALLOC(di, RTSP_DIRInfo);
+			di->path = gf_strdup(dpath);
+			gf_list_add(ctx->directories, di);
+		} else if (gf_file_exists(dpath)) {
+			GF_Config *rules = gf_cfg_new(NULL, dpath);
+			u32 j, count = gf_cfg_get_section_count(rules);
+			for (j=0; j<count; j++) {
+				const char *dname = gf_cfg_get_section_name(rules, j);
+				if (strcmp(dname, "$dynurl") && !gf_dir_exists(dname)) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTSPOut No such directory %s, ignoring rule\n", dname));
+					continue;
+				}
+				const char *fnames = gf_cfg_get_key(rules, dname, "filters");
+				if (fnames && strcmp(fnames, "*") && strcmp(fnames, "all")) {
+					if (!strstr(fnames, "rtspout")) continue;
+				}
+				RTSP_DIRInfo *di;
+				GF_SAFEALLOC(di, RTSP_DIRInfo);
+				di->path = gf_strdup(dname);
+				gf_list_add(ctx->directories, di);
+				di->name = (char*)gf_cfg_get_key(rules, dname, "name");
+				if (di->name) {
+					di->name = gf_strdup(di->name);
+					di->name_len = (u32) strlen(di->name);
+					if (di->namedi->name_len-1 != '/') {
+						gf_dynstrcat(&di->name, "/", NULL);
+						di->name_len += 1;
+					}
+				}
+				di->ru = (char*)gf_cfg_get_key(rules, dname, "ru");
+				if (di->ru) di->ru = gf_strdup(di->ru);
+				di->rg = (char*)gf_cfg_get_key(rules, dname, "rg");
+				if (di->rg) di->rg = gf_strdup(di->rg);
+				di->mcast = (char*)gf_cfg_get_key(rules, dname, "mcast");
+				if (di->mcast) di->mcast = gf_strdup(di->mcast);
+			}
+			gf_cfg_del(rules);
+		} else {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTSPOut No such directory %s, ignoring rule\n", dpath));
+		}
+	}
+	if (!gf_list_count(ctx->directories) && !ctx->dst) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSPOut No root dir for server, cannot run\n" ));
+		return GF_BAD_PARAM;
+	}
 	return GF_OK;
 }
 
@@ -427,12 +620,29 @@
 
 	while (gf_list_count(ctx->sessions)) {
 		GF_RTSPOutSession *tmp = gf_list_get(ctx->sessions, 0);
-		rtspout_del_session(tmp);
+		rtspout_del_session(NULL, tmp);
 	}
 	gf_list_del(ctx->sessions);
 
-	gf_sk_del(ctx->server_sock);
-	if (ctx->ip) gf_free(ctx->ip);	
+	if (ctx->server_sock) gf_sk_del(ctx->server_sock);
+	if (ctx->ip) gf_free(ctx->ip);
+
+#ifdef GPAC_HAS_SSL
+	if (ctx->ssl_ctx) {
+		gf_ssl_server_context_del(ctx->ssl_ctx);
+	}
+#endif
+
+	while (gf_list_count(ctx->directories)) {
+		RTSP_DIRInfo *di = gf_list_pop_back(ctx->directories);
+		gf_free(di->path);
+		if (di->name) gf_free(di->name);
+		if (di->ru) gf_free(di->ru);
+		if (di->rg) gf_free(di->rg);
+		if (di->mcast) gf_free(di->mcast);
+		gf_free(di);
+	}
+	gf_list_del(ctx->directories);
 }
 
 
@@ -481,6 +691,8 @@
 		for (i=0; i<count; i++) {
 			GF_RTPOutStream *stream = gf_list_get(sess->streams, i);
 			stream->rtp_ts_offset = gf_rand();
+			while (stream->rtp_ts_offset>0xFFFFFFF)
+				stream->rtp_ts_offset/=2;
 			GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSPOut Session %s: RTP stream %d initial RTP TS set to %d\n", sess->service_name, i+1, stream->rtp_ts_offset));
 		}
 	}
@@ -497,12 +709,23 @@
 
 		GF_SAFEALLOC(rtpi, GF_RTPInfo);
 		if (rtpi) {
+			u32 timescale;
 			rtpi->url = gf_malloc(sizeof(char) * (strlen(sess->service_name)+50));
-			sprintf(rtpi->url, "%s/trackID=%d", sess->service_name, stream->ctrl_id);
+			sprintf(rtpi->url, "%s/%s=%d", sess->service_name, sess->ctrl_name, stream->ctrl_id);
 			rtpi->seq = gf_rtp_streamer_get_next_rtp_sn(stream->rtp);
 			rtpi->rtp_time = (u32) (stream->current_cts + stream->ts_offset + stream->rtp_ts_offset);
 
+			timescale = gf_rtp_streamer_get_timescale(stream->rtp);
+			if (timescale)
+				rtpi->rtp_time = (u32) gf_timestamp_rescale(rtpi->rtp_time, stream->timescale, timescale);
+
 			gf_list_add(sess->response->RTP_Infos, rtpi);
+
+#ifdef GPAC_ENABLE_COVERAGE
+			if (gf_sys_is_cov_mode()) {
+				gf_rtp_streamer_get_ssrc(stream->rtp);
+			}
+#endif
 		}
 	}
 	GF_SAFEALLOC(sess->response->Range, GF_RTSPRange);
@@ -524,16 +747,27 @@
 
 	for (i=0; i<count; i++) {
 		GF_RTPOutStream *stream = gf_list_get(sess->streams, i);
-		if (!stream->selected) continue;
-
 		fevt.base.on_pid = stream->pid;
-		if (send_stop && stream->is_playing) {
-			stream->is_playing = GF_FALSE;
+		if (!stream->selected) {
+			//send a play/stop event for this pid
+			fevt.base.type = GF_FEVT_PLAY;
+			gf_filter_pid_send_event(stream->pid, &fevt);
+			fevt.base.type = GF_FEVT_STOP;
+			gf_filter_pid_send_event(stream->pid, &fevt);
+			stream->state = RTPOUT_STREAM_STOP;
+			stream->has_pck = GF_FALSE;
+			continue;
+		}
+		if (send_stop && (stream->state!=RTPOUT_STREAM_STOP)) {
+			stream->state = RTPOUT_STREAM_STOP;
 			fevt.base.type = GF_FEVT_STOP;
+			gf_filter_pid_set_discard(stream->pid, GF_TRUE);
 			gf_filter_pid_send_event(stream->pid, &fevt);
+			stream->has_pck = GF_FALSE;
 		}
-		if (send_play && !stream->is_playing) {
-			stream->is_playing = GF_TRUE;
+		if (send_play && (stream->state!=RTPOUT_STREAM_PLAY)) {
+			stream->state = RTPOUT_STREAM_PLAY;
+			gf_filter_pid_set_discard(stream->pid, GF_FALSE);
 			fevt.base.type = GF_FEVT_PLAY;
 			fevt.play.start_range = start_range;
 			gf_filter_pid_send_event(stream->pid, &fevt);
@@ -553,24 +787,28 @@
 		if (!rtspout_init_clock(ctx, sess)) return GF_OK;
 	}
 
-	if (ctx->runfor>0) {
-		s64 diff = gf_sys_clock_high_res();
-		diff -= sess->sys_clock_at_init;
-		diff /= 1000;
-		if ((s32) diff > ctx->runfor) {
-			u32 i, count = gf_list_count(sess->streams);
-			for (i=0; i<count; i++) {
-				GF_RTPOutStream *stream = gf_list_get(sess->streams, i);
-				gf_filter_pid_set_discard(stream->pid, GF_TRUE);
-				stream->pck = NULL;
-			}
-			return GF_EOS;
+	if (sess->rtsp && sess->interleave) {
+		e = gf_rtsp_check_connection(sess->rtsp);
+		if (e==GF_IP_NETWORK_EMPTY) {
+			ctx->next_wake_us = 100;
+			return GF_OK;
+		} else if (e) {
+			return e;
 		}
 	}
 
 	e = rtpout_process_rtp(sess->streams, &sess->active_stream, sess->loop, ctx->delay, &sess->active_stream_idx, sess->sys_clock_at_init, &sess->active_min_ts_microsec, sess->microsec_ts_init, &sess->wait_for_loop, &repost_delay_us, &sess->first_RTCP_sent, sess->base_pid_id);
 
-	if (e) return e;
+	if (e) {
+		if ((e==GF_IP_CONNECTION_CLOSED) || (e==GF_IP_CONNECTION_FAILURE)) {
+			sess->play_state = 0;
+			rtspout_send_event(sess, GF_TRUE, GF_FALSE, 0);
+
+			rtspout_del_session(filter, sess);
+			rtspout_check_last_sess(ctx);
+		}
+		return e;
+	}
 	if (ctx->next_wake_us > repost_delay_us)
 		ctx->next_wake_us = (u32) repost_delay_us;
 	return GF_OK;
@@ -582,6 +820,8 @@
 	GF_RTPOutStream *stream = (GF_RTPOutStream *)cbk2;
 
 	u32 idx = is_rtcp ? stream->rtcp_id : stream->rtp_id;
+	if (!sess->rtsp)
+		return GF_IP_CONNECTION_CLOSED;
 	return gf_rtsp_session_write_interleaved(sess->rtsp, idx, pck, pck_size);
 }
 
@@ -603,7 +843,7 @@
 		sess->response->CSeq = sess->command->CSeq;
 		rtspout_send_response(sess->ctx, sess);
 	}
-	rtspout_del_session(sess);
+	rtspout_del_session(NULL, sess);
 	//we don't notify error at our session level if the request fails
 	return GF_TRUE;
 }
@@ -703,6 +943,9 @@
 		char *a_sess_path=NULL;
 		GF_RTSPOutSession *a_sess = gf_list_get(ctx->sessions, i);
 		if (!a_sess->multicast_ip) continue;
+		if (a_sess->mcast_sname && !strcmp(a_sess->mcast_sname, res_path))
+			return a_sess;
+
 		if (!a_sess->service_name) continue;
 
 		a_sess_path = strstr(a_sess->service_name, "://");
@@ -714,29 +957,319 @@
 	return NULL;
 }
 
-static char *rtspout_get_local_res_path(GF_RTSPOutCtx *ctx, char *res_path)
+static char *rtspout_get_local_res_path(GF_RTSPOutCtx *ctx, char *res_path, GF_RTSPCommand *com, u32 *err_code, u32 *mcast_mode)
 {
-	u32 i;
+	u32 i, count, di_len;
+	RTSP_DIRInfo *di = NULL;
 	char *src_url=NULL;
-	for (i=0; i<ctx->mounts.nb_items; i++) {
-		char *mpoint = ctx->mounts.valsi;
+	count = gf_list_count(ctx->directories);
 
-		gf_dynstrcat(&src_url, mpoint, NULL);
-		gf_dynstrcat(&src_url, res_path, "/");
-		if (gf_file_exists(src_url))
-			break;
-		gf_free(src_url);
-		src_url = NULL;
+	*err_code = NC_RTSP_Not_Found;
+	if (res_path) {
+		for (i=0; i<count; i++) {
+			char *res_path_loc = res_path;
+			di = gf_list_get(ctx->directories, i);
+			char *mpoint = di->path;
+			if (di->name) {
+				if (strncmp(res_path, di->name, di->name_len)) continue;
+				res_path_loc += di->name_len;
+			}
+
+			gf_dynstrcat(&src_url, mpoint, NULL);
+			gf_dynstrcat(&src_url, res_path_loc, "/");
+			if (gf_file_exists(src_url))
+				break;
+			gf_free(src_url);
+			src_url = NULL;
+		}
+		if (!src_url) return NULL;
+	}
+	if (src_url || !res_path) {
+		di = NULL;
+		di_len = 0;
+		for (i=0; i<count; i++) {
+			RTSP_DIRInfo *adi = gf_list_get(ctx->directories, i);
+			u32 plen = (u32) strlen(adi->path);
+			if (!src_url) {
+				if (strcmp(adi->path, "$dynurl"))
+					continue;
+			} else {
+				if (strncmp(src_url, adi->path, plen)) continue;
+			}
+			if (!di || (plen > di_len)) {
+				di = adi;
+				di_len = plen;
+			}
+		}
+	}
+	if (!di && !src_url) {
+		*err_code = NC_RTSP_Not_Found;
+		return NULL;
+	}
+
+	if (!di->ru && !di->rg && !com->Authorization) {
+		*err_code = NC_RTSP_OK;
+		if (di->mcast) *mcast_mode = MCAST_AUTHENTICATE_SETUP;
+		return src_url;
+	}
+	//check access rights and authentication
+	GF_Err creds_ok = GF_NOT_FOUND;
+	char szUsrPass200, *user=NULL, *pass=NULL;
+	*err_code = NC_RTSP_Unauthorized;
+
+	if (!com->Authorization) {
+		if (src_url) gf_free(src_url);
+		return NULL;
+	}
+	if (!strncmp(com->Authorization, "Basic ", 6)) {
+		u32 len = gf_base64_decode(com->Authorization+6, (u32) strlen(com->Authorization)-6, szUsrPass, 200);
+		szUsrPasslen=0;
+		char *sep = strchr(szUsrPass, ':');
+		if (!sep) {
+			*err_code = NC_RTSP_Bad_Request;
+			if (src_url) gf_free(src_url);
+			return NULL;
+		}
+		pass = sep+1;
+		sep0 = 0;
+		user = szUsrPass;
+		creds_ok = gf_creds_check_password(user, pass);
+	} else {
+		if (src_url) gf_free(src_url);
+		return NULL;
+	}
+	//return unauthorized, so that we get a user name
+	if (!user) return NULL;
+
+	if (di->ru || di->rg) {
+		if (!gf_creds_check_membership(user, di->ru, di->rg)) {
+			*err_code = NC_RTSP_Forbidden;
+			if (src_url) gf_free(src_url);
+			return NULL;
+		}
+	}
+	//if wrong creds - return forbidden if invalid user name
+	if (creds_ok) {
+		if (creds_ok==GF_NOT_FOUND) *err_code = NC_RTSP_Forbidden;
+		if (src_url) gf_free(src_url);
+		return NULL;
+	}
+	*err_code = NC_RTSP_OK;
+	*mcast_mode = MCAST_OFF;
+	if (di->mcast) {
+		if (gf_creds_check_membership(user, di->mcast, di->mcast))
+			*mcast_mode = MCAST_ON;
+		else
+			*mcast_mode = MCAST_MIRROR;
 	}
 	return src_url;
 }
 
+static u32 rtspout_get_ctrl_id(GF_RTSPOutSession *sess, char *ctrl)
+{
+	u32 stream_ctrl_id=0;
+	if (ctrl && (ctrl0=='/')) {
+		u32 len = (u32) strlen(sess->ctrl_name);
+		if (!strncmp(ctrl+1, sess->ctrl_name, len)) {
+			if (sscanf(ctrl+1+len, "=%d", &stream_ctrl_id)<1) {
+				stream_ctrl_id=0;
+			}
+		}
+	}
+	return stream_ctrl_id;
+}
+
+static GF_Err rtspout_process_setup(GF_RTSPOutCtx *ctx, GF_RTSPOutSession *sess, char *ctrl)
+{
+	GF_Err e;
+	char remoteIPGF_MAX_IP_NAME_LEN;
+	GF_RTPOutStream *stream = NULL;
+	GF_RTSPTransport *transport = gf_list_get(sess->command->Transports, 0);
+	u32 rsp_code=NC_RTSP_OK;
+	Bool enable_multicast = GF_FALSE;
+	Bool reset_transport_dest = GF_FALSE;
+
+	u32 stream_ctrl_id = rtspout_get_ctrl_id(sess, ctrl);
+
+	if (ctrl && (ctrl0=='/')) {
+		u32 len = (u32) strlen(sess->ctrl_name);
+		if (!strncmp(ctrl+1, sess->ctrl_name, len)) {
+			if (sscanf(ctrl+1+len, "=%d", &stream_ctrl_id)<1) {
+				stream_ctrl_id=0;
+			}
+		}
+	}
+
+	if (!ctrl || !transport) {
+		rsp_code = NC_RTSP_Bad_Request;
+	} else if (sess->sessionID && sess->command->Session && strcmp(sess->sessionID, sess->command->Session)) {
+		rsp_code = NC_RTSP_Bad_Request;
+	} else if (sess->sessionID && !sess->command->Session) {
+		rsp_code = NC_RTSP_Not_Implemented;
+	} else {
+		u32 i, count = gf_list_count(sess->streams);
+		for (i=0; i<count; i++) {
+			stream = gf_list_get(sess->streams, i);
+			if (stream_ctrl_id==stream->ctrl_id)
+				break;
+			stream=NULL;
+		}
+		if (!stream_ctrl_id || !stream)
+			rsp_code = NC_RTSP_Not_Found;
+	}
+
+	if (!stream) {
+		gf_rtsp_response_reset(sess->response);
+		sess->response->ResponseCode = rsp_code;
+		sess->response->CSeq = sess->command->CSeq;
+		rtspout_send_response(ctx, sess);
+
+		gf_rtsp_session_del(sess->rtsp);
+		sess->rtsp = NULL;
+		rtspout_check_last_sess(ctx);
+		return GF_OK;
+	}
+
+	gf_rtsp_response_reset(sess->response);
+	sess->response->CSeq = sess->command->CSeq;
+
+	stream->selected = GF_TRUE;
+	if (transport && (rsp_code==NC_RTSP_OK) ) {
+		if (!transport->IsInterleaved) {
+			if (ctx->trp == TRP_TCP_ONLY) {
+				rsp_code = NC_RTSP_Unsupported_Transport;
+			} else {
+				u32 st_idx = gf_list_find(sess->streams, stream);
+				transport->port_first = ctx->firstport + 2 * st_idx;
+				transport->port_last = transport->port_first + 1;
+				if (sess->interleave)
+					rsp_code = NC_RTSP_Not_Implemented;
+			}
+		} else {
+			if (ctx->trp == TRP_UDP_ONLY) {
+				rsp_code = NC_RTSP_Unsupported_Transport;
+			} else if (!sess->sessionID) {
+				sess->interleave = GF_TRUE;
+			} else if (!sess->interleave) {
+				rsp_code = NC_RTSP_Not_Implemented;
+			}
+		}
+		transport->SSRC = rand();
+		transport->is_sender = GF_TRUE;
+
+		if (transport->IsUnicast) {
+			if (transport->destination && gf_sk_is_multicast_address(transport->destination)) {
+				rsp_code = NC_RTSP_Bad_Request;
+			} else if (!transport->destination) {
+				transport->destination = sess->peer_address;
+				reset_transport_dest = GF_TRUE;
+			}
+			if (sess->multicast_ip)
+				rsp_code = NC_RTSP_Forbidden;
+
+			if (ctx->dst && (strstr(ctx->dst, "://127.0.0.1") || strstr(ctx->dst, "://localhost") || strstr(ctx->dst, "://::1/128") ) ) {
+				if (!reset_transport_dest && transport->destination) gf_free(transport->destination);
+				transport->destination = "127.0.0.1";
+				reset_transport_dest = GF_TRUE;
+			}
+		}
+		else {
+			if (transport->destination && !gf_sk_is_multicast_address(transport->destination)) {
+				rsp_code = NC_RTSP_Bad_Request;
+			} else {
+				u32 mcast_mode = ctx->mcast;
+				if (sess->mcast_mode) mcast_mode = sess->mcast_mode;
+
+				if (mcast_mode==MCAST_AUTHENTICATE_SETUP) {
+					rtspout_get_local_res_path(ctx, NULL, sess->command, &rsp_code, &sess->mcast_mode);
+					mcast_mode = sess->mcast_mode;
+					//try once only
+					if (rsp_code==NC_RTSP_Forbidden)
+						mcast_mode = MCAST_OFF;
+				}
+
+				if (mcast_mode == MCAST_AUTHENTICATE_SETUP) {
+					rsp_code = NC_RTSP_Unauthorized;
+				}
+				else if (mcast_mode != MCAST_OFF) {
+					enable_multicast = GF_TRUE;
+					//we don't allow seting up streams on different mcast addresses
+					if (!sess->multicast_ip) {
+						sess->multicast_ip = transport->destination; //detach memory
+					}
+					transport->source = transport->destination = sess->multicast_ip;
+					reset_transport_dest = GF_TRUE;
+
+					transport->client_port_first = 0;
+					transport->client_port_last = 0;
+					if (ctx->ttl) transport->TTL = ctx->ttl;
+					if (!transport->TTL) transport->TTL = 1;
+					stream->mcast_port = transport->port_first;
+					rtspout_get_next_mcast_port(ctx, sess, &stream->mcast_port);
+					transport->port_first = stream->mcast_port;
+					transport->port_last = stream->mcast_port+1;
+				} else {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSP SETUP requests a multicast to %s, not allowed\n", transport->destination));
+					rsp_code = NC_RTSP_Forbidden;
+				}
+			}
+		}
+	}
+
+	if (rsp_code != NC_RTSP_OK) {
+		sess->response->ResponseCode = rsp_code;
+		if (rsp_code == NC_RTSP_Unauthorized) {
+			sess->response->WWW_Authenticate = gf_strdup("Basic");
+			rsp_code = NC_RTSP_OK; //do not delete session
+		}
+	} else {
+		e = gf_rtp_streamer_init_rtsp(stream->rtp, ctx->mtu, transport, ctx->ifce);
+		if (e) {
+			sess->response->ResponseCode = NC_RTSP_Internal_Server_Error;
+		} else {
+			if (!sess->sessionID)
+				sess->sessionID = gf_rtsp_generate_session_id(sess->rtsp);
+
+			sess->response->ResponseCode = NC_RTSP_OK;
+			sess->response->Session = sess->sessionID;
+			if (!enable_multicast) {
+				gf_rtsp_get_session_ip(sess->rtsp, remoteIP);
+				if (!reset_transport_dest && transport->destination) gf_free(transport->destination);
+				transport->destination = NULL;
+				transport->source = remoteIP;
+			}
+			gf_list_add(sess->response->Transports, transport);
+		}
+
+		if (sess->interleave) {
+			stream->rtp_id = transport->rtpID;
+			stream->rtcp_id = transport->rtcpID;
+			gf_rtp_streamer_set_interleave_callbacks(stream->rtp, rtspout_interleave_packet, sess, stream);
+		}
+	}
+
+	rtspout_send_response(ctx, sess);
+	gf_list_reset(sess->response->Transports);
+	sess->response->Session = NULL;
+	if (reset_transport_dest)
+		transport->destination = NULL;
+
+	transport->source = NULL;
+
+	if (rsp_code != NC_RTSP_OK) {
+		gf_rtsp_session_del(sess->rtsp);
+		sess->rtsp = NULL;
+		rtspout_check_last_sess(ctx);
+	}
+	return GF_OK;
+}
+
+
 static GF_Err rtspout_process_session_signaling(GF_Filter *filter, GF_RTSPOutCtx *ctx, GF_RTSPOutSession **sess_ptr)
 {
 	GF_Err e;
 	GF_RTSPOutSession *sess = *sess_ptr;
 	char *ctrl=NULL;
-	u32 stream_ctrl_id=0;
 
 	//no rtsp connection on this session
 	if (!sess->rtsp) return GF_OK;
@@ -748,14 +1281,12 @@
 	if (sess->request_pending) return GF_OK;
 
 	e = gf_rtsp_get_command(sess->rtsp, sess->command);
-	if (e==GF_IP_NETWORK_EMPTY) {
-		return GF_OK;
-	}
-	//
+	if (e==GF_IP_NETWORK_EMPTY) return GF_OK;
+
+	//delete RTSP session but not the RTP traffic
 	if (e==GF_IP_CONNECTION_CLOSED) {
 		gf_rtsp_session_del(sess->rtsp);
 		sess->rtsp = NULL;
-		rtspout_check_last_sess(ctx);
 		return GF_OK;
 	}
 	if (e)
@@ -805,8 +1336,9 @@
 			sess->rtsp = NULL;
 			sess->command = NULL;
 			memcpy(a_sess->peer_address, sess->peer_address, sizeof(char)*GF_MAX_IP_NAME_LEN);
-			rtspout_del_session(sess);
-			*sess_ptr = sess = a_sess;
+			rtspout_del_session(NULL, sess);
+			sess = a_sess;
+			*sess_ptr = NULL;
 			break;
 		}
 	}
@@ -828,22 +1360,74 @@
 		sess->response->Public = NULL;
 		return GF_OK;
 	}
+	if (!strcmp(sess->command->method, GF_RTSP_GET_PARAMETER)
+		|| !strcmp(sess->command->method, GF_RTSP_SET_PARAMETER)
+	) {
+		gf_rtsp_response_reset(sess->response);
+		sess->response->ResponseCode = NC_RTSP_Invalid_parameter;
+		sess->response->CSeq = sess->command->CSeq;
+		rtspout_send_response(ctx, sess);
+		return GF_OK;
+	}
+	if (!strcmp(sess->command->method, GF_RTSP_ANNOUNCE) || !strcmp(sess->command->method, GF_RTSP_RECORD)) {
+		gf_rtsp_response_reset(sess->response);
+		sess->response->ResponseCode = NC_RTSP_Not_Implemented;
+		sess->response->CSeq = sess->command->CSeq;
+		rtspout_send_response(ctx, sess);
+		return GF_OK;
+	}
+	if (!strcmp(sess->command->method, GF_RTSP_REDIRECT)) {
+		gf_rtsp_response_reset(sess->response);
+		sess->response->ResponseCode = NC_RTSP_Method_Not_Allowed;
+		sess->response->CSeq = sess->command->CSeq;
+		rtspout_send_response(ctx, sess);
+		return GF_OK;
+	}
+
 
 	//process describe
-	if (!strcmp(sess->command->method, GF_RTSP_DESCRIBE)) {
+	if (!strcmp(sess->command->method, GF_RTSP_DESCRIBE)
+		|| (!sess->service_name && !sess->sessionID && !strcmp(sess->command->method, GF_RTSP_SETUP))
+	) {
 		u32 rsp_code = NC_RTSP_OK;
+		u32 mcast_mode=MCAST_OFF;
+		Bool is_setup = !strcmp(sess->command->method, GF_RTSP_SETUP);
+
 		char *res_path = NULL;
 		if (sess->command->service_name) {
 			res_path = strstr(sess->command->service_name, "://");
 			if (res_path) res_path = strchr(res_path+3, '/');
 			if (res_path) res_path++;
 		}
+		if (is_setup && res_path) {
+			ctrl = strrchr(res_path, '/');
+			if (!ctrl) {
+				gf_rtsp_response_reset(sess->response);
+				sess->response->ResponseCode = NC_RTSP_Bad_Request;
+				sess->response->CSeq = sess->command->CSeq;
+				rtspout_send_response(ctx, sess);
+				return GF_OK;
+			}
+			ctrl0 = 0;
+		}
 
-		if (res_path && (ctx->mcast==MCAST_MIRROR) ) {
+		if (res_path) {
+			mcast_mode = ctx->mcast;
+			//check if we have a running multicast for this resource setup after authentication
 			GF_RTSPOutSession *a_sess = rtspout_locate_mcast(ctx, res_path);
-			if (a_sess) {
+			if (a_sess && (a_sess->mcast_mode==MCAST_ON)) {
+				mcast_mode = MCAST_MIRROR;
+			}
+			if ((mcast_mode==MCAST_MIRROR) && a_sess) {
 				sess->mcast_mirror = a_sess;
-				rtspout_send_sdp(sess);
+				if (is_setup) {
+					gf_rtsp_response_reset(sess->response);
+					sess->response->ResponseCode = NC_RTSP_Method_Not_Allowed;
+					sess->response->CSeq = sess->command->CSeq;
+					rtspout_send_response(ctx, sess);
+				} else {
+					rtspout_send_sdp(sess);
+				}
 				return GF_OK;
 			}
 		}
@@ -860,10 +1444,20 @@
 			}
 		}
 		else if ((res_path0 == '?') || (res_path0 == '@') ) {
-			if (!ctx->dynurl) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTSP client %s wants dynamic services, not enabled\n", sess->peer_address));
-				rsp_code = NC_RTSP_Forbidden;
+			Bool ok = GF_FALSE;
+			if (ctx->dynurl) {
+				ok = GF_TRUE;
 			} else {
+				rtspout_get_local_res_path(ctx, NULL, sess->command, &rsp_code, &mcast_mode);
+				if (rsp_code==NC_RTSP_OK) ok = GF_TRUE;
+				else if (rsp_code==NC_RTSP_Not_Found) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("RTSP client %s wants dynamic services, not enabled\n", sess->peer_address));
+					rsp_code = NC_RTSP_Forbidden;
+				}
+			}
+
+			if (ok) {
+				char *mcast_sname = NULL;
 				GF_List *paths = gf_list_new();
 				rsp_code = NC_RTSP_OK;
 				res_path++;
@@ -876,19 +1470,19 @@
 						sep_c = sep0;
 						sep0 = 0;
 					}
-
-					if (!strstr(res_path, "://")) {
-						src_url = rtspout_get_local_res_path(ctx, res_path);
-						if (src_url) gf_list_add(paths, src_url);
-						else
-							rsp_code = NC_RTSP_Not_Found;
+					if (!strncmp(res_path, "name=", 5)) {
+						if (!mcast_sname) mcast_sname = gf_strdup(res_path+5);
+					} else if (!strchr(res_path, ':')) {
+						src_url = rtspout_get_local_res_path(ctx, res_path, sess->command, &rsp_code, &mcast_mode);
+					} else if (gf_filter_is_supported_source(filter, res_path, NULL)) {
+						src_url = gf_strdup(res_path);
+					} else if (gf_filter_url_is_filter(filter, res_path, NULL)) {
+						src_url = gf_strdup(res_path);
 					} else {
-						if (gf_filter_is_supported_source(filter, res_path, NULL)) {
-							src_url = gf_strdup(res_path);
-							gf_list_add(paths, src_url);
-						} else {
-							rsp_code = NC_RTSP_Service_Unavailable;
-						}
+						rsp_code = NC_RTSP_Service_Unavailable;
+					}
+					if (src_url) {
+						gf_list_add(paths, src_url);
 					}
 
 					if (!sep) break;
@@ -909,10 +1503,10 @@
 					gf_free(src_url);
 				}
 				gf_list_del(paths);
+				sess->mcast_sname = mcast_sname;
 			}
 		} else {
-			rsp_code = NC_RTSP_Not_Found;
-			char *src_url = rtspout_get_local_res_path(ctx, res_path);
+			char *src_url = rtspout_get_local_res_path(ctx, res_path, sess->command, &rsp_code, &mcast_mode);
 			if (src_url) {
 				rsp_code = NC_RTSP_OK;
 				//load media service
@@ -931,18 +1525,38 @@
 			gf_rtsp_response_reset(sess->response);
 			sess->response->ResponseCode = rsp_code;
 			sess->response->CSeq = sess->command->CSeq;
+			if (rsp_code==NC_RTSP_Unauthorized) {
+				sess->response->WWW_Authenticate = gf_strdup("Basic");
+			}
 			rtspout_send_response(ctx, sess);
 			return GF_OK;
 		}
+		if (ctrl) ctrl0 = '/';
+
+		if (is_setup && ctrl) {
+			sess->setup_ctrl = gf_strdup(ctrl);
+		}
 
 		if (sess->sdp_state==SDP_LOADED) {
 			//single session, create SDP
+			if (is_setup) {
+				return rtspout_process_setup(ctx, sess, ctrl);
+			}
 			rtspout_send_sdp(sess);
 			return GF_OK;
 		}
 		//store cseq and wait for SDP to be loadable
 		sess->last_cseq = sess->command->CSeq;
 		sess->request_pending = GF_TRUE;
+		sess->mcast_mode = mcast_mode;
+		return GF_OK;
+	}
+
+	if (!sess->service_name) {
+		gf_rtsp_response_reset(sess->response);
+		sess->response->ResponseCode = NC_RTSP_Bad_Request;
+		sess->response->CSeq = sess->command->CSeq;
+		rtspout_send_response(ctx, sess);
 		return GF_OK;
 	}
 
@@ -967,154 +1581,17 @@
 	} else {
 		ctrl = strrchr(sess->command->service_name, '/');
 	}
-	if (ctrl) {
-		sscanf(ctrl, "/trackID=%d", &stream_ctrl_id);
-	}
 
 	//process setup
 	if (!strcmp(sess->command->method, GF_RTSP_SETUP)) {
-	 	char remoteIPGF_MAX_IP_NAME_LEN;
-		GF_RTPOutStream *stream = NULL;
-		GF_RTSPTransport *transport = gf_list_get(sess->command->Transports, 0);
-		u32 rsp_code=NC_RTSP_OK;
-		Bool enable_multicast = GF_FALSE;
-		Bool reset_transport_dest = GF_FALSE;
-
-		if (!ctrl || !transport) {
-			rsp_code = NC_RTSP_Bad_Request;
-		} else if (sess->sessionID && sess->command->Session && strcmp(sess->sessionID, sess->command->Session)) {
-			rsp_code = NC_RTSP_Bad_Request;
-		} else if (sess->sessionID && !sess->command->Session) {
-			rsp_code = NC_RTSP_Not_Implemented;
-		} else {
-			u32 i, count = gf_list_count(sess->streams);
-			for (i=0; i<count; i++) {
-				stream = gf_list_get(sess->streams, i);
-				if (stream_ctrl_id==stream->ctrl_id)
-					break;
-				stream=NULL;
-			}
-			if (!stream_ctrl_id)
-				rsp_code = NC_RTSP_Not_Found;
-		}
-
-		if (!stream) {
-			gf_rtsp_response_reset(sess->response);
-			sess->response->ResponseCode = rsp_code;
-			sess->response->CSeq = sess->command->CSeq;
-			rtspout_send_response(ctx, sess);
-			return GF_OK;
-		}
-
-		gf_rtsp_response_reset(sess->response);
-		sess->response->CSeq = sess->command->CSeq;
-
-		stream->selected = GF_TRUE;
-		if (transport && (rsp_code==NC_RTSP_OK) ) {
-			if (!transport->IsInterleaved) {
-				u32 st_idx = gf_list_find(sess->streams, stream);
-				transport->port_first = ctx->firstport + 2 * st_idx;
-				transport->port_last = transport->port_first + 1;
-				if (sess->interleave)
-					rsp_code = NC_RTSP_Not_Implemented;
-			} else {
-				if (!sess->sessionID) {
-					sess->interleave = GF_TRUE;
-				} else if (!sess->interleave) {
-					rsp_code = NC_RTSP_Not_Implemented;
-				}
-			}
-			transport->SSRC = rand();
-			transport->is_sender = GF_TRUE;
-
-			if (transport->IsUnicast) {
-				if (transport->destination && gf_sk_is_multicast_address(transport->destination)) {
-					rsp_code = NC_RTSP_Bad_Request;
-				} else if (!transport->destination) {
-					transport->destination = sess->peer_address;
-					reset_transport_dest = GF_TRUE;
-				}
-				if (sess->multicast_ip)
-					rsp_code = NC_RTSP_Forbidden;
-
-				if (ctx->dst && (strstr(ctx->dst, "://127.0.0.1") || strstr(ctx->dst, "://localhost") || strstr(ctx->dst, "://::1/128") ) ) {
-					if (!reset_transport_dest && transport->destination) gf_free(transport->destination);
-					transport->destination = "127.0.0.1";
-					reset_transport_dest = GF_TRUE;
-				}
-			}
-			else {
-				if (transport->destination && !gf_sk_is_multicast_address(transport->destination)) {
-					rsp_code = NC_RTSP_Bad_Request;
-				} else {
-					if (ctx->mcast != MCAST_OFF) {
-						enable_multicast = GF_TRUE;
-						//we don't allow seting up streams on different mcast addresses
-						if (!sess->multicast_ip) {
-							sess->multicast_ip = transport->destination; //detach memory
-						}
-						transport->source = transport->destination = sess->multicast_ip;
-						reset_transport_dest = GF_TRUE;
-
-						transport->client_port_first = 0;
-						transport->client_port_last = 0;
-						if (ctx->ttl) transport->TTL = ctx->ttl;
-						if (!transport->TTL) transport->TTL = 1;
-						stream->mcast_port = transport->port_first;
-						rtspout_get_next_mcast_port(ctx, sess, &stream->mcast_port);
-						transport->port_first = stream->mcast_port;
-						transport->port_last = stream->mcast_port+1;
-					} else {
-						GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSP SETUP requests a multicast to %s, not allowed\n", transport->destination));
-						rsp_code = NC_RTSP_Forbidden;
-					}
-				}
-			}
-		}
-
-		if (rsp_code != NC_RTSP_OK) {
-			sess->response->ResponseCode = rsp_code;
-		} else {
-			e = gf_rtp_streamer_init_rtsp(stream->rtp, ctx->mtu, transport, ctx->ifce);
-			if (e) {
-				sess->response->ResponseCode = NC_RTSP_Internal_Server_Error;
-			} else {
-				if (!sess->sessionID)
-					sess->sessionID = gf_rtsp_generate_session_id(sess->rtsp);
-
-				sess->response->ResponseCode = NC_RTSP_OK;
-				sess->response->Session = sess->sessionID;
-				if (!enable_multicast) {
-					gf_rtsp_get_session_ip(sess->rtsp, remoteIP);
-					if (!reset_transport_dest && transport->destination) gf_free(transport->destination);
-					transport->destination = NULL;
-					transport->source = remoteIP;
-				}
-				gf_list_add(sess->response->Transports, transport);
-			}
-		}
-
-
-		if (sess->interleave) {
-			stream->rtp_id = transport->rtpID;
-			stream->rtcp_id = transport->rtcpID;
-			gf_rtp_streamer_set_interleave_callbacks(stream->rtp, rtspout_interleave_packet, sess, stream);
-		}
-
-		rtspout_send_response(ctx, sess);
-		gf_list_reset(sess->response->Transports);
-		sess->response->Session = NULL;
-		if (reset_transport_dest)
-			transport->destination = NULL;
-
-		transport->source = NULL;
-		return GF_OK;
+		return rtspout_process_setup(ctx, sess, ctrl);
 	}
 
 	//process play
 	if (!strcmp(sess->command->method, GF_RTSP_PLAY)) {
 		Double start_range=-1;
 		u32 rsp_code=NC_RTSP_OK;
+		u32 stream_ctrl_id = rtspout_get_ctrl_id(sess, ctrl);
 		if (sess->sessionID && sess->command->Session && strcmp(sess->sessionID, sess->command->Session)) {
 			rsp_code = NC_RTSP_Bad_Request;
 		} else if (!sess->command->Session || !sess->sessionID) {
@@ -1184,19 +1661,63 @@
 
 		rtspout_send_event(sess, GF_TRUE, GF_FALSE, 0);
 
-		rtspout_del_session(sess);
-		rtspout_check_last_sess(ctx);
-		*sess_ptr = NULL;
+		if (ctx->dst) {
+			rtspout_del_session(filter, sess);
+			rtspout_check_last_sess(ctx);
+			*sess_ptr = NULL;
+		}
+		//keep session and setup small timeout - this speeds up seek by avoiding reloading the media source
+		else {
+			if (sess->sessionID) {
+				gf_free(sess->sessionID);
+				sess->sessionID = NULL;
+			}
+			sess->last_active_time = gf_sys_clock() - ctx->ms_timeout + 2000;
+		}
 		return GF_OK;
 	}
 	return GF_OK;
 }
 
+void rtspout_merge_http_tunnel(GF_Filter *filter, GF_RTSPOutCtx *ctx, GF_RTSPOutSession *sess)
+{
+	u32 i, count;
+	char sipGF_MAX_IP_NAME_LEN;
+	const char *session_cookie = gf_rtsp_get_session_cookie(sess->rtsp);
+	gf_rtsp_get_session_ip(sess->rtsp, sip);
+	if (!session_cookie) {
+		rtspout_del_session(NULL, sess);
+		return;
+	}
+	count = gf_list_count(ctx->sessions);
+	for (i=0; i<count; i++) {
+		GF_RTSPOutSession *a_sess = gf_list_get(ctx->sessions, i);
+		if (!a_sess->rtsp) continue;
+		char a_sipGF_MAX_IP_NAME_LEN;
+		const char *a_session_cookie = gf_rtsp_get_session_cookie(sess->rtsp);
+		if (!a_session_cookie) continue;
+		if (strcmp(a_session_cookie, session_cookie)) continue;
+		gf_rtsp_get_session_ip(sess->rtsp, a_sip);
+		if (strcmp(a_sip, sip)) continue;
+
+		GF_Err e = gf_rtsp_merge_tunnel(a_sess->rtsp, sess->rtsp);
+		if (e) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSPOut Failed to setup HTTP tunnel session from host %s: %s\n", sip, gf_error_to_string(e)));
+			rtspout_del_session(filter, a_sess);
+		} else {
+			a_sess->is_tunnel = GF_TRUE;
+		}
+		rtspout_del_session(NULL, sess);
+		return;
+	}
+	GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSPOut Invalid HTTP tunnel session from host %s, discarding session\n", sip));
+	rtspout_del_session(NULL, sess);
+}
 
 static GF_Err rtspout_process(GF_Filter *filter)
 {
 	GF_Err e=GF_OK;
-	u32 i, count;
+	u32 i, count, now;
 	GF_RTSPOutCtx *ctx = gf_filter_get_udta(filter);
 
 	if (ctx->done)
@@ -1208,48 +1729,79 @@
 		e = GF_OK;
 	}
 
+	now = gf_sys_clock();
 	count = gf_list_count(ctx->sessions);
 	for (i=0; i<count; i++) {
 		GF_Err sess_err;
 		GF_RTSPOutSession *sess = gf_list_get(ctx->sessions, i);
+		if (!sess) break;
+
 		sess_err = rtspout_process_session_signaling(filter, ctx, &sess);
+		if ((s32)sess_err == GF_RTSP_TUNNEL_POST) {
+			gf_list_rem(ctx->sessions, i);
+			rtspout_merge_http_tunnel(filter, ctx, sess);
+			i--;
+			count--;
+			continue;
+		}
 		if (sess_err) e |= sess_err;
+		if (!sess) break;
 
-		if (sess && sess->play_state) {
+		if (sess->play_state==1) {
 			sess_err = rtspout_process_rtp(filter, ctx, sess);
 			if (sess_err) e |= sess_err;
 		}
+
+		if (ctx->runfor>0) {
+			s64 diff = gf_sys_clock_high_res();
+			diff -= sess->sys_clock_at_init;
+			diff /= 1000;
+			if ((s32) diff > ctx->runfor) {
+				rtspout_del_session(filter, sess);
+				e = GF_EOS;
+				ctx->done = GF_TRUE;
+				break;
+			}
+		}
+
+		if (sess->last_active_time && ctx->ms_timeout && (now > sess->last_active_time + ctx->ms_timeout)) {
+			GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSP Timeout on session %s after %d ms, aborting\n", sess->service_name, now-sess->last_active_time));
+			rtspout_del_session(filter, sess);
+			i--;
+			count--;
+		}
 	}
+	if (!count && ctx->dst)
+		return GF_EOS;
 
 	if (e==GF_EOS) {
-		if (ctx->dst) return GF_EOS;
+		if (ctx->dst)
+			return GF_EOS;
 		e=GF_OK;
 	}
-
-	if (ctx->next_wake_us)
+	//server mode, post task
+	if (!ctx->dst)
+		gf_filter_post_process_task(filter);
+	if (ctx->next_wake_us) {
 		gf_filter_ask_rt_reschedule(filter, ctx->next_wake_us);
-
+	}
 	return e;
 }
 
 static GF_FilterProbeScore rtspout_probe_url(const char *url, const char *mime)
 {
 	if (!strnicmp(url, "rtsp://", 7)) return GF_FPROBE_SUPPORTED;
+	if (!strnicmp(url, "rtsph://", 8)) return GF_FPROBE_SUPPORTED;
+	if (!strnicmp(url, "rtsps://", 8)) return GF_FPROBE_SUPPORTED;
 	return GF_FPROBE_NOT_SUPPORTED;
 }
 
 static const GF_FilterCapability RTSPOutCaps =
 {
-	//anything else (not file and framed) result in manifest PID
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE),
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
-
-	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "sdp"),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "application/sdp"),
 	{0},
-	//anything else (not file and framed) result in media pids not file
 	CAP_UINT(GF_CAPS_INPUT_EXCLUDED | GF_CAPFLAG_LOADED_FILTER, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED | GF_CAPFLAG_LOADED_FILTER, GF_PROP_PID_UNFRAMED, GF_TRUE),
 };
@@ -1275,8 +1827,9 @@
 	{ OFFS(mounts), "list of directories to expose in server mode", GF_PROP_STRING_LIST, NULL, NULL, 0},
 	{ OFFS(block_size), "block size used to read TCP socket", GF_PROP_UINT, "10000", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(maxc), "maximum number of connections", GF_PROP_UINT, "100", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(timeout), "timeout in seconds for inactive sessions (0 disable timeout)", GF_PROP_UINT, "20", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(user_agent), "user agent string, by default solved from GPAC preferences", GF_PROP_STRING, "$GUA", NULL, 0},
-	{ OFFS(close), "close RTSP connection after each request, except when RTP over RTSP is used", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(close), "close RTSP connection after each request, except when RTP over RTSP is used", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(loop), "loop all streams in session (not always possible depending on source type)", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(dynurl), "allow dynamic service assembly", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(mcast), "control multicast setup of a session\n"
@@ -1284,7 +1837,14 @@
 				"- on: clients can create multicast sessions\n"
 				"- mirror: clients can create a multicast session. Any later request to the same URL will use that multicast session"
 		, GF_PROP_UINT, "off", "off|on|mirror", GF_FS_ARG_HINT_EXPERT},
-
+	{ OFFS(quit), "exit server once first session is over (for test purposes)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(htun), "enable RTSP over HTTP tunnel", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(trp), "transport mode\n"
+	"- both: allow TCP or UDP traffic\n"
+	"- udp: only allow UDP traffic\n"
+	"- tcp: only allow TCP traffic", GF_PROP_UINT, "both", "both|udp|tcp", GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(cert), "certificate file in PEM format to use for TLS mode", GF_PROP_STRING, NULL, NULL, 0},
+	{ OFFS(pkey), "private key file in PEM format to use for TLS mode", GF_PROP_STRING, NULL, NULL, 0},
 	{0}
 };
 
@@ -1298,25 +1858,58 @@
 		"The server only runs on TCP, and handles request in sequence: it will not probe for commands until previous response is sent.\n"
 		"The server supports both RTP over UDP delivery and RTP interleaved over RTSP delivery.\n"
 		"\n"
+		"The scheduling algorithm and RTP options are the same as the RTP output filter, see gpac -h rtpout(rtpout)\n"
+		"The server will disconnect UDP streaming sessions if no RTCP traffic has been received for -timeout() seconds.\n"
+		"\n"
+		"The server can run over TLS by specifying -cert() and -pkey(), in which case the default -port() is 322.\n"
+		"\n"
+		"# Sink mode\n"
 		"The filter can work as a simple output filter by specifying the -dst() option:\n"
 		"EX gpac -i source -o rtsp://myip/sessionname\n"
 		"EX gpac -i source -o rtsp://myip/sessionname\n"
 		"In this mode, only one session is possible. It is possible to -loop() the input source(s).\n"
 		"\n"
+		"# Server mode\n"
 		"The filter can work as a regular RTSP server by specifying the -mounts() option to indicate paths of media file to be served:\n"
 		"EX gpac rtspout:mounts=mydir1,mydir2\n"
-		"In server mode, it is possible to load any source supported by gpac by setting the option -dynurl().\n"
+		"In this case, content `RES` from any of the specified directory is exposed as `rtsp://SERVER/RES`\n"
+		"\n"
+		"The -mounts() option can also specify access rule file(s), see `gpac -h creds`. When rules are used:\n"
+		"- if a directory has a `name` rule, it will be used in the URL\n"
+		"- otherwise, the directory is directly available under server root `/`\n"
+		"- only read access and multicast rights are checked\n"
+		"EX foodir\n"
+		"EX name=bar\n"
+		"Content `RES` of this directory is exposed as `rtsp://SERVER/bar/RES`.\n"
+		" \n"
+		"\n"
+		"In this mode, it is possible to load any source supported by gpac by setting the option -dynurl().\n"
 		"The expected syntax of the dynamic RTSP URLs is `rtsp://servername/?URL1&URLN` or `rtsp://servername/@URL1@URLN` \n"
 		"Each URL can be absolute or local, in which case it is resolved against the mount point(s).\n"
 		"EX gpac -i rtsp://localhost/?pipe://mynamepipe&myfile.mp4 dst filters\n"
 		"The server will resolve this URL in a new session containing streams from `myfile.mp4` and streams from pipe `mynamepipe`.\n"
 		"When setting -runfor() in server mode, the server will exit at the end of the last session being closed.\n"
 		"\n"
+		"The parameter `name=VAL` is reserved to assign a session name in case multicast mirroring is used.\n"
+		"EX gpac -i rtsp://localhost/?name=live?pipe://mynamepipe&myfile.mp4 dst filters\n"
+		"\n"
+		"Usage of dynamic URLs can also be configured using the specific directory `$dynurl` in an access rule file.\n"
+		"EX$dynurl\n"
+		"ru=foo\n"
+		"This will allow dynamic URLs only for `foo` user.\n"
+		"\n"
+		"Note: If the -dynurl() is set, it is enabled for all users, without authentication.\n"
+		"\n"
+		"# Multicasting\n"
 		"In both modes, clients can setup multicast if the -mcast() option is `on` or `mirror`.\n"
 		"When -mcast() is set to `mirror` mode, any DESCRIBE command on a resource already delivered through a multicast session will use that multicast.\n"
 		"Consequently, only DESCRIBE methods are processed for such sessions, other methods will return Unauthorized.\n"
 		"\n"
-		"The scheduling algorithm and RTP options are the same as the RTP output filter, see gpac -h rtpout(rtpout)\n"
+		"In server mode, multicast can be enabled per read directory using the `mcast` access rule of the directory configuration - see `gpac -h creds`.\n"
+		"\n"
+		"# HTTP Tunnel\n"
+		"The server mode supports handling RTSP over HTTP tunnel by default. This can be disabled using -htun().\n"
+		"The tunnel conforms to QT specification, and only HTTP 1.0 and 1.1 tunnels are supported.\n"
 	)
 	.private_size = sizeof(GF_RTSPOutCtx),
 	.max_extra_pids = -1,
@@ -1332,6 +1925,9 @@
 
 const GF_FilterRegister *rtspout_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+		gf_opts_set_key("temp_out_proto", RTSPOutRegister.name, "rtsp,rtsph,rtsps");
+	}
 	return &RTSPOutRegister;
 }

gpac-2.0.0.tar.gz/src/filters/out_sock.c -> gpac-2.2.0.tar.gz/src/filters/out_sock.c Changed

@@ -177,6 +177,7 @@
 	} else {
 		return GF_NOT_SUPPORTED;
 	}
+	if (gf_filter_is_temporary(filter)) return GF_OK;
 
 	//skip ://
 	url = strchr(ctx->dst, ':');
@@ -262,6 +263,8 @@
 	pck_data = gf_filter_pck_get_data(pck, &pck_size);
 	if (pck_data) {
 		e = gf_sk_send(dst_sock, pck_data, pck_size);
+		if ((e==GF_IP_CONNECTION_CLOSED) || (e==GF_URL_REMOVED)) return GF_IP_CONNECTION_CLOSED;
+
 		if (e) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("SockOut Write error: %s\n", gf_error_to_string(e) ));
 		}
@@ -314,7 +317,6 @@
 	return GF_OK;
 }
 
-
 static GF_Err sockout_process(GF_Filter *filter)
 {
 	GF_Err e;
@@ -447,20 +449,10 @@
 		}
 		ctx->pck_pending = GF_FALSE;
 
-		if (!nb_clients) {
-			//client disconnected, drop packet if needed
-			if (ctx->had_clients && !ctx->kp) {
-				if (is_pck_ref) {
-					gf_filter_pck_unref(pck);
-					ctx->rev_pck = NULL;
-				} else {
-					gf_filter_pid_drop_packet(ctx->pid);
-				}
-			}
-			return GF_OK;
-		}
 		for (i=0; i<nb_clients; i++) {
 			GF_SockOutClient *sc = gf_list_get(ctx->clients, i);
+			if (!sc->socket) continue;
+
 			if (!sc->is_tuned) {
 
 			}
@@ -470,16 +462,45 @@
 			sc->pck_pending = GF_FALSE;
 
 			e = sockout_send_packet(ctx, pck, sc->socket);
+			if (e==GF_IP_CONNECTION_CLOSED) {
+				gf_sk_del(sc->socket);
+				sc->socket = NULL;
+				gf_list_rem(ctx->clients, i);
+				gf_free(sc);
+				i--;
+				nb_clients--;
+				continue;
+			}
 			if (e == GF_BUFFER_TOO_SMALL) {
 				sc->pck_pending = GF_TRUE;
 				ctx->pck_pending = GF_TRUE;
 			}
 		}
+
+		if (!nb_clients) {
+			//client disconnected, drop packet if needed
+			if (ctx->had_clients && !ctx->kp) {
+				if (is_pck_ref) {
+					gf_filter_pck_unref(pck);
+					ctx->rev_pck = NULL;
+				} else {
+					gf_filter_pid_drop_packet(ctx->pid);
+				}
+			}
+			return GF_OK;
+		}
 		if (ctx->pck_pending) return GF_OK;
 
 	} else {
 		e = sockout_send_packet(ctx, pck, ctx->socket);
 		if (e == GF_BUFFER_TOO_SMALL) return GF_OK;
+		if (e==GF_IP_CONNECTION_CLOSED) {
+			GF_FilterEvent evt;
+			GF_FEVT_INIT(evt, GF_FEVT_STOP, ctx->pid);
+			gf_filter_pid_send_event(ctx->pid, &evt);
+			gf_sk_del(ctx->socket);
+			ctx->socket = NULL;
+		}
 	}
 
 	ctx->nb_pck_processed++;
@@ -584,12 +605,20 @@
 	.initialize = sockout_initialize,
 	.finalize = sockout_finalize,
 	.configure_pid = sockout_configure_pid,
-	.process = sockout_process
+	.process = sockout_process,
+	.flags = GF_FS_REG_TEMP_INIT
 };
 
 
 const GF_FilterRegister *sockout_register(GF_FilterSession *session)
 {
+	if (gf_opts_get_bool("temp", "get_proto_schemes")) {
+#ifdef GPAC_HAS_SOCK_UN
+		gf_opts_set_key("temp_out_proto", SockOutRegister.name, "tcp,udp,tcpu,udpu");
+#else
+		gf_opts_set_key("temp_out_proto", SockOutRegister.name, "tcp,udp");
+#endif
+	}
 	return &SockOutRegister;
 }

gpac-2.0.0.tar.gz/src/filters/out_video.c -> gpac-2.2.0.tar.gz/src/filters/out_video.c Changed

@@ -56,12 +56,13 @@
 static char *default_glsl_vertex = "\
 	attribute vec4 gfVertex;\n\
 	attribute vec4 gfTexCoord;\n\
+	uniform mat4 gfModViewProjMatrix;\n\
 	uniform mat4 gfTextureMatrix;\n\
 	uniform bool hasTextureMatrix;\n\
 	varying vec2 TexCoord;\n\
 	void main(void)\n\
 	{\n\
-		gl_Position = gl_ModelViewProjectionMatrix * gfVertex;\n\
+		gl_Position = gfModViewProjMatrix * gfVertex;\n\
 		if (hasTextureMatrix) {\n\
 			TexCoord = vec2(gfTextureMatrix * gfTexCoord);\n\
 		} else {\n\
@@ -89,20 +90,21 @@
 	FLIP_BOTH2,
 };
 
+static u32 nb_vout_inst=0;
 
 typedef struct
 {
 	//options
 	char *drv;
 	GF_VideoOutMode disp;
-	Bool vsync, linear, fullscreen, drop, hide, step;
+	Bool vsync, linear, fullscreen, drop, hide, step, vjs, async;
 	GF_Fraction64 dur;
 	Double speed, hold;
 	u32 back, vflip, vrot;
 	GF_PropVec2i wsize, owsize;
 	GF_PropVec2i wpos;
 	Double start;
-	u32 buffer, mbuffer, rbuffer;
+	u32 buffer, mbuffer, rbuffer, wid;
 	GF_Fraction vdelay;
 	const char *out;
 	GF_PropUIntList dumpframes;
@@ -110,6 +112,7 @@
 	GF_PropVec4i olwnd;
 	GF_PropVec2i olsize;
 	GF_PropData oldata;
+	Double media_offset;
 
 	GF_Filter *filter;
 	GF_FilterPid *pid;
@@ -135,8 +138,9 @@
 	//if source is raw live grab (webcam/etc), we don't trust cts and always draw the frame
 	//this is needed for cases where we have a sudden jump in timestamps as is the case with ffmpeg: not doing so would
 	//hold the frame until its CTS is reached, triggering drops at capture time
-	Bool raw_grab;
-
+	u32 raw_grab;
+	GF_DisplayOrientationType screen_orientation;
+	
 #ifdef VOUT_USE_OPENGL
 	GLint glsl_program;
 	GF_SHADERID vertex_shader;
@@ -178,6 +182,7 @@
 
 	Bool force_reconfig_pid;
 	u32 pid_vflip, pid_vrot;
+	Bool too_slow;
 } GF_VideoOutCtx;
 
 static GF_Err vout_draw_frame(GF_VideoOutCtx *ctx);
@@ -188,6 +193,7 @@
 static void vout_make_gl_current(GF_VideoOutCtx *ctx)
 {
 	GF_Event evt;
+	memset(&evt, 0, sizeof(GF_Event));
 	evt.type = GF_EVENT_SET_GL;
 	ctx->video_out->ProcessEvent(ctx->video_out, &evt);
 }
@@ -239,15 +245,26 @@
 static void vout_set_caption(GF_VideoOutCtx *ctx)
 {
 	GF_Event evt;
+	const GF_PropertyValue *p;
 	memset(&evt, 0, sizeof(GF_Event));
 	evt.type = GF_EVENT_SET_CAPTION;
-	evt.caption.caption = gf_filter_pid_orig_src_args(ctx->pid, GF_FALSE);
-	if (!evt.caption.caption) evt.caption.caption = gf_filter_pid_get_source_filter_name(ctx->pid);
-	if (evt.caption.caption) {
+
+	evt.caption.caption = "GPAC "GPAC_VERSION;
+	if (ctx->pid) {
+		p = gf_filter_pid_get_property_str(ctx->pid, "title");
+		evt.caption.caption = p ? p->value.string : NULL;
+
+		if (!evt.caption.caption) evt.caption.caption = gf_filter_pid_orig_src_args(ctx->pid, GF_FALSE);
+		if (!evt.caption.caption) evt.caption.caption = gf_filter_pid_get_source_filter_name(ctx->pid);
+
 		if (!strncmp(evt.caption.caption, "src=", 4)) evt.caption.caption += 4;
 		if (!strncmp(evt.caption.caption, "./", 2)) evt.caption.caption += 2;
-		ctx->video_out->ProcessEvent(ctx->video_out, &evt);
 	}
+	char sep_c = gf_filter_get_sep(ctx->filter, GF_FS_SEP_ARGS);
+	char *sep = strchr(evt.caption.caption, sep_c);
+	if (sep) sep0 = 0;
+	ctx->video_out->ProcessEvent(ctx->video_out, &evt);
+	if (sep) sep0 = sep_c;
 }
 
 static GF_Err resize_video_output(GF_VideoOutCtx *ctx, u32 dw, u32 dh)
@@ -371,7 +388,7 @@
 		return GF_OK;
 	}
 	assert(!ctx->pid || (ctx->pid==pid));
-	if (!gf_filter_pid_check_caps(pid))
+	if (pid && !gf_filter_pid_check_caps(pid))
 		return GF_NOT_SUPPORTED;
 
 	w = h = pfmt = timescale = stride = 0;
@@ -414,7 +431,7 @@
 	}
 	
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_RAWGRAB);
-	ctx->raw_grab = (p && p->value.boolean) ? GF_TRUE : GF_FALSE;
+	ctx->raw_grab = p ? p->value.uint : 0;
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_COLR_RANGE);
 	full_range = (p && p->value.boolean) ? GF_TRUE : GF_FALSE;
@@ -494,6 +511,7 @@
 		load_gl_tx_matrix(ctx);
 		return GF_OK;
 	}
+
 	ctx->full_range = full_range;
 	ctx->cmx = cmx;
 	if (ctx->c_w && ctx->c_h) {
@@ -534,6 +552,9 @@
 		ctx->display_width = ctx->wsize.x;
 		ctx->display_height = ctx->wsize.y;
 		ctx->display_changed = GF_TRUE;
+	} else {
+		//force program matrix recompute
+		ctx->display_changed = GF_TRUE;
 	}
 
 	ctx->owsize.x = ctx->display_width;
@@ -636,6 +657,7 @@
 	case GF_PIXEL_YUYV:
 	case GF_PIXEL_YVYU:
 	case GF_PIXEL_VYUY:
+	case GF_PIXEL_V210:
 		ctx->uv_w = ctx->width/2;
 		ctx->uv_h = ctx->height;
 		if (!ctx->uv_stride) {
@@ -644,17 +666,16 @@
 		}
 		ctx->is_yuv = GF_TRUE;
 		break;
-	case GF_PIXEL_YUV444_PACK:
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
+		ctx->has_alpha = GF_TRUE;
+	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
 	case GF_PIXEL_YUV444_10_PACK:
 		ctx->uv_w = ctx->width;
 		ctx->uv_h = ctx->height;
 		ctx->uv_stride = ctx->stride;
 		ctx->is_yuv = GF_TRUE;
-		if (ctx->pfmt==GF_PIXEL_YUVA444_PACK) {
-			ctx->has_alpha = GF_TRUE;
-			//ctx->pfmt = GF_PIXEL_YUV444;
-		}
 		break;
 
 	case GF_PIXEL_ALPHAGREY:
@@ -681,28 +702,23 @@
 		//not yet set, happens with some decoders/stream settings - wait until first frame is available and PF is known
 		return GF_OK;
 	default:
-		GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("VideoOut Pixel format %s unknown\n", gf_4cc_to_str(ctx->pfmt)));
+		GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("VideoOut Pixel format %s not supported\n", gf_pixel_fmt_name(ctx->pfmt) ));
 		return GF_OK;
 	}
 
 #ifdef VOUT_USE_OPENGL
-	if (ctx->disp<MODE_2D) {
-		memset(&evt, 0, sizeof(GF_Event));
-		evt.type = GF_EVENT_SET_GL;
-		ctx->video_out->ProcessEvent(ctx->video_out, &evt);
+	if (ctx->glsl_program) {
+		vout_make_gl_current(ctx);
+		DEL_SHADER(ctx->vertex_shader);
+		DEL_SHADER(ctx->fragment_shader);
+		DEL_PROGRAM(ctx->glsl_program );
+		gf_gl_txw_reset(&ctx->tx);
 	}
-	
-	vout_make_gl_current(ctx);
-	DEL_SHADER(ctx->vertex_shader);
-	DEL_SHADER(ctx->fragment_shader);
-	DEL_PROGRAM(ctx->glsl_program );
-	gf_gl_txw_reset(&ctx->tx);
 
 	if (ctx->disp<MODE_2D) {
 		char *frag_shader_src = NULL;
-		GF_Matrix mx;
-		Float ft_hw, ft_hh;
 
+		GL_CHECK_ERR()
 		ctx->glsl_program = glCreateProgram();
 		ctx->vertex_shader = glCreateShader(GL_VERTEX_SHADER);
 		vout_compile_shader(ctx->vertex_shader, "vertex", default_glsl_vertex);
@@ -710,7 +726,18 @@
 		ctx->fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
 		gf_gl_txw_setup(&ctx->tx, ctx->pfmt, ctx->width, ctx->height, ctx->stride, ctx->uv_stride, ctx->linear, NULL, ctx->full_range, ctx->cmx);
 
+		GL_CHECK_ERR()
+
+#ifdef GPAC_USE_GLES2
+		gf_dynstrcat(&frag_shader_src, "#version 100\n"\
+			"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"\
+			"precision highp float;\n"\
+			"#else\n"\
+			"precision mediump float;\n"\
+			"#endif\n", NULL);
+#else
 		gf_dynstrcat(&frag_shader_src, "#version 120\n", NULL);
+#endif
 
 		gf_gl_txw_insert_fragment_shader(ctx->tx.pix_fmt, "maintx", &frag_shader_src, GF_FALSE);
 		gf_dynstrcat(&frag_shader_src, "varying vec2 TexCoord;\n"
@@ -739,16 +766,6 @@
 		glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
 		glViewport(0, 0, ctx->width, ctx->height);
 
-		gf_mx_init(mx);
-		ft_hw = ((Float)ctx->width)/2;
-		ft_hh = ((Float)ctx->height)/2;
-		gf_mx_ortho(&mx, -ft_hw, ft_hw, -ft_hh, ft_hh, 50, -50);
-		glMatrixMode(GL_PROJECTION);
-		glLoadMatrixf(mx.m);
-
-		glMatrixMode(GL_MODELVIEW);
-		glLoadIdentity();
-
 		glClear(GL_DEPTH_BUFFER_BIT);
 		glDisable(GL_NORMALIZE);
 		glDisable(GL_DEPTH_TEST);
@@ -766,6 +783,8 @@
 
 		load_gl_tx_matrix(ctx);
 
+		ctx->num_textures = ctx->tx.nb_textures;
+
 	} else
 #endif //VOUT_USE_OPENGL
 	{
@@ -820,6 +839,7 @@
 				gf_filter_pid_send_event(ctx->pid, &fevt);
 			}
 		}
+		ctx->screen_orientation = evt->size.orientation;
 		break;
 	case GF_EVENT_CLICK:
 	case GF_EVENT_MOUSEUP:
@@ -866,6 +886,12 @@
 		GF_FEVT_INIT(fevt, GF_FEVT_USER, ctx->pid);
 		fevt.user_event.event = *evt;
 		break;
+	case GF_EVENT_QUIT:
+		if (evt->show.window_id && (nb_vout_inst>1)) {
+			gf_filter_remove(ctx->filter);
+			return GF_FALSE;
+		}
+		break;
 	}
 	if (gf_filter_ui_event(ctx->filter, evt))
 		return GF_TRUE;
@@ -898,6 +924,8 @@
 GF_VideoOutput *gf_filter_claim_opengl_provider(GF_Filter *filter);
 Bool gf_filter_unclaim_opengl_provider(GF_Filter *filter, GF_VideoOutput *vout);
 
+void gf_filter_load_script(GF_Filter *filter, const char *js_file, const char *filters_blacklist);
+
 static GF_Err vout_initialize(GF_Filter *filter)
 {
 	const char *sOpt;
@@ -938,15 +966,15 @@
 
 	os_wnd_handler = os_disp_handler = NULL;
 	init_flags = 0;
-	sOpt = gf_opts_get_key("Temp", "OSWnd");
+	sOpt = gf_opts_get_key("temp", "window-handle");
 	if (sOpt) sscanf(sOpt, "%p", &os_wnd_handler);
-	sOpt = gf_opts_get_key("Temp", "OSDisp");
+	sOpt = gf_opts_get_key("temp", "window-display");
 	if (sOpt) sscanf(sOpt, "%p", &os_disp_handler);
-	sOpt = gf_opts_get_key("Temp", "InitFlags");
+	sOpt = gf_opts_get_key("temp", "window-flags");
 	if (sOpt) sscanf(sOpt, "%d", &init_flags);
 
 	if (ctx->hide)
-		init_flags |= GF_TERM_INIT_HIDE;
+		init_flags |= GF_VOUT_INIT_HIDE;
 
 	e = ctx->video_out->Setup(ctx->video_out, os_wnd_handler, os_disp_handler, init_flags);
 	if (e!=GF_OK) {
@@ -985,7 +1013,23 @@
 	}
 #endif
 
+	ctx->width = ctx->display_width = 320;
+	ctx->height = ctx->display_height = 240;
+	ctx->owsize.x = ctx->display_width;
+	ctx->owsize.y = ctx->display_height;
+	ctx->display_changed = GF_TRUE;
+	ctx->wid = ctx->video_out->window_id;
 	gf_filter_set_event_target(filter, GF_TRUE);
+
+	gf_filter_post_process_task(filter);
+
+	//load js on first vout only
+	if (ctx->vjs && !nb_vout_inst) {
+		gf_filter_load_script(filter, "$GSHARE/scripts/vout.js", "compositor");
+	}
+	nb_vout_inst++;
+
+	vout_set_caption(ctx);
 	return GF_OK;
 }
 
@@ -1019,6 +1063,7 @@
 		ctx->video_out = NULL;
 	}
 	if (ctx->dump_buffer) gf_free(ctx->dump_buffer);
+	nb_vout_inst--;
 
 }
 
@@ -1059,6 +1104,7 @@
 	glMatrixMode(GL_TEXTURE);
 	glLoadIdentity();
 	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
 
 	glEnable(GL_TEXTURE_2D);
 	glEnable(GL_BLEND);
@@ -1125,6 +1171,21 @@
 		break;
 	}
 
+	u32 nb_rot=ctx->pid_vrot;
+	//camera grab and screen orientation is set, rotate video
+	if (ctx->raw_grab && ctx->screen_orientation) {
+		switch (ctx->screen_orientation) {
+		case GF_DISPLAY_MODE_LANDSCAPE_INV: nb_rot+=2; break;
+		case GF_DISPLAY_MODE_LANDSCAPE: break;
+		case GF_DISPLAY_MODE_PORTRAIT: nb_rot+=3; break;
+		case GF_DISPLAY_MODE_PORTRAIT_INV: nb_rot+=1; break;
+		default: break;
+		}
+		//front camera, flip along vertical (auto-mirror mode)
+		if (ctx->raw_grab == 2)
+			flip_v = GF_TRUE;
+	}
+
 	if (flip_h) {
 		GLfloat v = textureVertices0;
 		textureVertices0 = textureVertices2 = textureVertices4;
@@ -1136,7 +1197,7 @@
 		textureVertices3 = textureVertices5 = v;
 	}
 
-	for (i=0; i < ctx->pid_vrot; i++) {
+	for (i=0; i < nb_rot; i++) {
 		GLfloat vx = textureVertices0;
 		GLfloat vy = textureVertices1;
 
@@ -1192,12 +1253,15 @@
 
 		glReadPixels(0, 0, ctx->display_width, ctx->display_height, GL_RGB, GL_UNSIGNED_BYTE, ctx->dump_buffer);
 		GL_CHECK_ERR()
+		GF_Err e=GF_IO_ERR;
 		fout = gf_fopen(szFileName, "wb");
 		if (fout) {
-			gf_fwrite(ctx->dump_buffer, ctx->display_width*ctx->display_height*3, fout);
+			u32 dsize = ctx->display_width*ctx->display_height*3;
+			if (gf_fwrite(ctx->dump_buffer, dsize, fout) == dsize) e = GF_OK;
 			gf_fclose(fout);
-		} else {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("VideoOut Error writing frame %d buffer to %s\n", ctx->nb_frames, szFileName));
+		}
+		if (e) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("VideoOut Error writing frame %d buffer to %s: %s\n", ctx->nb_frames, szFileName, gf_error_to_string(e) ));
 		}
 	}
 }
@@ -1209,7 +1273,6 @@
 		ctx->tx.internal_textures = GF_FALSE;
 	}
 	ctx->tx.frame_ifce = hwf;
-	gf_gl_txw_bind(&ctx->tx, "maintx", ctx->glsl_program, 0);
 
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
@@ -1228,6 +1291,7 @@
 	GF_FilterFrameInterface *frame_ifce;
 
 	vout_make_gl_current(ctx);
+	glUseProgram(ctx->glsl_program);
 
 	if (ctx->display_changed) {
 		u32 v_w, v_h;
@@ -1245,6 +1309,17 @@
 			v_w = w;
 			v_h = h;
 		}
+		if (ctx->raw_grab && ctx->screen_orientation) {
+			switch (ctx->screen_orientation) {
+			case GF_DISPLAY_MODE_PORTRAIT:
+			case GF_DISPLAY_MODE_PORTRAIT_INV:
+				v_w = h;
+				v_h = w;
+				break;
+			default:
+				break;
+			}
+		}
 
 		//if we fill width to display width and height is outside
 		if (ctx->display_width * v_h / v_w > ctx->display_height) {
@@ -1266,11 +1341,34 @@
 			gf_free(ctx->dump_buffer);
 			ctx->dump_buffer = NULL;
 		}
+		gf_mx_init(mx);
+		hw = ((Float)ctx->display_width)/2;
+		hh = ((Float)ctx->display_height)/2;
+		gf_mx_ortho(&mx, -hw, hw, -hh, hh, 10, -5);
+
+		int loc = glGetUniformLocation(ctx->glsl_program, "gfModViewProjMatrix");
+		if (loc>=0)
+			glUniformMatrix4fv(loc, 1, GL_FALSE, mx.m);
 
 		ctx->display_changed = GF_FALSE;
+
+		//also load proj matrix for overlay draw
+		glMatrixMode(GL_PROJECTION);
+		glLoadMatrixf(mx.m);
+		glMatrixMode(GL_MODELVIEW);
 	}
 
 	glViewport(0, 0, ctx->display_width, ctx->display_height);
+	if (ctx->has_alpha) {
+		Float r, g, b;
+		r = GF_COL_R(ctx->back); r /= 255;
+		g = GF_COL_G(ctx->back); g /= 255;
+		b = GF_COL_B(ctx->back); b /= 255;
+		glClearColor(r, g, b, 1.0);
+	} else {
+		glClearColor(0, 0, 0, 1.0);
+	}
+	glClear(GL_COLOR_BUFFER_BIT);
 
 	if (!pck)
 		goto exit;
@@ -1283,26 +1381,6 @@
 		goto exit;
 	}
 
-	gf_mx_init(mx);
-	hw = ((Float)ctx->display_width)/2;
-	hh = ((Float)ctx->display_height)/2;
-	gf_mx_ortho(&mx, -hw, hw, -hh, hh, 10, -5);
-	glMatrixMode(GL_PROJECTION);
-	glLoadMatrixf(mx.m);
-
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-
-	if (ctx->has_alpha) {
-		Float r, g, b;
-		r = GF_COL_R(ctx->back); r /= 255;
-		g = GF_COL_G(ctx->back); g /= 255;
-		b = GF_COL_B(ctx->back); b /= 255;
-		glClearColor(r, g, b, 1.0);
-	} else {
-		glClearColor(0, 0, 0, 1.0);
-	}
-	glClear(GL_COLOR_BUFFER_BIT);
 
 	//we are not sure if we are the only ones using the gl context, reset our defaults
 	glDisable(GL_LIGHTING);
@@ -1323,8 +1401,6 @@
 		glClear(GL_COLOR_BUFFER_BIT);
 	}
 
-	glUseProgram(ctx->glsl_program);
-
 	if (frame_ifce && frame_ifce->get_gl_texture) {
 		vout_draw_gl_hw_textures(ctx, frame_ifce);
 	} else {
@@ -1336,10 +1412,11 @@
 		//and draw
 		vout_draw_gl_quad(ctx, GF_FALSE);
 	}
-	glUseProgram(0);
 
 exit:
 
+	glUseProgram(0);
+
 	//we don't lock since most of the time overlay is not set
 	if (ctx->oldata.ptr && (ctx->olsize.x>0) && (ctx->olsize.y>0)) {
 		// overlay is set, lock filter to make sure the data is still valid
@@ -1513,7 +1590,8 @@
 			if (fout) {
 				u32 i;
 				for (i=0; i<backbuffer.height; i++) {
-					gf_fwrite(backbuffer.video_buffer + i*backbuffer.pitch_y, backbuffer.pitch_y, fout);
+					if (gf_fwrite(backbuffer.video_buffer + i*backbuffer.pitch_y, backbuffer.pitch_y, fout) != backbuffer.pitch_y)
+						e = GF_IO_ERR;
 				}
 				gf_fclose(fout);
 			} else {
@@ -1545,14 +1623,16 @@
 
 	if (ctx->force_vout) {
 		ctx->force_vout = GF_FALSE;
-		ctx->width = ctx->display_width = ctx->olwnd.z;
-		ctx->height = ctx->display_height = ctx->olwnd.w;
-		resize_video_output(ctx, ctx->width, ctx->height);
-		ctx->owsize.x = ctx->display_width;
-		ctx->owsize.y = ctx->display_height;
+		if (ctx->olwnd.z && ctx->olwnd.w) {
+			ctx->width = ctx->display_width = ctx->olwnd.z;
+			ctx->height = ctx->display_height = ctx->olwnd.w;
+			resize_video_output(ctx, ctx->width, ctx->height);
+			ctx->owsize.x = ctx->display_width;
+			ctx->owsize.y = ctx->display_height;
+		}
 	}
 	if (ctx->force_reconfig_pid) {
-		vout_configure_pid(filter, ctx->pid, GF_FALSE);
+		if (ctx->pid) vout_configure_pid(filter, ctx->pid, GF_FALSE);
 		ctx->force_reconfig_pid = GF_FALSE;
 	}
 	ctx->video_out->ProcessEvent(ctx->video_out, NULL);
@@ -1589,6 +1669,13 @@
 		//we don't lock here since we don't access the pointer
 		if (ctx->oldata.ptr && ctx->update_oldata)
 			return vout_draw_frame(ctx);
+
+		if (gf_filter_has_connect_errors(filter))
+			return GF_EOS;
+		//when we use vout+aout on audio only, we want the filter to still be active to process events
+		gf_filter_post_process_task(filter);
+		gf_filter_ask_rt_reschedule(filter, 10000);
+
 		return ctx->oldata.ptr ? GF_OK : GF_EOS;
 	}
 
@@ -1722,7 +1809,7 @@
 	if (!ctx->step && (ctx->vsync || ctx->drop)) {
 		u64 ref_clock = 0;
 		u64 cts = gf_filter_pck_get_cts(pck);
-		u64 clock_us, now = gf_sys_clock_high_res();
+		u64 clock_us=0, now = gf_sys_clock_high_res();
 		Bool check_clock = GF_FALSE;
 		GF_Fraction64 media_ts;
 		s64 delay;
@@ -1766,7 +1853,8 @@
 		}
 
 		//check if we have a clock hint from an audio output
-		gf_filter_get_clock_hint(filter, &clock_us, &media_ts);
+		if (ctx->async)
+			gf_filter_get_clock_hint(filter, &clock_us, &media_ts);
 		if (clock_us && media_ts.den) {
 			u32 safety;
 			//ref frame TS in video stream timescale
@@ -1862,8 +1950,21 @@
 				return GF_OK;
 			}
 			if (ABS(diff)>2000) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("VideoOut At %d ms frame cts "LLU"/%d is "LLD" us too %s\n", gf_sys_clock(), cts, ctx->timescale, diff<0 ? -diff : diff, diff<0 ? "early" : "late"));
+				GF_LOG((diff<0) ? GF_LOG_DEBUG : GF_LOG_INFO, GF_LOG_MMIO, ("VideoOut At %d ms frame cts "LLU"/%d is "LLD" us too %s\n", gf_sys_clock(), cts, ctx->timescale, diff<0 ? -diff : diff, diff<0 ? "early" : "late"));
+
+				if ((diff>5000000) && !ctx->too_slow) {
+					GF_Event evt;
+					evt.type = GF_EVENT_CODEC_SLOW;
+					gf_filter_ui_event(ctx->filter, &evt);
+					ctx->too_slow = GF_TRUE;
+				}
 			} else {
+				if (ctx->too_slow) {
+					GF_Event evt;
+					evt.type = GF_EVENT_CODEC_OK;
+					gf_filter_ui_event(ctx->filter, &evt);
+					ctx->too_slow = GF_FALSE;
+				}
 				diff = 0;
 			}
 
@@ -1926,6 +2027,12 @@
 		gf_filter_pck_unref(ctx->last_pck);
 	ctx->last_pck = pck;
 	ctx->nb_frames++;
+	const GF_PropertyValue *p = gf_filter_pck_get_property(pck, GF_PROP_PCK_MEDIA_TIME);
+	if (p) {
+		Double a_ts = (Double) gf_filter_pck_get_cts(pck);
+		a_ts /= ctx->timescale;
+		ctx->media_offset = a_ts - p->value.number;
+	}
 
 
 draw_frame:
@@ -1956,7 +2063,7 @@
 static GF_Err vout_draw_frame(GF_VideoOutCtx *ctx)
 {
 	ctx->force_release = GF_FALSE;
-	if ((ctx->pfmt && ctx->last_pck) || !ctx->pid) {
+	if ((ctx->pfmt && ctx->last_pck) || !ctx->pid || ctx->update_oldata) {
 #ifdef VOUT_USE_OPENGL
 		if (ctx->disp < MODE_2D) {
 			gf_rmt_begin_gl(vout_draw_gl);
@@ -2049,7 +2156,7 @@
 		}
 		return GF_OK;
 	}
-	if (!strcmp(arg_name, "vrot")) {
+	if (!strcmp(arg_name, "vrot") || !strcmp(arg_name, "vflip")) {
 		if (ctx->disp<MODE_2D)
 			ctx->force_reconfig_pid = GF_TRUE;
 		return GF_OK;
@@ -2117,6 +2224,7 @@
 	{ OFFS(dumpframes), "ordered list of frames to dump, 1 being first frame. Special value `0` means dump all frames", GF_PROP_UINT_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(out), "radical of dump frame filenames. If no extension provided, frames are exported as `$OUT_%d.PFMT`", GF_PROP_STRING, "dump", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(step), "step frame", GF_PROP_BOOL, "false", NULL, GF_ARG_HINT_HIDE|GF_FS_ARG_UPDATE},
+	{ OFFS(async), "sync video to audio output if any", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_ADVANCED},
 
 	{ OFFS(olwnd), "overlay window position and size", GF_PROP_VEC4I, NULL, NULL, GF_ARG_HINT_HIDE|GF_FS_ARG_UPDATE},
 	{ OFFS(olsize), "overlay texture size (must be RGBA)", GF_PROP_VEC2I, NULL, NULL, GF_ARG_HINT_HIDE|GF_FS_ARG_UPDATE_SYNC},
@@ -2124,6 +2232,10 @@
 	{ OFFS(owsize), "output window size (readonly)", GF_PROP_VEC2I, NULL, NULL, GF_ARG_HINT_EXPERT},
 	{ OFFS(buffer_done), "buffer done indication (readonly)", GF_PROP_BOOL, NULL, NULL, GF_ARG_HINT_EXPERT},
 	{ OFFS(rebuffer), "system time in us at which last rebuffer started, 0 if not rebuffering (readonly)", GF_PROP_LUINT, NULL, NULL, GF_ARG_HINT_EXPERT},
+	{ OFFS(vjs), "use default JS script for vout control", GF_PROP_BOOL, "true", NULL, GF_ARG_HINT_EXPERT},
+
+	{ OFFS(media_offset), "media offset (substract this value to CTS to get media time - readonly)", GF_PROP_DOUBLE, "0", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(wid), "window id (readonly)", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_EXPERT},
 
 	{ OFFS(vflip), "flip video (GL only)\n"
 		"- no: no flipping\n"
@@ -2144,7 +2256,8 @@
 static const GF_FilterCapability VideoOutCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
-	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_RAW)
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_RAW),
+	CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_ORIG_STREAM_TYPE, GF_STREAM_TEXT)
 };

gpac-2.0.0.tar.gz/src/filters/reframe_ac3.c -> gpac-2.2.0.tar.gz/src/filters/reframe_ac3.c Changed

@@ -107,7 +107,7 @@
 		if (p && p->value.string && strstr(p->value.string, "eac3")) ctx->is_eac3 = GF_TRUE;
 		else {
 			p = gf_filter_pid_get_property(pid, GF_PROP_PID_FILE_EXT);
-			if (p && p->value.string && strstr(p->value.string, "eac3")) ctx->is_eac3 = GF_TRUE;
+			if (p && p->value.string && (strstr(p->value.string, "eac3")||strstr(p->value.string, "ec3"))) ctx->is_eac3 = GF_TRUE;
 		}
 	}
 	if (ctx->is_eac3) {
@@ -211,7 +211,7 @@
 		ctx->opid = gf_filter_pid_new(filter);
 		ac3dmx_check_dur(filter, ctx);
 	}
-	if ((ctx->sample_rate == ctx->hdr.sample_rate) && (ctx->nb_ch == ctx->hdr.channels) && !ctx->copy_props) return;
+	if ((ctx->sample_rate == ctx->hdr.sample_rate) && (ctx->nb_ch == ctx->hdr.streams0.channels) && !ctx->copy_props) return;
 
 	ctx->copy_props = GF_FALSE;
 	//copy properties at init or reconfig
@@ -228,7 +228,7 @@
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CAN_DATAREF, & PROP_BOOL(GF_TRUE ) );
 
 
-	ctx->nb_ch = ctx->hdr.channels;
+	ctx->nb_ch = ctx->hdr.streams0.channels;
 	if (!ctx->timescale) {
 		//we change sample rate, change cts
 		if (ctx->cts && (ctx->sample_rate != ctx->hdr.sample_rate)) {
@@ -267,8 +267,6 @@
 		if (!ctx->is_playing) {
 			ctx->is_playing = GF_TRUE;
 			ctx->cts = 0;
-			ctx->ac3_buffer_size = 0;
-			ctx->resume_from = 0;
 		}
 		if (! ctx->is_file) {
 			return GF_FALSE;
@@ -304,6 +302,7 @@
 	case GF_FEVT_STOP:
 		//don't cancel event
 		ctx->is_playing = GF_FALSE;
+		ctx->cts = 0;
 		return GF_FALSE;
 
 	case GF_FEVT_SET_SPEED:
@@ -367,6 +366,12 @@
 			return GF_OK;
 		}
 
+		//max EAC3 frame is 4096, AC3 is 3840 - if we store more than 2 frames consider we have garbage
+		if (ctx->ac3_buffer_size>10000) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("AC3Dmx Trashing %d garbage bytes\n", ctx->ac3_buffer_size));
+			ctx->ac3_buffer_size = 0;
+		}
+
 		if (ctx->byte_offset != GF_FILTER_NO_BO) {
 			u64 byte_offset = gf_filter_pck_get_byte_offset(pck);
 			if (!ctx->ac3_buffer_size) {
@@ -390,6 +395,9 @@
 	//input pid sets some timescale - we flushed pending data , update cts
 	if (ctx->timescale && pck) {
 		cts = gf_filter_pck_get_cts(pck);
+		//init cts at first packet
+		if (!ctx->cts && (cts != GF_FILTER_NO_TS))
+			ctx->cts = cts;
 	}
 
 	if (cts == GF_FILTER_NO_TS) {
@@ -416,14 +424,18 @@
 		Bool res;
 		u32 sync_pos, bytes_to_drop=0;
 
-
 		res = ctx->ac3_parser_bs(ctx->bs, &ctx->hdr, GF_TRUE);
 
 		sync_pos = (u32) gf_bs_get_position(ctx->bs);
 
 		//startcode not found or not enough bytes, gather more
-		if (!res || (remain < sync_pos + ctx->hdr.framesize))
+		if (!res || (remain < sync_pos + ctx->hdr.framesize)) {
+			if (sync_pos && ctx->hdr.framesize) {
+				start += sync_pos;
+				remain -= sync_pos;
+			}
 			break;
+		}
 
 		ac3dmx_check_pid(filter, ctx);
 
@@ -505,7 +517,7 @@
 		ctx->ac3_buffer_size = 0;
 		return ac3dmx_process(filter);
 	} else {
-		if (remain) {
+		if (remain && (remain < ctx->ac3_buffer_size)) {
 			memmove(ctx->ac3_buffer, start, remain);
 		}
 		ctx->ac3_buffer_size = remain;
@@ -522,41 +534,88 @@
 	if (ctx->indexes) gf_free(ctx->indexes);
 }
 
-static const char *ac3dmx_probe_data(const u8 *data, u32 size, GF_FilterProbeScore *score)
+static const char *ac3dmx_probe_data(const u8 *_data, u32 _size, GF_FilterProbeScore *score)
 {
-	u32 nb_frames=0;
+	GF_AC3Config ahdr;
+	u32 i, nb_frames=0;
 	Bool has_broken_frames = GF_FALSE;
 	u32 pos=0;
+	const u8 *data = _data;
+	u32 size = _size;
+	u32 nb_ac3_frames=0;
+
+	//check AC3
 	while (1) {
-		GF_AC3Config ahdr;
-		if (! gf_ac3_parser((u8 *) data, size, &pos, &ahdr, GF_FALSE) )
+		ahdr.sample_rate = 0;
+		if (! gf_ac3_parser((u8 *) data, size, &pos, &ahdr, GF_FALSE) ) {
+			if (ahdr.sample_rate) nb_frames++;
 		 	break;
+		}
 		u32 fsize = ahdr.framesize;
 		if (pos) {
 			nb_frames=0;
 			has_broken_frames = GF_TRUE;
-			//what is before is bigger than max ac3 frame size (1920), this is packaged ac3 (mkv) at best
-			if (pos > 2000)
+			//what is before is bigger than max ac3 frame size (1920 words), this is packaged ac3 (mkv) at best
+			if (pos > 4000)
 				break;
 		}
 		nb_frames++;
-		if (fsize > size+pos) break;
+		if (fsize > size+pos) {
+			if (!pos && (nb_frames==1)) nb_frames++;
+			break;
+		}
 		if (nb_frames>4) break;
 		if (size < fsize+pos) break;
 		size -= fsize+pos;
 		data += fsize+pos;
 	}
-	if (nb_frames>2) {
+	nb_ac3_frames = nb_frames;
+
+	//check EAC3
+	pos=0;
+	data = _data;
+	size = _size;
+	nb_frames = 0;
+	GF_BitStream *bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
+	while (gf_bs_available(bs)) {
+		ahdr.sample_rate = 0;
+		if (!gf_eac3_parser_bs(bs, &ahdr, GF_FALSE)) {
+			if (ahdr.sample_rate) nb_frames++;
+			break;
+		}
+
+		if (pos != (u32) gf_bs_get_position(bs))
+			has_broken_frames = GF_TRUE;
+		nb_frames += ahdr.nb_streams;
+		for (i=0; i<ahdr.nb_streams; i++)
+			nb_frames += ahdr.streamsi.nb_dep_sub;
+		gf_bs_skip_bytes(bs, ahdr.framesize);
+		if (!pos && (nb_frames==1) && !gf_bs_available(bs)) nb_frames++;
+		pos+=ahdr.framesize;
+		if (nb_frames>4) break;
+	}
+	gf_bs_del(bs);
+
+	if (nb_frames<nb_ac3_frames) {
+		nb_frames = 0;
+	}
+	if (nb_ac3_frames>=2) {
 		*score = has_broken_frames ? GF_FPROBE_MAYBE_NOT_SUPPORTED : GF_FPROBE_SUPPORTED;
 		return "audio/ac3";
 	}
+
+	if (nb_frames>=2) {
+		*score = has_broken_frames ? GF_FPROBE_MAYBE_NOT_SUPPORTED : GF_FPROBE_SUPPORTED;
+		return "audio/eac3";
+	}
+
 	return NULL;
 }
 
 static const GF_FilterCapability AC3DmxCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "ac3|eac3"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "ac3|eac3|ec3"),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "audio/x-ac3|audio/ac3|audio/x-eac3|audio/eac3"),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_AC3),

gpac-2.0.0.tar.gz/src/filters/reframe_adts.c -> gpac-2.2.0.tar.gz/src/filters/reframe_adts.c Changed

@@ -99,6 +99,8 @@
 
 	GF_M4ADecSpecInfo acfg;
 	u32 bitrate;
+
+	Bool is_sync;
 } GF_ADTSDmxCtx;
 
 
@@ -521,6 +523,7 @@
 	case GF_FEVT_STOP:
 		//don't cancel event
 		ctx->is_playing = GF_FALSE;
+		ctx->cts = 0;
 		return GF_FALSE;
 
 	case GF_FEVT_SET_SPEED:
@@ -609,6 +612,9 @@
 	//input pid sets some timescale - we flushed pending data , update cts
 	if (ctx->timescale && pck) {
 		cts = gf_filter_pck_get_cts(pck);
+		//init cts at first packet
+		if (!ctx->cts && (cts != GF_FILTER_NO_TS))
+			ctx->cts = cts;
 	}
 
 	if (cts == GF_FILTER_NO_TS) {
@@ -677,7 +683,10 @@
 
 		//not sync !
 		if ((sync1 & 0xF0) != 0xF0) {
-			GF_LOG(ctx->nb_frames ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("ADTSDmx invalid ADTS sync bytes, resyncing\n"));
+			if (ctx->is_sync) {
+				GF_LOG(ctx->nb_frames ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("ADTSDmx invalid ADTS sync bytes, resyncing\n"));
+				ctx->is_sync=GF_FALSE;
+			}
 			ctx->nb_frames = 0;
 			goto drop_byte;
 		}
@@ -762,7 +771,10 @@
 			u32 next_frame = ctx->hdr.frame_size;
 			//make sure we are sync!
 			if ((syncnext_frame !=0xFF) || ((syncnext_frame+1 & 0xF0) !=0xF0) ) {
-				GF_LOG(ctx->nb_frames ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("ADTSDmx invalid next ADTS frame sync, resyncing\n"));
+				if (ctx->is_sync) {
+					GF_LOG(ctx->nb_frames ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("ADTSDmx invalid next ADTS frame sync, resyncing\n"));
+					ctx->is_sync = GF_FALSE;
+				}
 				ctx->nb_frames = 0;
 				goto drop_byte;
 			}
@@ -776,7 +788,8 @@
 		}
 
 		if (ctx->hdr.frame_size < ctx->hdr.hdr_size) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("ADTSDmx Corrupted ADTS frame header, resyncing\n"));
+			GF_LOG(ctx->is_sync ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("ADTSDmx Corrupted ADTS frame header, resyncing\n"));
+			ctx->is_sync = GF_FALSE;
 			ctx->nb_frames = 0;
 			goto drop_byte;
 		}
@@ -787,6 +800,7 @@
 			ctx->resume_from = 1 + ctx->adts_buffer_size - remain;
 			return GF_OK;
 		}
+		ctx->is_sync = GF_TRUE;
 
 		ctx->nb_frames++;
 		size = ctx->hdr.frame_size - ctx->hdr.hdr_size;

gpac-2.0.0.tar.gz/src/filters/reframe_amr.c -> gpac-2.2.0.tar.gz/src/filters/reframe_amr.c Changed

gpac-2.0.0.tar.gz/src/filters/reframe_av1.c -> gpac-2.2.0.tar.gz/src/filters/reframe_av1.c Changed

@@ -37,10 +37,16 @@
 } AV1Idx;
 
 typedef enum {
-	NOT_SET, /*Section 5*/
-	OBUs, /*Section 5*/
+	//input format not probed yet
+	NOT_SET,
+	//input is AV1 Section 5
+	OBUs,
+	//input is AV1 annexB
 	AnnexB,
+	//input is IVF (AV1, vpX ...)
 	IVF,
+	//input is raw VPX
+	RAW_VPX,
 	UNSUPPORTED
 } AV1BitstreamSyntax;
 
@@ -80,7 +86,6 @@
 
 	Bool is_av1;
 	Bool is_vp9;
-	Bool is_vpX;
 	u32 codecid;
 	u32 num_frames;
 	GF_VPConfig *vp_cfg;
@@ -148,6 +153,7 @@
 GF_Err av1dmx_check_format(GF_Filter *filter, GF_AV1DmxCtx *ctx, GF_BitStream *bs, u32 *last_obu_end)
 {
 	GF_Err e;
+	const GF_PropertyValue *p;
 	if (last_obu_end) (*last_obu_end) = 0;
 	//probing av1 bs mode
 	if (ctx->bsmode != NOT_SET) return GF_OK;
@@ -156,7 +162,7 @@
 	if (!ctx->state.config)
 		ctx->state.config = gf_odf_av1_cfg_new();
 
-	ctx->is_av1 = ctx->is_vp9 = ctx->is_vpX = GF_FALSE;
+	ctx->is_av1 = ctx->is_vp9 = GF_FALSE;
 	ctx->codecid = 0;
 	if (ctx->vp_cfg) gf_odf_vp_cfg_del(ctx->vp_cfg);
 	ctx->vp_cfg = NULL;
@@ -200,7 +206,6 @@
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
 		if (ctx->vp_cfg && !ctx->is_vp9) {
-			ctx->is_vpX = GF_TRUE;
 			ctx->vp_cfg->profile = 1;
 			ctx->vp_cfg->level = 10;
 			ctx->vp_cfg->bit_depth = 8;
@@ -224,7 +229,39 @@
 		ctx->file_hdr_size = (u32) gf_bs_get_position(bs);
 		if (last_obu_end) (*last_obu_end) = (u32) gf_bs_get_position(bs);
 		return GF_OK;
-	} else if (gf_media_aom_probe_annexb(bs)) {
+	}
+
+	ctx->codecid = 0;
+	p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_CODECID);
+	if (p && (p->value.uint!=GF_CODECID_AV1)) {
+		switch (p->value.uint) {
+		case GF_CODECID_VP9:
+			ctx->is_vp9 = GF_TRUE;
+		case GF_CODECID_VP8:
+		case GF_CODECID_VP10:
+			ctx->vp_cfg = gf_odf_vp_cfg_new();
+			ctx->codecid = p->value.uint;
+			if (ctx->vp_cfg && !ctx->is_vp9) {
+				ctx->vp_cfg->profile = 1;
+				ctx->vp_cfg->level = 10;
+				ctx->vp_cfg->bit_depth = 8;
+				//leave the rest as 0
+			}
+			break;
+		}
+	}
+
+	if (ctx->codecid) {
+		ctx->bsmode = RAW_VPX;
+		p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_WIDTH);
+		if (p) ctx->state.width = p->value.uint;
+		p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_HEIGHT);
+		if (p) ctx->state.height = p->value.uint;
+		return GF_OK;
+	}
+
+
+	if (gf_media_aom_probe_annexb(bs)) {
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("AV1Dmx Detected Annex B format\n"));
 		ctx->bsmode = AnnexB;
 	} else {
@@ -239,7 +276,7 @@
 			ctx->bsmode = UNSUPPORTED;
 			return e;
 		}
-		if (ctx->state.obu_type != OBU_TEMPORAL_DELIMITER) {
+		if (!ctx->timescale && (ctx->state.obu_type != OBU_TEMPORAL_DELIMITER)) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("AV1Dmx Error OBU stream start with %s, not a temporal delimiter - NOT SUPPORTED\n", gf_av1_get_obu_name(ctx->state.obu_type) ));
 			gf_filter_setup_failure(filter, e);
 			ctx->bsmode = UNSUPPORTED;
@@ -257,13 +294,33 @@
 	return GF_OK;
 }
 
+GF_Err gf_bs_set_logger(GF_BitStream *bs, void (*on_bs_log)(void *udta, const char *field_name, u32 nb_bits, u64 field_val, s32 idx1, s32 idx2, s32 idx3), void *udta);
+static void av1dmx_bs_log(void *udta, const char *field_name, u32 nb_bits, u64 field_val, s32 idx1, s32 idx2, s32 idx3)
+{
+	GF_AV1DmxCtx *ctx = (GF_AV1DmxCtx *) udta;
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, (" %s", field_name));
+	if (idx1>=0) {
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("_%d", idx1));
+		if (idx2>=0) {
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("_%d", idx2));
+			if (idx3>=0) {
+				GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("_%d", idx3));
+			}
+		}
+	}
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("=\""LLD, field_val));
+	if ((ctx->bsdbg==2) && ((s32) nb_bits > 1) )
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("(%u)", nb_bits));
+
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("\" "));
+}
 
 static void av1dmx_check_dur(GF_Filter *filter, GF_AV1DmxCtx *ctx)
 {
 	FILE *stream;
 	GF_Err e;
 	GF_BitStream *bs;
-	u64 duration, cur_dur, last_cdur, rate, max_pts, last_pts;
+	u64 duration, cur_dur, last_cdur, file_size, max_pts, last_pts, probe_size=0;
 	AV1State av1state;
 	const char *filepath=NULL;
 	const GF_PropertyValue *p;
@@ -288,12 +345,14 @@
 			p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_DOWN_SIZE);
 			if (!p || (p->value.longuint > 20000000)) {
 				GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("AV1/VP9 Source file larger than 20M, skipping indexing\n"));
+				if (!gf_sys_is_test_mode())
+					probe_size = 20000000;
 			} else {
 				ctx->index = -ctx->index;
 			}
 		}
 	}
-	if (ctx->index<=0)
+	if ((ctx->index<=0 )&& !probe_size)
 		return;
 
 	stream = gf_fopen_ex(filepath, NULL, "rb", GF_TRUE);
@@ -306,10 +365,15 @@
 	ctx->index_size = 0;
 
 	bs = gf_bs_from_file(stream, GF_BITSTREAM_READ);
+#ifndef GPAC_DISABLE_LOG
+	if (ctx->bsdbg && gf_log_tool_level_on(GF_LOG_MEDIA, GF_LOG_DEBUG))
+		gf_bs_set_logger(bs, av1dmx_bs_log, ctx);
+#endif
 
 	if (ctx->file_hdr_size) {
 		gf_bs_seek(bs, ctx->file_hdr_size);
 	}
+	file_size = gf_bs_available(bs);
 	gf_av1_init_state(&av1state);
 	av1state.skip_frames = GF_TRUE;
 	av1state.config = gf_odf_av1_cfg_new();
@@ -321,6 +385,10 @@
 		Bool is_sap=GF_FALSE;
 		u64 pts = GF_FILTER_NO_TS;
 		u64 frame_start = gf_bs_get_position(bs);
+
+		if (probe_size && (frame_start>probe_size))
+			break;
+
 		gf_av1_reset_state(&av1state, GF_FALSE);
 
 		/*we process each TU and extract only the necessary OBUs*/
@@ -339,6 +407,7 @@
 				e = gf_media_parse_ivf_frame_header(bs, &frame_size, &pts);
 				if (!e) gf_bs_skip_bytes(bs, frame_size);
 		 		is_sap = GF_TRUE;
+		 		pts *= ctx->cur_fps.den;
 			}
 			break;
 		default:
@@ -364,7 +433,7 @@
 		 	is_sap = GF_TRUE;
 
 		//only index at I-frame start
-		if (frame_start && is_sap && (cur_dur > ctx->index * ctx->cur_fps.num) ) {
+		if (!probe_size && frame_start && is_sap && (cur_dur > ctx->index * ctx->cur_fps.num) ) {
 			if (!ctx->index_alloc_size) ctx->index_alloc_size = 10;
 			else if (ctx->index_alloc_size == ctx->index_size) ctx->index_alloc_size *= 2;
 			ctx->indexes = gf_realloc(ctx->indexes, sizeof(AV1Idx)*ctx->index_alloc_size);
@@ -376,22 +445,27 @@
 			cur_dur = 0;
 		}
 	}
-	rate = gf_bs_get_position(bs);
+	if (probe_size)
+		probe_size = gf_bs_get_position(bs);
 	gf_bs_del(bs);
 	gf_fclose(stream);
 	gf_odf_av1_cfg_del(av1state.config);
 	gf_av1_reset_state(&av1state, GF_TRUE);
 
 	if (!ctx->duration.num || (ctx->duration.num * ctx->cur_fps.num != duration * ctx->duration.den)) {
+		if (probe_size) {
+			duration *= file_size / probe_size;
+		}
 		ctx->duration.num = (s32) duration;
+		if (probe_size) ctx->duration.num = -ctx->duration.num;
 		ctx->duration.den = ctx->cur_fps.num;
 
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DURATION, & PROP_FRAC64(ctx->duration));
 
 		if (ctx->duration.num && (!gf_sys_is_test_mode() || gf_opts_get_bool("temp", "force_indexing"))) {
-			rate *= 8 * ctx->duration.den;
-			rate /= ctx->duration.num;
-			ctx->bitrate = (u32) rate;
+			file_size *= 8 * ctx->duration.den;
+			file_size /= ctx->duration.num;
+			ctx->bitrate = (u32) file_size;
 		}
 	}
 }
@@ -411,7 +485,6 @@
 			ctx->cts = 0;
 		}
 		if (! ctx->is_file) {
-			ctx->buf_size = 0;
 			return GF_FALSE;
 		}
 		ctx->start_range = evt->play.start_range;
@@ -456,6 +529,8 @@
 	case GF_FEVT_STOP:
 		//don't cancel event
 		ctx->is_playing = GF_FALSE;
+		ctx->cts = 0;
+		ctx->buf_size = 0;
 		return GF_FALSE;
 
 	case GF_FEVT_SET_SPEED:
@@ -577,8 +652,9 @@
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, & PROP_UINT(GF_STREAM_VISUAL));
 
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, & PROP_UINT(ctx->codecid));
-
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, & PROP_UINT(ctx->cur_fps.num));
+	if (!ctx->timescale) {
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, & PROP_UINT(ctx->cur_fps.num));
+	}
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FPS, & PROP_FRAC(ctx->cur_fps));
 	if (ctx->state.sequence_width && ctx->state.sequence_height) {
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_WIDTH, & PROP_UINT(ctx->state.sequence_width));
@@ -646,32 +722,38 @@
 	u32 pck_size;
 	u64 frame_size = 0, pts = GF_FILTER_NO_TS;
 	GF_FilterPacket *pck;
-	u64 pos, pos_ivf_hdr;
+	u64 pos=0, pos_ivf_hdr=0;
 	u8 *output;
 
-	pos_ivf_hdr = gf_bs_get_position(ctx->bs);
-	e = gf_media_parse_ivf_frame_header(ctx->bs, &frame_size, &pts);
-	if (e) return e;
-
-	pos = gf_bs_get_position(ctx->bs);
-	if (gf_bs_available(ctx->bs) < frame_size) {
-		gf_bs_seek(ctx->bs, pos_ivf_hdr);
-		return GF_EOS;
-	}
+	if (ctx->bsmode==IVF) {
+		pos_ivf_hdr = gf_bs_get_position(ctx->bs);
+		e = gf_media_parse_ivf_frame_header(ctx->bs, &frame_size, &pts);
+		if (e) return e;
 
-	if (ctx->pts_from_file) {
-		pts += ctx->cumulated_dur;
-		if (ctx->last_pts && (ctx->last_pts>pts)) {
-			pts -= ctx->cumulated_dur;
-			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("IVF/AV1 Corrupted timestamp "LLU" less than previous timestamp "LLU", assuming concatenation\n", pts, ctx->last_pts));
-			ctx->cumulated_dur = ctx->last_pts + ctx->cur_fps.den;
-			ctx->cumulated_dur -= pts;
-			pts = ctx->cumulated_dur;
+		pos = gf_bs_get_position(ctx->bs);
+		if (gf_bs_available(ctx->bs) < frame_size) {
+			gf_bs_seek(ctx->bs, pos_ivf_hdr);
+			return GF_EOS;
 		}
-		ctx->last_pts = pts;
+		if (ctx->pts_from_file) {
+			pts *= ctx->cur_fps.den;
+			pts += ctx->cumulated_dur;
+			if (ctx->last_pts && (ctx->last_pts>pts)) {
+				pts -= ctx->cumulated_dur;
+				GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("IVF/AV1 Corrupted timestamp "LLU" less than previous timestamp "LLU", assuming concatenation\n", pts, ctx->last_pts));
+				ctx->cumulated_dur = ctx->last_pts + ctx->cur_fps.den;
+				ctx->cumulated_dur -= pts;
+				pts = ctx->cumulated_dur;
+			}
+			ctx->last_pts = pts;
+		}
+	} else {
+		//raw framed input, each packet is a frame
+		pts = ctx->src_pck ? gf_filter_pck_get_cts(ctx->src_pck) : 0;
+		pos = 0;
+		frame_size = gf_bs_available(ctx->bs);
 	}
 
-
 	//check pid state
 	av1dmx_check_pid(filter, ctx);
 
@@ -716,37 +798,45 @@
 {
 	Bool key_frame = GF_FALSE;
 	u64 frame_size = 0, pts = 0;
-	u64 pos, pos_ivf_hdr;
+	u64 pos=0, pos_ivf_hdr=0;
 	u32 width = 0, height = 0, renderWidth, renderHeight;
 	u32 num_frames_in_superframe = 0, superframe_index_size = 0, i = 0;
 	u32 frame_sizesVP9_MAX_FRAMES_IN_SUPERFRAME;
 	u8 *output;
 	GF_Err e;
 
-	pos_ivf_hdr = gf_bs_get_position(ctx->bs);
-	e = gf_media_parse_ivf_frame_header(ctx->bs, &frame_size, &pts);
-	if (e) return e;
-	if (!frame_size) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("IVF/VP9 Corrupted frame header !\n"));
-		return GF_NON_COMPLIANT_BITSTREAM;
-	}
+	if (ctx->bsmode==IVF) {
+		pos_ivf_hdr = gf_bs_get_position(ctx->bs);
+		e = gf_media_parse_ivf_frame_header(ctx->bs, &frame_size, &pts);
+		if (e) return e;
+		if (!frame_size) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("IVF/VP9 Corrupted frame header !\n"));
+			return GF_NON_COMPLIANT_BITSTREAM;
+		}
 
-	pos = gf_bs_get_position(ctx->bs);
-	if (gf_bs_available(ctx->bs) < frame_size) {
-		gf_bs_seek(ctx->bs, pos_ivf_hdr);
-		return GF_EOS;
-	}
+		pos = gf_bs_get_position(ctx->bs);
+		if (gf_bs_available(ctx->bs) < frame_size) {
+			gf_bs_seek(ctx->bs, pos_ivf_hdr);
+			return GF_EOS;
+		}
 
-	if (ctx->pts_from_file) {
-		pts += ctx->cumulated_dur;
-		if (ctx->last_pts && (ctx->last_pts>pts)) {
-			pts -= ctx->cumulated_dur;
-			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("IVF/VP9 Corrupted timestamp "LLU" less than previous timestamp "LLU", assuming concatenation\n", pts, ctx->last_pts));
-			ctx->cumulated_dur = ctx->last_pts + ctx->cur_fps.den;
-			ctx->cumulated_dur -= pts;
-			pts = ctx->cumulated_dur;
+		if (ctx->pts_from_file) {
+			pts *= ctx->cur_fps.den;
+			pts += ctx->cumulated_dur;
+			if (ctx->last_pts && (ctx->last_pts-1>pts)) {
+				pts -= ctx->cumulated_dur;
+				GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("IVF/VP9 Corrupted timestamp "LLU" less than previous timestamp "LLU", assuming concatenation\n", pts, ctx->last_pts-1));
+				ctx->cumulated_dur = ctx->last_pts-1 + ctx->cur_fps.den;
+				ctx->cumulated_dur -= pts;
+				pts = ctx->cumulated_dur;
+			}
+			ctx->last_pts = pts+1;
 		}
-		ctx->last_pts = pts;
+	} else {
+		//raw framed input, each packet is a frame
+		pts = ctx->src_pck ? gf_filter_pck_get_cts(ctx->src_pck) : 0;
+		frame_size = gf_bs_available(ctx->bs);
+		pos = 0;
 	}
 
 	/*check if it is a superframe*/
@@ -810,7 +900,6 @@
 		gf_filter_pck_set_cts(pck, ctx->cts);
 	}
 
-
 	if (key_frame) {
 		gf_filter_pck_set_sap(pck, GF_FILTER_SAP_1);
 	}
@@ -944,6 +1033,10 @@
 	//check pid state
 	av1dmx_check_pid(filter, ctx);
 
+	//fixme, we need to flush at each DFG start - for now we assume one PES = one DFG as we do in the muxer
+	if (ctx->timescale && (e==GF_BUFFER_TOO_SMALL))
+		e = GF_OK;
+
 	if (e) return e;
 
 
@@ -965,27 +1058,6 @@
 
 }
 
-GF_Err gf_bs_set_logger(GF_BitStream *bs, void (*on_bs_log)(void *udta, const char *field_name, u32 nb_bits, u64 field_val, s32 idx1, s32 idx2, s32 idx3), void *udta);
-static void av1dmx_bs_log(void *udta, const char *field_name, u32 nb_bits, u64 field_val, s32 idx1, s32 idx2, s32 idx3)
-{
-	GF_AV1DmxCtx *ctx = (GF_AV1DmxCtx *) udta;
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, (" %s", field_name));
-	if (idx1>=0) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("_%d", idx1));
-		if (idx2>=0) {
-			GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("_%d", idx2));
-			if (idx3>=0) {
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("_%d", idx3));
-			}
-		}
-	}
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("=\""LLD, field_val));
-	if ((ctx->bsdbg==2) && ((s32) nb_bits > 1) )
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("(%u)", nb_bits));
-
-	GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("\" "));
-}
-
 GF_Err av1dmx_process_buffer(GF_Filter *filter, GF_AV1DmxCtx *ctx, const char *data, u32 data_size, Bool is_copy)
 {
 	u32 last_obu_end = 0;
@@ -1277,7 +1349,7 @@
 static const GF_FilterArgs AV1DmxArgs =
 {
 	{ OFFS(fps), "import frame rate (0 default to FPS from bitstream or 25 Hz)", GF_PROP_FRACTION, "0/1000", NULL, 0},
-	{ OFFS(index), "indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 100M (slows down importers) unless a play with start range > 0 is issued", GF_PROP_DOUBLE, "-1.0", NULL, 0},
+	{ OFFS(index), "indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 20M (slows down importers) unless a play with start range > 0 is issued", GF_PROP_DOUBLE, "-1.0", NULL, 0},
 
 	{ OFFS(importer), "compatibility with old importer", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(deps), "import sample dependency information", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
@@ -1285,7 +1357,7 @@
 	{ OFFS(temporal_delim), "keep temporal delimiters in reconstructed frames", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 
 
-	{ OFFS(bsdbg), "debug NAL parsing in `parser@debug logs\n"
+	{ OFFS(bsdbg), "debug OBU parsing in `media@debug logs\n"
 		"- off: not enabled\n"
 		"- on: enabled\n"
 		"- full: enable with number of bits dumped", GF_PROP_UINT, "off", "off|on|full", GF_FS_ARG_HINT_EXPERT},

gpac-2.0.0.tar.gz/src/filters/reframe_flac.c -> gpac-2.2.0.tar.gz/src/filters/reframe_flac.c Changed

@@ -37,12 +37,14 @@
 {
 	u32 block_size;
 	u32 sample_rate;
+	u32 channels;
 } FLACHeader;
 
 typedef struct
 {
 	//filter args
 	Double index;
+	Bool docrc;
 
 	//only one input pid declared
 	GF_FilterPid *ipid;
@@ -62,7 +64,7 @@
 	Bool in_error;
 
 	Bool initialized;
-	u32 sample_rate, nb_channels, bits_per_sample, block_size;
+	u32 sample_rate, nb_channels, bits_per_sample, block_size, ch_layout;
 
 	u8 *flac_buffer;
 	u32 flac_buffer_size, flac_buffer_alloc, resume_from;
@@ -76,6 +78,7 @@
 	u32 bitrate;
 	Bool copy_props;
 	u32 dsi_crc;
+	Bool is_sync;
 } GF_FLACDmxCtx;
 
 
@@ -155,6 +158,23 @@
 	if (p && p->value.boolean) ctx->file_loaded = GF_TRUE;
 }
 
+static u64 flac_channel_layout(u32 in_lay)
+{
+	u64 ch_lay=0;
+	switch (in_lay) {
+	case 0: ch_lay = GF_AUDIO_CH_FRONT_CENTER; break;
+	case 1: ch_lay = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT; break;
+	case 2: ch_lay = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER; break;
+	case 3: ch_lay = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_REAR_SURROUND_LEFT | GF_AUDIO_CH_REAR_SURROUND_RIGHT; break;
+	case 4: ch_lay = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_REAR_SURROUND_LEFT | GF_AUDIO_CH_REAR_SURROUND_RIGHT; break;
+	case 5: ch_lay = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_REAR_SURROUND_LEFT | GF_AUDIO_CH_REAR_SURROUND_RIGHT | GF_AUDIO_CH_LFE; break;
+	case 6: ch_lay = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_SIDE_SURROUND_LEFT | GF_AUDIO_CH_SIDE_SURROUND_RIGHT | GF_AUDIO_CH_LFE | GF_AUDIO_CH_REAR_CENTER; break;
+	case 7: ch_lay = GF_AUDIO_CH_FRONT_LEFT | GF_AUDIO_CH_FRONT_RIGHT | GF_AUDIO_CH_FRONT_CENTER | GF_AUDIO_CH_SIDE_SURROUND_LEFT | GF_AUDIO_CH_SIDE_SURROUND_RIGHT | GF_AUDIO_CH_LFE | GF_AUDIO_CH_REAR_SURROUND_LEFT | GF_AUDIO_CH_REAR_SURROUND_RIGHT; break;
+	default: break;
+	}
+	return ch_lay;
+}
+
 static void flac_dmx_check_pid(GF_Filter *filter, GF_FLACDmxCtx *ctx, u8 *dsi, u32 dsi_size)
 {
 	u32 crc = gf_crc_32(dsi, dsi_size);
@@ -193,6 +213,10 @@
 	if (ctx->bitrate) {
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_BITRATE, & PROP_UINT(ctx->bitrate));
 	}
+	if (ctx->ch_layout>1) {
+		u64 layout = flac_channel_layout(ctx->ch_layout);
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CHANNEL_LAYOUT, & PROP_LONGUINT(layout));
+	}
 
 }
 
@@ -251,6 +275,7 @@
 		ctx->is_playing = GF_FALSE;
 		if (ctx->src_pck) gf_filter_pck_unref(ctx->src_pck);
 		ctx->src_pck = NULL;
+		ctx->cts = 0;
 		//don't cancel event
 		return GF_FALSE;
 
@@ -320,6 +345,51 @@
 	return crc;
 }
 
+
+static const u32 flac_dmx_crc16_table256 = {
+	0x0000, 0x0580, 0x0F80, 0x0A00, 0x1B80, 0x1E00, 0x1400, 0x1180,
+	0x3380, 0x3600, 0x3C00, 0x3980, 0x2800, 0x2D80, 0x2780, 0x2200,
+	0x6380, 0x6600, 0x6C00, 0x6980, 0x7800, 0x7D80, 0x7780, 0x7200,
+	0x5000, 0x5580, 0x5F80, 0x5A00, 0x4B80, 0x4E00, 0x4400, 0x4180,
+	0xC380, 0xC600, 0xCC00, 0xC980, 0xD800, 0xDD80, 0xD780, 0xD200,
+	0xF000, 0xF580, 0xFF80, 0xFA00, 0xEB80, 0xEE00, 0xE400, 0xE180,
+	0xA000, 0xA580, 0xAF80, 0xAA00, 0xBB80, 0xBE00, 0xB400, 0xB180,
+	0x9380, 0x9600, 0x9C00, 0x9980, 0x8800, 0x8D80, 0x8780, 0x8200,
+	0x8381, 0x8601, 0x8C01, 0x8981, 0x9801, 0x9D81, 0x9781, 0x9201,
+	0xB001, 0xB581, 0xBF81, 0xBA01, 0xAB81, 0xAE01, 0xA401, 0xA181,
+	0xE001, 0xE581, 0xEF81, 0xEA01, 0xFB81, 0xFE01, 0xF401, 0xF181,
+	0xD381, 0xD601, 0xDC01, 0xD981, 0xC801, 0xCD81, 0xC781, 0xC201,
+	0x4001, 0x4581, 0x4F81, 0x4A01, 0x5B81, 0x5E01, 0x5401, 0x5181,
+	0x7381, 0x7601, 0x7C01, 0x7981, 0x6801, 0x6D81, 0x6781, 0x6201,
+	0x2381, 0x2601, 0x2C01, 0x2981, 0x3801, 0x3D81, 0x3781, 0x3201,
+	0x1001, 0x1581, 0x1F81, 0x1A01, 0x0B81, 0x0E01, 0x0401, 0x0181,
+	0x0383, 0x0603, 0x0C03, 0x0983, 0x1803, 0x1D83, 0x1783, 0x1203,
+	0x3003, 0x3583, 0x3F83, 0x3A03, 0x2B83, 0x2E03, 0x2403, 0x2183,
+	0x6003, 0x6583, 0x6F83, 0x6A03, 0x7B83, 0x7E03, 0x7403, 0x7183,
+	0x5383, 0x5603, 0x5C03, 0x5983, 0x4803, 0x4D83, 0x4783, 0x4203,
+	0xC003, 0xC583, 0xCF83, 0xCA03, 0xDB83, 0xDE03, 0xD403, 0xD183,
+	0xF383, 0xF603, 0xFC03, 0xF983, 0xE803, 0xED83, 0xE783, 0xE203,
+	0xA383, 0xA603, 0xAC03, 0xA983, 0xB803, 0xBD83, 0xB783, 0xB203,
+	0x9003, 0x9583, 0x9F83, 0x9A03, 0x8B83, 0x8E03, 0x8403, 0x8183,
+	0x8002, 0x8582, 0x8F82, 0x8A02, 0x9B82, 0x9E02, 0x9402, 0x9182,
+	0xB382, 0xB602, 0xBC02, 0xB982, 0xA802, 0xAD82, 0xA782, 0xA202,
+	0xE382, 0xE602, 0xEC02, 0xE982, 0xF802, 0xFD82, 0xF782, 0xF202,
+	0xD002, 0xD582, 0xDF82, 0xDA02, 0xCB82, 0xCE02, 0xC402, 0xC182,
+	0x4382, 0x4602, 0x4C02, 0x4982, 0x5802, 0x5D82, 0x5782, 0x5202,
+	0x7002, 0x7582, 0x7F82, 0x7A02, 0x6B82, 0x6E02, 0x6402, 0x6182,
+	0x2002, 0x2582, 0x2F82, 0x2A02, 0x3B82, 0x3E02, 0x3402, 0x3182,
+	0x1382, 0x1602, 0x1C02, 0x1982, 0x0802, 0x0D82, 0x0782, 0x0202
+};
+
+static u32 flac_dmx_crc16(const u8 *data, u32 len)
+{
+	u32 crc = 0;
+	const u8 *end = data+len;
+ while (data < end) {
+		crc = flac_dmx_crc16_table((u8) crc) ^ *data++ ^ (crc >> 8);
+	}
+	return crc;
+}
 static u32 flac_dmx_block_sizes =
 {
 	0, 192, 576, 1152, 2304, 4608, 0, 0, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768
@@ -329,22 +399,50 @@
 	0, 88200, 176400, 192000, 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000
 };
 
+#define FLAC_CHANNELS 8
+#define FLAC_MID_SIDE 3
+
 static Bool flac_parse_header(GF_FLACDmxCtx *ctx, char *data, u32 size, FLACHeader *hdr)
 {
-	u32 block_size, sample_rate, res, top, pos, crc, crc_hdr;
+	u32 block_size, sample_rate, res, top, pos, crc, crc_hdr, ch_lay;
 
+	//we parse max frame header + first byte of subframe
+	if (size<17)
+		return GF_FALSE;
 	gf_bs_reassign_buffer(ctx->bs, data, size);
-	gf_bs_read_int(ctx->bs, 15);
+	gf_bs_mark_overflow(ctx->bs, GF_TRUE);
+	u32 sync = gf_bs_read_int(ctx->bs, 15);
+	if (sync != 0x7FFC)
+		return GF_FALSE;
+
 	/*block_strategy = */gf_bs_read_int(ctx->bs, 1);
 	block_size = gf_bs_read_int(ctx->bs, 4);
+	if (!block_size)
+		return GF_FALSE;
 	sample_rate = gf_bs_read_int(ctx->bs, 4);
-	/*u32 channel_layout = */gf_bs_read_int(ctx->bs, 4);
-	/*u32 bps = */gf_bs_read_int(ctx->bs, 3);
-	gf_bs_read_int(ctx->bs, 1);
+	if (sample_rate==0xF)
+		return GF_FALSE;
+
+	ch_lay = gf_bs_read_int(ctx->bs, 4);
+ if (ch_lay < FLAC_CHANNELS) {
+ } else if (ch_lay < FLAC_CHANNELS + FLAC_MID_SIDE) {
+ ch_lay = 1;
+ } else {
+		return GF_FALSE;
+ }
+
+
+	u32 bps = gf_bs_read_int(ctx->bs, 3);
+ if (bps == 3)
+		return GF_FALSE;
+	//reserved=0
+	if (gf_bs_read_int(ctx->bs, 1))
+		return GF_FALSE;
 
 	res = gf_bs_read_u8(ctx->bs);
 	top = (res & 128) >> 1;
-	if ((res & 0xC0) == 0x80 || (res >= 0xFE)) return GF_FALSE;
+	if ((res & 0xC0) == 0x80 || (res >= 0xFE))
+		return GF_FALSE;
 	while (res & top) {
 		s32 tmp = gf_bs_read_u8(ctx->bs);
 		tmp -= 128;
@@ -387,8 +485,26 @@
 	if (crc != crc_hdr) {
 		return GF_FALSE;
 	}
+ // subframe reserved zero bit
+ if (gf_bs_read_int(ctx->bs, 1) != 0)
+ return GF_FALSE;
+ // subframe type
+ crc = gf_bs_read_int(ctx->bs, 6);
+ if ((crc == 0) || (crc == 1)
+		|| ((crc >= 8) && (crc <= 12))
+		|| (crc >= 32)
+	) {
+	} else {
+ return GF_FALSE;
+ }
+
+	if (gf_bs_is_overflow(ctx->bs))
+		return GF_FALSE;
+
+
 	hdr->sample_rate = sample_rate;
 	hdr->block_size = block_size;
+	hdr->channels = ch_lay;
 	return GF_TRUE;
 }
 
@@ -456,6 +572,9 @@
 	//input pid sets some timescale - we flushed pending data , update cts
 	if (ctx->timescale && pck) {
 		cts = gf_filter_pck_get_cts(pck);
+		//init cts at first packet
+		if (!ctx->cts && (cts != GF_FILTER_NO_TS))
+			ctx->cts = cts;
 	}
 
 	if (cts == GF_FILTER_NO_TS) {
@@ -472,7 +591,7 @@
 		ctx->resume_from = 0;
 	}
 
-	while (remain>2) {
+	while (remain>20) {
 		u32 next_frame=0, nb_samp;
 		u32 cur_size = remain-2;
 		u8 *cur_buf = start+2;
@@ -486,12 +605,27 @@
 				hdr_start = memchr(cur_buf, 0xFF, cur_size);
 				if (!hdr_start) break;
 				next_frame = (u32) (hdr_start-start);
-				if (next_frame == remain)
+				if (next_frame + 17 >= remain) {
+					hdr_start = NULL;
 					break;
+				}
 
 				if ((hdr_start1&0xFC) == 0xF8) {
-					if (flac_parse_header(ctx, hdr_start, (u32) remain - next_frame, &hdr))
-						break;
+					if (flac_parse_header(ctx, hdr_start, (u32) remain - next_frame, &hdr)) {
+						if (!ctx->initialized)
+							break;
+
+						//no change of sample rate or channel layout, we assume this is a valid frame
+						if (!ctx->docrc && (hdr.sample_rate == ctx->sample_rate) && (hdr.channels==ctx->ch_layout))
+							break;
+						//check crc of frame
+						u32 frame_crc = flac_dmx_crc16(start, next_frame-2);
+						u32 crc_foot = startnext_frame-1;
+						crc_foot<<=8;
+						crc_foot |= startnext_frame-2;
+						if (frame_crc==crc_foot)
+							break;
+					}
 				}
 				cur_buf = hdr_start+1;
 				cur_size = (u32) (cur_buf - start);
@@ -556,6 +690,7 @@
 					gf_filter_pid_drop_packet(ctx->ipid);
 				return GF_NON_COMPLIANT_BITSTREAM;
 			}
+			ctx->ch_layout = hdr.channels;
 			flac_dmx_check_pid(filter, ctx, ctx->flac_buffer+4, dsi_end-4);
 			remain -= size;
 			start += size;
@@ -566,17 +701,26 @@
 
 		//we have a next frame, check we are synchronize
 		if ((start0 != 0xFF) && ((start1&0xFC) != 0xF8)) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("FLACDmx invalid frame, dropping %d bytes and resyncing\n", next_frame));
+			GF_LOG(ctx->is_sync ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("FLACDmx invalid frame, dropping %d bytes and resyncing\n", next_frame));
+			ctx->is_sync = GF_FALSE;
 			start += next_frame;
 			remain -= next_frame;
 			continue;
 		}
 
+		ctx->is_sync = GF_TRUE;
 		flac_parse_header(ctx,start, next_frame, &hdr);
 		if (hdr.sample_rate != ctx->sample_rate) {
 			ctx->sample_rate = hdr.sample_rate;
 			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_SAMPLE_RATE, & PROP_UINT(ctx->sample_rate));
 		}
+		if (hdr.channels != ctx->ch_layout) {
+			ctx->ch_layout = hdr.channels;
+			if (hdr.channels>1) {
+				u64 layout = flac_channel_layout(hdr.channels);
+				gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CHANNEL_LAYOUT, & PROP_LONGUINT(layout));
+			}
+		}
 
 		nb_samp = hdr.block_size;
 
@@ -682,6 +826,7 @@
 static const GF_FilterArgs FLACDmxArgs =
 {
 	{ OFFS(index), "indexing window length", GF_PROP_DOUBLE, "1.0", NULL, 0},
+	{ OFFS(docrc), "perform CRC check after each frame", GF_PROP_BOOL, "false", NULL, 0},
 	{0}
 };
 
@@ -689,7 +834,11 @@
 GF_FilterRegister FLACDmxRegister = {
 	.name = "rfflac",
 	GF_FS_SET_DESCRIPTION("FLAC reframer")
-	GF_FS_SET_HELP("This filter parses FLAC files/data and outputs corresponding audio PID and frames.")
+	GF_FS_SET_HELP("This filter parses FLAC files/data and outputs corresponding audio PID and frames.\n"
+	"\n"
+	"By default the reframer will only check CRC footer of frames if a change in sample rate or channel mapping is detected.\n"
+	"This should accomodate for most configurations, but CRC check can be enforced using -docrc().\n"
+	"")
 	.private_size = sizeof(GF_FLACDmxCtx),
 	.args = FLACDmxArgs,
 	.finalize = flac_dmx_finalize,
@@ -704,5 +853,15 @@
 
 const GF_FilterRegister *flac_dmx_register(GF_FilterSession *session)
 {
+
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) {
+		u32 v=0xFFEEDDCC;
+		flac_dmx_crc16((u8*)&v, 4);
+		flac_channel_layout(4);
+	}
+#endif
+
+
 	return &FLACDmxRegister;
 }

gpac-2.0.0.tar.gz/src/filters/reframe_h263.c -> gpac-2.2.0.tar.gz/src/filters/reframe_h263.c Changed

@@ -303,6 +303,7 @@
 	case GF_FEVT_STOP:
 		//don't cancel event
 		ctx->is_playing = GF_FALSE;
+		ctx->cts = 0;
 		return GF_FALSE;
 
 	case GF_FEVT_SET_SPEED:
@@ -509,7 +510,14 @@
 		if (current>0) {
 			if (!ctx->opid) {
 				if (ctx->bytes_in_header) {
-					ctx->bytes_in_header -= current;
+					if (ctx->bytes_in_header<(u32) current) {
+						current-=ctx->bytes_in_header;
+						ctx->bytes_in_header = 0;
+						start += current;
+						remain -= current;
+					} else {
+						ctx->bytes_in_header -= current;
+					}
 				} else {
 					start += current;
 					remain -= current;
@@ -530,8 +538,16 @@
 				if (byte_offset != GF_FILTER_NO_BO) {
 					gf_filter_pck_set_byte_offset(dst_pck, byte_offset - ctx->bytes_in_header);
 				}
-				ctx->bytes_in_header -= current;
 				memcpy(pck_data, ctx->hdr_store, current);
+				//we may have a partial startcode
+				if ((u32)current>ctx->bytes_in_header) {
+					current -= ctx->bytes_in_header;
+					start += current;
+					remain -= current;
+					ctx->bytes_in_header = 0;
+				} else {
+					ctx->bytes_in_header -= current;
+				}
 			} else {
 				if (byte_offset != GF_FILTER_NO_BO) {
 					gf_filter_pck_set_byte_offset(dst_pck, byte_offset);

gpac-2.0.0.tar.gz/src/filters/reframe_img.c -> gpac-2.2.0.tar.gz/src/filters/reframe_img.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / image (jpg/png/bmp/j2k) reframer filter
@@ -207,9 +207,6 @@
 			} else if (!stricmp(ext, "pngds")) {
 				codecid = GF_CODECID_PNG;
 				pf = GF_PIXEL_RGBDS;
-			} else if (!stricmp(ext, "pngs")) {
-				codecid = GF_CODECID_PNG;
-				pf = GF_PIXEL_RGBS;
 			} else if (!stricmp(ext, "bmp") || !strcmp(mime, "image/png")) {
 				codecid = GF_CODECID_RAW;
 			}
@@ -400,8 +397,8 @@
 static const GF_FilterCapability ReframeImgCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "jpg|jpeg|jp2|bmp|png|pngd|pngds|pngs"),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "image/jpg|image/jp2|image/bmp|image/png|image/x-png+depth|image/x-png+depth+mask|image/x-png+stereo"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "jpg|jpeg|jp2|j2k|bmp|png"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "image/jpg|image/jp2|image/bmp|image/png"),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_PNG),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_JPEG),
@@ -420,7 +417,12 @@
 GF_FilterRegister ReframeImgRegister = {
 	.name = "rfimg",
 	GF_FS_SET_DESCRIPTION("JPG/J2K/PNG/BMP reframer")
-	GF_FS_SET_HELP("This filter parses JPG/J2K/PNG/BMP files/data and outputs corresponding visual PID and frames.")
+	GF_FS_SET_HELP("This filter parses JPG/J2K/PNG/BMP files/data and outputs corresponding visual PID and frames.\n"
+	"\n"
+	"The following extensions for PNG change the pixel format for RGBA images:\n"
+	"- pngd: use RGB+depth map pixel format\n"
+	"- pngds: use RGB+depth(7bits)+shape(MSB of alpha channel) pixel format\n"
+	"")
 	.private_size = sizeof(GF_ReframeImgCtx),
 	.args = ReframeImgArgs,
 	SETCAPS(ReframeImgCaps),

gpac-2.0.0.tar.gz/src/filters/reframe_latm.c -> gpac-2.2.0.tar.gz/src/filters/reframe_latm.c Changed

@@ -30,6 +30,8 @@
 
 #ifndef GPAC_DISABLE_AV_PARSERS
 
+#define LATM_DMX_MAX_SIZE	8192
+
 typedef struct
 {
 	u64 pos;
@@ -157,7 +159,7 @@
 			size += tmp;
 			if (tmp!=255) break;
 		}
-		if (gf_bs_available(bs) < size) {
+		if ((gf_bs_available(bs) < size) || (size > LATM_DMX_MAX_SIZE)){
 			gf_bs_seek(bs, pos-3);
 			return GF_FALSE;
 		}
@@ -425,6 +427,7 @@
 	case GF_FEVT_STOP:
 		//don't cancel event
 		ctx->is_playing = GF_FALSE;
+		ctx->cts = 0;
 		return GF_FALSE;
 
 	case GF_FEVT_SET_SPEED:
@@ -490,6 +493,9 @@
 	//input pid sets some timescale - we flushed pending data , update cts
 	if (ctx->timescale && pck) {
 		cts = gf_filter_pck_get_cts(pck);
+		//init cts at first packet
+		if (!ctx->cts && (cts != GF_FILTER_NO_TS))
+			ctx->cts = cts;
 	}
 
 	prev_pck_size = ctx->latm_buffer_size;
@@ -517,8 +523,8 @@
 
 	while (1) {
 		pos = (u32) gf_bs_get_position(ctx->bs);
-		u8 latm_buffer4096;
-		u32 latm_frame_size = 4096;
+		u8 latm_bufferLATM_DMX_MAX_SIZE;
+		u32 latm_frame_size = LATM_DMX_MAX_SIZE;
 		if (!latm_dmx_sync_frame_bs(ctx->bs,&ctx->acfg, &latm_frame_size, latm_buffer, NULL)) break;
 
 		if (ctx->in_seek) {
@@ -609,7 +615,7 @@
 	while (1) {
 		u32 nb_skipped = 0;
 		if (!latm_dmx_sync_frame_bs(bs, &acfg, 0, NULL, &nb_skipped)) break;
-		if (! GF_M4ASampleRatesacfg.base_sr_index) {
+		if (acfg.base_sr_index > sizeof(GF_M4ASampleRates) / sizeof(GF_M4ASampleRates0) || GF_M4ASampleRatesacfg.base_sr_index == 0) {
 			nb_frames = 0;
 			break;
 		}
@@ -634,8 +640,8 @@
 static const GF_FilterCapability LATMDmxCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "latm"),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "audio/aac+latm"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "latm|usac|xheaac"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "audio/aac+latm|audio/xheaac+latm"),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG4),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_MP),

gpac-2.0.0.tar.gz/src/filters/reframe_mhas.c -> gpac-2.2.0.tar.gz/src/filters/reframe_mhas.c Changed

@@ -27,6 +27,8 @@
 #include <gpac/constants.h>
 #include <gpac/filters.h>
 
+#if !defined(GPAC_DISABLE_AV_PARSERS)
+
 
 static u32 USACSampleRates = {96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, 0, 0,
 	57600, 51200, 40000, 38400, 34150, 28800, 25600, 20000, 19200, 17075, 14400, 12800, 9600};
@@ -84,6 +86,7 @@
 	u32 nb_unknown_pck;
 	u32 bitrate;
 	Bool copy_props;
+	Bool is_sync;
 } GF_MHASDmxCtx;
 
 
@@ -390,6 +393,7 @@
 		ctx->is_playing = GF_FALSE;
 		if (ctx->src_pck) gf_filter_pck_unref(ctx->src_pck);
 		ctx->src_pck = NULL;
+		ctx->cts = 0;
 		//don't cancel event
 		return GF_FALSE;
 
@@ -513,6 +517,9 @@
 	//input pid sets some timescale - we flushed pending data , update cts
 	if (ctx->timescale && in_pck) {
 		cts = gf_filter_pck_get_cts(in_pck);
+		//init cts at first packet
+		if (!ctx->cts && (cts != GF_FILTER_NO_TS))
+			ctx->cts = cts;
 	}
 
 	if (cts == GF_FILTER_NO_TS) {
@@ -573,14 +580,16 @@
 		if (mhas_type>18) {
 			ctx->nb_unknown_pck++;
 			if (ctx->nb_unknown_pck > ctx->pcksync) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("MHASDmx %d packets of unknwon type, considering sync was lost\n"));
+				GF_LOG(ctx->is_sync ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("MHASDmx %d packets of unknown type, considering sync was lost\n"));
+				ctx->is_sync = GF_FALSE;
 				consumed = 0;
 				ctx->nosync = GF_TRUE;
 				ctx->nb_unknown_pck = 0;
 				break;
 			}
 		} else if (!mhas_size) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("MHASDmx MHAS packet with 0 payload size, considering sync was lost\n"));
+			GF_LOG(ctx->is_sync ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("MHASDmx MHAS packet with 0 payload size, considering sync was lost\n"));
+			ctx->is_sync = GF_FALSE;
 			consumed = 0;
 			ctx->nosync = GF_TRUE;
 			ctx->nb_unknown_pck = 0;
@@ -595,6 +604,8 @@
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("MHASDmx incomplete packet type %d %s label "LLU" size "LLU" - keeping in buffer\n", mhas_type, mhas_pck_name(mhas_type), mhas_label, mhas_size));
 			break;
 		}
+		ctx->is_sync = GF_TRUE;
+
 		//frame
 		if (mhas_type==2) {
 			mhas_sap = gf_bs_peek_bits(ctx->bs, 1, 0);
@@ -908,3 +919,11 @@
 {
 	return &MHASDmxRegister;
 }
+
+#else
+
+const GF_FilterRegister *mhas_dmx_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+#endif //#if !defined(GPAC_DISABLE_AV_PARSERS)

gpac-2.0.0.tar.gz/src/filters/reframe_mp3.c -> gpac-2.2.0.tar.gz/src/filters/reframe_mp3.c Changed

@@ -75,6 +75,8 @@
 
 	GF_FilterPid *vpid;
 	Bool copy_props;
+
+	Bool is_sync;
 } GF_MP3DmxCtx;
 
 
@@ -341,15 +343,27 @@
 
 static void mp3_dmx_check_pid(GF_Filter *filter, GF_MP3DmxCtx *ctx)
 {
-	u32 sr;
+	u32 sr, codec_id;
 
 	if (!ctx->opid) {
 		ctx->opid = gf_filter_pid_new(filter);
 		mp3_dmx_check_dur(filter, ctx);
 	}
 
+	codec_id = gf_mp3_object_type_indication(ctx->hdr);
+	switch (gf_mp3_layer(ctx->hdr)) {
+	case 3:
+		if (ctx->forcemp3) {
+			codec_id = GF_CODECID_MPEG_AUDIO;
+		}
+		break;
+	case 1:
+		codec_id = GF_CODECID_MPEG_AUDIO_L1;
+		break;
+	}
+
 	if ((ctx->sr == gf_mp3_sampling_rate(ctx->hdr)) && (ctx->nb_ch == gf_mp3_num_channels(ctx->hdr) )
-		&& (ctx->codecid == gf_mp3_object_type_indication(ctx->hdr) )
+		&& (ctx->codecid == codec_id )
 		&& !ctx->copy_props
 	)
 		return;
@@ -370,17 +384,7 @@
 	if (!ctx->timescale) gf_filter_pid_set_name(ctx->opid, "audio");
 
 	ctx->nb_ch = gf_mp3_num_channels(ctx->hdr);
-	ctx->codecid = gf_mp3_object_type_indication(ctx->hdr);
-	switch (gf_mp3_layer(ctx->hdr)) {
-	case 3:
-		if (ctx->forcemp3) {
-			ctx->codecid = GF_CODECID_MPEG_AUDIO;
-		}
-		break;
-	case 1:
-		ctx->codecid = GF_CODECID_MPEG_AUDIO_L1;
-		break;
-	}
+
 	sr = gf_mp3_sampling_rate(ctx->hdr);
 
 	if (!ctx->timescale) {
@@ -390,6 +394,7 @@
 		}
 	}
 	ctx->sr = sr;
+	ctx->codecid = codec_id;
 
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_TIMESCALE, & PROP_UINT(ctx->timescale ? ctx->timescale : sr));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_SAMPLE_RATE, & PROP_UINT(sr));
@@ -461,6 +466,7 @@
 		ctx->is_playing = GF_FALSE;
 		if (ctx->src_pck) gf_filter_pck_unref(ctx->src_pck);
 		ctx->src_pck = NULL;
+		ctx->cts = 0;
 		//don't cancel event
 		return GF_FALSE;
 
@@ -547,6 +553,9 @@
 	//input pid sets some timescale - we flushed pending data , update cts
 	if (ctx->timescale && pck) {
 		cts = gf_filter_pck_get_cts(pck);
+		//init cts at first packet
+		if (!ctx->cts && (cts != GF_FILTER_NO_TS))
+			ctx->cts = cts;
 	}
 
 	if (cts == GF_FILTER_NO_TS) {
@@ -623,7 +632,8 @@
 				if ((syncsize=='T') && (syncsize+1=='A') && (syncsize+2=='G')) {
 					skip_id3v1=GF_TRUE;
 				} else {
-					GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("MP3Dmx invalid frame, resyncing\n"));
+					GF_LOG(ctx->is_sync ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("MP3Dmx invalid frame, resyncing\n"));
+					ctx->is_sync = GF_FALSE;
 					goto drop_byte;
 				}
 			}
@@ -639,6 +649,7 @@
 			ctx->resume_from = (u32) (sync - ctx->mp3_buffer + 1);
 			return GF_OK;
 		}
+		ctx->is_sync = GF_TRUE;
 
 		nb_samp = gf_mp3_window_size(ctx->hdr);

gpac-2.0.0.tar.gz/src/filters/reframe_mpgvid.c -> gpac-2.2.0.tar.gz/src/filters/reframe_mpgvid.c Changed

@@ -30,6 +30,7 @@
 
 #ifndef GPAC_DISABLE_AV_PARSERS
 
+#define MIN_HDR_STORE	12
 typedef struct
 {
 	u64 pos;
@@ -86,6 +87,7 @@
 	MPGVidIdx *indexes;
 	u32 index_alloc_size, index_size;
 	u32 bitrate;
+	Bool trash_trailer;
 } GF_MPGVidDmxCtx;
 
 
@@ -176,11 +178,27 @@
 	GF_M4VParser *vparser;
 	GF_M4VDecSpecInfo dsi;
 	GF_Err e;
+	u32 probe_size=0;
 	u64 duration, cur_dur, rate;
 	const GF_PropertyValue *p;
 	if (!ctx->opid || ctx->timescale || ctx->file_loaded) return;
 
-	if (ctx->index<=0) {
+	if (ctx->index<0) {
+		if (gf_opts_get_bool("temp", "force_indexing")) {
+			ctx->index = 1.0;
+		} else {
+			p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_DOWN_SIZE);
+			if (!p || (p->value.longuint > 20000000)) {
+				GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("MPGVids Source file larger than 20M, skipping indexing\n"));
+				if (!gf_sys_is_test_mode())
+					probe_size = 20000000;
+			} else {
+				ctx->index = -ctx->index;
+			}
+		}
+	}
+	if ((ctx->index<=0) && !probe_size) {
+		ctx->duration.num = 1;
 		ctx->file_loaded = GF_TRUE;
 		return;
 	}
@@ -226,11 +244,14 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("MPGVid Could not parse video frame\n"));
 			continue;
 		}
+		if (probe_size && (pos>probe_size) && (ftype==1)) {
+			break;
+		}
 
 		duration += ctx->cur_fps.den;
 		cur_dur += ctx->cur_fps.den;
 		//only index at I-frame start
-		if (pos && (ftype==0) && (cur_dur >= ctx->index * ctx->cur_fps.num) ) {
+		if (!probe_size && pos && (ftype==1) && (cur_dur >= ctx->index * ctx->cur_fps.num) ) {
 			if (!ctx->index_alloc_size) ctx->index_alloc_size = 10;
 			else if (ctx->index_alloc_size == ctx->index_size) ctx->index_alloc_size *= 2;
 			ctx->indexes = gf_realloc(ctx->indexes, sizeof(MPGVidIdx)*ctx->index_alloc_size);
@@ -241,6 +262,7 @@
 			cur_dur = 0;
 		}
 	}
+
 	rate = gf_bs_get_position(bs);
 	gf_m4v_parser_del(vparser);
 	gf_fclose(stream);
@@ -265,6 +287,11 @@
 
 static void mpgviddmx_enqueue_or_dispatch(GF_MPGVidDmxCtx *ctx, GF_FilterPacket *pck, Bool flush_ref, Bool is_eos)
 {
+	if (pck && ctx->trash_trailer) {
+		gf_filter_pck_discard(pck);
+		return;
+	}
+
 	if (!is_eos && (!ctx->width || !ctx->height))
 		flush_ref = GF_FALSE;
 
@@ -450,6 +477,13 @@
 		ctx->in_seek = GF_TRUE;
 
 		if (ctx->start_range) {
+			if (ctx->index<0) {
+				ctx->index = -ctx->index;
+				ctx->file_loaded = GF_FALSE;
+				ctx->duration.den = ctx->duration.num = 0;
+				mpgviddmx_check_dur(filter, ctx);
+			}
+
 			for (i=1; i<ctx->index_size; i++) {
 				if ((ctx->indexesi.start_time > ctx->start_range) || (i+1==ctx->index_size)) {
 					ctx->cts = (u64) (ctx->indexesi-1.start_time * ctx->cur_fps.num);
@@ -485,6 +519,7 @@
 				gf_filter_pck_discard(pck);
 			}
 		}
+		ctx->cts = 0;
 		//don't cancel event
 		return GF_FALSE;
 
@@ -615,6 +650,8 @@
 		}
 
 		gf_filter_pck_get_framing(pck, &ctx->input_is_au_start, &ctx->input_is_au_end);
+		//we force it to true to deal with broken avi packaging where a video AU is split across several AVI video frames
+		ctx->input_is_au_end = GF_FALSE;
 		//this will force CTS recomput of each frame
 		if (ctx->recompute_cts) ctx->input_is_au_start = GF_FALSE;
 		if (ctx->src_pck) gf_filter_pck_unref(ctx->src_pck);
@@ -695,8 +732,8 @@
 		//if not, dispatch these bytes as continuation of the data
 		if (ctx->bytes_in_header) {
 
-			memcpy(ctx->hdr_store + ctx->bytes_in_header, start, 8 - ctx->bytes_in_header);
-			current = mpgviddmx_next_start_code(ctx->hdr_store, 8);
+			memcpy(ctx->hdr_store + ctx->bytes_in_header, start, MIN_HDR_STORE - ctx->bytes_in_header);
+			current = mpgviddmx_next_start_code(ctx->hdr_store, MIN_HDR_STORE);
 
 			//no start code in stored buffer
 			if ((current<0) || (current >= (s32) ctx->bytes_in_header) ) {
@@ -707,6 +744,7 @@
 					if (ctx->src_pck) gf_filter_pck_merge_properties(ctx->src_pck, dst_pck);
 					gf_filter_pck_set_cts(dst_pck, GF_FILTER_NO_TS);
 					gf_filter_pck_set_dts(dst_pck, GF_FILTER_NO_TS);
+					gf_filter_pck_set_sap(dst_pck, GF_FILTER_SAP_NONE);
 					memcpy(pck_data, ctx->hdr_store, ctx->bytes_in_header);
 					gf_filter_pck_set_framing(dst_pck, GF_FALSE, GF_FALSE);
 
@@ -825,10 +863,12 @@
 				current = 0;
 			}
 			gf_filter_pck_set_carousel_version(dst_pck, 1);
-
 			mpgviddmx_enqueue_or_dispatch(ctx, dst_pck, GF_FALSE, GF_FALSE);
 		}
 
+		//we're align to startcode, stop trashing packets
+		ctx->trash_trailer = GF_FALSE;
+
 		//not enough bytes to parse start code
 		if (remain<5) {
 			memcpy(ctx->hdr_store, start, remain);
@@ -943,6 +983,21 @@
 					assert(remain>=4);
 					start += 4;
 					remain -= 4;
+				} else if (!ctx->width) {
+					gf_bs_reassign_buffer(ctx->bs, start, remain);
+					PL = ctx->dsi.VideoPL;
+					e = gf_m4v_parse_config(ctx->vparser, &ctx->dsi);
+					if (ctx->dsi.width) {
+						u32 obj_size = (u32) gf_m4v_get_object_start(ctx->vparser);
+						if (vosh_start<0) vosh_start = 0;
+						vosh_end = start - (u8 *)data + obj_size;
+						vosh_end -= vosh_start;
+						mpgviddmx_check_pid(filter, ctx,(u32) vosh_end, data+vosh_start);
+						skip_pck = GF_TRUE;
+						assert(remain>=(s32) obj_size);
+						start += obj_size;
+						remain -= obj_size;
+					}
 				}
 				break;
 			}
@@ -982,8 +1037,13 @@
 		size = 0;
 		e = gf_m4v_parse_frame(ctx->vparser, &ctx->dsi, &ftype, &tinc, &size, &fstart, &is_coded);
 
-		//only for m1v/m2v, for m4v we mah have fstart>0 when we strip VO and VISOBJ
+		//only for m1v/m2v, for m4v we may have fstart>0 when we strip VO and VISOBJ
 		if (ctx->is_mpg12 && fstart && (fstart<remain)) {
+			//start code (4 bytes) in header, adjst frame start and size
+			if (sc_type_forced) {
+				fstart += 4;
+				size-=4;
+			}
 			dst_pck = gf_filter_pck_new_alloc(ctx->opid, (u32) fstart, &pck_data);
 			if (!dst_pck) return GF_OUT_OF_MEM;
 
@@ -1003,6 +1063,15 @@
 			start += fstart;
 			remain -= (s32) fstart;
 		}
+		//we may have VO or other packets before (fstart is on first of vop/gov/vol/vos)
+		else if (fstart && (fstart + size <= remain)) {
+			//start code (4 bytes) in header, adjst frame start and size
+			if (sc_type_forced) {
+				fstart += 4;
+				size-=4;
+			}
+			size += fstart;
+		}
 
 		//we skipped bytes already in store + end of start code present in packet, so the size of the first object
 		//needs adjustement
@@ -1027,45 +1096,56 @@
 			full_frame = GF_TRUE;
 		}
 
-		if (!is_coded) {
-			/*if prev is B and we're parsing a packed bitstream discard n-vop*/
-			if (ctx->forced_packed && ctx->b_frames) {
-				ctx->is_packed = GF_TRUE;
-				assert(remain>=size);
-				start += size;
-				remain -= (s32) size;
-				continue;
-			}
-			/*policy is to import at variable frame rate, skip*/
-			if (ctx->vfr) {
-				ctx->is_vfr = GF_TRUE;
-				mpgviddmx_update_time(ctx);
-				assert(remain>=size);
-				start += size;
-				remain -= (s32) size;
-				continue;
+		if (ftype) {
+			if (!is_coded) {
+				/*if prev is B and we're parsing a packed bitstream discard n-vop*/
+				if ((ctx->forced_packed && ctx->b_frames)
+					/*policy is to import at variable frame rate, skip*/
+					|| ctx->vfr
+				) {
+					if (ctx->vfr) {
+						ctx->is_vfr = GF_TRUE;
+						mpgviddmx_update_time(ctx);
+					} else {
+						ctx->is_packed = GF_TRUE;
+					}
+
+					//part of the frame was in store, adjust size
+					if (bytes_from_store)
+						size-= bytes_from_store + hdr_offset;
+
+					assert(remain>=size);
+					start += size;
+					remain -= (s32) size;
+					//trash all packets until we align to a new startcode
+					ctx->trash_trailer = full_frame ? GF_FALSE : GF_TRUE;
+					continue;
+				}
+
+				/*policy is to keep non coded frame (constant frame rate), add*/
 			}
-			/*policy is to keep non coded frame (constant frame rate), add*/
-		}
 
-		if (ftype==2) {
-			//count number of B-frames since last ref
-			ctx->b_frames++;
-			ctx->nb_b++;
+			if (ftype==3) {
+				//count number of B-frames since last ref
+				ctx->b_frames++;
+				ctx->nb_b++;
+			} else {
+				//flush all pending packets
+				mpgviddmx_enqueue_or_dispatch(ctx, NULL, GF_TRUE, GF_FALSE);
+				//remember the CTS of the last ref
+				ctx->last_ref_cts = ctx->cts;
+				if (ctx->max_b < ctx->b_frames) ctx->max_b = ctx->b_frames;
+
+				ctx->b_frames = 0;
+				if (ftype==2)
+					ctx->nb_p++;
+				else
+					ctx->nb_i++;
+			}
+			ctx->nb_frames++;
 		} else {
-			//flush all pending packets
-			mpgviddmx_enqueue_or_dispatch(ctx, NULL, GF_TRUE, GF_FALSE);
-			//remember the CTS of the last ref
-			ctx->last_ref_cts = ctx->cts;
-			if (ctx->max_b < ctx->b_frames) ctx->max_b = ctx->b_frames;
-			
-			ctx->b_frames = 0;
-			if (ftype)
-				ctx->nb_p++;
-			else
-				ctx->nb_i++;
+			full_frame = GF_FALSE;
 		}
-		ctx->nb_frames++;
 
 		dst_pck = gf_filter_pck_new_alloc(ctx->opid, (u32) size, &pck_data);
 		if (!dst_pck) return GF_OUT_OF_MEM;
@@ -1087,27 +1167,34 @@
 				gf_filter_pck_set_byte_offset(dst_pck, byte_offset + start - (u8 *) data);
 			}
 		}
-		assert(pck_data0 == 0);
-		assert(pck_data1 == 0);
-		assert(pck_data2 == 0x01);
-
-		gf_filter_pck_set_framing(dst_pck, GF_TRUE, (full_frame || ctx->input_is_au_end) ? GF_TRUE : GF_FALSE);
-		gf_filter_pck_set_cts(dst_pck, ctx->cts);
-		gf_filter_pck_set_dts(dst_pck, ctx->dts);
-		if (ctx->input_is_au_start) {
-			ctx->input_is_au_start = GF_FALSE;
-		} else {
-			//we use the carousel flag temporarly to indicate the cts must be recomputed
-			gf_filter_pck_set_carousel_version(dst_pck, 1);
-		}
-		gf_filter_pck_set_sap(dst_pck, ftype ? GF_FILTER_SAP_NONE : GF_FILTER_SAP_1);
-		if (ctx->cur_fps.den > 0) gf_filter_pck_set_duration(dst_pck, ctx->cur_fps.den);
-		if (ctx->in_seek) gf_filter_pck_set_seek_flag(dst_pck, GF_TRUE);
-		ctx->frame_started = GF_TRUE;
 
-		mpgviddmx_enqueue_or_dispatch(ctx, dst_pck, GF_FALSE, GF_FALSE);
+		if (ftype) {
+			assert(pck_data0 == 0);
+			assert(pck_data1 == 0);
+			assert(pck_data2 == 1);
+
+			gf_filter_pck_set_framing(dst_pck, GF_TRUE, (full_frame || ctx->input_is_au_end) ? GF_TRUE : GF_FALSE);
+			gf_filter_pck_set_cts(dst_pck, ctx->cts);
+			gf_filter_pck_set_dts(dst_pck, ctx->dts);
+
+			if (ctx->input_is_au_start) {
+				ctx->input_is_au_start = GF_FALSE;
+			} else {
+				//we use the carousel flag temporarly to indicate the cts must be recomputed
+				gf_filter_pck_set_carousel_version(dst_pck, 1);
+			}
+			gf_filter_pck_set_sap(dst_pck, (ftype==1) ? GF_FILTER_SAP_1 : GF_FILTER_SAP_NONE);
+			if (ctx->cur_fps.den > 0) gf_filter_pck_set_duration(dst_pck, ctx->cur_fps.den);
+			if (ctx->in_seek) gf_filter_pck_set_seek_flag(dst_pck, GF_TRUE);
+			ctx->frame_started = GF_TRUE;
 
-		mpgviddmx_update_time(ctx);
+			mpgviddmx_enqueue_or_dispatch(ctx, dst_pck, GF_FALSE, GF_FALSE);
+
+			mpgviddmx_update_time(ctx);
+		} else {
+			gf_filter_pck_set_framing(dst_pck, GF_FALSE, (full_frame || ctx->input_is_au_end) ? GF_TRUE : GF_FALSE);
+			mpgviddmx_enqueue_or_dispatch(ctx, dst_pck, GF_FALSE, GF_FALSE);
+		}
 
 		if (!full_frame) {
 			if (copy_last_bytes) {
@@ -1128,8 +1215,8 @@
 {
 	GF_MPGVidDmxCtx *ctx = gf_filter_get_udta(filter);
 	ctx->hdr_store_size = 0;
-	ctx->hdr_store_alloc = 8;
-	ctx->hdr_store = gf_malloc(sizeof(char)*8);
+	ctx->hdr_store_alloc = MIN_HDR_STORE;
+	ctx->hdr_store = gf_malloc(sizeof(char)*ctx->hdr_store_alloc);
 	return GF_OK;
 }
 
@@ -1254,7 +1341,7 @@
 static const GF_FilterCapability MPGVidDmxCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "cmp|m1v|m2v"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "cmp|m1v|m2v|m4v"),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "video/mp4v-es|video/mpgv-es"),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_MPEG4_PART2),
@@ -1284,7 +1371,7 @@
 static const GF_FilterArgs MPGVidDmxArgs =
 {
 	{ OFFS(fps), "import frame rate (0 default to FPS from bitstream or 25 Hz)", GF_PROP_FRACTION, "0/1000", NULL, 0},
-	{ OFFS(index), "indexing window length", GF_PROP_DOUBLE, "1.0", NULL, 0},
+	{ OFFS(index), "indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 20M (slows down importers) unless a play with start range > 0 is issued", GF_PROP_DOUBLE, "-1.0", NULL, 0},
 	{ OFFS(vfr), "set variable frame rate import", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(importer), "compatibility with old importer, displays import results", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(notime), "ignore input timestamps, rebuild from 0", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},

gpac-2.0.0.tar.gz/src/filters/reframe_nalu.c -> gpac-2.2.0.tar.gz/src/filters/reframe_nalu.c Changed

@@ -50,6 +50,7 @@
 {
 	u64 pos;
 	Double duration;
+	u32 roll_count;
 } NALUIdx;
 
 
@@ -102,6 +103,8 @@
 	Double start_range;
 	//indicates we are in seek, packets before start range should be marked
 	Bool in_seek;
+	u32 seek_gdr_count;
+	Bool first_gdr;
 	//set once we play something
 	Bool is_playing;
 	//is a file, is a file fully loaded on disk (local or download done)
@@ -113,7 +116,6 @@
 	NALUIdx *indexes;
 	u32 index_alloc_size, index_size;
 
-
 	//timescale of the input pid if any, 0 otherwise
 	u32 timescale;
 	//framing flag of input packet when input pid has timing (eg is not a file)
@@ -153,7 +155,7 @@
 	u32 nal_store_size, nal_store_alloc;
 
 	//list of param sets found
-	GF_List *sps, *pps, *vps, *sps_ext, *pps_svc, *vvc_aps_pre, *vvc_dci;
+	GF_List *sps, *pps, *vps, *sps_ext, *pps_svc, *vvc_aps_pre, *vvc_dci, *vvc_opi;
 	//set to true if one of the PS has been modified, will potentially trigger a PID reconfigure
 	Bool ps_modified;
 
@@ -164,8 +166,8 @@
 	Bool has_islice;
 	//AU is rap
 	GF_FilterSAPType au_sap;
-	//frame first slice
-	Bool first_slice_in_au;
+	//number of slices in frame
+	u32 nb_slices_in_au;
 	//frame first slice
 	Bool au_sap2_poc_reset;
 	//paff used - NEED FURTHER CHECKING
@@ -237,6 +239,8 @@
 	u32 clli_crc, mdcv_crc;
 
 	u32 nb_dv_rpu, nb_dv_el;
+
+	u32 valid_ps_flags;
 } GF_NALUDmxCtx;
 
 static void naludmx_enqueue_or_dispatch(GF_NALUDmxCtx *ctx, GF_FilterPacket *n_pck, Bool flush_ref);
@@ -361,7 +365,7 @@
 	}
 	if (ctx->timescale && !ctx->opid) {
 		ctx->opid = gf_filter_pid_new(filter);
-		ctx->first_slice_in_au = GF_TRUE;
+		ctx->nb_slices_in_au = 0;
 	}
 	ctx->full_au_source = GF_FALSE;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED_FULL_AU);
@@ -408,12 +412,74 @@
 	return GF_OK;
 }
 
+static u64 naludmx_next_start_code(GF_BitStream *bs, u64 offset, u64 fsize, u32 *sc_size)
+{
+	u32 pos=0, nb_zeros=0;
+	while (offset+pos<fsize) {
+		u8 b = gf_bs_read_u8(bs);
+		pos++;
+		switch (b) {
+		case 1:
+			//break at first 0xXX000001 or 0x00000001
+			if (nb_zeros>=2) {
+				*sc_size = (nb_zeros==2) ? 3 : 4;
+				return offset+pos;
+			}
+			nb_zeros = 0;
+			break;
+		case 0:
+			nb_zeros++;
+			break;
+		default:
+			nb_zeros=0;
+			break;
+		}
+	}
+	//eof
+	return 0;
+}
+
+void naludmx_probe_recovery_sei(GF_BitStream *bs, AVCState *avc)
+{
+	/*parse SEI*/
+	while (gf_bs_available(bs)) {
+		u32 ptype, psize;
+
+		ptype = 0;
+		while (1) {
+			u8 v = gf_bs_read_int(bs, 8);
+			ptype += v;
+			if (v != 0xFF) break;
+		}
+
+		psize = 0;
+		while (1) {
+			u8 v = gf_bs_read_int(bs, 8);
+			psize += v;
+			if (v != 0xFF) break;
+		}
+
+		if (ptype==6) {
+			avc->sei.recovery_point.frame_cnt = gf_bs_read_ue(bs);
+			avc->sei.recovery_point.valid = 1;
+			return;
+		}
+
+		gf_bs_skip_bytes(bs, psize);
+
+		ptype = gf_bs_peek_bits(bs, 8, 0);
+		if (ptype == 0x80) {
+			break;
+		}
+	}
+}
 
 static void naludmx_check_dur(GF_Filter *filter, GF_NALUDmxCtx *ctx)
 {
 	FILE *stream;
 	GF_BitStream *bs;
-	u64 duration, cur_dur, nal_start, start_code_pos, rate;
+	u64 duration, cur_dur, nal_start, filesize;
+	u32 probe_size=0, start_code_size;
 	AVCState *avc_state = NULL;
 	HEVCState *hevc_state = NULL;
 	VVCState *vvc_state = NULL;
@@ -438,12 +504,14 @@
 			p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_DOWN_SIZE);
 			if (!p || (p->value.longuint > 20000000)) {
 				GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("%s Source file larger than 20M, skipping indexing\n", ctx->log_name));
+				if (!gf_sys_is_test_mode())
+					probe_size = 20000000;
 			} else {
 				ctx->index = -ctx->index;
 			}
 		}
 	}
-	if (ctx->index<=0) {
+	if ((ctx->index<=0) && !probe_size) {
 		ctx->duration.num = 1;
 		ctx->file_loaded = GF_TRUE;
 		return;
@@ -477,9 +545,10 @@
 
 	bs = gf_bs_from_file(stream, GF_BITSTREAM_READ);
 	gf_bs_enable_emulation_byte_removal(bs, GF_TRUE);
+	filesize = gf_bs_available(bs);
 
-	start_code_pos = gf_bs_get_position(bs);
-	if (!gf_media_nalu_is_start_code(bs)) {
+	nal_start = naludmx_next_start_code(bs, 0, filesize, &start_code_size);
+	if (!nal_start) {
 		if (hevc_state) gf_free(hevc_state);
 		if (avc_state) gf_free(avc_state);
 		gf_bs_del(bs);
@@ -489,16 +558,13 @@
 		return;
 	}
 
-	nal_start = gf_bs_get_position(bs);
-
-	while (gf_bs_available(bs)) {
-		u32 nal_size;
+	while (1) {
 		s32 res;
+		u32 gdr_frame_count = 0;
 		Bool is_rap = GF_FALSE;
 		Bool is_slice = GF_FALSE;
-		nal_size = gf_media_nalu_next_start_code_bs(bs);
 
-		gf_bs_seek(bs, nal_start);
+		//parse directly from current pos (next byte is first byte of nal hdr)
 		if (hevc_state) {
 #ifndef GPAC_DISABLE_HEVC
 			u8 temporal_id, layer_id, nal_type;
@@ -528,26 +594,43 @@
 				is_slice = GF_TRUE;
 				break;
 			}
+			//also mark first slice in gdr as valid seek point
+			if (is_slice && hevc_state->sei.recovery_point.valid) {
+				is_rap = GF_TRUE;
+				hevc_state->sei.recovery_point.valid = GF_FALSE;
+				gdr_frame_count = hevc_state->sei.recovery_point.frame_cnt;
+			}
 #endif // GPAC_DISABLE_HEVC
 		} else if (vvc_state) {
 
+			u8 temporal_id, layer_id, nal_type;
+
+			res = gf_vvc_parse_nalu_bs(bs, vvc_state, &nal_type, &temporal_id, &layer_id);
+			if (res>0) first_slice_in_pic = GF_TRUE;
+			switch (nal_type) {
+			case GF_VVC_NALU_SLICE_TRAIL:
+			case GF_VVC_NALU_SLICE_STSA:
+			case GF_VVC_NALU_SLICE_RADL:
+			case GF_VVC_NALU_SLICE_RASL:
+				is_slice = GF_TRUE;
+				break;
+			case GF_VVC_NALU_SLICE_IDR_W_RADL:
+			case GF_VVC_NALU_SLICE_IDR_N_LP:
+			case GF_VVC_NALU_SLICE_CRA:
+			case GF_VVC_NALU_SLICE_GDR:
+				is_rap = GF_TRUE;
+				is_slice = GF_TRUE;
+				if (vvc_state->s_info.gdr_pic)
+					gdr_frame_count = vvc_state->s_info.gdr_recovery_count;
+				break;
+			}
 		} else {
 			u32 nal_type;
-			u64 pos = gf_bs_get_position(bs);
 			res = gf_avc_parse_nalu(bs, avc_state);
 			if (res>0) first_slice_in_pic = GF_TRUE;
 
 			nal_type = avc_state->last_nal_type_parsed;
-
 			switch (nal_type) {
-			case GF_AVC_NALU_SEQ_PARAM:
-				gf_bs_seek(bs, pos);
-				gf_avc_read_sps_bs(bs, avc_state, GF_FALSE, NULL);
-				break;
-			case GF_AVC_NALU_PIC_PARAM:
-				gf_bs_seek(bs, pos);
-				gf_avc_read_pps_bs(bs, avc_state);
-				break;
 			case GF_AVC_NALU_IDR_SLICE:
 				is_rap = GF_TRUE;
 				is_slice = GF_TRUE;
@@ -558,16 +641,31 @@
 			case GF_AVC_NALU_DP_C_SLICE:
 				is_slice = GF_TRUE;
 				break;
+			case GF_AVC_NALU_SEI:
+				naludmx_probe_recovery_sei(bs, avc_state);
+				break;
+			
 			}
+			//also mark open GOP or first slice in gdr as valid seek point
+			if (is_slice && avc_state->sei.recovery_point.valid) {
+				is_rap = GF_TRUE;
+				avc_state->sei.recovery_point.valid = GF_FALSE;
+				gdr_frame_count = avc_state->sei.recovery_point.frame_cnt;
+			}
+		}
+
+		if (probe_size && (nal_start>probe_size) && is_rap) {
+			break;
 		}
 
-		if (is_rap && first_slice_in_pic && (cur_dur >= ctx->index * ctx->cur_fps.num) ) {
+		if (!probe_size && is_rap && first_slice_in_pic && (cur_dur >= ctx->index * ctx->cur_fps.num) ) {
 			if (!ctx->index_alloc_size) ctx->index_alloc_size = 10;
 			else if (ctx->index_alloc_size == ctx->index_size) ctx->index_alloc_size *= 2;
 			ctx->indexes = gf_realloc(ctx->indexes, sizeof(NALUIdx)*ctx->index_alloc_size);
-			ctx->indexesctx->index_size.pos = start_code_pos;
+			ctx->indexesctx->index_size.pos = nal_start - start_code_size;
 			ctx->indexesctx->index_size.duration = (Double) duration;
 			ctx->indexesctx->index_size.duration /= ctx->cur_fps.num;
+			ctx->indexesctx->index_size.roll_count = gdr_frame_count;
 			ctx->index_size ++;
 			cur_dur = 0;
 		}
@@ -578,22 +676,15 @@
 			first_slice_in_pic = GF_FALSE;
 		}
 
-		gf_bs_seek(bs, nal_start + nal_size);
-/*		nal_start = gf_media_nalu_next_start_code_bs(bs);
-		if (nal_start) gf_bs_skip_bytes(bs, nal_start);
-*/
-		if (gf_bs_available(bs)<4)
+		//align since some NAL parsing may stop anywhere
+		gf_bs_align(bs);
+		nal_start = naludmx_next_start_code(bs, gf_bs_get_position(bs), filesize, &start_code_size);
+		if (!nal_start)
 			break;
-
-		start_code_pos = gf_bs_get_position(bs);
-		nal_start = gf_media_nalu_is_start_code(bs);
-		if (!nal_start) {
-			break;
-		}
-		nal_start = gf_bs_get_position(bs);
 	}
+	if (probe_size)
+		probe_size = (u32) gf_bs_get_position(bs);
 
-	rate = gf_bs_get_position(bs);
 	gf_bs_del(bs);
 	gf_fclose(stream);
 	if (hevc_state) gf_free(hevc_state);
@@ -601,19 +692,22 @@
 	if (avc_state) gf_free(avc_state);
 
 	if (!ctx->duration.num || (ctx->duration.num * ctx->cur_fps.num != duration * ctx->duration.den)) {
+		if (probe_size) {
+			duration *= filesize/probe_size;
+		}
 		ctx->duration.num = (s32) duration;
+		if (probe_size) ctx->duration.num = -ctx->duration.num;
 		ctx->duration.den = ctx->cur_fps.num;
 
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DURATION, & PROP_FRAC64(ctx->duration));
 
 		if (duration && (!gf_sys_is_test_mode() || gf_opts_get_bool("temp", "force_indexing"))) {
-			rate *= 8 * ctx->duration.den;
-			rate /= ctx->duration.num;
-			ctx->bitrate = (u32) rate;
+			filesize *= 8 * ctx->duration.den;
+			filesize /= ctx->duration.num;
+			ctx->bitrate = (u32) filesize;
 		}
 	}
 
-
 	p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_FILE_CACHED);
 	if (p && p->value.boolean) ctx->file_loaded = GF_TRUE;
 }
@@ -903,11 +997,15 @@
 	for (i = 0; i < vps->max_layers; i++) {
 		LHEVC_DependentLayer *dep;
 		u32 j, k;
+		if (i==MAX_LHVC_LAYERS) break;
+
 		GF_SAFEALLOC(dep, LHEVC_DependentLayer);
 		if (!dep) return GF_OUT_OF_MEM;
 
 		dep->dependent_layerID = vps->layer_id_in_nuhi;
 		for (j = 0; j < vps->max_layers; j++) {
+			if (j==MAX_LHVC_LAYERS) break;
+
 			if (vps->direct_dependency_flagdep->dependent_layerIDj) {
 				dep->dependent_on_layerIDdep->num_layers_dependent_on = j;
 				dep->num_layers_dependent_on ++;
@@ -967,7 +1065,7 @@
 	gf_filter_pid_set_info_str(ctx->opid, "hevc:linf", &PROP_DATA_NO_COPY(data, data_size) );
 }
 
-static void naludmx_create_hevc_decoder_config(GF_NALUDmxCtx *ctx, u8 **dsi, u32 *dsi_size, u8 **dsi_enh, u32 *dsi_enh_size, u32 *max_width, u32 *max_height, u32 *max_enh_width, u32 *max_enh_height, GF_Fraction *sar, Bool *has_hevc_base)
+static Bool naludmx_create_hevc_decoder_config(GF_NALUDmxCtx *ctx, u8 **dsi, u32 *dsi_size, u8 **dsi_enh, u32 *dsi_enh_size, u32 *max_width, u32 *max_height, u32 *max_enh_width, u32 *max_enh_height, GF_Fraction *sar, Bool *has_hevc_base)
 {
 #ifndef GPAC_DISABLE_HEVC
 	u32 i, count;
@@ -986,13 +1084,9 @@
 	max_ew = max_eh = 0;
 	sar->num = sar->den = 0;
 
-	hvcc = gf_odf_hevc_cfg_new();
-	lvcc = gf_odf_hevc_cfg_new();
-	hvcc->nal_unit_size = ctx->nal_length;
-	lvcc->nal_unit_size = ctx->nal_length;
-	lvcc->is_lhvc = GF_TRUE;
 	//check we have one pps or sps in base layer
 	count = gf_list_count(ctx->sps);
+	if (!count && !ctx->analyze) return GF_FALSE;
 	for (i=0; i<count; i++) {
 		GF_NALUFFParam *sl = gf_list_get(ctx->sps, i);
 		layer_id = ((sl->data0 & 0x1) << 5) | (sl->data1 >> 3);
@@ -1002,6 +1096,7 @@
 		}
 	}
 	count = gf_list_count(ctx->pps);
+	if (!count && !ctx->analyze) return GF_FALSE;
 	for (i=0; i<count; i++) {
 		GF_NALUFFParam *sl = gf_list_get(ctx->pps, i);
 		layer_id = ((sl->data0 & 0x1) << 5) | (sl->data1 >> 3);
@@ -1010,6 +1105,13 @@
 			break;
 		}
 	}
+
+	hvcc = gf_odf_hevc_cfg_new();
+	lvcc = gf_odf_hevc_cfg_new();
+	hvcc->nal_unit_size = ctx->nal_length;
+	lvcc->nal_unit_size = ctx->nal_length;
+	lvcc->is_lhvc = GF_TRUE;
+
 	//assign vps first so that they are serialized first
 	count = gf_list_count(ctx->vps);
 	for (i=0; i<count; i++) {
@@ -1133,10 +1235,11 @@
 	gf_odf_hevc_cfg_del(hvcc);
 	gf_odf_hevc_cfg_del(lvcc);
 #endif // GPAC_DISABLE_HEVC
+	return GF_TRUE;
 }
 
 
-static void naludmx_create_vvc_decoder_config(GF_NALUDmxCtx *ctx, u8 **dsi, u32 *dsi_size, u8 **dsi_enh, u32 *dsi_enh_size, u32 *max_width, u32 *max_height, u32 *max_enh_width, u32 *max_enh_height, GF_Fraction *sar, Bool *has_vvc_base)
+static Bool naludmx_create_vvc_decoder_config(GF_NALUDmxCtx *ctx, u8 **dsi, u32 *dsi_size, u8 **dsi_enh, u32 *dsi_enh_size, u32 *max_width, u32 *max_height, u32 *max_enh_width, u32 *max_enh_height, GF_Fraction *sar, Bool *has_vvc_base)
 {
 	u32 i, count;
 	u8 layer_id;
@@ -1151,11 +1254,9 @@
 	max_ew = max_eh = 0;
 	sar->num = sar->den = 0;
 
-	cfg = gf_odf_vvc_cfg_new();
-	cfg->nal_unit_size = ctx->nal_length;
-
 	//check we have one pps or sps in base layer
 	count = gf_list_count(ctx->sps);
+	if (!count && !ctx->analyze) return GF_FALSE;
 	for (i=0; i<count; i++) {
 		GF_NALUFFParam *sl = gf_list_get(ctx->sps, i);
 		layer_id = (sl->data0 & 0x3f);
@@ -1166,6 +1267,7 @@
 		}
 	}
 	count = gf_list_count(ctx->pps);
+	if (!count && !ctx->analyze) return GF_FALSE;
 	for (i=0; i<count; i++) {
 		GF_NALUFFParam *sl = gf_list_get(ctx->pps, i);
 		layer_id = (sl->data0 & 0x3f);
@@ -1175,6 +1277,11 @@
 			break;
 		}
 	}
+
+	cfg = gf_odf_vvc_cfg_new();
+	cfg->nal_unit_size = ctx->nal_length;
+
+
 	//assign vps first so that they are serialized first
 	count = gf_list_count(ctx->vps);
 	for (i=0; i<count; i++) {
@@ -1282,6 +1389,15 @@
 			naludmx_add_param_nalu(cfg->param_array, sl, GF_VVC_NALU_DEC_PARAM);
 	}
 
+	count = gf_list_count(ctx->vvc_opi);
+	for (i=0; i<count; i++) {
+		GF_NALUFFParam *sl = gf_list_get(ctx->vvc_opi, i);
+		layer_id = sl->data0 & 0x3F;
+		if (!layer_id) *has_vvc_base = GF_TRUE;
+		if (!ctx->analyze)
+			naludmx_add_param_nalu(cfg->param_array, sl, GF_VVC_NALU_OPI);
+	}
+
 	count = gf_list_count(ctx->vvc_aps_pre);
 	for (i=0; i<count; i++) {
 		GF_NALUFFParam *sl = gf_list_get(ctx->vvc_aps_pre, i);
@@ -1306,9 +1422,10 @@
 		gf_list_reset(pa->nalus);
 	}
 	gf_odf_vvc_cfg_del(cfg);
+	return GF_TRUE;
 }
 
-void naludmx_create_avc_decoder_config(GF_NALUDmxCtx *ctx, u8 **dsi, u32 *dsi_size, u8 **dsi_enh, u32 *dsi_enh_size, u32 *max_width, u32 *max_height, u32 *max_enh_width, u32 *max_enh_height, GF_Fraction *sar)
+Bool naludmx_create_avc_decoder_config(GF_NALUDmxCtx *ctx, u8 **dsi, u32 *dsi_size, u8 **dsi_enh, u32 *dsi_enh_size, u32 *max_width, u32 *max_height, u32 *max_enh_width, u32 *max_enh_height, GF_Fraction *sar)
 {
 	u32 i, count;
 	Bool first = GF_TRUE;
@@ -1322,6 +1439,9 @@
 	max_w = max_h = max_ew = max_eh = 0;
 	sar->num = sar->den = 0;
 
+	if (!ctx->analyze && (!gf_list_count(ctx->sps) || !gf_list_count(ctx->pps)))
+		return GF_FALSE;
+
 	avcc = gf_odf_avc_cfg_new();
 	svcc = gf_odf_avc_cfg_new();
 	avcc->nal_unit_size = ctx->nal_length;
@@ -1464,6 +1584,7 @@
 	*max_height = max_h;
 	*max_enh_width = max_ew;
 	*max_enh_height = max_eh;
+	return GF_TRUE;
 }
 
 static void naludmx_end_access_unit(GF_NALUDmxCtx *ctx)
@@ -1472,7 +1593,7 @@
 	naludmx_finalize_au_flags(ctx);
 
 	ctx->has_islice = GF_FALSE;
-	ctx->first_slice_in_au = GF_TRUE;
+	ctx->nb_slices_in_au = 0;
 	ctx->sei_recovery_frame_count = -1;
 	ctx->au_sap = GF_FILTER_SAP_NONE;
 	ctx->au_sap2_poc_reset = GF_FALSE;
@@ -1507,7 +1628,9 @@
 static void naludmx_set_dolby_vision(GF_NALUDmxCtx *ctx)
 {
 	u8 dv_cfg24;
-
+	if (!ctx->opid)
+		return;
+		
 	switch (ctx->dv_mode) {
 	case DVMODE_NONE:
 	case DVMODE_CLEAN:
@@ -1521,22 +1644,118 @@
 	u32 dv_level = gf_dolby_vision_level(ctx->width, ctx->height, ctx->cur_fps.num, ctx->cur_fps.den, ctx->codecid);
 
 	if (ctx->dv_profile==8) {
-		if (!ctx->dv_compatid) {
+		if (ctx->dv_compatid<2) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("%s DV profile 8 used but dv_compatid not set, defaulting to bt709 (=2)\n", ctx->log_name));
-			ctx->dv_compatid = 2;
+			ctx->dv_compatid = 3;
 		}
 	}
+	u32 dv_ccid = ctx->dv_compatid ? (ctx->dv_compatid-1) : 0;
+	u32 dv_profile_id = ctx->dv_profile;
+
+
+	//auto-detect DV profile, check range, color primaries, EOTF, matrix, and chroma sample location type
+	if (!ctx->dv_profile) {
+		Bool vui_present = GF_FALSE;
+		Bool has_non_def = GF_FALSE;
+		u32 luma_bit_depth=8;
+		u32 fr = 0;
+		u32 cp = 2;
+		u32 tc = 2;
+		u32 mx = 2;
+		u32 cl = 0;
+		if (ctx->avc_state && (ctx->avc_state->last_sps_idx>=0)) {
+			AVC_SPS *sps = &ctx->avc_state->spsctx->avc_state->last_sps_idx;
+			luma_bit_depth = sps->luma_bit_depth_m8+8;
+			if (sps->vui_parameters_present_flag) {
+				vui_present = GF_TRUE;
+				if (sps->vui.video_signal_type_present_flag) {
+					fr = sps->vui.video_full_range_flag;
+					has_non_def = GF_TRUE;
+				}
+				if (sps->vui.chroma_location_info_present_flag) {
+					cl = (sps->chroma_format==1) ? sps->vui.chroma_sample_loc_type_top_field : 2;
+					has_non_def = GF_TRUE;
+				}
+				if (sps->vui.colour_description_present_flag) {
+					cp = sps->vui.colour_primaries;
+					tc = sps->vui.transfer_characteristics;
+					mx = sps->vui.matrix_coefficients;
+					has_non_def = GF_TRUE;
+				}
+			}
+		}
+		else if (ctx->hevc_state && (ctx->hevc_state->last_parsed_sps_id>=0)) {
+			HEVC_SPS *sps = &ctx->hevc_state->spsctx->hevc_state->last_parsed_sps_id;
+			luma_bit_depth = sps->bit_depth_luma;
+			if (sps->vui_parameters_present_flag) {
+				vui_present = GF_TRUE;
+				if (sps->chroma_loc_info_present_flag)
+					cl = (sps->chroma_format_idc==1) ? sps->chroma_sample_loc_type_top_field : 2;
+
+				//check profile compat: range, color primaries, EOTF, matrix, and chroma sample location type
+				if (sps->video_signal_type_present_flag) {
+					fr = sps->video_full_range_flag;
+					has_non_def = GF_TRUE;
+				}
+				if (sps->colour_description_present_flag) {
+					cp = sps->colour_primaries;
+					tc = sps->transfer_characteristic;
+					mx = sps->matrix_coeffs;
+					has_non_def = GF_TRUE;
+				}
+			}
+		}
+
+		if ((fr==1) && (cp==2) && (tc==2) && (mx==2) && (cl==0)) dv_ccid=0;
+		else if ((fr==0) && (cp==9) && (tc==16) && (mx==9) && (cl==0)) dv_ccid=1;
+		else if ((fr==0) && (cp==1) && (tc==1) && (mx==1) && (cl==0)) dv_ccid=2;
+		else if ((fr==0) && (cp==9) && (tc==18) && (mx==9) && (cl==2)) dv_ccid=4;
+		else if ((fr==0) && (cp==9) && (tc==14) && (mx==9) && (cl==0)) dv_ccid=4;
+		else if ((fr==0) && (cp==9) && (tc==16) && (mx==9) && (cl==2)) dv_ccid=6;
+
+		//we consider that if no VUI but an EL is present, this will be profile 4 compat SRD
+		if (!vui_present && ctx->nb_dv_el)
+			dv_ccid = 2;
+
+
+		if (dv_ccid==2) {
+			if (ctx->nb_dv_el) dv_profile_id = 4;
+			else if (luma_bit_depth==8) dv_profile_id = 9;
+			else dv_profile_id = 8; //or 4
+		}
+		//DV spec: "Note: H.265 (2018-02) requires top-left chroma siting (VUI = 2), if the decoded video is intended for interpretation
+		// according to ITU-R BT.2020-2 or ITU-R BT.2100-1. Previously, H.265 (2016-12) described the default chroma siting as center left (VUI = 0)."
+		//we consider that dv_ccid=6 is allowed for profile 8 ( DV without EL) - this is not clearly written in the spec but matches deployed bitstreams
+		else if (dv_ccid==6) {
+			dv_profile_id = ctx->nb_dv_el ? 7 : 8;
+		}
+		else if ((dv_ccid==1) || (dv_ccid==4)) dv_profile_id = 8;
+		//default to 5 if no EL, 4 if EL
+		else dv_profile_id = ctx->nb_dv_el ? 4 : 5;
+
+		//DV spec: "Note: As of the effective date of this specification, all commercially produced profile 4 and profile 5 Dolby Vision bitstreams
+		// have used center-left siting during chroma downsampling, and are distributed without the VUI value for chroma sample location type.
+		// Those bitstreams are compliant with this specification."
+		//we treat bitstreams not explicitly signaling vui info as valid and assign the CCID according to DV spec
+		if (!has_non_def) {
+			if (dv_profile_id == 4) dv_ccid = 2;
+			else if (dv_profile_id == 5) dv_ccid = 0;
+		}
+	}
+	//not in auto mode, restore value
+	if (ctx->dv_compatid)
+		dv_ccid = ctx->dv_compatid-1;
 
 	memset(dv_cfg, 0, sizeof(u8)*24);
 	GF_BitStream *bs = gf_bs_new(dv_cfg, 24, GF_BITSTREAM_WRITE);
 	gf_bs_write_u8(bs, 1); //version major
 	gf_bs_write_u8(bs, 0); //version minor
-	gf_bs_write_int(bs, ctx->dv_profile, 7);
+	gf_bs_write_int(bs, dv_profile_id, 7);
 	gf_bs_write_int(bs, dv_level, 6);
 	gf_bs_write_int(bs, ctx->nb_dv_rpu ? 1 : 0, 1); //rpu present
 	gf_bs_write_int(bs, ctx->nb_dv_el ? 1 : 0, 1); //el present
 	gf_bs_write_int(bs, 1, 1); //bl_present_flag always true, we don't split streams
-	gf_bs_write_int(bs, ctx->dv_compatid, 4);
+	gf_bs_write_int(bs, dv_ccid, 4);
 	//the rest is zero-reserved
 	gf_bs_write_int(bs, 0, 28);
 	gf_bs_write_u32(bs, 0);
@@ -1556,6 +1775,7 @@
 	GF_Fraction sar;
 	Bool has_hevc_base = GF_TRUE;
 	Bool has_colr_info = GF_FALSE;
+	Bool res;
 
 	if (ctx->analyze) {
 		if (ctx->opid && !ctx->ps_modified) return;
@@ -1577,12 +1797,14 @@
 	}
 
 	if (ctx->codecid==GF_CODECID_HEVC) {
-		naludmx_create_hevc_decoder_config(ctx, &dsi, &dsi_size, &dsi_enh, &dsi_enh_size, &w, &h, &ew, &eh, &sar, &has_hevc_base);
+		res = naludmx_create_hevc_decoder_config(ctx, &dsi, &dsi_size, &dsi_enh, &dsi_enh_size, &w, &h, &ew, &eh, &sar, &has_hevc_base);
 	} else if (ctx->codecid==GF_CODECID_VVC) {
-		naludmx_create_vvc_decoder_config(ctx, &dsi, &dsi_size, &dsi_enh, &dsi_enh_size, &w, &h, &ew, &eh, &sar, &has_hevc_base);
+		res = naludmx_create_vvc_decoder_config(ctx, &dsi, &dsi_size, &dsi_enh, &dsi_enh_size, &w, &h, &ew, &eh, &sar, &has_hevc_base);
 	} else {
-		naludmx_create_avc_decoder_config(ctx, &dsi, &dsi_size, &dsi_enh, &dsi_enh_size, &w, &h, &ew, &eh, &sar);
+		res = naludmx_create_avc_decoder_config(ctx, &dsi, &dsi_size, &dsi_enh, &dsi_enh_size, &w, &h, &ew, &eh, &sar);
 	}
+	if (!res) return;
+
 	crc_cfg = crc_cfg_enh = 0;
 	if (dsi) crc_cfg = gf_crc_32(dsi, dsi_size);
 	if (dsi_enh) crc_cfg_enh = gf_crc_32(dsi_enh, dsi_enh_size);
@@ -1594,10 +1816,11 @@
 	}
 
 	if (!ctx->opid) {
+		u32 slice_in_au = ctx->nb_slices_in_au;
 		ctx->opid = gf_filter_pid_new(filter);
 
 		naludmx_check_dur(filter, ctx);
-		ctx->first_slice_in_au = GF_TRUE;
+		ctx->nb_slices_in_au = slice_in_au;
 	}
 
 	if ((ctx->crc_cfg == crc_cfg) && (ctx->crc_cfg_enh == crc_cfg_enh)
@@ -1612,12 +1835,10 @@
 	if (force_au_flush) {
 		naludmx_end_access_unit(ctx);
 	}
-	
 	naludmx_enqueue_or_dispatch(ctx, NULL, GF_TRUE);
 	if (!ctx->analyze && (gf_list_count(ctx->pck_queue)>1)) {
 		GF_LOG(dsi_enh ? GF_LOG_DEBUG : GF_LOG_ERROR, GF_LOG_MEDIA, ("%s xPS changed but could not flush frames before signaling state change %s\n", ctx->log_name, dsi_enh ? "- likely scalable xPS update" : "!"));
 	}
-
 	//copy properties at init or reconfig
 	gf_filter_pid_copy_properties(ctx->opid, ctx->ipid);
 
@@ -1753,8 +1974,11 @@
 			ctx->nb_nalus = ctx->nb_i = ctx->nb_p = ctx->nb_b = ctx->nb_sp = ctx->nb_si = ctx->nb_sei = ctx->nb_idr = ctx->nb_cra = 0;
 			for (i=1; i<ctx->index_size; i++) {
 				if (ctx->indexesi.duration>ctx->start_range) {
-					ctx->cts = ctx->dts = (u64) (ctx->indexesi-1.duration * ctx->cur_fps.num);
+					ctx->cts = (u64) (ctx->indexesi-1.duration * ctx->cur_fps.num);
+					ctx->dts = ctx->dts_last_IDR = ctx->cts;
 					file_pos = ctx->indexesi-1.pos;
+					ctx->seek_gdr_count = ctx->indexesi-1.roll_count;
+					if (ctx->seek_gdr_count) ctx->first_gdr = GF_TRUE;
 					break;
 				}
 			}
@@ -1788,6 +2012,7 @@
 		ctx->is_playing = GF_FALSE;
 		ctx->nal_store_size = 0;
 		ctx->resume_from = 0;
+		ctx->cts = 0;
 		return GF_FALSE;
 
 	case GF_FEVT_SET_SPEED:
@@ -1816,11 +2041,12 @@
 	}
 }
 
-static void naludmx_queue_param_set(GF_NALUDmxCtx *ctx, char *data, u32 size, u32 ps_type, s32 ps_id)
+static void naludmx_queue_param_set(GF_NALUDmxCtx *ctx, char *data, u32 size, u32 ps_type, s32 ps_id, u32 tid, u32 lid)
 {
 	GF_List *list = NULL, *alt_list = NULL;
 	GF_NALUFFParam *sl;
 	u32 i, count, crc;
+	Bool flush_au = GF_FALSE;
 
 	if (!size) return;
 	crc = gf_crc_32(data, size);
@@ -1830,12 +2056,16 @@
 		case GF_HEVC_NALU_VID_PARAM:
 			if (!ctx->vps) ctx->vps = gf_list_new();
 			list = ctx->vps;
+			flush_au = GF_TRUE;
 			break;
 		case GF_HEVC_NALU_SEQ_PARAM:
 			list = ctx->sps;
+			flush_au = GF_TRUE;
+			ctx->valid_ps_flags |= 1;
 			break;
 		case GF_HEVC_NALU_PIC_PARAM:
 			list = ctx->pps;
+			ctx->valid_ps_flags |= 1<<1;
 			break;
 		default:
 			assert(0);
@@ -1846,17 +2076,25 @@
 		case GF_VVC_NALU_VID_PARAM:
 			if (!ctx->vps) ctx->vps = gf_list_new();
 			list = ctx->vps;
+			flush_au = GF_TRUE;
 			break;
 		case GF_VVC_NALU_SEQ_PARAM:
 			list = ctx->sps;
+			flush_au = GF_TRUE;
+			ctx->valid_ps_flags |= 1;
 			break;
 		case GF_VVC_NALU_PIC_PARAM:
 			list = ctx->pps;
+			ctx->valid_ps_flags |= 1<<1;
 			break;
 		case GF_VVC_NALU_DEC_PARAM:
 			if (!ctx->vvc_dci) ctx->vvc_dci = gf_list_new();
 			list = ctx->vvc_dci;
 			break;
+		case GF_VVC_NALU_OPI:
+			if (!ctx->vvc_opi) ctx->vvc_opi = gf_list_new();
+			list = ctx->vvc_opi;
+			break;
 		case GF_VVC_NALU_APS_PREFIX:
 			if (!ctx->vvc_aps_pre) ctx->vvc_aps_pre = gf_list_new();
 			list = ctx->vvc_aps_pre;
@@ -1867,11 +2105,14 @@
 		}
 	} else {
 		switch (ps_type) {
-		case GF_AVC_NALU_SVC_SUBSEQ_PARAM:
 		case GF_AVC_NALU_SEQ_PARAM:
+			ctx->valid_ps_flags |= 1;
+			flush_au = GF_TRUE;
+		case GF_AVC_NALU_SVC_SUBSEQ_PARAM:
 			list = ctx->sps;
 			break;
 		case GF_AVC_NALU_PIC_PARAM:
+			ctx->valid_ps_flags |= 1<<1;
 			list = ctx->pps;
 			alt_list = ctx->pps_svc;
 			break;
@@ -1911,6 +2152,8 @@
 		}
 	}
 
+	if (lid || tid) flush_au = GF_FALSE;
+
 	if (sl) {
 		//otherwise we keep this new param set
 		sl->data = gf_realloc(sl->data, size);
@@ -1918,6 +2161,10 @@
 		sl->size = size;
 		sl->crc = crc;
 		ctx->ps_modified = GF_TRUE;
+		//flush AU if we have a slice
+		if (ctx->opid && flush_au && ctx->first_pck_in_au && ctx->nb_slices_in_au) {
+			naludmx_end_access_unit(ctx);
+		}
 		return;
 	}
 	//TODO we might want to purge the list after a while !!
@@ -1935,6 +2182,10 @@
 	sl->crc = crc;
 
 	ctx->ps_modified = GF_TRUE;
+	//flush AU if we have a slice
+	if (ctx->opid && flush_au && ctx->first_pck_in_au && ctx->nb_slices_in_au) {
+		naludmx_end_access_unit(ctx);
+	}
 	gf_list_add(list, sl);
 }
 
@@ -2093,7 +2344,13 @@
 		gf_filter_pck_set_carousel_version(dst_pck, ctx->notime ? 1 : 0);
 
 		gf_filter_pck_set_duration(dst_pck, ctx->pck_duration ? ctx->pck_duration : ctx->cur_fps.den);
-		if (ctx->in_seek) gf_filter_pck_set_seek_flag(dst_pck, GF_TRUE);
+		if (ctx->in_seek) {
+			gf_filter_pck_set_seek_flag(dst_pck, GF_TRUE);
+			if (ctx->first_gdr) {
+				ctx->first_gdr = GF_FALSE;
+				gf_filter_pck_set_sap(ctx->first_pck_in_au, GF_FILTER_SAP_4);
+			}
+		}
 
 		naludmx_update_time(ctx);
 		*au_start = GF_FALSE;
@@ -2166,7 +2423,7 @@
 
 	if (res < 0) {
 		if (res == -1) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Warning: Error parsing NAL unit\n", ctx->log_name));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing NAL unit type %u\n", ctx->log_name, nal_unit_type));
 		}
 		*skip_nal = GF_TRUE;
 	}
@@ -2187,7 +2444,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Video Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_HEVC_NALU_VID_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_HEVC_NALU_VID_PARAM, ps_idx, temporal_id, layer_id);
 		}
 		*skip_nal = GF_TRUE;
 		break;
@@ -2196,7 +2453,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Sequence Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_HEVC_NALU_SEQ_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_HEVC_NALU_SEQ_PARAM, ps_idx, temporal_id, layer_id);
 		}
 		*skip_nal = GF_TRUE;
 		break;
@@ -2205,7 +2462,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Picture Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_HEVC_NALU_PIC_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_HEVC_NALU_PIC_PARAM, ps_idx, temporal_id, layer_id);
 		}
 		*skip_nal = GF_TRUE;
 		break;
@@ -2341,7 +2598,7 @@
 
 	if (res < 0) {
 		if (res == -1) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Warning: Error parsing NAL unit\n", ctx->log_name));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing NAL unit type %u\n", ctx->log_name, nal_unit_type));
 		}
 		*skip_nal = GF_TRUE;
 	}
@@ -2363,7 +2620,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Video Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_VID_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_VID_PARAM, ps_idx, temporal_id, layer_id);
 		}
 		*skip_nal = GF_TRUE;
 		break;
@@ -2372,7 +2629,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Sequence Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_SEQ_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_SEQ_PARAM, ps_idx, temporal_id, layer_id);
 		}
 		*skip_nal = GF_TRUE;
 		break;
@@ -2381,13 +2638,18 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Picture Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_PIC_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_PIC_PARAM, ps_idx, temporal_id, layer_id);
 		}
 		*skip_nal = GF_TRUE;
 		break;
 	case GF_VVC_NALU_DEC_PARAM:
 		ps_idx = 0;
-		naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_DEC_PARAM, ps_idx);
+		naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_DEC_PARAM, ps_idx, temporal_id, layer_id);
+		*skip_nal = GF_TRUE;
+		break;
+	case GF_VVC_NALU_OPI:
+		ps_idx = 0;
+		naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_OPI, ps_idx, temporal_id, layer_id);
 		*skip_nal = GF_TRUE;
 		break;
 	case GF_VVC_NALU_APS_PREFIX:
@@ -2397,7 +2659,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Decoder Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_APS_PREFIX, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_VVC_NALU_APS_PREFIX, ps_idx, temporal_id, layer_id);
 		}
 		*skip_nal = GF_TRUE;
 #else
@@ -2483,10 +2745,6 @@
 		*skip_nal = GF_TRUE;
 		break;
 
-	case GF_VVC_NALU_OPI:
-		if (! ctx->is_playing) return 0;
-		break;
-
 	default:
 		if (! ctx->is_playing) return 0;
 		GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("%s NAL Unit type %d not handled - adding\n", ctx->log_name, nal_unit_type));
@@ -2518,7 +2776,7 @@
 	res = gf_avc_parse_nalu(ctx->bs_r, ctx->avc_state);
 	if (res < 0) {
 		if (res == -1) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Warning: Error parsing NAL unit\n", ctx->log_name));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing NAL unit type %u\n", ctx->log_name, nal_type));
 		}
 		*skip_nal = GF_TRUE;
 	}
@@ -2533,7 +2791,7 @@
 				GF_LOG(ctx->avc_state->sps0.profile_idc ? GF_LOG_WARNING : GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Sequence Param Set\n", ctx->log_name));
 			}
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_AVC_NALU_SEQ_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_AVC_NALU_SEQ_PARAM, ps_idx, 0, 0);
 		}
 		*skip_nal = GF_TRUE;
 		return 0;
@@ -2543,7 +2801,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Picture Param Set\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_AVC_NALU_PIC_PARAM, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_AVC_NALU_PIC_PARAM, ps_idx, 0, 0);
 		}
 		*skip_nal = GF_TRUE;
 		return 0;
@@ -2553,7 +2811,7 @@
 		if (ps_idx<0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("%s Error parsing Sequence Param Set Extension\n", ctx->log_name));
 		} else {
-			naludmx_queue_param_set(ctx, data, size, GF_AVC_NALU_SEQ_PARAM_EXT, ps_idx);
+			naludmx_queue_param_set(ctx, data, size, GF_AVC_NALU_SEQ_PARAM_EXT, ps_idx, 0, 0);
 		}
 		*skip_nal = GF_TRUE;
 		return 0;
@@ -2813,6 +3071,15 @@
 			}
 			if (ctx->opid)
 				gf_filter_pid_set_eos(ctx->opid);
+
+			if ((ctx->valid_ps_flags & 0x03) != 0x03) {
+				ctx->nb_nalus = 0;
+				return GF_NON_COMPLIANT_BITSTREAM;
+			}
+			if (ctx->nb_nalus && !(ctx->nb_i|ctx->nb_p|ctx->nb_b|ctx->nb_idr|ctx->nb_si|ctx->nb_sp|ctx->nb_cra)) {
+				ctx->nb_nalus = 0;
+				return GF_NON_COMPLIANT_BITSTREAM;
+			}
 			return GF_EOS;
 		}
 		return GF_OK;
@@ -2942,6 +3209,7 @@
 
 		//figure out which nal we need to completely load
 		if (ctx->codecid==GF_CODECID_HEVC) {
+			if (is_eos && (nal_size<2)) break;
 			nal_type = nal_data0;
 			nal_type = (nal_type & 0x7E) >> 1;
 
@@ -2987,6 +3255,7 @@
 				}
 			}
 		} else if (ctx->codecid==GF_CODECID_VVC) {
+			if (is_eos && (nal_size<2)) break;
 			nal_type = nal_data1>>3;
 			switch (nal_type) {
 			case GF_VVC_NALU_OPI:
@@ -3037,6 +3306,7 @@
 				}
 			}
 		} else {
+			if (is_eos && (nal_size<1)) break;
 			nal_type = nal_data0 & 0x1F;
 			nal_ref_idc = (nal_data0 & 0x60) >> 5;
 		}
@@ -3070,7 +3340,7 @@
 		}
 
 		//new frame - if no slices, we detected the new frame on AU delimiter, don't flush new frame !
-		if ((nal_parse_result>0) && !ctx->first_slice_in_au) {
+		if ((nal_parse_result>0) && ctx->nb_slices_in_au) {
 			naludmx_end_access_unit(ctx);
 		}
 
@@ -3099,7 +3369,10 @@
 			u64 nb_frames_at_seek = (u64) (ctx->start_range * ctx->cur_fps.num);
 			if (ctx->cts + ctx->cur_fps.den >= nb_frames_at_seek) {
 				//u32 samples_to_discard = (ctx->cts + ctx->dts_inc) - nb_samples_at_seek;
-				ctx->in_seek = GF_FALSE;
+				if (ctx->seek_gdr_count)
+					ctx->seek_gdr_count--;
+				else
+					ctx->in_seek = GF_FALSE;
 			}
 		}
 
@@ -3317,7 +3590,7 @@
 		}
 
 		if (is_slice) {
-			Bool first_in_au = ctx->first_slice_in_au;
+			Bool first_in_au = (ctx->nb_slices_in_au==0) ? GF_TRUE : GF_FALSE;
 
 			if (slice_is_idr)
 				ctx->nb_idr++;
@@ -3326,11 +3599,11 @@
 				ctx->nb_cra++;
 
 			slice_force_ref = GF_FALSE;
+			ctx->nb_slices_in_au++;
 
 			/*we only indicate TRUE IDRs for sync samples (cf AVC file format spec).
 			SEI recovery should be used to build sampleToGroup & RollRecovery tables*/
-			if (ctx->first_slice_in_au) {
-				ctx->first_slice_in_au = GF_FALSE;
+			if (first_in_au) {
 				if (recovery_point_valid) {
 					ctx->sei_recovery_frame_count = recovery_point_frame_cnt;
 
@@ -3357,7 +3630,6 @@
 			}
 
 			if (slice_poc < ctx->poc_shift) {
-
 				u32 i, count = gf_list_count(ctx->pck_queue);
 				for (i=0; i<count; i++) {
 					u64 dts, cts;
@@ -3594,6 +3866,14 @@
 		ctx->nal_length = 4;
 		break;
 	}
+
+	//if profile is forced and comapt_id is in auto mode, fail
+	if (!ctx->dv_compatid) {
+		if (ctx->dv_profile) {
+			ctx->dv_compatid=1;
+			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("%s DV profile forced but compatID in auto mode, using no compatibility\n", ctx->log_name));
+		}
+	}
 	return GF_OK;
 }
 
@@ -3671,8 +3951,9 @@
 	naludmx_del_param_list(ctx->pps_svc, do_free);
 	naludmx_del_param_list(ctx->vvc_aps_pre, do_free);
 	naludmx_del_param_list(ctx->vvc_dci, do_free);
-
+	naludmx_del_param_list(ctx->vvc_opi, do_free);
 }
+
 static void naludmx_finalize(GF_Filter *filter)
 {
 	GF_NALUDmxCtx *ctx = gf_filter_get_udta(filter);
@@ -3759,7 +4040,8 @@
 				break;
 			}
 		} else {
-			not_hevc++;
+			if ((nal_type!=GF_HEVC_NALU_DV_RPU) && (nal_type!=GF_HEVC_NALU_DV_EL))
+				not_hevc++;
 		}
 
 		nal_type = data0 & 0x1F;
@@ -3778,7 +4060,8 @@
 				break;
 			}
 		} else {
-			not_avc++;
+			if ((nal_type!=GF_AVC_NALU_DV_RPU) && (nal_type!=GF_AVC_NALU_DV_EL))
+				not_avc++;
 		}
 
 		//check vvc - 2nd bit reserved to 0
@@ -3815,7 +4098,8 @@
 
 	if (!nb_sps_avc || !nb_pps_avc) nb_avc=0;
 	if (!nb_sps_hevc || !nb_pps_hevc || !nb_vps_hevc) nb_hevc=0;
-	if (!nb_sps_vvc || !nb_pps_vvc || !nb_vps_vvc) nb_vvc=0;
+	//VPS is optional in VVC, don't check for its presence
+	if (!nb_sps_vvc || !nb_pps_vvc) nb_vvc=0;
 	if (not_avc) nb_avc=0;
 	if (not_hevc) nb_hevc=0;
 	if (not_vvc) nb_vvc=0;
@@ -3839,7 +4123,7 @@
 static const GF_FilterCapability NALUDmxCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "264|h264|26L|h26L|h26l|avc|svc|mvc|hevc|hvc|265|h265|shvc|lvhc|mhvc|266|vvc|lvvc"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "264|h264|26l|h26l|avc|svc|mvc|hevc|hvc|265|h265|lhvc|shvc|mhvc|266|h266|vvc|lvvc"),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "video/avc|video/h264|video/svc|video/mvc|video/hevc|video/lhvc|video/shvc|video/mhvc|video/vvc"),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_AVC),
@@ -3849,6 +4133,7 @@
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_HEVC),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_LHVC),
 	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_VVC),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_FORCE_UNFRAME, GF_TRUE),
 	CAP_BOOL(GF_CAPS_OUTPUT_STATIC_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_BOOL(GF_CAPS_OUTPUT_STATIC_EXCLUDED, GF_PROP_PID_TILE_BASE, GF_TRUE),
 	{0},
@@ -3862,6 +4147,7 @@
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_VVC),
 	CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_TILE_BASE, GF_TRUE),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_FORCE_UNFRAME, GF_TRUE),
 	{0},
 	//for HLS-SAES
 	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_ENCRYPTED),
@@ -3869,13 +4155,14 @@
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AVC),
 	CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_TILE_BASE, GF_TRUE),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_FORCE_UNFRAME, GF_TRUE),
 };
 
 #define OFFS(_n)	#_n, offsetof(GF_NALUDmxCtx, _n)
 static const GF_FilterArgs NALUDmxArgs =
 {
 	{ OFFS(fps), "import frame rate (0 default to FPS from bitstream or 25 Hz)", GF_PROP_FRACTION, "0/1000", NULL, 0},
-	{ OFFS(index), "indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 100M (slows down importers) unless a play with start range > 0 is issued", GF_PROP_DOUBLE, "-1.0", NULL, 0},
+	{ OFFS(index), "indexing window length. If 0, bitstream is not probed for duration. A negative value skips the indexing if the source file is larger than 20M (slows down importers) unless a play with start range > 0 is issued", GF_PROP_DOUBLE, "-1.0", NULL, 0},
 	{ OFFS(explicit), "use explicit layered (SVC/LHVC) import", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(strict_poc), "delay frame output of an entire GOP to ensure CTS info is correct when POC suddenly changes\n"
 		"- off: disable GOP buffering\n"
@@ -3897,19 +4184,19 @@
 	{ OFFS(dv_mode), "signaling for DolbyVision\n"
 	"- none: never signal DV profile\n"
 	"- auto: signal DV profile if RPU or EL are found\n"
-	"- force: always signal DV profile\n"
 	"- clean: do not signal and remove RPU and EL NAL units\n"
-	"- single: remove EL NAL units"
-	, GF_PROP_UINT, "auto", "none|auto|force|clean|single", GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(dv_profile), "profile for DolbyVision (currently defined profiles are 4, 5, 7, 8, 9)", GF_PROP_UINT, "5", NULL, GF_FS_ARG_HINT_ADVANCED},
+	"- single: signal DV profile if RPU are found and remove EL NAL units"
+	, GF_PROP_UINT, "auto", "none|auto|clean|single", GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(dv_profile), "profile for DolbyVision (currently defined profiles are 4, 5, 7, 8, 9), 0 for auto-detect", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(dv_compatid), "cross-compatibility ID for DolbyVision\n"
-		"- none: do not signal compatibility\n"
+		"- auto: auto-detect\n"
+		"- none: no cross-compatibility\n"
 		"- hdr10: CTA HDR10, as specified by EBU TR 03\n"
 		"- bt709: SDR BT.709\n"
 		"- hlg709: HLG BT.709 gamut in ITU-R BT.2020\n"
 		"- hlg2100: HLG BT.2100 gamut in ITU-R BT.2020\n"
 		"- bt2020: SDR BT.2020\n"
-		"- brd: Ultra HD Blu-ray Disc HDR", GF_PROP_UINT, "none", "none|hdr10|bt709|hlg709|hlg2100|bt2020|brd", GF_FS_ARG_HINT_ADVANCED},
+		"- brd: Ultra HD Blu-ray Disc HDR", GF_PROP_UINT, "auto", "auto|none|hdr10|bt709|hlg709|hlg2100|bt2020|brd", GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(bsdbg), "debug NAL parsing in `parser@debug` logs\n"
 		"- off: not enabled\n"
 		"- on: enabled\n"

gpac-2.0.0.tar.gz/src/filters/reframe_prores.c -> gpac-2.2.0.tar.gz/src/filters/reframe_prores.c Changed

gpac-2.0.0.tar.gz/src/filters/reframe_qcp.c -> gpac-2.2.0.tar.gz/src/filters/reframe_qcp.c Changed

gpac-2.0.0.tar.gz/src/filters/reframe_rawpcm.c -> gpac-2.2.0.tar.gz/src/filters/reframe_rawpcm.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2018-2021
+ *			Copyright (c) Telecom ParisTech 2018-2022
 *					All rights reserved
 *
 * This file is part of GPAC / RAW PCM reframer filter
@@ -44,6 +44,10 @@
 	GF_FilterPacket *out_pck;
 	u8 *out_data;
 	Bool reverse_play, done;
+
+	u32 probe_wave, wav_hdr_size;
+	u8 *probe_data;
+	u32 probe_data_size;
 } GF_PCMReframeCtx;
 
 
@@ -66,28 +70,32 @@
 		return GF_NOT_SUPPORTED;
 
 	ctx->ipid = pid;
+	p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_FILE_EXT);
 	if (!ctx->safmt) {
-		p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_FILE_EXT);
 		if (p && p->value.string) ctx->safmt = gf_audio_fmt_parse(p->value.string);
 	}
 	if (!ctx->safmt) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("PCMReframe Missing audio format, cannot parse\n"));
-		return GF_BAD_PARAM;
-	}
-	if (!ctx->sr) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("PCMReframe Missing audio sample rate, cannot parse\n"));
-		return GF_BAD_PARAM;
-	}
-	if (!ctx->ch) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("PCMReframe Missing audio ch, cannot parse\n"));
-		return GF_BAD_PARAM;
+		ctx->probe_wave = 1;
+		GF_FilterEvent evt;
+		GF_FEVT_INIT(evt, GF_FEVT_PLAY, pid);
+		gf_filter_pid_send_event(pid, &evt);
+		return GF_OK;
+	} else {
+		if (!ctx->sr) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("PCMReframe Missing audio sample rate, cannot parse\n"));
+			return GF_BAD_PARAM;
+		}
+		if (!ctx->ch) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("PCMReframe Missing audio ch, cannot parse\n"));
+			return GF_BAD_PARAM;
+		}
+		ctx->Bps = gf_audio_fmt_bit_depth(ctx->safmt) / 8;
 	}
 	if (!ctx->framelen) {
 		GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("PCMReframe Missing audio framelen, using 1024\n"));
 		ctx->framelen = 1024;
 	}
 
-	ctx->Bps = gf_audio_fmt_bit_depth(ctx->safmt) / 8;
 	ctx->frame_size = ctx->framelen * ctx->Bps * ctx->ch;
 
 	if (!ctx->opid)
@@ -97,6 +105,7 @@
 	gf_filter_pid_set_framing_mode(ctx->ipid, GF_FALSE);
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_AUDIO));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
+
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_SAMPLE_RATE, &PROP_UINT(ctx->sr));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_NUM_CHANNELS, &PROP_UINT(ctx->ch));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_SAMPLES_PER_FRAME, &PROP_UINT(ctx->framelen));
@@ -115,6 +124,7 @@
 	p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_DOWN_SIZE);
 	if (p && p->value.longuint) {
 		u64 nb_frames = p->value.longuint;
+		if (ctx->probe_wave) nb_frames -= ctx->wav_hdr_size;
 		nb_frames /= ctx->Bps * ctx->ch;
 		ctx->total_frames = p->value.longuint;
 		ctx->total_frames /= ctx->frame_size;
@@ -168,7 +178,7 @@
 		}
 		//post a seek
 		GF_FEVT_INIT(fevt, GF_FEVT_SOURCE_SEEK, ctx->ipid);
-		fevt.seek.start_offset = ctx->filepos;
+		fevt.seek.start_offset = ctx->filepos + ctx->wav_hdr_size;
 		gf_filter_pid_send_event(ctx->ipid, &fevt);
 
 		//cancel event
@@ -238,6 +248,102 @@
 	data = (char *) gf_filter_pck_get_data(pck, &pck_size);
 	byte_offset = gf_filter_pck_get_byte_offset(pck);
 
+	if (ctx->probe_wave==1) {
+		Bool wav_ok = GF_TRUE;
+		GF_BitStream *bs;
+		if (ctx->probe_data) {
+			ctx->probe_data = gf_realloc(ctx->probe_data, ctx->probe_data_size+pck_size);
+			memcpy(ctx->probe_data + ctx->probe_data_size, data, pck_size);
+			ctx->probe_data_size += pck_size;
+			bs = gf_bs_new(ctx->probe_data, ctx->probe_data_size, GF_BITSTREAM_READ);
+		} else {
+			bs = gf_bs_new(data, pck_size, GF_BITSTREAM_READ);
+		}
+		u32 type = gf_bs_read_u32(bs);
+		if (type!=GF_4CC('R', 'I', 'F', 'F')) {
+			wav_ok = GF_FALSE;
+		}
+		gf_bs_read_u32(bs);
+		u32 wtype = gf_bs_read_u32(bs);
+		if (wtype!=GF_4CC('W', 'A', 'V', 'E')) {
+			wav_ok = GF_FALSE;
+		}
+		while (gf_bs_available(bs)) {
+			type = gf_bs_read_u32(bs);
+			u32 csize = gf_bs_read_u32_le(bs); //subchunk size
+			if (type==GF_4CC('d', 'a', 't', 'a')) {
+				break;
+			}
+
+			if (type!=GF_4CC('f', 'm', 't', ' ')) {
+				gf_bs_skip_bytes(bs, csize);
+				continue;
+			}
+			//parse fmt
+			u16 atype = gf_bs_read_u16_le(bs);
+			ctx->ch = gf_bs_read_u16_le(bs);
+			ctx->sr = gf_bs_read_u32_le(bs);
+			gf_bs_read_u32_le(bs); //byte rate
+			gf_bs_read_u16_le(bs); // block align
+			u32 bps = gf_bs_read_u16_le(bs);
+			if (atype==3) {
+				if (bps==32) {
+					ctx->safmt = GF_AUDIO_FMT_FLT;
+				} else {
+					wav_ok = GF_FALSE;
+				}
+			} else if (atype==1) {
+				if (bps==32) {
+					ctx->safmt = GF_AUDIO_FMT_S32;
+				} else if (bps==24) {
+					ctx->safmt = GF_AUDIO_FMT_S24;
+				} else if (bps==16) {
+					ctx->safmt = GF_AUDIO_FMT_S16;
+				} else if (bps==8) {
+					ctx->safmt = GF_AUDIO_FMT_U8;
+				} else {
+					wav_ok = GF_FALSE;
+				}
+			}
+		}
+		if (gf_bs_is_overflow(bs)) {
+			if (!ctx->probe_data) {
+				ctx->probe_data = gf_malloc(pck_size);
+				memcpy(ctx->probe_data, data, pck_size);
+				ctx->probe_data_size = pck_size;
+			}
+			if (ctx->probe_data_size<=10000) {
+				gf_filter_pid_drop_packet(ctx->ipid);
+				return GF_OK;
+			}
+			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("PCMReframe Cannot find wave data chink afetr %d bytes, aborting\n", ctx->probe_data_size));
+			wav_ok = GF_FALSE;
+		}
+
+		ctx->wav_hdr_size = (u32) gf_bs_get_position(bs);
+
+		gf_bs_del(bs);
+		if (!wav_ok) {
+			gf_filter_pid_drop_packet(ctx->ipid);
+			if (ctx->opid)
+				gf_filter_pid_set_eos(ctx->opid);
+			gf_filter_pid_set_discard(ctx->ipid, GF_TRUE);
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("PCMReframe Invalid or unsupported WAVE header, aborting\n", ctx->probe_data_size));
+			return GF_NON_COMPLIANT_BITSTREAM;
+		}
+
+		ctx->probe_wave = 2;
+		pcmreframe_configure_pid(filter, ctx->ipid, GF_FALSE);
+		if (ctx->probe_data) {
+			pck_size = ctx->probe_data_size;
+			data = ctx->probe_data;
+		}
+		pck_size -= ctx->wav_hdr_size;
+		data+=ctx->wav_hdr_size;
+		byte_offset = 0;
+	}
+	byte_offset+= ctx->wav_hdr_size;
+
 	while (pck_size) {
 		if (!ctx->out_pck) {
 			ctx->out_pck = gf_filter_pck_new_alloc(ctx->opid, ctx->frame_size, &ctx->out_data);
@@ -282,7 +388,7 @@
 				gf_filter_pid_drop_packet(ctx->ipid);
 				//post a seek, this will trash remaining packets in buffers
 				GF_FEVT_INIT(fevt, GF_FEVT_SOURCE_SEEK, ctx->ipid);
-				fevt.seek.start_offset = ctx->filepos;
+				fevt.seek.start_offset = ctx->filepos + ctx->wav_hdr_size;
 				gf_filter_pid_send_event(ctx->ipid, &fevt);
 				return GF_OK;
 			}
@@ -290,13 +396,41 @@
 		}
 	}
 	gf_filter_pid_drop_packet(ctx->ipid);
+
+	if (ctx->probe_data) {
+		gf_free(ctx->probe_data);
+		ctx->probe_data = NULL;
+		ctx->probe_data_size = 0;
+	}
 	return GF_OK;
 }
 
+static const char *pcmreframe_probe_data(const u8 *data, u32 size, GF_FilterProbeScore *score)
+{
+	if (size<20) return NULL;
+
+	GF_BitStream *bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
+	u32 code = gf_bs_read_u32(bs);
+	if (code == GF_4CC('R', 'I', 'F', 'F')) {
+		gf_bs_read_u32(bs);
+		code = gf_bs_read_u32(bs);
+		if (code == GF_4CC('W', 'A', 'V', 'E')) {
+			*score = GF_FPROBE_SUPPORTED;
+			gf_bs_del(bs);
+			return "audio/wav";
+		}
+	}
+	gf_bs_del(bs);
+	*score = GF_FPROBE_EXT_MATCH;
+	return gf_audio_fmt_all_shortnames();
+}
+
+
 static void pcmreframe_finalize(GF_Filter *filter)
 {
 	GF_PCMReframeCtx *ctx = gf_filter_get_udta(filter);
 	if (ctx->out_pck) gf_filter_pck_discard(ctx->out_pck);
+	if (ctx->probe_data) gf_free(ctx->probe_data);
 }
 
 static GF_FilterCapability PCMReframeCaps =
@@ -304,9 +438,13 @@
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "pcm"),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "audio/x-pcm"),
-	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
-	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
-	CAP_BOOL(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
+	CAP_UINT(GF_CAPS_OUTPUT_STATIC, GF_PROP_PID_CODECID, GF_CODECID_RAW),
+	CAP_BOOL(GF_CAPS_OUTPUT_STATIC_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "wav"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "audio/wav"),
 };
 
 #define OFFS(_n)	#_n, offsetof(GF_PCMReframeCtx, _n)
@@ -323,14 +461,15 @@
 GF_FilterRegister PCMReframeRegister = {
 	.name = "rfpcm",
 	GF_FS_SET_DESCRIPTION("PCM reframer")
-	GF_FS_SET_HELP("This filter parses raw PCM file/data and outputs corresponding raw audio PID and frames.")
+	GF_FS_SET_HELP("This filter parses raw PCM file/data or WAVE files and outputs corresponding raw audio PID and frames.")
 	.private_size = sizeof(GF_PCMReframeCtx),
 	.args = PCMReframeArgs,
 	SETCAPS(PCMReframeCaps),
 	.finalize = pcmreframe_finalize,
 	.configure_pid = pcmreframe_configure_pid,
 	.process = pcmreframe_process,
-	.process_event = pcmreframe_process_event
+	.process_event = pcmreframe_process_event,
+	.probe_data = pcmreframe_probe_data
 };

gpac-2.0.0.tar.gz/src/filters/reframe_rawvid.c -> gpac-2.2.0.tar.gz/src/filters/reframe_rawvid.c Changed

@@ -94,6 +94,7 @@
 		if (p && p->value.string) {
 			if (!strcmp(p->value.string, "v210")) {
 				ctx->is_v210 = GF_TRUE;
+				ctx->spfmt = GF_PIXEL_V210;
 			} else {
 				ctx->spfmt = gf_pixel_fmt_parse(p->value.string);
 			}
@@ -130,11 +131,7 @@
 	gf_filter_pid_copy_properties(ctx->opid, ctx->ipid);
 	gf_filter_pid_set_framing_mode(ctx->ipid, GF_FALSE);
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_VISUAL));
-	if (ctx->is_v210) {
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_V210));
-	} else {
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
-	}
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_RAW));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_WIDTH, &PROP_UINT(ctx->size.x));
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_HEIGHT, &PROP_UINT(ctx->size.y));
 	if (ctx->spfmt)
@@ -444,26 +441,20 @@
 		*score = GF_FPROBE_MAYBE_SUPPORTED;
 		return "video/x-yuv4mpeg";
 	}
-	return NULL;
+	*score = GF_FPROBE_EXT_MATCH;
+	return gf_pixel_fmt_all_shortnames();
 }
 
 static GF_FilterCapability RawVidReframeCaps =
 {
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "yuv"),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "video/x-yuv"),
+	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "video/x-raw"),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
 	CAP_BOOL(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
 	{0},
 	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "v210"),
-	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "video/x-raw-v210"),
-	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
-	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_V210),
-	CAP_BOOL(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
-	{0},
-	CAP_UINT(GF_CAPS_INPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_FILE_EXT, "y4m"),
 	CAP_STRING(GF_CAPS_INPUT, GF_PROP_PID_MIME, "video/x-yuv4mpeg"),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),

gpac-2.0.0.tar.gz/src/filters/reframe_truehd.c -> gpac-2.2.0.tar.gz/src/filters/reframe_truehd.c Changed

@@ -51,11 +51,15 @@
 {
 	//filter args
 	Double index;
+	Bool auxac3;
 
-	//only one input pid declared
+	//only one input pid
 	GF_FilterPid *ipid;
-	//only one output pid declared
+	//truehd output pid
 	GF_FilterPid *opid;
+	//aux AC3 output pid
+	GF_FilterPid *aux_opid;
+	GF_Filter *filter;
 
 	GF_BitStream *bs;
 	u64 file_pos, cts;
@@ -73,11 +77,17 @@
 	Bool is_file, file_loaded;
 	Bool initial_play_done;
 
+	//ref src pck
 	GF_FilterPacket *src_pck;
+	//current src, not ref
+	GF_FilterPacket *src_current;
 
 	TrueHDIdx *indexes;
 	u32 index_alloc_size, index_size;
 	Bool copy_props;
+
+	GF_AC3Header ac3_hdr;
+	Bool is_sync;
 } GF_TrueHDDmxCtx;
 
 
@@ -99,6 +109,7 @@
 	if (! gf_filter_pid_check_caps(pid))
 		return GF_NOT_SUPPORTED;
 
+	ctx->filter = filter;
 	ctx->ipid = pid;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
 	if (p) ctx->timescale = p->value.uint;
@@ -112,17 +123,86 @@
 	return GF_OK;
 }
 
-static GF_Err truehd_parse_frame(GF_BitStream *bs, TrueHDHdr *hdr)
+static void truehd_aux_ac3(GF_TrueHDDmxCtx *ctx, GF_BitStream *bs, GF_AC3Header *hdr)
+{
+	u8 *data;
+	u32 size;
+
+	if (!ctx->aux_opid) {
+		ctx->aux_opid = gf_filter_pid_new(ctx->filter);
+		if (!ctx->aux_opid) return;
+		gf_filter_pid_set_name(ctx->aux_opid, "aux_ac3");
+	}
+
+	if (memcmp(&ctx->ac3_hdr, hdr, sizeof(GF_AC3Header))) {
+		memcpy(&ctx->ac3_hdr, hdr, sizeof(GF_AC3Header));
+
+		//copy properties from output pid
+		if (ctx->opid) {
+			gf_filter_pid_copy_properties(ctx->aux_opid, ctx->opid);
+		} else {
+			gf_filter_pid_copy_properties(ctx->aux_opid, ctx->ipid);
+		}
+		//don't change codec type if reframing an ES (for HLS SAES)
+		gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_STREAM_TYPE, & PROP_UINT( GF_STREAM_AUDIO));
+		gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_CODECID, & PROP_UINT( GF_CODECID_AC3));
+		gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_UNFRAMED, & PROP_BOOL(GF_FALSE) );
+
+		if (ctx->duration.num)
+			gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_DURATION, & PROP_FRAC64(ctx->duration));
+
+		gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_TIMESCALE, & PROP_UINT(ctx->timescale ? ctx->timescale : hdr->sample_rate));
+		gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_SAMPLE_RATE, & PROP_UINT(hdr->sample_rate));
+		gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_NUM_CHANNELS, & PROP_UINT(hdr->streams0.channels) );
+
+		gf_odf_ac3_cfg_write(hdr, &data, &size);
+		gf_filter_pid_set_property(ctx->aux_opid, GF_PROP_PID_DECODER_CONFIG, & PROP_DATA_NO_COPY(data, size) );
+	}
+
+	GF_FilterPacket *dst_pck = gf_filter_pck_new_alloc(ctx->aux_opid, hdr->framesize, &data);
+	gf_bs_read_data(bs, data, hdr->framesize);
+	gf_filter_pck_merge_properties(ctx->src_pck ? ctx->src_pck : ctx->src_current, dst_pck);
+	gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
+
+	gf_filter_pck_set_dts(dst_pck, ctx->cts);
+	gf_filter_pck_set_cts(dst_pck, ctx->cts);
+	gf_filter_pck_set_sap(dst_pck, GF_FILTER_SAP_1);
+	gf_filter_pck_set_framing(dst_pck, GF_TRUE, GF_TRUE);
+	gf_filter_pck_send(dst_pck);
+}
+
+static GF_Err truehd_parse_frame(GF_TrueHDDmxCtx *ctx, GF_BitStream *bs, TrueHDHdr *hdr, u64 *frame_start)
 {
 	memset(hdr, 0, sizeof(TrueHDHdr));
 
 	u32 avail = (u32) gf_bs_available(bs);
+	*frame_start = gf_bs_get_position(bs);
+	hdr->frame_size = 0;
 	//we need 8 bytes for base header (up to sync marker)
-	if (avail<8) {
-		hdr->frame_size = 0;
-		return GF_OK;
+	if (avail<8)
+		return GF_BUFFER_TOO_SMALL;
+
+	while (gf_bs_available(bs)) {
+		u32 sync = gf_bs_peek_bits(bs, 16, 0);
+		if (sync==0x0B77) {
+			GF_AC3Header ac3hdr;
+			if (!gf_ac3_parser_bs(bs, &ac3hdr, GF_TRUE))
+				return GF_OK;
+			//make sure we have the complete frame + 8 byte of TrueHD header
+			if (gf_bs_available(bs) < ac3hdr.framesize + 8)
+				return GF_BUFFER_TOO_SMALL;
+
+			if (ctx && ctx->auxac3 && ctx->is_playing) {
+				truehd_aux_ac3(ctx, bs, &ac3hdr);
+			} else {
+				gf_bs_skip_bytes(bs, ac3hdr.framesize);
+			}
+			avail = (u32) gf_bs_available(bs);
+			*frame_start = gf_bs_get_position(bs);
+			continue;
+		}
+		break;
 	}
-
 	/*u8 nibble = */gf_bs_read_int(bs, 4);
 	hdr->frame_size = 2 * gf_bs_read_int(bs, 12);
 	hdr->time = gf_bs_read_u16(bs);
@@ -135,7 +215,7 @@
 	//we need 12 bytes until peak rate - to update if we decide to parse more
 	if (avail < 12) {
 		hdr->frame_size = 0;
-		return GF_OK;
+		return GF_BUFFER_TOO_SMALL;
 	}
 
 	hdr->format = gf_bs_peek_bits(bs, 32, 0);
@@ -225,8 +305,8 @@
 	cur_dur = 0;
 	while (	gf_bs_available(bs) > 8 ) {
 		TrueHDHdr hdr;
-		u64 pos = gf_bs_get_position(bs);
-		GF_Err e = truehd_parse_frame(bs, &hdr);
+		u64 pos;
+		GF_Err e = truehd_parse_frame(NULL, bs, &hdr, &pos);
 		if (e) break;
 
 		if (hdr.sync) {
@@ -410,6 +490,7 @@
 	case GF_FEVT_STOP:
 		//don't cancel event
 		ctx->is_playing = GF_FALSE;
+		ctx->cts = 0;
 		return GF_FALSE;
 
 	case GF_FEVT_SET_SPEED:
@@ -457,6 +538,8 @@
 			if (!ctx->truehd_buffer_size) {
 				if (ctx->opid)
 					gf_filter_pid_set_eos(ctx->opid);
+				if (ctx->aux_opid)
+					gf_filter_pid_set_eos(ctx->aux_opid);
 				if (ctx->src_pck) gf_filter_pck_unref(ctx->src_pck);
 				ctx->src_pck = NULL;
 				return GF_EOS;
@@ -498,6 +581,9 @@
 	//input pid sets some timescale - we flushed pending data , update cts
 	if (ctx->timescale && pck) {
 		cts = gf_filter_pck_get_cts(pck);
+		//init cts at first packet
+		if (!ctx->cts && (cts != GF_FILTER_NO_TS))
+			ctx->cts = cts;
 	}
 
 	if (cts == GF_FILTER_NO_TS) {
@@ -507,6 +593,7 @@
 
 	remain = ctx->truehd_buffer_size;
 	start = ctx->truehd_buffer;
+	ctx->src_current = pck;
 
 	if (ctx->resume_from) {
 		start += ctx->resume_from - 1;
@@ -522,10 +609,13 @@
 	while (remain > 8) {
 		u8 *frame;
 		TrueHDHdr hdr;
-		u32 frame_start, bytes_to_drop=0;
-
-		frame_start = (u32) gf_bs_get_position(ctx->bs);
-		e = truehd_parse_frame(ctx->bs, &hdr);
+		u32 bytes_to_drop=0;
+		u64 frame_start;
+		e = truehd_parse_frame(ctx, ctx->bs, &hdr, &frame_start);
+		if (e==GF_BUFFER_TOO_SMALL) {
+			e = GF_OK;
+			break;
+		}
 		if (e) {
 			remain = 0;
 			break;
@@ -547,7 +637,11 @@
 			return GF_OK;
 		}
 
-		frame = start + frame_start;
+		if (frame_start) {
+			start += frame_start;
+			remain -= (u32) frame_start;
+		}
+		frame = start;
 
 		if (ctx->in_seek) {
 			u64 nb_samples_at_seek = (u64) (ctx->start_range * hdr.sample_rate);
@@ -564,21 +658,29 @@
 				ctx->cts = cts;
 			cts = GF_FILTER_NO_TS;
 		}
+		if (!ctx->sample_rate) {
+			GF_LOG(ctx->is_sync ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_MEDIA, ("TrueHDDmx Invalid TrueHD frame, no sample rate found\n"));
+			ctx->is_sync = GF_FALSE;
+			remain = 0;
+			break;
+		}
+		ctx->is_sync = GF_TRUE;
 
 		if (!ctx->in_seek) {
 			dst_pck = gf_filter_pck_new_alloc(ctx->opid, hdr.frame_size, &output);
 			if (!dst_pck) return GF_OUT_OF_MEM;
-			if (ctx->src_pck) gf_filter_pck_merge_properties(ctx->src_pck, dst_pck);
+			gf_filter_pck_merge_properties(ctx->src_pck ? ctx->src_pck : ctx->src_current, dst_pck);
 
 			memcpy(output, frame, hdr.frame_size);
 			gf_filter_pck_set_dts(dst_pck, ctx->cts);
 			gf_filter_pck_set_cts(dst_pck, ctx->cts);
-			if (hdr.sync)
-				gf_filter_pck_set_sap(dst_pck, GF_FILTER_SAP_1);
+			gf_filter_pck_set_sap(dst_pck, hdr.sync ? GF_FILTER_SAP_1 : GF_FILTER_SAP_NONE);
 			gf_filter_pck_set_framing(dst_pck, GF_TRUE, GF_TRUE);
 
 			if (ctx->byte_offset != GF_FILTER_NO_BO) {
-				gf_filter_pck_set_byte_offset(dst_pck, ctx->byte_offset + hdr.frame_size);
+				gf_filter_pck_set_byte_offset(dst_pck, ctx->byte_offset + hdr.frame_size + frame_start);
+			} else {
+				gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
 			}
 
 			gf_filter_pck_send(dst_pck);
@@ -616,7 +718,7 @@
 		ctx->truehd_buffer_size = 0;
 		return truehd_process(filter);
 	} else {
-		if (remain) {
+		if (remain && (remain<ctx->truehd_buffer_size)) {
 			memmove(ctx->truehd_buffer, start, remain);
 		}
 		ctx->truehd_buffer_size = remain;
@@ -639,8 +741,8 @@
 	GF_BitStream *bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
 	while (gf_bs_available(bs) > 8 ) {
 		TrueHDHdr hdr;
-		u64 pos = gf_bs_get_position(bs);
-		GF_Err e = truehd_parse_frame(bs, &hdr);
+		u64 pos;
+		GF_Err e = truehd_parse_frame(NULL, bs, &hdr, &pos);
 		if (e || !hdr.frame_size) {
 			nb_frames = 0;
 			break;
@@ -674,6 +776,7 @@
 static const GF_FilterArgs TrueHDDmxArgs =
 {
 	{ OFFS(index), "indexing window length", GF_PROP_DOUBLE, "1.0", NULL, 0},
+	{ OFFS(auxac3), "expose auxiliary AC-3 stream if present", GF_PROP_BOOL, "false", NULL, 0},
 	{0}
 };

gpac-2.0.0.tar.gz/src/filters/reframer.c -> gpac-2.2.0.tar.gz/src/filters/reframer.c Changed

@@ -52,6 +52,14 @@
 
 enum
 {
+	UTCREF_LOCAL=0,
+	UTCREF_ANY,
+	UTCREF_MEDIA,
+};
+
+
+enum
+{
 	EXTRACT_NONE=0,
 	EXTRACT_RANGE,
 	EXTRACT_SAP,
@@ -120,6 +128,9 @@
 	u64 probe_ref_frame_ts;
 
 	Bool fetch_done;
+
+	u64 last_utc_ref, last_utc_ref_ts;
+
 } RTStream;
 
 typedef struct
@@ -127,14 +138,14 @@
 	//args
 	Bool exporter;
 	GF_PropUIntList saps;
-	GF_PropUIntList frames;
+	GF_PropIntList frames;
 	Bool refs;
 	u32 rt;
 	Double speed;
 	u32 raw;
 	GF_PropStringList xs, xe;
-	Bool nosap, splitrange, xadjust, tcmdrw, no_audio_seek, probe_ref;
-	u32 xround;
+	Bool nosap, splitrange, xadjust, tcmdrw, no_audio_seek, probe_ref, xots;
+	u32 xround, utc_ref, utc_probe;
 	Double seeksafe;
 	GF_PropStringList props;
 
@@ -148,11 +159,14 @@
 	GF_List *streams;
 	RTStream *clock;
 
+	Double rt_speed;
 	u64 reschedule_in;
 	u64 clock_val;
 
 	u32 range_type;
 	u32 cur_range_idx;
+	//if cur_start.den is 0, cur_start.num is UTC start time
+	//if cur_end.den is 0, cur_start.num is UTC stop time, only if cur_start uses UTC
 	GF_Fraction64 cur_start, cur_end;
 	u64 start_frame_idx_plus_one, end_frame_idx_plus_one;
 
@@ -187,20 +201,26 @@
 	u64 flush_max_ts;
 	u32 flush_max_ts_scale;
 
+	u64 last_utc_time_s;
+	u32 last_clock_probe;
 } GF_ReframerCtx;
 
-static void reframer_reset_stream(GF_ReframerCtx *ctx, RTStream *st)
+static void reframer_reset_stream(GF_ReframerCtx *ctx, RTStream *st, Bool do_free)
 {
 	if (st->pck_queue) {
 		while (gf_list_count(st->pck_queue)) {
 			GF_FilterPacket *pck = gf_list_pop_front(st->pck_queue);
 			gf_filter_pck_unref(pck);
 		}
-		gf_list_del(st->pck_queue);
+		if (do_free)
+			gf_list_del(st->pck_queue);
 	}
 	if (st->split_pck) gf_filter_pck_unref(st->split_pck);
+	st->split_pck = NULL;
 	if (st->reinsert_single_pck) gf_filter_pck_unref(st->reinsert_single_pck);
-	gf_free(st);
+	st->reinsert_single_pck = NULL;
+	if (do_free)
+		gf_free(st);
 }
 
 static void reframer_push_props(GF_ReframerCtx *ctx, RTStream *st)
@@ -236,7 +256,7 @@
 			if (st->opid)
 				gf_filter_pid_remove(st->opid);
 			gf_list_del_item(ctx->streams, st);
-			reframer_reset_stream(ctx, st);
+			reframer_reset_stream(ctx, st, GF_TRUE);
 		}
 		return GF_OK;
 	}
@@ -363,7 +383,7 @@
 	return GF_OK;
 }
 
-static Bool reframer_parse_date(char *date, GF_Fraction64 *value, u64 *frame_idx_plus_one, u32 *extract_mode)
+static Bool reframer_parse_date(char *date, GF_Fraction64 *value, u64 *frame_idx_plus_one, u32 *extract_mode, Bool *is_dur)
 {
 	u64 v;
 	value->num =0;
@@ -371,6 +391,8 @@
 
 	if (extract_mode)
 		*extract_mode = EXTRACT_RANGE;
+	if (is_dur)
+		*is_dur = GF_FALSE;
 
 	if (date0 == 'T') {
 		u32 h=0, m=0, s=0, ms=0;
@@ -414,12 +436,21 @@
 	if ((date0=='D') || (date0=='d')) {
 		if (extract_mode)
 			*extract_mode = EXTRACT_DUR;
+		if (is_dur)
+			*is_dur = GF_TRUE;
+
 		if (sscanf(date+1, LLD"/"LLU, &value->num, &value->den)==2) {
 			return GF_TRUE;
 		}
+		if (strchr(date+1, '.')) {
+			Double res = atof(date+1);
+			value->den = 1000000;
+			value->num = (s64) (res * value->den);
+			return GF_TRUE;
+		}
 		if (sscanf(date+1, LLU, &v)==1) {
 			value->num = v;
-			value->den = 1000;
+			value->den = 1;
 			return GF_TRUE;
 		}
 	}
@@ -433,6 +464,11 @@
 			return GF_TRUE;
 		}
 	}
+	if (strchr(date, 'T')) {
+		value->num = gf_net_parse_date(date);
+		value->den = 0;
+		return GF_TRUE;
+	}
 
 	if (gf_parse_lfrac(date, value)) {
 		return GF_TRUE;
@@ -501,7 +537,7 @@
 	if (!end_date) ctx->range_type = RANGE_OPEN;
 	else ctx->range_type = RANGE_CLOSED;
 
-	if (!reframer_parse_date(start_date, &ctx->cur_start, &ctx->start_frame_idx_plus_one, &ctx->extract_mode)) {
+	if (!reframer_parse_date(start_date, &ctx->cur_start, &ctx->start_frame_idx_plus_one, &ctx->extract_mode, NULL)) {
 		GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Reframer cannot parse start date, assuming end of ranges\n"));
 		//done
 		ctx->range_type = RANGE_DONE;
@@ -530,6 +566,8 @@
 	if (ctx->cur_range_idx==1) {
 		do_seek = GF_FALSE;
 	}
+	if (!ctx->cur_start.den)
+		do_seek = GF_FALSE;
 
 	if (!ctx->seekable && do_seek) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Reframer ranges not in order and input not seekable, aborting extraction\n"));
@@ -564,13 +602,20 @@
 		}
 	}
 	if (end_date) {
-		if (!reframer_parse_date(end_date, &ctx->cur_end, &ctx->end_frame_idx_plus_one, NULL)) {
+		Bool is_dur = GF_FALSE;
+		if (!reframer_parse_date(end_date, &ctx->cur_end, &ctx->end_frame_idx_plus_one, NULL, &is_dur)) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Reframer cannot parse end date, assuming open range\n"));
 			ctx->range_type = RANGE_OPEN;
-		}
-		else if (gf_timestamp_greater_or_equal(ctx->cur_start.num, ctx->cur_start.den, ctx->cur_end.num, ctx->cur_end.den) ) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Reframer End range before start range, assuming open range\n"));
-			ctx->range_type = RANGE_OPEN;
+		} else {
+			if (is_dur) {
+				ctx->cur_end.num = gf_timestamp_rescale(ctx->cur_end.num, ctx->cur_end.den, ctx->cur_start.den);
+				ctx->cur_end.den = ctx->cur_start.den;
+				ctx->cur_end.num += ctx->cur_start.num;
+			}
+			if (gf_timestamp_greater_or_equal(ctx->cur_start.num, ctx->cur_start.den, ctx->cur_end.num, ctx->cur_end.den) ) {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Reframer End range before start range, assuming open range\n"));
+				ctx->range_type = RANGE_OPEN;
+			}
 		}
 	}
 
@@ -700,8 +745,8 @@
 				do_send = GF_TRUE;
 			} else {
 				u64 diff = cts_us - st_clock->cts_us_at_init;
-				if (ctx->speed>0) diff = (u64) ( diff / ctx->speed);
-				else if (ctx->speed<0) diff = (u64) ( diff / -ctx->speed);
+				if (ctx->rt_speed>0) diff = (u64) ( diff / ctx->rt_speed);
+				else if (ctx->rt_speed<0) diff = (u64) ( diff / -ctx->rt_speed);
 
 				clock -= st_clock->sys_clock_at_init;
 				if (clock + RT_PRECISION_US >= diff) {
@@ -724,9 +769,17 @@
 		u32 i;
 		Bool found=GF_FALSE;
 		for (i=0; i<ctx->frames.nb_items; i++) {
-			if (ctx->frames.valsi == st->nb_frames + 1) {
-				found=GF_TRUE;
-				break;
+			s32 v = ctx->frames.valsi;
+			if (v>=0) {
+				if (v == st->nb_frames + 1) {
+					found=GF_TRUE;
+					break;
+				}
+			} else {
+				if (st->nb_frames % (-v) == 0) {
+					found=GF_TRUE;
+					break;
+				}
 			}
 		}
 		if (!found) {
@@ -927,15 +980,17 @@
 					}
 				}
 			}
+			if (!ctx->xots) {
+				ts += st->tk_delay;
+				ts += st->ts_at_range_end;
+				ts -= st->ts_at_range_start_plus_one - 1;
 
-			ts += st->tk_delay;
-			ts += st->ts_at_range_end;
-			ts -= st->ts_at_range_start_plus_one - 1;
-
-			if (ts<0) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Reframer Negative TS while splitting, something went wrong during range estimation, forcing to 0\n"));
-				ts = 0;
+				if (ts<0) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Reframer Negative TS while splitting, something went wrong during range estimation, forcing to 0\n"));
+					ts = 0;
+				}
 			}
+
 			if (st->probe_ref_frame_ts && (gf_filter_pck_get_dts(pck) + st->tk_delay + 1 == st->probe_ref_frame_ts)) {
 				gf_filter_pck_set_property(new_pck, GF_PROP_PCK_SKIP_PRES, &PROP_BOOL(GF_TRUE));
 			}
@@ -945,7 +1000,7 @@
 				gf_filter_pck_set_dts(new_pck, ts);
 			}
 		}
-		if (!st->is_raw) {
+		if (!st->is_raw && !ctx->xots) {
 			ts = gf_filter_pck_get_dts(pck) + cts_offset;
 			if (ts != GF_FILTER_NO_TS) {
 				ts += st->tk_delay;
@@ -1007,7 +1062,7 @@
 	return GF_TRUE;
 }
 
-static u32 reframer_check_pck_range(GF_ReframerCtx *ctx, RTStream *st, u64 ts, u32 dur, u32 frame_idx, u32 *nb_audio_samples_to_keep)
+static u32 reframer_check_pck_range(GF_Filter *filter, GF_ReframerCtx *ctx, RTStream *st, GF_FilterPacket *pck, u64 ts, u32 dur, u32 frame_idx, u32 *nb_audio_samples_to_keep)
 {
 	if (ctx->start_frame_idx_plus_one) {
 		//frame not after our range start
@@ -1020,10 +1075,103 @@
 			}
 			return 1;
 		}
-	} else {
-		Bool before = GF_FALSE;
-		Bool after = GF_FALSE;
+		return 0;
+	}
+
+	Bool before = GF_FALSE;
+	Bool after = GF_FALSE;
+
+	if (!ctx->cur_start.den) {
+		u64 now=0;
+		if (ctx->utc_ref) {
+			//check sender NTP on packet
+			const GF_PropertyValue *date = gf_filter_pck_get_property(pck, GF_PROP_PCK_SENDER_NTP);
+			if (date) {
+				now = gf_net_ntp_to_utc(date->value.longuint);
+				st->last_utc_ref = now;
+				st->last_utc_ref_ts = ts;
+			}
+			//otherwise check UTC date mapping
+			else {
+				date = gf_filter_pck_get_property(pck, GF_PROP_PCK_UTC_TIME);
+				if (date) {
+					ctx->last_clock_probe=0;
+					st->last_utc_ref = date->value.longuint;
+					st->last_utc_ref_ts = ts;
+				}
+				//otherwise interpolate from last mapping
+				else if (st->last_utc_ref && st->last_utc_ref_ts) {
+					s64 diff_ms = (s64) ts;
+					diff_ms -= (s64) st->last_utc_ref_ts;
+					diff_ms = gf_timestamp_rescale_signed(diff_ms, st->timescale, 1000);
+					now = st->last_utc_ref;
+					now += diff_ms;
+				}
+			}
+
+			if (!now && !st->last_utc_ref) {
+				if (!ctx->last_clock_probe) ctx->last_clock_probe = gf_sys_clock();
+				else if (gf_sys_clock() - ctx->last_clock_probe > ctx->utc_probe) {
+					if (ctx->utc_ref==UTCREF_ANY) {
+						now = gf_net_get_utc();
+						ctx->utc_ref = UTCREF_LOCAL;
+						GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("Reframer Failed to acquire UTC mapping from media, will use local host\n"));
+					} else {
+						GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("Reframer Failed to acquire UTC mapping from media, aborting\n"));
+						ctx->cur_range_idx = ctx->xs.nb_items;
+						return 2;
+					}
+				}
+			}
+			//time not yet known, consider we are before
+			if (!now)
+				return 0;
+		} else {
+			now = gf_net_get_utc();
+		}
 
+		if (now < (u64) ctx->cur_start.num) {
+			before = GF_TRUE;
+			u64 time = (ctx->cur_start.num - now) / 1000;
+
+			if (!ctx->last_utc_time_s || (ctx->last_utc_time_s-2>time)) {
+				u32 h, m, s;
+				char szStatus100;
+				ctx->last_utc_time_s = time+2;
+				h = (u32) (time/3600);
+				m = (u32) (time/60 - h*60);
+				s = (u32) (time - m*60 - h*3660);
+				if (h>24) {
+					u32 days = h/24;
+					sprintf(szStatus, "Next range start in %d days", days);
+				} else {
+					sprintf(szStatus, "Next range start in %02d:%02d:%02d", h, m, s);
+				}
+				if (gf_filter_reporting_enabled(filter)) {
+					gf_filter_update_status(filter, 0, szStatus);
+				} else {
+					GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("Reframer %s\r", szStatus));
+				}
+			}
+		} else if (ctx->last_utc_time_s!=1) {
+			ctx->last_utc_time_s = 1;
+			if (gf_filter_reporting_enabled(filter)) {
+				gf_filter_update_status(filter, 0, "");
+			} else {
+				GF_LOG(GF_LOG_INFO, GF_LOG_APP, (" \r"));
+			}
+		}
+
+		if (ctx->cur_end.num) {
+			u64 end;
+			if (ctx->cur_end.den)
+				end = ctx->cur_start.num + (ctx->cur_end.num*1000) / ctx->cur_end.den;
+			else
+				end = ctx->cur_end.num;
+			if (now>end)
+				after = GF_TRUE;
+		}
+	} else {
 		//check ts not after our range start:
 		//if round_seek mode, check TS+dur is less than or equal to desired start, and we will notify the duration of data to skip from the packet
 		//otherwise, check TS is strictly less than desired start
@@ -1061,18 +1209,18 @@
 			}
 			after = GF_TRUE;
 		}
-		if (before) {
-			if (!after)
-				return 0;
-			//long duration samples (typically text) can both start before and end after the target range
-			else
-				return 2;
-		}
-		if (after)
+	}
+
+	if (before) {
+		if (!after)
+			return 0;
+		//long duration samples (typically text) can both start before and end after the target range
+		else
 			return 2;
-		return 1;
 	}
-	return 0;
+	if (after)
+		return 2;
+	return 1;
 }
 
 void reframer_purge_queues(GF_ReframerCtx *ctx, u64 ts, u32 timescale)
@@ -1710,7 +1858,7 @@
 			}
 
 			//check if packet is in our range
-			pck_in_range = reframer_check_pck_range(ctx, st, check_ts, dur, st->nb_frames_range, &nb_audio_samples_to_keep);
+			pck_in_range = reframer_check_pck_range(filter, ctx, st, pck, check_ts, dur, st->nb_frames_range, &nb_audio_samples_to_keep);
 
 
 			//SAP packet, decide if we cut here or at previous SAP
@@ -1824,8 +1972,12 @@
 						st->sap_ts_plus_one = st->prev_sap_ts + 1;
 						st->range_start_computed = 1;
 						nb_start_range_reached++;
-						if (st->prev_sap_ts == ts)
+						//for UTC case, if range is empty discard everything
+						if (!ctx->cur_start.den) {
+							reframer_reset_stream(ctx, st, GF_FALSE);
+						} else if (st->prev_sap_ts == ts) {
 							enqueue = GF_TRUE;
+						}
 					}
 					//remember the timestamp of first packet after range
 					st->range_end_reached_ts = ts + 1;
@@ -1970,7 +2122,7 @@
 			} else {
 				min_ts -= 1;
 
-				if ((ctx->extract_mode==EXTRACT_RANGE) && (ctx->xround!=REFRAME_ROUND_SEEK)) {
+				if (ctx->cur_start.den && (ctx->extract_mode==EXTRACT_RANGE) && (ctx->xround!=REFRAME_ROUND_SEEK)) {
 					ctx->cur_start.num = min_ts;
 					ctx->cur_start.den = min_timescale;
 				}
@@ -2072,13 +2224,14 @@
 				//we couldn't find a sample with dts >= to our min_ts - this happens when the min_ts
 				//is located a few seconds AFTER the target split point
 				//so force stream to reevaluate and enqueue more packets
-				if (!start_found && !st->use_blocking_refs) {
+				if (ctx->cur_start.den && !start_found && !st->use_blocking_refs) {
 					st->range_start_computed = 0;
 					return GF_OK;
 				}
 			}
 
 			//OK every stream has now packets starting at the min_ts, ready to go
+			const GF_PropertyValue *chap_times=NULL, *chap_names=NULL;
 			ctx->nb_video_frames_since_start = 0;
 			for (i=0; i<count; i++) {
 				GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
@@ -2104,6 +2257,13 @@
 						st->nb_frames_until_start = 0;
 					}
 				}
+
+				if (!chap_times && ctx->cur_start.den) {
+					chap_times = gf_filter_pid_get_property(st->ipid, GF_PROP_PID_CHAP_TIMES);
+					chap_names = gf_filter_pid_get_property(st->ipid, GF_PROP_PID_CHAP_NAMES);
+					if (!chap_times || !chap_names || (chap_times->value.uint_list.nb_items!=chap_names->value.string_list.nb_items))
+						chap_times = chap_names = NULL;
+				}
 			}
 			ctx->nb_video_frames_since_start_at_range_start = ctx->nb_video_frames_since_start;
 
@@ -2119,6 +2279,63 @@
 #ifdef DEBUG_RF_MEM_USAGE
 			reframer_dump_mem(ctx, "Starting new range");
 #endif
+
+			if (chap_times) {
+				GF_PropertyValue ch;
+				GF_PropUIntList new_times;
+				GF_PropStringList new_names;
+				u32 first_chap_idx=0, last_chap_idx=chap_times->value.uint_list.nb_items;
+				u32 cut_time = (u32) gf_timestamp_rescale(min_ts, min_timescale, 1000);
+				u32 out_time = 0;
+				if (ctx->range_type == RANGE_CLOSED) {
+					out_time = (u32) gf_timestamp_rescale(ctx->cur_end.num, ctx->cur_end.den, 1000);
+				}
+
+				for (i=0; i<chap_times->value.uint_list.nb_items; i++) {
+					if (chap_times->value.uint_list.valsi <= cut_time)
+						first_chap_idx = i;
+					if (!out_time) continue;
+
+					if (chap_times->value.uint_list.valsi == out_time)
+						break;
+
+					if (chap_times->value.uint_list.valsi > out_time) {
+						last_chap_idx = i+1;
+						break;
+					}
+				}
+				new_times.nb_items = last_chap_idx - first_chap_idx;
+				new_times.vals = gf_malloc(sizeof(u32)*new_times.nb_items);
+				new_names.nb_items = new_times.nb_items;
+				new_names.vals = gf_malloc(sizeof(char *)*new_names.nb_items);
+				u32 k=0;
+				for (i=first_chap_idx; i<last_chap_idx; i++) {
+					s64 time = chap_times->value.uint_list.valsi;
+					time -= cut_time;
+					if (time<0) time = 0;
+					new_times.valsk = (u32) time;
+					new_names.valsk = gf_strdup(chap_names->value.string_list.valsi);
+					k++;
+				}
+
+				//set chapter properties
+				for (i=0; i<count; i++) {
+					GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
+					RTStream *st = gf_filter_pid_get_udta(ipid);
+
+					ch.type = GF_PROP_UINT_LIST;
+					ch.value.uint_list = new_times;
+					gf_filter_pid_set_property(st->opid, GF_PROP_PID_CHAP_TIMES, &ch);
+
+					ch.type = GF_PROP_STRING_LIST_COPY;
+					ch.value.string_list = new_names;
+					gf_filter_pid_set_property(st->opid, GF_PROP_PID_CHAP_NAMES, &ch);
+				}
+				gf_free(new_times.vals);
+				ch.type = GF_PROP_STRING_LIST;
+				ch.value.string_list = new_names;
+				gf_props_reset_single(&ch);
+			}
 		}
 		if (!ctx->in_range && !ctx->flush_samples)
 			return GF_OK;
@@ -2369,7 +2586,8 @@
 		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Reframer `xround=seek` can only be used for single range extraction\n"));
 		return GF_BAD_PARAM;
 	}
-
+	if (ctx->speed != 0)
+		ctx->rt_speed = ctx->speed;
 
 	reframer_load_range(ctx);
 
@@ -2403,7 +2621,7 @@
 
 	//if range extraction based on time, adjust start range
 	if (evt->base.type==GF_FEVT_PLAY) {
-		if (ctx->range_type && !ctx->start_frame_idx_plus_one) {
+		if (ctx->range_type && !ctx->start_frame_idx_plus_one && ctx->cur_start.den) {
 			Double start_range = (Double) ctx->cur_start.num;
 			start_range /= ctx->cur_start.den;
 			//rewind safety offset
@@ -2418,8 +2636,14 @@
 		st->is_playing = GF_TRUE;
 		if (ctx->eos_state==1)
 			ctx->eos_state = 0;
+		if (ctx->speed==0)
+			ctx->rt_speed = evt->play.speed;
+
 	} else if (evt->base.type==GF_FEVT_STOP) {
 		st->is_playing = GF_FALSE;
+	} else if (evt->base.type==GF_FEVT_SET_SPEED) {
+		if (ctx->speed==0)
+			ctx->rt_speed = evt->play.speed;
 	}
 
 	gf_filter_pid_send_event(st->ipid, &fevt);
@@ -2432,7 +2656,7 @@
 
 	while (gf_list_count(ctx->streams)) {
 		RTStream *st = gf_list_pop_back(ctx->streams);
-		reframer_reset_stream(ctx, st);
+		reframer_reset_stream(ctx, st, GF_TRUE);
 	}
 	gf_list_del(ctx->streams);
 }
@@ -2448,7 +2672,7 @@
 	//we don't produce RAW streams during dynamic chain resolution - this will avoid loading the filter for compositor/other raw access
 	CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
 	//but we may produce raw streams when filter is explicitly loaded (media exporter)
-	CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER, GF_PROP_PID_CODECID, GF_CODECID_RAW)
+	CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER|GF_CAPFLAG_OPTIONAL, GF_PROP_PID_CODECID, GF_CODECID_RAW)
 };
 
 
@@ -2462,13 +2686,13 @@
 	"- sync: enables real-time regulation one clock for all PIDs", GF_PROP_UINT, "off", "off|on|sync", GF_FS_ARG_HINT_NORMAL},
 	{ OFFS(saps), "list of SAP types (0,1,2,3,4) to forward, other packets are dropped (forwarding only sap 0 will break the decoding)", GF_PROP_UINT_LIST, NULL, "0|1|2|3|4", GF_FS_ARG_HINT_NORMAL},
 	{ OFFS(refs), "forward only frames used as reference frames, if indicated in the input stream", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_NORMAL},
-	{ OFFS(speed), "speed for real-time regulation mode", GF_PROP_DOUBLE, "1.0", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(speed), "speed for real-time regulation mode, a value of 0 uses speed from play commands", GF_PROP_DOUBLE, "0.0", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(raw), "force input AV streams to be in raw format\n"
 	"- no: do not force decoding of inputs\n"
 	"- av: force decoding of audio and video inputs\n"
 	"- a: force decoding of audio inputs\n"
 	"- v: force decoding of video inputs", GF_PROP_UINT, "no", "av|a|v|no", GF_FS_ARG_HINT_NORMAL},
-	{ OFFS(frames), "drop all except listed frames (first being 1)", GF_PROP_UINT_LIST, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(frames), "drop all except listed frames (first being 1). A negative value `-V` keeps only first frame every `V` frames", GF_PROP_SINT_LIST, NULL, NULL, GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(xs), "extraction start time(s)", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_NORMAL},
 	{ OFFS(xe), "extraction end time(s). If less values than start times, the last time interval extracted is an open range", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_NORMAL},
 	{ OFFS(xround), "adjust start time of extraction range to I-frame\n"
@@ -2477,13 +2701,19 @@
 	"- after: use first I-frame (if any) following or matching range start\n"
 	"- closest: use I-frame closest to range start", GF_PROP_UINT, "before", "before|seek|after|closest", GF_FS_ARG_HINT_ADVANCED},
 	{ OFFS(xadjust), "adjust end time of extraction range to be before next I-frame", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(xots), "keep original timestamps after extraction", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(nosap), "do not cut at SAP when extracting range (may result in broken streams)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(splitrange), "signal file boundary at each extraction first packet for template-base file generation", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
-	{ OFFS(seeksafe), "rewind play requests by given seconds (to make sur I-frame preceding start is catched)", GF_PROP_DOUBLE, "10.0", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(seeksafe), "rewind play requests by given seconds (to make sure the I-frame preceding start is catched)", GF_PROP_DOUBLE, "10.0", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(tcmdrw), "rewrite TCMD samples when splitting", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(props), "extra output PID properties per extraction range", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(no_audio_seek), "disable seek mode on audio streams (no change of priming duration)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
 	{ OFFS(probe_ref), "allow extracted range to be longer in case of B-frames with reference frames presented outside of range", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
+	{ OFFS(utc_ref), "set reference mode for UTC range extraction\n"
+	"- local: use UTC of local host\n"
+	"- any: use UTC of media, or UTC of local host if not found in media after probing time\n"
+	"- media: use UTC of media (abort if none found)", GF_PROP_UINT, "any", "local|any|media", GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(utc_probe), "timeout in milliseconds to try to acquire UTC reference from media", GF_PROP_UINT, "5000", NULL, GF_FS_ARG_HINT_EXPERT},
 	{0}
 };
 
@@ -2521,11 +2751,12 @@
 		"The formats allowed for times specifiers are:\n"
 		"- 'T'H:M:S, 'T'M:S: specify time in hours, minutes, seconds\n"
 		"- 'T'H:M:S.MS, 'T'M:S.MS, 'T'S.MS: specify time in hours, minutes, seconds and milliseconds\n"
-		"- INT, FLOAT: specify time in seconds\n"
-		"- NUM/DEN: specify time in seconds as fraction\n"
+		"- INT, FLOAT, NUM/DEN: specify time in seconds (number or fraction)\n"
+		"- 'D'INT, 'D'FLOAT, 'D'NUM/DEN: specify end time as offset to start time in seconds (number or fraction) - only valid for -xe()\n"
 		"- 'F'NUM: specify time as frame number\n"
+		"- XML DateTime: specify absolute UTC time\n"
 		" \n"
-		"In this mode, the timestamps are rewritten to form a continuous timeline.\n"
+		"In this mode, the timestamps are rewritten to form a continuous timeline, unless -xots() is set.\n"
 		"When multiple ranges are given, the filter will try to seek if needed and supported by source.\n"
 		"\n"
 		"EX gpac -i m.mp4 reframer:xs=T00:00:10,T00:01:10,T00:02:00:xe=T00:00:20,T00:01:20 dst\n"
@@ -2535,8 +2766,8 @@
 		"- if a following start range is set, the end range is set to this next start\n"
 		"- otherwise, the end range is open\n"
 		"\n"
-		"EX gpac -i m.mp4 reframer:xs=0,10,25:xe=5 dst\n"
-		"This will extract the time ranges 0s,5s, 10s,25s and all media starting from 25s\n"
+		"EX gpac -i m.mp4 reframer:xs=0,10,25:xe=5,20 dst\n"
+		"This will extract the time ranges 0s,5s, 10s,20s and all media starting from 25s\n"
 		"EX gpac -i m.mp4 reframer:xs=0,10,25 dst\n"
 		"This will extract the time ranges 0s,10s, 10s,25s and all media starting from 25s\n"
 		"\n"
@@ -2570,21 +2801,31 @@
 		"Consequently, these streams will have modified edit lists in ISOBMFF which might not be properly handled by players.\n"
 		"This can be avoided using -no_audio_seek(), but this will introduce audio delay.\n"
 		"\n"
+		"# UTC-based range extraction\n"
+		"The filter can perform range extraction based on UTC time rather than media time. In this mode, the end time must be:\n"
+		"- a UTC date: range extraction will stop after this date\n"
+		"- a time in second: range extraction will stop after the specified duration\n"
+		"\n"
+		"The UTC reference is specified using -utc_ref().\n"
+		"If UTC signal from media source is used, the filter will probe for -utc_probe() before considering the source has no UTC signal.\n"
+		"\n"
+		"The properties `SenderNTP` and, if absent, `UTC` of source packets are checked for establishing the UTC reference.\n"
 		"# Other split actions\n"
 		"The filter can perform splitting of the source using -xs() option.\n"
 		"The additional formats allowed for -xs() option are:\n"
 		"- `SAP`: split source at each SAP/RAP\n"
-		"- `D`VAL: split source by chunks of `VAL` ms\n"
+		"- `D`VAL: split source by chunks of `VAL` seconds\n"
 		"- `D`NUM/DEN: split source by chunks of `NUM/DEN` seconds\n"
 		"- `S`VAL: split source by chunks of estimated size `VAL` bytes (can use property multipliers, e.g. `m`)\n"
 		"\n"
 		"Note: In these modes, -splitrange() and -xadjust() are implicitly set.\n"
+		"\n"
 	)
 	.private_size = sizeof(GF_ReframerCtx),
 	.max_extra_pids = (u32) -1,
 	.args = ReframerArgs,
 	//reframer is explicit only, so we don't load the reframer during resolution process
-	.flags = GF_FS_REG_EXPLICIT_ONLY|GF_FS_REG_ALLOW_CYCLIC,
+	.flags = GF_FS_REG_EXPLICIT_ONLY|GF_FS_REG_ALLOW_CYCLIC|GF_FS_REG_TEMP_INIT,
 	SETCAPS(ReframerCaps),
 	.initialize = reframer_initialize,
 	.finalize = reframer_finalize,

gpac-2.0.0.tar.gz/src/filters/resample_audio.c -> gpac-2.2.0.tar.gz/src/filters/resample_audio.c Changed

gpac-2.0.0.tar.gz/src/filters/restamp.c -> gpac-2.2.0.tar.gz/src/filters/restamp.c Changed

@@ -31,7 +31,7 @@
 typedef struct
 {
 	GF_FilterPid *ipid, *opid;
-	s64 ts_offset;
+	s64 ts_offset, ts_shift_plus_one;
 	Bool raw_vid_copy;
 	Bool is_audio, is_video;
 	s64 last_min_dts;
@@ -54,11 +54,14 @@
 
 typedef struct
 {
-	GF_Fraction fps, delay_v, delay_a, delay_t, delay_o;
+	GF_Fraction fps, delay, delay_v, delay_a, delay_t, delay_o;
+	GF_Fraction64 tsinit;
 	u32 rawv;
 
 	GF_List *pids;
 	Bool reconfigure;
+	Bool config_timing;
+	u32 config_retry;
 } RestampCtx;
 
 
@@ -92,6 +95,7 @@
 		gf_filter_pid_set_udta(pid, pctx);
 		pctx->opid = gf_filter_pid_new(filter);
 		if (!pctx->opid) return GF_OUT_OF_MEM;
+		ctx->config_timing = GF_TRUE;
 	}
 
 	pctx->raw_vid_copy = GF_FALSE;
@@ -135,7 +139,12 @@
 
 	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
 	u32 timescale = prop ? prop->value.uint : 1000;
-	s64 ts_offset = gf_timestamp_rescale_signed(delay->num, delay->den, timescale);
+	//global delay
+	s64 ts_offset = gf_timestamp_rescale_signed(ctx->delay.num, ctx->delay.den, timescale);
+	//per media-type delay
+	if (delay)
+		ts_offset += gf_timestamp_rescale_signed(delay->num, delay->den, timescale);
+
 	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
 	if (prop) {
 		ts_offset += prop->value.longsint;
@@ -179,19 +188,20 @@
 		}
 	}
 	prop = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
-	if ((ctx->fps.num) && prop) {
-		u64 dur = prop->value.uint;
+	if ((ctx->fps.num) && prop->value.lfrac.den) {
+		GF_Fraction64 ndur = prop->value.lfrac;
 		if (ctx->fps.num>0) {
 			if (fps_scaler.num) {
-				dur *= fps_scaler.num;
-				dur /= fps_scaler.den;
+				ndur.num *= fps_scaler.num;
+				ndur.num /= fps_scaler.den;
+				gf_filter_pid_set_property(pctx->opid, GF_PROP_PID_DURATION, &PROP_FRAC64(ndur));
 			} else {
 				gf_filter_pid_set_property(pctx->opid, GF_PROP_PID_DURATION, NULL);
 			}
 		} else {
-			dur /= -ctx->fps.num;
-			dur *= ctx->fps.den;
-			gf_filter_pid_set_property(pctx->opid, GF_PROP_PID_DURATION, &PROP_LONGUINT(dur));
+			ndur.num /= -ctx->fps.num;
+			ndur.num *= ctx->fps.den;
+			gf_filter_pid_set_property(pctx->opid, GF_PROP_PID_DURATION, &PROP_FRAC64(ndur));
 		}
 	}
 
@@ -206,6 +216,10 @@
 {
 	if (ots == GF_FILTER_NO_TS) return ots;
 	u64 ts;
+
+	if (pctx->ts_shift_plus_one) {
+		ots = ots + (pctx->ts_shift_plus_one-1);
+	}
 	//ots + pctx->ts_offset<0
 	if ((pctx->ts_offset<0) && (ots < (u64) -pctx->ts_offset)) {
 		pctx->ts_offset += (s64) ots + pctx->ts_offset;;
@@ -268,12 +282,68 @@
 	return ts;
 }
 
+static void restamp_config_timing(GF_Filter *filter, RestampCtx *ctx)
+{
+	Bool not_ready=GF_FALSE;
+	Bool has_blocking=GF_FALSE;
+	u64 min_ts=0;
+	u32 min_timescale=0;
+
+	if ((ctx->tsinit.num<0) || !ctx->tsinit.den) {
+		ctx->config_timing = GF_FALSE;;
+		return;
+	}
+
+
+	u32 i, count = gf_list_count(ctx->pids);
+	for (i=0; i<count; i++) {
+		RestampPid *pctx = gf_list_get(ctx->pids, i);
+		GF_FilterPacket *pck = gf_filter_pid_get_packet(pctx->ipid);
+		if (!pck) {
+			if (!gf_filter_pid_is_eos(pctx->ipid))
+				not_ready = GF_TRUE;
+			continue;
+		}
+		if (gf_filter_pck_is_blocking_ref(pck))
+			has_blocking=GF_TRUE;
+
+		u64 ts = gf_filter_pck_get_dts(pck);
+		if (ts==GF_FILTER_NO_TS)
+			ts = gf_filter_pck_get_cts(pck);
+
+		if (!min_timescale || (min_ts < gf_timestamp_rescale(ts, pctx->timescale, min_timescale))) {
+			min_timescale = pctx->timescale;
+			min_ts = ts;
+		}
+	}
+	if (not_ready && !has_blocking) {
+		ctx->config_retry++;
+		if (ctx->config_retry<10000)
+			return;
+	}
+	ctx->config_retry=0;
+
+	for (i=0; i<count; i++) {
+		RestampPid *pctx = gf_list_get(ctx->pids, i);
+
+		pctx->ts_shift_plus_one = - (s64) gf_timestamp_rescale_signed(min_ts, min_timescale, pctx->timescale);
+		pctx->ts_shift_plus_one += gf_timestamp_rescale(ctx->tsinit.num, ctx->tsinit.den, pctx->timescale);
+		pctx->ts_shift_plus_one += 1;
+	}
+	ctx->config_timing = GF_FALSE;;
+}
+
 
 static GF_Err restamp_process(GF_Filter *filter)
 {
 	u32 i, count;
 	RestampCtx *ctx = (RestampCtx *) gf_filter_get_udta(filter);
 
+	if (ctx->config_timing) {
+		restamp_config_timing(filter, ctx);
+		if (ctx->config_timing) return GF_OK;
+	}
+
 	count = gf_list_count(ctx->pids);
 	for (i=0; i<count; i++) {
 		RestampPid *pctx = gf_list_get(ctx->pids, i);
@@ -300,6 +370,8 @@
 
 			if (!pctx->raw_vid_copy) {
 				opck = gf_filter_pck_new_ref(pctx->opid, 0, 0, pck);
+				if (!opck) return GF_OUT_OF_MEM;
+				gf_filter_pck_merge_properties(pck, opck);
 				ts = restamp_get_timestamp(ctx, pctx, gf_filter_pck_get_dts(pck) );
 				if (ts != GF_FILTER_NO_TS)
 					gf_filter_pck_set_dts(opck, ts);
@@ -349,6 +421,8 @@
 				}
 				assert(pctx->pck_ref);
 				opck = gf_filter_pck_new_ref(pctx->opid, 0, 0, pctx->pck_ref);
+				if (!opck) return GF_OUT_OF_MEM;
+				gf_filter_pck_merge_properties(pck, opck);
 				if (ts != GF_FILTER_NO_TS)
 					gf_filter_pck_set_cts(opck, ts);
 				pctx->nb_frames++;
@@ -416,6 +490,7 @@
 static GF_FilterArgs RestampArgs =
 {
 	{ OFFS(fps), "target fps", GF_PROP_FRACTION, "0/1", NULL, 0},
+	{ OFFS(delay), "delay to add to all streams", GF_PROP_FRACTION, "0/1", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(delay_v), "delay to add to video streams", GF_PROP_FRACTION, "0/1", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(delay_a), "delay to add to audio streams", GF_PROP_FRACTION, "0/1", NULL, GF_FS_ARG_UPDATE},
 	{ OFFS(delay_t), "delay to add to text streams", GF_PROP_FRACTION, "0/1", NULL, GF_FS_ARG_UPDATE},
@@ -425,6 +500,7 @@
 		"- force: force decoding all video streams\n"
 		"- dyn: decoding video streams if not all intra"
 	, GF_PROP_UINT, "no", "no|force|dyn", 0},
+	{ OFFS(tsinit), "initial timestamp to resync to, negative values disables resync", GF_PROP_FRACTION64, "-1/1", NULL, 0},
 	{0}
 };
 
@@ -449,7 +525,7 @@
 	GF_FS_SET_DESCRIPTION("Packet timestamp rewriter")
 	GF_FS_SET_HELP("This filter rewrites timing (offsets and rate) of packets.\n"
 	"\n"
-	"The specified delay per stream class can be either positive (stream presented later) or negative (stream presented sooner).\n"
+	"The delays (global or per stream class) can be either positive (stream presented later) or negative (stream presented sooner).\n"
 	"\n"
 	"The specified -fps() can be either 0, positive or negative.\n"
 	"- if 0 or if the stream is audio, stream rate is not modified.\n"
@@ -464,7 +540,7 @@
 	)
 	.private_size = sizeof(RestampCtx),
 	.max_extra_pids = 0xFFFFFFFF,
-	.flags = GF_FS_REG_EXPLICIT_ONLY|GF_FS_REG_ALLOW_CYCLIC,
+	.flags = GF_FS_REG_EXPLICIT_ONLY|GF_FS_REG_ALLOW_CYCLIC|GF_FS_REG_TEMP_INIT,
 	.args = RestampArgs,
 	SETCAPS(RestampCaps),
 	.initialize = restamp_initialize,

gpac-2.0.0.tar.gz/src/filters/rewrite_mp4v.c -> gpac-2.2.0.tar.gz/src/filters/rewrite_mp4v.c Changed

@@ -41,6 +41,9 @@
 	u32 crc;
 	char *dsi;
 	u32 dsi_size;
+
+	Bool is_vc1;
+	Bool vc1_ilaced;
 } GF_M4VMxCtx;
 
 GF_Err m4vmx_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
@@ -82,6 +85,14 @@
 
 	ctx->dsi = dcd->value.data.ptr;
 	ctx->dsi_size = dcd->value.data.size;
+
+
+	if (ctx->is_vc1 && ctx->dsi && (ctx->dsi_size>=7)) {
+		ctx->vc1_ilaced = ((ctx->dsi2 & 0x20) == 0x20) ? GF_FALSE : GF_TRUE;
+		ctx->dsi += 7;
+		ctx->dsi_size -= 7;
+	}
+
 	return GF_OK;
 }
 
@@ -92,6 +103,7 @@
 	GF_FilterPacket *pck;
 	u8 *data, *output;
 	u32 pck_size, size, sap_type;
+	u8 inject_startcode=0;
 	pck = gf_filter_pid_get_packet(ctx->ipid);
 	if (!pck) {
 		if (gf_filter_pid_is_eos(ctx->ipid)) {
@@ -123,14 +135,36 @@
 		}
 	}
 
-	if (sap_type && ctx->dsi) {
+
+	if (ctx->is_vc1 && (data0!=0) && (data1!=0) && (data2!=1)) {
+		if (ctx->vc1_ilaced && ((data0 & 0xC0) == 0xC0))
+			inject_startcode = 0x0C;
+		else
+			inject_startcode = 0x0D;
+	}
+
+	if ((sap_type && ctx->dsi) || inject_startcode) {
 		GF_FilterPacket *dst_pck;
-		size = pck_size + ctx->dsi_size;
+		u32 offset=0;
+		size = pck_size;
+		if (inject_startcode) size += 4;
+		if (sap_type) size += ctx->dsi_size;
 
 		dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output);
 		if (!dst_pck) return GF_OUT_OF_MEM;
-		memcpy(output, ctx->dsi, ctx->dsi_size);
-		memcpy(output+ctx->dsi_size, data, pck_size);
+		if (sap_type) {
+			memcpy(output, ctx->dsi, ctx->dsi_size);
+			offset = ctx->dsi_size;
+		}
+		if (inject_startcode) {
+			outputoffset = 0;
+			outputoffset+1 = 0;
+			outputoffset+2 = 1;
+			outputoffset+3 = inject_startcode;
+			offset+=4;
+		}
+
+		memcpy(output+offset, data, pck_size);
 		gf_filter_pck_merge_properties(pck, dst_pck);
 		gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
 		gf_filter_pck_send(dst_pck);
@@ -181,3 +215,46 @@
 {
 	return &M4VMxRegister;
 }
+
+
+static const GF_FilterCapability VC1MxCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_SMPTE_VC1),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+};
+
+
+static GF_Err vc1mx_initialize(GF_Filter *filter)
+{
+#ifdef GPAC_ENABLE_COVERAGE
+	if (!filter) return GF_OK;
+#endif
+	GF_M4VMxCtx *ctx = gf_filter_get_udta(filter);
+	if (ctx) ctx->is_vc1 = GF_TRUE;
+	return GF_OK;
+}
+
+GF_FilterRegister VC1VMxRegister = {
+	.name = "ufvc1",
+	GF_FS_SET_DESCRIPTION("VC1 writer")
+	GF_FS_SET_HELP("This filter converts VC1 visual streams into writable format (reinsert decoder config and start codes if needed).")
+	.private_size = sizeof(GF_M4VMxCtx),
+	.args = M4VMxArgs,
+	SETCAPS(VC1MxCaps),
+	.initialize = vc1mx_initialize,
+	.configure_pid = m4vmx_configure_pid,
+	.process = m4vmx_process
+};
+
+
+const GF_FilterRegister *vc1mx_register(GF_FilterSession *session)
+{
+#ifdef GPAC_ENABLE_COVERAGE
+	//we currently miss vc1 test sequence
+	if (gf_sys_is_cov_mode())
+		vc1mx_initialize(NULL);
+#endif
+	return &VC1VMxRegister;
+}

gpac-2.0.0.tar.gz/src/filters/rewrite_nalu.c -> gpac-2.2.0.tar.gz/src/filters/rewrite_nalu.c Changed

@@ -223,6 +223,7 @@
 			//copy properties at init or reconfig
 			gf_filter_pid_copy_properties(ctx->opid, pid);
 			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FORCE_UNFRAME, NULL);
 		}
 		return GF_OK;
 	}
@@ -249,6 +250,7 @@
 	//copy properties at init or reconfig
 	gf_filter_pid_copy_properties(ctx->opid, pid);
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FORCE_UNFRAME, NULL);
 
 	ctx->ipid = pid;
 	gf_filter_pid_set_framing_mode(ctx->ipid, GF_TRUE);
@@ -389,6 +391,9 @@
 			gf_filter_pid_drop_packet(ctx->ipid);
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
+		//we allow nal_size=0 for incomplete files, abort as soon as we see one to avoid parsing thousands of 0 bytes
+		if (!nal_size) break;
+
 		pos = (u32) gf_bs_get_position(ctx->bs_r);
 		//even if not filtering, parse to check for AU delim
 		skip_nal = nalumx_is_nal_skip(ctx, data, pos, &is_nalu_delim, &layer_id, &temporal_id, &avc_hdr);
@@ -407,6 +412,12 @@
 	}
 	gf_bs_seek(ctx->bs_r, 0);
 
+	if (!size) {
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("NALWrite Empty AU with only 0-size NAL, skipping\n"));
+		gf_filter_pid_drop_packet(ctx->ipid);
+		return GF_OK;
+	}
+
 	if (!ctx->delim)
 		has_nalu_delim = GF_TRUE;
 
@@ -497,6 +508,7 @@
 			return GF_NON_COMPLIANT_BITSTREAM;
 		}
 		pos = (u32) gf_bs_get_position(ctx->bs_r);
+		if (!nal_size) continue;
 
 		skip_nal = nalumx_is_nal_skip(ctx, data, pos, &is_nalu_delim, &layer_id, &temporal_id, &avc_hdr);
 		if (!ctx->extract) {
@@ -507,7 +519,6 @@
 			skip_nal = GF_TRUE;
 		}
 
-
 		if (skip_nal) {
 			gf_bs_skip_bytes(ctx->bs_r, nal_size);
 			continue;
@@ -588,6 +599,17 @@
 	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_AVC),
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+	//for forced frame->unframe
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_AVC),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_SVC),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_MVC),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_HEVC),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_LHVC),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_VVC),
+	CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_FORCE_UNFRAME, GF_TRUE),
+	CAP_BOOL(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
 };

gpac-2.0.0.tar.gz/src/filters/rewrite_obu.c -> gpac-2.2.0.tar.gz/src/filters/rewrite_obu.c Changed

@@ -30,6 +30,13 @@
 
 #ifndef GPAC_DISABLE_AV_PARSERS
 
+typedef enum {
+	FRAMING_OBU 	= 0,
+	FRAMING_AV1B 	= 1,
+	FRAMING_IVF 	= 2,
+	FRAMING_AV1TS	= 3
+} OBUFramingMode;
+
 typedef struct
 {
 	//opts
@@ -43,7 +50,7 @@
 	u32 crc;
 
 	Bool ivf_hdr;
-	u32 mode;
+	OBUFramingMode mode;
 	GF_BitStream *bs_w;
 	GF_BitStream *bs_r;
 	u32 w, h;
@@ -94,12 +101,14 @@
 		//check output type OBU vs av1b
 		p = gf_filter_pid_caps_query(ctx->opid, GF_PROP_PID_FILE_EXT);
 		if (p) {
-			if (!strcmp(p->value.string, "obu")) ctx->mode = 0;
-			else if (!strcmp(p->value.string, "av1b") || !strcmp(p->value.string, "av1")) ctx->mode = 1;
+			if (!strcmp(p->value.string, "obu")) ctx->mode = FRAMING_OBU;
+			else if (!strcmp(p->value.string, "av1b") || !strcmp(p->value.string, "av1")) ctx->mode = FRAMING_AV1B;
 			//we might want to add a generic IVF read/write at some point
 			else if (!strcmp(p->value.string, "ivf")) {
-				ctx->mode = 2;
+				ctx->mode = FRAMING_IVF;
 				ctx->ivf_hdr = 1;
+			} else if (!strcmp(p->value.string, "ts")) {
+				ctx->mode = FRAMING_AV1TS;
 			}
 		} else {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("OBUWrite Couldn't guess desired output format type, assuming plain OBU\n"));
@@ -108,14 +117,14 @@
 	case GF_CODECID_VP8:
 	case GF_CODECID_VP9:
 	case GF_CODECID_VP10:
-		ctx->mode = 2; //IVF only
+		ctx->mode = FRAMING_IVF;
 		ctx->ivf_hdr = 1;
 		break;
 	}
 
 	if (ctx->av1c) gf_odf_av1_cfg_del(ctx->av1c);
 	ctx->av1c = NULL;
-	if (ctx->mode==1) {
+	if (ctx->mode==FRAMING_AV1B) {
 		u32 i=0;
 		GF_AV1_OBUArrayEntry *obu;
 		ctx->av1c = gf_odf_av1_cfg_read(dcd->value.data.ptr, dcd->value.data.size);
@@ -157,6 +166,181 @@
 	return GF_OK;
 }
 
+// Create a new packet from the Bitstream
+// Set initial properties from source packet
+// Add packet to the list
+static GF_Err obumx_add_packet(GF_FilterPid *opid,
+							   GF_BitStream *bs,
+							   GF_FilterPacket *src_pck,
+							   GF_List *pcks)
+{
+	u8 *output = NULL;
+	GF_FilterPacket *pck = NULL;
+	u8 *pck_input_data;
+	u32 pck_input_data_size;
+
+	if (!pcks) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OBUWrite Packet list is null!!\n"));
+		return GF_BAD_PARAM;
+	}
+	gf_bs_get_content(bs, &pck_input_data, &pck_input_data_size);
+	if (!pck_input_data || !pck_input_data_size) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OBUWrite Trying to create an empty packet!!\n"));
+		return GF_BAD_PARAM;
+	}
+	pck = gf_filter_pck_new_alloc(opid, pck_input_data_size, &output);
+	if (!pck || !output) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OBUWrite Problem allocating new packet!!\n"));
+		return GF_OUT_OF_MEM;
+	}
+	memcpy(output, pck_input_data, pck_input_data_size);
+	if (src_pck) {
+		gf_filter_pck_merge_properties(src_pck, pck);
+	}
+	gf_free(pck_input_data);
+	gf_list_add(pcks, pck);
+	return GF_OK;
+}
+
+// Generate MPEG-TS formatted OBU:
+// - add start code
+// - add emulation prevention bytes
+// NOTE: size fields are not modified
+static GF_Err format_obu_mpeg2ts(u8* in_data, u32 in_size, u8 **out_data, u32 *out_size) {
+	const u8 START_CODE_SIZE = 3;
+	u8 *pck_data_epb = NULL;
+	u32 pck_size_epb = 0;
+
+	if (!in_data || !in_size || !out_data || !out_size) {
+		return GF_BAD_PARAM;
+	}
+	pck_size_epb = START_CODE_SIZE + in_size + gf_media_nalu_emulation_bytes_add_count(in_data, in_size);
+	pck_data_epb = gf_malloc(pck_size_epb);
+	if (!pck_data_epb) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OBUWrite Could not allocate EPB buffer!!\n"));
+		return GF_OUT_OF_MEM;
+	}
+	pck_data_epb0 = 0;
+	pck_data_epb1 = 0;
+	pck_data_epb2 = 1;
+	gf_media_nalu_add_emulation_bytes(in_data, pck_data_epb+3, in_size);
+	*out_data = pck_data_epb;
+	*out_size = pck_size_epb;
+	return GF_OK;
+}
+
+// Generate one or more output packet(s) from an input packet that contains a AV1 TU
+// One output packet is created for each frame (frame_header only or full frame)
+// All OBUs are transformed to add start code and emulation prevention bytes
+static GF_Err obumx_process_mpeg2au(GF_OBUMxCtx *ctx, GF_FilterPacket *src_pck, u8 *data, u32 src_pck_size) {
+	Bool first_frame_found = GF_FALSE;
+	u32 pck_count = 0;
+	Bool first_packet = GF_TRUE;
+	GF_List *pcks = gf_list_new();
+	u64 cts = gf_filter_pck_get_cts(src_pck);
+	u32 duration = gf_filter_pck_get_duration(src_pck);
+	u32 out_duration;
+	u64 out_cts;
+
+	if (!ctx->bs_r) ctx->bs_r = gf_bs_new(data, src_pck_size, GF_BITSTREAM_READ);
+	else gf_bs_reassign_buffer(ctx->bs_r, data, src_pck_size);
+
+	if (ctx->bs_w) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OBUWrite Write bitstream should be null, deleting... !!\n"));
+		gf_bs_del(ctx->bs_w);
+	}
+	ctx->bs_w = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+
+	while (gf_bs_available(ctx->bs_r)) {
+		ObuType obu_type;
+		u32 obu_size;
+		u32 read_size;
+		u8 *obu_data;
+		u8 *out_obu_data = NULL;
+		u32 out_obu_size = 0;
+		Bool obu_extension_flag, obu_has_size_field;
+		u8 temporal_id, spatial_id;
+		u64 obu_start = (u32) gf_bs_get_position(ctx->bs_r);
+		u32 obu_hdr_size;
+
+		gf_av1_parse_obu_header(ctx->bs_r, &obu_type, &obu_extension_flag, &obu_has_size_field, &temporal_id, &spatial_id);
+		obu_hdr_size = (u32) (gf_bs_get_position(ctx->bs_r) - obu_start);
+
+		if (obu_has_size_field) {
+			obu_size = (u32)gf_av1_leb128_read(ctx->bs_r, NULL);
+			obu_hdr_size = (u32) (gf_bs_get_position(ctx->bs_r) - obu_start);
+		} else {
+			obu_size = src_pck_size - (u32) gf_bs_get_position(ctx->bs_r);
+		}
+		obu_size += obu_hdr_size;
+		gf_bs_seek(ctx->bs_r, obu_start);
+
+		if (obu_type == OBU_FRAME || obu_type == OBU_FRAME_HEADER) {
+			// start creating packet only after the first frame is found
+			if (first_frame_found) {
+				obumx_add_packet(ctx->opid, ctx->bs_w, src_pck, pcks);
+				gf_bs_del(ctx->bs_w);
+				ctx->bs_w = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+			}
+			first_frame_found = GF_TRUE;
+		}
+		//TODO - rework code to avoid alloc/free all per obu
+		obu_data = gf_malloc(obu_size);
+		read_size = gf_bs_read_data(ctx->bs_r, obu_data, obu_size);
+		if (read_size != obu_size) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OBUWrite Could not read entire OBU %d vs %d !!\n", read_size, obu_size));
+		}
+		GF_Err e = format_obu_mpeg2ts(obu_data, read_size, &out_obu_data, &out_obu_size);
+		if (e != GF_OK || out_obu_data == NULL || out_obu_size == 0) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("OBUWrite Problem formatting OBU for MPEG-2 TS!!\n"));
+		} else {
+			gf_bs_write_data(ctx->bs_w, out_obu_data, out_obu_size);
+		}
+		if (out_obu_data) gf_free(out_obu_data);
+		out_obu_data = NULL;
+		if (obu_data) gf_free(obu_data);
+	}
+	// create last packet from any pending data
+	obumx_add_packet(ctx->opid,ctx->bs_w, src_pck, pcks);
+	gf_bs_del(ctx->bs_w);
+	ctx->bs_w = NULL;
+
+	// Adjust CTS, flags and send
+	pck_count = gf_list_count(pcks);
+	out_duration = duration / pck_count;
+	out_cts = cts;
+	while (gf_list_count(pcks)) {
+		GF_FilterPacket *pck = (GF_FilterPacket *)gf_list_get(pcks, 0);
+		gf_list_rem(pcks, 0);
+		gf_filter_pck_set_cts(pck, out_cts);
+		gf_filter_pck_set_dts(pck, out_cts);
+		out_cts += out_duration;
+		if (gf_list_count(pcks) != 0) {
+			gf_filter_pck_set_duration(pck, out_duration);
+		} else {
+			// adjust the duration of the last packet for rounding issues
+			gf_filter_pck_set_duration(pck, duration - (u32)(out_cts-cts));
+		}
+		if (first_packet) {
+			// The first output packet gets the timing, flags and sap type of the input packet
+			u8 sap_type = gf_filter_pck_get_sap(src_pck);
+			u8 flags = gf_filter_pck_get_dependency_flags(src_pck);
+			gf_filter_pck_set_sap(pck, sap_type);
+			gf_filter_pck_set_dependency_flags(pck, flags);
+			first_packet = GF_FALSE;
+		} else {
+			// all other output packets get no flags
+			gf_filter_pck_set_sap(pck, 0);
+			gf_filter_pck_set_dependency_flags(pck, 0);
+		}
+		gf_filter_pck_send(pck);
+	}
+	gf_list_del(pcks);
+
+	// we are done with the input packet
+	gf_filter_pid_drop_packet(ctx->ipid);
+	return GF_OK;
+}
 
 GF_Err obumx_process(GF_Filter *filter)
 {
@@ -167,7 +351,6 @@
 	u8 *data, *output;
 	u32 pck_size, size, sap_type, hdr_size, av1b_frame_size=0;
 
-
 	pck = gf_filter_pid_get_packet(ctx->ipid);
 	if (!pck) {
 		if (gf_filter_pid_is_eos(ctx->ipid)) {
@@ -188,6 +371,9 @@
 		return GF_OK;
 	}
 
+	if (ctx->mode == FRAMING_AV1TS) {
+		return obumx_process_mpeg2au(ctx, pck, data, pck_size);
+	}
 
 	hdr_size = 0;
 	size = pck_size;
@@ -207,11 +393,11 @@
 	}
 
 	memset(frame_sizes, 0, sizeof(u32)*128);
-	if (ctx->mode==2) {
+	if (ctx->mode==FRAMING_IVF) {
 		if (ctx->ivf_hdr) hdr_size += 32;
 		hdr_size += 12;
 	}
-	if (ctx->mode==1) {
+	if (ctx->mode==FRAMING_AV1B) {
 		u32 obu_sizes=0;
 		u32 frame_idx=0;
 
@@ -279,7 +465,7 @@
 	if (!ctx->bs_w) ctx->bs_w = gf_bs_new(output, hdr_size+size, GF_BITSTREAM_WRITE);
 	else gf_bs_reassign_buffer(ctx->bs_w, output, hdr_size+size);
 
-	if (ctx->mode==1) {
+	if (ctx->mode==FRAMING_AV1B) {
 		u32 frame_idx = 0;
 		//temporal unit
 		gf_av1_leb128_write(ctx->bs_w, av1b_frame_size);
@@ -368,7 +554,7 @@
 			gf_bs_write_u32_le(ctx->bs_w, 0);
 			ctx->ivf_hdr = 0;
 		}
-		if (ctx->mode==2) {
+		if (ctx->mode==FRAMING_IVF) {
 			u64 cts = gf_timestamp_rescale(gf_filter_pck_get_cts(pck), ctx->fps.den * gf_filter_pck_get_timescale(pck), ctx->fps.num);
 			gf_bs_write_u32_le(ctx->bs_w, size);
 			gf_bs_write_u64_le(ctx->bs_w, cts);

gpac-2.0.0.tar.gz/src/filters/tileagg.c -> gpac-2.2.0.tar.gz/src/filters/tileagg.c Changed

gpac-2.0.0.tar.gz/src/filters/tilesplit.c -> gpac-2.2.0.tar.gz/src/filters/tilesplit.c Changed

gpac-2.0.0.tar.gz/src/filters/tssplit.c -> gpac-2.2.0.tar.gz/src/filters/tssplit.c Changed

gpac-2.2.0.tar.gz/src/filters/ttml_conv.c Added

@@ -0,0 +1,379 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / TTML to SRT converter filter
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <gpac/filters.h>
+#include <gpac/constants.h>
+#include <gpac/bitstream.h>
+#include <gpac/internal/isomedia_dev.h>
+#include <gpac/internal/media_dev.h>
+#include <gpac/color.h>
+#include <gpac/xml.h>
+
+
+#if !defined(GPAC_DISABLE_ISOM_WRITE)
+
+typedef struct
+{
+	//only one input pid declared
+	GF_FilterPid *ipid;
+	//only one output pid declared
+	GF_FilterPid *opid;
+	u32 timescale;
+
+	u8 *buf;
+	u32 buf_alloc;
+	u64 last_end_ts;
+
+	Bool srt_conv;
+} TTMLConvCtx;
+
+GF_Err ttmlconv_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
+{
+	TTMLConvCtx *ctx = gf_filter_get_udta(filter);
+
+	if (is_remove) {
+		ctx->ipid = NULL;
+		if (ctx->opid) {
+			gf_filter_pid_remove(ctx->opid);
+			ctx->opid = NULL;
+		}
+		return GF_OK;
+	}
+	if (! gf_filter_pid_check_caps(pid))
+		return GF_NOT_SUPPORTED;
+
+
+	if (!ctx->opid) {
+		ctx->opid = gf_filter_pid_new(filter);
+	}
+	ctx->ipid = pid;
+	gf_filter_pid_copy_properties(ctx->opid, pid);
+
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(ctx->srt_conv ? GF_CODECID_SIMPLE_TEXT : GF_CODECID_WEBVTT) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, NULL);
+
+	const GF_PropertyValue *p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+	ctx->timescale = p ? p->value.uint : 1000;
+	return GF_OK;
+}
+
+//from filter writegen
+GF_XMLNode *ttml_get_body(GF_XMLNode *root);
+GF_XMLAttribute *ttml_get_attr(GF_XMLNode *node, char *name);
+
+//from filter txtin
+u64 ttml_get_timestamp_ex(char *value, u32 tick_rate, u32 *ttml_fps_num, u32 *ttml_fps_den, u32 *ttml_sfps);
+GF_Err ttml_parse_root(GF_XMLNode *root, const char **lang, u32 *tick_rate, u32 *ttml_fps_num, u32 *ttml_fps_den, u32 *ttml_sfps);
+
+static void ttmlconv_dump_node(TTMLConvCtx *ctx, GF_XMLNode *p, FILE *dump)
+{
+	u32 i;
+	GF_XMLNode *child;
+	GF_XMLAttribute *att;
+
+	Bool needs_italic = GF_FALSE;
+	Bool needs_underlined = GF_FALSE;
+	Bool needs_bold = GF_FALSE;
+	const char *needs_color = NULL;
+	i=0;
+	while ( (att = gf_list_enum(p->attributes, &i)) ) {
+		const char *sep = strchr(att->name, ':');
+		const char *name = sep ? sep+1 : att->name;
+		if (!name) continue;;
+		if (!strcmp(name, "fontStyle") && (!strcmp(att->value, "italic") || !strcmp(att->value, "oblique")))
+			needs_italic = GF_TRUE;
+		if (!strcmp(name, "textDecoration") && !strcmp(att->value, "underlined"))
+			needs_underlined = GF_TRUE;
+		if (!strcmp(name, "fontWeight") && !strcmp(att->value, "bold"))
+			needs_bold = GF_TRUE;
+		if (!strcmp(name, "color"))
+			needs_color = att->value;
+	}
+	if (!ctx->srt_conv) needs_color = NULL;
+
+	if (needs_color) fprintf(dump, "", needs_color);
+	if (needs_italic) fprintf(dump, "");
+	if (needs_bold) fprintf(dump, "");
+	if (needs_underlined) fprintf(dump, "");
+
+	i=0;
+	while ( (child = gf_list_enum(p->content, &i)) ) {
+		if (child->type == GF_XML_TEXT_TYPE) {
+			fprintf(dump, "%s", child->name);
+			continue;
+		}
+		if (child->type != GF_XML_NODE_TYPE) continue;
+		if (!strcmp(child->name, "br")) {
+			fprintf(dump, "\n");
+			continue;
+		}
+		ttmlconv_dump_node(ctx, child, dump);
+	}
+
+	if (needs_underlined) fprintf(dump, "");
+	if (needs_bold) fprintf(dump, "");
+	if (needs_italic) fprintf(dump, "");
+	if (needs_color) fprintf(dump, "");
+}
+
+GF_Err ttmlconv_process(GF_Filter *filter)
+{
+	TTMLConvCtx *ctx = gf_filter_get_udta(filter);
+	GF_FilterPacket *pck, *dst_pck;
+	u8 *data;
+	u64 start_ts, end_ts;
+	u32 pck_size;
+	GF_Err e = GF_OK;
+	GF_DOMParser *dom;
+	u32 txt_size, nb_children;
+	u32 i, j;
+	FILE *dump = NULL;
+	u32 tick_rate=0, ttml_fps_num=0, ttml_fps_den=0, ttml_sfps=0;
+	const char *lang;
+	GF_XMLNode *root, *p, *body;
+
+	pck = gf_filter_pid_get_packet(ctx->ipid);
+	if (!pck) {
+		if (gf_filter_pid_is_eos(ctx->ipid)) {
+			gf_filter_pid_set_eos(ctx->opid);
+			return GF_EOS;
+		}
+		return GF_OK;
+	}
+
+	data = (char *) gf_filter_pck_get_data(pck, &pck_size);
+	if (!data || !pck_size) {
+		gf_filter_pid_drop_packet(ctx->ipid);
+		return GF_OK;
+	}
+
+
+	start_ts = gf_filter_pck_get_cts(pck);
+	end_ts = start_ts + gf_filter_pck_get_duration(pck);
+
+	start_ts = gf_timestamp_rescale(start_ts, ctx->timescale, 1000);
+	end_ts = gf_timestamp_rescale(end_ts, ctx->timescale, 1000);
+
+	const GF_PropertyValue *subs = gf_filter_pck_get_property(pck, GF_PROP_PCK_SUBS);
+
+	if (subs) {
+		if (subs->value.data.size < 14)
+			return GF_NON_COMPLIANT_BITSTREAM;
+		txt_size = subs->value.data.ptr4;
+		txt_size <<= 8;
+		txt_size |= subs->value.data.ptr5;
+		txt_size <<= 8;
+		txt_size |= subs->value.data.ptr6;
+		txt_size <<= 8;
+		txt_size |= subs->value.data.ptr7;
+		if (txt_size>pck_size)
+			return GF_NON_COMPLIANT_BITSTREAM;
+	} else {
+		txt_size = pck_size;
+	}
+	if (ctx->buf_alloc < txt_size + 2) {
+		ctx->buf = gf_realloc(ctx->buf, txt_size+2);
+		if (!ctx->buf) return GF_OUT_OF_MEM;
+		ctx->buf_alloc = txt_size+2;
+	}
+	memcpy(ctx->buf, data, txt_size);
+	ctx->buftxt_size = 0;
+	ctx->buftxt_size+1 = 0;
+
+	dom = gf_xml_dom_new();
+	if (!dom) return GF_OUT_OF_MEM;
+	e = gf_xml_dom_parse_string(dom, ctx->buf);
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("XML Invalid TTML doc: %s\n\tXML text was:\n%s", gf_xml_dom_get_error(dom), ctx->buf));
+		goto exit;
+	}
+	root = gf_xml_dom_get_root(dom);
+	//parse root att
+	e = ttml_parse_root(root, &lang, &tick_rate, &ttml_fps_num, &ttml_fps_den, &ttml_sfps);
+	if (e) goto exit;
+
+	u32 div_idx=0;
+	body = ttml_get_body(root);
+	nb_children = body ? gf_list_count(body->content) : 0;
+	for (i=0; i<nb_children; i++) {
+		GF_XMLNode *div = gf_list_get(body->content, i);
+		if (div->type) continue;
+		if (strcmp(div->name, "div")) continue;
+
+		div_idx++;
+//		div_reg = ttml_get_attr(div, "region");
+
+		j=0;
+		while ( (p = gf_list_enum(div->content, &j)) ) {
+			if (p->type) continue;
+			if (strcmp(p->name, "p")) continue;
+
+			GF_XMLAttribute *start = ttml_get_attr(p, "begin");
+			GF_XMLAttribute *end = ttml_get_attr(p, "end");
+			if (!end || !start) continue;
+
+			u64 p_end_ts = ttml_get_timestamp_ex(end->value, tick_rate, &ttml_fps_num, &ttml_fps_den, &ttml_sfps);
+			u64 p_start_ts = ttml_get_timestamp_ex(start->value, tick_rate, &ttml_fps_num, &ttml_fps_den, &ttml_sfps);
+			p_start_ts = gf_timestamp_rescale(p_start_ts, 1000, ctx->timescale);
+			p_end_ts = gf_timestamp_rescale(p_end_ts, 1000, ctx->timescale);
+
+			//wrong timing in doc, don't process
+			if (p_end_ts < p_start_ts) continue;
+			//p.end less than packet start time, don't send
+			if (p_end_ts < start_ts) continue;
+			//p.start greater than packet end time, stop sending
+			if (p_start_ts > end_ts) break;
+
+			if (ctx->last_end_ts && (ctx->last_end_ts >= p_end_ts+1)) continue;
+			ctx->last_end_ts = p_end_ts+1;
+
+			dump = gf_file_temp(NULL);
+			if (!dump) {
+				e = GF_OUT_OF_MEM;
+				goto exit;
+			}
+			ttmlconv_dump_node(ctx, p, dump);
+			u32 size = (u32) gf_ftell(dump);
+			gf_fseek(dump, 0, SEEK_SET);
+			u8 *output;
+			dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output);
+			if (!dst_pck) {
+				e = GF_OUT_OF_MEM;
+				goto exit;
+			}
+			gf_fread(output, size, dump);
+			gf_fclose(dump);
+			dump=NULL;
+
+			gf_filter_pck_merge_properties(pck, dst_pck);
+			gf_filter_pck_set_sap(dst_pck, GF_FILTER_SAP_1);
+			gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
+			gf_filter_pck_set_cts(dst_pck, p_start_ts);
+			gf_filter_pck_set_duration(dst_pck, (u32) (p_end_ts-p_start_ts));
+			gf_filter_pck_send(dst_pck);
+		}
+	}
+
+exit:
+	gf_filter_pid_drop_packet(ctx->ipid);
+	gf_xml_dom_del(dom);
+	if (dump) gf_fclose(dump);
+	return e;
+}
+
+static void ttmlconv_finalize(GF_Filter *filter)
+{
+	TTMLConvCtx *ctx = gf_filter_get_udta(filter);
+	if (ctx->buf) gf_free(ctx->buf);
+}
+
+static const GF_FilterCapability TTMLConvCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	CAP_BOOL(GF_CAPS_OUTPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+};
+
+
+GF_FilterRegister TTMLConvRegister = {
+	.name = "ttml2vtt",
+	GF_FS_SET_DESCRIPTION("TTML to WebVTT")
+	GF_FS_SET_HELP("This filter converts TTML frames to unframed WebVTT\n."
+	"\n"
+	"Conversion is quite limited: only the first div is analyzed and only basic styling is implemented.\n"
+	)
+	.private_size = sizeof(TTMLConvCtx),
+	.finalize = ttmlconv_finalize,
+	SETCAPS(TTMLConvCaps),
+	.configure_pid = ttmlconv_configure_pid,
+	.process = ttmlconv_process,
+	//lower priority so that we always favor ttml2srt when converting ttml to tx3g
+	.priority = 128
+};
+
+
+const GF_FilterRegister *ttmlconv_register(GF_FilterSession *session)
+{
+	return &TTMLConvRegister;
+}
+
+static GF_Err ttmlconv2_initialize(GF_Filter *filter)
+{
+	TTMLConvCtx *ctx = gf_filter_get_udta(filter);
+	ctx->srt_conv = GF_TRUE;
+	return GF_OK;
+}
+
+static const GF_FilterCapability TTMLConv2Caps =
+{
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+	CAP_BOOL(GF_CAPS_OUTPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+};
+
+
+GF_FilterRegister TTMLConv2Register = {
+	.name = "ttml2srt",
+	GF_FS_SET_DESCRIPTION("TTML to SRT")
+	GF_FS_SET_HELP("This filter converts TTML frames to unframed SRT\n."
+	"\n"
+	"Conversion is quite limited: only the first div is analyzed and only basic styling is implemented.\n"
+	)
+	.private_size = sizeof(TTMLConvCtx),
+	.initialize = ttmlconv2_initialize,
+	.finalize = ttmlconv_finalize,
+	SETCAPS(TTMLConv2Caps),
+	.configure_pid = ttmlconv_configure_pid,
+	.process = ttmlconv_process
+};
+
+
+const GF_FilterRegister *ttmlconv2_register(GF_FilterSession *session)
+{
+	return &TTMLConv2Register;
+}
+
+#else
+
+const GF_FilterRegister *ttmlconv_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+
+const GF_FilterRegister *ttmlconv2_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+
+#endif //#if !defined(GPAC_DISABLE_ISOM_WRITE)

gpac-2.2.0.tar.gz/src/filters/unframer.c Added

@@ -0,0 +1,132 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom Paris 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / unframer filter
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <gpac/filters.h>
+#include <gpac/constants.h>
+#include <gpac/internal/media_dev.h>
+#include <gpac/mpeg4_odf.h>
+
+static GF_Err unframer_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
+{
+	GF_FilterPid *opid = gf_filter_pid_get_udta(pid);
+
+	//disconnect of src pid (not yet supported)
+	if (is_remove) {
+		if (opid) {
+			gf_filter_pid_set_udta(pid, NULL);
+			gf_filter_pid_remove(opid);
+		}
+		return GF_OK;
+	}
+	if (! gf_filter_pid_check_caps(pid))
+		return GF_NOT_SUPPORTED;
+
+	if (!opid) {
+		opid = gf_filter_pid_new(filter);
+		if (!opid) return GF_OUT_OF_MEM;
+		gf_filter_pid_set_udta(pid, opid);
+	}
+	//remove unframe property for streams/codecs not using them
+	Bool no_unframe=GF_FALSE;
+	gf_filter_pid_copy_properties(opid, pid);
+	const GF_PropertyValue *p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
+	if (p) {
+		//for now we only have audio video or text using framing formats
+		switch (p->value.uint) {
+		case GF_STREAM_AUDIO:
+		case GF_STREAM_TEXT:
+		case GF_STREAM_VISUAL:
+			p =gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+			if (!p || !gf_codecid_has_unframer(p->value.uint))
+				no_unframe = GF_TRUE;
+			break;
+		default:
+			no_unframe = GF_TRUE;
+			break;
+		}
+	} else {
+		//no stream type defined, cannot unframe
+		no_unframe = GF_TRUE;
+	}
+
+	if (no_unframe)
+		gf_filter_pid_set_property(opid, GF_PROP_PID_UNFRAMED, NULL);
+	return GF_OK;
+}
+
+static GF_Err unframer_process(GF_Filter *filter)
+{
+	u32 i, count;
+
+	count = gf_filter_get_ipid_count(filter);
+	for (i=0; i<count; i++) {
+		GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
+		while (1) {
+			GF_FilterPacket *pck = gf_filter_pid_get_packet(ipid);
+			GF_FilterPid *opid = gf_filter_pid_get_udta(ipid);
+			if (!pck) {
+				if (opid && gf_filter_pid_is_eos(ipid))
+					gf_filter_pid_set_eos(opid);
+				break;
+			}
+			gf_filter_pck_forward(pck, opid);
+			gf_filter_pid_drop_packet(ipid);
+		}
+	}
+	return GF_OK;
+}
+
+
+static const GF_FilterCapability UnframerCaps =
+{
+	//all codecs with unframed formats
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT | GF_CAPFLAG_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT | GF_CAPFLAG_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE),
+	CAP_BOOL(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_FORCE_UNFRAME, GF_TRUE),
+	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_FALSE),
+};
+
+GF_FilterRegister UnframerRegister = {
+	.name = "unframer",
+	GF_FS_SET_DESCRIPTION("Stream unframer")
+	GF_FS_SET_HELP("This filter is used to force reframing of input sources using the same internal framing as GPAC (e.g. ISOBMFF) but with broken framing or signaling.\n"
+	"EX gpac -i src.mp4 unframer -o dst.mp4\n"
+	"This will:\n"
+	"- force input PIDs of unframer to be in serialized form (AnnexB, ADTS, ...)\n"
+	"- trigger reframers to be instanciated after the `unframer` filter.\n"
+	"Using the unframer filter avoids doing a dump to disk then reimport or other complex data piping."
+	)
+	.max_extra_pids = 0xFFFFFFFF,
+	.flags = GF_FS_REG_EXPLICIT_ONLY|GF_FS_REG_FORCE_REMUX,
+	SETCAPS(UnframerCaps),
+	.configure_pid = unframer_configure_pid,
+	.process = unframer_process,
+};
+
+const GF_FilterRegister *unframer_register(GF_FilterSession *session)
+{
+	return (const GF_FilterRegister *) &UnframerRegister;
+}

gpac-2.0.0.tar.gz/src/filters/write_generic.c -> gpac-2.2.0.tar.gz/src/filters/write_generic.c Changed

@@ -31,8 +31,6 @@
 
 #include <gpac/internal/isomedia_dev.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 enum
 {
 	DECINFO_NO=0,
@@ -75,6 +73,7 @@
 	u64 nb_bytes;
 	Bool dash_mode;
 	Bool trunc_audio;
+	Bool webvtt;
 
 	u64 first_dts_plus_one;
 
@@ -82,6 +81,14 @@
 	GF_XMLNode *ttml_root;
 
 	GF_FilterPacket *ttml_dash_pck;
+
+	Bool dump_srt;
+	Bool need_ttxt_footer;
+	u8 *write_buf;
+	u32 write_alloc;
+
+	Bool unframe_only;
+	Bool vc1_ilaced;
 } GF_GenDumpCtx;
 
 
@@ -101,8 +108,15 @@
 		}
 		return GF_OK;
 	}
-	if (! gf_filter_pid_check_caps(pid))
-		return GF_NOT_SUPPORTED;
+	if (! gf_filter_pid_check_caps(pid)) {
+		p = ctx->frame ? gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED) : NULL;
+		if (p && p->value.boolean) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Option frame specified as inherited and writegen loaded dynamically, input data will be unframed ! Use `writegen:frame -o dst` for raw frame dump\n", szExt));
+
+		} else {
+			return GF_NOT_SUPPORTED;
+		}
+	}
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
 	if (!p) return GF_NOT_SUPPORTED;
@@ -143,9 +157,17 @@
 	if (!pf) pf = GF_PIXEL_YUV;
 
 	//get DSI except for unframed streams
+	Bool get_dsi = GF_FALSE;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED);
 	if (!p ) p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED_LATM);
 	if (!p || !p->value.boolean) {
+		get_dsi = GF_TRUE;
+	}
+	//we need this one for tx3g and webvtt
+	if ((cid==GF_CODECID_TX3G) || (cid==GF_CODECID_WEBVTT))
+		get_dsi = GF_TRUE;
+
+	if (get_dsi) {
 		p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
 		if (p) {
 			ctx->dcfg = p->value.data.ptr;
@@ -171,6 +193,16 @@
 		if (sep) sep0 = 0;
 		break;
 	}
+
+	ctx->dump_srt = GF_FALSE;
+	p = gf_filter_pid_caps_query(ctx->opid, GF_PROP_PID_FILE_EXT);
+	if (p && p->value.string) {
+		if (!strcmp(p->value.string, "srt")) {
+			ctx->dump_srt = GF_TRUE;
+			strcpy(szCodecExt, "srt");
+		}
+	}
+
 	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING(szCodecExt) );
 
 	mimetype = gf_codecid_mime(cid);
@@ -231,7 +263,19 @@
 			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) );
 		if (ctx->decinfo == DECINFO_AUTO)
 			ctx->decinfo = DECINFO_FIRST;
+
+		p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED);
+		if (p && p->value.boolean)
+			ctx->dump_srt = GF_TRUE;
 		break;
+
+	case GF_CODECID_TX3G:
+		if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME))
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) );
+		if (ctx->decinfo == DECINFO_AUTO)
+			ctx->decinfo = DECINFO_FIRST;
+		break;
+
 	case GF_CODECID_META_TEXT:
 		if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME))
 			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) );
@@ -250,6 +294,13 @@
 		if (ctx->decinfo == DECINFO_AUTO)
 			ctx->decinfo = DECINFO_FIRST;
 		break;
+	case GF_CODECID_WEBVTT:
+		if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME))
+			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) );
+		if (ctx->decinfo == DECINFO_AUTO)
+			ctx->decinfo = DECINFO_FIRST;
+		ctx->webvtt = GF_TRUE;
+		break;
 	case GF_CODECID_SUBS_XML:
 		if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME))
 			gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) );
@@ -257,7 +308,7 @@
 		if (ctx->dash_mode) {
 			ctx->ttml_agg = GF_TRUE;
 		}
-		else if (!ctx->frame) {
+		else if (!ctx->frame && !ctx->split) {
 			ctx->ttml_agg = GF_TRUE;
 		} else {
 			ctx->split = GF_TRUE;
@@ -340,8 +391,20 @@
 				if (!strcmp(szExt, "wav")) {
 					ctx->is_wav = GF_TRUE;
 					//request PCMs16 ?
-//					ctx->target_afmt = GF_AUDIO_FMT_S16;
-					ctx->target_afmt = sfmt;
+					switch (sfmt) {
+					case GF_AUDIO_FMT_FLTP:
+						ctx->target_afmt = GF_AUDIO_FMT_FLT;
+						break;
+					case GF_AUDIO_FMT_FLT:
+					case GF_AUDIO_FMT_S16:
+					case GF_AUDIO_FMT_S24:
+					case GF_AUDIO_FMT_S32:
+						ctx->target_afmt = sfmt;
+						break;
+					default:
+						ctx->target_afmt = GF_AUDIO_FMT_S16;
+						break;
+					}
 				} else {
 					ctx->target_afmt = gf_audio_fmt_parse(szExt);
 					strcpy(szExt, gf_audio_fmt_sname(ctx->target_afmt));
@@ -427,7 +490,13 @@
 	}
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
-	if (p) ctx->duration = p->value.lfrac;
+	if (p && (p->value.lfrac.num>0)) ctx->duration = p->value.lfrac;
+
+	if (ctx->unframe_only) {
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE));
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(stype));
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(cid));
+	}
 
 	gf_filter_pid_set_framing_mode(pid, GF_TRUE);
 	return GF_OK;
@@ -594,7 +663,11 @@
 
 	gf_bs_write_data(ctx->bs, subchunk1ID, 4);
 	gf_bs_write_u32_le(ctx->bs, 16); //subchunk1 size
-	gf_bs_write_u16_le(ctx->bs, 1); //audio format
+	//audio format
+	if (afmt==GF_AUDIO_FMT_FLT)
+		gf_bs_write_u16_le(ctx->bs, 3);
+	else
+		gf_bs_write_u16_le(ctx->bs, 1);
 	gf_bs_write_u16_le(ctx->bs, nb_ch);
 	gf_bs_write_u32_le(ctx->bs, sample_rate);
 	gf_bs_write_u32_le(ctx->bs, sample_rate * nb_ch * bps / 8); //byte rate
@@ -611,7 +684,7 @@
 }
 
 
-static GF_XMLAttribute *ttml_get_attr(GF_XMLNode *node, char *name)
+GF_XMLAttribute *ttml_get_attr(GF_XMLNode *node, char *name)
 {
 	u32 i=0;
 	GF_XMLAttribute *att;
@@ -620,6 +693,7 @@
 	}
 	return NULL;
 }
+
 static GF_XMLNode *ttml_locate_div(GF_XMLNode *body, const char *region_name, u32 div_idx)
 {
 	u32 i=0, loc_div_idx=0;
@@ -643,7 +717,18 @@
 	return NULL;
 }
 
-static GF_XMLNode *ttml_get_body(GF_XMLNode *root)
+static GF_XMLNode *ttml_get_head(GF_XMLNode *root)
+{
+	u32 i=0;
+	GF_XMLNode *child;
+	while (root && (child = gf_list_enum(root->content, &i)) ) {
+		if (child->type) continue;
+		if (!strcmp(child->name, "head")) return child;
+	}
+	return NULL;
+}
+
+GF_XMLNode *ttml_get_body(GF_XMLNode *root)
 {
 	u32 i=0;
 	GF_XMLNode *child;
@@ -673,6 +758,31 @@
 	return GF_TRUE;
 }
 
+static void ttml_merge_head(GF_XMLNode *node_src, GF_XMLNode *node_dst)
+{
+	u32 i=0;
+	GF_XMLNode *child_src;
+	while ( (child_src = gf_list_enum(node_src->content, &i)) ) {
+		Bool found = GF_FALSE;
+		u32 j=0;
+		GF_XMLNode *child_dst;
+		while ( (child_dst = gf_list_enum(node_dst->content, &j)) ) {
+			if (!strcmp(child_src->name, child_dst->name) && ttml_same_attr(child_dst, child_src)) {
+				found = GF_TRUE;
+				break;
+			}
+		}
+		if (found) {
+			ttml_merge_head(child_src, child_dst);
+			continue;
+		}
+		i--;
+		gf_list_rem(node_src->content, i);
+		gf_list_add(node_dst->content, child_src);
+	}
+	return;
+}
+
 static GF_Err ttml_embed_data(GF_XMLNode *node, u8 *aux_data, u32 aux_data_size, u8 *subs_data, u32 subs_data_size)
 {
 	u32 i=0;
@@ -778,12 +888,13 @@
 		GF_SAFEALLOC(node, GF_XMLNode)
 		if (!node) return GF_OUT_OF_MEM;
 		node->type = GF_XML_TEXT_TYPE;
-		node->name = gf_malloc(sizeof(u8) * subs_size * 2);
+		u32 size_64 = (subs_size * 2) + 3;
+		node->name = gf_malloc(sizeof(char) * size_64);
 		if (!node->name) {
 			gf_free(node);
 			return GF_OUT_OF_MEM;
 		}
-		subs_size = gf_base64_encode(aux_data + subs_offset, subs_size, (u8*) node->name, subs_size * 2);
+		subs_size = gf_base64_encode(aux_data + subs_offset, subs_size, (u8*) node->name, size_64);
 		node->namesubs_size = 0;
 		return gf_list_add(data->content, node);
 	}
@@ -807,7 +918,7 @@
 	GF_DOMParser *dom;
 	u32 txt_size, nb_children;
 	u32 i, k, div_idx;
-	GF_XMLNode *root_pck, *p_global, *p_pck, *body_pck, *body_global;
+	GF_XMLNode *root_pck, *root_global, *p_global, *p_pck, *body_pck, *body_global, *head_pck, *head_global;
 
 	if (subs) {
 		if (subs->value.data.size < 14)
@@ -847,14 +958,36 @@
 		if (e) goto exit;
 	}
 
+	//if previous root is empty, reset - we do this in 2 passes so that single-sample emty ttml can be dumped
+	if (ctx->ttml_root && (gf_list_count(ctx->ttml_root->content)==0)) {
+		gf_xml_dom_node_del(ctx->ttml_root);
+		ctx->ttml_root = NULL;
+	}
 	if (!ctx->ttml_root) {
 		ctx->ttml_root = gf_xml_dom_detach_root(dom);
 		goto exit;
 	}
-
+	root_global = ctx->ttml_root;
+
+	head_global = ttml_get_head(root_global);
+	head_pck = ttml_get_head(root_pck);
+	if (head_pck) {
+		if (!head_global) {
+			gf_list_del_item(root_pck->content, head_pck);
+			gf_list_add(root_global->content, head_pck);
+		} else {
+			ttml_merge_head(head_pck, head_global);
+		}
+	}
 
 	body_pck = ttml_get_body(root_pck);
-	body_global = ttml_get_body(ctx->ttml_root);
+	body_global = ttml_get_body(root_global);
+	if (body_pck && !body_global) {
+		gf_list_del_item(root_pck->content, body_pck);
+		gf_list_add(root_global->content, body_pck);
+		goto exit;
+	}
+
 	div_idx = 0;
 	nb_children = body_pck ? gf_list_count(body_pck->content) : 0;
 	for (k=0; k<nb_children; k++) {
@@ -978,6 +1111,55 @@
 	return gf_filter_pck_send(pck);
 }
 
+static GF_Err writegen_flush_ttxt(GF_GenDumpCtx *ctx)
+{
+	const char *footer = "</TextStream>";
+	if (!ctx->need_ttxt_footer) return GF_OK;
+	u32 size = (u32) strlen(footer);
+	u8 *output;
+	GF_FilterPacket *pck = gf_filter_pck_new_alloc(ctx->opid, size, &output);
+	memcpy(output, footer, size);
+	gf_filter_pck_set_framing(pck, GF_FALSE, GF_TRUE);
+	gf_filter_pck_set_byte_offset(pck, GF_FILTER_NO_BO);
+	ctx->need_ttxt_footer = GF_FALSE;
+	return gf_filter_pck_send(pck);
+}
+
+
+#include <gpac/webvtt.h>
+static void webvtt_timestamps_dump(GF_BitStream *bs, u64 start_ts, u64 end_ts, u32 timescale, Bool write_srt)
+{
+#ifndef GPAC_DISABLE_VTT
+	char szTS200;
+	szTS0 = 0;
+	GF_WebVTTTimestamp start, end;
+	gf_webvtt_timestamp_set(&start, gf_timestamp_rescale(start_ts, timescale, 1000) );
+	gf_webvtt_timestamp_set(&end, gf_timestamp_rescale(end_ts, timescale, 1000) );
+
+	Bool write_hour = GF_FALSE;
+	if (gf_opts_get_bool("core", "webvtt-hours")) write_hour = GF_TRUE;
+	else if (start.hour || end.hour) write_hour = GF_TRUE;
+	else if (write_srt) write_hour = GF_TRUE;
+
+	if (write_hour) {
+		sprintf(szTS, "%02u:", start.hour);
+		gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
+	}
+	sprintf(szTS, "%02u:%02u%c%03u", start.min, start.sec, write_srt ? ',' : '.', start.ms);
+	gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
+
+	sprintf(szTS, " --> ");
+	gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
+
+	if (write_hour) {
+		sprintf(szTS, "%02u:", end.hour);
+		gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
+	}
+	sprintf(szTS, "%02u:%02u%c%03u", end.min, end.sec, write_srt ? ',' : '.', end.ms);
+	gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
+#endif
+}
+
 GF_Err writegen_process(GF_Filter *filter)
 {
 	GF_GenDumpCtx *ctx = gf_filter_get_udta(filter);
@@ -993,6 +1175,9 @@
 		if (gf_filter_pid_is_eos(ctx->ipid)) {
 			if (ctx->is_wav) writegen_write_wav_header(ctx);
 			else if (ctx->ttml_agg) writegen_flush_ttml(ctx);
+			else if (ctx->codecid==GF_CODECID_TX3G) {
+				writegen_flush_ttxt(ctx);
+			}
 			gf_filter_pid_set_eos(ctx->opid);
 			return GF_EOS;
 		}
@@ -1048,20 +1233,39 @@
 
 	if (ctx->frame) {
 		split = GF_TRUE;
-	} else if (ctx->dcfg_size && gf_filter_pck_get_sap(pck) && !ctx->is_mj2k && (ctx->decinfo!=DECINFO_NO) && !ctx->cfg_sent) {
-		dst_pck = gf_filter_pck_new_shared(ctx->opid, ctx->dcfg, ctx->dcfg_size, NULL);
-		if (!dst_pck) return GF_OUT_OF_MEM;
-
+	} else if (ctx->dcfg_size && gf_filter_pck_get_sap(pck) && !ctx->is_mj2k && !ctx->webvtt && (ctx->decinfo!=DECINFO_NO) && !ctx->cfg_sent) {
+		if (ctx->codecid==GF_CODECID_FLAC) {
+			u8 *dsi_out;
+			dst_pck = gf_filter_pck_new_alloc(ctx->opid, ctx->dcfg_size+4, &dsi_out);
+			if (!dst_pck) return GF_OUT_OF_MEM;
+			dsi_out0 = 'f';
+			dsi_out1 = 'L';
+			dsi_out2 = 'a';
+			dsi_out3 = 'C';
+			memcpy(dsi_out+4, ctx->dcfg, ctx->dcfg_size);
+		} else {
+			dst_pck = gf_filter_pck_new_shared(ctx->opid, ctx->dcfg, ctx->dcfg_size, NULL);
+			if (!dst_pck) return GF_OUT_OF_MEM;
+			gf_filter_pck_set_readonly(dst_pck);
+		}
 		gf_filter_pck_merge_properties(pck, dst_pck);
-		gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE);
+		if (!ctx->unframe_only)
+			gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE);
+
+		if (ctx->first) {
+			gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENUM, &PROP_UINT(ctx->sample_num) );
+			ctx->sample_num--;
+		}
+
 		ctx->first = GF_FALSE;
-		gf_filter_pck_set_readonly(dst_pck);
 		gf_filter_pck_send(dst_pck);
 		if ((ctx->decinfo==DECINFO_FIRST) && !ctx->split) {
 			ctx->dcfg_size = 0;
 			ctx->dcfg = NULL;
 		}
 		ctx->cfg_sent = GF_TRUE;
+		if (ctx->codecid==GF_CODECID_TX3G)
+			ctx->need_ttxt_footer = GF_TRUE;
 		return GF_OK;
 	}
 	ctx->cfg_sent = GF_FALSE;
@@ -1184,7 +1388,76 @@
 		if (!dst_pck) {
 			dst_pck = gf_filter_pck_new_ref(ctx->opid, 0, 0, pck);
 		}
+	} else if (ctx->webvtt || ctx->dump_srt) {
+		const GF_PropertyValue *p;
+
+		if (!data || !pck_size) {
+			ctx->sample_num--;
+			goto no_output;
+		}
+
+		u64 start = gf_filter_pck_get_cts(pck);
+		u64 end = start + gf_filter_pck_get_duration(pck);
+		u32 timescale = gf_filter_pck_get_timescale(pck);
 
+		if (!ctx->bs) ctx->bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+		else gf_bs_reassign_buffer(ctx->bs, ctx->write_buf, ctx->write_alloc);
+
+		if (ctx->first && !ctx->dump_srt) {
+			if (ctx->dcfg && ctx->dcfg_size) {
+				u32 len = ctx->dcfg_size;
+				if (ctx->dcfglen-1==0) len--;
+				gf_bs_write_data(ctx->bs, ctx->dcfg, len);
+				if (ctx->dcfglen-1!='\n')
+					gf_bs_write_data(ctx->bs, "\n", 1);
+				gf_bs_write_data(ctx->bs, "\n", 1);
+			} else
+				gf_bs_write_data(ctx->bs, "WEBVTT\n\n", 8);
+		}
+		p = gf_filter_pck_get_property_str(pck, "vtt_pre");
+		if (!ctx->dump_srt && p && p->value.string) {
+			u32 len = (u32) strlen(p->value.string);
+			gf_bs_write_data(ctx->bs, p->value.string, len);
+			if (len && (p->value.stringlen-1!='\n'))
+				gf_bs_write_data(ctx->bs, "\n", 1);
+			gf_bs_write_data(ctx->bs, "\n", 1);
+		}
+		p = gf_filter_pck_get_property_str(pck, "vtt_cueid");
+		if (!ctx->dump_srt && p && p->value.string) {
+			u32 len = (u32) strlen(p->value.string) ;
+			gf_bs_write_data(ctx->bs, p->value.string, len);
+			if (len && (p->value.stringlen-1!='\n'))
+				gf_bs_write_data(ctx->bs, "\n", 1);
+		}
+
+		if (ctx->dump_srt) {
+			char szCID100;
+			sprintf(szCID, "%d\n", ctx->sample_num);
+			gf_bs_write_data(ctx->bs, szCID, (u32) strlen(szCID));
+		}
+		webvtt_timestamps_dump(ctx->bs, start, end, timescale, ctx->dump_srt);
+
+		p = gf_filter_pck_get_property_str(pck, "vtt_settings");
+		if (!ctx->dump_srt && p && p->value.string) {
+			gf_bs_write_data(ctx->bs, " ", 1);
+			gf_bs_write_data(ctx->bs, p->value.string, (u32) strlen(p->value.string));
+		}
+
+		gf_bs_write_data(ctx->bs, "\n", 1);
+		if (data) {
+			gf_bs_write_data(ctx->bs, data, pck_size);
+			if (pck_size && (datapck_size-1 != '\n'))
+				gf_bs_write_data(ctx->bs, "\n", 1);
+		}
+		gf_bs_write_data(ctx->bs, "\n", 1);
+
+		u8 *odata;
+		u32 vtt_data_size, alloc_size;
+		gf_bs_get_content_no_truncate(ctx->bs, &ctx->write_buf, &vtt_data_size, &alloc_size);
+		if (alloc_size>ctx->write_alloc) ctx->write_alloc = alloc_size;
+
+		dst_pck = gf_filter_pck_new_alloc(ctx->opid, vtt_data_size, &odata);
+		memcpy(odata, ctx->write_buf, vtt_data_size);
 	} else {
 		dst_pck = gf_filter_pck_new_ref(ctx->opid, 0, 0, pck);
 	}
@@ -1195,15 +1468,21 @@
 	gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
 
 	if (split) {
-		gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENUM, &PROP_UINT(ctx->sample_num) );
-		gf_filter_pck_set_framing(dst_pck, GF_TRUE, GF_TRUE);
+		if (ctx->first)
+			gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENUM, &PROP_UINT(ctx->sample_num) );
+		gf_filter_pck_set_framing(dst_pck, ctx->first, ctx->need_ttxt_footer ? GF_FALSE : GF_TRUE);
+		ctx->first = GF_TRUE;
 	} else {
-		gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE);
+		if (!ctx->unframe_only)
+			gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE);
 		ctx->first = GF_FALSE;
 	}
 
 	gf_filter_pck_set_seek_flag(dst_pck, 0);
 	gf_filter_pck_send(dst_pck);
+
+	if (split && ctx->need_ttxt_footer)
+		writegen_flush_ttxt(ctx);
 	ctx->nb_bytes += pck_size;
 
 no_output:
@@ -1266,7 +1545,7 @@
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MVC),
 	CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "264|h264|avc|svc|mvc"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "264|h264|avc|svc|mvc|26l|h26l"),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/avc|video/h264|video/svc|video/mvc"),
 	{0},
 
@@ -1276,7 +1555,7 @@
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_LHVC),
 	CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "265|h265|hvc|hevc|shvc|lhvc"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "265|h265|hvc|hevc|shvc|mhvc|lhvc"),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/hevc|video/lhvc|video/shvc|video/mhvc"),
 	{0},
 
@@ -1296,7 +1575,7 @@
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG4_PART2),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "cmp|m4ve|m4v"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "cmp|m4v"),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/mp4v-es"),
 	{0},
 
@@ -1394,13 +1673,6 @@
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "image/jp2"),
 	{0},
 
-	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
-	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_V210),
-	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "v210"),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/x-raw-v210"),
-	{0},
-
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG_AUDIO),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
@@ -1426,7 +1698,7 @@
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AMR),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AMR_WB),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "amr"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "amr|awb"),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/amr"),
 	{0},
 
@@ -1466,16 +1738,38 @@
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "x-subtitle/srt|subtitle/srt|text/srt"),
 	{0},
 
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_META_XML),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "xml|txml|ttml"),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "subtitle/ttml|text/ttml|application/xml+ttml"),
 	{0},
 
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "vtt"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "subtitle/vtt|text/vtt"),
+	{0},
+
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "srt"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "subtitle/srt|text/srt"),
+	{0},
+
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "ttxt"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "x-subtitle/ttxt|subtitle/ttxt|text/ttxt"),
+	{0},
+
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_QCELP),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "qcelp"),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/qcelp"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-qcelp"),
 	{0},
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_THEORA),
@@ -1504,6 +1798,12 @@
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mhas"),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/mpegh"),
 	{0},
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SMPTE_VC1),
+	CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "vc1"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/vc1"),
+	{0},
 
 	//we accept unframed VVC (annex B format)
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
@@ -1517,7 +1817,7 @@
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
 	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TRUEHD),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mlp"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mlp|thd|truehd"),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/truehd"),
 	{0},
 
@@ -1536,6 +1836,17 @@
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/x-yuv4mpeg"),
 	{0},
 
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_CA),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_X),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_HD_HR),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_HD_MASTER),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_LBR),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "dts"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/dts"),
+	{0},
+
 	//anything else: only for explicit dump (filter loaded on purpose), otherwise don't load for filter link resolution
 	CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "*"),
@@ -1603,6 +1914,7 @@
 {
 	GF_GenDumpCtx *ctx = gf_filter_get_udta(filter);
 	if (ctx->bs) gf_bs_del(ctx->bs);
+	if (ctx->write_buf) gf_free(ctx->write_buf);
 	if (ctx->ttml_root)
 		gf_xml_dom_node_del(ctx->ttml_root);
 
@@ -1623,7 +1935,8 @@
 	.finalize = writegen_finalize,
 	SETCAPS(GenDumpCaps),
 	.configure_pid = writegen_configure_pid,
-	.process = writegen_process
+	.process = writegen_process,
+	.flags = GF_FS_REG_TEMP_INIT
 };
 
 static const GF_FilterCapability FrameDumpCaps =
@@ -1659,4 +1972,39 @@
 	return &GenDumpRegister;
 }
 
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
+
+static GF_Err writeuf_initialize(GF_Filter *filter)
+{
+	GF_GenDumpCtx *ctx = gf_filter_get_udta(filter);
+	ctx->unframe_only = GF_TRUE;
+	return GF_OK;
+}
+
+/* writeuf: same as writegen but declare unframed output cap rather than mime / ext , used to force unframed format for all streams handled by writegen */
+static GF_FilterCapability GenDumpXCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT|GF_CAPFLAG_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT|GF_CAPFLAG_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	//prevent connection of this filter to file outputs, we only connect to unframer or all reframers
+	CAP_STRING(GF_CAPS_OUTPUT|GF_CAPFLAG_OPTIONAL, GF_PROP_PID_FILE_EXT, "__ignore"),
+};
+
+
+const GF_FilterRegister WriteUFRegister = {
+	.name = "writeuf",
+	GF_FS_SET_DESCRIPTION("Stream to unframed format")
+	GF_FS_SET_HELP("Generic single stream to unframed format converter, used when converting PIDs. This filter should not be explicitly loaded.\n")
+	.private_size = sizeof(GF_GenDumpCtx),
+	.initialize = writeuf_initialize,
+	.finalize = writegen_finalize,
+	SETCAPS(GenDumpXCaps),
+	.configure_pid = writegen_configure_pid,
+	.process = writegen_process
+};
+const GF_FilterRegister *writeuf_register(GF_FilterSession *session)
+{
+
+	return &WriteUFRegister;
+}

gpac-2.0.0.tar.gz/src/filters/write_nhml.c -> gpac-2.2.0.tar.gz/src/filters/write_nhml.c Changed

@@ -306,8 +306,7 @@
 	ctx->is_stpp = (cid==GF_CODECID_SUBS_XML) ? GF_TRUE : GF_FALSE;
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
-	if (p) ctx->duration = p->value.lfrac;
-
+	if (p && (p->value.lfrac.num>0)) ctx->duration = p->value.lfrac;
 
 	if (ctx->opid_nhml)
 		gf_filter_pid_set_name(ctx->opid_nhml, "nhml");
@@ -343,7 +342,7 @@
 
 
 
-static void nhmldump_send_header(GF_NHMLDumpCtx *ctx)
+static GF_Err nhmldump_send_header(GF_NHMLDumpCtx *ctx)
 {
 	GF_FilterPacket *dst_pck;
 	char nhml1024;
@@ -490,19 +489,19 @@
 	gf_bs_get_content_no_truncate(ctx->bs_w, &ctx->nhml_buffer, &size, &ctx->nhml_buffer_size);
 
 	if (ctx->filep) {
-		gf_fwrite(ctx->nhml_buffer, size, ctx->filep);
-		return;
+		if (gf_fwrite(ctx->nhml_buffer, size, ctx->filep) != size) return GF_IO_ERR;
+		return GF_OK;
 	}
 
 	dst_pck = gf_filter_pck_new_alloc(ctx->opid_nhml, size, &output);
-	if (!dst_pck) return;
+	if (!dst_pck) return GF_OUT_OF_MEM;
 
 	memcpy(output, ctx->nhml_buffer, size);
 	gf_filter_pck_set_framing(dst_pck, GF_TRUE, GF_FALSE);
-	gf_filter_pck_send(dst_pck);
+	return gf_filter_pck_send(dst_pck);
 }
 
-static void nhmldump_send_dims(GF_NHMLDumpCtx *ctx, char *data, u32 data_size, GF_FilterPacket *pck)
+static GF_Err nhmldump_send_dims(GF_NHMLDumpCtx *ctx, char *data, u32 data_size, GF_FilterPacket *pck)
 {
 	char nhml1024;
 	u32 size;
@@ -597,7 +596,7 @@
 			gf_bs_del(ctx->bs_r);
 			if (prev)
 				datapos+2+size = prev;
-			return;
+			return GF_NOT_SUPPORTED;
 #endif
 		} else {
 			gf_bs_write_data(ctx->bs_w, data+pos+3, size-1);
@@ -613,16 +612,16 @@
 	gf_bs_get_content_no_truncate(ctx->bs_w, &ctx->nhml_buffer, &size, &ctx->nhml_buffer_size);
 
 	if (ctx->filep) {
-		gf_fwrite(ctx->nhml_buffer, size, ctx->filep);
-		return;
+		if (gf_fwrite(ctx->nhml_buffer, size, ctx->filep) != size) return GF_IO_ERR;
+		return GF_OK;
 	}
 
 	dst_pck = gf_filter_pck_new_alloc(ctx->opid_nhml, size, &output);
-	if (!dst_pck) return;
+	if (!dst_pck) return GF_OUT_OF_MEM;
 
 	memcpy(output, ctx->nhml_buffer, size);
 	gf_filter_pck_set_framing(dst_pck, GF_FALSE, GF_FALSE);
-	gf_filter_pck_send(dst_pck);
+	return gf_filter_pck_send(dst_pck);
 }
 
 
@@ -657,7 +656,7 @@
 	gf_bs_write_data(ctx->bs_w, nhml, (u32) strlen(nhml));
 }
 
-static void nhmldump_send_frame(GF_NHMLDumpCtx *ctx, char *data, u32 data_size, GF_FilterPacket *pck)
+static GF_Err nhmldump_send_frame(GF_NHMLDumpCtx *ctx, char *data, u32 data_size, GF_FilterPacket *pck)
 {
 	GF_FilterPacket *dst_pck;
 	char nhml1024;
@@ -781,8 +780,8 @@
 					gf_bs_write_data(ctx->bs_w, nhml, (u32) strlen(nhml));
 				} else {
 					u32 d_size;
-					if (ctx->b64_buffer_size<2*s_size) {
-						ctx->b64_buffer_size = 2 * s_size;
+					if (ctx->b64_buffer_size < 2*s_size + 3) {
+						ctx->b64_buffer_size = 2 * s_size + 3;
 						ctx->b64_buffer = gf_realloc(ctx->b64_buffer, ctx->b64_buffer_size);
 					}
 					d_size = gf_base64_encode(data + offset_in_sample, s_size, ctx->b64_buffer, ctx->b64_buffer_size);
@@ -812,8 +811,8 @@
 	gf_bs_get_content_no_truncate(ctx->bs_w, &ctx->nhml_buffer, &size, &ctx->nhml_buffer_size);
 
 	if (ctx->filep) {
-		gf_fwrite(ctx->nhml_buffer, size, ctx->filep);
-		return;
+		if (gf_fwrite(ctx->nhml_buffer, size, ctx->filep) != size) return GF_IO_ERR;
+		return GF_OK;
 	}
 
 	dst_pck = gf_filter_pck_new_alloc(ctx->opid_nhml, size, &output);
@@ -828,7 +827,7 @@
 	if (ctx->opid_mdia) {
 		//send the complete data packet
 		dst_pck = gf_filter_pck_new_ref(ctx->opid_mdia, 0, data_size, pck);
-		if (!dst_pck) return;
+		if (!dst_pck) return GF_OUT_OF_MEM;
 
 		gf_filter_pck_merge_properties(pck, dst_pck);
 		//keep byte offset ?
@@ -837,6 +836,7 @@
 		gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE);
 		gf_filter_pck_send(dst_pck);
 	}
+	return GF_OK;
 }
 
 
@@ -846,6 +846,7 @@
 	GF_FilterPacket *pck;
 	char *data;
 	u32 pck_size;
+	GF_Err e;
 
 	if (!ctx->side_streams_config) {
 		return nhmldump_config_side_stream(filter, ctx);
@@ -854,6 +855,7 @@
 	pck = gf_filter_pid_get_packet(ctx->ipid);
 	if (!pck) {
 		if (gf_filter_pid_is_eos(ctx->ipid)) {
+			e = GF_EOS;
 			if (ctx->bs_w && ctx->szRootName) {
 				char nhml1024;
 				u32 size;
@@ -864,7 +866,8 @@
 				gf_bs_get_content_no_truncate(ctx->bs_w, &ctx->nhml_buffer, &size, &ctx->nhml_buffer_size);
 
 				if (ctx->filep) {
-					gf_fwrite(ctx->nhml_buffer, size, ctx->filep);
+					if (gf_fwrite(ctx->nhml_buffer, size, ctx->filep) != size)
+						e = GF_IO_ERR;
 				} else {
 					GF_FilterPacket *dst_pck;
 					u8 *output;
@@ -872,7 +875,9 @@
 					if (dst_pck) {
 						memcpy(output, ctx->nhml_buffer, size);
 						gf_filter_pck_set_framing(dst_pck, GF_FALSE, GF_TRUE);
-						gf_filter_pck_send(dst_pck);
+						e = gf_filter_pck_send(dst_pck);
+					} else {
+						e = GF_OUT_OF_MEM;
 					}
 				}
 				ctx->szRootName = NULL;
@@ -880,7 +885,7 @@
 			if (ctx->opid_nhml) gf_filter_pid_set_eos(ctx->opid_nhml);
 			if (ctx->opid_mdia) gf_filter_pid_set_eos(ctx->opid_mdia);
 			if (ctx->opid_info) gf_filter_pid_set_eos(ctx->opid_info);
-			return GF_EOS;
+			return e;
 		}
 		return GF_OK;
 	}
@@ -889,7 +894,8 @@
 	else gf_bs_reassign_buffer(ctx->bs_w, ctx->nhml_buffer, ctx->nhml_buffer_size);
 
 	if (ctx->first) {
-		nhmldump_send_header(ctx);
+		e = nhmldump_send_header(ctx);
+		if (e) return e;
 		gf_bs_reassign_buffer(ctx->bs_w, ctx->nhml_buffer, ctx->nhml_buffer_size);
 	}
 
@@ -898,11 +904,12 @@
 
 	//send data
 	if (ctx->is_dims) {
-		nhmldump_send_dims(ctx, data, pck_size, pck);
+		e = nhmldump_send_dims(ctx, data, pck_size, pck);
 	} else {
-		nhmldump_send_frame(ctx, data, pck_size, pck);
+		e = nhmldump_send_frame(ctx, data, pck_size, pck);
 	}
 	ctx->first = GF_FALSE;
+	if (e) return e;
 
 
 	if (ctx->exporter) {

gpac-2.0.0.tar.gz/src/filters/write_nhnt.c -> gpac-2.2.0.tar.gz/src/filters/write_nhnt.c Changed

gpac-2.0.0.tar.gz/src/filters/write_qcp.c -> gpac-2.2.0.tar.gz/src/filters/write_qcp.c Changed

@@ -100,30 +100,29 @@
 		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_FILE) );
 	}
 
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("qcp") );
 	switch (ctx->codecid) {
 	case GF_CODECID_QCELP:
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("qcp") );
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/qcp") );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/qcelp") );
 		ctx->qcp_type = 1;
 		memcpy(ctx->GUID, QCP_QCELP_GUID_1, sizeof(char)*16);
 		break;
 	case GF_CODECID_EVRC_PV:
 	case GF_CODECID_EVRC:
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("evc") );
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/qcp") );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/evrc-qcp") );
 		memcpy(ctx->GUID, QCP_EVRC_GUID, sizeof(char)*16);
 		ctx->qcp_type = 3;
 		break;
 	case GF_CODECID_SMV:
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("smv") );
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/qcp") );
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/smv-qcp") );
 		ctx->qcp_type = 2;
 		memcpy(ctx->GUID, QCP_SMV_GUID, sizeof(char)*16);
 		break;
+	default:
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/qcelp") );
+		break;
 	}
 
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("qcp") );
-	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("audio/qcp") );
 	ctx->first = GF_TRUE;
 
 	if (ctx->exporter) {
@@ -132,7 +131,7 @@
 
 	ctx->ipid = pid;
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
-	if (p) ctx->duration = p->value.lfrac;
+	if (p && (p->value.lfrac.num>0)) ctx->duration = p->value.lfrac;
 
 	gf_filter_pid_set_framing_mode(pid, GF_TRUE);
 
@@ -362,7 +361,7 @@
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
 	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
 	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "qcp"),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/qcp"),
+	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/qcelp|audio/evrc-qcp|audio/smv-qcp"),
 };

gpac-2.2.0.tar.gz/src/filters/write_tx3g.c Added

@@ -0,0 +1,711 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / TX3G to SRT/VTT/TTML convert filter
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <gpac/filters.h>
+#include <gpac/constants.h>
+#include <gpac/bitstream.h>
+#include <gpac/internal/isomedia_dev.h>
+#include <gpac/internal/media_dev.h>
+#include <gpac/color.h>
+
+#if !defined(GPAC_DISABLE_ISOM_DUMP) && !defined(GPAC_DISABLE_ISOM)
+
+
+typedef struct
+{
+	//opts
+	Bool exporter, merge;
+
+	//only one input pid declared
+	GF_FilterPid *ipid;
+	//only one output pid declared
+	GF_FilterPid *opid;
+
+	GF_BitStream *bs_r;
+	u32 codecid;
+
+	GF_Fraction64 duration;
+
+	GF_TextConfig *cfg;
+	u32 dsi_crc;
+	Bool is_tx3g;
+
+	u32 dump_type;
+	u32 cur_frame;
+} TX3GMxCtx;
+
+static void tx3gmx_write_config(TX3GMxCtx *ctx);
+
+GF_Err tx3gmx_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
+{
+	GF_Err e;
+	const GF_PropertyValue *p;
+	TX3GMxCtx *ctx = gf_filter_get_udta(filter);
+
+	if (is_remove) {
+		ctx->ipid = NULL;
+		if (ctx->opid) {
+			gf_filter_pid_remove(ctx->opid);
+			ctx->opid = NULL;
+		}
+		return GF_OK;
+	}
+	if (! gf_filter_pid_check_caps(pid))
+		return GF_NOT_SUPPORTED;
+
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
+	if (!p) return GF_NOT_SUPPORTED;
+	ctx->codecid = p->value.uint;
+
+	//decoder config may be not ready yet
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+	if (p) {
+		u32 crc = gf_crc_32(p->value.data.ptr, p->value.data.size);
+		if (crc == ctx->dsi_crc) return GF_OK;
+		ctx->dsi_crc = crc;
+	}
+
+
+	if (!ctx->opid) {
+		ctx->opid = gf_filter_pid_new(filter);
+	}
+	gf_filter_pid_copy_properties(ctx->opid, pid);
+
+	u32 codec_id = 0;
+	if (ctx->dump_type==3) codec_id = GF_CODECID_SUBS_XML;
+	else if (ctx->dump_type==2) codec_id = GF_CODECID_WEBVTT;
+	else if (ctx->dump_type==1) codec_id = GF_CODECID_SIMPLE_TEXT;
+	else codec_id = GF_CODECID_TX3G;
+
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_TEXT) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(codec_id) );
+	if (ctx->dump_type<3)
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, NULL );
+
+	ctx->ipid = pid;
+
+	//decoder config may be not ready yet
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+	if (!p) return GF_OK;
+
+	if (ctx->cfg) gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
+	ctx->cfg = (GF_TextConfig *) gf_odf_desc_new(GF_ODF_TEXT_CFG_TAG);
+	if (ctx->codecid == GF_CODECID_TEXT_MPEG4) {
+		e = gf_odf_get_text_config(p->value.data.ptr, p->value.data.size, GF_CODECID_TEXT_MPEG4, ctx->cfg);
+		if (e) {
+			gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
+			ctx->cfg = NULL;
+			return e;
+		}
+		ctx->is_tx3g = GF_FALSE;
+	} else if (ctx->codecid == GF_CODECID_TX3G) {
+		GF_TextSampleDescriptor * sd = gf_odf_tx3g_read(p->value.data.ptr, p->value.data.size);
+		if (!sd) {
+			gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
+			ctx->cfg = NULL;
+			return GF_NON_COMPLIANT_BITSTREAM;
+		}
+		if (!sd->default_style.text_color)
+			sd->default_style.text_color = 0xFFFFFFFF;
+
+		gf_list_add(ctx->cfg->sample_descriptions, sd);
+		ctx->is_tx3g = GF_TRUE;
+	}
+
+	if (ctx->exporter) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Exporting %s\n", gf_codecid_name(ctx->codecid)));
+	}
+
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
+	if (p && (p->value.lfrac.num>0)) ctx->duration = p->value.lfrac;
+
+	gf_filter_pid_set_framing_mode(pid, GF_TRUE);
+
+	if (!ctx->dump_type)
+		tx3gmx_write_config(ctx);
+
+	return GF_OK;
+}
+
+void dump_ttxt_header(FILE *dump, GF_Tx3gSampleEntryBox *txt_e, u32 def_width, u32 def_height);
+
+static void tx3gmx_get_stsd(GF_TextSampleDescriptor *ent, GF_Tx3gSampleEntryBox *samp_ent, GF_FontTableBox *font_ent)
+{
+	memset(samp_ent, 0, sizeof(GF_Tx3gSampleEntryBox));
+	samp_ent->type = GF_ISOM_BOX_TYPE_TX3G;
+	samp_ent->displayFlags = ent->displayFlags;
+	samp_ent->horizontal_justification = ent->horiz_justif;
+	samp_ent->vertical_justification = ent->vert_justif;
+	samp_ent->back_color = ent->back_color;
+	samp_ent->default_box = ent->default_pos;
+	samp_ent->default_style = ent->default_style;
+	samp_ent->font_table = font_ent;
+	font_ent->entry_count = ent->font_count;
+	font_ent->fonts = ent->fonts;
+}
+
+static void tx3gmx_write_config(TX3GMxCtx *ctx)
+{
+	FILE *dump = gf_file_temp(NULL);
+	GF_Tx3gSampleEntryBox samp_ent;
+	GF_FontTableBox font_ent;
+	const GF_PropertyValue *p;
+	GF_TextSampleDescriptor *ent = gf_list_get(ctx->cfg->sample_descriptions, 0);
+
+	tx3gmx_get_stsd(ent, &samp_ent, &font_ent);
+
+	p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_WIDTH);
+	u32 w = p ? p->value.uint : 0;
+	p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_HEIGHT);
+	u32 h = p ? p->value.uint : 0;
+
+
+	gf_fprintf(dump, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
+	gf_fprintf(dump, "\n");
+	gf_fprintf(dump, "<TextStream version=\"1.1\">\n");
+	if (w && h) {
+		gf_fprintf(dump, "<TextStreamHeader width=\"%u\" height=\"%u\">\n", w, h);
+	} else {
+		gf_fprintf(dump, "<TextStreamHeader>\n");
+	}
+#ifndef GPAC_DISABLE_ISOM_DUMP
+	dump_ttxt_header(dump, &samp_ent, w, h);
+#endif
+	gf_fprintf(dump, "</TextStreamHeader>\n");
+
+	u32 size = (u32) gf_ftell(dump);
+	u8 *dsi = gf_malloc(size);
+	if (dsi) {
+		gf_fseek(dump, 0, SEEK_SET);
+		gf_fread(dsi, size, dump);
+		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, size));
+	}
+
+	gf_fclose(dump);
+}
+
+//from libisomedia box_dump.c
+void dump_ttxt_sample(FILE *dump, GF_TextSample *s_txt, u64 ts, u32 timescale, u32 di, Bool box_dump);
+char *tx3g_format_time(u64 ts, u32 timescale, char *szDur, Bool is_srt);
+GF_Err dump_ttxt_sample_srt(FILE *dump, GF_TextSample *txt, GF_Tx3gSampleEntryBox *txtd, Bool vtt_dump);
+
+static GF_Err dump_ttxt_sample_ttml(TX3GMxCtx *ctx, FILE *dump, GF_TextSample *txt, GF_Tx3gSampleEntryBox *txtd, u64 start_ts, u64 end_ts)
+{
+	char szTime100;
+	u32 len, j, k;
+
+	gf_fprintf(dump,
+"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
+"<tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\" "
+"xmlns:tts=\"http://www.w3.org/ns/ttml#styling\" xmlns:ttp=\"http://www.w3.org/ns/ttml#parameter\"");
+
+	const GF_PropertyValue *p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_LANGUAGE);
+	if (p && p->value.string) {
+		gf_fprintf(dump, " xml:lang=\"%s\"", p->value.string);
+	}
+	gf_fprintf(dump, ">\n");
+
+	gf_fprintf(dump," <head>\n <layout>\n <region xml:id=\"Default\" tts:origin=\"5%% 5%%\" tts:extent=\"90%% 90%%\" tts:displayAlign=\"after\" tts:overflow=\"visible\"");
+
+	switch (txtd->horizontal_justification) {
+	case 1:
+		gf_fprintf(dump, " tts:textAlign=\"center\"");
+		break;/*center*/
+	case -1:
+		gf_fprintf(dump, " tts:textAlign=\"right\"");
+		break;/*right*/
+	default:
+		gf_fprintf(dump, " tts:textAlign=\"left\"");
+		break;/*left*/
+	}
+	if (txtd->default_style.font_size)
+		gf_fprintf(dump, " tts:fontSize=\"%dpx\"", txtd->default_style.font_size);
+	if (txtd->font_table && txtd->font_table->entry_count && txtd->font_table->fonts0.fontName)
+		gf_fprintf(dump, " tts:fontFamily=\"%s\"", txtd->font_table->fonts0.fontName);
+
+	gf_fprintf(dump, "/>\n </layout>\n </head>\n <body>\n <div>\n");
+
+	tx3g_format_time(start_ts, 1000, szTime, GF_FALSE);
+	gf_fprintf(dump, " len) {
+		gf_fprintf(dump, ">\n");
+		goto exit;
+	}
+
+	u32 styles, char_num, new_styles, color, new_color;
+	u16 *utf16Line = gf_malloc(sizeof(u16) * 4*txt->len);
+	if (!utf16Line) return GF_OUT_OF_MEM;
+	Bool has_span = GF_FALSE;
+
+	/*UTF16*/
+	if ((txt->len>2) && ((unsigned char) txt->text0 == (unsigned char) 0xFE) && ((unsigned char) txt->text1 == (unsigned char) 0xFF)) {
+		memcpy(utf16Line, txt->text+2, sizeof(char)*txt->len);
+		( ((char *)utf16Line)txt->len ) = 0;
+		len = txt->len;
+	} else {
+		u8 *str = (u8 *) (txt->text);
+		len = gf_utf8_mbstowcs(utf16Line, 10000, (const char **) &str);
+		if (len == GF_UTF8_FAIL) return GF_NON_COMPLIANT_BITSTREAM;
+		utf16Linelen = 0;
+	}
+	char_num = 0;
+	styles = 0;
+	new_styles = txtd->default_style.style_flags;
+	color = new_color = txtd->default_style.text_color;
+	Bool single_style = GF_FALSE;
+	if (txt->styles && (txt->styles->entry_count==1)) {
+		if ((txt->styles->styles0.startCharOffset==0) && (txt->styles->styles0.endCharOffset==len)) {
+			single_style = GF_TRUE;
+			new_styles = txt->styles->styles0.style_flags;
+			new_color = txt->styles->styles0.text_color;
+		}
+	}
+	if (single_style) {
+		Bool needs_bold = (new_styles & GF_TXT_STYLE_BOLD);
+		Bool needs_italic = (new_styles & GF_TXT_STYLE_ITALIC);
+		Bool needs_underlined = (new_styles & GF_TXT_STYLE_UNDERLINED);
+		Bool needs_strikethrough = (new_styles & GF_TXT_STYLE_STRIKETHROUGH);
+		Bool needs_color = (new_color != txtd->default_style.text_color);
+		if (needs_bold || needs_italic || needs_underlined || needs_strikethrough || needs_color) {
+			if (needs_italic) gf_fprintf(dump, " tts:fontStyle=\"italic\"");
+			if (needs_bold) gf_fprintf(dump, " tts:fontWeight=\"bold\"");
+			if (needs_underlined) gf_fprintf(dump, " tts:textDecoration=\"underline\"");
+			if (needs_strikethrough) gf_fprintf(dump, " tts:textDecoration=\"lineThrough\"");
+
+			if (needs_color) gf_fprintf(dump, " tts:color=\"%s\"", gf_color_get_name(color));
+		}
+	}
+	//end of 
+	gf_fprintf(dump, ">");
+
+	for (j=0; j<len; j++) {
+		if (!single_style) {
+			if (txt->styles) {
+				new_styles = txtd->default_style.style_flags;
+				new_color = txtd->default_style.text_color;
+				for (k=0; k<txt->styles->entry_count; k++) {
+					if (txt->styles->stylesk.startCharOffset>char_num) continue;
+					if (txt->styles->stylesk.endCharOffset<char_num+1) continue;
+
+					if (txt->styles->stylesk.style_flags & (GF_TXT_STYLE_ITALIC | GF_TXT_STYLE_BOLD | GF_TXT_STYLE_UNDERLINED | GF_TXT_STYLE_STRIKETHROUGH)) {
+						new_styles = txt->styles->stylesk.style_flags;
+						new_color = txt->styles->stylesk.text_color;
+						break;
+					}
+				}
+			}
+
+			Bool needs_bold=GF_FALSE;
+			Bool needs_italic=GF_FALSE;
+			Bool needs_underlined=GF_FALSE;
+			Bool needs_strikethrough=GF_FALSE;
+			Bool needs_color=GF_FALSE;
+			Bool close_span=GF_FALSE;
+
+			if (new_color != color) {
+				close_span = GF_TRUE;
+				if (new_color != txtd->default_style.text_color) needs_color = GF_TRUE;
+				color = new_color;
+				//reset style to default
+				styles = txtd->default_style.style_flags;
+			}
+
+			if (new_styles != styles) {
+				if ((new_styles & GF_TXT_STYLE_BOLD) && !(styles & GF_TXT_STYLE_BOLD)) needs_bold = GF_TRUE;
+				if ((new_styles & GF_TXT_STYLE_ITALIC) && !(styles & GF_TXT_STYLE_ITALIC)) needs_italic = GF_TRUE;
+				if ((new_styles & GF_TXT_STYLE_UNDERLINED) && !(styles & GF_TXT_STYLE_UNDERLINED)) needs_underlined = GF_TRUE;
+				if ((new_styles & GF_TXT_STYLE_STRIKETHROUGH) && !(styles & GF_TXT_STYLE_STRIKETHROUGH)) needs_strikethrough = GF_TRUE;
+
+				styles = new_styles;
+			}
+
+			if (has_span && close_span) {
+				gf_fprintf(dump, "");
+				has_span = GF_FALSE;
+			}
+			if (needs_bold || needs_italic || needs_underlined || needs_strikethrough || needs_color) {
+				has_span = GF_TRUE;
+				gf_fprintf(dump, "<span");
+				if (needs_italic) gf_fprintf(dump, " tts:fontStyle=\"italic\"");
+				if (needs_bold) gf_fprintf(dump, " tts:fontWeight=\"bold\"");
+				if (needs_underlined) gf_fprintf(dump, " tts:textDecoration=\"underline\"");
+				if (needs_strikethrough) gf_fprintf(dump, " tts:textDecoration=\"lineThrough\"");
+
+				if (needs_color) gf_fprintf(dump, " tts:color=\"%s\"", gf_color_get_name(color));
+
+				gf_fprintf(dump, ">");
+			}
+		}
+
+		if (utf16Linej=='\r') {
+
+		} else if (utf16Linej=='\n') {
+			gf_fprintf(dump, " ");
+		} else {
+			u32 sl;
+			char szChar30;
+			s16 swT2, *swz;
+			swT0 = utf16Linej;
+			swT1 = 0;
+			swz= (s16 *)swT;
+			sl = gf_utf8_wcstombs(szChar, 30, (const unsigned short **) &swz);
+			if (sl == GF_UTF8_FAIL) sl=0;
+			szCharsl=0;
+			gf_fprintf(dump, "%s", szChar);
+		}
+		char_num++;
+	}
+
+	if (has_span) {
+		gf_fprintf(dump, "");
+	}
+	gf_fprintf(dump, "\n");
+	gf_free(utf16Line);
+
+
+exit:
+	gf_fprintf(dump, " </div>\n </body>\n</tt>");
+	return GF_OK;
+}
+
+GF_Err tx3gmx_process(GF_Filter *filter)
+{
+	TX3GMxCtx *ctx = gf_filter_get_udta(filter);
+	GF_FilterPacket *pck, *dst_pck;
+	u8 *data, *output;
+	u64 start_ts, end_ts;
+	u32 pck_size, timescale;
+	FILE *dump=NULL;
+	pck = gf_filter_pid_get_packet(ctx->ipid);
+	if (!pck) {
+		if (gf_filter_pid_is_eos(ctx->ipid)) {
+			gf_filter_pid_set_eos(ctx->opid);
+			return GF_EOS;
+		}
+		return GF_OK;
+	}
+
+	data = (char *) gf_filter_pck_get_data(pck, &pck_size);
+	if (pck_size<=1) {
+		gf_filter_pid_drop_packet(ctx->ipid);
+		return GF_NON_COMPLIANT_BITSTREAM;
+	}
+	if (ctx->dump_type && (pck_size<=2)) {
+		gf_filter_pid_drop_packet(ctx->ipid);
+		return GF_OK;
+	}
+
+	timescale = gf_filter_pck_get_timescale(pck);
+	if (!timescale) timescale=1000;
+
+	start_ts = gf_filter_pck_get_cts(pck);
+	end_ts = start_ts + gf_filter_pck_get_duration(pck);
+
+	start_ts = gf_timestamp_rescale(start_ts, timescale, 1000);
+	end_ts = gf_timestamp_rescale(end_ts, timescale, 1000);
+
+
+	gf_bs_reassign_buffer(ctx->bs_r, data, pck_size);
+
+	while (gf_bs_available(ctx->bs_r)) {
+		GF_TextSample *txt;
+		//Bool is_utf_16=GF_FALSE;
+		u32 type, /*length, */sample_index;
+
+		if (!ctx->is_tx3g) {
+			/*is_utf_16 = (Bool) */gf_bs_read_int(ctx->bs_r, 1);
+			gf_bs_read_int(ctx->bs_r, 4);
+			type = gf_bs_read_int(ctx->bs_r, 3);
+			/*length = */gf_bs_read_u16(ctx->bs_r);
+
+			/*currently only full text samples are supported*/
+			if (type != 1) {
+				return GF_NOT_SUPPORTED;
+			}
+			sample_index = gf_bs_read_u8(ctx->bs_r);
+			/*duration*/
+			//sample_duration = gf_bs_read_u24(ctx->bs_r);
+		} else {
+			sample_index = 1;
+			/*duration*/
+			//sample_duration = gf_filter_pck_get_duration(pck);
+		}
+		/*txt length is parsed with the sample*/
+		txt = gf_isom_parse_text_sample(ctx->bs_r);
+		if (!txt) return GF_NON_COMPLIANT_BITSTREAM;
+
+		if (!dump)
+			dump = gf_file_temp(NULL);
+
+		if (ctx->dump_type) {
+			ctx->cur_frame++;
+
+			GF_TextSampleDescriptor *ent = gf_list_get(ctx->cfg->sample_descriptions, sample_index-1);
+			if (ent) {
+				GF_Tx3gSampleEntryBox txtd;
+				GF_FontTableBox font_ent;
+
+				tx3gmx_get_stsd(ent, &txtd, &font_ent);
+				if (ctx->dump_type<3) {
+					dump_ttxt_sample_srt(dump, txt, &txtd, (ctx->dump_type==2) ? GF_TRUE : GF_FALSE);
+				} else {
+					dump_ttxt_sample_ttml(ctx, dump, txt, &txtd, start_ts, end_ts);
+				}
+			}
+		} else {
+			dump_ttxt_sample(dump, txt, gf_filter_pck_get_cts(pck), gf_filter_pck_get_timescale(pck), sample_index, GF_FALSE);
+		}
+
+		gf_isom_delete_text_sample(txt);
+
+		/*since we support only TTU(1), no need to go on*/
+		if (!ctx->is_tx3g) {
+			break;
+		} else {
+			//tx3g mode, single sample per AU
+			break;
+		}
+	}
+
+	if (dump && gf_ftell(dump)) {
+		u32 size = (u32) gf_ftell(dump);
+		dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output);
+		if (!dst_pck) return GF_OUT_OF_MEM;
+		gf_fseek(dump, 0, SEEK_SET);
+		gf_fread(output, size, dump);
+		gf_filter_pck_merge_properties(pck, dst_pck);
+		gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
+		gf_filter_pck_set_framing(dst_pck, GF_TRUE, GF_TRUE);
+		gf_filter_pck_set_sap(dst_pck, GF_FILTER_SAP_1);
+
+		gf_filter_pck_send(dst_pck);
+	}
+	if (dump) gf_fclose(dump);
+
+	if (ctx->exporter) {
+		u64 ts = gf_filter_pck_get_cts(pck);
+		timescale = gf_filter_pck_get_timescale(pck);
+		gf_set_progress("Exporting", ts*ctx->duration.den, ctx->duration.num*timescale);
+	}
+
+	gf_filter_pid_drop_packet(ctx->ipid);
+
+	return GF_OK;
+}
+
+static GF_Err tx3gmx_initialize(GF_Filter *filter)
+{
+	TX3GMxCtx *ctx = gf_filter_get_udta(filter);
+	ctx->bs_r = gf_bs_new((char *) "", 1, GF_BITSTREAM_READ);
+	return GF_OK;
+}
+
+static void tx3gmx_finalize(GF_Filter *filter)
+{
+	TX3GMxCtx *ctx = gf_filter_get_udta(filter);
+	if (ctx->cfg) gf_odf_desc_del((GF_Descriptor *) ctx->cfg);
+	gf_bs_del(ctx->bs_r);
+}
+
+static const GF_FilterCapability TX3GMxCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TEXT_MPEG4),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+};
+
+
+#define OFFS(_n)	#_n, offsetof(TX3GMxCtx, _n)
+static const GF_FilterArgs TX3GMxArgs =
+{
+	{ OFFS(exporter), "compatibility with old exporter, displays export results", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{0}
+};
+
+GF_FilterRegister TTXTMxRegister = {
+	.name = "ufttxt",
+	GF_FS_SET_DESCRIPTION("TX3G unframer")
+	GF_FS_SET_HELP("This filter converts a single ISOBMFF TX3G stream to TTXT (xml format) unframed stream.")
+	.private_size = sizeof(TX3GMxCtx),
+	.args = TX3GMxArgs,
+	.initialize = tx3gmx_initialize,
+	.finalize = tx3gmx_finalize,
+	SETCAPS(TX3GMxCaps),
+	.configure_pid = tx3gmx_configure_pid,
+	.process = tx3gmx_process
+};
+
+const GF_FilterRegister *ttxtuf_register(GF_FilterSession *session)
+{
+	return &TTXTMxRegister;
+}
+
+static const GF_FilterCapability TX3G2SRTCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TEXT_MPEG4),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT),
+	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+};
+
+static GF_Err tx3g2srt_initialize(GF_Filter *filter)
+{
+	TX3GMxCtx *ctx = gf_filter_get_udta(filter);
+	tx3gmx_initialize(filter);
+	ctx->dump_type=1;
+	return GF_OK;
+}
+
+GF_FilterRegister TX3G2SRTRegister = {
+	.name = "tx3g2srt",
+	GF_FS_SET_DESCRIPTION("TX3G to SRT")
+	GF_FS_SET_HELP("This filter converts a single ISOBMFF TX3G stream to an SRT unframed stream.")
+	.private_size = sizeof(TX3GMxCtx),
+	.args = TX3GMxArgs,
+	.initialize = tx3g2srt_initialize,
+	.finalize = tx3gmx_finalize,
+	SETCAPS(TX3G2SRTCaps),
+	.configure_pid = tx3gmx_configure_pid,
+	.process = tx3gmx_process
+};
+
+const GF_FilterRegister *tx3g2srt_register(GF_FilterSession *session)
+{
+	return &TX3G2SRTRegister;
+}
+
+
+static const GF_FilterCapability TX3G2VTTCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TEXT_MPEG4),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	{0},
+};
+
+static GF_Err tx3g2vtt_initialize(GF_Filter *filter)
+{
+	TX3GMxCtx *ctx = gf_filter_get_udta(filter);
+	tx3gmx_initialize(filter);
+	ctx->dump_type=2;
+	return GF_OK;
+}
+
+GF_FilterRegister TTX2VTTRegister = {
+	.name = "tx3g2vtt",
+	GF_FS_SET_DESCRIPTION("TX3G to WebVTT")
+	GF_FS_SET_HELP("This filter converts a single ISOBMFF TX3G stream to a WebVTT unframed stream.")
+	.private_size = sizeof(TX3GMxCtx),
+	.args = TX3GMxArgs,
+	.initialize = tx3g2vtt_initialize,
+	.finalize = tx3gmx_finalize,
+	SETCAPS(TX3G2VTTCaps),
+	.configure_pid = tx3gmx_configure_pid,
+	.process = tx3gmx_process
+};
+
+const GF_FilterRegister *tx3g2vtt_register(GF_FilterSession *session)
+{
+	return &TTX2VTTRegister;
+}
+
+
+static const GF_FilterCapability TX3G2TTMLCaps =
+{
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TX3G),
+	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TEXT_MPEG4),
+	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
+	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML),
+	{0},
+};
+
+static GF_Err tx3g2ttml_initialize(GF_Filter *filter)
+{
+	TX3GMxCtx *ctx = gf_filter_get_udta(filter);
+	tx3gmx_initialize(filter);
+	ctx->dump_type=3;
+	return GF_OK;
+}
+
+GF_FilterRegister TX3G2TTMLRegister = {
+	.name = "tx3g2ttml",
+	GF_FS_SET_DESCRIPTION("TX3G to TTML")
+	GF_FS_SET_HELP("This filter converts ISOBMFF TX3G stream to a TTML stream.\n"
+	"\n"
+	"Each output TTML frame is a complete TTML document.")
+	.private_size = sizeof(TX3GMxCtx),
+	.args = NULL,
+	.initialize = tx3g2ttml_initialize,
+	.finalize = tx3gmx_finalize,
+	SETCAPS(TX3G2TTMLCaps),
+	.configure_pid = tx3gmx_configure_pid,
+	.process = tx3gmx_process
+};
+
+
+const GF_FilterRegister *tx3g2ttml_register(GF_FilterSession *session)
+{
+	return &TX3G2TTMLRegister;
+}
+
+#else
+const GF_FilterRegister *ttxtuf_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+const GF_FilterRegister *tx3g2srt_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+const GF_FilterRegister *tx3g2vtt_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+const GF_FilterRegister *tx3g2ttml_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+#endif //#if !defined(GPAC_DISABLE_ISOM_DUMP) && !defined(GPAC_DISABLE_ISOM)
+
+

gpac-2.0.0.tar.gz/src/filters/write_vtt.c -> gpac-2.2.0.tar.gz/src/filters/write_vtt.c Changed

@@ -5,7 +5,7 @@
 *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
- * This file is part of GPAC / WebVTT stream to file filter
+ * This file is part of GPAC / WebVTT stream unframer filter
 *
 * GPAC is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
@@ -30,10 +30,12 @@
 #include <gpac/internal/media_dev.h>
 
 
+#ifndef GPAC_DISABLE_VTT
+
 typedef struct
 {
 	//opts
-	Bool exporter, merge;
+	Bool exporter, merge_cues;
 
 	//only one input pid declared
 	GF_FilterPid *ipid;
@@ -41,18 +43,16 @@
 	GF_FilterPid *opid;
 
 	u32 codecid;
-	Bool first;
+	u32 timescale;
 
 	GF_Fraction64 duration;
-	char *dcd;
 
-	GF_BitStream *bs_w;
 	u8 *cues_buffer;
 	u32 cues_buffer_size;
 
 	GF_WebVTTParser *parser;
 
-	Bool dash_mode;
+	GF_FilterPacket *src_pck;
 } GF_WebVTTMxCtx;
 
 static void vttmx_write_cue(void *ctx, GF_WebVTTCue *cue);
@@ -76,136 +76,104 @@
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
 	if (!p) return GF_NOT_SUPPORTED;
 	ctx->codecid = p->value.uint;
+	ctx->ipid = pid;
 
-	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
-	if (!p) return GF_NOT_SUPPORTED;
-	if (ctx->dcd && !strcmp(ctx->dcd, p->value.string)) return GF_OK;
-	if (ctx->dcd) gf_free(ctx->dcd);
 
-	if ((p->type==GF_PROP_DATA) || (p->type==GF_PROP_DATA_NO_COPY)) {
-		ctx->dcd = gf_malloc(p->value.data.size+1);
-		memcpy(ctx->dcd, p->value.data.ptr, p->value.data.size);
-		ctx->dcdp->value.data.size=0;
-	} else {
-		ctx->dcd = gf_strdup(p->value.string);
-	}
 	if (!ctx->opid) {
 		ctx->opid = gf_filter_pid_new(filter);
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_FILE) );
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("vtt") );
-		gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("text/vtt") );
-		ctx->first = GF_TRUE;
-
 		if (ctx->exporter) {
 			GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Exporting %s\n", gf_codecid_name(ctx->codecid)));
 		}
-
 	}
-	ctx->ipid = pid;
+	gf_filter_pid_copy_properties(ctx->opid, pid );
+	gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE) );
+
+	//dec config not ready
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
+	if (!p) return GF_OK;
+
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
-	if (p) ctx->duration = p->value.lfrac;
+	if (p && (p->value.lfrac.num>0)) ctx->duration = p->value.lfrac;
 
 	if (ctx->parser) gf_webvtt_parser_del(ctx->parser);
 	ctx->parser = NULL;
-	if (ctx->merge) {
+	if (ctx->merge_cues) {
 		ctx->parser = gf_webvtt_parser_new();
 		gf_webvtt_parser_cue_callback(ctx->parser, vttmx_write_cue, ctx);
 	}
 	gf_filter_pid_set_framing_mode(pid, GF_TRUE);
 
 	p = gf_filter_pid_get_property(pid, GF_PROP_PID_DASH_MODE);
-	ctx->dash_mode = (p && p->value.uint) ? GF_TRUE : GF_FALSE;
+
+	p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
+	ctx->timescale = p ? p->value.uint : 1000;
 
 	return GF_OK;
 }
 
-static void vttmx_timestamp_dump(GF_BitStream *bs, GF_WebVTTTimestamp *ts, Bool dump_hour, Bool write_srt)
-{
-	char szTS200;
-	szTS0 = 0;
-	if (dump_hour) {
-		sprintf(szTS, "%02u:", ts->hour);
-		gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
-	}
-	sprintf(szTS, "%02u:%02u%c%03u", ts->min, ts->sec, write_srt ? ',' : '.', ts->ms);
-	gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
-}
 
-void webvtt_write_cue(GF_BitStream *bs, GF_WebVTTCue *cue, Bool write_srt)
+void webvtt_write_cue(GF_WebVTTMxCtx *ctx, GF_WebVTTCue *cue, Bool write_srt)
 {
-	Bool write_hour = GF_FALSE;
+	u8 *output;
+	u32 size;
 	if (!cue) return;
-	if (!write_srt && cue->pre_text) {
-		gf_bs_write_data(bs, cue->pre_text, (u32) strlen(cue->pre_text));
-		gf_bs_write_data(bs, "\n\n", 2);
-	}
-	if (!write_srt && cue->id) {
-		u32 len = (u32) strlen(cue->id) ;
-		gf_bs_write_data(bs, cue->id, len);
-		if (len && (cue->idlen-1!='\n'))
-			gf_bs_write_data(bs, "\n", 1);
-	}
-
-	if (gf_opts_get_bool("core", "webvtt-hours")) write_hour = GF_TRUE;
-	else if (cue->start.hour || cue->end.hour) write_hour = GF_TRUE;
-	else if (write_srt) write_hour = GF_TRUE;
-
-	vttmx_timestamp_dump(bs, &cue->start, write_hour, write_srt);
-	gf_bs_write_data(bs, " --> ", 5);
-	vttmx_timestamp_dump(bs, &cue->end, write_hour, write_srt);
 
-	if (!write_srt && cue->settings) {
-		gf_bs_write_data(bs, " ", 1);
-		gf_bs_write_data(bs, cue->settings, (u32) strlen(cue->settings));
-	}
-	gf_bs_write_data(bs, "\n", 1);
-	if (cue->text)
-		gf_bs_write_data(bs, cue->text, (u32) strlen(cue->text));
-
-	if (!write_srt)
-		gf_bs_write_data(bs, "\n\n", 2);
-	else
-		gf_bs_write_data(bs, "\n", 1);
-
-	if (!write_srt && cue->post_text) {
-		gf_bs_write_data(bs, cue->post_text, (u32) strlen(cue->post_text));
-		gf_bs_write_data(bs, "\n\n", 2);
+	size = cue->text ? (u32) strlen(cue->text) : 0;
+
+	GF_FilterPacket *dst = gf_filter_pck_new_alloc(ctx->opid, size, &output);
+	if (!dst) return;
+	if (size) memcpy(output, cue->text, size);
+
+	gf_filter_pck_merge_properties(ctx->src_pck, dst);
+	u64 start = cue->start.hour*3600 + cue->start.min*60 + cue->start.sec;
+	start *= 1000;
+	start += cue->start.ms;
+	u64 end = cue->end.hour*3600 + cue->end.min*60 + cue->end.sec;
+	end *= 1000;
+	end += cue->end.ms;
+	start = gf_timestamp_rescale(start, 1000, ctx->timescale);
+	end = gf_timestamp_rescale(end, 1000, ctx->timescale);
+	//override both dts and cts as they can be different from input if cues are merged
+	gf_filter_pck_set_dts(dst, start);
+	gf_filter_pck_set_cts(dst, start);
+	gf_filter_pck_set_duration(dst, (u32) (end-start));
+
+	gf_filter_pck_set_property_str(dst, "vtt_pre", NULL);
+	gf_filter_pck_set_property_str(dst, "vtt_cueid", NULL);
+	gf_filter_pck_set_property_str(dst, "vtt_settings", NULL);
+
+	if (!write_srt) {
+		if (cue->pre_text) {
+			gf_filter_pck_set_property_str(dst, "vtt_pre", &PROP_STRING(cue->pre_text) );
+		}
+		if (cue->id) {
+			gf_filter_pck_set_property_str(dst, "vtt_cueid", &PROP_STRING(cue->id) );
+		}
+		if (cue->settings) {
+			gf_filter_pck_set_property_str(dst, "vtt_settings", &PROP_STRING(cue->settings) );
+		}
 	}
+
+	gf_filter_pck_set_sap(dst, GF_FILTER_SAP_1);
+	gf_filter_pck_set_byte_offset(dst, GF_FILTER_NO_BO);
+	gf_filter_pck_send(dst);
 }
 
 static void vttmx_write_cue(void *udta, GF_WebVTTCue *cue)
 {
 	GF_WebVTTMxCtx *ctx = (GF_WebVTTMxCtx *)udta;
-	webvtt_write_cue(ctx->bs_w, cue, GF_FALSE);
+	webvtt_write_cue(ctx, cue, GF_FALSE);
 }
 
 void vttmx_parser_flush(GF_WebVTTMxCtx *ctx)
 {
-	u8 *output;
-	u64 duration = ctx->duration.num;
-	duration *= 1000;
-	duration /= ctx->duration.den;
-
-	if (!ctx->bs_w) ctx->bs_w = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-	else gf_bs_reassign_buffer(ctx->bs_w, ctx->cues_buffer, ctx->cues_buffer_size);
-
-	gf_webvtt_parser_finalize(ctx->parser, duration);
-
-	if (gf_bs_get_position(ctx->bs_w)) {
-		GF_FilterPacket *dst_pck;
-		u32 size;
-		gf_bs_get_content_no_truncate(ctx->bs_w, &ctx->cues_buffer, &size, &ctx->cues_buffer_size);
-		dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output);
-		if (dst_pck) {
-			memcpy(output, ctx->cues_buffer, size);
-
-			gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
-
-			gf_filter_pck_set_framing(dst_pck, GF_FALSE, GF_TRUE);
-			gf_filter_pck_send(dst_pck);
-		}
+	u64 duration = 0;
+	if (ctx->duration.num && ctx->duration.den) {
+		duration = ctx->duration.num;
+		duration *= 1000;
+		duration /= ctx->duration.den;
 	}
-
+	gf_webvtt_parser_finalize(ctx->parser, duration);
 	gf_webvtt_parser_del(ctx->parser);
 	ctx->parser = NULL;
 
@@ -213,10 +181,10 @@
 GF_Err vttmx_process(GF_Filter *filter)
 {
 	GF_WebVTTMxCtx *ctx = gf_filter_get_udta(filter);
-	GF_FilterPacket *pck, *dst_pck;
-	u8 *data, *output;
+	GF_FilterPacket *pck;
+	u8 *data;
 	u64 start_ts, end_ts;
-	u32 i, pck_size, size, timescale;
+	u32 i, pck_size;
 	GF_List *cues;
 
 	pck = gf_filter_pid_get_packet(ctx->ipid);
@@ -226,44 +194,26 @@
 			if (ctx->parser) {
 				vttmx_parser_flush(ctx);
 			}
+			if (ctx->src_pck) {
+				gf_filter_pck_unref(ctx->src_pck);
+				ctx->src_pck = NULL;
+			}
 			return GF_EOS;
 		}
 		return GF_OK;
 	}
 
-	if (ctx->dash_mode && gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM)) {
-		ctx->first = GF_TRUE;
-	}
-
-
 	data = (char *) gf_filter_pck_get_data(pck, &pck_size);
 
-	if (ctx->first && ctx->dcd) {
-		size = (u32) strlen(ctx->dcd)+2;
-		dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output);
-		if (!dst_pck) return GF_OUT_OF_MEM;
-
-		memcpy(output, ctx->dcd, size-2);
-		outputsize-2 = '\n';
-		outputsize-1 = '\n';
-		gf_filter_pck_merge_properties(pck, dst_pck);
-		gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
-		gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE);
-		ctx->first = GF_FALSE;
-		gf_filter_pck_send(dst_pck);
-	}
-
-	if (!ctx->bs_w) ctx->bs_w = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-	else gf_bs_reassign_buffer(ctx->bs_w, ctx->cues_buffer, ctx->cues_buffer_size);
-
-	timescale = gf_filter_pck_get_timescale(pck);
-	if (!timescale) timescale=1000;
-
 	start_ts = gf_filter_pck_get_cts(pck);
 	end_ts = start_ts + gf_filter_pck_get_duration(pck);
 
-	start_ts = gf_timestamp_rescale(start_ts, timescale, 1000);
-	end_ts = gf_timestamp_rescale(end_ts, timescale, 1000);
+	start_ts = gf_timestamp_rescale(start_ts, ctx->timescale, 1000);
+	end_ts = gf_timestamp_rescale(end_ts, ctx->timescale, 1000);
+
+	if (ctx->src_pck) gf_filter_pck_unref(ctx->src_pck);
+	ctx->src_pck = pck;
+	gf_filter_pck_ref_props(&ctx->src_pck);
 
 	cues = gf_webvtt_parse_cues_from_data(data, pck_size, start_ts, end_ts);
 	if (ctx->parser) {
@@ -277,29 +227,9 @@
 	}
 	gf_list_del(cues);
 
-	gf_bs_get_content_no_truncate(ctx->bs_w, &ctx->cues_buffer, &size, &ctx->cues_buffer_size);
-	if (size) {
-		dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output);
-		if (!dst_pck) return GF_OUT_OF_MEM;
-
-		memcpy(output, ctx->cues_buffer, size);
-		gf_filter_pck_merge_properties(pck, dst_pck);
-		gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO);
-		if (ctx->dash_mode) {
-			gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENUM, NULL);
-			gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENAME, NULL);
-		}
-		
-		gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE);
-		ctx->first = GF_FALSE;
-
-		gf_filter_pck_send(dst_pck);
-	}
-
 	if (ctx->exporter) {
 		u64 ts = gf_filter_pck_get_cts(pck);
-		timescale = gf_filter_pck_get_timescale(pck);
-		gf_set_progress("Exporting", ts*ctx->duration.den, ctx->duration.num*timescale);
+		gf_set_progress("Exporting", ts*ctx->duration.den, ctx->duration.num * ctx->timescale);
 	}
 
 	gf_filter_pid_drop_packet(ctx->ipid);
@@ -310,21 +240,23 @@
 static void vttmx_finalize(GF_Filter *filter)
 {
 	GF_WebVTTMxCtx *ctx = gf_filter_get_udta(filter);
-	if (ctx->bs_w) gf_bs_del(ctx->bs_w);
-	if (ctx->dcd) gf_free(ctx->dcd);
 	if (ctx->cues_buffer) gf_free(ctx->cues_buffer);
 
 	if (ctx->parser) gf_webvtt_parser_del(ctx->parser);
+
+	if (ctx->src_pck) {
+		gf_filter_pck_unref(ctx->src_pck);
+		ctx->src_pck = NULL;
+	}
+
 }
 
 static const GF_FilterCapability WebVTTMxCaps =
 {
-	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
-	CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT),
+	CAP_UINT(GF_CAPS_INPUT_OUTPUT,GF_PROP_PID_CODECID, GF_CODECID_WEBVTT),
 	CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
-	CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "vtt"),
-	CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "subtitle/vtt|text/vtt"),
+	CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE),
 };
 
 
@@ -332,15 +264,15 @@
 static const GF_FilterArgs WebVTTMxArgs =
 {
 	{ OFFS(exporter), "compatibility with old exporter, displays export results", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
-	{ OFFS(merge), "merge VTT cue if needed", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
+	{ OFFS(merge_cues), "merge VTT cues (undo ISOBMFF cue split)", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_ADVANCED},
 	{0}
 };
 
 
 GF_FilterRegister WebVTTMxRegister = {
-	.name = "writevtt",
-	GF_FS_SET_DESCRIPTION("WebVTT writer")
-	GF_FS_SET_HELP("This filter converts a single ISOBMFF WebVTT stream to a WebVTT output file.")
+	.name = "ufvtt",
+	GF_FS_SET_DESCRIPTION("WebVTT unframer")
+	GF_FS_SET_HELP("This filter converts a single ISOBMFF WebVTT stream to its unframed format.")
 	.private_size = sizeof(GF_WebVTTMxCtx),
 	.args = WebVTTMxArgs,
 	.finalize = vttmx_finalize,
@@ -354,3 +286,10 @@
 {
 	return &WebVTTMxRegister;
 }
+#else
+const GF_FilterRegister *vttmx_register(GF_FilterSession *session)
+{
+	return NULL;
+}
+
+#endif /*GPAC_DISABLE_VTT*/

gpac-2.0.0.tar.gz/src/ietf/rtcp.c -> gpac-2.2.0.tar.gz/src/ietf/rtcp.c Changed

@@ -141,8 +141,8 @@
 
 			ch->first_SR = 0;
 
-			//common encoding for SR and RR
-			goto process_reports;
+			//common encoding for SR and RR, for now we don't process reports on SR
+			break;
 
 
 		case 201:
@@ -150,31 +150,31 @@
 			/*sender_ssrc = */gf_bs_read_u32(ch->bs_r);
 			rtcp_hdr.Length -= 1;
 
-process_reports:
-
-#if 0
-			//process all reports - we actually don't since we do not handle sources
-			//to add
+			ch->nb_rctp_rr=0;
+			//process all reports
 			for (i=0; i<rtcp_hdr.Count; i++) {
-				//ssrc slot
-				cur_ssrc = gf_bs_read_u32(ch->bs_r);
+				if (i>=MAX_RTCP_RR) break;
+
+				GF_RTCP_Report *rr = &ch->rtcp_rri;
+				ch->nb_rctp_rr++;
+				//ssrc
+				rr->ssrc = gf_bs_read_u32(ch->bs_r);
 				//frac lost
-				gf_bs_read_u8(ch->bs_r);
+				rr->frac_lost = gf_bs_read_u8(ch->bs_r);
 				//cumulative lost
-				gf_bs_read_u24(ch->bs_r);
+				rr->total_loss = gf_bs_read_u24(ch->bs_r);
 				//extended seq num
-				gf_bs_read_u32(ch->bs_r);
+				rr->last_rtp_sn = gf_bs_read_u32(ch->bs_r);
 				//jitter
-				gf_bs_read_u32(ch->bs_r);
+				rr->jitter = gf_bs_read_u32(ch->bs_r);
 				//LSR
-				gf_bs_read_u32(ch->bs_r);
+				rr->last_sr = gf_bs_read_u32(ch->bs_r);
 				//DLSR
-				gf_bs_read_u32(ch->bs_r);
+				rr->delay_last_sr = gf_bs_read_u32(ch->bs_r);
 
 				rtcp_hdr.Length -= 6;
 			}
 			//remaining bytes? we skip (this includes padding and crypto - not supported)
-#endif
 			break;
 
 		//SDES
@@ -312,7 +312,6 @@
 		//num payload bytes sent
 		gf_bs_write_u32(bs, ch->num_payload_bytes);
 
-
 		size += 20;
 		//nota: as we only support single-way channels we are done for SR...
 		return size;
@@ -329,6 +328,10 @@
 	if (!expect_diff || (loss_diff <= 0)) loss_diff = 0;
 	else loss_diff = (loss_diff<<8) / expect_diff;
 
+	if (ch->force_loss_rate) {
+		loss_diff = ch->force_loss_rate-1;
+		ch->force_loss_rate = 0;
+	}
 	gf_bs_write_u8(bs, loss_diff);
 
 	//update and write cumulative loss
@@ -487,6 +490,14 @@
 }
 
 GF_EXPORT
+void gf_rtp_set_loss_rate(GF_RTPChannel *ch, u32 loss_rate)
+{
+	if (!ch) return;
+	if (loss_rate>1000) ch->force_loss_rate = 256;
+	else ch->force_loss_rate = 1 + (loss_rate*255)/1000;
+}
+
+GF_EXPORT
 GF_Err gf_rtp_send_rtcp_report(GF_RTPChannel *ch)
 {
 	u32 Time, report_size;
@@ -499,7 +510,6 @@
 	if (!ch->forced_ntp_sec && ch->first_SR) return GF_OK;
 	Time = gf_rtp_get_report_time();
 	if ( Time < ch->next_report_time) return GF_OK;
-
 	bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 
 	//pck were received/sent send the RR/SR

gpac-2.0.0.tar.gz/src/ietf/rtp.c -> gpac-2.2.0.tar.gz/src/ietf/rtp.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / IETF RTP/RTSP/SDP sub-project
@@ -147,7 +147,12 @@
 GF_Err gf_rtp_set_info_rtp(GF_RTPChannel *ch, u32 seq_num, u32 rtp_time, u32 ssrc)
 {
 	if (!ch) return GF_BAD_PARAM;
-	ch->CurrentTime = ch->rtp_time = seq_num ? (1 + rtp_time) : 0;
+	if (seq_num) {
+		ch->CurrentTime = rtp_time;
+		ch->rtp_time = 1 + rtp_time;
+	} else {
+		ch->CurrentTime = ch->rtp_time = 0;
+	}
 	ch->last_pck_sn = 0;
 	ch->rtp_first_SN = seq_num;
 	ch->num_sn_loops = 0;
@@ -173,6 +178,17 @@
 }
 
 GF_EXPORT
+GF_Err gf_rtp_set_ssm(GF_RTPChannel *ch, const char **src_ip_inc, u32 nb_src_ip_inc, const char **src_ip_exc, u32 nb_src_ip_exc)
+{
+	if (!ch) return GF_BAD_PARAM;
+	ch->ssm = src_ip_inc;
+	ch->nb_ssm = nb_src_ip_inc;
+	ch->ssmx = src_ip_exc;
+	ch->nb_ssmx = nb_src_ip_exc;
+	return GF_OK;
+}
+
+GF_EXPORT
 GF_Err gf_rtp_initialize(GF_RTPChannel *ch, u32 UDPBufferSize, Bool IsSource, u32 PathMTU, u32 ReorederingSize, u32 MaxReorderDelay, char *local_ip)
 {
 	u16 port;
@@ -238,7 +254,11 @@
 			//Bind to multicast (auto-join the group).
 			//we do not bind the socket if this is a source-only channel because some servers
 			//don't like that on local loop ...
-			e = gf_sk_setup_multicast(ch->rtp, ch->net_info.source, ch->net_info.port_first, ch->net_info.TTL, GF_FALSE, local_ip);
+			if (!IsSource && (ch->nb_ssm || ch->nb_ssmx)) {
+				e = gf_sk_setup_multicast_ex(ch->rtp, ch->net_info.source, ch->net_info.port_first, ch->net_info.TTL, GF_FALSE, local_ip, ch->ssm, ch->nb_ssm, ch->ssmx, ch->nb_ssmx);
+			} else {
+				e = gf_sk_setup_multicast(ch->rtp, ch->net_info.source, ch->net_info.port_first, ch->net_info.TTL, GF_FALSE, local_ip);
+			}
 			if (e) return e;
 		}
 		if (UDPBufferSize) gf_sk_set_buffer_size(ch->rtp, IsSource, UDPBufferSize);
@@ -270,7 +290,11 @@
 		} else {
 			if (!ch->net_info.port_last) ch->net_info.port_last = ch->net_info.client_port_last;
 			//Bind to multicast (auto-join the group)
-			e = gf_sk_setup_multicast(ch->rtcp, ch->net_info.source, ch->net_info.port_last, ch->net_info.TTL, GF_FALSE, local_ip);
+			if (!IsSource && (ch->nb_ssm || ch->nb_ssmx)) {
+				e = gf_sk_setup_multicast_ex(ch->rtcp, ch->net_info.source, ch->net_info.port_last, ch->net_info.TTL, GF_FALSE, local_ip, ch->ssm, ch->nb_ssm, ch->ssmx, ch->nb_ssmx);
+			} else {
+				e = gf_sk_setup_multicast(ch->rtcp, ch->net_info.source, ch->net_info.port_last, ch->net_info.TTL, GF_FALSE, local_ip);
+			}
 			if (e) return e;
 		}
 	}

gpac-2.0.0.tar.gz/src/ietf/rtp_depacketizer.c -> gpac-2.2.0.tar.gz/src/ietf/rtp_depacketizer.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2020
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / RTP input module
@@ -1124,7 +1124,7 @@
 
 #ifndef GPAC_DISABLE_AV_PARSERS
 
-static void gf_rtp_parse_ac3(GF_RTPDepacketizer *rtp, GF_RTPHeader *hdr, u8 *payload, u32 size)
+static void gf_rtp_parse_ac3_eac3(GF_RTPDepacketizer *rtp, GF_RTPHeader *hdr, u8 *payload, u32 size, Bool is_eac3)
 {
 	u8 ft;
 
@@ -1142,14 +1142,25 @@
 		rtp->sl_hdr.accessUnitStartFlag = rtp->sl_hdr.accessUnitEndFlag = 1;
 		while (size) {
 			u32 offset;
-			if (!gf_ac3_parser((u8*)payload, size, &offset, &ac3hdr, GF_FALSE)) {
-				return;
+			if (is_eac3) {
+				if (!gf_eac3_parser((u8*)payload, size, &offset, &ac3hdr, GF_FALSE)) {
+					return;
+				}
+			} else {
+				if (!gf_ac3_parser((u8*)payload, size, &offset, &ac3hdr, GF_FALSE)) {
+					return;
+				}
 			}
 			if (offset) {
 				if (offset>size) return;
 				payload+=offset;
 				size-=offset;
 			}
+			if (!rtp->sl_map.config) {
+				ac3hdr.is_ec3 = is_eac3;
+				gf_odf_ac3_cfg_write(&ac3hdr, &rtp->sl_map.config, &rtp->sl_map.configSize);
+				rtp->sl_map.config_updated = 1;
+			}
 			rtp->on_sl_packet(rtp->udta, payload, ac3hdr.framesize, &rtp->sl_hdr, GF_OK);
 			if (size < ac3hdr.framesize) return;
 			size -= ac3hdr.framesize;
@@ -1167,6 +1178,29 @@
 		rtp->on_sl_packet(rtp->udta, payload, size, &rtp->sl_hdr, GF_OK);
 	}
 }
+static void gf_rtp_parse_ac3(GF_RTPDepacketizer *rtp, GF_RTPHeader *hdr, u8 *payload, u32 size)
+{
+	gf_rtp_parse_ac3_eac3(rtp, hdr, payload, size, GF_FALSE);
+}
+static void gf_rtp_parse_eac3(GF_RTPDepacketizer *rtp, GF_RTPHeader *hdr, u8 *payload, u32 size)
+{
+	gf_rtp_parse_ac3_eac3(rtp, hdr, payload, size, GF_TRUE);
+}
+
+
+static void gf_rtp_parse_opus(GF_RTPDepacketizer *rtp, GF_RTPHeader *hdr, u8 *payload, u32 size)
+{
+	rtp->sl_hdr.compositionTimeStampFlag = 1;
+	if (rtp->sl_hdr.compositionTimeStamp != hdr->TimeStamp) {
+		rtp->sl_hdr.accessUnitStartFlag = 1;
+		rtp->sl_hdr.compositionTimeStamp = hdr->TimeStamp;
+	}
+	rtp->sl_hdr.randomAccessPointFlag = 1;
+	rtp->on_sl_packet(rtp->udta, payload, size, &rtp->sl_hdr, GF_OK);
+	rtp->flags |= GF_RTP_NEW_AU;
+	rtp->sl_hdr.accessUnitStartFlag = 0;
+}
+
 #endif /*GPAC_DISABLE_AV_PARSERS*/
 
 static u32 gf_rtp_get_payload_type(GF_RTPMap *map, GF_SDPMedia *media)
@@ -1209,10 +1243,13 @@
 	else if (!stricmp(map->payload_name, "richmedia+xml")) return GF_RTP_PAYT_3GPP_DIMS;
 #endif
 	else if (!stricmp(map->payload_name, "ac3")) return GF_RTP_PAYT_AC3;
+	else if (!stricmp(map->payload_name, "eac3")) return GF_RTP_PAYT_EAC3;
 	else if (!stricmp(map->payload_name, "H264-SVC")) return GF_RTP_PAYT_H264_SVC;
 	else if (!stricmp(map->payload_name, "H265")) return GF_RTP_PAYT_HEVC;
 	else if (!stricmp(map->payload_name, "H265-SHVC")) return GF_RTP_PAYT_LHVC;
 	else if (!stricmp(map->payload_name, "H266")) return GF_RTP_PAYT_VVC;
+	else if (!stricmp(map->payload_name, "opus")) return GF_RTP_PAYT_OPUS;
+	else if (!stricmp(map->payload_name, "QCELP")) return GF_RTP_PAYT_QCELP;
 	else return 0;
 }
 
@@ -1813,6 +1850,32 @@
 		/*assign depacketizer*/
 		rtp->depacketize = gf_rtp_parse_ac3;
 		break;
+	case GF_RTP_PAYT_EAC3:
+		rtp->sl_map.StreamType = GF_STREAM_AUDIO;
+		rtp->sl_map.CodecID = GF_CODECID_EAC3;
+		rtp->sl_map.RandomAccessIndication = GF_TRUE;
+		/*assign depacketizer*/
+		rtp->depacketize = gf_rtp_parse_eac3;
+		break;
+	case GF_RTP_PAYT_OPUS:
+		rtp->sl_map.StreamType = GF_STREAM_AUDIO;
+		rtp->sl_map.CodecID = GF_CODECID_OPUS;
+		rtp->sl_map.RandomAccessIndication = GF_TRUE;
+		/*assign depacketizer*/
+		rtp->depacketize = gf_rtp_parse_opus;
+
+		if (!rtp->sl_map.config) {
+			GF_OpusConfig opcfg;
+			opcfg.version = 1;
+			opcfg.OutputChannelCount = rtp->audio_channels;
+			opcfg.PreSkip = 0;
+			opcfg.InputSampleRate = rtp->clock_rate;
+			opcfg.OutputGain = 0;
+			opcfg.ChannelMappingFamily = 0;
+			gf_odf_opus_cfg_write(&opcfg, &rtp->sl_map.config, &rtp->sl_map.configSize);
+		}
+
+		break;
 #endif /*GPAC_DISABLE_AV_PARSERS*/
 	default:
 		if (rtp->payt >= GF_RTP_PAYT_LAST_STATIC_DEFINED)
@@ -1871,7 +1934,7 @@
 	GF_RTPMap *map = NULL;
 	u32 payt;
 	GF_RTPDepacketizer *tmp;
-	u32 clock_rate;
+	u32 clock_rate, nb_chan=0;
 	const GF_RTPStaticMap *static_map = NULL;
 
 	/*check RTP map. For now we only support 1 RTPMap*/
@@ -1890,6 +1953,8 @@
 			return NULL;
 		}
 		clock_rate = static_map->clock_rate;
+		if (static_map->stream_type==GF_STREAM_AUDIO)
+			nb_chan = 1;
 		payt = hdr_payt;
 	} else {
 		/*check payload type*/
@@ -1905,10 +1970,13 @@
 				return NULL;
 			}
 			clock_rate = static_map->clock_rate;
+			if (static_map->stream_type==GF_STREAM_AUDIO)
+				nb_chan = 1;
 		} else {
 			payt = gf_rtp_get_payload_type(map, media);
 			if (!payt) return NULL;
 			clock_rate = map->ClockRate;
+			nb_chan = map->AudioChannels;
 		}
 	}
 
@@ -1916,6 +1984,8 @@
 	if (!tmp) return NULL;
 	tmp->payt = payt;
 	tmp->static_map = static_map;
+	tmp->clock_rate = clock_rate;
+	tmp->audio_channels = nb_chan;
 
 	e = gf_rtp_payt_setup(tmp, map, media);
 	if (e) {
@@ -1924,7 +1994,6 @@
 	}
 
 	assert(tmp->depacketize);
-	tmp->clock_rate = clock_rate;
 	tmp->on_sl_packet = sl_packet_cbk;
 	tmp->udta = udta;
 	return tmp;

gpac-2.0.0.tar.gz/src/ietf/rtp_packetizer.c -> gpac-2.2.0.tar.gz/src/ietf/rtp_packetizer.c Changed

@@ -118,6 +118,7 @@
 		return gp_rtp_builder_do_dims(builder, data, data_size, IsAUEnd, FullAUSize, duration);
 #endif
 	case GF_RTP_PAYT_AC3:
+	case GF_RTP_PAYT_EAC3:
 		return gp_rtp_builder_do_ac3(builder, data, data_size, IsAUEnd, FullAUSize);
 	case GF_RTP_PAYT_HEVC:
 	case GF_RTP_PAYT_LHVC:
@@ -126,6 +127,8 @@
 		return gp_rtp_builder_do_vvc(builder, data, data_size, IsAUEnd, FullAUSize);
 	case GF_RTP_PAYT_MP2T:
 		return gp_rtp_builder_do_mp2t(builder, data, data_size, IsAUEnd, FullAUSize);
+	case GF_RTP_PAYT_OPUS:
+		return gp_rtp_builder_do_opus(builder, data, data_size, IsAUEnd, FullAUSize);
 	default:
 		return GF_NOT_SUPPORTED;
 	}
@@ -537,6 +540,14 @@
 		strcpy(szMediaName, "audio");
 		strcpy(szPayloadName, "ac3");
 		return GF_TRUE;
+	case GF_RTP_PAYT_EAC3:
+		strcpy(szMediaName, "audio");
+		strcpy(szPayloadName, "eac3");
+		return GF_TRUE;
+	case GF_RTP_PAYT_OPUS:
+		strcpy(szMediaName, "audio");
+		strcpy(szPayloadName, "opus");
+		return GF_TRUE;
 	case GF_RTP_PAYT_H264_SVC:
 		strcpy(szMediaName, "video");
 		strcpy(szPayloadName, "H264-SVC");
@@ -568,13 +579,27 @@
 	char buffer20100, dsiString20000;
 	u32 i, k;
 	Bool is_first = GF_TRUE;
+	char *sdp = NULL;
+	GF_Err e = GF_OK;
 
 	if ((builder->rtp_payt!=GF_RTP_PAYT_MPEG4) && (builder->rtp_payt!=GF_RTP_PAYT_LATM) ) return GF_BAD_PARAM;
 
-#define SDP_ADD_INT(_name, _val) { if (!is_first) strcat(sdpLine, "; "); sprintf(buffer, "%s=%d", _name, _val); strcat(sdpLine, buffer); is_first = 0;}
-#define SDP_ADD_STR(_name, _val) { if (!is_first) strcat(sdpLine, "; "); sprintf(buffer, "%s=%s", _name, _val); strcat(sdpLine, buffer); is_first = 0;}
+#define SDP_ADD_INT(_name, _val) {\
+		if (!is_first) gf_dynstrcat(&sdp, "; ", NULL); \
+		sprintf(buffer, "%s=%d", _name, _val);\
+		gf_dynstrcat(&sdp, buffer, NULL);\
+		is_first = 0;\
+	}
+
+#define SDP_ADD_STR(_name, _val) {\
+		if (!is_first) gf_dynstrcat(&sdp, "; ", NULL);\
+		sprintf(buffer, "%s=%s", _name, _val);\
+		gf_dynstrcat(&sdp, buffer, NULL);\
+		is_first = 0;\
+	}
 
-	sprintf(sdpLine, "a=fmtp:%d ", builder->PayloadType);
+	sprintf(buffer, "a=fmtp:%d ", builder->PayloadType);
+	gf_dynstrcat(&sdp, buffer, NULL);
 
 	/*mandatory fields*/
 	if (builder->slMap.PL_ID) SDP_ADD_INT("profile-level-id", builder->slMap.PL_ID);
@@ -583,6 +608,10 @@
 
 	if (dsi && dsi_size) {
 		k = 0;
+		if (dsi_size>10000) {
+			e = GF_OUT_OF_MEM;
+			goto exit;
+		}
 		for (i=0; i<dsi_size; i++) {
 			sprintf(&dsiStringk, "%02x", (unsigned char) dsii);
 			k+=2;
@@ -590,7 +619,10 @@
 		dsiStringk = 0;
 		SDP_ADD_STR("config", dsiString);
 	}
-	if (!strcmp(payload_name, "MP4V-ES") || (builder->rtp_payt == GF_RTP_PAYT_LATM) ) return GF_OK;
+	if (!strcmp(payload_name, "MP4V-ES") || (builder->rtp_payt == GF_RTP_PAYT_LATM) ) {
+		e = GF_OK;
+		goto exit;
+	}
 
 	SDP_ADD_INT("streamType", builder->slMap.StreamType);
 	if (strcmp(builder->slMap.mode, "") && strcmp(builder->slMap.mode, "default")) {
@@ -624,7 +656,20 @@
 		if (builder->slMap.KI_length) SDP_ADD_INT("ISMACrypKeyIndicatorLength", builder->slMap.KI_length);
 		if (builder->flags & GP_RTP_PCK_KEY_IDX_PER_AU) SDP_ADD_INT("ISMACrypKeyIndicatorPerAU", 1);
 	}
-	return GF_OK;
+
+exit:
+	sdpLine0 = 0;
+	if (sdp) {
+		k = (u32) strlen(sdp);
+		if (k<20000)
+			strcpy(sdpLine, sdp);
+		else
+			e = GF_OUT_OF_MEM;
+		gf_free(sdp);
+	} else {
+		e = GF_OUT_OF_MEM;
+	}
+	return e;
 }
 
 #endif /*GPAC_DISABLE_STREAMING*/

gpac-2.0.0.tar.gz/src/ietf/rtp_pck_3gpp.c -> gpac-2.2.0.tar.gz/src/ietf/rtp_pck_3gpp.c Changed

@@ -817,5 +817,32 @@
 	return GF_OK;
 }
 
+GF_Err gp_rtp_builder_do_opus(GP_RTPPacketizer *builder, u8 *data, u32 data_size, u8 IsAUEnd, u32 FullAUSize)
+{
+	/*flush*/
+	if (!data) return GF_OK;
+
+	/*fits*/
+	if (data_size > builder->Path_MTU) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTPOpus Packet size %u larger MTU %u but Opus fragmentation is not yet supported, pacth welcome\n", data_size, builder->Path_MTU ));
+		return GF_NOT_SUPPORTED;
+	}
+	/*send new packet*/
+	builder->rtp_header.TimeStamp = (u32) builder->sl_header.compositionTimeStamp;
+	builder->rtp_header.Marker = 0;
+	builder->rtp_header.SequenceNumber += 1;
+	builder->OnNewPacket(builder->cbk_obj, &builder->rtp_header);
+
+	/*add payload*/
+	if (builder->OnDataReference)
+		builder->OnDataReference(builder->cbk_obj, data_size, 0);
+	else
+		builder->OnData(builder->cbk_obj, data, data_size, GF_FALSE);
+
+	builder->OnPacketDone(builder->cbk_obj, &builder->rtp_header);
+	builder->last_au_sn++;
+	return GF_OK;
+}
+
 #endif /*GPAC_DISABLE_STREAMING*/

gpac-2.0.0.tar.gz/src/ietf/rtp_pck_mpeg4.c -> gpac-2.2.0.tar.gz/src/ietf/rtp_pck_mpeg4.c Changed

gpac-2.0.0.tar.gz/src/ietf/rtp_streamer.c -> gpac-2.2.0.tar.gz/src/ietf/rtp_streamer.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2020
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / IETF RTP/RTSP/SDP sub-project
@@ -37,6 +37,7 @@
 /*for ISOBMFF subtypes*/
 #include <gpac/isomedia.h>
 
+#define RTCP_BUF_SIZE	10000
 struct __rtp_streamer
 {
 	GP_RTPPacketizer *packetizer;
@@ -46,7 +47,10 @@
 	char *buffer;
 	u32 payload_len, buffer_alloc;
 
-	Double ts_scale;
+	u32 in_timescale;
+	char rtcp_bufRTCP_BUF_SIZE;
+
+	GF_Err last_err;
 };
 
 
@@ -63,6 +67,7 @@
 
 #ifndef GPAC_DISABLE_LOG
 	if (e) {
+		rtp->last_err = e;
 		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTP Error %s sending RTP packet SN %u - TS %u\n", gf_error_to_string(e), header->SequenceNumber, header->TimeStamp));
 	} else {
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("RTP SN %u - TS %u - M %u - Size %u\n", header->SequenceNumber, header->TimeStamp, header->Marker, rtp->payload_len + 12));
@@ -99,8 +104,11 @@
 {
 	GF_Err res;
 
-	if (!rtp->channel) rtp->channel = gf_rtp_new();
-
+	if (!rtp->channel) {
+		rtp->channel = gf_rtp_new();
+		if (!rtp->channel) return GF_OUT_OF_MEM;
+		rtp->channel->TimeScale = rtp->packetizer->sl_config.timestampResolution;
+	}
 	res = gf_rtp_setup_transport(rtp->channel, tr, tr->destination);
 	if (res !=0) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("Cannot setup RTP transport info: %s\n", gf_error_to_string(res) ));
@@ -120,6 +128,9 @@
 	GF_Err res;
 
 	rtp->channel = gf_rtp_new();
+	if (!rtp->channel) return GF_OUT_OF_MEM;
+	rtp->channel->TimeScale = rtp->packetizer->sl_config.timestampResolution;
+
 	gf_rtp_set_ports(rtp->channel, 0);
 	memset(&tr, 0, sizeof(GF_RTSPTransport));
 
@@ -364,6 +375,11 @@
 		streamType = GF_STREAM_AUDIO;
 		has_mpeg4_mapping = GF_TRUE;
 		break;
+	case GF_CODECID_EAC3:
+		rtp_type = GF_RTP_PAYT_EAC3;
+		streamType = GF_STREAM_AUDIO;
+		has_mpeg4_mapping = GF_FALSE;
+		break;
 
 	case GF_CODECID_QCELP:
 		required_rate = 8000;
@@ -396,6 +412,11 @@
 		PayloadType = OfficialPayloadType = GF_RTP_PAYT_MP2T;
 		required_rate = 90000;
 		break;
+	case GF_CODECID_OPUS:
+		rtp_type = GF_RTP_PAYT_OPUS;
+		streamType = GF_STREAM_AUDIO;
+		has_mpeg4_mapping = GF_FALSE;
+		break;
 
 	default:
 		if (!rtp_type) {
@@ -478,8 +499,7 @@
 		}
 	}
 
-	stream->ts_scale = slc.timestampResolution;
-	stream->ts_scale /= timeScale;
+	stream->in_timescale = timeScale;
 
 	stream->buffer_alloc = MTU+12;
 	stream->buffer = (char*)gf_malloc(sizeof(char) * stream->buffer_alloc);
@@ -522,7 +542,7 @@
 
 
 GF_EXPORT
-GF_Err gf_rtp_streamer_append_sdp_extended(GF_RTPStreamer *rtp, u16 ESID, const u8 *dsi, u32 dsi_len, const u8 *dsi_enh, u32 dsi_enh_len, char *KMS_URI, u32 width, u32 height, u32 tw, u32 th, s32 tx, s32 ty, s16 tl, Bool for_rtsp, char **out_sdp_buffer)
+GF_Err gf_rtp_streamer_append_sdp_extended(GF_RTPStreamer *rtp, u16 ESID, const u8 *dsi, u32 dsi_len, const u8 *dsi_enh, u32 dsi_enh_len, char *KMS_URI, u32 width, u32 height, u32 tw, u32 th, s32 tx, s32 ty, s16 tl, u32 nb_channels, Bool for_rtsp, char **out_sdp_buffer)
 {
 	u32 size;
 	u16 port=0;
@@ -532,17 +552,24 @@
 	if (!out_sdp_buffer) return GF_BAD_PARAM;
 
 	gf_rtp_builder_get_payload_name(rtp->packetizer, payloadName, mediaName);
-	if (!for_rtsp)
+	if (!for_rtsp) {
+		//this can happen when forwarding a multicast SDP from RTSP, where only a subset of streams have been setup
+		if (!rtp->channel) return GF_OK;
 		gf_rtp_get_ports(rtp->channel, &port, NULL);
+	}
 
-	sprintf(sdp, "m=%s %d RTP/%s %d\n", mediaName, for_rtsp ? 0 : port, rtp->packetizer->slMap.IV_length ? "SAVP" : "AVP", rtp->packetizer->PayloadType);
-	sprintf(sdpLine, "a=rtpmap:%d %s/%d\n", rtp->packetizer->PayloadType, payloadName, rtp->packetizer->sl_config.timestampResolution);
+	sprintf(sdp, "m=%s %d RTP/%s %u\n", mediaName, for_rtsp ? 0 : port, rtp->packetizer->slMap.IV_length ? "SAVP" : "AVP", rtp->packetizer->PayloadType);
+	if (nb_channels > 1)
+		sprintf(sdpLine, "a=rtpmap:%u %s/%u/%u\n", rtp->packetizer->PayloadType, payloadName, rtp->packetizer->sl_config.timestampResolution, nb_channels);
+	else
+		sprintf(sdpLine, "a=rtpmap:%u %s/%u\n", rtp->packetizer->PayloadType, payloadName, rtp->packetizer->sl_config.timestampResolution);
 	strcat(sdp, sdpLine);
 
 	if (ESID
 #if GPAC_ENABLE_3GPP_DIMS_RTP
 		&& (rtp->packetizer->rtp_payt != GF_RTP_PAYT_3GPP_DIMS)
 #endif
+		&& (rtp->packetizer->rtp_payt != GF_RTP_PAYT_OPUS)
 	 ) {
 		sprintf(sdpLine, "a=mpeg4-esid:%d\n", ESID);
 		strcat(sdp, sdpLine);
@@ -761,22 +788,28 @@
 GF_EXPORT
 GF_Err gf_rtp_streamer_append_sdp(GF_RTPStreamer *rtp, u16 ESID, const u8 *dsi, u32 dsi_len, char *KMS_URI, char **out_sdp_buffer)
 {
-	return gf_rtp_streamer_append_sdp_extended(rtp, ESID, dsi, dsi_len, NULL, 0, KMS_URI, 0, 0, 0, 0, 0, 0, 0, GF_FALSE, out_sdp_buffer);
+	return gf_rtp_streamer_append_sdp_extended(rtp, ESID, dsi, dsi_len, NULL, 0, KMS_URI, 0, 0, 0, 0, 0, 0, 0, 0, GF_FALSE, out_sdp_buffer);
 }
 
 GF_EXPORT
 GF_Err gf_rtp_streamer_send_data(GF_RTPStreamer *rtp, u8 *data, u32 size, u32 fullsize, u64 cts, u64 dts, Bool is_rap, Bool au_start, Bool au_end, u32 au_sn, u32 sampleDuration, u32 sampleDescIndex)
 {
-	rtp->packetizer->sl_header.compositionTimeStamp = (u64) (cts*rtp->ts_scale);
-	rtp->packetizer->sl_header.decodingTimeStamp = (u64) (dts*rtp->ts_scale);
+	GF_Err e;
+	if (!rtp->channel) return data ? GF_BAD_PARAM : GF_EOS;
+
+	rtp->packetizer->sl_header.compositionTimeStamp = gf_timestamp_rescale(cts, rtp->in_timescale, rtp->channel->TimeScale);
+	rtp->packetizer->sl_header.decodingTimeStamp = gf_timestamp_rescale(dts, rtp->in_timescale, rtp->channel->TimeScale);
 	rtp->packetizer->sl_header.randomAccessPointFlag = is_rap;
 	rtp->packetizer->sl_header.accessUnitStartFlag = au_start;
 	rtp->packetizer->sl_header.accessUnitEndFlag = au_end;
 	rtp->packetizer->sl_header.AU_sequenceNumber = au_sn;
-	sampleDuration = (u32) (sampleDuration * rtp->ts_scale);
+	sampleDuration = (u32) gf_timestamp_rescale(sampleDuration, rtp->in_timescale, rtp->channel->TimeScale);
 	if (au_start && size) rtp->packetizer->nb_aus++;
 
-	return gf_rtp_builder_process(rtp->packetizer, data, size, (u8) au_end, fullsize, sampleDuration, sampleDescIndex);
+	rtp->last_err = GF_OK;
+	e = gf_rtp_builder_process(rtp->packetizer, data, size, (u8) au_end, fullsize, sampleDuration, sampleDescIndex);
+	if (e) return e;
+	return rtp->last_err;
 }
 
 GF_EXPORT
@@ -802,16 +835,34 @@
 GF_Err gf_rtp_streamer_send_rtcp(GF_RTPStreamer *streamer, Bool force_ts, u32 rtp_ts, u32 force_ntp_type, u32 ntp_sec, u32 ntp_frac)
 {
 	if (force_ts) streamer->channel->last_pck_ts = rtp_ts;
-	streamer->channel->forced_ntp_sec = force_ntp_type ? ntp_sec : 0;
-	streamer->channel->forced_ntp_frac = force_ntp_type ? ntp_frac : 0;
-	if (force_ntp_type==2)
-		streamer->channel->next_report_time = 0;
-	return gf_rtp_send_rtcp_report(streamer->channel);
+	if (force_ntp_type) {
+		streamer->channel->forced_ntp_sec = ntp_sec;
+		streamer->channel->forced_ntp_frac = ntp_frac;
+		if (force_ntp_type==2) {
+			streamer->channel->next_report_time = 0;
+		}
+		//we are sendind RTCP before first packet was sent, set sent time to same values
+		if (!streamer->channel->last_pck_ntp_sec) {
+			streamer->channel->last_pck_ntp_sec = ntp_sec;
+			streamer->channel->last_pck_ntp_frac = ntp_frac;
+		}
+	} else {
+		streamer->channel->forced_ntp_sec = 0;
+		streamer->channel->forced_ntp_frac = 0;
+	}
+
+	GF_Err e = gf_rtp_send_rtcp_report(streamer->channel);
+	if (force_ntp_type) {
+		streamer->channel->forced_ntp_sec = 0;
+		streamer->channel->forced_ntp_frac = 0;
+	}
+	return e;
 }
 
 GF_EXPORT
 GF_Err gf_rtp_streamer_send_bye(GF_RTPStreamer *streamer)
 {
+	if (!streamer->channel) return GF_OK;
 	return gf_rtp_send_bye(streamer->channel);
 }
 
@@ -834,5 +885,49 @@
 	return gf_rtp_set_interleave_callbacks(streamer->channel, RTP_TCPCallback, cbk1, cbk2);
 }
 
+GF_EXPORT
+GF_Err gf_rtp_streamer_read_rtcp(GF_RTPStreamer *streamer, gf_rtcp_rr_callback rtcp_cbk, void *udta)
+{
+	u32 i, frac, sec;
+	u32 size = gf_rtp_read_rtcp(streamer->channel, streamer->rtcp_buf, RTCP_BUF_SIZE);
+	if (!size || !rtcp_cbk) return GF_EOS;
+
+	gf_net_get_ntp(&sec, &frac);
+	GF_Err e = gf_rtp_decode_rtcp(streamer->channel, streamer->rtcp_buf, size, NULL);
+	if (e<0) return e;
+
+	for (i=0; i<streamer->channel->nb_rctp_rr; i++) {
+		GF_RTCP_Report *rr = &streamer->channel->rtcp_rri;
+		u32 ssrc = (rr->ssrc==streamer->channel->SSRC) ? 0 : rr->ssrc;
+		u32 lsr_sec = rr->last_sr>>16;
+		u32 lsr_frac = (rr->last_sr&0xFFFF)<<16;
+		u64 dlsr = rr->delay_last_sr * 1000;
+		dlsr /= 65536;
+		s64 diff = (sec&0x0000FFFF) * 1000;
+		diff -= lsr_sec*1000;
+		diff += ((frac>>16)*1000)/65536;
+		diff -= (lsr_frac*1000)/65536;
+		diff -= dlsr;
+
+		u32 rtt_ms = (diff>=0) ? (u32) diff : 0;
+		u32 loss_rate = (rr->frac_lost*1000)/255;
+
+		rtcp_cbk(udta, ssrc, rtt_ms, rr->jitter, loss_rate);
+	}
+	return GF_OK;
+}
+
+GF_EXPORT
+u32 gf_rtp_streamer_get_ssrc(GF_RTPStreamer *streamer)
+{
+	return (streamer && streamer->channel) ? streamer->channel->SSRC : 0;
+}
+
+GF_EXPORT
+u32 gf_rtp_streamer_get_timescale(GF_RTPStreamer *streamer)
+{
+	return (streamer && streamer->packetizer) ? streamer->packetizer->sl_config.timestampResolution : 0;
+}
+
 #endif /*GPAC_DISABLE_STREAMING && GPAC_DISABLE_ISOM*/

gpac-2.0.0.tar.gz/src/ietf/rtsp_command.c -> gpac-2.2.0.tar.gz/src/ietf/rtsp_command.c Changed

gpac-2.0.0.tar.gz/src/ietf/rtsp_common.c -> gpac-2.2.0.tar.gz/src/ietf/rtsp_common.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / IETF RTP/RTSP/SDP sub-project
@@ -39,7 +39,7 @@
 	//fetch more data on the socket if needed
 	while (1) {
 		//Locate header / body
-		if (!BodyStart) gf_rtsp_get_body_info(sess, &BodyStart, &body_size);
+		if (!BodyStart) gf_rtsp_get_body_info(sess, &BodyStart, &body_size, GF_FALSE);
 
 		if (BodyStart) {
 			//enough data
@@ -51,49 +51,106 @@
 		}
 		//this is the tricky part: if we do NOT have a body start -> we refill
 		e = gf_rtsp_refill_buffer(sess);
-		if (e) return e;
+		if (e) {
+			//we have a buffer, nothing to follow and this is an http tunnel, this means no '=' at the end of the base64 string
+			//assume we got the entire message
+			if ((e==GF_IP_NETWORK_EMPTY) && (sess->CurrentPos<sess->CurrentSize) && (sess->tunnel_mode==RTSP_HTTP_SERVER)) {
+				return GF_OK;
+			}
+			return e;
+		}
 	}
 	return GF_OK;
 }
 
-void gf_rtsp_get_body_info(GF_RTSPSession *sess, u32 *body_start, u32 *body_size)
+void gf_rtsp_get_body_info(GF_RTSPSession *sess, u32 *body_start, u32 *body_size, Bool skip_tunnel)
 {
-	u32 i;
 	s32 start;
+	Bool is_post=GF_FALSE;
 	char *buffer;
 	char *cl_str;
 
 	*body_start = *body_size = 0;
 
 	buffer = sess->tcp_buffer + sess->CurrentPos;
-	start = gf_token_find(buffer, 0, sess->CurrentSize - sess->CurrentPos, "\r\n\r\n");
-	if (start<=0) {
+	if (!skip_tunnel && (sess->tunnel_mode==RTSP_HTTP_SERVER)) {
+		start = gf_token_find(buffer, 0, sess->CurrentSize - sess->CurrentPos, "=");
+		if (start<=0) return;
+		*body_start = start + 1;
+		if (bufferstart+1=='=')
+			*body_start += 1;
 		return;
+	} else {
+		start = gf_token_find(buffer, 0, sess->CurrentSize - sess->CurrentPos, "\r\n\r\n");
+		if (start<=0) return;
+		//if found add the 2 "\r\n" and parse it
+		*body_start = start + 4;
+	}
+	if (!strncmp(buffer, "POST ", 5)) {
+		is_post = GF_TRUE;
 	}
-
-	//if found add the 2 "\r\n" and parse it
-	*body_start = start + 4;
 
 	//get the content length
 	cl_str = strstr(buffer, "Content-Length: ");
 	if (!cl_str) cl_str = strstr(buffer, "Content-length: ");
 
 	if (cl_str) {
-		char val30;
+		char *sep;
 		cl_str += 16;
-		i = 0;
-		while (cl_stri != '\r') {
-			vali = cl_stri;
-			i += 1;
+		sep = strchr(cl_str, '\r');
+		if (sep) {
+			sep0 = 0;
+			*body_size = atoi(cl_str);
+			sep0 = '\r';
 		}
-		vali = 0;
-		*body_size = atoi(val);
-	} else {
-		*body_size = 0;
 	}
+	if (is_post) *body_size = 0;
+}
+
+
+GF_Err gf_rstp_do_read_sock(GF_RTSPSession *sess, GF_Socket *sock, u8 *data, u32 data_size, u32 *out_read)
+{
+	GF_Err e;
+#ifdef GPAC_HAS_SSL
+	SSL *ssl_sock = (sock == sess->http) ? sess->ssl_http : sess->ssl;
+	if (ssl_sock) {
+		//receive on null buffer (select only, check if data available)
+		e = gf_sk_receive(sock, NULL, 0, NULL);
+		//empty and no pending bytes in SSL, network empty
+		if ((e==GF_IP_NETWORK_EMPTY) && !SSL_pending(sess->ssl))
+			return GF_IP_NETWORK_EMPTY;
+
+		int size = SSL_read(ssl_sock, data, data_size);
+		if (size < 0) {
+			*out_read = 0;
+			e = gf_sk_probe(sock);
+			if (!e) {
+				int err = SSL_get_error(ssl_sock, size);
+				if (err==SSL_ERROR_SSL) {
+					e = GF_IO_ERR;
+				} else if ((err==SSL_ERROR_WANT_READ) || (err==SSL_ERROR_WANT_WRITE)) {
+					e = GF_IP_NETWORK_EMPTY;
+				} else {
+					e = GF_IP_NETWORK_FAILURE;
+				}
+			}
+		} else if (!size) {
+			e = GF_IP_NETWORK_EMPTY;
+		} else {
+			e = GF_OK;
+			datasize = 0;
+			*out_read = size;
+		}
+	} else
+#endif
+	{
+		e = gf_sk_receive(sock, data, data_size, out_read);
+	}
+	return e;
 }
 
 
+
 GF_Err gf_rtsp_refill_buffer(GF_RTSPSession *sess)
 {
 	GF_Err e;
@@ -115,7 +172,7 @@
 	sess->CurrentSize = res;
 
 	//now read from current pos
-	e = gf_sk_receive(sess->connection, sess->tcp_buffer + sess->CurrentSize, sess->SockBufferSize - sess->CurrentSize, &res);
+	e = gf_rstp_do_read_sock(sess, sess->connection, sess->tcp_buffer + sess->CurrentSize, sess->SockBufferSize - sess->CurrentSize, &res);
 
 	if (!e) {
 		sess->CurrentSize += res;
@@ -123,7 +180,6 @@
 	return e;
 }
 
-
 GF_Err gf_rtsp_fill_buffer(GF_RTSPSession *sess)
 {
 	GF_Err e = GF_OK;
@@ -131,7 +187,11 @@
 	if (!sess->connection) return GF_IP_NETWORK_EMPTY;
 
 	if (sess->CurrentSize == sess->CurrentPos) {
-		e = gf_sk_receive(sess->connection, sess->tcp_buffer, sess->SockBufferSize, &sess->CurrentSize);
+		if (sess->tunnel_mode==RTSP_HTTP_SERVER) {
+			e = gf_rstp_do_read_sock(sess, sess->http, sess->tcp_buffer, sess->SockBufferSize, &sess->CurrentSize);
+		} else {
+			e = gf_rstp_do_read_sock(sess, sess->connection, sess->tcp_buffer, sess->SockBufferSize, &sess->CurrentSize);
+		}
 		sess->CurrentPos = 0;
 		sess->tcp_buffersess->CurrentSize = 0;
 		if (e) sess->CurrentSize = 0;

gpac-2.0.0.tar.gz/src/ietf/rtsp_response.c -> gpac-2.2.0.tar.gz/src/ietf/rtsp_response.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / IETF RTP/RTSP/SDP sub-project
@@ -238,8 +238,8 @@
 	else if (!stricmp(Header, "Unsupported")) rsp->Unsupported = gf_strdup(Value);
 	else if (!stricmp(Header, "User-Agent")) rsp->User_Agent = gf_strdup(Value);
 	else if (!stricmp(Header, "Vary")) rsp->Vary = gf_strdup(Value);
-	else if (!stricmp(Header, "Via")) rsp->Vary = gf_strdup(Value);
-	else if (!stricmp(Header, "WWW_Authenticate")) rsp->Vary = gf_strdup(Value);
+	else if (!stricmp(Header, "Via")) rsp->Via = gf_strdup(Value);
+	else if (!stricmp(Header, "WWW-Authenticate")) rsp->WWW_Authenticate = gf_strdup(Value);
 	else if (!stricmp(Header, "Transport")) {
 		LinePos = 0;
 		while (1) {
@@ -354,6 +354,7 @@
 	if (buffer0=='$') return 0;
 
 	if (!strncmp(buffer, "RTSP", 4)) return 1;
+	if (!strncmp(buffer, "HTTP", 4)) return 1;
 	if (!strncmp(buffer, "GET_PARAMETER", strlen("GET_PARAMETER"))) return 1;
 	if (!strncmp(buffer, "ANNOUNCE", strlen("ANNOUNCE"))) return 1;
 	if (!strncmp(buffer, "SET_PARAMETER", strlen("SET_PARAMETER"))) return 1;
@@ -393,11 +394,23 @@
 		goto exit;
 
 	//get the reply
-	gf_rtsp_get_body_info(sess, &BodyStart, &size);
+	gf_rtsp_get_body_info(sess, &BodyStart, &size, GF_FALSE);
+
+	if (!strncmp(sess->tcp_buffer+sess->CurrentPos, "HTTP", 4)) {
+		sess->CurrentPos += BodyStart + rsp->Content_Length;
+		e = GF_IP_NETWORK_EMPTY;
+		goto exit;
+	}
 	e = RTSP_ParseResponseHeader(sess, rsp, BodyStart);
 
 	//copy the body if any
 	if (!e && rsp->Content_Length) {
+		u32 rsp_size = sess->CurrentSize - sess->CurrentPos;
+		if (rsp_size < rsp->Content_Length) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("RTSP Invalid content length %u - Response was: \n%s\n", rsp->Content_Length, sess->tcp_buffer+sess->CurrentPos));
+			e = GF_NON_COMPLIANT_BITSTREAM;
+			goto exit;
+		}
 		rsp->body = (char *)gf_malloc(sizeof(char) * (rsp->Content_Length));
 		memcpy(rsp->body, sess->tcp_buffer+sess->CurrentPos + BodyStart, rsp->Content_Length);
 	}
@@ -407,6 +420,7 @@
 	//reset TCP buffer
 	sess->CurrentPos += BodyStart + rsp->Content_Length;
 
+
 	if (e) goto exit;
 
 	//update RTSP aggreagation info
@@ -464,7 +478,7 @@
 		sess->connection = NULL;
 
 		//destroy the http tunnel if any
-		if (sess->HasTunnel && sess->http) {
+		if (sess->http) {
 			gf_sk_del(sess->http);
 			sess->http = NULL;
 		}
@@ -541,7 +555,7 @@
 
 	//Range, only NPT
 	if (rsp->Range && !rsp->Range->UseSMPTE) {
-		RTSP_WRITE_ALLOC_STR(buffer, size, cur_pos, "Range: npt:");
+		RTSP_WRITE_ALLOC_STR(buffer, size, cur_pos, "Range: npt=");
 		RTSP_WRITE_FLOAT_WITHOUT_CHECK(buffer, size, cur_pos, rsp->Range->start);
 		RTSP_WRITE_ALLOC_STR(buffer, size, cur_pos, "-");
 		if (rsp->Range->end > rsp->Range->start) {
@@ -695,6 +709,7 @@
 
 	e = RTSP_WriteResponse(sess, rsp, (unsigned char **) &buffer, &size);
 	if (!e) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSP Sending response %s", buffer));
 		//send buffer
 		e = gf_rtsp_send_data(sess, buffer, size);
 	}

gpac-2.0.0.tar.gz/src/ietf/rtsp_session.c -> gpac-2.2.0.tar.gz/src/ietf/rtsp_session.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / IETF RTP/RTSP/SDP sub-project
@@ -29,18 +29,39 @@
 
 #ifndef GPAC_DISABLE_STREAMING
 
+static GF_Err gf_rtsp_write_sock(GF_RTSPSession *sess, u8 *data, u32 len);
+static GF_Err gf_rstp_flush_buffer(GF_RTSPSession *sess);
+static GF_Err gf_rtsp_http_tunnel_setup(GF_RTSPSession *sess);
+
+#ifdef GPAC_HAS_SSL
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+#include <openssl/rand.h>
+
+void *gf_ssl_new(void *ssl_server_ctx, GF_Socket *client_sock, GF_Err *e);
+void gf_ssl_del(void *ssl);
+Bool gf_ssl_check_cert(SSL *ssl, const char *server_name);
+
+#endif
+
+
 /*default packet size to use when storing incomplete packets*/
 #define RTSP_PCK_SIZE			1000
 
-GF_Err RTSP_UnpackURL(char *sURL, char *Server, u16 *Port, char *Service, Bool *useTCP)
+GF_Err RTSP_UnpackURL(char *sURL, char Server1024, u16 *Port, char Service1024, Bool *useTCP, char User1024, char Pass1024)
 {
-	char schema10, *test, text1024, *retest, *sep;
+	char schema10, *test, text1024, *retest, *sep, *service_start;
 	u32 i, len;
 	Bool is_ipv6;
 	if (!sURL) return GF_BAD_PARAM;
 
-	strcpy(Server, "");
-	strcpy(Service, "");
+	Server0 = 0;
+	Service0 = 0;
+	User0 = 0;
+	Pass0 = 0;
+
 	*Port = 0;
 	*useTCP = GF_FALSE;
 
@@ -60,7 +81,7 @@
 
 found:
 	schemai = 0;
-	if (stricmp(schema, "rtsp") && stricmp(schema, "rtspu") && stricmp(schema, "satip")) return GF_URL_ERROR;
+	if (stricmp(schema, "rtsp") && stricmp(schema, "rtspu") && stricmp(schema, "rtsph") && stricmp(schema, "rtsps") && stricmp(schema, "satip")) return GF_URL_ERROR;
 	//check for user/pass - not allowed
 	/*
 		test = strstr(sURL, "@");
@@ -78,11 +99,13 @@
 		if (sep) sep0 = '?';
 		return GF_URL_ERROR;
 	}
-	if (!stricmp(schema, "rtsp") || !stricmp(schema, "satip"))
+	if (!stricmp(schema, "rtsp") || !stricmp(schema, "satip") || !stricmp(schema, "rtsph") || !stricmp(schema, "rtsps"))
 		*useTCP = GF_TRUE;
 
+	service_start = retest;
 	//check for port
-	retest = strrchr(test, ':');
+	char *port = strrchr(test, ':');
+	retest = (port<retest) ? port : NULL;
 	/*IPV6 address*/
 	if (retest && strchr(retest, '')) retest = NULL;
 
@@ -98,6 +121,24 @@
 		*Port = atoi(text);
 	}
 
+	char *sep_auth = strchr(test, '@');
+	if (sep_auth>service_start) sep_auth=NULL;
+	if (sep_auth) {
+		sep_auth0 = 0;
+		char *psep = strchr(test, ':');
+		if (psep) psep0 = 0;
+		strncpy(User, test, 1023);
+		User1023=0;
+		if (psep) {
+			strncpy(Pass, psep+1, 1023);
+			Pass1023=0;
+			if (psep) psep0 = ':';
+		}
+
+		sep_auth0 = '@';
+		test = sep_auth+1;
+	}
+
 	//get the server name
 	is_ipv6 = GF_FALSE;
 	len = (u32) strlen(test);
@@ -110,12 +151,16 @@
 		i += 1;
 	}
 	texti = 0;
-	strcpy(Server, text);
+	strncpy(Server, text, 1023);
+	Server1023=0;
 	if (sep) sep0 = '?';
 
-	while (testi != '/') i += 1;
-	strcpy(Service, test+i+1);
-
+	if (service_start) {
+		strncpy(Service, service_start+1, 1023);
+		Service1023=0;
+	} else {
+		Service0=0;
+	}
 	return GF_OK;
 }
 
@@ -125,33 +170,50 @@
 GF_RTSPSession *gf_rtsp_session_new(char *sURL, u16 DefaultPort)
 {
 	GF_RTSPSession *sess;
-	char server1024, service1024;
+	char server1024, service1024, user1024, pass1024;
 	GF_Err e;
 	u16 Port;
 	Bool UseTCP;
 
 	if (!sURL) return NULL;
 
-	e = RTSP_UnpackURL(sURL, server, &Port, service, &UseTCP);
+	e = RTSP_UnpackURL(sURL, server, &Port, service, &UseTCP, user, pass);
 	if (e) return NULL;
 
 	GF_SAFEALLOC(sess, GF_RTSPSession);
 	if (!sess) return NULL;
 	sess->ConnectionType = UseTCP ? GF_SOCK_TYPE_TCP : GF_SOCK_TYPE_UDP;
+
+#ifdef GPAC_HAS_SSL
+	if (!strncmp(sURL, "rtsps://", 8)
+		|| (!strncmp(sURL, "rtsph://", 8) && ((Port==443) || (Port == 8443)))
+	) {
+		sess->use_ssl = GF_TRUE;
+		sess->ConnectionType = GF_SOCK_TYPE_TCP;
+	}
+#endif
+
 	if (Port) sess->Port = Port;
+#ifdef GPAC_HAS_SSL
+	else if (sess->use_ssl) sess->Port = 322;
+#endif
 	else if (DefaultPort) sess->Port = DefaultPort;
 	else sess->Port = 554;
 
 	//HTTP tunnel
-	if (sess->Port == 80) {
+	if ((sess->Port == 80) || (sess->Port == 8080) || !strnicmp(sURL, "rtsph://", 8)){
 		sess->ConnectionType = GF_SOCK_TYPE_TCP;
-		sess->HasTunnel = GF_TRUE;
+		sess->tunnel_mode = RTSP_HTTP_CLIENT;
 	}
 
 	gf_rtsp_set_buffer_size(sess, RTSP_PCK_SIZE);
 
 	sess->Server = gf_strdup(server);
 	sess->Service = gf_strdup(service);
+	if (user0)
+		sess->User = gf_strdup(user);
+	if (pass0)
+	sess->Pass = gf_strdup(pass);
 	sess->TCPChannels = gf_list_new();
 	gf_rtsp_session_reset(sess, GF_FALSE);
 	return sess;
@@ -183,7 +245,7 @@
 
 
 GF_EXPORT
-void gf_rtsp_session_reset(GF_RTSPSession *sess, Bool ResetConnection)
+u32 gf_rtsp_session_reset(GF_RTSPSession *sess, Bool ResetConnection)
 {
 	sess->last_session_id = NULL;
 	sess->NeedConnection = 1;
@@ -194,18 +256,57 @@
 		if (sess->http) {
 			gf_sk_del(sess->http);
 			sess->http = NULL;
+			if (sess->tunnel_mode<RTSP_HTTP_DISABLE)
+				sess->tunnel_mode = 0;
 		}
+		sess->tunnel_state = 0;
+#ifdef GPAC_HAS_SSL
+		if (sess->ssl) {
+			gf_ssl_del(sess->ssl);
+			sess->ssl = NULL;
+		}
+		if (sess->ssl_http) {
+			gf_ssl_del(sess->ssl_http);
+			sess->ssl_http = NULL;
+		}
+#endif
+
 	}
 
 	sess->RTSP_State = GF_RTSP_STATE_INIT;
-//	sess->CSeq = sess->NbPending = 0;
 	sess->InterID = (u8) -1;
 	sess->pck_start = sess->payloadSize = 0;
 	sess->CurrentPos = sess->CurrentSize = 0;
 	strcpy(sess->RTSPLastRequest, "");
 	RemoveTCPChannels(sess);
+	//CSeq 1 is for regular rtsp -> rtsps switch, 0 is for rtsph->rtsph+tls
+	if (sess->CSeq<=1) {
+		sess->nb_retry++;
+
+#ifdef GPAC_HAS_SSL
+		if ((sess->nb_retry>2)
+			&& !sess->use_ssl
+			&& !gf_opts_get_bool("core", "no-tls-rcfg")
+		) {
+			sess->use_ssl = GF_TRUE;
+			GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSP Connection closed by server %s, retrying with TLS\n", sess->Server));
+		}
+#endif
+		return sess->nb_retry;
+	}
+	return 0;
 }
 
+
+#ifdef GPAC_HAS_SSL
+Bool gf_rtsp_session_needs_ssl(GF_RTSPSession *sess)
+{
+	if (!sess) return GF_FALSE;
+	if (sess->use_ssl && !sess->ssl_ctx) return GF_TRUE;
+	return GF_FALSE;
+}
+#endif
+
 GF_EXPORT
 void gf_rtsp_session_del(GF_RTSPSession *sess)
 {
@@ -220,10 +321,29 @@
 	gf_list_del(sess->TCPChannels);
 	if (sess->rtsp_pck_buf) gf_free(sess->rtsp_pck_buf);
 	gf_free(sess->tcp_buffer);
+	if (sess->HTTP_Cookie) gf_free(sess->HTTP_Cookie);
+	if (sess->User) gf_free(sess->User);
+	if (sess->Pass) gf_free(sess->Pass);
+	if (sess->async_buf) gf_free(sess->async_buf);
+
+#ifdef GPAC_HAS_SSL
+	if (sess->ssl) gf_ssl_del(sess->ssl);
+	if (sess->ssl_http) gf_ssl_del(sess->ssl_http);
+#endif
 
 	gf_free(sess);
 }
 
+#ifdef GPAC_HAS_SSL
+GF_Err gf_rtsp_set_ssl_ctx(GF_RTSPSession *sess, void *ssl_CTX)
+{
+	if (!sess) return GF_BAD_PARAM;
+	sess->ssl_ctx = ssl_CTX;
+	return GF_OK;
+}
+#endif
+
+
 GF_EXPORT
 u32 gf_rtsp_get_session_state(GF_RTSPSession *sess)
 {
@@ -264,7 +384,7 @@
 #endif
 
 GF_EXPORT
-char *gf_rtsp_get_server_name(GF_RTSPSession *sess)
+const char *gf_rtsp_get_server_name(GF_RTSPSession *sess)
 {
 	if (!sess) return NULL;
 	return sess->Server;
@@ -276,36 +396,101 @@
 	return (sess ? sess->Port : 0);
 }
 
+GF_EXPORT
+Bool gf_rtsp_use_tls(GF_RTSPSession *sess)
+{
+#ifdef GPAC_HAS_TLS
+	return (sess ? sess->use_tls : GF_FALSE);
+#endif
+	return GF_FALSE;
+}
+
 GF_Err gf_rtsp_check_connection(GF_RTSPSession *sess)
 {
 	GF_Err e;
+	if (!sess) return GF_BAD_PARAM;
 	//active, return
-	if (!sess->NeedConnection) return GF_OK;
+	if (!sess->NeedConnection) {
+		if (sess->tunnel_state) return gf_rtsp_http_tunnel_setup(sess);
+		return gf_rstp_flush_buffer(sess);
+	}
 
 	//socket is destroyed, recreate
 	if (!sess->connection) {
 		sess->connection = gf_sk_new(sess->ConnectionType);
 		if (!sess->connection) return GF_OUT_OF_MEM;
+
+		//work in non-blocking mode
+		gf_sk_set_block_mode(sess->connection, GF_TRUE);
+		sess->timeout_in = gf_opts_get_int("core", "tcp-timeout");
+		if (!sess->timeout_in) sess->timeout_in = 5000;
+		sess->timeout_in += gf_sys_clock();
+		if (sess->SockBufferSize) gf_sk_set_buffer_size(sess->connection, GF_FALSE, sess->SockBufferSize);
 	}
+
 	//the session is down, reconnect
-	e = gf_sk_connect(sess->connection, sess->Server, sess->Port, NULL);
-	if (e) return e;
+#ifdef GPAC_HAS_SSL
+	if (!sess->ssl_connect_pending)
+#endif
+	{
+		e = gf_sk_connect(sess->connection, sess->Server, sess->Port, NULL);
+		if (e) {
+			if (e==GF_IP_NETWORK_EMPTY) {
+				if (sess->timeout_in < gf_sys_clock())
+					e = GF_IP_CONNECTION_FAILURE;
+			}
+			return e;
+		}
+	}
+
+#ifdef GPAC_HAS_SSL
+	if (sess->use_ssl) {
+		if (!sess->ssl_ctx)
+			return GF_IP_CONNECTION_FAILURE;
+
+		if (!sess->ssl) {
+			sess->ssl = SSL_new(sess->ssl_ctx);
+			SSL_set_fd(sess->ssl, gf_sk_get_handle(sess->connection));
+			SSL_ctrl(sess->ssl, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, (void*) sess->Server);
+			SSL_set_connect_state(sess->ssl);
+			SSL_set_mode(sess->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER|SSL_MODE_ENABLE_PARTIAL_WRITE);
+			SSL_set_alpn_protos(sess->ssl, NULL, 0);
+		}
 
-	if (sess->SockBufferSize) gf_sk_set_buffer_size(sess->connection, GF_FALSE, sess->SockBufferSize);
+		sess->ssl_connect_pending = 0;
+		int ret = SSL_connect(sess->ssl);
+		if (ret<=0) {
+			ret = SSL_get_error(sess->ssl, ret);
+			if (ret==SSL_ERROR_SSL) {
+				char msg1024;
+				SSL_load_error_strings();
+				ERR_error_string_n(ERR_get_error(), msg, sizeof(msg));
+				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Cannot connect, error %s\n", msg));
+				return GF_IP_CONNECTION_FAILURE;
+			} else if ((ret==SSL_ERROR_WANT_READ) || (ret==SSL_ERROR_WANT_WRITE)) {
+				sess->ssl_connect_pending = 1;
+				return GF_IP_NETWORK_EMPTY;
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Cannot connect, error %d\n", ret));
+				return GF_REMOTE_SERVICE_ERROR;
+			}
+		} else {
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("SSL connected\n"));
+		}
 
-#ifdef GPAC_ENABLE_COVERAGE
-	if (gf_sys_is_cov_mode())
-		gf_rtsp_http_tunnel_start(NULL, NULL);
+		Bool success = gf_ssl_check_cert(sess->ssl, sess->Server);
+		if (!success) {
+			return GF_AUTHENTICATION_FAILURE;
+		}
+	}
 #endif
 
-	if (!sess->http && sess->HasTunnel) {
-		const char *ua = gf_opts_get_key("core", "user-agent");
-		if (!ua) ua = "GPAC " GPAC_VERSION;
-		e = gf_rtsp_http_tunnel_start(sess, (char *)ua);
+	sess->NeedConnection = 0;
+	if (!sess->http && (sess->tunnel_mode==RTSP_HTTP_CLIENT)) {
+		e = gf_rtsp_http_tunnel_setup(sess);
 		if (e) return e;
 	}
-	sess->NeedConnection = 0;
-	return GF_OK;
+	return gf_rstp_flush_buffer(sess);
 }
 
 
@@ -318,14 +503,16 @@
 	if (e) return e;
 
 	//RTSP requests on HTTP are base 64 encoded
-	if (sess->HasTunnel) {
-		char buf643000;
-		Size64 = gf_base64_encode(buffer, Size, buf64, 3000);
-		buf64Size64 = 0;
+	if (sess->tunnel_mode==RTSP_HTTP_CLIENT) {
+		char *buf64 = gf_malloc(sizeof(char)*Size*2);
+		if (!buf64) return GF_OUT_OF_MEM;
+		Size64 = gf_base64_encode(buffer, Size, buf64, Size*2);
 		//send on http connection
-		return gf_sk_send_wait(sess->http, buf64, Size64, 30);
+		e = gf_rtsp_write_sock(sess, buf64, Size64);
+		gf_free(buf64);
+		return e;
 	} else {
-		return gf_sk_send(sess->connection, buffer, Size);
+		return gf_rtsp_write_sock(sess, buffer, Size);
 	}
 }
 
@@ -347,7 +534,7 @@
 }
 
 
-GF_Err gf_rtsp_set_deinterleave(GF_RTSPSession *sess)
+GF_Err gf_rtsp_do_deinterleave(GF_RTSPSession *sess)
 {
 	GF_TCPChan *ch;
 	Bool IsRTCP;
@@ -361,14 +548,15 @@
 	Size = sess->CurrentSize - sess->CurrentPos;
 	buffer = sess->tcp_buffer + sess->CurrentPos;
 
-	if (!Size) return GF_IP_NETWORK_EMPTY;
-
 	//we do not work with just a header -> force a refill
-	if (Size <= 4) return gf_rtsp_refill_buffer(sess);
+	if (!Size)
+		return gf_rtsp_fill_buffer(sess);
+	if (Size <= 4)
+		return gf_rtsp_refill_buffer(sess);
 
 	//break if we get RTSP response on the wire
-	if (!strncmp(buffer, "RTSP", 4))
-		return GF_IP_NETWORK_EMPTY;
+	if (!strncmp(buffer, "RTSP", 4) || !strncmp(buffer, "HTTP", 4))
+		return GF_EOS;
 
 	//new packet
 	if (!sess->pck_start && (buffer0 == '$')) {
@@ -412,7 +600,8 @@
 //		GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("RTP over RTSP Missed beginning of packet (%d bytes) in stream %d\n", Size, sess->InterID));
 
 		res = sess->payloadSize - sess->pck_start;
-		memcpy(sess->rtsp_pck_buf + sess->pck_start, buffer, res);
+		if (res)
+			memcpy(sess->rtsp_pck_buf + sess->pck_start, buffer, res);
 		//flush - same as above, don't complain if channel not found
 		ch = GetTCPChannel(sess, sess->InterID, sess->InterID, GF_FALSE);
 		if (ch) {
@@ -445,10 +634,10 @@
 
 	e = gf_rtsp_fill_buffer(sess);
 	if (!e) {
-		//only read if not RTSP
+		//read as much as possible (will break if no data or if "RTSP" is found)
 		while (1) {
-			e = gf_rtsp_set_deinterleave(sess);
-			if (e) break;
+			e = gf_rtsp_do_deinterleave(sess);
+			if (e) return e;
 		}
 	}
 	return e;
@@ -513,78 +702,185 @@
 	if (!sess) return GF_BAD_PARAM;
 	if (sess->SockBufferSize >= BufferSize) return GF_OK;
 	sess->SockBufferSize = BufferSize;
-	sess->tcp_buffer = gf_realloc(sess->tcp_buffer, BufferSize);
+	sess->tcp_buffer = gf_realloc(sess->tcp_buffer, (BufferSize+1));
 	return GF_OK;
 }
 
+static GF_Err rstp_do_write_sock(GF_RTSPSession *sess, GF_Socket *sock, const u8 *buffer, u32 size, u32 *written)
+{
+#ifdef GPAC_HAS_SSL
+	SSL *ssl_sock = (sock==sess->http) ? sess->ssl_http : sess->ssl;
+	if (ssl_sock) {
+		u32 idx=0;
+		s32 nb_tls_blocks = size/16000;
+		if (written)
+			*written = 0;
+		while (nb_tls_blocks>=0) {
+			u32 len, to_write = 16000;
+			if (nb_tls_blocks==0)
+				to_write = size - idx*16000;
+
+			len = SSL_write(ssl_sock, buffer + idx*16000, to_write);
+			nb_tls_blocks--;
+			idx++;
+
+			if (len != to_write) {
+				int err = SSL_get_error(ssl_sock, len);
+				if ((err==SSL_ERROR_WANT_READ) || (err==SSL_ERROR_WANT_WRITE)) {
+					return GF_IP_NETWORK_EMPTY;
+				}
+				if (err==SSL_ERROR_SSL) {
+					char msg1024;
+					SSL_load_error_strings();
+					ERR_error_string_n(ERR_get_error(), msg, sizeof(msg));
+					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Cannot send, error %s\n", msg));
+				}
+				return GF_IP_NETWORK_FAILURE;
+			}
+			if (written)
+				*written += to_write;
+		}
+		return GF_OK;
+	}
+#endif
+	return gf_sk_send_ex(sock, buffer, size, written);
+}
 
-static Bool HTTP_RandInit = GF_TRUE;
-
-#define HTTP_WAIT_SEC		30
 
-#define HTTP_RSP_OK	"HTTP/1.0 200 OK"
+static Bool HTTP_RandInit = GF_TRUE;
 
+#define HTTP10_RSP_OK	"HTTP/1.0 200 OK"
+#define HTTP11_RSP_OK	"HTTP/1.1 200 OK"
 
-//http tunnelling start.
-GF_EXPORT
-GF_Err gf_rtsp_http_tunnel_start(GF_RTSPSession *sess, char *UserAgent)
+static GF_Err gf_rtsp_http_tunnel_setup(GF_RTSPSession *sess)
 {
 	GF_Err e;
 	u32 size;
 	s32 pos;
-	u32 i, num, temp;
+	const char *ua;
 	char bufferGF_RTSP_DEFAULT_BUFFER;
 
-	if (!sess || !UserAgent) return GF_BAD_PARAM;
+	if (!sess) return GF_BAD_PARAM;
+
+	if (!sess->tunnel_state) {
+		//generate http cookie
+		if (HTTP_RandInit) {
+			gf_rand_init(GF_FALSE);
+			HTTP_RandInit = GF_FALSE;
+		}
+		if (!sess->HTTP_Cookie) {
+			char szBuf30;
+			u32 r = gf_rand();
+			snprintf(szBuf, 29, "GPAC_%x_"LLX, r, gf_sys_clock_high_res() );
+			szBuf29=0;
+			sess->HTTP_Cookie = gf_strdup(szBuf);
+			if (!sess->HTTP_Cookie) return GF_OUT_OF_MEM;
+		}
 
-	//generate http cookie
-	if (HTTP_RandInit) {
-		gf_rand_init(GF_FALSE);
-		HTTP_RandInit = GF_FALSE;
-	}
-	if (!sess->CookieRadLen) {
-		strcpy(sess->HTTP_Cookie, "GPACROH");
-		sess->CookieRadLen = 8;
+		ua = gf_opts_get_key("core", "user-agent");
+		if (!ua) ua = "GPAC " GPAC_VERSION;
+
+		// 1. send "GET /sample.mov HTTP/1.0\r\n ..."
+		memset(buffer, 0, GF_RTSP_DEFAULT_BUFFER);
+		pos = 0;
+		pos += sprintf(buffer + pos, "GET /%s HTTP/1.0\r\n", sess->Service);
+		pos += sprintf(buffer + pos, "User-Agent: %s\r\n", ua);
+		pos += sprintf(buffer + pos, "x-sessioncookie: %s\r\n", sess->HTTP_Cookie);
+		pos += sprintf(buffer + pos, "Accept: application/x-rtsp-tunnelled\r\n" );
+		pos += sprintf(buffer + pos, "Pragma: no-cache\r\n" );
+		/*pos += */sprintf(buffer + pos, "Cache-Control: no-cache\r\n\r\n" );
+
+		sess->tunnel_state = 1;
+		GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSPTunnel Sending %s", buffer));
+
+		//	send it - we assume this will fit the socket buffer
+		e = rstp_do_write_sock(sess, sess->connection, buffer, (u32) strlen(buffer), NULL);
+		if (e) return e;
 	}
-	num = gf_rand();
-	for (i=0; i < 8; i++) {
-		temp = (num >> (i * 4)) & 0x0f;
-		sess->HTTP_Cookiesess->CookieRadLen + i = (u8) temp + sess->HTTP_Cookie0;
+
+	if (sess->tunnel_state == 1) {
+		//	2. wait for "HTTP/1.0 200 OK"
+		e = gf_rstp_do_read_sock(sess, sess->connection, buffer, GF_RTSP_DEFAULT_BUFFER, &size);
+		if (e) {
+			if ((e==GF_IP_NETWORK_EMPTY) && (sess->timeout_in < gf_sys_clock()))
+				e = GF_IP_CONNECTION_FAILURE;
+			return e;
+		}
+		assert(size);
+		sess->tunnel_state = 2;
+		GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSPTunnel Got reply %s", buffer));
+
+		//get HTTP/1.0 200 OK
+		if (strncmp(buffer, HTTP10_RSP_OK, strlen(HTTP10_RSP_OK)) && strncmp(buffer, HTTP11_RSP_OK, strlen(HTTP11_RSP_OK))) {
+			sess->tunnel_state = 0;
+			return GF_REMOTE_SERVICE_ERROR;
+		}
+
+		//	3. send "POST /sample.mov HTTP/1.0\r\n ..."
+		sess->http = gf_sk_new(GF_SOCK_TYPE_TCP);
+		if (!sess->http ) {
+			sess->tunnel_state = 0;
+			return GF_IP_NETWORK_FAILURE;
+		}
+		gf_sk_set_block_mode(sess->http, GF_TRUE);
 	}
-	sess->HTTP_Cookiesess->CookieRadLen + i = 0;
 
-	// 1. send "GET /sample.mov HTTP/1.0\r\n ..."
-	memset(buffer, 0, GF_RTSP_DEFAULT_BUFFER);
-	pos = 0;
-	pos += sprintf(buffer + pos, "GET /%s HTTP/1.0\r\n", sess->Service);
-	pos += sprintf(buffer + pos, "User-Agent: %s\r\n", UserAgent);
-	pos += sprintf(buffer + pos, "x-sessioncookie: %s\r\n", sess->HTTP_Cookie);
-	pos += sprintf(buffer + pos, "Accept: application/x-rtsp-tunnelled\r\n" );
-	pos += sprintf(buffer + pos, "Pragma: no-cache\r\n" );
-	/*pos += */sprintf(buffer + pos, "Cache-Control: no-cache\r\n\r\n" );
+#ifdef GPAC_HAS_SSL
+	if (!sess->ssl_connect_pending)
+#endif
+	{
+		e = gf_sk_connect(sess->http, sess->Server, sess->Port, NULL);
+		if (e) {
+			if ((e==GF_IP_NETWORK_EMPTY) && (sess->timeout_in < gf_sys_clock()))
+				e = GF_IP_CONNECTION_FAILURE;
+			return e;
+		}
+	}
 
-	//	send it!
-	e = gf_sk_send_wait(sess->connection, buffer, (u32) strlen(buffer), HTTP_WAIT_SEC);
-	if (e) return e;
 
-	//	2. wait for "HTTP/1.0 200 OK"
-	e = gf_sk_receive_wait(sess->connection, buffer, GF_RTSP_DEFAULT_BUFFER, &size, HTTP_WAIT_SEC);
-	if (e) return e;
+#ifdef GPAC_HAS_SSL
+	if (sess->use_ssl) {
+		if (!sess->ssl_http) {
+			sess->ssl_http = SSL_new(sess->ssl_ctx);
+			SSL_set_fd(sess->ssl_http, gf_sk_get_handle(sess->http));
+			SSL_ctrl(sess->ssl_http, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, (void*) sess->Server);
+			SSL_set_connect_state(sess->ssl_http);
+			SSL_set_mode(sess->ssl_http, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER|SSL_MODE_ENABLE_PARTIAL_WRITE);
+			SSL_set_alpn_protos(sess->ssl_http, NULL, 0);
+		}
 
-	//get HTTP/1.0 200 OK
-	if (strncmp(buffer, HTTP_RSP_OK, strlen(HTTP_RSP_OK)))
-		return GF_REMOTE_SERVICE_ERROR;
+		sess->ssl_connect_pending = 0;
+		int ret = SSL_connect(sess->ssl_http);
+		if (ret<=0) {
+			ret = SSL_get_error(sess->ssl_http, ret);
+			if (ret==SSL_ERROR_SSL) {
+				char msg1024;
+				SSL_load_error_strings();
+				ERR_error_string_n(ERR_get_error(), msg, sizeof(msg));
+				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Cannot connect, error %s\n", msg));
+				return GF_IP_CONNECTION_FAILURE;
+			} else if ((ret==SSL_ERROR_WANT_READ) || (ret==SSL_ERROR_WANT_WRITE)) {
+				sess->ssl_connect_pending = 1;
+				return GF_IP_NETWORK_EMPTY;
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Cannot connect, error %d\n", ret));
+				return GF_REMOTE_SERVICE_ERROR;
+			}
+		} else {
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("SSL connected\n"));
+		}
+	}
+#endif
 
-	//	3. send "POST /sample.mov HTTP/1.0\r\n ..."
-	sess->http = gf_sk_new(GF_SOCK_TYPE_TCP);
-	if (!sess->http ) return GF_IP_NETWORK_FAILURE;
+	GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSPTunnel POST channel connected"));
 
-	if (gf_sk_connect(sess->http, sess->Server, sess->Port, NULL)) return GF_IP_CONNECTION_FAILURE;
 
+	ua = gf_opts_get_key("core", "user-agent");
+	if (!ua) ua = "GPAC " GPAC_VERSION;
 	memset(buffer, 0, GF_RTSP_DEFAULT_BUFFER);
 	pos = 0;
 	pos += sprintf(buffer + pos, "POST /%s HTTP/1.0\r\n", sess->Service);
-	pos += sprintf(buffer + pos, "User-Agent: %s\r\n", UserAgent);
+	pos += sprintf(buffer + pos, "User-Agent: %s\r\n", ua);
 	pos += sprintf(buffer + pos, "x-sessioncookie: %s\r\n", sess->HTTP_Cookie);
 	pos += sprintf(buffer + pos, "Accept: application/x-rtsp-tunnelled\r\n");
 	pos += sprintf(buffer + pos, "Pragma: no-cache\r\n");
@@ -592,27 +888,28 @@
 	pos += sprintf(buffer + pos, "Content-Length: 32767\r\n");
 	/*pos += */sprintf(buffer + pos, "Expires: Sun. 9 Jan 1972 00:00:00 GMT\r\n\r\n");
 
-	//	send it!
-	e = gf_sk_send_wait(sess->http, buffer, (u32) strlen(buffer), HTTP_WAIT_SEC);
-
-	return e;
+	sess->tunnel_state = 0;
+	GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("RTSPTunnel Sending request %s", buffer));
+	//	send it, no need to wait for answer
+	return rstp_do_write_sock(sess, sess->http, buffer, (u32) strlen(buffer), NULL);
 }
 
-
 /*server-side RTSP sockets*/
 
 static u32 SessionID_RandInit = 0;
 
 
 GF_EXPORT
-GF_RTSPSession *gf_rtsp_session_new_server(GF_Socket *rtsp_listener)
+GF_RTSPSession *gf_rtsp_session_new_server(GF_Socket *rtsp_listener, Bool allow_http_tunnel, void *ssl_ctx)
 {
 	GF_RTSPSession *sess;
 	GF_Socket *new_conn;
 	GF_Err e;
 	u32 fam;
 	u16 port;
-	char nameGF_MAX_IP_NAME_LEN;
+#ifdef GPAC_HAS_SSL
+	SSL *ssl = NULL;
+#endif
 
 	if (!rtsp_listener) return NULL;
 
@@ -620,6 +917,18 @@
 	e = gf_sk_accept(rtsp_listener, &new_conn);
 	if (!new_conn || e) return NULL;
 
+#ifdef GPAC_HAS_SSL
+	if (ssl_ctx) {
+		ssl = gf_ssl_new(ssl_ctx, new_conn, &e);
+		if (e) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("SSL Failed to create TLS session: %s\n", gf_error_to_string(e) ));
+			gf_sk_del(new_conn);
+			return NULL;
+		}
+		SSL_set_mode(ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER|SSL_MODE_ENABLE_PARTIAL_WRITE);
+	}
+#endif
+
 	e = gf_sk_get_local_info(new_conn, &port, &fam);
 	if (e) {
 		gf_sk_del(new_conn);
@@ -643,10 +952,22 @@
 	sess->connection = new_conn;
 	sess->Port = port;
 	sess->ConnectionType = fam;
-	gf_sk_get_host_name(name);
-	sess->Server = gf_strdup(name);
+#ifdef GPAC_HAS_SSL
+	sess->ssl_ctx = ssl_ctx;
+	sess->ssl = ssl;
+#endif
+	const char *name = gf_opts_get_key("core", "user-agent");
+	if (name) {
+		sess->Server = gf_strdup(name);
+	} else {
+		sess->Server = gf_strdup("GPAC-");
+		gf_dynstrcat(&sess->Server, gf_gpac_version(), NULL);
+	}
 	gf_rtsp_set_buffer_size(sess, 4096);
 	sess->TCPChannels = gf_list_new();
+	if (!allow_http_tunnel)
+		sess->tunnel_mode = RTSP_HTTP_DISABLE;
+
 	return sess;
 }
 
@@ -654,14 +975,14 @@
 #if 0 //unused
 GF_Err gf_rtsp_load_service_name(GF_RTSPSession *sess, char *URL)
 {
-	char server1024, service1024;
+	char server1024, service1024, user1024, pass1024;
 	GF_Err e;
 	u16 Port;
 	Bool UseTCP;
 	u32 type;
 
 	if (!sess || !URL) return GF_BAD_PARAM;
-	e = RTSP_UnpackURL(URL, server, &Port, service, &UseTCP);
+	e = RTSP_UnpackURL(URL, server, &Port, service, &UseTCP, user, pass);
 	if (e) return e;
 
 	type = UseTCP ? GF_SOCK_TYPE_TCP : GF_SOCK_TYPE_UDP;
@@ -730,6 +1051,27 @@
 	return gf_sk_get_remote_address(sess->connection, buf);
 }
 
+static GF_Err gf_rtsp_write_sock(GF_RTSPSession *sess, u8 *data, u32 len)
+{
+	u32 remain, written=0;
+	if (!sess->async_buf_size) {
+		GF_Err e = rstp_do_write_sock(sess, (sess->http && (sess->tunnel_mode==RTSP_HTTP_CLIENT)) ? sess->http : sess->connection, data, len, &written);
+		if (e && (e!= GF_IP_NETWORK_EMPTY))
+			return e;
+		if (written==len) return GF_OK;
+	}
+
+	remain = len - written;
+	if (sess->async_buf_size + remain > sess->async_buf_alloc) {
+		sess->async_buf_alloc = sess->async_buf_size+remain;
+		sess->async_buf = gf_realloc(sess->async_buf, sess->async_buf_alloc);
+		if (!sess->async_buf) return GF_OUT_OF_MEM;
+	}
+	memcpy(sess->async_buf + sess->async_buf_size, data+written, remain);
+	sess->async_buf_size += remain;
+	return GF_OK;
+}
+
 GF_EXPORT
 GF_Err gf_rtsp_session_write_interleaved(GF_RTSPSession *sess, u32 idx, u8 *pck, u32 pck_size)
 {
@@ -742,9 +1084,76 @@
 	streamID2 = (pck_size>>8) & 0xFF;
 	streamID3 = pck_size & 0xFF;
 
-	e = gf_sk_send_wait(sess->connection, streamID, 4, 20);
-	e |= gf_sk_send_wait(sess->connection, pck, pck_size, 20);
+	e = gf_rtsp_write_sock(sess, streamID, 4);
+	e |= gf_rtsp_write_sock(sess, pck, pck_size);
 	return e;
 }
 
+
+static GF_Err gf_rstp_flush_buffer(GF_RTSPSession *sess)
+{
+	while (sess->async_buf_size) {
+		u32 written = 0;
+		GF_Err e = rstp_do_write_sock(sess, (sess->tunnel_mode==RTSP_HTTP_CLIENT) ? sess->http : sess->connection, sess->async_buf, sess->async_buf_size, &written);
+		if (e) {
+			if (e!= GF_IP_NETWORK_EMPTY)
+				sess->async_buf_size = 0;
+			return e;
+		}
+		if (written==sess->async_buf_size) {
+			sess->async_buf_size = 0;
+			return GF_OK;
+		}
+		memmove(sess->async_buf, sess->async_buf + written, sess->async_buf_size - written);
+		sess->async_buf_size -= written;
+	}
+	return GF_OK;
+}
+
+const char *gf_rtsp_get_session_cookie(GF_RTSPSession *sess)
+{
+	return sess ? sess->HTTP_Cookie : NULL;
+}
+
+GF_Err gf_rtsp_merge_tunnel(GF_RTSPSession *sess, GF_RTSPSession *post_sess)
+{
+	if (!sess || !post_sess) return GF_BAD_PARAM;
+	if (!sess->HTTP_Cookie || !post_sess->HTTP_Cookie) return GF_BAD_PARAM;
+	if (strcmp(sess->HTTP_Cookie, post_sess->HTTP_Cookie)) return GF_BAD_PARAM;
+	if (!post_sess->connection) return GF_BAD_PARAM;
+
+	//move any pending data
+	if (post_sess->CurrentPos<post_sess->CurrentSize) {
+		u8 *buf = post_sess->tcp_buffer + post_sess->CurrentPos;
+		u32 remain = post_sess->CurrentSize - post_sess->CurrentPos;
+		if (sess->CurrentSize + remain > sess->SockBufferSize) {
+			sess->SockBufferSize = sess->CurrentSize + remain;
+			sess->tcp_buffer = gf_realloc(sess->tcp_buffer, sess->SockBufferSize);
+			if (!sess->tcp_buffer) return GF_OUT_OF_MEM;
+		}
+		memcpy(sess->tcp_buffer+sess->CurrentPos, buf, remain);
+		sess->CurrentSize += remain;
+	}
+	sess->tunnel_mode = RTSP_HTTP_SERVER;
+	sess->http = post_sess->connection;
+	post_sess->connection = NULL;
+
+#ifdef GPAC_HAS_SSL
+	sess->ssl_http = post_sess->ssl;
+	post_sess->ssl = NULL;
+#endif
+
+	return GF_OK;
+}
+
+const char *gf_rtsp_get_user(GF_RTSPSession *sess)
+{
+	return sess ? sess->User : NULL;
+}
+const char *gf_rtsp_get_password(GF_RTSPSession *sess)
+{
+	return sess ? sess->Pass : NULL;
+}
+
+
 #endif /*GPAC_DISABLE_STREAMING*/

gpac-2.0.0.tar.gz/src/ietf/sdp.c -> gpac-2.2.0.tar.gz/src/ietf/sdp.c Changed

gpac-2.0.0.tar.gz/src/isomedia/avc_ext.c -> gpac-2.2.0.tar.gz/src/isomedia/avc_ext.c Changed

@@ -397,7 +397,6 @@
 	}
 }
 
-
 GF_Err gf_isom_nalu_sample_rewrite(GF_MediaBox *mdia, GF_ISOSample *sample, u32 sampleNumber, GF_MPEGVisualSampleEntryBox *entry)
 {
 	Bool is_hevc = GF_FALSE;
@@ -417,6 +416,10 @@
 	GF_ISOFile *file = mdia->mediaTrack->moov->mov;
 	GF_TrackReferenceTypeBox *scal = NULL;
 
+	if (mdia->in_nalu_rewrite)
+		return GF_ISOM_INVALID_FILE;
+	mdia->in_nalu_rewrite = GF_TRUE;
+
 	Track_FindRef(mdia->mediaTrack, GF_ISOM_REF_SCAL, &scal);
 
 	rewrite_ps = (mdia->mediaTrack->extractor_mode & GF_ISOM_NALU_EXTRACT_INBAND_PS_FLAG) ? GF_TRUE : GF_FALSE;
@@ -448,10 +451,14 @@
 
 						if (!mdia->extracted_samp) {
 							mdia->extracted_samp = gf_isom_sample_new();
-							if (!mdia->extracted_samp) return GF_OUT_OF_MEM;
+							if (!mdia->extracted_samp) {
+									mdia->in_nalu_rewrite = GF_FALSE;
+									return GF_OUT_OF_MEM;
+							}
 						}
 
 						base_samp = gf_isom_get_sample_ex(mdia->mediaTrack->moov->mov, ref_track, sampleNumber + mdia->mediaTrack->sample_count_at_seg_start, &di, mdia->extracted_samp, NULL);
+						//base sample may be null (track split)
 						if (base_samp && base_samp->data) {
 							if (!sample->alloc_size || (sample->alloc_size<sample->dataLength+base_samp->dataLength) ) {
 								sample->data = gf_realloc(sample->data, sample->dataLength+base_samp->dataLength);
@@ -477,10 +484,14 @@
 
 				if (!mdia->extracted_samp) {
 					mdia->extracted_samp = gf_isom_sample_new();
-					if (!mdia->extracted_samp) return GF_OUT_OF_MEM;
+					if (!mdia->extracted_samp) {
+						mdia->in_nalu_rewrite = GF_FALSE;
+						return GF_OUT_OF_MEM;
+					}
 				}
 
 				tile_samp = gf_isom_get_sample_ex(mdia->mediaTrack->moov->mov, ref_track, sampleNumber + mdia->mediaTrack->sample_count_at_seg_start, &di, mdia->extracted_samp, NULL);
+				//tile sample may be NULL (removal of tracks, ...)
 				if (tile_samp && tile_samp ->data) {
 					if (!sample->alloc_size || (sample->alloc_size<sample->dataLength+tile_samp->dataLength) ) {
 						sample->data = gf_realloc(sample->data, sample->dataLength+tile_samp->dataLength);
@@ -489,7 +500,7 @@
 					memcpy(sample->data + sample->dataLength, tile_samp->data, tile_samp->dataLength);
 					sample->dataLength += tile_samp->dataLength;
 				}
-			}
+ 			}
 		}
 	}
 
@@ -514,15 +525,19 @@
 	if (extractor_mode != GF_ISOM_NALU_EXTRACT_LAYER_ONLY)
 		insert_vdrd_code = GF_FALSE;
 
-	if (!entry) return GF_BAD_PARAM;
-
+	if (!entry) {
+		mdia->in_nalu_rewrite = GF_FALSE;
+		return GF_BAD_PARAM;
+	}
 	//this is a compatible HEVC, don't insert VDRD, insert NALU delim
 	if (entry->lhvc_config && entry->hevc_config)
 		insert_vdrd_code = GF_FALSE;
 
 	if (extractor_mode == GF_ISOM_NALU_EXTRACT_INSPECT) {
-		if (!rewrite_ps && !rewrite_start_codes)
+		if (!rewrite_ps && !rewrite_start_codes) {
+			mdia->in_nalu_rewrite = GF_FALSE;
 			return GF_OK;
+		}
 	}
 
 	nal_unit_size_field = 0;
@@ -541,6 +556,7 @@
 
 	/*otherwise do nothing*/
 	else if (!rewrite_ps && !rewrite_start_codes && !scal && !force_sei_inspect) {
+		mdia->in_nalu_rewrite = GF_FALSE;
 		return GF_OK;
 	}
 
@@ -557,8 +573,10 @@
 		}
 	}
 
-	if (!nal_unit_size_field) return GF_ISOM_INVALID_FILE;
-
+	if (!nal_unit_size_field) {
+		mdia->in_nalu_rewrite = GF_FALSE;
+		return GF_ISOM_INVALID_FILE;
+	}
 	//setup PS rewriter
 	if (!mdia->nalu_ps_bs)
 		mdia->nalu_ps_bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
@@ -573,10 +591,16 @@
 
 	if (!mdia->nalu_parser) {
 		mdia->nalu_parser = gf_bs_new(mdia->in_sample_buffer, sample->dataLength, GF_BITSTREAM_READ);
-		if (!mdia->nalu_parser && sample->data) return GF_ISOM_INVALID_FILE;
+		if (!mdia->nalu_parser && sample->data) {
+			mdia->in_nalu_rewrite = GF_FALSE;
+			return GF_ISOM_INVALID_FILE;
+		}
 	} else {
 		e = gf_bs_reassign_buffer(mdia->nalu_parser, mdia->in_sample_buffer, sample->dataLength);
-		if (e) return e;
+		if (e) {
+			mdia->in_nalu_rewrite = GF_FALSE;
+			return e;
+		}
 	}
 	//setup output
 	if (!mdia->nalu_out_bs) {
@@ -664,7 +688,7 @@
 				}
 				gf_bs_write_data(mdia->nalu_out_bs, mdia->in_sample_buffer, sample->dataLength);
 				gf_bs_get_content_no_truncate(mdia->nalu_out_bs, &sample->data, &sample->dataLength, &sample->alloc_size);
-
+				mdia->in_nalu_rewrite = GF_FALSE;
 				return GF_OK;
 			}
 		}
@@ -680,6 +704,7 @@
 		}
 		gf_bs_write_data(mdia->nalu_out_bs, mdia->in_sample_buffer, sample->dataLength);
 		gf_bs_get_content_no_truncate(mdia->nalu_out_bs, &sample->data, &sample->dataLength, &sample->alloc_size);
+		mdia->in_nalu_rewrite = GF_FALSE;
 		return GF_OK;
 	}
 
@@ -758,6 +783,7 @@
 				if (check_cra_bla && !sample->IsRAP) {
 					sample->IsRAP = sap_type_from_nal_type(nal_type);
 					if (sei_suffix_bs) gf_bs_del(sei_suffix_bs);
+					mdia->in_nalu_rewrite = GF_FALSE;
 					return gf_isom_nalu_sample_rewrite(mdia, sample, sampleNumber, entry);
 				}
 			default:
@@ -841,6 +867,7 @@
 	if (sei_suffix_bs)
 		gf_bs_del(sei_suffix_bs);
 
+	mdia->in_nalu_rewrite = GF_FALSE;
 	return e;
 }
 
@@ -1475,15 +1502,8 @@
 	GF_DOVIDecoderConfigurationRecord* out = NULL;
 	GF_SAFEALLOC(out, GF_DOVIDecoderConfigurationRecord);
 	if (!out) return NULL;
-
-	out->dv_version_major = cfg->dv_version_major;
-	out->dv_version_minor = cfg->dv_version_minor;
-	out->dv_profile = cfg->dv_profile;
-	out->dv_level = cfg->dv_level;
-	out->rpu_present_flag = cfg->rpu_present_flag;
-	out->el_present_flag = cfg->el_present_flag;
-	out->bl_present_flag = cfg->bl_present_flag;
-
+	memcpy(out, cfg, sizeof(GF_DOVIDecoderConfigurationRecord));
+	out->force_dv=0;
 	return out;
 }
 
@@ -2458,7 +2478,7 @@
 	entry = (GF_MPEGVisualSampleEntryBox*)gf_list_get(trak->Media->information->sampleTable->SampleDescription->child_boxes, DescriptionIndex - 1);
 	if (!entry) return NULL;
 	if (entry->internal_type != GF_ISOM_SAMPLE_ENTRY_VIDEO) return NULL;
-	if (!entry->av1_config|| !entry->av1_config->config) return NULL;
+	if (!entry->av1_config || !entry->av1_config->config) return NULL;
 	return AV1_DuplicateConfig(entry->av1_config->config);
 }
 
@@ -2487,7 +2507,7 @@
 	entry = (GF_MPEGVisualSampleEntryBox*)gf_list_get(trak->Media->information->sampleTable->SampleDescription->child_boxes, DescriptionIndex - 1);
 	if (!entry) return NULL;
 	if (entry->internal_type != GF_ISOM_SAMPLE_ENTRY_VIDEO) return NULL;
-	if (!entry->size || !entry->dovi_config) return NULL;
+	if (!entry->dovi_config) return NULL;
 	return DOVI_DuplicateConfig(&entry->dovi_config->DOVIConfig);
 }
 
@@ -3523,6 +3543,11 @@
 			op->layers_infoj.layer_id = gf_bs_read_int(bs, 6);
 			op->layers_infoj.is_outputlayer = gf_bs_read_int(bs, 1) ? GF_TRUE : GF_FALSE;
 			op->layers_infoj.is_alternate_outputlayer = gf_bs_read_int(bs, 1) ? GF_TRUE : GF_FALSE;
+
+			if (gf_bs_is_overflow(bs)) {
+				gf_free(op);
+				return GF_NON_COMPLIANT_BITSTREAM;
+			}
 		}
 		op->minPicWidth = gf_bs_read_u16(bs);
 		op->minPicHeight = gf_bs_read_u16(bs);
@@ -3542,6 +3567,10 @@
 			op->maxBitRate = gf_bs_read_u32(bs);
 			op->avgBitRate = gf_bs_read_u32(bs);
 		}
+		if (gf_bs_is_overflow(bs)) {
+			gf_free(op);
+			return GF_NON_COMPLIANT_BITSTREAM;
+		}
 		gf_list_add(ptr->operating_points, op);
 	}
 	count = gf_bs_read_u8(bs);
@@ -3561,6 +3590,10 @@
 			if (ptr->scalability_mask & (1 << j))
 				dep->dimension_identifierj = gf_bs_read_u8(bs);
 		}
+		if (gf_bs_is_overflow(bs)) {
+			gf_free(dep);
+			return GF_NON_COMPLIANT_BITSTREAM;
+		}
 		gf_list_add(ptr->dependency_layers, dep);
 	}

gpac-2.0.0.tar.gz/src/isomedia/box_code_3gpp.c -> gpac-2.2.0.tar.gz/src/isomedia/box_code_3gpp.c Changed

@@ -1046,8 +1046,8 @@
 
 GF_Err dimC_box_read(GF_Box *s, GF_BitStream *bs)
 {
-	char str1024;
-	u32 i;
+	GF_Err e;
+	u32 i, msize;
 	GF_DIMSSceneConfigBox *p = (GF_DIMSSceneConfigBox *)s;
 
 	ISOM_DECREASE_SIZE(p, 3);
@@ -1058,28 +1058,47 @@
 	p->streamType = gf_bs_read_int(bs, 1);
 	p->containsRedundant = gf_bs_read_int(bs, 2);
 
+	char *str = gf_malloc( (size_t) (p->size+1));
+	if (!str) return GF_OUT_OF_MEM;
+	msize = (u32) p->size;
+	strmsize = 0;
 	i=0;
 	str0=0;
-	while (i < GF_ARRAY_LENGTH(str)) {
+	while (i < msize) {
+		ISOM_DECREASE_SIZE_GOTO_EXIT(p, 1);
 		stri = gf_bs_read_u8(bs);
 		if (!stri) break;
 		i++;
 	}
-	ISOM_DECREASE_SIZE(p, i);
+	if (i == msize) {
+		gf_free(str);
+		return GF_ISOM_INVALID_FILE;
+	}
 
 	p->textEncoding = gf_strdup(str);
 
 	i=0;
 	str0=0;
-	while (i < GF_ARRAY_LENGTH(str)) {
+	while (i < msize) {
+		ISOM_DECREASE_SIZE_GOTO_EXIT(p, 1);
 		stri = gf_bs_read_u8(bs);
 		if (!stri) break;
 		i++;
 	}
-	ISOM_DECREASE_SIZE(p, i);
+	if (i == msize) {
+		gf_free(str);
+		return GF_ISOM_INVALID_FILE;
+	}
 
 	p->contentEncoding = gf_strdup(str);
+	gf_free(str);
+	if (!p->textEncoding || !p->contentEncoding)
+		return GF_OUT_OF_MEM;
 	return GF_OK;
+
+exit:
+	gf_free(str);
+	return e;
 }
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
@@ -1128,20 +1147,12 @@
 
 GF_Err diST_box_read(GF_Box *s, GF_BitStream *bs)
 {
-	u32 i;
-	char str1024;
 	GF_DIMSScriptTypesBox *p = (GF_DIMSScriptTypesBox *)s;
 
-	i=0;
-	str0=0;
-	while (1) {
-		stri = gf_bs_read_u8(bs);
-		if (!stri) break;
-		i++;
-	}
-	ISOM_DECREASE_SIZE(p, i);
-
-	p->content_script_types = gf_strdup(str);
+	p->content_script_types = gf_malloc(sizeof(u8) * ((u32) s->size + 1));
+	if (!p->content_script_types) return GF_OUT_OF_MEM;
+	gf_bs_read_data(bs, p->content_script_types, (u32) s->size);
+	p->content_script_typess->size = 0;
 	return GF_OK;
 }

gpac-2.0.0.tar.gz/src/isomedia/box_code_adobe.c -> gpac-2.2.0.tar.gz/src/isomedia/box_code_adobe.c Changed

@@ -138,7 +138,7 @@
 			goto exit;
 		}
 		if (j) {
-			gf_list_insert(ptr->server_entry_table, gf_strdup(tmp_str), i);
+			gf_list_add(ptr->server_entry_table, gf_strdup(tmp_str));
 		}
 	}
 	if (ptr->server_entry_count != gf_list_count(ptr->server_entry_table)) {
@@ -168,7 +168,7 @@
 			goto exit;
 		}
 		if (j) {
-			gf_list_insert(ptr->quality_entry_table, gf_strdup(tmp_str), i);
+			gf_list_add(ptr->quality_entry_table, gf_strdup(tmp_str));
 		}
 	}
 	if (ptr->quality_entry_count != gf_list_count(ptr->quality_entry_table)) {
@@ -408,7 +408,7 @@
 	for (i=0; i<ptr->entry_count; i++) {
 		GF_AfraEntry *ae = gf_malloc(sizeof(GF_AfraEntry));
 		if (!ae) return GF_OUT_OF_MEM;
-		gf_list_insert(ptr->local_access_entries, ae, i);
+		gf_list_add(ptr->local_access_entries, ae);
 
 		ISOM_DECREASE_SIZE(ptr, 8)
 		ae->time = gf_bs_read_u64(bs);
@@ -427,7 +427,7 @@
 		for (i=0; i<ptr->global_entry_count; i++) {
 			GF_GlobalAfraEntry *ae = gf_malloc(sizeof(GF_GlobalAfraEntry));
 			if (!ae) return GF_OUT_OF_MEM;
-			gf_list_insert(ptr->global_access_entries, ae, i);
+			gf_list_add(ptr->global_access_entries, ae);
 
 			ISOM_DECREASE_SIZE(ptr, 8)
 			ae->time = gf_bs_read_u64(bs);
@@ -565,6 +565,7 @@
 		if (!tmp_strsize) return GF_ISOM_INVALID_FILE;
 		char *tmp_str = (char*) gf_malloc(tmp_strsize+1);
 		if (!tmp_str) return GF_OUT_OF_MEM;
+		gf_list_add(ptr->quality_segment_url_modifiers, tmp_str);
 		tmp_strtmp_strsize=0;
 		while (tmp_strsize) {
 			tmp_strj = gf_bs_read_u8(bs);
@@ -574,7 +575,6 @@
 				break;
 			j++;
 		}
-		gf_list_insert(ptr->quality_segment_url_modifiers, tmp_str, i);
 	}
 
 	ISOM_DECREASE_SIZE(ptr, 4)
@@ -585,10 +585,10 @@
 	for (i=0; i<ptr->segment_run_entry_count; i++) {
 		GF_AdobeSegmentRunEntry *sre = gf_malloc(sizeof(GF_AdobeSegmentRunEntry));
 		if (!sre) return GF_OUT_OF_MEM;
+		gf_list_add(ptr->segment_run_entry_table, sre);
 		ISOM_DECREASE_SIZE(ptr, 8)
 		sre->first_segment = gf_bs_read_u32(bs);
 		sre->fragment_per_segment = gf_bs_read_u32(bs);
-		gf_list_insert(ptr->segment_run_entry_table, sre, i);
 	}
 
 	return GF_OK;
@@ -686,6 +686,7 @@
 		if (!tmp_strsize) return GF_ISOM_INVALID_FILE;
 		char *tmp_str = (char*) gf_malloc(tmp_strsize+1);
 		if (!tmp_str) return GF_OUT_OF_MEM;
+		gf_list_add(ptr->quality_segment_url_modifiers, tmp_str);
 		tmp_strtmp_strsize=0;
 		while (tmp_strsize) {
 			tmp_strj = gf_bs_read_u8(bs);
@@ -695,7 +696,6 @@
 				break;
 			j++;
 		}
-		gf_list_insert(ptr->quality_segment_url_modifiers, tmp_str, i);
 	}
 
 	ISOM_DECREASE_SIZE(ptr, 4)
@@ -705,6 +705,7 @@
 	for (i=0; i<ptr->fragment_run_entry_count; i++) {
 		GF_AdobeFragmentRunEntry *fre = gf_malloc(sizeof(GF_AdobeFragmentRunEntry));
 		if (!fre) return GF_OUT_OF_MEM;
+		gf_list_add(ptr->fragment_run_entry_table, fre);
 		ISOM_DECREASE_SIZE(ptr, 16)
 		fre->first_fragment = gf_bs_read_u32(bs);
 		fre->first_fragment_timestamp = gf_bs_read_u64(bs);
@@ -713,7 +714,6 @@
 			ISOM_DECREASE_SIZE(ptr, 1)
 			fre->discontinuity_indicator = gf_bs_read_u8(bs);
 		}
-		gf_list_insert(ptr->fragment_run_entry_table, fre, i);
 	}
 
 	return GF_OK;

gpac-2.0.0.tar.gz/src/isomedia/box_code_apple.c -> gpac-2.2.0.tar.gz/src/isomedia/box_code_apple.c Changed

@@ -44,7 +44,7 @@
 		/*if no ilst type coded, break*/
 		sub_type = gf_bs_peek_bits(bs, 32, 0);
 		if (sub_type) {
-			e = gf_isom_box_parse_ex(&a, bs, s->type, GF_FALSE);
+			e = gf_isom_box_parse_ex(&a, bs, s->type, GF_FALSE, s->size);
 
 			/* the macro will return in this case before we can free */
 			if (!e && ptr->size < a->size) {
@@ -364,7 +364,7 @@
 
 #endif /*GPAC_DISABLE_ISOM_WRITE*/
 
-GF_Box *gf_isom_get_meta_extensions(GF_ISOFile *mov, Bool for_xtra)
+GF_Box *gf_isom_get_meta_extensions(GF_ISOFile *mov, u32 meta_type)
 {
 	u32 i;
 	GF_UserDataMap *map;
@@ -372,26 +372,31 @@
 	if (!mov || !mov->moov) return NULL;
 
 	if (!mov->moov->udta) return NULL;
-	map = udta_getEntry(mov->moov->udta, for_xtra ? GF_ISOM_BOX_TYPE_XTRA : GF_ISOM_BOX_TYPE_META, NULL);
+	map = udta_getEntry(mov->moov->udta, (meta_type==1) ? GF_ISOM_BOX_TYPE_XTRA : GF_ISOM_BOX_TYPE_META, NULL);
 	if (!map) return NULL;
 
 	for(i = 0; i < gf_list_count(map->boxes); i++) {
 		GF_MetaBox *meta = (GF_MetaBox*)gf_list_get(map->boxes, i);
-		if (for_xtra && (meta->type==GF_ISOM_BOX_TYPE_XTRA)) return (GF_Box *) meta;
+		if ((meta_type==1) && (meta->type==GF_ISOM_BOX_TYPE_XTRA)) return (GF_Box *) meta;
 
-		if(meta != NULL && meta->handler != NULL && meta->handler->handlerType == GF_ISOM_HANDLER_TYPE_MDIR) return (GF_Box *) meta;
+		if (meta && meta->handler) {
+			if ( (meta_type==0) && (meta->handler->handlerType == GF_ISOM_HANDLER_TYPE_MDIR))
+				return (GF_Box *) meta;
+			if ( (meta_type==2) && (meta->handler->handlerType == GF_ISOM_HANDLER_TYPE_MDTA))
+				return (GF_Box *) meta;
+		}
 	}
 	return NULL;
 }
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
-GF_Box *gf_isom_create_meta_extensions(GF_ISOFile *mov, Bool for_xtra)
+GF_Box *gf_isom_create_meta_extensions(GF_ISOFile *mov, u32 meta_type)
 {
 	GF_Err e;
 	u32 i;
 	GF_MetaBox *meta;
 	GF_UserDataMap *map;
-	u32 udta_subtype = for_xtra ? GF_ISOM_BOX_TYPE_XTRA : GF_ISOM_BOX_TYPE_META;
+	u32 udta_subtype = (meta_type==1) ? GF_ISOM_BOX_TYPE_XTRA : GF_ISOM_BOX_TYPE_META;
 
 	if (!mov || !mov->moov) return NULL;
 
@@ -404,9 +409,12 @@
 	if (map) {
 		for (i=0; i<gf_list_count(map->boxes); i++) {
 			meta = (GF_MetaBox*)gf_list_get(map->boxes, i);
-			if (for_xtra) return (GF_Box *) meta;
+			if (meta_type==1) return (GF_Box *) meta;
 
-			if (meta && meta->handler && (meta->handler->handlerType == GF_ISOM_HANDLER_TYPE_MDIR)) return (GF_Box *) meta;
+			if (meta && meta->handler) {
+				if ((meta_type==0) && (meta->handler->handlerType == GF_ISOM_HANDLER_TYPE_MDIR)) return (GF_Box *) meta;
+				if ((meta_type==2) && (meta->handler->handlerType == GF_ISOM_HANDLER_TYPE_MDTA)) return (GF_Box *) meta;
+			}
 		}
 	}
 
@@ -415,13 +423,13 @@
 
 	if (meta) {
 		udta_on_child_box((GF_Box *)mov->moov->udta, (GF_Box *)meta, GF_FALSE);
-		if (!for_xtra) {
+		if (meta_type!=1) {
 			meta->handler = (GF_HandlerBox *)gf_isom_box_new_parent(&meta->child_boxes, GF_ISOM_BOX_TYPE_HDLR);
 			if(meta->handler == NULL) {
 				gf_isom_box_del((GF_Box *)meta);
 				return NULL;
 			}
-			meta->handler->handlerType = GF_ISOM_HANDLER_TYPE_MDIR;
+			meta->handler->handlerType = (meta_type==2) ? GF_ISOM_HANDLER_TYPE_MDTA : GF_ISOM_HANDLER_TYPE_MDIR;
 			gf_isom_box_new_parent(&meta->child_boxes, GF_ISOM_BOX_TYPE_ILST);
 		}
 	}
@@ -973,4 +981,90 @@
 #endif /*GPAC_DISABLE_ISOM_WRITE*/
 
 
+void keys_box_del(GF_Box *s)
+{
+	GF_MetaKeysBox *ptr = (GF_MetaKeysBox *)s;
+	if (ptr == NULL) return;
+	while (gf_list_count(ptr->keys)) {
+		GF_MetaKey *k = gf_list_pop_back(ptr->keys);
+		if (k->data) gf_free(k->data);
+		gf_free(k);
+	}
+	gf_list_del(ptr->keys);
+	gf_free(ptr);
+}
+
+GF_Err keys_box_read(GF_Box *s, GF_BitStream *bs)
+{
+	u32 i, nb_keys;
+	GF_MetaKeysBox *ptr = (GF_MetaKeysBox *)s;
+
+	ISOM_DECREASE_SIZE(ptr, 4);
+	nb_keys = gf_bs_read_u32(bs);
+	for (i=0; i<nb_keys; i++) {
+		GF_MetaKey *k;
+		ISOM_DECREASE_SIZE(ptr, 8);
+		u32 ksize = gf_bs_read_u32(bs);
+		if (ksize<8) return GF_ISOM_INVALID_FILE;
+		u32 ns = gf_bs_read_u32(bs);
+		ISOM_DECREASE_SIZE(ptr, ksize-8);
+		GF_SAFEALLOC(k, GF_MetaKey);
+		if (!k) return GF_OUT_OF_MEM;
+		gf_list_add(ptr->keys, k);
+		k->ns = ns;
+		k->size = ksize-8;
+		k->data = gf_malloc(k->size+1);
+		if (!k->data) return GF_OUT_OF_MEM;
+		gf_bs_read_data(bs, k->data, k->size);
+		k->datak->size=0;
+	}
+	return GF_OK;
+}
+
+GF_Box *keys_box_new()
+{
+	ISOM_DECL_BOX_ALLOC(GF_MetaKeysBox, GF_ISOM_BOX_TYPE_KEYS);
+	tmp->keys = gf_list_new();
+	return (GF_Box *)tmp;
+}
+
+#ifndef GPAC_DISABLE_ISOM_WRITE
+
+GF_Err keys_box_write(GF_Box *s, GF_BitStream *bs)
+{
+	GF_Err e;
+	u32 i, nb_keys;
+	GF_MetaKeysBox *ptr = (GF_MetaKeysBox *)s;
+
+	e = gf_isom_full_box_write(s, bs);
+	if (e) return e;
+	nb_keys = gf_list_count(ptr->keys);
+	gf_bs_write_u32(bs, nb_keys);
+	for (i=0; i<nb_keys; i++) {
+		GF_MetaKey *k = gf_list_get(ptr->keys, i);
+		gf_bs_write_u32(bs, k->size+8);
+		gf_bs_write_u32(bs, k->ns);
+		if (k->data)
+			gf_bs_write_data(bs, k->data, k->size);
+	}
+	return GF_OK;
+}
+
+
+GF_Err keys_box_size(GF_Box *s)
+{
+	u32 i, nb_keys;
+	GF_MetaKeysBox *ptr = (GF_MetaKeysBox *)s;
+	ptr->size += 4;
+	nb_keys = gf_list_count(ptr->keys);
+	for (i=0; i<nb_keys; i++) {
+		GF_MetaKey *k = gf_list_get(ptr->keys, i);
+		if (!k->data) k->size = 0;
+		ptr->size += 8 + k->size;
+	}
+	return GF_OK;
+}
+
+#endif /*GPAC_DISABLE_ISOM_WRITE*/
+
 #endif /*GPAC_DISABLE_ISOM*/

gpac-2.0.0.tar.gz/src/isomedia/box_code_base.c -> gpac-2.2.0.tar.gz/src/isomedia/box_code_base.c Changed

@@ -412,7 +412,7 @@
 
 		if (ptr->max_cts_delta <= ABS(ptr->entriesi.decodingOffset)) {
 			ptr->max_cts_delta = ABS(ptr->entriesi.decodingOffset);
-			ptr->sample_num_max_cts_delta = sampleCount;
+			//ptr->sample_num_max_cts_delta = sampleCount;
 		}
 		sampleCount += ptr->entriesi.sampleCount;
 	}
@@ -815,6 +815,7 @@
 	u32 type;
 	GF_UnknownBox *ptr = (GF_UnknownBox *)s;
 	if (!s) return GF_BAD_PARAM;
+	if (ptr->original_4cc == GF_ISOM_BOX_TYPE_UUID) return GF_BAD_PARAM;
 	type = s->type;
 	ptr->type = ptr->original_4cc;
 	e = gf_isom_box_write_header(s, bs);
@@ -1526,6 +1527,7 @@
 	GF_GenericSampleEntryBox *ptr = (GF_GenericSampleEntryBox *)s;
 
 	//careful we are not writing the box type but the entry type so switch for write
+	if (ptr->EntryType == GF_ISOM_BOX_TYPE_UUID) return GF_BAD_PARAM;
 	ptr->type = ptr->EntryType;
 	e = gf_isom_box_write_header(s, bs);
 	if (e) return e;
@@ -1576,6 +1578,7 @@
 	GF_GenericVisualSampleEntryBox *ptr = (GF_GenericVisualSampleEntryBox *)s;
 
 	//careful we are not writing the box type but the entry type so switch for write
+	if (ptr->EntryType == GF_ISOM_BOX_TYPE_UUID) return GF_BAD_PARAM;
 	ptr->type = ptr->EntryType;
 	e = gf_isom_box_write_header(s, bs);
 	if (e) return e;
@@ -1627,6 +1630,7 @@
 	GF_GenericAudioSampleEntryBox *ptr = (GF_GenericAudioSampleEntryBox *)s;
 
 	//careful we are not writing the box type but the entry type so switch for write
+	if (ptr->EntryType == GF_ISOM_BOX_TYPE_UUID) return GF_BAD_PARAM;
 	ptr->type = ptr->EntryType;
 	e = gf_isom_box_write_header(s, bs);
 	if (e) return e;
@@ -1884,7 +1888,7 @@
 
 GF_Err hnti_box_read(GF_Box *s, GF_BitStream *bs)
 {
-	return gf_isom_box_array_read_ex(s, bs, s->type);
+	return gf_isom_box_array_read(s, bs);
 }
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
@@ -2916,6 +2920,12 @@
 {
 	GF_MediaDataBox *ptr = (GF_MediaDataBox *)s;
 	if (ptr == NULL) return GF_BAD_PARAM;
+	if (ptr->type==GF_ISOM_BOX_TYPE_IMDA) {
+		ptr->type = GF_ISOM_BOX_TYPE_MDAT;
+		ptr->is_imda = 1;
+		ISOM_DECREASE_SIZE(s, 4)
+		ptr->imda_id = gf_bs_read_u32(bs);
+	}
 
 	ptr->dataSize = s->size;
 	ptr->bsOffset = gf_bs_get_position(bs);
@@ -2946,8 +2956,16 @@
 {
 	GF_Err e;
 	GF_MediaDataBox *ptr = (GF_MediaDataBox *)s;
-	e = gf_isom_box_write_header(s, bs);
-	if (e) return e;
+	if (ptr->is_imda) {
+		s->type = GF_ISOM_BOX_TYPE_IMDA;
+		e = gf_isom_box_write_header(s, bs);
+		s->type = GF_ISOM_BOX_TYPE_MDAT;
+		if (e) return e;
+		gf_bs_write_u32(bs, ptr->imda_id);
+	} else {
+		e = gf_isom_box_write_header(s, bs);
+		if (e) return e;
+	}
 
 	//make sure we have some data ...
 	//if not, we handle that independently (edit files)
@@ -2961,6 +2979,8 @@
 {
 	GF_MediaDataBox *ptr = (GF_MediaDataBox *)s;
 	ptr->size += ptr->dataSize;
+	if (ptr->is_imda)
+		ptr->size += 4;
 	return GF_OK;
 }
 
@@ -4050,18 +4070,20 @@
 	for (i=0; i<size-8; i++) {
 		if (GF_4CC((u32)datai+4, (u8)datai+5, (u8)datai+6, (u8)datai+7) == GF_ISOM_BOX_TYPE_ESDS) {
 			GF_BitStream *mybs = gf_bs_new(data + i, size - i, GF_BITSTREAM_READ);
+			gf_bs_set_cookie(mybs, GF_ISOM_BS_COOKIE_NO_LOGS);
 			if (ptr->esd) gf_isom_box_del_parent(&ptr->child_boxes, (GF_Box *)ptr->esd);
 			ptr->esd = NULL;
 			e = gf_isom_box_parse((GF_Box **)&ptr->esd, mybs);
 			gf_bs_del(mybs);
 
-			if ((e==GF_OK) && (ptr->esd->type == GF_ISOM_BOX_TYPE_ESDS)) {
+			if ((e==GF_OK) && ptr->esd && (ptr->esd->type == GF_ISOM_BOX_TYPE_ESDS)) {
 				if (!ptr->child_boxes) ptr->child_boxes = gf_list_new();
 				gf_list_add(ptr->child_boxes, ptr->esd);
 			} else if (ptr->esd) {
 				gf_isom_box_del((GF_Box *)ptr->esd);
 				ptr->esd = NULL;
 			}
+			e = GF_OK;
 			break;
 		}
 	}
@@ -4104,6 +4126,7 @@
 		return GF_OK;
 
 	gf_isom_check_position(s, (GF_Box *)ptr->esd, &pos);
+	gf_isom_check_position(s, (GF_Box *)ptr->cfg_mha, &pos);
 	gf_isom_check_position(s, (GF_Box *)ptr->cfg_3gpp, &pos);
 	gf_isom_check_position(s, (GF_Box *)ptr->cfg_opus, &pos);
 	gf_isom_check_position(s, (GF_Box *)ptr->cfg_ac3, &pos);
@@ -5460,7 +5483,7 @@
 	ISOM_DECREASE_SIZE(s, 4)
 	gf_bs_read_u32(bs);
 
-	return gf_isom_box_array_read_ex(s, bs, GF_ISOM_BOX_TYPE_STSD);
+	return gf_isom_box_array_read(s, bs);
 }
 
 GF_Box *stsd_box_new()
@@ -5904,6 +5927,7 @@
 GF_Err stts_box_read(GF_Box *s, GF_BitStream *bs)
 {
 	u32 i;
+	Bool logged=GF_FALSE;
 	GF_TimeToSampleBox *ptr = (GF_TimeToSampleBox *)s;
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
@@ -5933,7 +5957,10 @@
 
 		if (!ptr->entriesi.sampleDelta) {
 			if ((i+1<ptr->nb_entries) ) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("iso file Found stts entry with sample_delta=0 - forbidden ! Fixing to 1\n" ));
+				if (!logged) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("iso file Found stts entry with sample_delta=0 - forbidden ! Fixing to 1\n" ));
+					logged=GF_TRUE;
+				}
 				ptr->entriesi.sampleDelta = 1;
 			} else if (ptr->entriesi.sampleCount>1) {
 				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("iso file more than one stts entry at the end of the track with sample_delta=0 - forbidden ! Fixing to 1\n" ));
@@ -6347,6 +6374,9 @@
 {
 	ISOM_DECL_BOX_ALLOC(GF_TrackFragmentBox, GF_ISOM_BOX_TYPE_TRAF);
 	tmp->TrackRuns = gf_list_new();
+
+	if (gf_sys_old_arch_compat())
+		tmp->no_sdtp_first_flags = 1;
 	return (GF_Box *)tmp;
 }
 
@@ -7142,7 +7172,7 @@
 
 GF_Err tref_box_read(GF_Box *s, GF_BitStream *bs)
 {
-	return gf_isom_box_array_read_ex(s, bs, s->type);
+	return gf_isom_box_array_read(s, bs);
 }
 
 GF_Box *tref_box_new()
@@ -7232,6 +7262,7 @@
 	GF_Err e;
 	u32 i;
 	GF_TrackReferenceTypeBox *ptr = (GF_TrackReferenceTypeBox *)s;
+	if (ptr->reference_type == GF_ISOM_BOX_TYPE_UUID) return GF_BAD_PARAM;
 	ptr->type = ptr->reference_type;
 	e = gf_isom_box_write_header(s, bs);
 	ptr->type = GF_ISOM_BOX_TYPE_REFT;
@@ -8099,6 +8130,19 @@
 		gf_list_del_item(map->boxes, a);
 		return GF_OK;
 	}
+	u32 i, count = gf_list_count(map->boxes);
+	for (i=0; i<count; i++) {
+		GF_Box *b = gf_list_get(map->boxes, i);
+		u32 btype = b->type;
+		if (b->type==GF_ISOM_BOX_TYPE_UNKNOWN) btype = ((GF_UnknownBox*)b)->original_4cc;
+		if (btype != box_type) continue;
+		if (box_type == GF_ISOM_BOX_TYPE_UUID) {
+			if (memcmp( ((GF_UUIDBox *)a)->uuid, ((GF_UUIDBox *)b)->uuid, 16)) continue;
+		}
+		gf_isom_box_del(b);
+		gf_list_rem(map->boxes, i);
+		break;
+	}
 	return gf_list_add(map->boxes, a);
 }
 
@@ -8526,10 +8570,14 @@
 	if (e) return e;
 	ISOM_DECREASE_SIZE(ptr, 8);
 
+	if (ptr->size > (u64)SIZE_MAX) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Invalid size "LLU" in metx\n", ptr->size));
+		return GF_ISOM_INVALID_FILE;
+	}
+
 	size = (u32) ptr->size;
 	str = gf_malloc(sizeof(char)*size);
 	if (!str) return GF_OUT_OF_MEM;
-
 	i=0;
 
 	while (size) {
@@ -8775,9 +8823,26 @@
 
 GF_Err dac3_box_read(GF_Box *s, GF_BitStream *bs)
 {
+	GF_Err e;
+	u64 pos;
 	GF_AC3ConfigBox *ptr = (GF_AC3ConfigBox *)s;
 	if (ptr == NULL) return GF_BAD_PARAM;
-	return gf_odf_ac3_config_parse_bs(bs, ptr->cfg.is_ec3, &ptr->cfg);
+	pos = gf_bs_get_position(bs);
+	e = gf_odf_ac3_config_parse_bs(bs, ptr->cfg.is_ec3, &ptr->cfg);
+	if (e) return e;
+	pos = gf_bs_get_position(bs) - pos;
+	ISOM_DECREASE_SIZE(ptr, pos);
+
+	if (ptr->size>=2) {
+		ptr->size-=2;
+		gf_bs_read_int(bs, 7);
+		ptr->cfg.atmos_ec3_ext = gf_bs_read_int(bs, 1);
+		ptr->cfg.complexity_index_type = gf_bs_read_u8(bs);
+	}
+	//the rest is reserved
+	gf_bs_skip_bytes(bs, ptr->size);
+	ptr->size = 0;
+	return GF_OK;
 }
 
 
@@ -8793,7 +8858,15 @@
 	if (ptr->cfg.is_ec3) s->type = GF_ISOM_BOX_TYPE_DAC3;
 	if (e) return e;
 	
-	return gf_odf_ac3_cfg_write_bs(&ptr->cfg, bs);
+	e = gf_odf_ac3_cfg_write_bs(&ptr->cfg, bs);
+	if (e) return e;
+
+	if (ptr->cfg.atmos_ec3_ext || ptr->cfg.complexity_index_type) {
+		gf_bs_write_int(bs, 0, 7);
+		gf_bs_write_int(bs, ptr->cfg.atmos_ec3_ext, 1);
+		gf_bs_write_u8(bs, ptr->cfg.complexity_index_type);
+	}
+	return GF_OK;
 }
 
 GF_Err dac3_box_size(GF_Box *s)
@@ -8811,6 +8884,9 @@
 	} else {
 		s->size += 3;
 	}
+	if (ptr->cfg.atmos_ec3_ext || ptr->cfg.complexity_index_type) {
+		s->size += 2;
+	}
 	return GF_OK;
 }
 
@@ -10554,7 +10630,7 @@
 
 GF_Err trgr_box_read(GF_Box *s, GF_BitStream *bs)
 {
-	return gf_isom_box_array_read_ex(s, bs, s->type);
+	return gf_isom_box_array_read(s, bs);
 }
 
 
@@ -10606,6 +10682,7 @@
 	GF_Err e;
 	GF_TrackGroupTypeBox *ptr = (GF_TrackGroupTypeBox *) s;
 	if (!s) return GF_BAD_PARAM;
+	if (ptr->group_type == GF_ISOM_BOX_TYPE_UUID) return GF_BAD_PARAM;
 	s->type = ptr->group_type;
 	e = gf_isom_full_box_write(s, bs);
 	s->type = GF_ISOM_BOX_TYPE_TRGT;
@@ -11759,7 +11836,7 @@
 }
 GF_Err jp2h_box_read(GF_Box *s,GF_BitStream *bs)
 {
-	return gf_isom_box_array_read_ex(s, bs, s->type);
+	return gf_isom_box_array_read(s, bs);
 }
 
 GF_Box *jp2h_box_new()
@@ -11880,11 +11957,16 @@
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("iso file dvcC reserved bits are not zero\n"));
 		}
 	}
-	if (ptr->DOVIConfig.dv_profile==8) {
-		if (!ptr->DOVIConfig.dv_bl_signal_compatibility_id || (ptr->DOVIConfig.dv_bl_signal_compatibility_id>2) ) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("iso file dvcC profile 8 but compatibility ID %d is not 1 or 2, patching to 2\n", ptr->DOVIConfig.dv_bl_signal_compatibility_id));
-			ptr->DOVIConfig.dv_bl_signal_compatibility_id = 2;
-		}
+	switch (ptr->DOVIConfig.dv_bl_signal_compatibility_id) {
+	case 0:
+	case 1:
+	case 2:
+	case 4:
+	case 6:
+		break;
+	default:
+		GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("iso file dvcC compatibility ID %d is not valid (only 0, 1, 2, 4 or 6 defined), patching to 0\n", ptr->DOVIConfig.dv_bl_signal_compatibility_id));
+		ptr->DOVIConfig.dv_bl_signal_compatibility_id = 0;
 	}
 	return GF_OK;
 }
@@ -11971,27 +12053,35 @@
 	if (ptr) gf_free(ptr);
 }
 
+//we don't use odf_opus_cfg read due to endianness
 GF_Err dOps_box_read(GF_Box *s, GF_BitStream *bs)
 {
 	GF_OpusSpecificBox *ptr = (GF_OpusSpecificBox *)s;
-	ptr->version = gf_bs_read_u8(bs);
-	ptr->OutputChannelCount = gf_bs_read_u8(bs);
-	ptr->PreSkip = gf_bs_read_u16(bs);
-	ptr->InputSampleRate = gf_bs_read_u32(bs);
-	ptr->OutputGain = gf_bs_read_u16(bs);
-	ptr->ChannelMappingFamily = gf_bs_read_u8(bs);
+	ptr->opcfg.version = gf_bs_read_u8(bs);
+	if (ptr->opcfg.version) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("IsoMedia Opus config version not 0 !\n", ptr->size));
+		return GF_NOT_SUPPORTED;
+	}
+	//force version to 1 as used in ogg/opus
+	ptr->opcfg.version = 1;
+	ptr->opcfg.OutputChannelCount = gf_bs_read_u8(bs);
+	ptr->opcfg.PreSkip = gf_bs_read_u16(bs);
+	ptr->opcfg.InputSampleRate = gf_bs_read_u32(bs);
+	ptr->opcfg.OutputGain = gf_bs_read_u16(bs);
+	ptr->opcfg.ChannelMappingFamily = gf_bs_read_u8(bs);
 	ISOM_DECREASE_SIZE(ptr, 11)
 	if (ptr->size) {
-		ISOM_DECREASE_SIZE(ptr, 2+ptr->OutputChannelCount);
-		ptr->StreamCount = gf_bs_read_u8(bs);
-		ptr->CoupledCount = gf_bs_read_u8(bs);
-		gf_bs_read_data(bs, (char *) ptr->ChannelMapping, ptr->OutputChannelCount);
+		ISOM_DECREASE_SIZE(ptr, 2+ptr->opcfg.OutputChannelCount);
+		ptr->opcfg.StreamCount = gf_bs_read_u8(bs);
+		ptr->opcfg.CoupledCount = gf_bs_read_u8(bs);
+		gf_bs_read_data(bs, (char *) ptr->opcfg.ChannelMapping, ptr->opcfg.OutputChannelCount);
 	}
 	return GF_OK;
 }
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
 
+//we don't use odf_opus_cfg write due to endianness
 GF_Err dOps_box_write(GF_Box *s, GF_BitStream *bs)
 {
 	GF_Err e;
@@ -11999,16 +12089,17 @@
 	if (!s) return GF_BAD_PARAM;
 	e = gf_isom_box_write_header(s, bs);
 	if (e) return e;
-	gf_bs_write_u8(bs, ptr->version);
-	gf_bs_write_u8(bs, ptr->OutputChannelCount);
-	gf_bs_write_u16(bs, ptr->PreSkip);
-	gf_bs_write_u32(bs, ptr->InputSampleRate);
-	gf_bs_write_u16(bs, ptr->OutputGain);
-	gf_bs_write_u8(bs, ptr->ChannelMappingFamily);
-	if (ptr->ChannelMappingFamily) {
-		gf_bs_write_u8(bs, ptr->StreamCount);
-		gf_bs_write_u8(bs, ptr->CoupledCount);
-		gf_bs_write_data(bs, (char *) ptr->ChannelMapping, ptr->OutputChannelCount);
+	//we always write 0 - the version may also be set to 1 when fed from ffenc or opus+ogg
+	gf_bs_write_u8(bs, /*ptr->opcfg.version*/ 0);
+	gf_bs_write_u8(bs, ptr->opcfg.OutputChannelCount);
+	gf_bs_write_u16(bs, ptr->opcfg.PreSkip);
+	gf_bs_write_u32(bs, ptr->opcfg.InputSampleRate);
+	gf_bs_write_u16(bs, ptr->opcfg.OutputGain);
+	gf_bs_write_u8(bs, ptr->opcfg.ChannelMappingFamily);
+	if (ptr->opcfg.ChannelMappingFamily) {
+		gf_bs_write_u8(bs, ptr->opcfg.StreamCount);
+		gf_bs_write_u8(bs, ptr->opcfg.CoupledCount);
+		gf_bs_write_data(bs, (char *) ptr->opcfg.ChannelMapping, ptr->opcfg.OutputChannelCount);
 	}
 	return GF_OK;
 }
@@ -12017,8 +12108,8 @@
 {
 	GF_OpusSpecificBox *ptr = (GF_OpusSpecificBox *)s;
 	ptr->size += 11;
-	if (ptr->ChannelMappingFamily)
-		ptr->size += 2 + ptr->OutputChannelCount;
+	if (ptr->opcfg.ChannelMappingFamily)
+		ptr->size += 2 + ptr->opcfg.OutputChannelCount;
 
 	return GF_OK;
 }
@@ -12585,7 +12676,8 @@
 	if (p->patterns) {
 		u32 i;
 		for (i=0; i<p->pattern_count; i++) {
-			gf_free(p->patternsi.sample_group_description_indices);
+			if (p->patternsi.sample_group_description_indices)
+				gf_free(p->patternsi.sample_group_description_indices);
 		}
 		gf_free(p->patterns);
 	}
@@ -12618,7 +12710,7 @@
 	index_size = get_size_by_code( (ptr->flags & 0x3) );
 
 	if (((pattern_size==4) && (scount_size!=4)) || ((pattern_size!=4) && (scount_size==4))) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file compact sample gorup pattern_size and sample_count_size mare not both 4 bits\n"));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file compact sample group pattern_size and sample_count_size mare not both 4 bits\n"));
 		return GF_ISOM_INVALID_FILE;
 	}
 
@@ -12632,13 +12724,15 @@
 
 
 	if ( (ptr->size / ( (pattern_size + scount_size) / 8 ) < ptr->pattern_count) || (u64)ptr->pattern_count > (u64)SIZE_MAX/sizeof(GF_CompactSampleGroupPattern) ) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file compact sample gorup pattern_count value (%lu) invalid\n", ptr->pattern_count));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file compact sample group pattern_count value (%lu) invalid\n", ptr->pattern_count));
 		return GF_ISOM_INVALID_FILE;
 	}
 
 	ptr->patterns = gf_malloc(sizeof(GF_CompactSampleGroupPattern) * ptr->pattern_count);
 	if (!ptr->patterns) return GF_OUT_OF_MEM;
+	memset(ptr->patterns, 0, sizeof(GF_CompactSampleGroupPattern) * ptr->pattern_count);
 
+	u64 patterns_sizes=0;
 	bits = 0;
 	for (i=0; i<ptr->pattern_count; i++) {
 		ptr->patternsi.length = gf_bs_read_int(bs, pattern_size);
@@ -12649,8 +12743,15 @@
 			ISOM_DECREASE_SIZE(ptr, bits);
 			bits=0;
 		}
+		patterns_sizes+=ptr->patternsi.length;
+		if (patterns_sizes * index_size > ptr->size*8) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file compact sample group pattern cumulated sizes "LLU" larger than box size "LLU"\n", patterns_sizes, ptr->size));
+			ptr->patternsi.sample_group_description_indices = NULL;
+			return GF_ISOM_INVALID_FILE;
+		}
+
 		if ( (u64)ptr->patternsi.length > (u64)SIZE_MAX/sizeof(u32) ) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file compact sample gorup pattern #%d value (%lu) invalid\n", i, ptr->patternsi.length));
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file compact sample group pattern #%d value (%lu) invalid\n", i, ptr->patternsi.length));
 			ptr->patternsi.sample_group_description_indices = NULL;
 			return GF_ISOM_INVALID_FILE;
 		}
@@ -12854,8 +12955,12 @@
 			prop_type = gf_bs_read_u16(bs);
 			prop_size -= 6;
 			ISOM_DECREASE_SIZE_NO_ERR(ptr, prop_size)
-			data2 = gf_malloc(sizeof(char) * (prop_size));
+			//add 3 extra bytes for UTF16 case string dump (3 because we need 0-aligned short value)
+			data2 = gf_malloc(sizeof(char) * (prop_size+3));
 			gf_bs_read_data(bs, data2, prop_size);
+			data2prop_size = 0;
+			data2prop_size+1 = 0;
+			data2prop_size+2 = 0;
 			tag_size-=prop_size;
 		} else {
 			prop_size = 0;

gpac-2.0.0.tar.gz/src/isomedia/box_code_drm.c -> gpac-2.2.0.tar.gz/src/isomedia/box_code_drm.c Changed

gpac-2.0.0.tar.gz/src/isomedia/box_code_meta.c -> gpac-2.2.0.tar.gz/src/isomedia/box_code_meta.c Changed

@@ -95,20 +95,47 @@
 	case GF_ISOM_BOX_TYPE_GRPL:
 		BOX_FIELD_ASSIGN(groups_list, GF_GroupListBox)
 		break;
+	case GF_ISOM_BOX_TYPE_KEYS:
+		BOX_FIELD_ASSIGN(keys, GF_MetaKeysBox)
+		ptr->keys->meta = ptr;
+		break;
 	}
 	return GF_OK;
 }
 
 GF_Err meta_box_read(GF_Box *s, GF_BitStream *bs)
 {
+	GF_MetaBox *ptr = (GF_MetaBox *)s;
 	u64 pos = gf_bs_get_position(bs);
 	u64 size = s->size;
-	GF_Err e = gf_isom_box_array_read(s, bs);
-	/*try to hack around QT files which don't use a full box for meta, rewind 4 bytes*/
-	if (e && (pos>4) ) {
-		gf_bs_seek(bs, pos-4);
+	//probe 4->8 bytes, if equal to one of the following this is a QT meta
+	u32 qt_type = (pos>8) ? gf_bs_peek_bits(bs, 32, 4) : 0;
+	switch (qt_type) {
+	case GF_4CC('h', 'd', 'l', 'r'):
+	case GF_4CC('m', 'h', 'd', 'r'):
+	case GF_4CC('k', 'e', 'y', 's'):
+	case GF_4CC('i', 'l', 's', 't'):
+	case GF_4CC('c', 't', 'r', 'y'):
+	case GF_4CC('l', 'a', 'n', 'g'):
+		break;
+	default:
+		qt_type = 0;
+		break;
+	}
+	GF_Err e = GF_EOS;
+	if (!qt_type) {
+		ISOM_DECREASE_SIZE(s, 4)
+		ptr->version = gf_bs_read_u8(bs);
+		ptr->flags = gf_bs_read_u24(bs);
+		e = gf_isom_box_array_read(s, bs);
+	}
+
+	/*try to hack around QT files which don't use a full box for meta, reparse*/
+	if (e && (pos>8) ) {
+		gf_bs_seek(bs, pos);
 		meta_reset(s);
 		s->size = size+4;
+		ptr->is_qt = GF_TRUE;
 		e = gf_isom_box_array_read(s, bs);
 	}
 	return e;
@@ -117,6 +144,10 @@
 #ifndef GPAC_DISABLE_ISOM_WRITE
 GF_Err meta_box_write(GF_Box *s, GF_BitStream *bs)
 {
+	GF_MetaBox *ptr = (GF_MetaBox *)s;
+	if (ptr->write_qt) {
+		return gf_isom_box_write_header(s, bs);
+	}
 	return gf_isom_full_box_write(s, bs);
 }
 
@@ -134,6 +165,10 @@
 	gf_isom_check_position(s, (GF_Box *)ptr->item_refs, &pos);
 	gf_isom_check_position(s, (GF_Box *)ptr->item_props, &pos);
 	gf_isom_check_position(s, (GF_Box *)ptr->groups_list, &pos);
+	gf_isom_check_position(s, (GF_Box *)ptr->keys, &pos);
+
+	if (!ptr->write_qt)
+		s->size+=4;
 	return GF_OK;
 }
 #endif /*GPAC_DISABLE_ISOM_WRITE*/
@@ -774,7 +809,7 @@
 
 GF_Err iref_box_read(GF_Box *s, GF_BitStream *bs)
 {
-	return gf_isom_box_array_read_ex(s, bs, s->type);
+	return gf_isom_box_array_read(s, bs);
 }
 
 GF_Box *iref_box_new()

gpac-2.0.0.tar.gz/src/isomedia/box_dump.c -> gpac-2.2.0.tar.gz/src/isomedia/box_dump.c Changed

@@ -66,6 +66,7 @@
 static void dump_data_string(FILE *trace, char *data, u32 dataLength)
 {
 	u32 i;
+	if (!data) return;
 	for (i=0; i<dataLength; i++) {
 		switch ((unsigned char) datai) {
 		case '\'':
@@ -83,6 +84,8 @@
 		case '<':
 			gf_fprintf(trace, "&lt;");
 			break;
+		case 0:
+			break;
 		default:
 			gf_fprintf(trace, "%c", (u8) datai);
 			break;
@@ -144,6 +147,9 @@
 	GF_TrackReferenceTypeBox *p = (GF_TrackReferenceTypeBox *)a;
 	if (!p->reference_type) return GF_OK;
 	p->type = p->reference_type;
+	//don't allow UNKN or UUID as type (possible buffer overflow when typecasting to GF_UnknownBox)
+	if ((p->type==GF_ISOM_BOX_TYPE_UNKNOWN) || (p->type==GF_ISOM_BOX_TYPE_UUID))
+		p->type = GF_4CC('u','k','n','w');
 
 	gf_isom_box_dump_start(a, "TrackReferenceTypeBox", trace);
 	gf_fprintf(trace, ">\n");
@@ -165,6 +171,9 @@
 	if (!p->reference_type) return GF_OK;
 
 	p->type = p->reference_type;
+	//don't allow UNKN or UUI as type (possible buffer overflow when typecasting to GF_UnknownBox)
+	if ((p->type==GF_ISOM_BOX_TYPE_UNKNOWN) || (p->type==GF_ISOM_BOX_TYPE_UUID))
+		p->type = GF_4CC('u','k','n','w');
 	gf_isom_box_dump_start(a, "ItemReferenceBox", trace);
 	gf_fprintf(trace, "from_item_id=\"%d\">\n", p->from_item_id);
 	for (i = 0; i < p->reference_count; i++) {
@@ -201,7 +210,15 @@
 	GF_MediaDataBox *p;
 	const char *name = (a->type==GF_ISOM_BOX_TYPE_IDAT ? "ItemDataBox" : "MediaDataBox");
 	p = (GF_MediaDataBox *)a;
-	gf_isom_box_dump_start(a, name, trace);
+	if (p->is_imda) {
+		name = "IdentifiedMediaDataBox";
+		p->type = GF_ISOM_BOX_TYPE_IMDA;
+		gf_isom_box_dump_start(a, name, trace);
+		gf_fprintf(trace, "imda_identifier=\"%d\" ", p->imda_id);
+		p->type = GF_ISOM_BOX_TYPE_MDAT;
+	} else {
+		gf_isom_box_dump_start(a, name, trace);
+	}
 	gf_fprintf(trace, "dataSize=\""LLD"\">\n", p->dataSize);
 	gf_isom_box_dump_done(name, a, trace);
 	return GF_OK;
@@ -858,8 +875,11 @@
 {
 	GF_List *list = NULL;
 	GF_Err e = GF_OK;
-	if (!data) return;
-
+	if (!data) {
+		gf_fprintf(trace, ">\n");
+		return;
+	}
+	
 	GF_BitStream *bs = gf_bs_new(data, data_size, GF_BITSTREAM_READ);
 	gf_bs_set_cookie(bs, GF_ISOM_BS_COOKIE_NO_LOGS);
 	while (gf_bs_available(bs)) {
@@ -889,9 +909,12 @@
 GF_Err gnrm_box_dump(GF_Box *a, FILE * trace)
 {
 	GF_GenericSampleEntryBox *p = (GF_GenericSampleEntryBox *)a;
-	if (p->EntryType)
+	if (p->EntryType) {
 		a->type = p->EntryType;
-
+		//don't allow UNKN or UUID as type (possible buffer overflow when typecasting to GF_UnknownBox)
+		if ((a->type==GF_ISOM_BOX_TYPE_UNKNOWN) || (a->type==GF_ISOM_BOX_TYPE_UUID))
+			a->type = GF_4CC('u','k','n','w');
+	}
 	gf_isom_box_dump_start(a, "SampleDescriptionEntryBox", trace);
 	gf_fprintf(trace, "DataReferenceIndex=\"%d\" ExtensionDataSize=\"%d\"", p->dataReferenceIndex, p->data_size);
 	a->type = GF_ISOM_BOX_TYPE_GNRM;
@@ -904,9 +927,12 @@
 GF_Err gnrv_box_dump(GF_Box *a, FILE * trace)
 {
 	GF_GenericVisualSampleEntryBox *p = (GF_GenericVisualSampleEntryBox *)a;
-	if (p->EntryType)
+	if (p->EntryType) {
 		a->type = p->EntryType;
-
+		//don't allow UNKN or UUID as type (possible buffer overflow when typecasting to GF_UnknownBox)
+		if ((a->type==GF_ISOM_BOX_TYPE_UNKNOWN) || (a->type==GF_ISOM_BOX_TYPE_UUID))
+			a->type = GF_4CC('u','k','n','w');
+	}
 	gf_isom_box_dump_start(a, "VisualSampleDescriptionBox", trace);
 	gf_fprintf(trace, "DataReferenceIndex=\"%d\" Version=\"%d\" Revision=\"%d\" Vendor=\"%d\" TemporalQuality=\"%d\" SpacialQuality=\"%d\" Width=\"%d\" Height=\"%d\" HorizontalResolution=\"%d\" VerticalResolution=\"%d\" CompressorName=\"%s\" BitDepth=\"%d\"",
 	 p->dataReferenceIndex, p->version, p->revision, p->vendor, p->temporal_quality, p->spatial_quality, p->Width, p->Height, p->horiz_res, p->vert_res, isalnum(p->compressor_name0) ? p->compressor_name : p->compressor_name+1, p->bit_depth);
@@ -921,9 +947,12 @@
 GF_Err gnra_box_dump(GF_Box *a, FILE * trace)
 {
 	GF_GenericAudioSampleEntryBox *p = (GF_GenericAudioSampleEntryBox *)a;
-	if (p->EntryType)
+	if (p->EntryType) {
 		a->type = p->EntryType;
-
+		//don't allow UNKN or UUID as type (possible buffer overflow when typecasting to GF_UnknownBox)
+		if ((a->type==GF_ISOM_BOX_TYPE_UNKNOWN) || (a->type==GF_ISOM_BOX_TYPE_UUID))
+			a->type = GF_4CC('u','k','n','w');
+	}
 	gf_isom_box_dump_start(a, "AudioSampleDescriptionBox", trace);
 	gf_fprintf(trace, "DataReferenceIndex=\"%d\" Version=\"%d\" Revision=\"%d\" Vendor=\"%d\" ChannelCount=\"%d\" BitsPerSample=\"%d\" Samplerate=\"%d\"",
 	 p->dataReferenceIndex, p->version, p->revision, p->vendor, p->channel_count, p->bitspersample, p->samplerate_hi);
@@ -1200,25 +1229,34 @@
 {
 	GF_SyncSampleBox *p;
 	u32 i;
+	const char *name, *entname;
 
 	if (dump_skip_samples)
 		return GF_OK;
 
 	p = (GF_SyncSampleBox *)a;
-	gf_isom_box_dump_start(a, "SyncSampleBox", trace);
+	if (a->type==GF_ISOM_BOX_TYPE_STSS) {
+		name = "SyncSampleBox";
+		entname = "SyncSampleEntry";
+	} else {
+		name = "PartialSyncSampleBox";
+		entname = "PartialSyncSampleEntry";
+	}
+	gf_isom_box_dump_start(a, name, trace);
 	gf_fprintf(trace, "EntryCount=\"%d\">\n", p->nb_entries);
 
 	if (!p->sampleNumbers && p->size) {
-		gf_fprintf(trace, "\n");
+		if (a->type==GF_ISOM_BOX_TYPE_STSS)
+			gf_fprintf(trace, "\n");
 	} else if (p->sampleNumbers) {
 		for (i=0; i<p->nb_entries; i++) {
-			gf_fprintf(trace, "<SyncSampleEntry sampleNumber=\"%u\"/>\n", p->sampleNumbersi);
+			gf_fprintf(trace, "<%s sampleNumber=\"%u\"/>\n", entname, p->sampleNumbersi);
 		}
 	}
 	if (!p->size) {
-			gf_fprintf(trace, "<SyncSampleEntry sampleNumber=\"\"/>\n");
+			gf_fprintf(trace, "<%s sampleNumber=\"\"/>\n", entname);
 	}
-	gf_isom_box_dump_done("SyncSampleBox", a, trace);
+	gf_isom_box_dump_done(name, a, trace);
 	return GF_OK;
 }
 
@@ -1455,6 +1493,275 @@
 	return GF_OK;
 }
 
+#define get_and_print(name, bits) \
+	val = gf_bs_read_int(bs, bits); \
+	gf_fprintf(trace, " "name"=\"%u\"", val);\
+
+#define get_4cc_and_print(name, bits) \
+	val = gf_bs_read_int(bs, bits); \
+	gf_fprintf(trace, " "name"=\"%s\"", gf_4cc_to_str(val) );\
+
+static GF_Err dump_alac(GF_UnknownBox *u, FILE * trace)
+{
+	u32 val;
+	GF_BitStream *bs = gf_bs_new(u->data, u->dataSize, GF_BITSTREAM_READ);
+	gf_isom_box_dump_start((GF_Box *)u, "ALACConfigurationBox", trace);
+
+	get_and_print("version", 32)
+	get_and_print("frameLength", 32)
+	get_and_print("compatibleVersion", 8)
+	get_and_print("bitDepth", 8)
+	get_and_print("pb", 8)
+	get_and_print("mb", 8)
+	get_and_print("kb", 8)
+	get_and_print("numChannels", 8)
+	get_and_print("maxRun", 16)
+	get_and_print("maxFrameBytes", 32)
+	get_and_print("avgBitRate", 32)
+	get_and_print("sampleRate", 32)
+
+	gf_bs_del(bs);
+	gf_fprintf(trace, ">\n");
+	gf_isom_box_dump_done("ALACConfigurationBox", (GF_Box *)u, trace);
+	return GF_OK;
+}
+
+
+static GF_Err dump_uncc(GF_UnknownBox *u, FILE * trace)
+{
+	u32 val, nb_comps, i;
+	GF_BitStream *bs = gf_bs_new(u->data, u->dataSize, GF_BITSTREAM_READ);
+	gf_isom_box_dump_start((GF_Box *)u, "UncompressedFrameConfigBox", trace);
+	//full box
+	get_and_print("version", 8)
+	get_and_print("flags", 24)
+
+	nb_comps = gf_bs_read_u16(bs);
+	gf_bs_skip_bytes(bs, 5*nb_comps);
+
+	get_and_print("sampling_type", 8)
+	get_and_print("interleave_type", 8)
+	get_and_print("block_size", 8)
+	get_and_print("components_little_endian", 1)
+	get_and_print("block_pad_lsb", 1)
+	get_and_print("block_little_endian", 1)
+	get_and_print("block_reversed", 1)
+	get_and_print("pad_unknown", 1)
+	get_and_print("reserved", 3)
+	get_and_print("pixel_size", 8)
+	get_and_print("row_align_size", 32)
+	get_and_print("tile_align_size", 32)
+	get_and_print("num_tile_cols_minus_one", 32)
+	get_and_print("num_tile_rows_minus_one", 32)
+
+	gf_fprintf(trace, ">\n");
+	gf_bs_seek(bs, 6);
+	for (i=0; i<nb_comps; i++) {
+		gf_fprintf(trace, "<ComponentInfo");
+		get_and_print("index", 16)
+		get_and_print("bit_depth_minus_one", 8)
+		get_and_print("format", 8)
+		get_and_print("align_size", 8)
+		gf_fprintf(trace, "/>\n");
+	}
+
+	gf_bs_del(bs);
+	gf_isom_box_dump_done("UncompressedFrameConfigBox", (GF_Box *)u, trace);
+	return GF_OK;
+}
+
+static char *ctyp_names = {"Monochrome", "Y", "U/Cb", "V/Cr", "Red", "Green", "Blue", "Alpha", "Depth", "Disparity", "Palette", "FilterArray",
+	"padded", "Gamma", "X-ray", "VUV", "UVC", "UVB", "UVA", "NIR", "SWIR", "MWIR", "LWIR", "Panchromatic",
+	"SAR complex", "SAR magnitude", "SAR phase",
+	"ISAR complex", "ISAR magnitude", "ISAR phase"};
+
+static const char *get_comp_type_name(u32 ctype)
+{
+	u32 nb_cnames = GF_ARRAY_LENGTH(ctyp_names);
+	if (ctype<nb_cnames) return ctyp_namesctype;
+	return "unknwon";
+}
+
+static GF_Err dump_cmpd(GF_UnknownBox *u, FILE * trace)
+{
+	u32 nb_comps, i;
+	GF_BitStream *bs = gf_bs_new(u->data, u->dataSize, GF_BITSTREAM_READ);
+	gf_isom_box_dump_start((GF_Box *)u, "ComponentDefinitionBox", trace);
+
+	nb_comps = gf_bs_read_u16(bs);
+	gf_fprintf(trace, ">\n");
+	for (i=0; i<nb_comps; i++) {
+		gf_fprintf(trace, "<Component");
+		u32 ctype = gf_bs_read_u16(bs);
+		if (ctype<0x8000) {
+			gf_fprintf(trace, " type=\"%u\" name=\"%s\"", ctype, get_comp_type_name(ctype));
+		} else {
+			char *comp_uri = gf_bs_read_utf8(bs);
+			if (comp_uri) {
+				gf_fprintf(trace, " URI=\"%s\"", comp_uri);
+				gf_free(comp_uri);
+			}
+		}
+		gf_fprintf(trace, "/>\n");
+	}
+	gf_bs_del(bs);
+	gf_isom_box_dump_done("ComponentDefinitionBox", (GF_Box *)u, trace);
+	return GF_OK;
+}
+
+typedef struct {
+	u32 type;
+	u32 bits;
+} CompInfo;
+
+static GF_Err dump_cpal(GF_UnknownBox *u, FILE * trace)
+{
+	u32 val, nb_comps, nb_vals, j, i;
+	CompInfo *types=NULL;
+	GF_BitStream *bs = gf_bs_new(u->data, u->dataSize, GF_BITSTREAM_READ);
+	gf_isom_box_dump_start((GF_Box *)u, "ComponentPaletteBox", trace);
+
+	//full box
+	get_and_print("version", 8)
+	get_and_print("flags", 24)
+	gf_fprintf(trace, ">\n");
+
+	nb_comps = gf_bs_read_u16(bs);
+	types = gf_malloc(sizeof(CompInfo) * nb_comps);
+	if (!types) {
+		gf_bs_del(bs);
+		gf_isom_box_dump_done("ComponentDefinitionBox", (GF_Box *)u, trace);
+		return GF_OUT_OF_MEM;
+	}
+	for (i=0; i<nb_comps; i++) {
+		gf_fprintf(trace, "<Component");
+		get_and_print("index", 16)
+		typesi.bits = 1 + gf_bs_read_int(bs, 8);
+		typesi.type = gf_bs_read_int(bs, 8);
+		gf_fprintf(trace, " bit_depth=\"%u\" type=\"%u\" name=\"%s\"/>\n", typesi.bits, typesi.type, get_comp_type_name(typesi.type) );
+	}
+	nb_vals = gf_bs_read_u32(bs);
+	for (j=0; j<nb_vals; j++) {
+		gf_fprintf(trace, "<ComponentValue");
+		for (i=0; i<nb_comps; i++) {
+			char szTmp100;
+			szTmp0 = 0;
+			switch (typesi.type) {
+			case 0:
+				sprintf(szTmp, " C%d=\"%u\"", i+1, gf_bs_read_int(bs, typesi.bits));
+				break;
+			case 1:
+				if (typesi.bits==32)
+					sprintf(szTmp, " C%d=\"%f\"", i+1, gf_bs_read_float(bs));
+				else if (typesi.bits==64)
+					sprintf(szTmp, " C%d=\"%f\"", i+1, gf_bs_read_double(bs));
+				else
+					sprintf(szTmp, " C%d=\"0x%X\"", i+1, gf_bs_read_int(bs, typesi.bits));
+				break;
+			case 2:
+				if (typesi.bits==64)
+					sprintf(szTmp, " C%d=\"%f + %fi\"", i+1, gf_bs_read_float(bs), gf_bs_read_float(bs));
+				else if (typesi.bits==128)
+					sprintf(szTmp, " C%d=\"%f + %fi\"", i+1, gf_bs_read_double(bs), gf_bs_read_double(bs));
+				else
+					sprintf(szTmp, " C%d=\"0x%X + 0x%Xi\"", i+1, gf_bs_read_int(bs, typesi.bits/2), gf_bs_read_int(bs, typesi.bits/2) );
+				break;
+			default:
+				sprintf(szTmp, " C%d=\"invalid", i+1);
+				break;
+			}
+			gf_fprintf(trace, "%s", szTmp);
+		}
+		gf_fprintf(trace, "/>\n");
+	}
+
+	gf_bs_del(bs);
+	gf_free(types);
+	gf_isom_box_dump_done("ComponentDefinitionBox", (GF_Box *)u, trace);
+	return GF_OK;
+
+}
+
+static GF_Err dump_cpat(GF_UnknownBox *u, FILE * trace)
+{
+	u32 val, pw, ph, j, i;
+	GF_BitStream *bs = gf_bs_new(u->data, u->dataSize, GF_BITSTREAM_READ);
+	gf_isom_box_dump_start((GF_Box *)u, "ComponentPatternBox", trace);
+
+	//full box
+	get_and_print("version", 8)
+	get_and_print("flags", 24)
+	get_and_print("pattern_width", 16)
+	pw = val;
+	get_and_print("pattern_height", 16)
+	ph = val;
+	gf_fprintf(trace, ">\n");
+	for (i=0; i<pw; i++) {
+		for (j=0; j<ph; j++) {
+			gf_fprintf(trace, "<Component x=\"%d\" y=\"%d\"", i, j);
+			get_and_print("index", 16)
+			gf_fprintf(trace, " gain\"%g\"/>\n", gf_bs_read_double(bs) );
+		}
+	}
+	gf_bs_del(bs);
+	gf_isom_box_dump_done("ComponentPatternBox", (GF_Box *)u, trace);
+	return GF_OK;
+}
+
+static GF_Err dump_gmcc(GF_UnknownBox *u, FILE * trace)
+{
+	u32 val, pos;
+	GF_BitStream *bs = gf_bs_new(u->data, u->dataSize, GF_BITSTREAM_READ);
+	gf_isom_box_dump_start((GF_Box *)u, "GPACMetaCodecWrapperConfigBox", trace);
+
+	get_4cc_and_print("gpac_codec_id", 32)
+	get_4cc_and_print("meta_codec_id", 32)
+	u8 *cname = gf_bs_read_utf8(bs);
+	if (cname) {
+		gf_fprintf(trace, " codec_name=\"%s\"", cname);
+		gf_free(cname);
+	}
+	get_and_print("meta_opaque", 32)
+	pos = (u32) gf_bs_get_position(bs);
+	dump_data_attribute(trace, "decoderSpecificInfo", u->data+pos, u->dataSize-pos);
+	gf_bs_del(bs);
+	gf_fprintf(trace, ">\n");
+	gf_isom_box_dump_done("GPACMetaCodecWrapperConfigBox", (GF_Box *)u, trace);
+	return GF_OK;
+}
+
+static GF_Err dump_dvc1(GF_UnknownBox *u, FILE * trace)
+{
+	u32 val, pos;
+	GF_BitStream *bs = gf_bs_new(u->data, u->dataSize, GF_BITSTREAM_READ);
+	gf_isom_box_dump_start((GF_Box *)u, "VC1ConfigurationBox", trace);
+
+	get_and_print("profile", 4)
+	get_and_print("level", 3)
+	gf_bs_read_int(bs, 1);
+	get_and_print("level", 3)
+	get_and_print("cbr", 1)
+	gf_bs_read_int(bs, 6);
+	get_and_print("no_interlace", 1)
+	get_and_print("no_multiple_seq", 1)
+	get_and_print("no_multiple_entry", 1)
+	get_and_print("no_slice_code", 1)
+	get_and_print("no_b_frames", 1)
+	gf_bs_read_int(bs, 1);
+	get_and_print("framerate", 32)
+
+	pos = (u32) gf_bs_get_position(bs);
+	gf_bs_del(bs);
+
+	gf_fprintf(trace, " VOS=\"");
+	dump_data_hex(trace, u->data+pos, u->dataSize-pos);
+	gf_fprintf(trace, "\">\n");
+	gf_isom_box_dump_done("VC1ConfigurationBox", (GF_Box *)u, trace);
+	return GF_OK;
+}
+#undef get_and_print
+
+
 GF_Err unkn_box_dump(GF_Box *a, FILE * trace)
 {
 	Bool str_dump = GF_FALSE;
@@ -1468,6 +1775,20 @@
 	} else if (u->original_4cc==GF_4CC('m','e','a','n') && (u->dataSize>4) && !u->data0 && !u->data1 && !u->data2 && !u->data3) {
 		name = "iTunesMean";
 		str_dump = GF_TRUE;
+	} else if (u->original_4cc==GF_QT_SUBTYPE_ALAC) {
+		return dump_alac(u, trace);
+	} else if (u->original_4cc==GF_4CC('u','n','c','C')) {
+		return dump_uncc(u, trace);
+	} else if (u->original_4cc==GF_4CC('c','m','p','d')) {
+		return dump_cmpd(u, trace);
+	} else if (u->original_4cc==GF_4CC('c','p','a','l')) {
+		return dump_cpal(u, trace);
+	} else if (u->original_4cc==GF_4CC('c','p','a','t')) {
+		return dump_cpat(u, trace);
+	} else if (u->original_4cc==GF_4CC('G','M','C','C')) {
+		return dump_gmcc(u, trace);
+	} else if (u->original_4cc==GF_4CC('d','v','c','1')) {
+		return dump_dvc1(u, trace);
 	}
 
 	gf_isom_box_dump_start(a, name, trace);
@@ -1484,11 +1805,6 @@
 
 	gf_fprintf(trace, ">\n");
 	gf_isom_box_dump_done(name, a, trace);
-#ifdef GPAC_ENABLE_COVERAGE
-	if (gf_sys_is_cov_mode()) {
-		dump_data_string(NULL, NULL, 0);
-	}
-#endif
 	return GF_OK;
 }
 
@@ -2122,7 +2438,8 @@
 
 GF_Err meta_box_dump(GF_Box *a, FILE * trace)
 {
-	gf_isom_box_dump_start(a, "MetaBox", trace);
+	GF_MetaBox *ptr = (GF_MetaBox *)a;
+	gf_isom_box_dump_start_ex(a, "MetaBox", trace, ptr->is_qt ? GF_FALSE : GF_TRUE);
 	gf_fprintf(trace, ">\n");
 	gf_isom_box_dump_done("MetaBox", a, trace);
 	return GF_OK;
@@ -2131,15 +2448,18 @@
 
 GF_Err xml_box_dump(GF_Box *a, FILE * trace)
 {
+	GF_Err e=GF_OK;
 	GF_XMLBox *p = (GF_XMLBox *)a;
 	gf_isom_box_dump_start(a, "XMLBox", trace);
 	gf_fprintf(trace, ">\n");
 	gf_fprintf(trace, "<!CDATA\n");
-	if (p->xml)
-		gf_fwrite(p->xml, strlen(p->xml), trace);
+	if (p->xml) {
+		u32 len = (u32) strlen(p->xml);
+		if (gf_fwrite(p->xml, len, trace)!=len) e = GF_IO_ERR;
+	}
 	gf_fprintf(trace, ">\n");
 	gf_isom_box_dump_done("XMLBox", a, trace);
-	return GF_OK;
+	return e;
 }
 
 
@@ -3014,7 +3334,7 @@
 	gf_fprintf(trace, "/>\n");
 }
 
-static char *tx3g_format_time(u64 ts, u32 timescale, char *szDur, Bool is_srt)
+char *tx3g_format_time(u64 ts, u32 timescale, char *szDur, Bool is_srt)
 {
 	u32 h, m, s, ms;
 	ts = (u32) (ts*1000 / timescale);
@@ -3030,13 +3350,241 @@
 	return szDur;
 }
 
+void dump_ttxt_header(FILE *dump, GF_Tx3gSampleEntryBox *txt_e, u32 def_width, u32 def_height)
+{
+	gf_fprintf(dump, "<TextSampleDescription horizontalJustification=\"");
+	switch (txt_e->horizontal_justification) {
+	case 1:
+		gf_fprintf(dump, "center");
+		break;
+	case -1:
+		gf_fprintf(dump, "right");
+		break;
+	default:
+		gf_fprintf(dump, "left");
+		break;
+	}
+	gf_fprintf(dump, "\" verticalJustification=\"");
+	switch (txt_e->vertical_justification) {
+	case 1:
+		gf_fprintf(dump, "center");
+		break;
+	case -1:
+		gf_fprintf(dump, "bottom");
+		break;
+	default:
+		gf_fprintf(dump, "top");
+		break;
+	}
+	gf_fprintf(dump, "\" ");
+	tx3g_dump_rgba8(dump, "backColor", txt_e->back_color);
+	gf_fprintf(dump, " verticalText=\"%s\"", (txt_e->displayFlags & GF_TXT_VERTICAL) ? "yes" : "no");
+	gf_fprintf(dump, " fillTextRegion=\"%s\"", (txt_e->displayFlags & GF_TXT_FILL_REGION) ? "yes" : "no");
+	gf_fprintf(dump, " continuousKaraoke=\"%s\"", (txt_e->displayFlags & GF_TXT_KARAOKE) ? "yes" : "no");
+	Bool has_scroll = GF_FALSE;
+	if (txt_e->displayFlags & GF_TXT_SCROLL_IN) {
+		has_scroll = GF_TRUE;
+		if (txt_e->displayFlags & GF_TXT_SCROLL_OUT) gf_fprintf(dump, " scroll=\"InOut\"");
+		else gf_fprintf(dump, " scroll=\"In\"");
+	} else if (txt_e->displayFlags & GF_TXT_SCROLL_OUT) {
+		has_scroll = GF_TRUE;
+		gf_fprintf(dump, " scroll=\"Out\"");
+	} else {
+		gf_fprintf(dump, " scroll=\"None\"");
+	}
+	if (has_scroll) {
+		u32 mode = (txt_e->displayFlags & GF_TXT_SCROLL_DIRECTION)>>7;
+		switch (mode) {
+		case GF_TXT_SCROLL_CREDITS:
+			gf_fprintf(dump, " scrollMode=\"Credits\"");
+			break;
+		case GF_TXT_SCROLL_MARQUEE:
+			gf_fprintf(dump, " scrollMode=\"Marquee\"");
+			break;
+		case GF_TXT_SCROLL_DOWN:
+			gf_fprintf(dump, " scrollMode=\"Down\"");
+			break;
+		case GF_TXT_SCROLL_RIGHT:
+			gf_fprintf(dump, " scrollMode=\"Right\"");
+			break;
+		default:
+			gf_fprintf(dump, " scrollMode=\"Unknown\"");
+			break;
+		}
+	}
+	gf_fprintf(dump, ">\n");
+	gf_fprintf(dump, "<FontTable>\n");
+	if (txt_e->font_table) {
+		u32 j;
+		for (j=0; j<txt_e->font_table->entry_count; j++) {
+			gf_fprintf(dump, "<FontTableEntry fontName=\"%s\" fontID=\"%d\"/>\n", txt_e->font_table->fontsj.fontName, txt_e->font_table->fontsj.fontID);
+
+		}
+	}
+	gf_fprintf(dump, "</FontTable>\n");
+	if ((txt_e->default_box.bottom == txt_e->default_box.top) || (txt_e->default_box.right == txt_e->default_box.left)) {
+		txt_e->default_box.top = txt_e->default_box.left = 0;
+		txt_e->default_box.right = def_width / 65536;
+		txt_e->default_box.bottom = def_height / 65536;
+	}
+	tx3g_dump_box_nobox(dump, &txt_e->default_box);
+	tx3g_dump_style_nobox(dump, &txt_e->default_style, NULL, 0);
+	gf_fprintf(dump, "</TextSampleDescription>\n");
+}
+
+void dump_ttxt_sample(FILE *dump, GF_TextSample *s_txt, u64 ts, u32 timescale, u32 di, Bool box_dump)
+{
+	GF_Box *a;
+	u32 len, j;
+	u32 shift_offset20;
+	u32 so_count;
+	char szDur100;
+	gf_fprintf(dump, "<TextSample sampleTime=\"%s\" sampleDescriptionIndex=\"%d\"", tx3g_format_time(ts, timescale, szDur, GF_FALSE), di);
+
+	if (!box_dump) {
+		if (s_txt->highlight_color) {
+			gf_fprintf(dump, " ");
+			tx3g_dump_rgba8(dump, "highlightColor", s_txt->highlight_color->hil_color);
+		}
+		if (s_txt->scroll_delay) {
+			Double delay = s_txt->scroll_delay->scroll_delay;
+			delay /= timescale;
+			gf_fprintf(dump, " scrollDelay=\"%g\"", delay);
+		}
+		if (s_txt->wrap) gf_fprintf(dump, " wrap=\"%s\"", (s_txt->wrap->wrap_flag==0x01) ? "Automatic" : "None");
+	}
+
+	so_count = 0;
+
+	gf_fprintf(dump, " xml:space=\"preserve\">");
+	if (s_txt->len) {
+		unsigned short utf16Line10000;
+		/*UTF16*/
+		if ((s_txt->len>2) && ((unsigned char) s_txt->text0 == (unsigned char) 0xFE) && ((unsigned char) s_txt->text1 == (unsigned char) 0xFF)) {
+			/*copy 2 more chars because the lib always add 2 '0' at the end for UTF16 end of string*/
+			memcpy((char *) utf16Line, s_txt->text+2, sizeof(char) * (s_txt->len));
+			len = gf_utf8_wcslen((const u16*)utf16Line);
+		} else {
+			char *str;
+			str = s_txt->text;
+			len = gf_utf8_mbstowcs((u16*)utf16Line, 10000, (const char **) &str);
+		}
+		if (len != GF_UTF8_FAIL) {
+			utf16Linelen = 0;
+			for (j=0; j<len; j++) {
+				if ((utf16Linej=='\n') || (utf16Linej=='\r') || (utf16Linej==0x85) || (utf16Linej==0x2028) || (utf16Linej==0x2029) ) {
+					gf_fprintf(dump, "\n");
+					if ((utf16Linej=='\r') && (utf16Linej+1=='\n')) {
+						shift_offsetso_count = j;
+						so_count++;
+						j++;
+					}
+				}
+				else {
+					switch (utf16Linej) {
+					case '\'':
+						gf_fprintf(dump, "&apos;");
+						break;
+					case '\"':
+						gf_fprintf(dump, "&quot;");
+						break;
+					case '&':
+						gf_fprintf(dump, "&amp;");
+						break;
+					case '>':
+						gf_fprintf(dump, "&gt;");
+						break;
+					case '<':
+						gf_fprintf(dump, "&lt;");
+						break;
+					default:
+						if (utf16Linej < 128) {
+							gf_fprintf(dump, "%c", (u8) utf16Linej);
+						} else {
+							gf_fprintf(dump, "&#%d;", utf16Linej);
+						}
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	if (box_dump) {
+
+		if (s_txt->highlight_color)
+			gf_isom_box_dump((GF_Box*) s_txt->highlight_color, dump);
+		if (s_txt->scroll_delay)
+			gf_isom_box_dump((GF_Box*) s_txt->scroll_delay, dump);
+		if (s_txt->wrap)
+			gf_isom_box_dump((GF_Box*) s_txt->wrap, dump);
+		if (s_txt->box)
+			gf_isom_box_dump((GF_Box*) s_txt->box, dump);
+		if (s_txt->styles)
+			gf_isom_box_dump((GF_Box*) s_txt->styles, dump);
+	} else {
+
+		if (s_txt->box) tx3g_dump_box_nobox(dump, &s_txt->box->box);
+		if (s_txt->styles) {
+			for (j=0; j<s_txt->styles->entry_count; j++) {
+				tx3g_dump_style_nobox(dump, &s_txt->styles->stylesj, shift_offset, so_count);
+			}
+		}
+	}
+	j=0;
+	while ((a = (GF_Box *)gf_list_enum(s_txt->others, &j))) {
+		if (box_dump) {
+			gf_isom_box_dump((GF_Box*) a, dump);
+			continue;
+		}
+
+		switch (a->type) {
+		case GF_ISOM_BOX_TYPE_HLIT:
+			gf_fprintf(dump, "<Highlight ");
+			tx3g_print_char_offsets(dump, ((GF_TextHighlightBox *)a)->startcharoffset, ((GF_TextHighlightBox *)a)->endcharoffset, shift_offset, so_count);
+			gf_fprintf(dump, "/>\n");
+			break;
+		case GF_ISOM_BOX_TYPE_HREF:
+		{
+			GF_TextHyperTextBox *ht = (GF_TextHyperTextBox *)a;
+			gf_fprintf(dump, "<HyperLink ");
+			tx3g_print_char_offsets(dump, ht->startcharoffset, ht->endcharoffset, shift_offset, so_count);
+			gf_fprintf(dump, "URL=\"%s\" URLToolTip=\"%s\"/>\n", ht->URL ? ht->URL : "", ht->URL_hint ? ht->URL_hint : "");
+		}
+		break;
+		case GF_ISOM_BOX_TYPE_BLNK:
+			gf_fprintf(dump, "<Blinking ");
+			tx3g_print_char_offsets(dump, ((GF_TextBlinkBox *)a)->startcharoffset, ((GF_TextBlinkBox *)a)->endcharoffset, shift_offset, so_count);
+			gf_fprintf(dump, "/>\n");
+			break;
+		case GF_ISOM_BOX_TYPE_KROK:
+		{
+			u32 k;
+			Double t;
+			GF_TextKaraokeBox *krok = (GF_TextKaraokeBox *)a;
+			t = krok->highlight_starttime;
+			t /= timescale;
+			gf_fprintf(dump, "<Karaoke startTime=\"%g\">\n", t);
+			for (k=0; k<krok->nb_entries; k++) {
+				t = krok->recordsk.highlight_endtime;
+				t /= timescale;
+				gf_fprintf(dump, "<KaraokeRange ");
+				tx3g_print_char_offsets(dump, krok->recordsk.start_charoffset, krok->recordsk.end_charoffset, shift_offset, so_count);
+				gf_fprintf(dump, "endTime=\"%g\"/>\n", t);
+			}
+			gf_fprintf(dump, "</Karaoke>\n");
+		}
+			break;
+		}
+	}
+
+	gf_fprintf(dump, "</TextSample>\n");
+
+}
 static GF_Err gf_isom_dump_ttxt_track(GF_ISOFile *the_file, u32 track, FILE *dump, GF_TextDumpType dump_type)
 {
-	u32 i, j, count, di, nb_descs, shift_offset20, so_count;
+	u32 i, count, di, nb_descs;
 	u64 last_DTS;
-	u32 len;
-	GF_Box *a;
-	Bool has_scroll;
 	char szDur100;
 	GF_Tx3gSampleEntryBox *txt_e;
 	Bool box_dump = (dump_type==GF_TEXTDUMPTYPE_TTXT_BOXES) ? GF_TRUE : GF_FALSE;
@@ -3081,83 +3629,7 @@
 		if (box_dump) {
 			gf_isom_box_dump((GF_Box*) txt_e, dump);
 		} else if (txt_e->type==GF_ISOM_BOX_TYPE_TX3G) {
-			gf_fprintf(dump, "<TextSampleDescription horizontalJustification=\"");
-			switch (txt_e->horizontal_justification) {
-			case 1:
-				gf_fprintf(dump, "center");
-				break;
-			case -1:
-				gf_fprintf(dump, "right");
-				break;
-			default:
-				gf_fprintf(dump, "left");
-				break;
-			}
-			gf_fprintf(dump, "\" verticalJustification=\"");
-			switch (txt_e->vertical_justification) {
-			case 1:
-				gf_fprintf(dump, "center");
-				break;
-			case -1:
-				gf_fprintf(dump, "bottom");
-				break;
-			default:
-				gf_fprintf(dump, "top");
-				break;
-			}
-			gf_fprintf(dump, "\" ");
-			tx3g_dump_rgba8(dump, "backColor", txt_e->back_color);
-			gf_fprintf(dump, " verticalText=\"%s\"", (txt_e->displayFlags & GF_TXT_VERTICAL) ? "yes" : "no");
-			gf_fprintf(dump, " fillTextRegion=\"%s\"", (txt_e->displayFlags & GF_TXT_FILL_REGION) ? "yes" : "no");
-			gf_fprintf(dump, " continuousKaraoke=\"%s\"", (txt_e->displayFlags & GF_TXT_KARAOKE) ? "yes" : "no");
-			has_scroll = GF_FALSE;
-			if (txt_e->displayFlags & GF_TXT_SCROLL_IN) {
-				has_scroll = GF_TRUE;
-				if (txt_e->displayFlags & GF_TXT_SCROLL_OUT) gf_fprintf(dump, " scroll=\"InOut\"");
-				else gf_fprintf(dump, " scroll=\"In\"");
-			} else if (txt_e->displayFlags & GF_TXT_SCROLL_OUT) {
-				has_scroll = GF_TRUE;
-				gf_fprintf(dump, " scroll=\"Out\"");
-			} else {
-				gf_fprintf(dump, " scroll=\"None\"");
-			}
-			if (has_scroll) {
-				u32 mode = (txt_e->displayFlags & GF_TXT_SCROLL_DIRECTION)>>7;
-				switch (mode) {
-				case GF_TXT_SCROLL_CREDITS:
-					gf_fprintf(dump, " scrollMode=\"Credits\"");
-					break;
-				case GF_TXT_SCROLL_MARQUEE:
-					gf_fprintf(dump, " scrollMode=\"Marquee\"");
-					break;
-				case GF_TXT_SCROLL_DOWN:
-					gf_fprintf(dump, " scrollMode=\"Down\"");
-					break;
-				case GF_TXT_SCROLL_RIGHT:
-					gf_fprintf(dump, " scrollMode=\"Right\"");
-					break;
-				default:
-					gf_fprintf(dump, " scrollMode=\"Unknown\"");
-					break;
-				}
-			}
-			gf_fprintf(dump, ">\n");
-			gf_fprintf(dump, "<FontTable>\n");
-			if (txt_e->font_table) {
-				for (j=0; j<txt_e->font_table->entry_count; j++) {
-					gf_fprintf(dump, "<FontTableEntry fontName=\"%s\" fontID=\"%d\"/>\n", txt_e->font_table->fontsj.fontName, txt_e->font_table->fontsj.fontID);
-
-				}
-			}
-			gf_fprintf(dump, "</FontTable>\n");
-			if ((txt_e->default_box.bottom == txt_e->default_box.top) || (txt_e->default_box.right == txt_e->default_box.left)) {
-				txt_e->default_box.top = txt_e->default_box.left = 0;
-				txt_e->default_box.right = trak->Header->width / 65536;
-				txt_e->default_box.bottom = trak->Header->height / 65536;
-			}
-			tx3g_dump_box_nobox(dump, &txt_e->default_box);
-			tx3g_dump_style_nobox(dump, &txt_e->default_style, NULL, 0);
-			gf_fprintf(dump, "</TextSampleDescription>\n");
+			dump_ttxt_header(dump, txt_e, trak->Header->width, trak->Header->height);
 		} else {
 			GF_TextSampleEntryBox *text = (GF_TextSampleEntryBox *)gf_list_get(trak->Media->information->sampleTable->SampleDescription->child_boxes, i);
 			gf_fprintf(dump, "<TextSampleDescription horizontalJustification=\"");
@@ -3217,149 +3689,13 @@
 			continue;
 		}
 
-		gf_fprintf(dump, "<TextSample sampleTime=\"%s\" sampleDescriptionIndex=\"%d\"", tx3g_format_time(s->DTS, trak->Media->mediaHeader->timeScale, szDur, GF_FALSE), di);
-
-		if (!box_dump) {
-			if (s_txt->highlight_color) {
-				gf_fprintf(dump, " ");
-				tx3g_dump_rgba8(dump, "highlightColor", s_txt->highlight_color->hil_color);
-			}
-			if (s_txt->scroll_delay) {
-				Double delay = s_txt->scroll_delay->scroll_delay;
-				delay /= trak->Media->mediaHeader->timeScale;
-				gf_fprintf(dump, " scrollDelay=\"%g\"", delay);
-			}
-			if (s_txt->wrap) gf_fprintf(dump, " wrap=\"%s\"", (s_txt->wrap->wrap_flag==0x01) ? "Automatic" : "None");
-		}
-
-		so_count = 0;
-
-		gf_fprintf(dump, " xml:space=\"preserve\">");
+		dump_ttxt_sample(dump, s_txt, s->DTS, trak->Media->mediaHeader->timeScale, di, box_dump);
 		if (!s_txt->len) {
 			last_DTS = (u32) trak->Media->mediaHeader->duration;
 		} else {
-			unsigned short utf16Line10000;
 			last_DTS = s->DTS;
-			/*UTF16*/
-			if ((s_txt->len>2) && ((unsigned char) s_txt->text0 == (unsigned char) 0xFE) && ((unsigned char) s_txt->text1 == (unsigned char) 0xFF)) {
-				/*copy 2 more chars because the lib always add 2 '0' at the end for UTF16 end of string*/
-				memcpy((char *) utf16Line, s_txt->text+2, sizeof(char) * (s_txt->len));
-				len = gf_utf8_wcslen((const u16*)utf16Line);
-			} else {
-				char *str;
-				str = s_txt->text;
-				len = gf_utf8_mbstowcs((u16*)utf16Line, 10000, (const char **) &str);
-			}
-			if (len != GF_UTF8_FAIL) {
-				utf16Linelen = 0;
-				for (j=0; j<len; j++) {
-					if ((utf16Linej=='\n') || (utf16Linej=='\r') || (utf16Linej==0x85) || (utf16Linej==0x2028) || (utf16Linej==0x2029) ) {
-						gf_fprintf(dump, "\n");
-						if ((utf16Linej=='\r') && (utf16Linej+1=='\n')) {
-							shift_offsetso_count = j;
-							so_count++;
-							j++;
-						}
-					}
-					else {
-						switch (utf16Linej) {
-						case '\'':
-							gf_fprintf(dump, "&apos;");
-							break;
-						case '\"':
-							gf_fprintf(dump, "&quot;");
-							break;
-						case '&':
-							gf_fprintf(dump, "&amp;");
-							break;
-						case '>':
-							gf_fprintf(dump, "&gt;");
-							break;
-						case '<':
-							gf_fprintf(dump, "&lt;");
-							break;
-						default:
-							if (utf16Linej < 128) {
-								gf_fprintf(dump, "%c", (u8) utf16Linej);
-							} else {
-								gf_fprintf(dump, "&#%d;", utf16Linej);
-							}
-							break;
-						}
-					}
-				}
-			}
-		}
-
-		if (box_dump) {
-
-			if (s_txt->highlight_color)
-				gf_isom_box_dump((GF_Box*) s_txt->highlight_color, dump);
-			if (s_txt->scroll_delay)
-				gf_isom_box_dump((GF_Box*) s_txt->scroll_delay, dump);
-			if (s_txt->wrap)
-				gf_isom_box_dump((GF_Box*) s_txt->wrap, dump);
-			if (s_txt->box)
-				gf_isom_box_dump((GF_Box*) s_txt->box, dump);
-			if (s_txt->styles)
-				gf_isom_box_dump((GF_Box*) s_txt->styles, dump);
-		} else {
-
-			if (s_txt->box) tx3g_dump_box_nobox(dump, &s_txt->box->box);
-			if (s_txt->styles) {
-				for (j=0; j<s_txt->styles->entry_count; j++) {
-					tx3g_dump_style_nobox(dump, &s_txt->styles->stylesj, shift_offset, so_count);
-				}
-			}
 		}
-		j=0;
-		while ((a = (GF_Box *)gf_list_enum(s_txt->others, &j))) {
-			if (box_dump) {
-				gf_isom_box_dump((GF_Box*) a, dump);
-				continue;
-			}
 
-			switch (a->type) {
-			case GF_ISOM_BOX_TYPE_HLIT:
-				gf_fprintf(dump, "<Highlight ");
-				tx3g_print_char_offsets(dump, ((GF_TextHighlightBox *)a)->startcharoffset, ((GF_TextHighlightBox *)a)->endcharoffset, shift_offset, so_count);
-				gf_fprintf(dump, "/>\n");
-				break;
-			case GF_ISOM_BOX_TYPE_HREF:
-			{
-				GF_TextHyperTextBox *ht = (GF_TextHyperTextBox *)a;
-				gf_fprintf(dump, "<HyperLink ");
-				tx3g_print_char_offsets(dump, ht->startcharoffset, ht->endcharoffset, shift_offset, so_count);
-				gf_fprintf(dump, "URL=\"%s\" URLToolTip=\"%s\"/>\n", ht->URL ? ht->URL : "", ht->URL_hint ? ht->URL_hint : "");
-			}
-			break;
-			case GF_ISOM_BOX_TYPE_BLNK:
-				gf_fprintf(dump, "<Blinking ");
-				tx3g_print_char_offsets(dump, ((GF_TextBlinkBox *)a)->startcharoffset, ((GF_TextBlinkBox *)a)->endcharoffset, shift_offset, so_count);
-				gf_fprintf(dump, "/>\n");
-				break;
-			case GF_ISOM_BOX_TYPE_KROK:
-			{
-				u32 k;
-				Double t;
-				GF_TextKaraokeBox *krok = (GF_TextKaraokeBox *)a;
-				t = krok->highlight_starttime;
-				t /= trak->Media->mediaHeader->timeScale;
-				gf_fprintf(dump, "<Karaoke startTime=\"%g\">\n", t);
-				for (k=0; k<krok->nb_entries; k++) {
-					t = krok->recordsk.highlight_endtime;
-					t /= trak->Media->mediaHeader->timeScale;
-					gf_fprintf(dump, "<KaraokeRange ");
-					tx3g_print_char_offsets(dump, krok->recordsk.start_charoffset, krok->recordsk.end_charoffset, shift_offset, so_count);
-					gf_fprintf(dump, "endTime=\"%g\"/>\n", t);
-				}
-				gf_fprintf(dump, "</Karaoke>\n");
-			}
-				break;
-			}
-		}
-
-		gf_fprintf(dump, "</TextSample>\n");
 		gf_isom_sample_del(&s);
 		gf_isom_delete_text_sample(s_txt);
 		gf_set_progress("TTXT Extract", i, count);
@@ -3378,9 +3714,178 @@
 }
 
 #include <gpac/webvtt.h>
+
+GF_Err dump_ttxt_sample_srt(FILE *dump, GF_TextSample *txt, GF_Tx3gSampleEntryBox *txtd, Bool vtt_dump)
+{
+	u32 len, j, k;
+	if (!txt || !txt->len) {
+		gf_fprintf(dump, "\n");
+	} else {
+		u32 styles, char_num, new_styles, color, new_color;
+		u16 utf16Line10000;
+
+		/*UTF16*/
+		if ((txt->len>2) && ((unsigned char) txt->text0 == (unsigned char) 0xFE) && ((unsigned char) txt->text1 == (unsigned char) 0xFF)) {
+			memcpy(utf16Line, txt->text+2, sizeof(char)*txt->len);
+			( ((char *)utf16Line)txt->len ) = 0;
+			len = txt->len;
+		} else {
+			u8 *str = (u8 *) (txt->text);
+			len = gf_utf8_mbstowcs(utf16Line, 10000, (const char **) &str);
+			if (len == GF_UTF8_FAIL) return GF_NON_COMPLIANT_BITSTREAM;
+			utf16Linelen = 0;
+		}
+		char_num = 0;
+		styles = 0;
+		new_styles = txtd->default_style.style_flags;
+		color = new_color = txtd->default_style.text_color;
+
+		for (j=0; j<len; j++) {
+			Bool is_new_line;
+
+			if (txt->styles) {
+				new_styles = txtd->default_style.style_flags;
+				new_color = txtd->default_style.text_color;
+				for (k=0; k<txt->styles->entry_count; k++) {
+					if (txt->styles->stylesk.startCharOffset>char_num) continue;
+					if (txt->styles->stylesk.endCharOffset<char_num+1) continue;
+
+					if (txt->styles->stylesk.style_flags & (GF_TXT_STYLE_ITALIC | GF_TXT_STYLE_BOLD | GF_TXT_STYLE_UNDERLINED | GF_TXT_STYLE_STRIKETHROUGH))
+						new_styles = txt->styles->stylesk.style_flags;
+					if (txt->styles->stylesk.text_color)
+						new_color = txt->styles->stylesk.text_color;
+
+					break;
+				}
+			}
+			if (new_styles != styles) {
+				if ((new_styles & GF_TXT_STYLE_BOLD) && !(styles & GF_TXT_STYLE_BOLD)) gf_fprintf(dump, "");
+				if ((new_styles & GF_TXT_STYLE_ITALIC) && !(styles & GF_TXT_STYLE_ITALIC)) gf_fprintf(dump, "");
+				if ((new_styles & GF_TXT_STYLE_UNDERLINED) && !(styles & GF_TXT_STYLE_UNDERLINED)) gf_fprintf(dump, "");
+				if ((new_styles & GF_TXT_STYLE_STRIKETHROUGH) && !(styles & GF_TXT_STYLE_STRIKETHROUGH)) gf_fprintf(dump, "<strike>");
+
+				if ((styles & GF_TXT_STYLE_STRIKETHROUGH) && !(new_styles & GF_TXT_STYLE_STRIKETHROUGH)) gf_fprintf(dump, "</strike>");
+				if ((styles & GF_TXT_STYLE_UNDERLINED) && !(new_styles & GF_TXT_STYLE_UNDERLINED)) gf_fprintf(dump, "");
+				if ((styles & GF_TXT_STYLE_ITALIC) && !(new_styles & GF_TXT_STYLE_ITALIC)) gf_fprintf(dump, "");
+				if ((styles & GF_TXT_STYLE_BOLD) && !(new_styles & GF_TXT_STYLE_BOLD)) gf_fprintf(dump, "");
+
+				styles = new_styles;
+			}
+			if (!vtt_dump && (new_color != color)) {
+				if (new_color ==txtd->default_style.text_color) {
+					gf_fprintf(dump, "");
+				} else {
+					const char *cname = gf_color_get_name(new_color);
+					if (cname) {
+						gf_fprintf(dump, "", cname);
+					} else {
+						if (new_color >> 24 < 0xFF)
+							gf_fprintf(dump, "", new_color);
+						else
+							gf_fprintf(dump, "", new_color&0x00FFFFFF);
+					}
+				}
+				color = new_color;
+			}
+
+			/*not sure if styles must be reseted at line breaks in srt...*/
+			is_new_line = GF_FALSE;
+			if ((utf16Linej=='\n') || (utf16Linej=='\r') ) {
+				if ((utf16Linej=='\r') && (utf16Linej+1=='\n')) j++;
+				gf_fprintf(dump, "\n");
+				is_new_line = GF_TRUE;
+			}
+
+			if (!is_new_line) {
+				u32 sl;
+				char szChar30;
+				s16 swT2, *swz;
+				swT0 = utf16Linej;
+				swT1 = 0;
+				swz= (s16 *)swT;
+				sl = gf_utf8_wcstombs(szChar, 30, (const unsigned short **) &swz);
+				if (sl == GF_UTF8_FAIL) sl=0;
+				szCharsl=0;
+				gf_fprintf(dump, "%s", szChar);
+			}
+			char_num++;
+		}
+		new_styles = 0;
+		if (new_styles != styles) {
+			if (styles & GF_TXT_STYLE_STRIKETHROUGH) gf_fprintf(dump, "</strike>");
+			if (styles & GF_TXT_STYLE_UNDERLINED) gf_fprintf(dump, "");
+			if (styles & GF_TXT_STYLE_ITALIC) gf_fprintf(dump, "");
+			if (styles & GF_TXT_STYLE_BOLD) gf_fprintf(dump, "");
+
+//				styles = 0;
+		}
+
+		if (color != txtd->default_style.text_color) {
+			gf_fprintf(dump, "");
+//				color = txtd->default_style.text_color;
+		}
+		gf_fprintf(dump, "\n");
+	}
+	return GF_OK;
+}
+
+static void vttmx_timestamp_dump(GF_BitStream *bs, GF_WebVTTTimestamp *ts, Bool dump_hour, Bool write_srt)
+{
+	char szTS200;
+	szTS0 = 0;
+	if (dump_hour) {
+		sprintf(szTS, "%02u:", ts->hour);
+		gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
+	}
+	sprintf(szTS, "%02u:%02u%c%03u", ts->min, ts->sec, write_srt ? ',' : '.', ts->ms);
+	gf_bs_write_data(bs, szTS, (u32) strlen(szTS) );
+}
+
+void webvtt_write_cue_bs(GF_BitStream *bs, GF_WebVTTCue *cue, Bool write_srt)
+{
+	Bool write_hour = GF_FALSE;
+	if (!cue) return;
+	if (!write_srt && cue->pre_text) {
+		gf_bs_write_data(bs, cue->pre_text, (u32) strlen(cue->pre_text));
+		gf_bs_write_data(bs, "\n\n", 2);
+	}
+	if (!write_srt && cue->id) {
+		u32 len = (u32) strlen(cue->id) ;
+		gf_bs_write_data(bs, cue->id, len);
+		if (len && (cue->idlen-1!='\n'))
+			gf_bs_write_data(bs, "\n", 1);
+	}
+
+	if (gf_opts_get_bool("core", "webvtt-hours")) write_hour = GF_TRUE;
+	else if (cue->start.hour || cue->end.hour) write_hour = GF_TRUE;
+	else if (write_srt) write_hour = GF_TRUE;
+
+	vttmx_timestamp_dump(bs, &cue->start, write_hour, write_srt);
+	gf_bs_write_data(bs, " --> ", 5);
+	vttmx_timestamp_dump(bs, &cue->end, write_hour, write_srt);
+
+	if (!write_srt && cue->settings) {
+		gf_bs_write_data(bs, " ", 1);
+		gf_bs_write_data(bs, cue->settings, (u32) strlen(cue->settings));
+	}
+	gf_bs_write_data(bs, "\n", 1);
+	if (cue->text)
+		gf_bs_write_data(bs, cue->text, (u32) strlen(cue->text));
+
+	if (!write_srt)
+		gf_bs_write_data(bs, "\n\n", 2);
+	else
+		gf_bs_write_data(bs, "\n", 1);
+
+	if (!write_srt && cue->post_text) {
+		gf_bs_write_data(bs, cue->post_text, (u32) strlen(cue->post_text));
+		gf_bs_write_data(bs, "\n\n", 2);
+	}
+}
+
 static GF_Err gf_isom_dump_srt_track(GF_ISOFile *the_file, u32 track, FILE *dump)
 {
-	u32 i, j, k, count, di, len, ts, cur_frame;
+	u32 i, j, count, di, ts, cur_frame;
 	u64 start, end;
 	GF_Tx3gSampleEntryBox *txtd;
 	char szDur100;
@@ -3411,6 +3916,8 @@
 	default:
 		return GF_NOT_SUPPORTED;
 	}
+	s64 ts_offset=0;
+	gf_isom_get_edit_list_type(the_file, track, &ts_offset);
 
 	count = gf_isom_get_sample_count(the_file, track);
 	for (i=0; i<count; i++) {
@@ -3419,7 +3926,7 @@
 		GF_ISOSample *s = gf_isom_get_sample(the_file, track, i+1, &di);
 		if (!s) continue;
 
-		start = s->DTS;
+		start = s->DTS+ts_offset;
 		if (s->dataLength==2) {
 			gf_isom_sample_del(&s);
 			continue;
@@ -3427,7 +3934,7 @@
 		if (i+1<count) {
 			GF_ISOSample *next = gf_isom_get_sample_info(the_file, track, i+2, NULL, NULL);
 			if (next) {
-				end = next->DTS;
+				end = next->DTS+ts_offset;
 				gf_isom_sample_del(&next);
 			}
 		} else {
@@ -3445,7 +3952,6 @@
 
 		if (is_wvtt) {
 			u64 start_ts, end_ts;
-			void webvtt_write_cue(GF_BitStream *bs, GF_WebVTTCue *cue, Bool write_srt);
 			GF_List *cues;
 			u32 nb_cues;
 			u8 *data;
@@ -3470,7 +3976,7 @@
 			bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 			for (j = 0; j < gf_list_count(cues); j++) {
 				GF_WebVTTCue *cue = (GF_WebVTTCue *)gf_list_get(cues, j);
-				webvtt_write_cue(bs, cue, GF_TRUE);
+				webvtt_write_cue_bs(bs, cue, GF_TRUE);
 				gf_webvtt_cue_del(cue);
 			}
 			gf_list_del(cues);
@@ -3492,7 +3998,7 @@
 			continue;
 		}
 		else if ((subtype!=GF_ISOM_SUBTYPE_TX3G) && (subtype!=GF_ISOM_SUBTYPE_TEXT)) {
-			gf_fprintf(dump, "unknwon\n");
+			gf_fprintf(dump, "unknown\n");
 			gf_isom_sample_del(&s);
 			continue;
 		}
@@ -3502,109 +4008,13 @@
 
 		txtd = (GF_Tx3gSampleEntryBox *)gf_list_get(trak->Media->information->sampleTable->SampleDescription->child_boxes, di-1);
 
-		if (!txt || !txt->len) {
-			gf_fprintf(dump, "\n");
-		} else {
-			u32 styles, char_num, new_styles, color, new_color;
-			u16 utf16Line10000;
-
-			/*UTF16*/
-			if ((txt->len>2) && ((unsigned char) txt->text0 == (unsigned char) 0xFE) && ((unsigned char) txt->text1 == (unsigned char) 0xFF)) {
-				memcpy(utf16Line, txt->text+2, sizeof(char)*txt->len);
-				( ((char *)utf16Line)txt->len ) = 0;
-				len = txt->len;
-			} else {
-				u8 *str = (u8 *) (txt->text);
-				len = gf_utf8_mbstowcs(utf16Line, 10000, (const char **) &str);
-				if (len == GF_UTF8_FAIL) return GF_NON_COMPLIANT_BITSTREAM;
-				utf16Linelen = 0;
-			}
-			char_num = 0;
-			styles = 0;
-			new_styles = txtd->default_style.style_flags;
-			color = new_color = txtd->default_style.text_color;
-
-			for (j=0; j<len; j++) {
-				Bool is_new_line;
-
-				if (txt->styles) {
-					new_styles = txtd->default_style.style_flags;
-					new_color = txtd->default_style.text_color;
-					for (k=0; k<txt->styles->entry_count; k++) {
-						if (txt->styles->stylesk.startCharOffset>char_num) continue;
-						if (txt->styles->stylesk.endCharOffset<char_num+1) continue;
-
-						if (txt->styles->stylesk.style_flags & (GF_TXT_STYLE_ITALIC | GF_TXT_STYLE_BOLD | GF_TXT_STYLE_UNDERLINED | GF_TXT_STYLE_STRIKETHROUGH)) {
-							new_styles = txt->styles->stylesk.style_flags;
-							new_color = txt->styles->stylesk.text_color;
-							break;
-						}
-					}
-				}
-				if (new_styles != styles) {
-					if ((new_styles & GF_TXT_STYLE_BOLD) && !(styles & GF_TXT_STYLE_BOLD)) gf_fprintf(dump, "");
-					if ((new_styles & GF_TXT_STYLE_ITALIC) && !(styles & GF_TXT_STYLE_ITALIC)) gf_fprintf(dump, "");
-					if ((new_styles & GF_TXT_STYLE_UNDERLINED) && !(styles & GF_TXT_STYLE_UNDERLINED)) gf_fprintf(dump, "");
-					if ((new_styles & GF_TXT_STYLE_STRIKETHROUGH) && !(styles & GF_TXT_STYLE_STRIKETHROUGH)) gf_fprintf(dump, "<strike>");
-
-					if ((styles & GF_TXT_STYLE_STRIKETHROUGH) && !(new_styles & GF_TXT_STYLE_STRIKETHROUGH)) gf_fprintf(dump, "</strike>");
-					if ((styles & GF_TXT_STYLE_UNDERLINED) && !(new_styles & GF_TXT_STYLE_UNDERLINED)) gf_fprintf(dump, "");
-					if ((styles & GF_TXT_STYLE_ITALIC) && !(new_styles & GF_TXT_STYLE_ITALIC)) gf_fprintf(dump, "");
-					if ((styles & GF_TXT_STYLE_BOLD) && !(new_styles & GF_TXT_STYLE_BOLD)) gf_fprintf(dump, "");
-
-					styles = new_styles;
-				}
-				if (new_color != color) {
-					if (new_color ==txtd->default_style.text_color) {
-						gf_fprintf(dump, "");
-					} else {
-						gf_fprintf(dump, "", gf_color_get_name(new_color) );
-					}
-					color = new_color;
-				}
-
-				/*not sure if styles must be reseted at line breaks in srt...*/
-				is_new_line = GF_FALSE;
-				if ((utf16Linej=='\n') || (utf16Linej=='\r') ) {
-					if ((utf16Linej=='\r') && (utf16Linej+1=='\n')) j++;
-					gf_fprintf(dump, "\n");
-					is_new_line = GF_TRUE;
-				}
-
-				if (!is_new_line) {
-					u32 sl;
-					char szChar30;
-					s16 swT2, *swz;
-					swT0 = utf16Linej;
-					swT1 = 0;
-					swz= (s16 *)swT;
-					sl = gf_utf8_wcstombs(szChar, 30, (const unsigned short **) &swz);
-					if (sl == GF_UTF8_FAIL) sl=0;
-					szCharsl=0;
-					gf_fprintf(dump, "%s", szChar);
-				}
-				char_num++;
-			}
-			new_styles = 0;
-			if (new_styles != styles) {
-				if (styles & GF_TXT_STYLE_STRIKETHROUGH) gf_fprintf(dump, "</strike>");
-				if (styles & GF_TXT_STYLE_UNDERLINED) gf_fprintf(dump, "");
-				if (styles & GF_TXT_STYLE_ITALIC) gf_fprintf(dump, "");
-				if (styles & GF_TXT_STYLE_BOLD) gf_fprintf(dump, "");
-
-//				styles = 0;
-			}
+		GF_Err e = dump_ttxt_sample_srt(dump, txt, txtd, GF_FALSE);
 
-			if (color != txtd->default_style.text_color) {
-				gf_fprintf(dump, "");
-//				color = txtd->default_style.text_color;
-			}
-			gf_fprintf(dump, "\n");
-		}
 		gf_isom_sample_del(&s);
 		gf_isom_delete_text_sample(txt);
 		gf_fprintf(dump, "\n");
 		gf_set_progress("SRT Extract", i, count);
+		if (e) return e;
 	}
 	if (count) gf_set_progress("SRT Extract", i, count);
 	return GF_OK;
@@ -3979,13 +4389,38 @@
 		default:
 			if (dbox && dbox->data) {
 				gf_fprintf(trace, " value=\"");
-				if (!unknown && (itype==GF_ITAG_STR)) {
+				switch (itype) {
+				case GF_ITAG_STR:
 					dump_data_string(trace, dbox->data, dbox->dataSize);
-				}
-				else if (!unknown && gf_utf8_is_legal(dbox->data, dbox->dataSize) ) {
-					dump_data_string(trace, dbox->data, dbox->dataSize);
-				} else {
-					dump_data(trace, dbox->data, dbox->dataSize);
+					break;
+				case GF_ITAG_INT8:
+					if (dbox->dataSize)
+						gf_fprintf(trace, "%d", dbox->data0);
+					break;
+				case GF_ITAG_INT16:
+					if (dbox->dataSize>1) {
+						u16 v = dbox->data0;
+						v<<=8;
+						v |= dbox->data1;
+						gf_fprintf(trace, "%d", v);
+					}
+					break;
+				case GF_ITAG_INT32:
+					if (dbox->dataSize>3) {
+						u32 v = dbox->data0; v<<=8;
+						v |= dbox->data1; v<<=8;
+						v |= dbox->data2; v<<=8;
+						v |= dbox->data3;
+						gf_fprintf(trace, "%d", v);
+					}
+					break;
+				default:
+					if (!unknown && gf_utf8_is_legal(dbox->data, dbox->dataSize) ) {
+						dump_data_string(trace, dbox->data, dbox->dataSize);
+					} else {
+						dump_data(trace, dbox->data, dbox->dataSize);
+					}
+				break;
 				}
 				gf_fprintf(trace, "\" ");
 			}
@@ -4342,20 +4777,19 @@
 	return GF_OK;
 }
 
-
 GF_Err dOps_box_dump(GF_Box *a, FILE * trace)
 {
 	GF_OpusSpecificBox *p = (GF_OpusSpecificBox *)a;
 
 	gf_isom_box_dump_start(a, "OpusSpecificBox", trace);
 	gf_fprintf(trace, "version=\"%d\" OutputChannelCount=\"%d\" PreSkip=\"%d\" InputSampleRate=\"%d\" OutputGain=\"%d\" ChannelMappingFamily=\"%d\"",
-		p->version, p->OutputChannelCount, p->PreSkip, p->InputSampleRate, p->OutputGain, p->ChannelMappingFamily);
+		p->version, p->opcfg.OutputChannelCount, p->opcfg.PreSkip, p->opcfg.InputSampleRate, p->opcfg.OutputGain, p->opcfg.ChannelMappingFamily);
 
-	if (p->ChannelMappingFamily) {
+	if (p->opcfg.ChannelMappingFamily) {
 		u32 i;
-		gf_fprintf(trace, " StreamCount=\"%d\" CoupledStreamCount=\"%d\" channelMapping=\"", p->StreamCount, p->CoupledCount);
-		for (i=0; i<p->OutputChannelCount; i++) {
-			gf_fprintf(trace, "%s%d", i ? " " : "", p->ChannelMappingi);
+		gf_fprintf(trace, " StreamCount=\"%d\" CoupledStreamCount=\"%d\" channelMapping=\"", p->opcfg.StreamCount, p->opcfg.CoupledCount);
+		for (i=0; i<p->opcfg.OutputChannelCount; i++) {
+			gf_fprintf(trace, "%s%d", i ? " " : "", p->opcfg.ChannelMappingi);
 		}
 		gf_fprintf(trace, "\"");
 	}
@@ -4374,11 +4808,15 @@
 		a->type = GF_ISOM_BOX_TYPE_DEC3;
 		gf_isom_box_dump_start(a, "EC3SpecificBox", trace);
 		a->type = GF_ISOM_BOX_TYPE_DAC3;
-		gf_fprintf(trace, "nb_streams=\"%d\" data_rate=\"%d\">\n", p->cfg.nb_streams, p->cfg.brcode);
+		gf_fprintf(trace, "nb_streams=\"%d\" data_rate=\"%d\">\n", p->cfg.nb_streams, p->cfg.brcode*1000);
 		for (i=0; i<p->cfg.nb_streams; i++) {
 			gf_fprintf(trace, "<EC3StreamConfig fscod=\"%d\" bsid=\"%d\" bsmod=\"%d\" acmod=\"%d\" lfon=\"%d\" asvc=\"%d\" num_sub_dep=\"%d\" chan_loc=\"%d\"/>\n",
 			 p->cfg.streamsi.fscod, p->cfg.streamsi.bsid, p->cfg.streamsi.bsmod, p->cfg.streamsi.acmod, p->cfg.streamsi.lfon, p->cfg.streamsi.asvc, p->cfg.streamsi.nb_dep_sub, p->cfg.streamsi.chan_loc);
 		}
+		if (p->cfg.atmos_ec3_ext || p->cfg.complexity_index_type) {
+			gf_fprintf(trace, "<ExtendedConfig flag_ec3_extension_type_a=\"%d\" complexity_index_type_a=\"%d\"/>\n",
+				p->cfg.atmos_ec3_ext, p->cfg.complexity_index_type);
+		}
 		gf_isom_box_dump_done("EC3SpecificBox", a, trace);
 	} else {
 		gf_isom_box_dump_start(a, "AC3SpecificBox", trace);
@@ -5488,8 +5926,8 @@
 			gf_fprintf(trace, "colour_type=\"%s\">\n", gf_4cc_to_str(ptr->colour_type));
 			if (ptr->opaque != NULL) {
 				gf_fprintf(trace, "<profile><!CDATA");
-				size_64 = 2*ptr->opaque_size;
-				prof_data_64 = gf_malloc(size_64);
+				size_64 = 2*ptr->opaque_size+3;
+				prof_data_64 = gf_malloc(sizeof(char) * size_64);
 				size_64 = gf_base64_encode((const char *) ptr->opaque, ptr->opaque_size, (char *)prof_data_64, size_64);
 				prof_data_64size_64 = 0;
 				gf_fprintf(trace, "%s", prof_data_64);
@@ -5675,6 +6113,9 @@
 {
 	GF_TrackGroupTypeBox *ptr = (GF_TrackGroupTypeBox *) a;
 	a->type = ptr->group_type;
+	//don't allow UNKN or UUID as type (possible buffer overflow when typecasting to GF_UnknownBox)
+	if ((a->type==GF_ISOM_BOX_TYPE_UNKNOWN) || (a->type==GF_ISOM_BOX_TYPE_UUID))
+		a->type = GF_4CC('u','k','n','w');
 	gf_isom_box_dump_start(a, "TrackGroupTypeBox", trace);
 	a->type = GF_ISOM_BOX_TYPE_TRGT;
 	gf_fprintf(trace, "track_group_id=\"%d\">\n", ptr->track_group_id);
@@ -5695,6 +6136,9 @@
 	u32 i;
 	GF_EntityToGroupTypeBox *ptr = (GF_EntityToGroupTypeBox *) a;
 	a->type = ptr->grouping_type;
+	//don't allow UNKN or UUID as type (possible buffer overflow when typecasting to GF_UnknownBox)
+	if ((a->type==GF_ISOM_BOX_TYPE_UNKNOWN) || (a->type==GF_ISOM_BOX_TYPE_UUID))
+		a->type = GF_4CC('u','k','n','w');
 	gf_isom_box_dump_start(a, "EntityToGroupTypeBox", trace);
 	a->type = GF_ISOM_BOX_TYPE_GRPT;
 	gf_fprintf(trace, "group_id=\"%d\">\n", ptr->group_id);
@@ -6424,4 +6868,32 @@
 	return GF_OK;
 }
 
+GF_Err keys_box_dump(GF_Box *a, FILE * trace)
+{
+	u32 i;
+	GF_MetaKey *k;
+	GF_MetaKeysBox *ptr = (GF_MetaKeysBox *)a;
+	gf_isom_box_dump_start(a, "KeysBox", trace);
+	gf_fprintf(trace, ">\n");
+
+	i=0;
+	while ( (k = (GF_MetaKey*)gf_list_enum(ptr->keys, &i))) {
+		gf_fprintf(trace, " <Key ns=\"%s\"", gf_4cc_to_str(k->ns) );
+		if (k->data) {
+			if (gf_utf8_is_legal(k->data, k->size)) {
+				gf_fprintf(trace, " name=\"");
+				dump_data_string(trace, k->data, k->size);
+				gf_fprintf(trace, "\"");
+			} else if (k->size<100) {
+				dump_data_attribute(trace, "name", k->data, k->size);
+			} else {
+				gf_fprintf(trace, " nameSize=\"%u\"", k->size);
+			}
+		}
+		gf_fprintf(trace, "/>\n");
+	}
+	gf_isom_box_dump_done("KeysBox", NULL, trace);
+	return GF_OK;
+}
+
 #endif /*GPAC_DISABLE_ISOM_DUMP*/

gpac-2.0.0.tar.gz/src/isomedia/box_funcs.c -> gpac-2.2.0.tar.gz/src/isomedia/box_funcs.c Changed

@@ -35,7 +35,7 @@
 	GF_Err ret;
 	u64 start;
 	start = gf_bs_get_position(bs);
-	ret = gf_isom_box_parse_ex(outBox, bs, 0, GF_TRUE);
+	ret = gf_isom_box_parse_ex(outBox, bs, 0, GF_TRUE, 0);
 	if (ret == GF_ISOM_INCOMPLETE_FILE) {
 		if (!*outBox) {
 			// We could not even read the box size, we at least need 8 bytes
@@ -90,7 +90,9 @@
 
 u64 unused_bytes = 0;
 
-GF_Err gf_isom_box_parse_ex(GF_Box **outBox, GF_BitStream *bs, u32 parent_type, Bool is_root_box)
+#define GF_SKIP_BOX 10
+
+GF_Err gf_isom_box_parse_ex(GF_Box **outBox, GF_BitStream *bs, u32 parent_type, Bool is_root_box, u64 parent_size)
 {
 	u32 type, uuid_type, hdr_size, restore_type;
 	u64 size, start, comp_start, end;
@@ -132,8 +134,8 @@
 				size = gf_bs_available(bs) + 8;
 			} else {
 				if (!skip_logs) {
-					GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Read Box type %s (0x%08X) at position "LLU" has size 0 but is not at root/file level !\n", gf_4cc_to_str(type), type, start));
-					return GF_ISOM_INVALID_FILE;
+					GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Read Box type %s (0x%08X) at position "LLU" has size 0 but is not at root/file level. Forbidden, skipping end of parent box !\n", gf_4cc_to_str(type), type, start));
+					return GF_SKIP_BOX;
 				}
 				return GF_OK;
 			}
@@ -162,11 +164,13 @@
 
 			if (do_uncompress) {
 				compb = gf_malloc((u32) (size-8));
+				if (!compb) return GF_OUT_OF_MEM;
 
 				compressed_size = (u32) (size - 8);
 				gf_bs_read_data(bs, compb, compressed_size);
 				e = gf_gz_decompress_payload(compb, compressed_size, &uncomp_data, &osize);
 				if (e) {
+					gf_free(compb);
 					GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Failed to uncompress payload for box type %s (0x%08X)\n", gf_4cc_to_str(otype), otype));
 					return e;
 				}
@@ -180,11 +184,20 @@
 			}
 		}
 	}
+
+#define ERR_EXIT(_e) { \
+		if (uncomp_bs) {\
+			gf_free(uncomp_data);\
+			gf_bs_del(uncomp_bs); \
+		}\
+		return _e;\
+	}
+
 	/*handle uuid*/
 	memset(uuid, 0, 16);
 	if (type == GF_ISOM_BOX_TYPE_UUID ) {
 		if (gf_bs_available(bs) < 16) {
-			return GF_ISOM_INCOMPLETE_FILE;
+			ERR_EXIT(GF_ISOM_INCOMPLETE_FILE);
 		}
 		gf_bs_read_data(bs, uuid, 16);
 		hdr_size += 16;
@@ -194,7 +207,7 @@
 	//handle large box
 	if (size == 1) {
 		if (gf_bs_available(bs) < 8) {
-			return GF_ISOM_INCOMPLETE_FILE;
+			ERR_EXIT(GF_ISOM_INCOMPLETE_FILE);
 		}
 		size = gf_bs_read_u64(bs);
 		hdr_size += 8;
@@ -203,8 +216,13 @@
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("iso file Read Box type %s size "LLD" start "LLD"\n", gf_4cc_to_str(type), size, start));
 
 	if ( size < hdr_size ) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("iso file Box size "LLD" less than box header size %d\n", size, hdr_size));
-		return GF_ISOM_INVALID_FILE;
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Box %s size "LLD" less than box header size %d\n", gf_4cc_to_str(type), size, hdr_size));
+		ERR_EXIT(GF_ISOM_INVALID_FILE);
+	}
+	//if parent size is given, make sure box fits within parent
+	if (parent_size && (parent_size<size)) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Box %s size "LLU" is larger than remaining parent size "LLU"\n", gf_4cc_to_str(type), size, parent_size ));
+		ERR_EXIT(GF_ISOM_INVALID_FILE);
 	}
 	restore_type = 0;
 	if ((parent_type==GF_ISOM_BOX_TYPE_STSD) && (type==GF_QT_SUBTYPE_RAW) ) {
@@ -220,25 +238,25 @@
 	//some special boxes (references and track groups) are handled by a single generic box with an associated ref/group type
 	if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_TREF)) {
 		newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_REFT);
-		if (!newBox) return GF_OUT_OF_MEM;
+		if (!newBox) ERR_EXIT(GF_OUT_OF_MEM);
 		((GF_TrackReferenceTypeBox*)newBox)->reference_type = type;
 	} else if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_IREF)) {
 		newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_REFI);
-		if (!newBox) return GF_OUT_OF_MEM;
+		if (!newBox) ERR_EXIT(GF_OUT_OF_MEM);
 		((GF_ItemReferenceTypeBox*)newBox)->reference_type = type;
 	} else if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_TRGR)) {
 		newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_TRGT);
-		if (!newBox) return GF_OUT_OF_MEM;
+		if (!newBox) ERR_EXIT(GF_OUT_OF_MEM);
 		((GF_TrackGroupTypeBox*)newBox)->group_type = type;
 	} else if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_GRPL)) {
 		newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_GRPT);
-		if (!newBox) return GF_OUT_OF_MEM;
+		if (!newBox) ERR_EXIT(GF_OUT_OF_MEM);
 		((GF_EntityToGroupTypeBox*)newBox)->grouping_type = type;
 	} else {
 		//OK, create the box based on the type
 		is_special = GF_FALSE;
 		newBox = gf_isom_box_new_ex(uuid_type ? uuid_type : type, parent_type, skip_logs, is_root_box);
-		if (!newBox) return GF_OUT_OF_MEM;
+		if (!newBox) ERR_EXIT(GF_OUT_OF_MEM);
 	}
 
 	//OK, init and read this box
@@ -255,7 +273,7 @@
 	if (size - hdr_size > end ) {
 		newBox->size = size - hdr_size - end;
 		*outBox = newBox;
-		return GF_ISOM_INCOMPLETE_FILE;
+		ERR_EXIT(GF_ISOM_INCOMPLETE_FILE);
 	}
 
 	newBox->size = size - hdr_size;
@@ -303,8 +321,10 @@
 	if (e && (e != GF_ISOM_INCOMPLETE_FILE)) {
 		gf_isom_box_del(newBox);
 		*outBox = NULL;
+		if (is_root_box && (e==GF_SKIP_BOX))
+			e = GF_ISOM_INVALID_FILE;
 
-		if (!skip_logs) {
+		if (!skip_logs && (e!=GF_SKIP_BOX)) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Read Box \"%s\" (start "LLU") failed (%s) - skipping\n", gf_4cc_to_str(type), start, gf_error_to_string(e)));
 		}
 		//we don't try to reparse known boxes that have been failing (too dangerous)
@@ -335,7 +355,7 @@
 GF_EXPORT
 GF_Err gf_isom_box_parse(GF_Box **outBox, GF_BitStream *bs)
 {
-	return gf_isom_box_parse_ex(outBox, bs, 0, GF_FALSE);
+	return gf_isom_box_parse_ex(outBox, bs, 0, GF_FALSE, 0);
 }
 
 void gf_isom_box_array_reset(GF_List *boxlist)
@@ -374,11 +394,6 @@
 }
 
 
-GF_Err gf_isom_box_array_read(GF_Box *parent, GF_BitStream *bs)
-{
-	return gf_isom_box_array_read_ex(parent, bs, parent->type);
-}
-
 #ifndef GPAC_DISABLE_ISOM_WRITE
 
 GF_EXPORT
@@ -534,6 +549,7 @@
 ISOM_BOX_IMPL_DECL(free)
 ISOM_BOX_IMPL_DECL(wide)
 ISOM_BOX_IMPL_DECL(mdat)
+ISOM_BOX_IMPL_DECL(imda)
 ISOM_BOX_IMPL_DECL_CHILD(moov)
 ISOM_BOX_IMPL_DECL(mvhd)
 ISOM_BOX_IMPL_DECL(mdhd)
@@ -879,6 +895,7 @@
 ISOM_BOX_IMPL_DECL(proj_type)
 //ISOM_BOX_IMPL_DECL(mesh)
 
+ISOM_BOX_IMPL_DECL(keys)
 
 #define BOX_DEFINE(__type, b_rad, __par) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 0, 0, __par, "p12", GF_FALSE}
 
@@ -1016,6 +1033,7 @@
 	BOX_DEFINE( GF_ISOM_BOX_TYPE_SKIP, free, "*"),
 	BOX_DEFINE( GF_ISOM_BOX_TYPE_MDAT, mdat, "file"),
 	BOX_DEFINE( GF_ISOM_BOX_TYPE_IDAT, mdat, "meta"),
+	BOX_DEFINE( GF_ISOM_BOX_TYPE_IMDA, mdat, "file"),
 	BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_MOOV, moov, "file"),
 	FBOX_DEFINE( GF_ISOM_BOX_TYPE_MVHD, mvhd, "moov", 1),
 	FBOX_DEFINE( GF_ISOM_BOX_TYPE_MDHD, mdhd, "mdia", 1),
@@ -1073,7 +1091,7 @@
 	BOX_DEFINE( GF_ISOM_BOX_TYPE_BTRT, btrt, "sample_entry"),
 	BOX_DEFINE( GF_ISOM_BOX_TYPE_PASP, pasp, "video_sample_entry ipco"),
 	BOX_DEFINE( GF_ISOM_BOX_TYPE_CLAP, clap, "video_sample_entry ipco"),
-	FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_META, meta, "file moov trak moof traf udta", 0),	//apple uses meta in moov->udta
+	BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_META, meta, "file moov trak moof traf udta"),	//apple uses meta in moov->udta
 	FBOX_DEFINE( GF_ISOM_BOX_TYPE_XML, xml, "meta", 0),
 	FBOX_DEFINE( GF_ISOM_BOX_TYPE_BXML, bxml, "meta", 0),
 	FBOX_DEFINE( GF_ISOM_BOX_TYPE_ILOC, iloc, "meta", 2),
@@ -1424,12 +1442,35 @@
 	ITUNES_TAG(GF_ISOM_ITUNE_COMPOSER),
 	ITUNES_TAG(GF_ISOM_ITUNE_TRACK),
 	ITUNES_TAG(GF_ISOM_ITUNE_CONDUCTOR),
+	ITUNES_TAG(GF_ISOM_ITUNE_ART_DIRECTOR),
+	ITUNES_TAG(GF_ISOM_ITUNE_ARRANGER),
+	ITUNES_TAG(GF_ISOM_ITUNE_LYRICIST),
+	ITUNES_TAG(GF_ISOM_ITUNE_COPY_ACK),
+	ITUNES_TAG(GF_ISOM_ITUNE_SONG_DESC),
+	ITUNES_TAG(GF_ISOM_ITUNE_DIRECTOR),
+	ITUNES_TAG(GF_ISOM_ITUNE_EQ_PRESET),
+	ITUNES_TAG(GF_ISOM_ITUNE_LINER_NOTES),
+	ITUNES_TAG(GF_ISOM_ITUNE_REC_COMPANY),
+	ITUNES_TAG(GF_ISOM_ITUNE_ORIG_ARTIST),
+	ITUNES_TAG(GF_ISOM_ITUNE_PHONO_RIGHTS),
+	ITUNES_TAG(GF_ISOM_ITUNE_PRODUCER),
+	ITUNES_TAG(GF_ISOM_ITUNE_PERFORMER),
+	ITUNES_TAG(GF_ISOM_ITUNE_PUBLISHER),
+	ITUNES_TAG(GF_ISOM_ITUNE_SOUND_ENG),
+	ITUNES_TAG(GF_ISOM_ITUNE_SOLOIST),
+	ITUNES_TAG(GF_ISOM_ITUNE_CREDITS),
+	ITUNES_TAG(GF_ISOM_ITUNE_THANKS),
+	ITUNES_TAG(GF_ISOM_ITUNE_ONLINE),
+	ITUNES_TAG(GF_ISOM_ITUNE_EXEC_PRODUCER),
+	ITUNES_TAG(GF_ISOM_ITUNE_LOCATION),
+
 	BOX_DEFINE_S( GF_ISOM_BOX_TYPE_iTunesSpecificInfo, ilst_item, "ilst data", "apple"),
 	BOX_DEFINE_S(GF_ISOM_BOX_TYPE_GMHD, def_parent, "minf", "apple"),
 	BOX_DEFINE_S(GF_QT_BOX_TYPE_LOAD, load, "trak", "apple"),
 	BOX_DEFINE_S(GF_QT_BOX_TYPE_TAPT, def_parent, "trak", "apple"),
 	FBOX_DEFINE_S( GF_QT_BOX_TYPE_GMIN, gmin, "gmhd", 0, "apple"),
 	FBOX_DEFINE_FLAGS_S( GF_QT_BOX_TYPE_ALIS, alis, "dref", 0, 1, "apple"),
+	FBOX_DEFINE_FLAGS_S( GF_QT_BOX_TYPE_CIOS, alis, "dref", 0, 1, "apple"),
 	FBOX_DEFINE_S( GF_QT_BOX_TYPE_CLEF, clef, "tapt", 0, "apple"),
 	FBOX_DEFINE_S( GF_QT_BOX_TYPE_PROF, clef, "tapt", 0, "apple"),
 	FBOX_DEFINE_S( GF_QT_BOX_TYPE_ENOF, clef, "tapt", 0, "apple"),
@@ -1488,7 +1529,8 @@
 	BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_RGBA, video_sample_entry, "stsd", "apple"),
 	BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_ABGR, video_sample_entry, "stsd", "apple"),
 	
-	
+	FBOX_DEFINE_S(GF_QT_BOX_TYPE_STPS, stss, "stbl", 0, "apple"),
+
 	//dolby boxes
 	BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AC3, audio_sample_entry, "stsd", "dolby"),
 	BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_EC3, audio_sample_entry, "stsd", "dolby"),
@@ -1567,6 +1609,31 @@
 	FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_EQUI, proj_type, "proj", 0, "youtube"),
 	FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_MESH, proj_type, "proj", 0, "youtube"),
 
+	FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_KEYS, keys, "meta", 0, "apple"),
+
+	BOX_DEFINE_S(GF_QT_SUBTYPE_ALAC, unkn, "stsd", "apple"),
+	BOX_DEFINE_S(GF_ISOM_SUBTYPE_FFV1, unkn, "stsd", "ffmpeg"),
+
+	BOX_DEFINE_S(GF_4CC('v','c','-','1'), unkn, "stsd", "smpte-RP2025"),
+	BOX_DEFINE_S(GF_4CC('d','v','c','1'), unkn, "vc-1 ipco", "smpte-RP2025"),
+
+	BOX_DEFINE_S(GF_4CC('G','M','C','W'), unkn, "stsd", "GPAC"),
+	BOX_DEFINE_S(GF_4CC('G','M','C','C'), unkn, "GMCW", "GPAC"),
+
+	/* for now we don't parse these*/
+	BOX_DEFINE_S(GF_4CC('u','n','c','C'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('c','m','p','d'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('c','p','a','l'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('c','p','a','t'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('c','l','e','v'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('s','p','l','z'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('s','n','u','c'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('s','b','p','m'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('c','l','o','c'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('f','p','c','k'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('d','i','s','i'), unkn, "video_sample_entry ipco", "rawff"),
+	BOX_DEFINE_S(GF_4CC('d','e','p','i'), unkn, "video_sample_entry ipco", "rawff"),
+
 /*
 	GF_ISOM_BOX_TYPE_CBMP	= GF_4CC( 'c', 'b', 'm', 'p' ),
 	GF_ISOM_BOX_TYPE_EQUI	= GF_4CC( 'e', 'q', 'u', 'i' ),
@@ -1603,8 +1670,6 @@
 static u32 get_box_reg_idx(u32 boxCode, u32 parent_type, u32 start_from)
 {
 	u32 i=0, count = gf_isom_get_num_supported_boxes();
-	const char *parent_name = parent_type ? gf_4cc_to_str(parent_type) : NULL;
-
 	if (!start_from) start_from = 1;
 
 	for (i=start_from; i<count; i++) {
@@ -1614,7 +1679,7 @@
 
 		if (!parent_type)
 			return i;
-		if (strstr(box_registryi.parents_4cc, parent_name) != NULL)
+		if (strstr(box_registryi.parents_4cc, gf_4cc_to_str(parent_type)) != NULL)
 			return i;
 		if (strstr(box_registryi.parents_4cc, "*") != NULL)
 			return i;
@@ -1658,7 +1723,6 @@
 				break;
 			//some sample descritions are handled as generic ones but we know them, don't warn
 			case GF_ISOM_BOX_TYPE_STSD:
-				if (boxType==GF_ISOM_SUBTYPE_FFV1) break;
 				//fallthrough
 			default:
 				if (boxType==GF_ISOM_BOX_TYPE_GDAT) break;
@@ -1714,18 +1778,19 @@
 	return gf_isom_box_new_ex(boxType, 0, 0, GF_FALSE);
 }
 
-GF_Err gf_isom_box_array_read_ex(GF_Box *parent, GF_BitStream *bs, u32 parent_type)
+GF_Err gf_isom_box_array_read(GF_Box *parent, GF_BitStream *bs)
 {
 	GF_Err e;
+	u32 parent_type = parent->type;
 	GF_Box *a = NULL;
 	Bool skip_logs = (gf_bs_get_cookie(bs) & GF_ISOM_BS_COOKIE_NO_LOGS ) ? GF_TRUE : GF_FALSE;
 
 	//we may have terminators in some QT files (4 bytes set to 0 ...)
 	while (parent->size>=8) {
-		e = gf_isom_box_parse_ex(&a, bs, parent_type, GF_FALSE);
+		e = gf_isom_box_parse_ex(&a, bs, parent_type, GF_FALSE, skip_logs ? 0 : parent->size);
 		if (e) {
 			if (a) gf_isom_box_del(a);
-			return e;
+			return (e==GF_SKIP_BOX) ? GF_OK : e;
 		}
 		//sub box parsing aborted with no error
 		if (!a) return GF_OK;
@@ -1744,7 +1809,7 @@
 		}
 
 		//check container validity
-		if (strlen(a->registry->parents_4cc)) {
+		if (parent_type && strlen(a->registry->parents_4cc)) {
 			Bool parent_OK = GF_FALSE;
 			const char *parent_code = gf_4cc_to_str(parent->type);
 			if (parent->type == GF_ISOM_BOX_TYPE_UNKNOWN)
@@ -1784,7 +1849,7 @@
 		e = gf_list_add(parent->child_boxes, a);
 		if (e) return e;
 
-		if (parent->registry->add_rem_fn) {
+		if (parent->registry && parent->registry->add_rem_fn) {
 			e = parent->registry->add_rem_fn(parent, a, GF_FALSE);
 			if (e) {
 				if (e == GF_ISOM_INVALID_MEDIA) return GF_OK;
@@ -2025,7 +2090,7 @@
 
 #ifndef GPAC_DISABLE_ISOM_DUMP
 
-GF_Err gf_isom_box_dump_start(GF_Box *a, const char *name, FILE * trace)
+GF_Err gf_isom_box_dump_start_ex(GF_Box *a, const char *name, FILE * trace, Bool force_version)
 {
 	gf_fprintf(trace, "<%s ", name);
 	if (a->size > 0xFFFFFFFF) {
@@ -2049,7 +2114,7 @@
 		gf_fprintf(trace, "}\" ");
 	}
 
-	if (a->registry->max_version_plus_one) {
+	if (a->registry->max_version_plus_one || force_version) {
 		gf_fprintf(trace, "Version=\"%d\" Flags=\"%d\" ", ((GF_FullBox*)a)->version,((GF_FullBox*)a)->flags);
 	}
 	gf_fprintf(trace, "Specification=\"%s\" ", a->registry->spec);
@@ -2060,6 +2125,10 @@
 	}
 	return GF_OK;
 }
+GF_Err gf_isom_box_dump_start(GF_Box *a, const char *name, FILE * trace)
+{
+	return gf_isom_box_dump_start_ex(a, name, trace, GF_FALSE);
+}
 
 GF_Err gf_isom_box_dump(void *ptr, FILE * trace)
 {

gpac-2.0.0.tar.gz/src/isomedia/drm_sample.c -> gpac-2.2.0.tar.gz/src/isomedia/drm_sample.c Changed

@@ -418,6 +418,7 @@
 	u32 original_format;
 	GF_Err e;
 	u32 gnr_type=0;
+	u32 *overwrite_type=NULL;
 	GF_SampleEntryBox *sea;
 	GF_ProtectionSchemeInfoBox *sinf;
 	GF_TrackBox *trak = gf_isom_get_track_from_file(the_file, trackNumber);
@@ -429,14 +430,16 @@
 	original_format = sea->type;
 	if (original_format==GF_ISOM_BOX_TYPE_GNRA) {
 		gnr_type = original_format;
-		original_format = ((GF_GenericAudioSampleEntryBox*)sea)->EntryType;
+		overwrite_type = &((GF_GenericAudioSampleEntryBox*)sea)->EntryType;
 	} else if (original_format==GF_ISOM_BOX_TYPE_GNRV) {
 		gnr_type = original_format;
-		original_format = ((GF_GenericVisualSampleEntryBox*)sea)->EntryType;
+		overwrite_type = &((GF_GenericVisualSampleEntryBox*)sea)->EntryType;
 	} else if (original_format==GF_ISOM_BOX_TYPE_GNRM) {
 		gnr_type = original_format;
-		original_format = ((GF_GenericSampleEntryBox*)sea)->EntryType;
+		overwrite_type = &((GF_GenericSampleEntryBox*)sea)->EntryType;
 	}
+	if (overwrite_type)
+		original_format = *overwrite_type;
 
 	/* Replacing the Media Type */
 	switch (sea->type) {
@@ -509,9 +512,11 @@
 		return GF_BAD_PARAM;
 	default:
 		if (sea->internal_type == GF_ISOM_SAMPLE_ENTRY_AUDIO) {
-			sea->type = GF_ISOM_BOX_TYPE_ENCA;
+			if (overwrite_type) *overwrite_type = GF_ISOM_BOX_TYPE_ENCA;
+			else sea->type = GF_ISOM_BOX_TYPE_ENCA;
 		} else if (sea->internal_type == GF_ISOM_SAMPLE_ENTRY_VIDEO) {
-			sea->type = GF_ISOM_BOX_TYPE_ENCV;
+			if (overwrite_type) *overwrite_type = GF_ISOM_BOX_TYPE_ENCV;
+			else sea->type = GF_ISOM_BOX_TYPE_ENCV;
 		} else {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("iso file unsupported entry type %s for CENC.\n", gf_4cc_to_str(sea->type) ));
 			return GF_BAD_PARAM;
@@ -1182,8 +1187,7 @@
 		senc->cenc_saiz->default_sample_info_size = len;
 	} else {
 		if (senc->cenc_saiz->sample_count + 1 > senc->cenc_saiz->sample_alloc) {
-			if (!senc->cenc_saiz->sample_alloc) senc->cenc_saiz->sample_alloc = senc->cenc_saiz->sample_count+1;
-			else senc->cenc_saiz->sample_alloc *= 2;
+			senc->cenc_saiz->sample_alloc = senc->cenc_saiz->sample_count+10;
 
 			senc->cenc_saiz->sample_info_size = (u8*)gf_realloc(senc->cenc_saiz->sample_info_size, sizeof(u8)*(senc->cenc_saiz->sample_alloc));
 		}
@@ -1236,10 +1240,7 @@
 		u32 sample_diff = sample_number - senc->cenc_saiz->sample_count;
 
 		if (senc->cenc_saiz->sample_count + sample_diff > senc->cenc_saiz->sample_alloc) {
-			senc->cenc_saiz->sample_alloc *= 2;
-			if (senc->cenc_saiz->sample_alloc < senc->cenc_saiz->sample_count + sample_diff) {
-				senc->cenc_saiz->sample_alloc = senc->cenc_saiz->sample_count + sample_diff;
-			}
+			senc->cenc_saiz->sample_alloc = senc->cenc_saiz->sample_count + sample_diff + 10;
 			senc->cenc_saiz->sample_info_size = (u8*)gf_realloc(senc->cenc_saiz->sample_info_size, sizeof(u8)*(senc->cenc_saiz->sample_alloc));
 			if (!senc->cenc_saiz->sample_info_size) return GF_OUT_OF_MEM;
 		}
@@ -1306,6 +1307,7 @@
 	case GF_ISOM_BOX_TYPE_SENC:
 	case 0:
 		senc = trak->sample_encryption;
+		if (!senc) return GF_BAD_PARAM;
 		break;
 	default:
 		return GF_NOT_SUPPORTED;
@@ -1701,8 +1703,6 @@
 	return GF_OK;
 }
 
-u32 gf_isom_has_cenc_sample_group_ex(GF_TrackBox *trak);
-
 void gf_isom_cenc_get_default_info_internal(GF_TrackBox *trak, u32 sampleDescriptionIndex, u32 *container_type, Bool *default_IsEncrypted, u8 *crypt_byte_block, u8 *skip_byte_block, const u8 **key_info, u32 *key_info_size)
 {
 	GF_ProtectionSchemeInfoBox *sinf;

gpac-2.0.0.tar.gz/src/isomedia/iff.c -> gpac-2.2.0.tar.gz/src/isomedia/iff.c Changed

gpac-2.0.0.tar.gz/src/isomedia/isom_intern.c -> gpac-2.2.0.tar.gz/src/isomedia/isom_intern.c Changed

@@ -104,7 +104,7 @@
 		if (gf_list_count(moof->PSSHs)) {
 			u8 *pssh_data;
 			u32 pssh_len;
-			u32 j, k, nb_pssh = gf_list_count(moof->PSSHs);
+			u32 k, nb_pssh = gf_list_count(moof->PSSHs);
 			GF_BitStream *pssh_bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 			gf_bs_write_u32(pssh_bs, nb_pssh);
 			for (j=0; j<nb_pssh; j++) {
@@ -132,7 +132,7 @@
 		if (gf_list_count(mov->emsgs)) {
 			u8 *emsg_data;
 			u32 emsg_len;
-			u32 j, nb_emsg = gf_list_count(mov->emsgs);
+			u32 nb_emsg = gf_list_count(mov->emsgs);
 			GF_BitStream *emsg_bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 			for (j=0; j<nb_emsg; j++) {
 				GF_Box *emsg = gf_list_get(mov->emsgs, j);
@@ -218,20 +218,25 @@
 
 			while ((trun = (GF_TrackFragmentRunBox*)gf_list_enum(traf->TrackRuns, &j))) {
 				u32 i;
+				Bool aborted=GF_FALSE;
+				//use sample flags
 				trun->flags |= GF_ISOM_TRUN_FLAGS;
+				//remove first sample flag (cannot be used with sample flags)
+				trun->flags &= ~GF_ISOM_TRUN_FIRST_FLAG;
 				for (i=0; i<trun->nb_samples; i++) {
 					GF_TrunEntry *entry = &trun->samplesi;
+					if (sample_index >= traf->sdtp->sampleCount) {
+						aborted = GF_TRUE;
+						break;
+					}
 					const u8 info = traf->sdtp->sample_infosample_index;
 					entry->flags |= GF_ISOM_GET_FRAG_DEPEND_FLAGS(info >> 6, info >> 4, info >> 2, info);
 					sample_index++;
-					if (sample_index > traf->sdtp->sampleCount) {
-						GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Error: TRAF box of track id=%u contained an inconsistent SDTP.\n", traf->tfhd->trackID));
-						return;
-					}
 				}
+				if (aborted) break;
 			}
-			if (sample_index < traf->sdtp->sampleCount) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Error: TRAF box of track id=%u list less samples than SDTP.\n", traf->tfhd->trackID));
+			if (sample_index != traf->sdtp->sampleCount) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("iso file Error: TRAF box of track id=%u list %d samples but SDTP %d.\n", traf->tfhd->trackID, sample_index, traf->sdtp->sampleCount));
 			}
 			gf_isom_box_del_parent(&traf->child_boxes, (GF_Box*)traf->sdtp);
 			traf->sdtp = NULL;
@@ -373,7 +378,8 @@
 		e = gf_isom_parse_root_box(&a, mov->movieFileMap->bs, boxType, bytesMissing, progressive_mode);
 
 		if (e >= 0) {
-
+			//safety check, should never happen
+			if (!a) return GF_ISOM_INVALID_FILE;
 		} else if (e == GF_ISOM_INCOMPLETE_FILE) {
 			/*our mdat is uncomplete, only valid for READ ONLY files...*/
 			if (mov->openMode != GF_ISOM_OPEN_READ) {
@@ -609,7 +615,10 @@
 					mov->root_sidx = (GF_SegmentIndexBox *) a;
 					mov->sidx_start_offset = mov->current_top_box_start;
 					mov->sidx_end_offset = gf_bs_get_position(mov->movieFileMap->bs);
-
+					if (!mov->root_sidx_end_offset) {
+						mov->root_sidx_end_offset = mov->sidx_end_offset;
+						mov->root_sidx_start_offset = mov->sidx_start_offset;
+					}
 				}
 				else if (a->type==GF_ISOM_BOX_TYPE_STYP) {
 					mov->styp_start_offset = mov->current_top_box_start;
@@ -768,7 +777,14 @@
 				break;
 			}
 #endif
-
+		case GF_ISOM_BOX_TYPE_MFRA:
+		case GF_ISOM_BOX_TYPE_MFRO:
+			//only keep for dump mode, otherwise we ignore these boxes and we don't want to carry them over in non-fragmented file
+			if (! (mov->FragmentsFlags & GF_ISOM_FRAG_READ_DEBUG)) {
+				totSize += a->size;
+				gf_isom_box_del(a);
+				break;
+			}
 		default:
 			totSize += a->size;
 			e = gf_list_add(mov->TopBoxes, a);
@@ -970,6 +986,8 @@
 
 	//OK, let's parse the movie...
 	mov->LastError = gf_isom_parse_movie_boxes(mov, NULL, &bytes, 0);
+	if (((OpenMode & 0xFF) == GF_ISOM_OPEN_READ_DUMP) && (mov->LastError==GF_ISOM_INCOMPLETE_FILE))
+		mov->LastError = GF_OK;
 
 #if 0
 	if (!mov->LastError && (OpenMode == GF_ISOM_OPEN_CAT_FRAGMENTS)) {
@@ -992,6 +1010,7 @@
 GF_Err gf_isom_set_write_callback(GF_ISOFile *mov,
 			GF_Err (*on_block_out)(void *cbk, u8 *data, u32 block_size),
 			GF_Err (*on_block_patch)(void *usr_data, u8 *block, u32 block_size, u64 block_offset, Bool is_insert),
+			void (*on_last_block_start)(void *usr_data),
 			void *usr_data,
 			u32 block_size)
 {
@@ -1001,6 +1020,7 @@
 	else return GF_BAD_PARAM;
 	mov->on_block_out = on_block_out;
 	mov->on_block_patch = on_block_patch;
+	mov->on_last_block_start = on_last_block_start;
 	mov->on_block_out_usr_data = usr_data;
 	mov->on_block_out_block_size = block_size;
 	return GF_OK;
@@ -1049,6 +1069,9 @@
 
 	if (mov->block_buffer)
 		gf_free(mov->block_buffer);
+
+	if (mov->emsgs)
+		gf_isom_box_array_del(mov->emsgs);
 #endif
 	if (mov->last_producer_ref_time)
 		gf_isom_box_del((GF_Box *) mov->last_producer_ref_time);

gpac-2.0.0.tar.gz/src/isomedia/isom_read.c -> gpac-2.2.0.tar.gz/src/isomedia/isom_read.c Changed

@@ -561,11 +561,22 @@
 
 
 GF_EXPORT
-GF_Err gf_isom_write(GF_ISOFile *movie) {
+GF_Err gf_isom_write(GF_ISOFile *movie)
+{
 	GF_Err e;
 	if (movie == NULL) return GF_ISOM_INVALID_FILE;
 	e = GF_OK;
 
+	//update duration of each track
+	if (movie->moov) {
+		u32 i, count = gf_list_count(movie->moov->trackList);
+		for (i=0; i<count; i++) {
+			GF_TrackBox *trak = gf_list_get(movie->moov->trackList, i);
+			e = SetTrackDuration(trak);
+			if (e) return e;
+		}
+	}
+
 #ifndef GPAC_DISABLE_ISOM_WRITE
 	//write our movie to the file
 	if ((movie->openMode != GF_ISOM_OPEN_READ) && (movie->openMode != GF_ISOM_OPEN_READ_EDIT)) {
@@ -1988,6 +1999,24 @@
 }
 
 GF_EXPORT
+u32 gf_isom_get_avg_sample_delta(GF_ISOFile *the_file, u32 trackNumber)
+{
+	GF_TrackBox *trak = gf_isom_get_track_from_file(the_file, trackNumber);
+	if (!trak || !trak->Media || !trak->Media->information || !trak->Media->information->sampleTable || !trak->Media->information->sampleTable->TimeToSample) return 0;
+
+	GF_TimeToSampleBox *stts = trak->Media->information->sampleTable->TimeToSample;
+	u32 i, nb_ent = 0, min = 0;
+	for (i=0; i<stts->nb_entries; i++) {
+		if (!nb_ent || nb_ent < stts->entriesi.sampleCount) {
+			min = stts->entriesi.sampleDelta;
+			nb_ent = stts->entriesi.sampleCount;
+		}
+	}
+	return min;
+}
+
+
+GF_EXPORT
 u32 gf_isom_get_max_sample_cts_offset(GF_ISOFile *the_file, u32 trackNumber)
 {
 	GF_TrackBox *trak = gf_isom_get_track_from_file(the_file, trackNumber);
@@ -2721,6 +2750,11 @@
 		ptr = (GF_UnknownBox*)gf_list_get(map->boxes, UserDataIndex-1);
 
 		if (ptr->type == GF_ISOM_BOX_TYPE_UNKNOWN) {
+			if (!ptr->dataSize) {
+				*userData = NULL;
+				*userDataSize = 0;
+				return GF_OK;
+			}
 			*userData = (char *)gf_malloc(sizeof(char)*ptr->dataSize);
 			if (!*userData) return GF_OUT_OF_MEM;
 			memcpy(*userData, ptr->data, sizeof(char)*ptr->dataSize);
@@ -2728,6 +2762,11 @@
 			return GF_OK;
 		} else if (ptr->type == GF_ISOM_BOX_TYPE_UUID) {
 			GF_UnknownUUIDBox *p_uuid = (GF_UnknownUUIDBox *)ptr;
+			if (!p_uuid->dataSize) {
+				*userData = NULL;
+				*userDataSize = 0;
+				return GF_OK;
+			}
 			*userData = (char *)gf_malloc(sizeof(char)*p_uuid->dataSize);
 			if (!*userData) return GF_OUT_OF_MEM;
 			memcpy(*userData, p_uuid->data, sizeof(char)*p_uuid->dataSize);
@@ -3119,13 +3158,13 @@
 	stbl_RemoveSize(stbl, 1, nb_samples);
 	stbl_RemoveChunk(stbl, 1, nb_samples);
 	stbl_RemoveRedundant(stbl, 1, nb_samples);
+	stbl_RemoveRAPs(stbl, nb_samples);
 
 	//then remove sample per sample for the rest, which is either
 	//- sparse data
 	//- allocated structure rather than memmove-able array
 	//- not very frequent info (paddind bits)
 	while (nb_samples) {
-		stbl_RemoveRAP(stbl, 1);
 		stbl_RemoveShadow(stbl, 1);
 		stbl_RemoveSubSample(stbl, 1);
 		stbl_RemovePaddingBits(stbl, 1);
@@ -3529,6 +3568,23 @@
 	return GF_OK;
 }
 
+static void gf_isom_gen_desc_get_dsi(GF_GenericSampleDescription *udesc, GF_List *child_boxes)
+{
+	if (!child_boxes) return;
+	GF_UnknownBox *a=NULL;
+	u32 i=0;
+	while ((a=gf_list_enum(child_boxes, &i))) {
+		if (a->type == GF_ISOM_BOX_TYPE_UNKNOWN) break;
+		a = NULL;
+	}
+	if (!a) return;
+	udesc->extension_buf = (char*)gf_malloc(sizeof(char) * a->dataSize);
+	if (udesc->extension_buf) {
+		udesc->extension_buf_size = a->dataSize;
+		memcpy(udesc->extension_buf, a->data, a->dataSize);
+		udesc->ext_box_wrap = a->original_4cc;
+	}
+}
 
 GF_EXPORT
 GF_GenericSampleDescription *gf_isom_get_generic_sample_description(GF_ISOFile *movie, u32 trackNumber, u32 StreamDescriptionIndex)
@@ -3581,6 +3637,8 @@
 				return NULL;
 			}
 			memcpy(udesc->extension_buf, entry->data, entry->data_size);
+		} else {
+			gf_isom_gen_desc_get_dsi(udesc, entry->child_boxes);
 		}
 		return udesc;
 	case GF_ISOM_BOX_TYPE_GNRA:
@@ -3606,6 +3664,8 @@
 				return NULL;
 			}
 			memcpy(udesc->extension_buf, gena->data, gena->data_size);
+		} else {
+			gf_isom_gen_desc_get_dsi(udesc, entry->child_boxes);
 		}
 		return udesc;
 	case GF_ISOM_BOX_TYPE_GNRM:
@@ -3625,6 +3685,8 @@
 				return NULL;
 			}
 			memcpy(udesc->extension_buf, genm->data, genm->data_size);
+		} else {
+			gf_isom_gen_desc_get_dsi(udesc, entry->child_boxes);
 		}
 		return udesc;
 	}
@@ -3808,15 +3870,71 @@
 	if (entry->internal_type!=GF_ISOM_SAMPLE_ENTRY_VIDEO) {
 		return GF_BAD_PARAM;
 	}
-	GF_ColourInformationBox *clr = (GF_ColourInformationBox *) gf_isom_box_find_child(entry->child_boxes, GF_ISOM_BOX_TYPE_COLR);
-	if (!clr) return GF_NOT_FOUND;
 
-	if (colour_type) *colour_type = clr->colour_type;
-	if (colour_primaries) *colour_primaries = clr->colour_primaries;
-	if (transfer_characteristics) *transfer_characteristics = clr->transfer_characteristics;
-	if (matrix_coefficients) *matrix_coefficients = clr->matrix_coefficients;
-	if (full_range_flag) *full_range_flag = clr->full_range_flag;
-	return GF_OK;
+	u32 i, count = gf_list_count(entry->child_boxes);
+	for (i=0; i<count; i++) {
+		GF_ColourInformationBox *clr = (GF_ColourInformationBox *) gf_list_get(entry->child_boxes, i);
+		if (clr->type != GF_ISOM_BOX_TYPE_COLR) continue;
+		if (clr->is_jp2) continue;
+		if (clr->opaque_size) continue;
+
+		if (colour_type) *colour_type = clr->colour_type;
+		if (colour_primaries) *colour_primaries = clr->colour_primaries;
+		if (transfer_characteristics) *transfer_characteristics = clr->transfer_characteristics;
+		if (matrix_coefficients) *matrix_coefficients = clr->matrix_coefficients;
+		if (full_range_flag) *full_range_flag = clr->full_range_flag;
+		return GF_OK;
+	}
+	return GF_NOT_FOUND;
+}
+
+GF_EXPORT
+GF_Err gf_isom_get_icc_profile(GF_ISOFile *movie, u32 trackNumber, u32 StreamDescriptionIndex, Bool *icc_restricted, const u8 **icc, u32 *icc_size)
+{
+	GF_TrackBox *trak;
+	GF_VisualSampleEntryBox *entry;
+	GF_SampleDescriptionBox *stsd;
+
+	if (!icc || !icc_size) return GF_BAD_PARAM;
+	*icc = NULL;
+	*icc_size = 0;
+	if (icc_restricted) *icc_restricted = GF_FALSE;
+
+	trak = gf_isom_get_track_from_file(movie, trackNumber);
+	if (!trak) return GF_BAD_PARAM;
+
+	stsd = trak->Media->information->sampleTable->SampleDescription;
+	if (!stsd) return movie->LastError = GF_ISOM_INVALID_FILE;
+	if (!StreamDescriptionIndex || StreamDescriptionIndex > gf_list_count(stsd->child_boxes)) return movie->LastError = GF_BAD_PARAM;
+
+	entry = (GF_VisualSampleEntryBox *)gf_list_get(stsd->child_boxes, StreamDescriptionIndex - 1);
+	//no support for generic sample entries (eg, no MPEG4 descriptor)
+	if (entry == NULL) return GF_OK;
+
+	//valid for MPEG visual, JPG and 3GPP H263
+	if (entry->internal_type!=GF_ISOM_SAMPLE_ENTRY_VIDEO) {
+		return GF_BAD_PARAM;
+	}
+
+	u32 i, count = gf_list_count(entry->child_boxes);
+	for (i=0; i<count; i++) {
+		GF_ColourInformationBox *clr = (GF_ColourInformationBox *) gf_list_get(entry->child_boxes, i);
+		if (clr->type != GF_ISOM_BOX_TYPE_COLR) continue;
+		if (clr->is_jp2) continue;
+		if (!clr->opaque_size) continue;
+
+		if (clr->colour_type==GF_4CC('r', 'I', 'C', 'C')) {
+			if (icc_restricted) *icc_restricted = GF_TRUE;
+			*icc = clr->opaque;
+			*icc_size = clr->opaque_size;
+		}
+		else if (clr->colour_type==GF_4CC('p', 'r', 'o', 'f')) {
+			*icc = clr->opaque;
+			*icc_size = clr->opaque_size;
+		}
+		return GF_OK;
+	}
+	return GF_NOT_FOUND;
 }
 
 GF_EXPORT
@@ -4193,7 +4311,7 @@
 	*data = NULL;
 	*data_len = 0;
 
-	meta = (GF_MetaBox *) gf_isom_get_meta_extensions(mov, GF_FALSE);
+	meta = (GF_MetaBox *) gf_isom_get_meta_extensions(mov, 0);
 	if (!meta) return GF_URL_ERROR;
 
 	ilst = gf_isom_locate_box(meta->child_boxes, GF_ISOM_BOX_TYPE_ILST, NULL);
@@ -4233,12 +4351,16 @@
 	GF_ItemListBox *ilst;
 	GF_MetaBox *meta;
 	GF_DataBox *dbox = NULL;
+	Bool found=GF_FALSE;
 	u32 itype, tag_val;
 	s32 tag_idx;
 	*data = NULL;
 	*data_len = 0;
+	*out_int_val = 0;
+	*out_int_val2 = 0;
+	*out_flags = 0;
 
-	meta = (GF_MetaBox *) gf_isom_get_meta_extensions(mov, GF_FALSE);
+	meta = (GF_MetaBox *) gf_isom_get_meta_extensions(mov, 0);
 	if (!meta) return GF_URL_ERROR;
 
 	ilst = gf_isom_locate_box(meta->child_boxes, GF_ISOM_BOX_TYPE_ILST, NULL);
@@ -4248,6 +4370,7 @@
 	while ( (info=(GF_ListItemBox*)gf_list_enum(ilst->child_boxes, &i))) {
 		GF_DataBox *data_box = NULL;
 		if (gf_itags_find_by_itag(info->type)<0) {
+			tag_val = info->type;
 			if (info->type==GF_ISOM_BOX_TYPE_UNKNOWN) {
 				data_box = (GF_DataBox *) gf_isom_box_find_child(info->child_boxes, GF_ISOM_BOX_TYPE_DATA);
 				if (!data_box) continue;
@@ -4259,12 +4382,21 @@
 		}
 		if (child_index==idx) {
 			dbox = data_box;
+			found = GF_TRUE;
 			break;
 		}
 		child_index++;
 	}
-	if (!dbox) return GF_URL_ERROR;
 
+	if (!dbox) {
+		if (found) {
+			*data = NULL;
+			*data_len = 1;
+			*out_tag = tag_val;
+			return GF_OK;
+		}
+		return GF_URL_ERROR;
+	}
 	*out_flags = dbox->flags;
 	*out_tag = tag_val;
 	if (!dbox->data) {
@@ -4357,6 +4489,132 @@
 	return GF_OK;
 }
 
+GF_EXPORT
+GF_Err gf_isom_enum_udta_keys(GF_ISOFile *mov, u32 idx, GF_QT_UDTAKey *okey)
+{
+	u32 i, count;
+
+	GF_MetaBox *meta = (GF_MetaBox *) gf_isom_get_meta_extensions(mov, 2);
+	if (!meta || !meta->keys) return GF_URL_ERROR;
+
+	GF_MetaKey *k = gf_list_get(meta->keys->keys, idx);
+	if (!k) return GF_URL_ERROR;
+	if (!okey) return GF_OK;
+
+	memset(okey, 0, sizeof(GF_QT_UDTAKey) );
+	okey->name = k->data;
+	okey->ns = k->ns;
+
+	GF_ListItemBox *ilst = (GF_ListItemBox *) gf_isom_locate_box(meta->child_boxes, GF_ISOM_BOX_TYPE_ILST, NULL);
+	if (!ilst) return GF_OK;
+
+	GF_DataBox *data_box = NULL;
+	count = gf_list_count(ilst->child_boxes);
+	for (i=0; i<count; i++) {
+		GF_UnknownBox *u = gf_list_get(ilst->child_boxes, i);
+		if (u->type!=GF_ISOM_BOX_TYPE_UNKNOWN) continue;
+		if (u->original_4cc==idx+1) {
+			data_box = (GF_DataBox *) gf_isom_box_find_child(u->child_boxes, GF_ISOM_BOX_TYPE_DATA);
+		}
+	}
+
+	okey->type=GF_QT_KEY_OPAQUE;
+	if (!data_box || (data_box->version!=0)) {
+		if (data_box) {
+			okey->value.data.data = data_box->data;
+			okey->value.data.data_len = data_box->dataSize;
+		}
+		return GF_OK;
+	}
+	okey->type = data_box->flags;
+
+	u32 nb_bits = 8 * data_box->dataSize;
+	GF_BitStream *bs = gf_bs_new(data_box->data, data_box->dataSize, GF_BITSTREAM_READ);
+	switch (okey->type) {
+	case GF_QT_KEY_UTF8:
+	case GF_QT_KEY_UTF8_SORT:
+		okey->value.string = data_box->data;
+		break;
+
+	case GF_QT_KEY_SIGNED_VSIZE:
+	{
+		u32 val = gf_bs_read_int(bs, nb_bits);
+		if (nb_bits==8) okey->value.sint = (s64) (s8) val;
+		else if (nb_bits==16) okey->value.sint = (s64) (s16) val;
+		else if (nb_bits==32) okey->value.sint = (s64) (s32) val;
+		else if (nb_bits==64) okey->value.sint = (s64) val;
+	}
+		break;
+	case GF_QT_KEY_UNSIGNED_VSIZE:
+		okey->value.uint = (s32) gf_bs_read_int(bs, nb_bits);
+		break;
+	case GF_QT_KEY_FLOAT:
+		okey->value.number = gf_bs_read_float(bs);
+		break;
+	case GF_QT_KEY_DOUBLE:
+		okey->value.number = gf_bs_read_double(bs);
+		break;
+	case GF_QT_KEY_SIGNED_8:
+		okey->value.sint = (s64) (s8) gf_bs_read_int(bs, 8);
+		break;
+	case GF_QT_KEY_SIGNED_16:
+		okey->value.sint = (s64) (s16) gf_bs_read_int(bs, 16);
+		break;
+	case GF_QT_KEY_SIGNED_32:
+		okey->value.sint = (s64) (s32) gf_bs_read_int(bs, 32);
+		break;
+	case GF_QT_KEY_SIGNED_64:
+		okey->value.sint = (s64) gf_bs_read_long_int(bs, 64);
+		break;
+	case GF_QT_KEY_POINTF:
+	case GF_QT_KEY_SIZEF:
+		okey->value.pos_size.x = gf_bs_read_float(bs);
+		okey->value.pos_size.y = gf_bs_read_float(bs);
+		break;
+	case GF_QT_KEY_RECTF:
+		okey->value.rect.x = gf_bs_read_float(bs);
+		okey->value.rect.y = gf_bs_read_float(bs);
+		okey->value.rect.w = gf_bs_read_float(bs);
+		okey->value.rect.h = gf_bs_read_float(bs);
+		break;
+
+	case GF_QT_KEY_UNSIGNED_8:
+		okey->value.uint = gf_bs_read_int(bs, 8);
+		break;
+	case GF_QT_KEY_UNSIGNED_16:
+		okey->value.uint = gf_bs_read_int(bs, 16);
+		break;
+	case GF_QT_KEY_UNSIGNED_32:
+		okey->value.uint = gf_bs_read_int(bs, 32);
+		break;
+	case GF_QT_KEY_UNSIGNED_64:
+		okey->value.uint = gf_bs_read_int(bs, 64);
+		break;
+	case GF_QT_KEY_MATRIXF:
+		for (i=0; i<9; i++)
+			okey->value.matrixi = gf_bs_read_float(bs);
+		break;
+
+	case GF_QT_KEY_OPAQUE:
+	case GF_QT_KEY_UTF16_BE:
+	case GF_QT_KEY_JIS:
+	case GF_QT_KEY_UTF16_SORT:
+	case GF_QT_KEY_JPEG:
+	case GF_QT_KEY_PNG:
+	case GF_QT_KEY_BMP:
+	case GF_QT_KEY_METABOX:
+		okey->value.data.data = data_box->data;
+		okey->value.data.data_len = data_box->dataSize;
+		break;
+	case GF_QT_KEY_REMOVE:
+		break;
+	}
+	GF_Err e = GF_OK;
+	if (gf_bs_is_overflow(bs))
+		e = GF_ISOM_INVALID_FILE;
+	gf_bs_del(bs);
+	return e;
+}
 
 GF_EXPORT
 GF_Err gf_isom_wma_enum_tag(GF_ISOFile *mov, u32 idx, char **out_tag, const u8 **data, u32 *data_len, u32 *version, u32 *data_type)
@@ -4370,7 +4628,7 @@
 	*version = 0;
 	*data_type = 0;
 
-	xtra = (GF_XtraBox *) gf_isom_get_meta_extensions(mov, GF_TRUE);
+	xtra = (GF_XtraBox *) gf_isom_get_meta_extensions(mov, 1);
 	if (!xtra) return GF_URL_ERROR;
 
 	tag = gf_list_get(xtra->tags, idx);
@@ -4591,11 +4849,14 @@
 }
 
 GF_EXPORT
-Bool gf_isom_has_cenc_sample_group(GF_ISOFile *the_file, u32 trackNumber)
+Bool gf_isom_has_cenc_sample_group(GF_ISOFile *the_file, u32 trackNumber, Bool *has_selective, Bool *has_roll)
 {
 	GF_TrackBox *trak;
 	u32 i, count;
+	GF_SampleGroupDescriptionBox *seig=NULL;
 
+	if (has_selective) *has_selective = GF_FALSE;
+	if (has_roll) *has_roll = GF_FALSE;
 	trak = gf_isom_get_track_from_file(the_file, trackNumber);
 	if (!trak) return GF_FALSE;
 	if (!trak->Media->information->sampleTable->sampleGroups) return GF_FALSE;
@@ -4604,10 +4865,22 @@
 	for (i=0; i<count; i++) {
 		GF_SampleGroupDescriptionBox *sgdesc = (GF_SampleGroupDescriptionBox*)gf_list_get(trak->Media->information->sampleTable->sampleGroupsDescription, i);
 		if (sgdesc->grouping_type==GF_ISOM_SAMPLE_GROUP_SEIG) {
-			return GF_TRUE;
+			seig = sgdesc;
+			break;
 		}
 	}
-	return GF_FALSE;
+	if (!seig)
+		return GF_FALSE;
+
+	for (i=0; i<gf_list_count(seig->group_descriptions); i++) {
+		GF_CENCSampleEncryptionGroupEntry *se = gf_list_get(seig->group_descriptions, i);
+		if (!se->IsProtected) {
+			if (has_selective) *has_selective = GF_TRUE;
+		} else {
+			if (has_roll) *has_roll = GF_TRUE;
+		}
+	}
+	return GF_TRUE;
 }
 
 GF_EXPORT
@@ -5542,7 +5815,14 @@
 	return GF_FALSE;
 }
 
-
+GF_EXPORT
+Bool gf_isom_get_root_sidx_offsets(GF_ISOFile *movie, u64 *start, u64 *end)
+{
+	if (!movie || !start || !end) return GF_FALSE;
+	*start = movie->root_sidx_start_offset;
+	*end = movie->root_sidx_end_offset;
+	return GF_TRUE;
+}
 
 
 GF_EXPORT

gpac-2.0.0.tar.gz/src/isomedia/isom_store.c -> gpac-2.2.0.tar.gz/src/isomedia/isom_store.c Changed

@@ -2450,7 +2450,13 @@
 			gf_bs_seek(movie->editFileMap->bs, gf_bs_get_size(movie->editFileMap->bs) );
 
 			if ((movie->storageMode==GF_ISOM_STORE_FASTSTART) && mdat_start && mdat_size) {
+				u32 pad = (u32) mdat_start;
+				//make sure the bitstream has the right offset - this is require for box using offsets into other boxes (typically saio)
 				moov_bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+				while (pad) {
+					gf_bs_write_u8(moov_bs, 0);
+					pad--;
+				}
 			}
 			//write as non-seekable
 			e = WriteFlat(&mw, 0, movie->editFileMap->bs, GF_TRUE, GF_FALSE, moov_bs);
@@ -2482,8 +2488,8 @@
 
 				gf_bs_get_content(moov_bs, &moov_data, &moov_size);
 				gf_bs_del(moov_bs);
-
-				movie->on_block_patch(movie->on_block_out_usr_data, moov_data, moov_size, mdat_start, GF_TRUE);
+				//the first mdat_start bytes are dummy, cf above
+				movie->on_block_patch(movie->on_block_out_usr_data, moov_data+mdat_start, (u32) (moov_size-mdat_start), mdat_start, GF_TRUE);
 				gf_free(moov_data);
 			}
 		} else {

gpac-2.0.0.tar.gz/src/isomedia/isom_write.c -> gpac-2.2.0.tar.gz/src/isomedia/isom_write.c Changed

@@ -313,7 +313,9 @@
 		const char *code_3cc;
 		lang_idx = gf_lang_find(code);
 		if (lang_idx == -1) {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("The given code is not a valid one: %s, using 'und' as 3-letter code\n", code));
+			if (code0!=0) {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("The given code is not a valid one: %s, using 'und' as 3-letter code\n", code));
+			}
 			code_3cc = "und";
 		} else {
 			code_3cc = gf_lang_get_3cc(lang_idx);
@@ -593,7 +595,7 @@
 	//we may have terminators in some QT files (4 bytes set to 0 ...)
 	while (gf_bs_available(bs) >= 8) {
 		GF_Box *a_box;
-		e = gf_isom_box_parse_ex((GF_Box**)&a_box, bs, GF_ISOM_BOX_TYPE_MOOV, GF_FALSE);
+		e = gf_isom_box_parse_ex((GF_Box**)&a_box, bs, GF_ISOM_BOX_TYPE_MOOV, GF_FALSE, 0);
 		if (e || !a_box) goto exit;
 
 		if (a_box->type == GF_ISOM_BOX_TYPE_UDTA) {
@@ -680,13 +682,15 @@
 		GF_BitStream *bs = gf_bs_new(tk_box, tk_box_size, GF_BITSTREAM_READ);
 		gf_bs_set_cookie(bs, GF_ISOM_BS_COOKIE_NO_LOGS|GF_ISOM_BS_COOKIE_CLONE_TRACK);
 
-		e = gf_isom_box_parse_ex((GF_Box**)&trak, bs, GF_ISOM_BOX_TYPE_MOOV, GF_FALSE);
+		e = gf_isom_box_parse_ex((GF_Box**)&trak, bs, GF_ISOM_BOX_TYPE_MOOV, GF_FALSE, 0);
 		gf_bs_del(bs);
 		if (e) trak = NULL;
 		else if (udta_only) {
 			udta = trak->udta;
 			trak->udta = NULL;
+			gf_list_del_item(trak->child_boxes, udta);
 			gf_isom_box_del((GF_Box*)trak);
+			trak = NULL;
 		} else {
 			Bool tpl_ok = GF_TRUE;
 			if (!trak->Header || !trak->Media || !trak->Media->handler || !trak->Media->mediaHeader || !trak->Media->information) tpl_ok = GF_FALSE;
@@ -795,7 +799,10 @@
 	if (trakID+1> movie->moov->mvhd->nextTrackID)
 		movie->moov->mvhd->nextTrackID = trakID+1;
 
-	trak->udta = udta;
+	if (udta) {
+		trak->udta = udta;
+		gf_list_add(trak->child_boxes, udta);
+	}
 
 	//and return our track number
 	return gf_isom_get_track_by_id(movie, trakID);
@@ -1029,10 +1036,21 @@
 	}
 	if (e) return e;
 
-
 	if (!movie->keep_utc)
 		trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
-	return SetTrackDuration(trak);
+
+	//update media duration
+	if ((s64)sample->DTS + sample->CTS_Offset>=0) {
+		GF_TimeToSampleBox *stts = trak->Media->information->sampleTable->TimeToSample;
+		u64 dur = sample->DTS + sample->CTS_Offset;
+		dur += stts->entriesstts->nb_entries-1.sampleDelta;
+
+		if (dur > trak->Media->mediaHeader->duration) {
+			trak->Media->mediaHeader->duration = dur;
+		}
+	}
+	//do not update track duration yet, this is done on close
+	return GF_OK;
 }
 
 GF_EXPORT
@@ -1306,8 +1324,12 @@
 	}
 	if (!movie->keep_utc)
 		trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
-	trak->Media->mediaHeader->duration = mdur;
-	return SetTrackDuration(trak);
+
+	//update media duration if duration was set
+	if (trak->Media->mediaHeader->duration)
+		trak->Media->mediaHeader->duration = mdur;
+	//do not update track duration yet, this is done on close
+	return GF_OK;
 }
 
 GF_EXPORT
@@ -1811,6 +1833,12 @@
 		if (clr) gf_isom_box_del_parent(&entry->child_boxes, (GF_Box *)clr);
 		return GF_OK;
 	}
+	if (clr) {
+		//create another color box
+		if (clr->opaque && !icc_data) clr = NULL;
+		else if (!clr->opaque && icc_data) clr = NULL;
+	}
+
 	if (!clr) {
 		clr = (GF_ColourInformationBox*)gf_isom_box_new_parent(&entry->child_boxes, GF_ISOM_BOX_TYPE_COLR);
 		if (!clr) return GF_OUT_OF_MEM;
@@ -4260,6 +4288,9 @@
 		}
 	}
 
+	if (flags & GF_ISOM_CLONE_RESET_DURATION)
+		new_tk->Media->mediaHeader->duration = 0;
+
 	if (!new_tk->Media->information->dataInformation->dref) return GF_BAD_PARAM;
 
 	/*reset data ref*/
@@ -4268,7 +4299,7 @@
 		Bool use_alis = GF_FALSE;
 		if (! (flags & GF_ISOM_CLONE_TRACK_NO_QT)) {
 			GF_Box *b = gf_list_get(new_tk->Media->information->dataInformation->dref->child_boxes, 0);
-			if (b && b->type==GF_QT_BOX_TYPE_ALIS)
+			if (b && (b->type==GF_QT_BOX_TYPE_ALIS))
 				use_alis = GF_TRUE;
 		}
 		gf_isom_box_array_del(new_tk->Media->information->dataInformation->dref->child_boxes);
@@ -4895,9 +4926,18 @@
 	if (!trak->Media->information->sampleTable->CompositionOffset) return GF_BAD_PARAM;
 	if (!trak->Media->information->sampleTable->CompositionOffset->unpack_mode) return GF_BAD_PARAM;
 
-	for (i=0; i<trak->Media->information->sampleTable->CompositionOffset->nb_entries; i++) {
+	GF_CompositionOffsetBox *ctso = trak->Media->information->sampleTable->CompositionOffset;
+	for (i=0; i<ctso->nb_entries; i++) {
+		s64 new_ts = ctso->entriesi.decodingOffset;
+		new_ts -= offset_shift;
 		/*we're in unpack mode: one entry per sample*/
-		trak->Media->information->sampleTable->CompositionOffset->entriesi.decodingOffset -= offset_shift;
+		ctso->entriesi.decodingOffset = (s32) new_ts;
+	}
+	if (trak->Media->mediaHeader->duration >= -offset_shift) {
+		s64 new_dur = trak->Media->mediaHeader->duration;
+		new_dur -= offset_shift;
+		if (new_dur<0) new_dur = 0;
+		trak->Media->mediaHeader->duration = (u32) new_dur;
 	}
 	return GF_OK;
 }
@@ -5057,7 +5097,8 @@
 			}
 		}
 #undef RESCALE_TSVAL
-
+		//force recompute of duration
+		trak->Media->mediaHeader->duration=0;
 		return SetTrackDuration(trak);
 	}
 
@@ -5071,7 +5112,9 @@
 		GF_EdtsEntry *ent;
 		i=0;
 		while ((ent = (GF_EdtsEntry*)gf_list_enum(trak->editBox->editList->entryList, &i))) {
-			ent->mediaTime = (u32) (scale*ent->mediaTime);
+			//only update if media time is >=0 (neg means empty edit)
+			if (ent->mediaTime>=0)
+				ent->mediaTime = (u32) (scale*ent->mediaTime);
 		}
 	}
 	if (! stbl || !stbl->TimeToSample || !stbl->TimeToSample->nb_entries) {
@@ -6232,6 +6275,215 @@
 	return GF_OK;
 }
 
+GF_EXPORT
+GF_Err gf_isom_set_qt_key(GF_ISOFile *movie, GF_QT_UDTAKey *key)
+{
+	GF_Err e;
+	GF_MetaBox *meta;
+	GF_ItemListBox *ilst;
+	GF_MetaKeysBox *keys;
+	u32 i, nb_keys;
+
+	if (!movie) return GF_BAD_PARAM;
+	e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
+	if (e) {
+		gf_isom_set_last_error(movie, e);
+		return 0;
+	}
+	e = gf_isom_insert_moov(movie);
+	if (e) return e;
+
+	meta = (GF_MetaBox *) gf_isom_create_meta_extensions(movie, 2);
+	if (!meta) return GF_BAD_PARAM;
+
+	keys = (GF_MetaKeysBox *) gf_isom_locate_box(meta->child_boxes, GF_ISOM_BOX_TYPE_KEYS, NULL);
+	if (!keys) {
+		keys = (GF_MetaKeysBox *) gf_isom_box_new_parent(&meta->child_boxes, GF_ISOM_BOX_TYPE_KEYS);
+		meta->keys = keys;
+	}
+	ilst = (GF_ItemListBox *) gf_isom_locate_box(meta->child_boxes, GF_ISOM_BOX_TYPE_ILST, NULL);
+	if (!ilst) {
+		ilst = (GF_ItemListBox *) gf_isom_box_new_parent(&meta->child_boxes, GF_ISOM_BOX_TYPE_ILST);
+	}
+	if (!keys || !ilst) return GF_OUT_OF_MEM;
+
+	nb_keys = gf_list_count(keys->keys);
+	if (!key) {
+		u32 nb_keys = gf_list_count(keys->keys);
+		gf_isom_box_del_parent(&meta->child_boxes, (GF_Box *) keys);
+		for (i=0; i<gf_list_count(ilst->child_boxes); i++) {
+			GF_ListItemBox *info = gf_list_get(ilst->child_boxes, i);
+			if (info->type <= nb_keys) {
+				gf_isom_box_del_parent(&ilst->child_boxes, (GF_Box *) info);
+				i--;
+			}
+		}
+		if (!gf_list_count(ilst->child_boxes)) {
+			gf_isom_box_del_parent(&meta->child_boxes, (GF_Box *) ilst);
+			//if last, delete udta - we may still have a handler box remaining
+			if ((gf_list_count(meta->child_boxes) <= 1) && (gf_list_count(movie->moov->udta->recordList)==1)) {
+				gf_isom_box_del_parent(&movie->moov->child_boxes, (GF_Box *) movie->moov->udta);
+				movie->moov->udta = NULL;
+			}
+		}
+		return GF_OK;
+	}
+	//locate key
+	GF_MetaKey *o_key = NULL;
+	u32 ksize = (u32) strlen(key->name);
+	for (i=0; i<nb_keys; i++) {
+		o_key = gf_list_get(keys->keys, i);
+		if ((o_key->ns == key->ns) && (o_key->size==ksize) && !strcmp(o_key->data, key->name))
+			break;
+		o_key = NULL;
+	}
+	if (!o_key) {
+		if (key->type==GF_QT_KEY_REMOVE) return GF_OK;
+		GF_SAFEALLOC(o_key, GF_MetaKey);
+		o_key->ns = key->ns;
+		o_key->data = gf_strdup(key->name);
+		o_key->size = ksize;
+		gf_list_add(keys->keys, o_key);
+	}
+	u32 key_idx = gf_list_find(keys->keys, o_key)+1;
+	GF_UnknownBox *info=NULL;
+	for (i=0; i<gf_list_count(ilst->child_boxes); i++) {
+		info = gf_list_get(ilst->child_boxes, i);
+		if (info->original_4cc == key_idx) break;
+		info = NULL;
+	}
+
+	if (key->type==GF_QT_KEY_REMOVE) {
+		gf_list_del_item(keys->keys, o_key);
+		if (o_key->data) gf_free(o_key->data);
+		gf_free(o_key);
+		for (i=0; i<gf_list_count(ilst->child_boxes); i++) {
+			info = gf_list_get(ilst->child_boxes, i);
+			if (info->type!=GF_ISOM_BOX_TYPE_UNKNOWN) continue;
+			if (info->original_4cc==key_idx) {
+				gf_isom_box_del_parent(&ilst->child_boxes, (GF_Box *)info);
+				i--;
+				continue;
+			}
+			if (info->original_4cc>key_idx) {
+				info->original_4cc--;
+			}
+		}
+		return GF_OK;
+	}
+	if (!info) {
+		info = (GF_UnknownBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_UNKNOWN);
+		if (!info) return GF_OUT_OF_MEM;
+		if (!ilst->child_boxes) ilst->child_boxes = gf_list_new();
+		gf_list_add(ilst->child_boxes, info);
+	}
+
+	GF_DataBox *dbox = (GF_DataBox *) gf_isom_box_find_child(info->child_boxes, GF_ISOM_BOX_TYPE_DATA);
+	if (!dbox) {
+		dbox = (GF_DataBox *)gf_isom_box_new_parent(&info->child_boxes, GF_ISOM_BOX_TYPE_DATA);
+		if (!dbox) {
+			gf_isom_box_del((GF_Box *)info);
+			return GF_OUT_OF_MEM;
+		}
+	}
+	u32 nb_bits=0;
+	info->original_4cc = key_idx;
+	dbox->version = 0;
+	dbox->flags = key->type;
+	//serialize
+	GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+
+	switch (key->type) {
+	case GF_QT_KEY_UTF8:
+	case GF_QT_KEY_UTF8_SORT:
+		if (key->value.string)
+			gf_bs_write_data(bs, key->value.string, (u32) strlen(key->value.string));
+		break;
+
+	case GF_QT_KEY_SIGNED_VSIZE:
+		if (ABS(key->value.sint)<=0x7F) nb_bits=8;
+		else if (ABS(key->value.sint)<=0x7FFF) nb_bits=16;
+		else if (ABS(key->value.sint)<=0x7FFFFF) nb_bits=24;
+		else nb_bits = 32;
+		gf_bs_write_int(bs, (s32) key->value.sint, nb_bits);
+		break;
+	case GF_QT_KEY_UNSIGNED_VSIZE:
+		if (key->value.uint<=0xFF) nb_bits=8;
+		else if (key->value.uint<=0xFFFF) nb_bits=16;
+		else if (key->value.uint<=0xFFFFFF) nb_bits=24;
+		else nb_bits = 32;
+		gf_bs_write_int(bs, (u32) key->value.uint, nb_bits);
+		break;
+	case GF_QT_KEY_FLOAT:
+		gf_bs_write_float(bs, (Float) key->value.number);
+		break;
+	case GF_QT_KEY_DOUBLE:
+		gf_bs_write_double(bs, key->value.number);
+		break;
+	case GF_QT_KEY_SIGNED_8:
+		gf_bs_write_int(bs, (s32) key->value.sint, 8);
+		break;
+	case GF_QT_KEY_SIGNED_16:
+		gf_bs_write_int(bs, (s32) key->value.sint, 16);
+		break;
+	case GF_QT_KEY_SIGNED_32:
+		gf_bs_write_int(bs, (s32) key->value.sint, 32);
+		break;
+	case GF_QT_KEY_SIGNED_64:
+		gf_bs_write_long_int(bs, key->value.sint, 64);
+		break;
+	case GF_QT_KEY_POINTF:
+	case GF_QT_KEY_SIZEF:
+		gf_bs_write_float(bs, key->value.pos_size.x);
+		gf_bs_write_float(bs, key->value.pos_size.y);
+		break;
+	case GF_QT_KEY_RECTF:
+		gf_bs_write_float(bs, key->value.rect.x);
+		gf_bs_write_float(bs, key->value.rect.y);
+		gf_bs_write_float(bs, key->value.rect.w);
+		gf_bs_write_float(bs, key->value.rect.h);
+		break;
+
+	case GF_QT_KEY_UNSIGNED_8:
+		gf_bs_write_int(bs, (s32) key->value.uint, 8);
+		break;
+	case GF_QT_KEY_UNSIGNED_16:
+		gf_bs_write_int(bs, (s32) key->value.uint, 16);
+		break;
+	case GF_QT_KEY_UNSIGNED_32:
+		gf_bs_write_int(bs, (s32) key->value.uint, 32);
+		break;
+	case GF_QT_KEY_UNSIGNED_64:
+		gf_bs_write_long_int(bs, key->value.uint, 64);
+		break;
+	case GF_QT_KEY_MATRIXF:
+		for (i=0; i<9; i++)
+			gf_bs_write_float(bs, (Float) key->value.matrixi );
+		break;
+
+	case GF_QT_KEY_OPAQUE:
+	case GF_QT_KEY_UTF16_BE:
+	case GF_QT_KEY_JIS:
+	case GF_QT_KEY_UTF16_SORT:
+	case GF_QT_KEY_JPEG:
+	case GF_QT_KEY_PNG:
+	case GF_QT_KEY_BMP:
+	case GF_QT_KEY_METABOX:
+	default:
+		gf_bs_write_data(bs, key->value.data.data, key->value.data.data_len);
+		break;
+	}
+	//write extra 0 at end, not serialized
+	gf_bs_write_u8(bs, 0);
+	if (dbox->data) gf_free(dbox->data);
+
+	gf_bs_get_content(bs, &dbox->data, &i);
+	if (i) i--;
+	dbox->dataSize = i;
+	gf_bs_del(bs);
+	return GF_OK;
+}
+
 
 GF_EXPORT
 GF_Err gf_isom_set_alternate_group_id(GF_ISOFile *movie, u32 trackNumber, u32 groupId)
@@ -6747,7 +6999,7 @@
 GF_Err gf_isom_add_sample_group_info_internal(GF_ISOFile *movie, u32 track, u32 grouping_type, void *data, u32 data_size, Bool is_default, u32 *sampleGroupDescriptionIndex, Bool *is_traf_sgpd, Bool check_access)
 {
 	GF_Err e;
-	GF_TrackBox *trak;
+	GF_TrackBox *trak=NULL;
 #ifndef GPAC_DISABLE_ISOM_FRAGMENTS
 	GF_TrackFragmentBox *traf=NULL;
 #else
@@ -6781,8 +7033,8 @@
 		}
 
 		trak = gf_isom_get_track_from_file(movie, track);
-		if (!trak) return GF_BAD_PARAM;
 	}
+	if (!trak) return GF_BAD_PARAM;
 
 	//get sample group desc for this grouping type
 	sgdesc = get_sgdp(trak->Media->information->sampleTable, traf, grouping_type, is_traf_sgpd);
@@ -7239,7 +7491,9 @@
 		if (shift > 0)
 		{
 			for (i=0; i<ctts->nb_entries; i++) {
-				ctts->entriesi.decodingOffset += shift;
+				s64 new_ts = ctts->entriesi.decodingOffset;
+				new_ts += shift;
+				ctts->entriesi.decodingOffset = (u32) shift;
 			}
 		}
 	}
@@ -7248,7 +7502,9 @@
 		cslg = trak->Media->information->sampleTable->CompositionToDecode;
 		shift = cslg->compositionToDTSShift;
 		for (i=0; i<ctts->nb_entries; i++) {
-			ctts->entriesi.decodingOffset += shift;
+			s64 new_ts = ctts->entriesi.decodingOffset;
+			new_ts += shift;
+			ctts->entriesi.decodingOffset = (u32) shift;
 		}
 		gf_isom_box_del_parent(&trak->Media->information->sampleTable->child_boxes, (GF_Box *)cslg);
 		trak->Media->information->sampleTable->CompositionToDecode = NULL;
@@ -7656,7 +7912,7 @@
 		GF_EditListBox *elst = trak->editBox->editList;
 		i=0;
 		while ((ent = (GF_EdtsEntry*)gf_list_enum(elst->entryList, &i))) {
-			if ((ent->mediaTime>=0) && (ent->mediaRate==1) && (ent->segmentDuration > trackDuration))
+			if ((ent->mediaTime>=0) && (ent->mediaRate==0x10000) && (ent->segmentDuration > trackDuration))
 				ent->segmentDuration = trackDuration;
 
 			if (!ent->segmentDuration) {
@@ -7881,7 +8137,7 @@
 
 	bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
 //	e = gf_isom_box_parse(&tpl_ent, bs);
-	e = gf_isom_box_parse_ex (&tpl_ent, bs, GF_ISOM_BOX_TYPE_STSD, GF_FALSE);
+	e = gf_isom_box_parse_ex(&tpl_ent, bs, GF_ISOM_BOX_TYPE_STSD, GF_FALSE, 0);
 	gf_bs_del(bs);
 	if (e) return e;
 
@@ -7929,16 +8185,6 @@
 }
 
 
-#ifdef GPAC_DISABLE_CORE_TOOLS
-
-GF_EXPORT
-GF_Err gf_isom_apply_box_patch(GF_ISOFile *file, GF_ISOTrackID globalTrackID, const char *box_patch_filename, Bool for_fragments)
-{
-	return GF_NOT_SUPPORTED;
-}
-
-#else
-
 #include <gpac/xml.h>
 GF_EXPORT
 GF_Err gf_isom_apply_box_patch(GF_ISOFile *file, GF_ISOTrackID globalTrackID, const char *box_patch_filename, Bool for_fragments)
@@ -8167,7 +8413,7 @@
 					gf_bs_seek(bs, 0);
 					while (gf_bs_available(bs)) {
 						GF_Box *new_box;
-						e = gf_isom_box_parse_ex(&new_box, bs, (insert_pos<0) ? box->type : parent_list_box_type, parent_box ? GF_FALSE : GF_TRUE);
+						e = gf_isom_box_parse_ex(&new_box, bs, (insert_pos<0) ? box->type : parent_list_box_type, parent_box ? GF_FALSE : GF_TRUE, 0);
 						if (e) {
 							GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("ISOBMFF failed to parse box\n", box_path));
 							gf_bs_del(bs);
@@ -8197,9 +8443,6 @@
 	return e;
 }
 
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
-
-
 GF_EXPORT
 GF_Err gf_isom_set_track_magic(GF_ISOFile *movie, u32 trackNumber, u64 magic)
 {
@@ -8501,8 +8744,7 @@
 		saiz->default_sample_info_size = size;
 	} else {
 		if (sampleNumber > saiz->sample_alloc) {
-			if (!saiz->sample_alloc) saiz->sample_alloc = sampleNumber;
-			else saiz->sample_alloc *= 2;
+			saiz->sample_alloc = sampleNumber+10;
 			saiz->sample_info_size = (u8*)gf_realloc(saiz->sample_info_size, sizeof(u8)*(saiz->sample_alloc));
 		}
 
@@ -8567,4 +8809,68 @@
 	return gf_isom_add_sample_aux_info_internal(trak, NULL, sampleNumber, aux_type, aux_info, data, size);
 }
 
+
+GF_Err gf_isom_set_meta_qt(GF_ISOFile *file)
+{
+	u32 i, count;
+	if (!file) return GF_BAD_PARAM;
+	GF_Err e = CanAccessMovie(file, GF_ISOM_OPEN_WRITE);
+	if (e) return e;
+	if (file->moov->meta)
+		file->moov->meta->write_qt = 1;
+
+	count = gf_list_count(file->moov->trackList);
+	for (i=0; i<count; i++) {
+		GF_TrackBox *trak = gf_list_get(file->moov->trackList, i);
+		if (trak->meta)
+			trak->meta->write_qt = 1;
+	}
+	return GF_OK;
+}
+
+
+GF_EXPORT
+GF_Err gf_isom_set_mpegh_compatible_profiles(GF_ISOFile *movie, u32 trackNumber, u32 sampleDescIndex, const u32 *profiles, u32 nb_compat_profiles)
+{
+	u32 i, type;
+	GF_SampleEntryBox *ent;
+	GF_MHACompatibleProfilesBox *mhap;
+	GF_TrackBox *trak;
+
+	trak = gf_isom_get_track_from_file(movie, trackNumber);
+	if (!trak || !trak->Media) return GF_BAD_PARAM;
+	ent = gf_list_get(trak->Media->information->sampleTable->SampleDescription->child_boxes, sampleDescIndex-1);
+	if (!ent) return GF_BAD_PARAM;
+	type = ent->type;
+	if (type==GF_ISOM_BOX_TYPE_GNRA)
+		type = ((GF_GenericAudioSampleEntryBox *)ent)->EntryType;
+
+	switch (type) {
+	case GF_ISOM_BOX_TYPE_MHA1:
+	case GF_ISOM_BOX_TYPE_MHA2:
+	case GF_ISOM_BOX_TYPE_MHM1:
+	case GF_ISOM_BOX_TYPE_MHM2:
+		break;
+	default:
+		return GF_BAD_PARAM;
+	}
+	mhap = (GF_MHACompatibleProfilesBox *) gf_isom_box_find_child(ent->child_boxes, GF_ISOM_BOX_TYPE_MHAP);
+	if (!mhap) {
+		if (! profiles || !nb_compat_profiles) return GF_OK;
+		mhap = (GF_MHACompatibleProfilesBox *) gf_isom_box_new_parent(&ent->child_boxes, GF_ISOM_BOX_TYPE_MHAP);
+	} else if (! profiles || !nb_compat_profiles) {
+		gf_isom_box_del_parent(&ent->child_boxes, (GF_Box*)mhap);
+		return GF_OK;
+	}
+	if (mhap->compat_profiles) gf_free(mhap->compat_profiles);
+	mhap->compat_profiles = gf_malloc(sizeof(u8) * nb_compat_profiles);
+	if (!mhap->compat_profiles) return GF_OUT_OF_MEM;
+	for (i=0; i<nb_compat_profiles; i++) {
+		mhap->compat_profilesi = (u8) profilesi;
+	}
+	mhap->num_profiles = nb_compat_profiles;
+	return GF_OK;
+}
+
 #endif	/*!defined(GPAC_DISABLE_ISOM) && !defined(GPAC_DISABLE_ISOM_WRITE)*/
+

gpac-2.0.0.tar.gz/src/isomedia/media.c -> gpac-2.2.0.tar.gz/src/isomedia/media.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2019
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / ISO Media File Format sub-project
@@ -344,23 +344,19 @@
 		if (entry->internal_type != GF_ISOM_SAMPLE_ENTRY_AUDIO)
 			return GF_ISOM_INVALID_MEDIA;
 	{
-		GF_OpusSpecificBox *e = ((GF_MPEGAudioSampleEntryBox*)entry)->cfg_opus;
-		GF_BitStream *bs_out;
-		if (!e) {
+		GF_OpusSpecificBox *opus_c;
+		if (true_desc_only)
+			return GF_ISOM_INVALID_MEDIA;
+
+		opus_c = ((GF_MPEGAudioSampleEntryBox*)entry)->cfg_opus;
+		if (!opus_c) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("ESD not found for Opus\n)"));
 			break;
 		}
-
 		*out_esd = gf_odf_desc_esd_new(2);
 		(*out_esd)->decoderConfig->streamType = GF_STREAM_AUDIO;
 		(*out_esd)->decoderConfig->objectTypeIndication = GF_CODECID_OPUS;
-
-		//serialize box with header - compatibility with ffmpeg
-		bs_out = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-		gf_isom_box_size((GF_Box *) e);
-		gf_isom_box_write((GF_Box *) e, bs_out);
-		gf_bs_get_content(bs_out, & (*out_esd)->decoderConfig->decoderSpecificInfo->data, & (*out_esd)->decoderConfig->decoderSpecificInfo->dataLength);
-		gf_bs_del(bs_out);
+		gf_odf_opus_cfg_write(&opus_c->opcfg, & (*out_esd)->decoderConfig->decoderSpecificInfo->data, & (*out_esd)->decoderConfig->decoderSpecificInfo->dataLength);
 		break;
 	}
 	case GF_ISOM_SUBTYPE_3GP_H263:
@@ -648,6 +644,8 @@
 			return GF_IO_ERR;
 		}
 		mdia->BytesMissing = 0;
+	} else {
+		(*samp)->dataLength = 0;
 	}
 
 	//finally rewrite the sample if this is an OD Access Unit or NAL-based one
@@ -696,8 +694,14 @@
 
 	//ok, not self contained, let's go for it...
 	//we only support alias and URL boxes
-	if ((entry->type != GF_ISOM_BOX_TYPE_URL) && (entry->type != GF_QT_BOX_TYPE_ALIS) )
+	switch (entry->type) {
+	case GF_ISOM_BOX_TYPE_URL:
+	case GF_QT_BOX_TYPE_ALIS:
+	case GF_QT_BOX_TYPE_CIOS:
+		break;
+	default:
 		return GF_NOT_SUPPORTED;
+	}
 
 	if (mdia->mediaTrack->moov->mov->openMode == GF_ISOM_OPEN_WRITE) {
 		e = gf_isom_datamap_new(entry->location, NULL, GF_ISOM_DATA_MAP_READ, &map);
@@ -732,6 +736,7 @@
 	if (a->flags & 1) return 1;
 	/*QT specific*/
 	if (a->type == GF_QT_BOX_TYPE_ALIS) return 1;
+	if (a->type == GF_QT_BOX_TYPE_CIOS) return 1;
 	return 0;
 }
 
@@ -857,7 +862,6 @@
 		if (Track_IsMPEG4Stream(trak->Media->handler->handlerType)) {
 			Media_GetESD(trak->Media, 1, &esd, 1);
 			if (esd && esd->URLString) trak->Media->mediaHeader->duration = (u64) -1;
-
 		}
 		return GF_OK;
 	}
@@ -866,13 +870,21 @@
 	e = stbl_GetSampleDTS_and_Duration(trak->Media->information->sampleTable->TimeToSample, nbSamp, &DTS, &dur);
 	if (e < 0) return e;
 	DTS += dur;
-	trak->Media->mediaHeader->duration = DTS;
 
 	//do not do that for old arch compat which was not taking into account cts offset
-	if (gf_sys_old_arch_compat() || !trak->Media->information->sampleTable->CompositionOffset)
+	if (gf_sys_old_arch_compat() || !trak->Media->information->sampleTable->CompositionOffset) {
+		trak->Media->mediaHeader->duration = DTS;
 		return GF_OK;
-
+	}
 	//try to set duration according to spec: "should be the largest composition timestamp plus the duration of that sample"
+	s32 cts_o;
+	stbl_GetSampleCTS(trak->Media->information->sampleTable->CompositionOffset, nbSamp, &cts_o);
+	if (cts_o>0) DTS += cts_o;
+	if (DTS>trak->Media->mediaHeader->duration)
+		trak->Media->mediaHeader->duration = DTS;
+
+	//this can be more precise in some corner cases but takes way too long - we keep code for reference
+#if 0
 	//browse from sample_num_max_cts_delta (updated in read and edit to point to sample number with max cts offset)
 	u32 s_idx, min = trak->Media->information->sampleTable->CompositionOffset->sample_num_max_cts_delta;
 	if (!min) return GF_OK;
@@ -888,6 +900,7 @@
 		}
 	}
 	trak->Media->mediaHeader->duration = DTS;
+#endif
 	return GF_OK;
 }

gpac-2.0.0.tar.gz/src/isomedia/meta.c -> gpac-2.2.0.tar.gz/src/isomedia/meta.c Changed

@@ -2,7 +2,7 @@
 *					GPAC Multimedia Framework
 *
 *			Authors: Cyril Concolato - Jean le Feuvre
- *			Copyright (c) Telecom ParisTech 2005-2020
+ *			Copyright (c) Telecom ParisTech 2005-2022
 *					All rights reserved
 *
 * This file is part of GPAC / ISO Media File Format sub-project
@@ -69,6 +69,7 @@
 {
 	u32 i, count;
 	FILE *didfile;
+	GF_Err e=GF_OK;
 	GF_XMLBox *xml = NULL;
 	GF_MetaBox *meta = gf_isom_get_meta(file, root_meta, track_num);
 	if (!meta) return GF_BAD_PARAM;
@@ -86,11 +87,12 @@
 
 	didfile = gf_fopen(outName, "wb");
 	if (!didfile) return GF_IO_ERR;
-	gf_fwrite(xml->xml, strlen(xml->xml), didfile);
+	u32 len = (u32) strlen(xml->xml);
+	if (gf_fwrite(xml->xml, len, didfile)!=len) e = GF_IO_ERR;
 	gf_fclose(didfile);
 
 	if (is_binary) *is_binary = (xml->type==GF_ISOM_BOX_TYPE_BXML) ? 1 : 0;
-	return GF_OK;
+	return e;
 }
 
 #if 0 //unused
@@ -174,6 +176,8 @@
 		GF_ItemLocationEntry *iloc = (GF_ItemLocationEntry *)gf_list_get(meta->item_locations->location_entries, i);
 		if (iloc->item_ID==iinf->item_ID) {
 			if (iloc->data_reference_index) {
+				if (!meta->file_locations || !meta->file_locations->dref)
+					return GF_ISOM_INVALID_FILE;
 				GF_Box *a = (GF_Box *)gf_list_get(meta->file_locations->dref->child_boxes, iloc->data_reference_index-1);
 				if (!a) return GF_ISOM_INVALID_FILE;
 				if (a->type==GF_ISOM_BOX_TYPE_URL) {
@@ -200,7 +204,7 @@
 }
 
 GF_EXPORT
-GF_Err gf_isom_get_meta_item_flags(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 item_num)
+u32 gf_isom_get_meta_item_flags(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 item_num)
 {
 	GF_ItemInfoEntryBox *iinf;
 	GF_MetaBox *meta = gf_isom_get_meta(file, root_meta, track_num);
@@ -678,7 +682,7 @@
 
 
 GF_EXPORT
-GF_Err gf_isom_get_meta_image_props(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 item_id, GF_ImageItemProperties *prop) {
+GF_Err gf_isom_get_meta_image_props(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 item_id, GF_ImageItemProperties *prop, GF_List *unmapped_props) {
 	u32 count, i, inum;
 	u32 j;
 	GF_ItemPropertyAssociationBox *ipma = NULL;
@@ -788,6 +792,12 @@
 			case GF_ISOM_BOX_TYPE_VVCC:
 				prop->config = b;
 				break;
+
+			default:
+				if (unmapped_props) {
+					gf_list_add(unmapped_props, b);
+				}
+				break;
 			}
 		}
 	}
@@ -1093,18 +1103,58 @@
 		if (e) return e;
 		searchprop.config = NULL;
 	}
+
+	if (image_props->config_ba && image_props->config_ba_size) {
+		GF_Box *b;
+		GF_SAFEALLOC(b, GF_Box);
+		b->child_boxes = gf_list_new();
+		b->size = image_props->config_ba_size;
+		GF_BitStream *bs = gf_bs_new(image_props->config_ba, image_props->config_ba_size, GF_BITSTREAM_READ);
+		e = gf_isom_box_array_read(b, bs);
+		if (e) {
+			gf_isom_box_array_del(b->child_boxes);
+			gf_free(b);
+			return e;
+		}
+		while (gf_list_count(b->child_boxes)) {
+			GF_Box *a = gf_list_pop_front(b->child_boxes);
+			gf_list_add(ipco->child_boxes, a);
+			prop_index = gf_list_count(ipco->child_boxes) - 1;
+			//mark all as essential
+			e = meta_add_item_property_association(ipma, item_ID, prop_index + 1, GF_TRUE);
+			if (e) return e;
+		}
+		gf_list_del(b->child_boxes);
+		gf_free(b);
+	}
 	if (image_props->alpha) {
 		searchprop.alpha = image_props->alpha;
 		prop_index = meta_find_prop(ipco, &searchprop);
 		if (prop_index < 0) {
 			GF_AuxiliaryTypePropertyBox *auxC = (GF_AuxiliaryTypePropertyBox *)gf_isom_box_new_parent(&ipco->child_boxes, GF_ISOM_BOX_TYPE_AUXC);
 			if (!auxC) return GF_OUT_OF_MEM;
-			auxC->aux_urn = gf_strdup("urn:mpeg:mpegB:cicp:systems:auxiliary:alpha");
+
+			//always use mpegB code points (2nd edition of HEIF recommends it)
+			if (gf_opts_get_bool("core", "heif-hevc-urn")) {
+				u32 cfg_type = image_props->config ? ((GF_Box *) image_props->config)->type : 0;
+				switch (cfg_type) {
+				case GF_ISOM_BOX_TYPE_HVCC:
+				case GF_ISOM_BOX_TYPE_LHVC:
+					auxC->aux_urn = gf_strdup("urn:mpeg:hevc:2015:auxid:1");
+					break;
+				default:
+					auxC->aux_urn = gf_strdup("urn:mpeg:mpegB:cicp:systems:auxiliary:alpha");
+					break;
+				}
+			} else {
+				auxC->aux_urn = gf_strdup("urn:mpeg:mpegB:cicp:systems:auxiliary:alpha");
+			}
 			prop_index = gf_list_count(ipco->child_boxes) - 1;
 		}
 		e = meta_add_item_property_association(ipma, item_ID, prop_index + 1, GF_TRUE);
 		if (e) return e;
 		searchprop.alpha = GF_FALSE;
+		if (image_props->num_channels) image_props->num_channels = 1;
 	}
 	if (image_props->depth) {
 		searchprop.depth = image_props->depth;
@@ -1112,12 +1162,28 @@
 		if (prop_index < 0) {
 			GF_AuxiliaryTypePropertyBox *auxC = (GF_AuxiliaryTypePropertyBox *)gf_isom_box_new_parent(&ipco->child_boxes, GF_ISOM_BOX_TYPE_AUXC);
 			if (!auxC) return GF_OUT_OF_MEM;
-			auxC->aux_urn = gf_strdup("urn:mpeg:mpegB:cicp:systems:auxiliary:depth");
+
+			//always use mpegB code points (2nd edition of HEIF recommends it)
+			if (gf_opts_get_bool("core", "heif-hevc-urn")) {
+				u32 cfg_type = image_props->config ? ((GF_Box *) image_props->config)->type : 0;
+				switch (cfg_type) {
+				case GF_ISOM_BOX_TYPE_HVCC:
+				case GF_ISOM_BOX_TYPE_LHVC:
+					auxC->aux_urn = gf_strdup("urn:mpeg:hevc:2015:auxid:2");
+					break;
+				default:
+					auxC->aux_urn = gf_strdup("urn:mpeg:mpegB:cicp:systems:auxiliary:depth");
+					break;
+				}
+			} else {
+				auxC->aux_urn = gf_strdup("urn:mpeg:mpegB:cicp:systems:auxiliary:depth");
+			}
 			prop_index = gf_list_count(ipco->child_boxes) - 1;
 		}
 		e = meta_add_item_property_association(ipma, item_ID, prop_index + 1, GF_TRUE);
 		if (e) return e;
-		searchprop.alpha = GF_FALSE;
+		searchprop.depth = GF_FALSE;
+		if (image_props->num_channels) image_props->num_channels = 1;
 	}
 	if (image_props->num_channels) {
 		u32 k;
@@ -1894,7 +1960,7 @@
 				continue;
 
 			stsz = trak->Media->information->sampleTable->SampleSize;
-			if (!stsz->sampleCount) continue;
+			if (!stsz || !stsz->sampleCount) continue;
 			for (k=0; k<stsz->sampleCount; k++) {
 				GF_Err e;
 				u32 chunk, di, samp_size;

gpac-2.0.0.tar.gz/src/isomedia/movie_fragments.c -> gpac-2.2.0.tar.gz/src/isomedia/movie_fragments.c Changed

@@ -258,7 +258,7 @@
                                     u32 DefaultSampleDescriptionIndex,
                                     u32 DefaultSampleDuration,
                                     u32 DefaultSampleSize,
-                                    u8 DefaultSampleIsSync,
+                                    u8 DefaultSampleSyncFlags,
                                     u8 DefaultSamplePadding,
                                     u16 DefaultDegradationPriority,
                                     Bool force_traf_flags)
@@ -277,6 +277,13 @@
 	trak = gf_isom_get_track_from_id(movie->moov, TrackID);
 	if (!trak) return GF_BAD_PARAM;
 
+	if (DefaultSampleSyncFlags & GF_ISOM_FRAG_USE_SYNC_TABLE) {
+		DefaultSampleSyncFlags &= ~GF_ISOM_FRAG_USE_SYNC_TABLE;
+		if (!trak->Media->information->sampleTable->SyncSample) {
+			trak->Media->information->sampleTable->SyncSample = (GF_SyncSampleBox *) gf_isom_box_new_parent(&trak->Media->information->sampleTable->child_boxes, GF_ISOM_BOX_TYPE_STSS);
+		}
+	}
+
 	//create MVEX if needed
 	if (!movie->moov->mvex) {
 		mvex = (GF_MovieExtendsBox *) gf_isom_box_new_parent(&movie->moov->child_boxes, GF_ISOM_BOX_TYPE_MVEX);
@@ -298,7 +305,7 @@
 		mvex_on_child_box((GF_Box*)mvex, (GF_Box *) trex, GF_FALSE);
 	}
 	trex->track = trak;
-	return gf_isom_change_track_fragment_defaults(movie, TrackID, DefaultSampleDescriptionIndex, DefaultSampleDuration, DefaultSampleSize, DefaultSampleIsSync, DefaultSamplePadding, DefaultDegradationPriority, force_traf_flags);
+	return gf_isom_change_track_fragment_defaults(movie, TrackID, DefaultSampleDescriptionIndex, DefaultSampleDuration, DefaultSampleSize, DefaultSampleSyncFlags, DefaultSamplePadding, DefaultDegradationPriority, force_traf_flags);
 }
 
 #ifdef GF_ENABLE_CTRN
@@ -646,7 +653,7 @@
 				if (j==1 || (trun->nb_samples==1) ) RunFlags = ent->flags;
 
 				if (ssize != RunSize) RunSize = 0;
-				if (ent->Duration != RunDur)
+				if (RunDur && (ent->Duration != RunDur))
 					RunDur = 0;
 				if (j && (RunFlags != ent->flags)) NeedFlags = 1;
 			}
@@ -724,6 +731,10 @@
 			   we just need to check if the first entry flags need to be singled out*/
 			if (first_ent->flags != RunFlags) {
 				trun->flags |= GF_ISOM_TRUN_FIRST_FLAG;
+				//if not old arch write the flags
+				//in old arch we write 0, which means all deps unknown and sync sample set
+				if (!traf->no_sdtp_first_flags)
+					trun->first_sample_flags = first_ent->flags;
 			}
 		}
 
@@ -1220,6 +1231,9 @@
 
 	if (e) return e;
 
+	if (movie->on_last_block_start && !gf_list_count(movie->moof_list))
+		movie->on_last_block_start(movie->on_block_out_usr_data);
+		
 	//rewrite mdat after moof
 	if (movie->moof->mdat) {
 		gf_bs_write_data(bs, movie->moof->mdat, movie->moof->mdat_size);
@@ -1243,6 +1257,8 @@
 	}
 
 	if (!movie->use_segments) {
+		//remove from moof list (may happen in regular fragmentation when single traf per moof is used)
+		gf_list_del_item(movie->moof_list, movie->moof);
 		gf_isom_box_del((GF_Box *) movie->moof);
 		movie->moof = NULL;
 	}
@@ -2449,7 +2465,7 @@
 
 	//store existing fragment
 	if (movie->moof) {
-		e = StoreFragment(movie, movie->use_segments ? GF_TRUE : GF_FALSE, 0, NULL, movie->use_segments ? GF_TRUE : GF_FALSE);
+		e = StoreFragment(movie, movie->use_segments ? GF_TRUE : GF_FALSE, 0, NULL, movie->use_segments ? GF_TRUE : (movie->on_block_out ? GF_TRUE : GF_FALSE));
 		if (e) return e;
 	}

gpac-2.0.0.tar.gz/src/isomedia/sample_descs.c -> gpac-2.2.0.tar.gz/src/isomedia/sample_descs.c Changed

@@ -445,20 +445,20 @@
 
 #ifndef GPAC_DISABLE_ISOM_WRITE
 GF_EXPORT
-GF_Err gf_isom_opus_config_new(GF_ISOFile *the_file, u32 trackNumber, GF_OpusSpecificBox *cfg, char *URLname, char *URNname, u32 *outDescriptionIndex)
+GF_Err gf_isom_opus_config_new(GF_ISOFile *the_file, u32 trackNumber, GF_OpusConfig *cfg, char *URLname, char *URNname, u32 *outDescriptionIndex)
 {
 	GF_TrackBox *trak;
 	GF_Err e;
 	u32 dataRefIndex;
 	GF_MPEGAudioSampleEntryBox *entry;
 	GF_SampleDescriptionBox *stsd;
-	ptrdiff_t offset;
 
+	if (!cfg) return GF_BAD_PARAM;
 	e = CanAccessMovie(the_file, GF_ISOM_OPEN_WRITE);
 	if (e) return e;
 
 	trak = gf_isom_get_track_from_file(the_file, trackNumber);
-	if (!trak || !trak->Media || !cfg) return GF_BAD_PARAM;
+	if (!trak || !trak->Media) return GF_BAD_PARAM;
 
 	//get or create the data ref
 	e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
@@ -476,9 +476,8 @@
 	if (!entry) return GF_OUT_OF_MEM;
 	entry->cfg_opus = (GF_OpusSpecificBox*)gf_isom_box_new_parent(&entry->child_boxes, GF_ISOM_BOX_TYPE_DOPS);
 	if (!entry->cfg_opus) return GF_OUT_OF_MEM;
-	//skip box header
-	offset = (ptrdiff_t)&cfg->version - (ptrdiff_t)cfg;
-	memcpy((char*)entry->cfg_opus + offset, (char*)cfg + offset, sizeof(GF_OpusSpecificBox) - (size_t)offset);
+	entry->cfg_opus->opcfg = *cfg;
+	entry->cfg_opus->opcfg.version = 0;
 
 	entry->dataReferenceIndex = dataRefIndex;
 	*outDescriptionIndex = gf_list_count(stsd->child_boxes);
@@ -486,8 +485,7 @@
 }
 #endif
 
-GF_EXPORT
-GF_Err gf_isom_opus_config_get(GF_ISOFile *the_file, u32 trackNumber, u32 StreamDescriptionIndex, u8 **dsi, u32 *dsi_size)
+static GF_Err gf_isom_opus_config_get_internal(GF_ISOFile *the_file, u32 trackNumber, u32 StreamDescriptionIndex, u8 **dsi, u32 *dsi_size, GF_OpusConfig *ocfg)
 {
 	u32 type;
 	GF_TrackBox *trak;
@@ -495,6 +493,8 @@
 	trak = gf_isom_get_track_from_file(the_file, trackNumber);
 	if (dsi) *dsi = NULL;
 	if (dsi_size) *dsi_size = 0;
+	if (ocfg) memset(ocfg, 0, sizeof(GF_OpusConfig));
+
 	if (!trak || !StreamDescriptionIndex) return GF_BAD_PARAM;
 
 	entry = (GF_MPEGAudioSampleEntryBox *)gf_list_get(trak->Media->information->sampleTable->SampleDescription->child_boxes, StreamDescriptionIndex-1);
@@ -512,15 +512,27 @@
 		return GF_BAD_PARAM;
 
 	if (dsi && dsi_size) {
-		GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-		gf_isom_box_size((GF_Box *)entry->cfg_opus);
-		gf_isom_box_write((GF_Box *)entry->cfg_opus, bs);
-		gf_bs_get_content(bs, dsi, dsi_size);
-		gf_bs_del(bs);
+		gf_odf_opus_cfg_write(&entry->cfg_opus->opcfg, dsi, dsi_size);
 	}
+	if (ocfg)
+		*ocfg = entry->cfg_opus->opcfg;
 	return GF_OK;
 }
 
+GF_EXPORT
+GF_Err gf_isom_opus_config_get(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, u8 **dsi, u32 *dsi_size)
+{
+	return gf_isom_opus_config_get_internal(isom_file, trackNumber, sampleDescriptionIndex, dsi, dsi_size, NULL);
+}
+
+GF_EXPORT
+GF_Err gf_isom_opus_config_get_desc(GF_ISOFile *isom_file, u32 trackNumber, u32 sampleDescriptionIndex, GF_OpusConfig *opcfg)
+{
+	return gf_isom_opus_config_get_internal(isom_file, trackNumber, sampleDescriptionIndex, NULL, NULL, opcfg);
+
+}
+
+
 #ifndef GPAC_DISABLE_ISOM_WRITE
 
 GF_EXPORT
@@ -703,6 +715,35 @@
 }
 
 GF_EXPORT
+GF_Err gf_isom_ac3_config_update(GF_ISOFile *the_file, u32 trackNumber, u32 sampleDescriptionIndex, GF_AC3Config *cfg)
+{
+	GF_TrackBox *trak;
+	GF_Err e;
+	GF_MPEGAudioSampleEntryBox *entry;
+
+	e = CanAccessMovie(the_file, GF_ISOM_OPEN_WRITE);
+	if (e) return e;
+
+	trak = gf_isom_get_track_from_file(the_file, trackNumber);
+	if (!trak || !trak->Media || !cfg || !sampleDescriptionIndex) return GF_BAD_PARAM;
+
+	if (!the_file->keep_utc)
+		trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
+
+	entry = gf_list_get(trak->Media->information->sampleTable->SampleDescription->child_boxes, sampleDescriptionIndex-1);
+	if (!entry) return GF_BAD_PARAM;
+	if (!entry->cfg_ac3) return GF_BAD_PARAM;
+
+	if (entry->cfg_ac3->cfg.is_ec3) {
+		if (!cfg->is_ec3) return GF_BAD_PARAM;
+	} else {
+		if (cfg->is_ec3) return GF_BAD_PARAM;
+	}
+	memcpy(&entry->cfg_ac3->cfg, cfg, sizeof(GF_AC3Config));
+	return GF_OK;
+}
+
+GF_EXPORT
 GF_Err gf_isom_flac_config_new(GF_ISOFile *the_file, u32 trackNumber, u8 *metadata, u32 metadata_size, const char *URLname, const char *URNname, u32 *outDescriptionIndex)
 {
 	GF_TrackBox *trak;
@@ -1283,7 +1324,7 @@
 	}
 
 	if (!mime) {
-		GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("Text (Metadata, Subtitle or SimpleText) SampleEntry: mime is mandatory. Using text/plain.\n"));
+		GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("Text (Metadata, Subtitle or SimpleText) missing mime, using text/plain.\n"));
 		mime = "text/plain";
 	}
 
@@ -1659,7 +1700,7 @@
 	return e;
 }
 
-GF_Err gf_isom_new_mpha_description(GF_ISOFile *movie, u32 trackNumber, const char *URLname, const char *URNname, u32 *outDescriptionIndex, u8 *dsi, u32 dsi_size)
+GF_Err gf_isom_new_mpha_description(GF_ISOFile *movie, u32 trackNumber, const char *URLname, const char *URNname, u32 *outDescriptionIndex, u8 *dsi, u32 dsi_size, u32 mha_subtype)
 {
 	GF_TrackBox *trak;
 	GF_Err e;
@@ -1668,7 +1709,6 @@
 
 	e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
 	if (e) return e;
-	if (dsi_size<6) return GF_BAD_PARAM;
 
 	trak = gf_isom_get_track_from_file(movie, trackNumber);
 	if (!trak || !trak->Media) return GF_BAD_PARAM;
@@ -1679,6 +1719,18 @@
 	default:
 		return GF_BAD_PARAM;
 	}
+	switch (mha_subtype) {
+	case GF_ISOM_BOX_TYPE_MHA1:
+	case GF_ISOM_BOX_TYPE_MHA2:
+		if (!dsi || (dsi_size<6)) return GF_BAD_PARAM;
+		break;
+	case GF_ISOM_BOX_TYPE_MHM1:
+	case GF_ISOM_BOX_TYPE_MHM2:
+		if (dsi_size && (dsi_size<6)) return GF_BAD_PARAM;
+		break;
+	default:
+		return GF_BAD_PARAM;
+	}
 
 	//get or create the data ref
 	e = Media_FindDataRef(trak->Media->information->dataInformation->dref, (char *)URLname, (char *)URNname, &dataRefIndex);
@@ -1690,23 +1742,25 @@
 	if (!movie->keep_utc)
 		trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
 
-	mpa = (GF_MPEGAudioSampleEntryBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_MHA1);
+	mpa = (GF_MPEGAudioSampleEntryBox *) gf_isom_box_new(mha_subtype);
 	if (!mpa) return GF_OUT_OF_MEM;
 	mpa->dataReferenceIndex = dataRefIndex;
 	gf_list_add(trak->Media->information->sampleTable->SampleDescription->child_boxes, mpa);
 	if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->child_boxes);
 
-	mpa->cfg_mha = (GF_MHAConfigBox *) gf_isom_box_new_parent(&mpa->child_boxes, GF_ISOM_BOX_TYPE_MHAC);
-	if (!mpa->cfg_mha) return GF_OUT_OF_MEM;
-	mpa->cfg_mha->configuration_version = dsi0;
-	mpa->cfg_mha->mha_pl_indication = dsi1;
-	mpa->cfg_mha->reference_channel_layout = dsi2;
-	mpa->cfg_mha->mha_config_size = dsi3;
-	mpa->cfg_mha->mha_config_size <<= 8;
-	mpa->cfg_mha->mha_config_size |= dsi4;
-	mpa->cfg_mha->mha_config = gf_malloc(sizeof(u8) * mpa->cfg_mha->mha_config_size);
-	if (!mpa->cfg_mha->mha_config) return GF_OUT_OF_MEM;
-	memcpy(mpa->cfg_mha->mha_config, dsi+5, dsi_size-5);
+	if (dsi) {
+		mpa->cfg_mha = (GF_MHAConfigBox *) gf_isom_box_new_parent(&mpa->child_boxes, GF_ISOM_BOX_TYPE_MHAC);
+		if (!mpa->cfg_mha) return GF_OUT_OF_MEM;
+		mpa->cfg_mha->configuration_version = dsi0;
+		mpa->cfg_mha->mha_pl_indication = dsi1;
+		mpa->cfg_mha->reference_channel_layout = dsi2;
+		mpa->cfg_mha->mha_config_size = dsi3;
+		mpa->cfg_mha->mha_config_size <<= 8;
+		mpa->cfg_mha->mha_config_size |= dsi4;
+		mpa->cfg_mha->mha_config = gf_malloc(sizeof(u8) * mpa->cfg_mha->mha_config_size);
+		if (!mpa->cfg_mha->mha_config) return GF_OUT_OF_MEM;
+		memcpy(mpa->cfg_mha->mha_config, dsi+5, dsi_size-5);
+	}
 	return GF_OK;
 }

gpac-2.0.0.tar.gz/src/isomedia/stbl_write.c -> gpac-2.2.0.tar.gz/src/isomedia/stbl_write.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / ISO Media File Format sub-project
@@ -273,7 +273,7 @@
 		if (offset<0) ctts->version=1;
 		if (ABS(offset) >= ctts->max_cts_delta) {
 			ctts->max_cts_delta = ABS(offset);
-			ctts->sample_num_max_cts_delta = ctts->w_LastSampleNumber;
+			//ctts->sample_num_max_cts_delta = ctts->w_LastSampleNumber;
 		}
 		return GF_OK;
 	}
@@ -289,7 +289,7 @@
 		if (e) return e;
 		if (ABS(offset) >= ctts->max_cts_delta) {
 			ctts->max_cts_delta = ABS(offset);
-			ctts->sample_num_max_cts_delta = ctts->w_LastSampleNumber;
+			//ctts->sample_num_max_cts_delta = ctts->w_LastSampleNumber;
 		}
 		return GF_OK;
 	}
@@ -310,7 +310,7 @@
 				sampNum ++;
 				if (ABS(offset) >= ctts->max_cts_delta) {
 					ctts->max_cts_delta = ABS(offset);
-					ctts->sample_num_max_cts_delta = sampNum;
+					//ctts->sample_num_max_cts_delta = sampNum;
 				}
 			}
 			CTSssampNum = ctts->entriesi.decodingOffset;
@@ -914,7 +914,7 @@
 			gf_free(co64->offsets);
 			co64->offsets = newLarge;
 			co64->nb_entries++;
-			co64->alloc_size++;
+			co64->alloc_size = co64->nb_entries;
 		}
 	}
 
@@ -1377,7 +1377,13 @@
 
 	//we remove the only one around...
 	if (stss->nb_entries == 1) {
-		if (stss->sampleNumbers0 != sampleNumber) return GF_OK;
+		if (stss->sampleNumbers0 != sampleNumber) {
+			if (sampleNumber < stss->sampleNumbers0) {
+				assert(stss->sampleNumbers0);
+				stss->sampleNumbers0--;
+			}
+			return GF_OK;
+		}
 		//free our numbers but don't delete (all samples are NON-sync
 		gf_free(stss->sampleNumbers);
 		stss->sampleNumbers = NULL;
@@ -1391,9 +1397,10 @@
 		if (sampleNumber == stss->sampleNumbersi) {
 			memmove(&stss->sampleNumbersi, &stss->sampleNumbersi+1, sizeof(u32)* (stss->nb_entries-i-1) );
 			stss->nb_entries--;
+			i--;
 		}
 
-		if (sampleNumber < stss->sampleNumbersi) {
+		else if (sampleNumber < stss->sampleNumbersi) {
 			assert(stss->sampleNumbersi);
 			stss->sampleNumbersi--;
 		}
@@ -1401,6 +1408,35 @@
 	return GF_OK;
 }
 
+GF_Err stbl_RemoveRAPs(GF_SampleTableBox *stbl, u32 nb_samples)
+{
+	u32 i;
+
+	GF_SyncSampleBox *stss = stbl->SyncSample;
+	if (!stss) return GF_OK;
+
+	for (i=0; i<stss->nb_entries; i++) {
+		if (stss->sampleNumbersi <= nb_samples) {
+			memmove(&stss->sampleNumbersi, &stss->sampleNumbersi+1, sizeof(u32)* (stss->nb_entries-i-1) );
+			stss->nb_entries--;
+			i--;
+			continue;
+		}
+		stss->sampleNumbersi -= nb_samples;
+	}
+
+	if (!stss->nb_entries) {
+		//free our numbers but don't delete (all samples are NON-sync
+		gf_free(stss->sampleNumbers);
+		stss->sampleNumbers = NULL;
+		stss->r_LastSampleIndex = stss->r_LastSyncSample = 0;
+		stss->alloc_size = stss->nb_entries = 0;
+		return GF_OK;
+	}
+
+	return GF_OK;
+}
+
 GF_Err stbl_RemoveRedundant(GF_SampleTableBox *stbl, u32 SampleNumber, u32 nb_samples)
 {
 	u32 i;
@@ -1435,9 +1471,11 @@
 	//shadows for 1 sample...
 	i=0;
 	while ((ent = (GF_StshEntry *)gf_list_enum(stsh->entries, &i))) {
-		if (ent->shadowedSampleNumber == sampleNumber) {
+		if (ent->shadowedSampleNumber <= sampleNumber) {
 			i--;
 			gf_list_rem(stsh->entries, i);
+		} else {
+			ent->shadowedSampleNumber--;
 		}
 	}
 	//reset the cache
@@ -1517,7 +1555,7 @@
 
 GF_Err stbl_RemoveSubSample(GF_SampleTableBox *stbl, u32 SampleNumber)
 {
-	u32 i, count, j, subs_count, prev_sample, delta=0;
+	u32 i, count, j, subs_count, prev_sample;
 
 	if (! stbl->sub_samples) return GF_OK;
 	subs_count = gf_list_count(stbl->sub_samples);
@@ -1525,12 +1563,19 @@
 		GF_SubSampleInformationBox *subs = gf_list_get(stbl->sub_samples, j);
 		if (! subs->Samples) continue;
 
+
 		prev_sample = 0;
 		count = gf_list_count(subs->Samples);
 		for (i=0; i<count; i++) {
 			GF_SubSampleInfoEntry *e = gf_list_get(subs->Samples, i);
 			prev_sample += e->sample_delta;
-			if (prev_sample==SampleNumber) {
+			//convert to sample num
+			e->sample_delta = prev_sample;
+		}
+		for (i=0; i<count; i++) {
+			GF_SubSampleInfoEntry *e = gf_list_get(subs->Samples, i);
+			//remove
+			if (e->sample_delta<=SampleNumber) {
 				gf_list_rem(subs->Samples, i);
 				while (gf_list_count(e->SubSamples)) {
 					GF_SubSampleEntry *pSubSamp = (GF_SubSampleEntry*) gf_list_get(e->SubSamples, 0);
@@ -1541,10 +1586,19 @@
 				gf_free(e);
 				i--;
 				count--;
-				delta=1;
 				continue;
+			} else {
+				e->sample_delta--;
 			}
-			e->sample_delta+=delta;
+
+		}
+		//convert back to delta
+		GF_SubSampleInfoEntry *prev_e = gf_list_get(subs->Samples, 0);
+		if (!prev_e) return GF_OK;
+		for (i=1; i<count; i++) {
+			GF_SubSampleInfoEntry *e = gf_list_get(subs->Samples, i);
+			e->sample_delta = e->sample_delta - prev_e->sample_delta;
+			prev_e = e;
 		}
 	}
 	return GF_OK;
@@ -1730,6 +1784,7 @@
 	if (!co64->offsets) return GF_OUT_OF_MEM;
 	co64->offsetsco64->nb_entries = offset;
 	co64->alloc_size = co64->nb_entries;
+ co64->nb_entries += 1;
 	return GF_OK;
 }
 
@@ -1805,7 +1860,7 @@
 	return GF_OK;
 }
 
-GF_Err stbl_AppendTrafMap(GF_SampleTableBox *stbl, Bool is_seg_start, u64 seg_start_offset, u64 frag_start_offset, u8 *moof_template, u32 moof_template_size, u64 sidx_start, u64 sidx_end, u32 nb_pack_samples)
+GF_Err stbl_AppendTrafMap(GF_ISOFile *mov, GF_SampleTableBox *stbl, Bool is_seg_start, u64 seg_start_offset, u64 frag_start_offset, u8 *moof_template, u32 moof_template_size, u64 sidx_start, u64 sidx_end, u32 nb_pack_samples)
 {
 	GF_TrafToSampleMap *tmap;
 	GF_TrafMapEntry *tmap_ent;
@@ -1890,7 +1945,7 @@
 
 	if (ABS(offset) >= ctts->max_cts_delta) {
 		ctts->max_cts_delta = ABS(offset);
-		ctts->sample_num_max_cts_delta = ctts->w_LastSampleNumber;
+		//ctts->sample_num_max_cts_delta = ctts->w_LastSampleNumber;
 	}
 
 	return GF_OK;

gpac-2.0.0.tar.gz/src/isomedia/track.c -> gpac-2.2.0.tar.gz/src/isomedia/track.c Changed

@@ -211,7 +211,7 @@
 			} else {
 				esd->decoderConfig->rvc_config = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
 				if (mime_type && !strcmp(mime_type, "application/rvc-config+xml+gz") ) {
-#if !defined(GPAC_DISABLE_CORE_TOOLS) && !defined(GPAC_DISABLE_ZLIB)
+#if !defined(GPAC_DISABLE_ZLIB)
 					gf_gz_decompress_payload(rvc_cfg_data, rvc_cfg_size, &esd->decoderConfig->rvc_config->data, &esd->decoderConfig->rvc_config->dataLength);
 					gf_free(rvc_cfg_data);
 #endif
@@ -441,6 +441,17 @@
 }
 #endif
 
+static u32 saio_get_index(GF_TrackFragmentBox *traf, u32 sample_idx)
+{
+	u32 k, all_samples=0, saio_idx=0;
+	for (k=0; k<gf_list_count(traf->TrackRuns); k++) {
+		GF_TrackFragmentRunBox *trun = gf_list_get(traf->TrackRuns, k);
+		all_samples+=trun->nb_samples;
+		if (sample_idx<all_samples) break;
+		saio_idx++;
+	}
+	return saio_idx;
+}
 
 GF_Err MergeTrack(GF_TrackBox *trak, GF_TrackFragmentBox *traf, GF_MovieFragmentBox *moof_box, u64 moof_offset, s32 compressed_diff, u64 *cumulated_offset)
 {
@@ -786,7 +797,7 @@
 
 			if (store_traf_map && first_samp_in_traf) {
 				first_samp_in_traf = GF_FALSE;
-				e = stbl_AppendTrafMap(trak->Media->information->sampleTable, is_seg_start, seg_start, frag_start, moof_template, moof_template_size, sidx_start, sidx_end, ent->nb_pack);
+				e = stbl_AppendTrafMap(trak->moov->mov, trak->Media->information->sampleTable, is_seg_start, seg_start, frag_start, moof_template, moof_template_size, sidx_start, sidx_end, ent->nb_pack);
 				if (e) return e;
 				//do not deallocate, the memory is now owned by traf map
 				moof_template = NULL;
@@ -1004,7 +1015,7 @@
 		|| traf->sample_encryption) {
 		/*Merge sample auxiliary encryption information*/
 		GF_SampleEncryptionBox *senc = NULL;
-		u32 scheme_type;
+		u32 scheme_type=0;
 		gf_isom_get_cenc_info(trak->moov->mov, track_num, DescIndex, NULL, &scheme_type, NULL);
 
 		if (traf->sample_encryption) {
@@ -1086,8 +1097,13 @@
 					const u8 *key_info=NULL;
 					u32 key_info_size, samp_num;
 					u64 cur_position;
-					if (nb_saio != 1)
-						offset = saio->offsetsi + moof_offset;
+					if (nb_saio != 1) {
+						u32 saio_idx = saio_get_index(traf, i);
+						if (saio_idx>=saio->entry_count)
+							return GF_ISOM_INVALID_FILE;
+
+						offset = saio->offsetssaio_idx + moof_offset;
+					}
 					size = saiz->default_sample_info_size ? saiz->default_sample_info_size : saiz->sample_info_sizei;
 
 					cur_position = gf_bs_get_position(trak->moov->mov->movieFileMap->bs);
@@ -1135,8 +1151,8 @@
 
 					e = gf_isom_cenc_merge_saiz_saio(senc, trak->Media->information->sampleTable, samp_num, offset, size);
 					if (e) return e;
-					if (nb_saio == 1)
-						offset += size;
+					//always increment size even for saio.nb_entries>1
+					offset += size;
 				}
 			}
 		} else if (traf->sample_encryption) {
@@ -1181,16 +1197,22 @@
 		}
 		u64 offset = saio->offsets0 + moof_offset;
 		u32 nb_saio = saio->entry_count;
-		if ((nb_saio>1) && (saio->entry_count != saiz->sample_count)) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("isobmf Number of size and offset mismatch in auxiliary type %s aux info type %d, cannot merge SAI\n", gf_4cc_to_str(saiz->aux_info_type), saiz->aux_info_type_parameter));
+		if ((nb_saio>1) && (saio->entry_count != gf_list_count(traf->TrackRuns))) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("isobmf Number of SAI offset does not match number of fragments, cannot merge SAI %s aux info type %d\n", gf_4cc_to_str(saiz->aux_info_type), saiz->aux_info_type_parameter));
 			continue;
 		}
 
 		u32 sai_max_size=0;
 		u8 *sai = NULL;
 		for (j=0; j < saiz->sample_count; j++) {
-			if (nb_saio != 1)
+			if (nb_saio != 1) {
+				u32 saio_idx = saio_get_index(traf, i);
+				if (saio_idx>=saio->entry_count) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("isobmf Number of offset less than number of fragments, cannot merge SAI %s aux info type %d\n", gf_4cc_to_str(saiz->aux_info_type), saiz->aux_info_type_parameter));
+					break;
+				}
 				offset = saio->offsetsj + moof_offset;
+			}
 			size = saiz->default_sample_info_size ? saiz->default_sample_info_size : saiz->sample_info_sizej;
 
 			u64 cur_position = gf_bs_get_position(trak->moov->mov->movieFileMap->bs);
@@ -1210,8 +1232,8 @@
 				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("isobmf Failed to merge sai data: %s\n", gf_error_to_string(e) ));
 			}
 
-			if (nb_saio == 1)
-				offset += size;
+			//always increment size even for saio.nb_entries>1
+			offset += size;
 		}
 		if (sai) gf_free(sai);
 	}
@@ -1573,7 +1595,7 @@
 		entry_type = entry->type;
 		GF_ProtectionSchemeInfoBox *sinf = (GF_ProtectionSchemeInfoBox *) gf_isom_box_find_child(entry->child_boxes, GF_ISOM_BOX_TYPE_SINF);
 		if (sinf && sinf->original_format) entry_type = sinf->original_format->data_format;
-		
+
 		switch (entry_type) {
 		case GF_ISOM_BOX_TYPE_MP4S:
 			//OK, delete the previous ESD
@@ -1734,7 +1756,7 @@
 		if (!trak->Media->information->sampleTable->SampleDescription->child_boxes)
 			trak->Media->information->sampleTable->SampleDescription->child_boxes = gf_list_new();
 		gf_list_add(trak->Media->information->sampleTable->SampleDescription->child_boxes, entry);
-		
+
 		e = stsd_on_child_box((GF_Box*)trak->Media->information->sampleTable->SampleDescription, (GF_Box *) entry, GF_FALSE);
 		if (e) return e;
 		if(outStreamIndex) *outStreamIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->child_boxes);

gpac-2.0.0.tar.gz/src/jsmods/core.c -> gpac-2.2.0.tar.gz/src/jsmods/core.c Changed

@@ -103,24 +103,20 @@
 
 	js_rt->nb_inst --;
 	if (js_rt->nb_inst == 0) {
-		//persistent context, do not delete runtime but perform GC
-		if (gf_opts_get_bool("temp", "peristent-jsrt")) {
-			JS_RunGC(js_rt->js_runtime);
-			return;
-		}
-
-		qjs_uninit_runtime_libc(js_rt->js_runtime);
-		JS_FreeRuntime(js_rt->js_runtime);
-		gf_list_del(js_rt->allocated_contexts);
-		gf_mx_del(js_rt->mx);
-		gf_free(js_rt);
-		js_rt = NULL;
+		//we delete the runtime in gf_sys_close (we use static vars for class IDs)
+		//but perform GC
+		JS_RunGC(js_rt->js_runtime);
 	}
 }
-GF_EXPORT
+
 void gf_js_delete_runtime()
 {
+	//prevent destruction of the runtime if asked (used for android)
+	if (gf_opts_get_bool("temp", "static-jsrt"))
+		return;
+
 	if (js_rt) {
+		qjs_uninit_runtime_libc(js_rt->js_runtime);
 		JS_FreeRuntime(js_rt->js_runtime);
 		gf_list_del(js_rt->allocated_contexts);
 		gf_mx_del(js_rt->mx);
@@ -182,6 +178,7 @@
 int i=0;
 Bool first=GF_TRUE;
 s32 logl = GF_LOG_INFO;
+ Bool no_new_line = GF_FALSE;
 JSValue v, g;
 const char *c_logname=NULL;
 const char *log_name = "JS";
@@ -241,14 +238,20 @@
 				js_dump_error_exc(ctx, argvi);
 			}
 		}
+ if (i+1==argc) {
+			u32 len = (u32) strlen(str);
+			if (len && (strlen-1=='\r')) no_new_line = GF_TRUE;
+		}
 JS_FreeCString(ctx, str);
 first=GF_FALSE;
 }
+ if (!no_new_line) {
 #ifndef GPAC_DISABLE_LOG
- 	GF_LOG(logl, ltool, ("\n"));
+		GF_LOG(logl, ltool, ("\n"));
 #else
-	fprintf(stderr, "\n");
+		fprintf(stderr, "\n");
 #endif
+	}
 	if (c_logname) JS_FreeCString(ctx, c_logname);
 	return JS_UNDEFINED;
 }
@@ -456,6 +459,18 @@
 		return JS_NewInt32(ctx, gf_bs_read_int(bs, nb_bits) );
 	return JS_NewInt64(ctx, gf_bs_read_long_int(bs, nb_bits) );
 }
+static JSValue js_bs_get_string(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	char *res;
+	JSValue ret;
+	GET_JSBS
+	if (!bs) return GF_JS_EXCEPTION(ctx);
+	res = gf_bs_read_utf8(bs);
+	if (!res) return JS_NULL;
+	ret = JS_NewString(ctx, res);
+	gf_free(res);
+	return ret;
+}
 
 static JSValue js_bs_data_io(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, u32 mode)
 {
@@ -498,6 +513,14 @@
 {
 	return js_bs_data_io(ctx, this_val, argc, argv, 0);
 }
+
+static JSValue js_bs_get_4cc(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	GET_JSBS
+	u32 fcc = gf_bs_read_u32(bs);
+	return JS_NewString(ctx, gf_4cc_to_str(fcc) );
+}
+
 static JSValue js_bs_skip_bytes(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
 	s32 nb_bytes;
@@ -667,6 +690,35 @@
 	return js_bs_data_io(ctx, this_val, argc, argv, 2);
 }
 
+static JSValue js_bs_put_4cc(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	u32 val;
+	GET_JSBS
+	if (!bs || (argc!=1)) return GF_JS_EXCEPTION(ctx);
+	if (!JS_IsString(argv0)) return GF_JS_EXCEPTION(ctx);
+	const char *str = JS_ToCString(ctx, argv0);
+	if (!str || (strlen(str) != 4)) {
+		if (str) JS_FreeCString(ctx, str);
+		return GF_JS_EXCEPTION(ctx);
+	}
+	val = GF_4CC(str0, str1, str2, str3);
+	JS_FreeCString(ctx, str);
+	gf_bs_write_u32(bs, val);
+	return JS_UNDEFINED;
+}
+
+static JSValue js_bs_put_string(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	GET_JSBS
+	if (!bs || (argc!=1)) return GF_JS_EXCEPTION(ctx);
+	if (!JS_IsString(argv0)) return GF_JS_EXCEPTION(ctx);
+	const char *str = JS_ToCString(ctx, argv0);
+	if (!str) return GF_JS_EXCEPTION(ctx);
+	gf_bs_write_utf8(bs, str);
+	JS_FreeCString(ctx, str);
+	return JS_UNDEFINED;
+}
+
 static JSValue js_bs_get_content(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
 	u8 *data;
@@ -781,9 +833,11 @@
 	JS_CFUNC_DEF("get_u64_le", 0, js_bs_get_u64_le),
 	JS_CFUNC_DEF("get_s64", 0, js_bs_get_s64),
 	JS_CFUNC_DEF("get_bits", 0, js_bs_get_bits),
+	JS_CFUNC_DEF("get_string", 0, js_bs_get_string),
 	JS_CFUNC_DEF("get_float", 0, js_bs_get_float),
 	JS_CFUNC_DEF("get_double", 0, js_bs_get_double),
 	JS_CFUNC_DEF("get_data", 0, js_bs_get_data),
+	JS_CFUNC_DEF("get_4cc", 0, js_bs_get_4cc),
 	JS_CFUNC_DEF("put_u8", 0, js_bs_put_u8),
 	JS_CFUNC_DEF("put_s8", 0, js_bs_put_s8),
 	JS_CFUNC_DEF("put_u16", 0, js_bs_put_u16),
@@ -800,6 +854,8 @@
 	JS_CFUNC_DEF("put_float", 0, js_bs_put_float),
 	JS_CFUNC_DEF("put_double", 0, js_bs_put_double),
 	JS_CFUNC_DEF("put_data", 0, js_bs_put_data),
+	JS_CFUNC_DEF("put_4cc", 0, js_bs_put_4cc),
+	JS_CFUNC_DEF("put_string", 0, js_bs_put_string),
 	JS_CFUNC_DEF("insert_data", 0, js_bs_insert_data),
 	JS_CFUNC_DEF("get_content", 0, js_bs_get_content),
 	JS_CFUNC_DEF("transfer", 0, js_bs_transfer),
@@ -977,18 +1033,15 @@
 		}
 		break;
 	case JS_SYS_LAST_WORK_DIR:
-		res = gf_opts_get_key("General", "LastWorkingDir");
+		res = gf_opts_get_key("core", "last-dir");
 #ifdef WIN32
 		if (!res) res = getenv("HOMEPATH");
 		if (!res) res = "C:\\";
 #elif defined(GPAC_CONFIG_DARWIN)
 		if (!res) res = getenv("HOME");
 		if (!res) res = "/Users";
-#elif defined(GPAC_CONFIG_ANDROID)
-		if (!res) res = getenv("EXTERNAL_STORAGE");
-		if (!res) res = "/sdcard";
-#elif defined(GPAC_CONFIG_IOS)
-		if (!res) res = (char *) gf_opts_get_key("General", "iOSDocumentsDir");
+#elif defined(GPAC_CONFIG_ANDROID) || defined(GPAC_CONFIG_IOS)
+		if (!res) res = (char *) gf_opts_get_key("core", "docs-dir");
 #else
 		if (!res) res = getenv("HOME");
 		if (!res) res = "/home/";
@@ -1056,7 +1109,7 @@
 	case JS_SYS_LAST_WORK_DIR:
 		if (!JS_IsString(value)) return GF_JS_EXCEPTION(ctx);
 		prop_val = JS_ToCString(ctx, value);
-		gf_opts_set_key("General", "LastWorkingDir", prop_val);
+		gf_opts_set_key("core", "last-dir", prop_val);
 		JS_FreeCString(ctx, prop_val);
 		break;
 	}
@@ -1877,14 +1930,15 @@
 		size_t data_size;
 		data = JS_GetArrayBuffer(ctx, &data_size, argv0 );
 		if (!data) return GF_JS_EXCEPTION(ctx);
-		out_ptr = gf_malloc(sizeof(u8) * (1 + data_size * 2) );
+		u32 size64 = (u32) data_size * 2 + 3;
+		out_ptr = gf_malloc(sizeof(char) * size64);
 		if (!out_ptr) {
 			e = GF_OUT_OF_MEM;
 		} else if (is_16) {
-			out_size = gf_base16_encode((u8*) data, (u32) data_size, out_ptr, 1 + (u32) data_size * 2);
+			out_size = gf_base16_encode((u8*) data, (u32) data_size, out_ptr, size64);
 			e = out_size ? GF_OK : GF_NON_COMPLIANT_BITSTREAM;
 		} else {
-			out_size = gf_base64_encode((u8*) data, (u32) data_size, out_ptr, 1 + (u32) data_size * 2);
+			out_size = gf_base64_encode((u8*) data, (u32) data_size, out_ptr, size64);
 			e = out_size ? GF_OK : GF_NON_COMPLIANT_BITSTREAM;
 		}
 	}
@@ -1961,6 +2015,14 @@
 	return JS_NewInt32(ctx, osize);
 }
 
+static JSValue js_pixfmt_depth(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	GF_PropertyValue prop;
+	if (argc<1) return GF_JS_EXCEPTION(ctx);
+	GF_Err e = jsf_ToProp_ex(NULL, ctx, argv0, 0, &prop, GF_PROP_PIXFMT);
+	if (e) return GF_JS_EXCEPTION(ctx);
+	return JS_NewInt32(ctx, gf_pixel_is_wide_depth(prop.value.uint));
+}
 static JSValue js_pixfmt_transparent(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
 	GF_PropertyValue prop;
@@ -2252,10 +2314,10 @@
 			//todo , proper down/up mix ...
 			for (k=0; k<mix->channels; k++) {
 				Double s_val;
-				if (pid->channels < k )
+				if (pid->channels <= k)
 					s_val = mix->in_chan_buf0;
 				else
-				s_val = mix->in_chan_bufk;
+					s_val = mix->in_chan_bufk;
 
 				mix->chan_bufk += s_val * fade_scale;
 			}
@@ -2522,6 +2584,7 @@
 	JS_CFUNC_DEF("pixfmt_size", 0, js_pixfmt_size),
 	JS_CFUNC_DEF("pixfmt_transparent", 0, js_pixfmt_transparent),
 	JS_CFUNC_DEF("pixfmt_yuv", 0, js_pixfmt_yuv),
+	JS_CFUNC_DEF("pixfmt_depth", 0, js_pixfmt_depth),
 	JS_CFUNC_DEF("pcmfmt_depth", 0, js_pcmfmt_depth),
 	JS_CFUNC_DEF("color_lerp", 0, js_color_lerp),
 	JS_CFUNC_DEF("color_component", 0, js_color_get_component),
@@ -2745,7 +2808,7 @@
 {
 	const u8 *data;
 	size_t size;
-	u32 read;
+	u32 written;
 	s32 nb_bytes=0;
 	FILE *f = JS_GetOpaque(this_val, file_class_id);
 	if (!f) return GF_JS_EXCEPTION(ctx);
@@ -2759,8 +2822,8 @@
 	if (!nb_bytes) nb_bytes = (u32) size;
 	else if (nb_bytes > (s32) size) nb_bytes = (u32) size;
 
-	read = (u32) gf_fwrite((void *) data, nb_bytes, f);
-	return JS_NewInt64(ctx, read);
+	written = (u32) gf_fwrite((void *) data, nb_bytes, f);
+	return JS_NewInt64(ctx, written);
 }
 static JSValue js_file_puts(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
@@ -3599,10 +3662,15 @@
 		u8 *buf;
 		JSValue func_val;
 		char *url;
+		GF_Err e;
 		const char *par_url = jsf_get_script_filename(ctx);
 		url = gf_url_concatenate(par_url, module_name);
 
-		GF_Err e = gf_file_load_data(url ? url : module_name, &buf, &buf_len);
+		if (gf_file_exists(url ? url : module_name)) {
+			e = gf_file_load_data(url ? url : module_name, &buf, &buf_len);
+		} else {
+			e = GF_URL_ERROR;
+		}
 		if (url) gf_free(url);
 
 		if (e != GF_OK) {
@@ -3666,6 +3734,12 @@
 if (gf_opts_get_bool("core", "unhandled-rejection")) {
 JS_SetHostPromiseRejectionTracker(rt, js_promise_rejection_tracker, NULL);
 }
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) {
+		js_promise_rejection_tracker(NULL, JS_NULL, JS_NULL, 1, NULL);
+	}
+#endif
+
 #endif
 
 }

gpac-2.0.0.tar.gz/src/jsmods/evg.c -> gpac-2.2.0.tar.gz/src/jsmods/evg.c Changed

@@ -1043,8 +1043,8 @@
 	tx = JS_GetOpaque(argv0, texture_class_id);
 	if (!tx) return GF_JS_EXCEPTION(c);
 
-	pf_src = ffmpeg_pixfmt_from_gpac(tx->pf);
-	pf_dst = ffmpeg_pixfmt_from_gpac(canvas->pf);
+	pf_src = ffmpeg_pixfmt_from_gpac(tx->pf, GF_FALSE);
+	pf_dst = ffmpeg_pixfmt_from_gpac(canvas->pf, GF_FALSE);
 	if ((pf_src==AV_PIX_FMT_NONE) || (pf_dst==AV_PIX_FMT_NONE))
 		return js_throw_err(c, GF_NOT_SUPPORTED);
 
@@ -1577,7 +1577,7 @@
 	GF_IVec4 *right_vali;
 	register u32 if_level=0;
 	register u32 nif_level=0;
-	register Bool cond_res;
+	register Bool cond_res=GF_FALSE;
 	register ShaderOp *op = &shader->ops0;
 
 	//assign to dummy values, this will prevent any badly formatted shader to assign a value to a NULL left-val or read a null right-val
@@ -3763,6 +3763,9 @@
 
 static void va_gc_mark(JSRuntime *rt, JSValueConst obj, JS_MarkFunc *mark_func)
 {
+#ifdef GPAC_ENABLE_COVERAGE
+	if (!rt) return;
+#endif
 	EVG_VA *va = JS_GetOpaque(obj, va_class_id);
 	if (!va) return;
 	JS_MarkValue(rt, va->ab, mark_func);
@@ -6251,6 +6254,189 @@
 	return JS_NewString(c, szCol);
 }
 
+u32 gf_evg_stencil_get_pixel_fast(GF_EVGStencil *st, s32 x, s32 y);
+
+static JSValue texture_diff_score(JSContext *c, JSValueConst obj, int argc, JSValueConst *argv)
+{
+	u32 i, j;
+	Bool is_yuv=GF_FALSE;
+	Bool has_alpha=GF_FALSE;
+	Bool split_sums=GF_FALSE;
+	Bool do_mae = GF_FALSE, do_mse = GF_FALSE;
+	Double mae_r=0, mae_g=0, mae_b=0, mae_a=0;
+	Double mse_r=0, mse_g=0, mse_b=0, mse_a=0;
+	GF_JSTexture *tx = JS_GetOpaque(obj, texture_class_id);
+	if (!tx || !tx->stencil || !argc) return GF_JS_EXCEPTION(c);
+	GF_JSTexture *tx_with = JS_GetOpaque(argv0, texture_class_id);
+	if (!tx_with || !tx_with->stencil) return GF_JS_EXCEPTION(c);
+
+	if (tx_with->width != tx->width) return GF_JS_EXCEPTION(c);
+	if (tx_with->height != tx->height) return GF_JS_EXCEPTION(c);
+	if (tx_with->pf != tx->pf) return GF_JS_EXCEPTION(c);
+
+	if (argc>1) {
+		int idx=1;
+		if (JS_IsString(argv1)) {
+			const char * str = JS_ToCString(c, argv1);
+			if (strstr(str, "mae")) do_mae = GF_TRUE;
+			if (strstr(str, "mse")) do_mse = GF_TRUE;
+			idx++;
+			JS_FreeCString(c, str);
+		}
+		if ((argc>idx) && JS_ToBool(c, argvidx)) {
+			split_sums = GF_TRUE;
+		}
+	}
+	if (!do_mae && !do_mse) do_mae = GF_TRUE;
+
+	if (!split_sums && gf_pixel_fmt_is_yuv(tx->pf)) {
+		is_yuv = GF_TRUE;
+	}
+
+	has_alpha = gf_pixel_fmt_is_transparent(tx->pf);
+
+	for (j=0; j<tx->height; j++) {
+		u64 mae_line_r=0, mae_line_g=0, mae_line_b=0, mae_line_a=0;
+		u64 mse_line_r=0, mse_line_g=0, mse_line_b=0, mse_line_a=0;
+		for (i=0; i<tx->width; i++) {
+			u32 pval, pval2;
+			if (is_yuv) {
+				pval = gf_evg_stencil_get_pixel_fast(tx->stencil, i, j);
+				pval2 = gf_evg_stencil_get_pixel_fast(tx_with->stencil, i, j);
+			} else {
+				pval = gf_evg_stencil_get_pixel_fast(tx->stencil, i, j);
+				pval2 = gf_evg_stencil_get_pixel_fast(tx_with->stencil, i, j);
+			}
+			s32 this_c = GF_COL_R(pval);
+			s32 prev_c = GF_COL_R(pval2);
+			if (do_mse) mse_line_r += (this_c-prev_c)*(this_c-prev_c);
+			if (do_mae) {
+				if (prev_c<this_c) mae_line_r += this_c-prev_c;
+				else mae_line_r += prev_c-this_c;
+			}
+
+			if (has_alpha) {
+				this_c = GF_COL_A(pval);
+				prev_c = GF_COL_A(pval2);
+				if (do_mse) mse_line_a += (this_c-prev_c)*(this_c-prev_c);
+				if (do_mae) {
+					if (prev_c<this_c) mae_line_a += this_c-prev_c;
+					else mae_line_a += prev_c-this_c;
+				}
+			}
+
+			if (is_yuv) continue;
+
+			this_c = GF_COL_G(pval);
+			prev_c = GF_COL_G(pval2);
+			if (do_mse) mse_line_g += (this_c-prev_c)*(this_c-prev_c);
+			if (do_mae) {
+				if (prev_c<this_c) mae_line_g += this_c-prev_c;
+				else mae_line_g += prev_c-this_c;
+			}
+
+			this_c = GF_COL_B(pval);
+			prev_c = GF_COL_B(pval2);
+			if (do_mse) mse_line_b += (this_c-prev_c)*(this_c-prev_c);
+			if (do_mae) {
+				if (prev_c<this_c) mae_line_b += this_c-prev_c;
+				else mae_line_b += prev_c-this_c;
+			}
+		}
+		mae_r += mae_line_r;
+		mae_g += mae_line_g;
+		mae_b += mae_line_b;
+		mae_a += mae_line_a;
+
+		mse_r += mse_line_r;
+		mse_g += mse_line_g;
+		mse_b += mse_line_b;
+		mse_a += mse_line_a;
+	}
+
+	u64 div = tx->height * tx->width * 255;
+	u64 div_mse = div * 255;
+
+	u32 nb_p=1;
+	Double mae = mae_r;
+	Double mse = mse_r;
+	mae_r /= div;
+	mse_r /= div_mse;
+	if (has_alpha) {
+		mae += mae_a;
+		mse += mse_a;
+		nb_p=2;
+		mae_a /= div;
+		mse_a /= div_mse;
+	}
+	if (!is_yuv) {
+		mae += mae_g + mae_b;
+		mse += mse_g + mse_b;
+		nb_p = 4;
+		mae_g /= div;
+		mae_b /= div;
+		mse_g /= div_mse;
+		mse_b /= div_mse;
+	}
+#define FCLAMP(_v)\
+		if (_v<0) _v = 0;\
+		else if (_v>1.0) _v = 1.0;\
+
+
+	if (!split_sums) {
+		JSValue ar = JS_NewArray(c);
+		if (JS_IsException(ar)) return GF_JS_EXCEPTION(c);
+		JSValue v = JS_NewObject(c);
+		if (JS_IsException(v)) return GF_JS_EXCEPTION(c);
+
+		mae /= div * nb_p;
+		mse /= div_mse * nb_p;
+		FCLAMP(mae)
+		FCLAMP(mse)
+		JS_SetPropertyStr(c, v, "mae", JS_NewFloat64(c, mae*100));
+		JS_SetPropertyStr(c, v, "mse", JS_NewFloat64(c, mse*100));
+		JS_SetPropertyUint32(c, ar, 0, v);
+		return ar;
+	}
+
+	JSValue ar = JS_NewArray(c);
+	if (JS_IsException(ar)) return GF_JS_EXCEPTION(c);
+	FCLAMP(mae_r)
+	FCLAMP(mae_g)
+	FCLAMP(mae_b)
+	FCLAMP(mae_a)
+	FCLAMP(mse_r)
+	FCLAMP(mse_g)
+	FCLAMP(mse_b)
+	FCLAMP(mse_a)
+
+	JSValue v = JS_NewObject(c);
+	if (JS_IsException(v)) return GF_JS_EXCEPTION(c);
+	JS_SetPropertyStr(c, v, "mae", JS_NewFloat64(c, mae_r*100));
+	JS_SetPropertyStr(c, v, "mse", JS_NewFloat64(c, mse_r*100));
+	JS_SetPropertyUint32(c, ar, 0, v);
+
+	v = JS_NewObject(c);
+	if (JS_IsException(v)) return GF_JS_EXCEPTION(c);
+	JS_SetPropertyStr(c, v, "mae", JS_NewFloat64(c, mae_g*100));
+	JS_SetPropertyStr(c, v, "mse", JS_NewFloat64(c, mse_g*100));
+	JS_SetPropertyUint32(c, ar, 1, v);
+
+	v = JS_NewObject(c);
+	if (JS_IsException(v)) return GF_JS_EXCEPTION(c);
+	JS_SetPropertyStr(c, v, "mae", JS_NewFloat64(c, mae_b*100));
+	JS_SetPropertyStr(c, v, "mse", JS_NewFloat64(c, mse_b*100));
+	JS_SetPropertyUint32(c, ar, 2, v);
+
+	if (has_alpha) {
+		v = JS_NewObject(c);
+		if (JS_IsException(v)) return GF_JS_EXCEPTION(c);
+		JS_SetPropertyStr(c, v, "mae", JS_NewFloat64(c, mae_a*100));
+		JS_SetPropertyStr(c, v, "mse", JS_NewFloat64(c, mse_a*100));
+		JS_SetPropertyUint32(c, ar, 3, v);
+	}
+	return ar;
+}
 
 static const JSCFunctionListEntry texture_funcs =
 {
@@ -6284,6 +6470,7 @@
 	JS_CFUNC_DEF("set_named", 0, texture_set_named),
 	JS_CFUNC_DEF("set_pad_color", 0, texture_set_pad_color),
 	JS_CFUNC_DEF("get_pad_color", 0, texture_get_pad_color),
+	JS_CFUNC_DEF("diff_score", 0, texture_diff_score),
 };
 
 
@@ -7613,6 +7800,11 @@
 		JS_NewClassID(&va_class_id);
 		JS_NewClass(rt, va_class_id, &va_class);
 
+#ifdef GPAC_ENABLE_COVERAGE
+		if (gf_sys_is_cov_mode())
+			va_gc_mark(NULL, JS_NULL, NULL);
+#endif
+
 #ifdef EVG_USE_JS_SHADER
 		JS_NewClassID(&fragment_class_id);
 		JS_NewClass(rt, fragment_class_id, &fragment_class);

gpac-2.0.0.tar.gz/src/jsmods/scene_js.c -> gpac-2.2.0.tar.gz/src/jsmods/scene_js.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2007-2020
+ *			Copyright (c) Telecom ParisTech 2007-2022
 *			All rights reserved
 *
 * This file is part of GPAC / JavaScript Compositor extensions
@@ -37,7 +37,6 @@
 
 #include <gpac/download.h>
 #include <gpac/network.h>
-#include <gpac/options.h>
 #include <gpac/xml.h>
 
 
@@ -46,7 +45,6 @@
 #include "../scenegraph/qjs_common.h"
 
 #include <gpac/internal/compositor_dev.h>
-#include <gpac/term_info.h>
 
 typedef struct
 {
@@ -149,6 +147,7 @@
 	GJS_SCENE_PROP_HAS_OPENGL,
 	GJS_SCENE_PROP_ZOOM,
 	GJS_SCENE_PROP_TEXT_SEL,
+	GJS_SCENE_PROP_DISP_ORIENTATION,
 
 };
 
@@ -259,7 +258,6 @@
 			return JS_NewInt32(ctx, compositor->osize.y);
 		return JS_NewInt32(ctx, compositor->video_out->max_screen_height);
 
-
 	case GJS_SCENE_PROP_FPS:
 		return JS_NewFloat64(ctx, gf_sc_get_fps(compositor, 0) );
 
@@ -278,6 +276,9 @@
 	case GJS_SCENE_PROP_SENSORS_ACTIVE:
 		return JS_NewBool(ctx, compositor->orientation_sensors_active);
 
+	case GJS_SCENE_PROP_FOCUS_HIGHLIGHT:
+		return JS_NewBool(ctx, !compositor->disable_focus_highlight);
+
 	case GJS_SCENE_PROP_ZOOM:
 		if (compositor->root_scene && compositor->root_scene->graph->script_action) {
 			GF_JSAPIParam jspar;
@@ -297,6 +298,10 @@
 		str = (char *) gf_sc_get_selected_text(compositor);
 		if (!str) str = "";
 		return JS_NewString(ctx, str);
+
+
+	case GJS_SCENE_PROP_DISP_ORIENTATION:
+		return JS_NewInt32(ctx, compositor->disp_ori);
 	}
 	return JS_UNDEFINED;
 }
@@ -355,7 +360,7 @@
 		gf_sc_set_option(compositor, GF_OPT_NAVIGATION_TYPE, 0);
 		break;
 	case GJS_SCENE_PROP_FOCUS_HIGHLIGHT:
-		compositor->disable_focus_highlight = JS_ToBool(ctx, value);
+		compositor->disable_focus_highlight = !JS_ToBool(ctx, value);
 		break;
 	case GJS_SCENE_PROP_SENSORS_ACTIVE:
 	{
@@ -371,6 +376,16 @@
 		}
 	}
 		break;
+	case GJS_SCENE_PROP_DISP_ORIENTATION:
+		if (JS_ToInt32(ctx, &ival, value)) return GF_JS_EXCEPTION(ctx);
+		if (compositor->video_out && compositor->video_out->ProcessEvent) {
+			GF_Event evt;
+			memset(&evt, 0, sizeof(GF_Event));
+			evt.size.type = GF_EVENT_SET_ORIENTATION;
+			evt.size.orientation = ival;
+			compositor->video_out->ProcessEvent(compositor->video_out, &evt);
+		}
+		break;
 	}
 	return JS_UNDEFINED;
 }
@@ -395,7 +410,7 @@
 		key_name = JS_ToCString(ctx, argv1);
 	}
 
-	if (sec_name && !stricmp(sec_name, "General") && key_name && !strcmp(key_name, "Version")) {
+	if (sec_name && !stricmp(sec_name, "core") && key_name && !strcmp(key_name, "version")) {
 		opt = gf_gpac_version();
 	} else if (sec_name && key_name) {
 		if (!strcmp(sec_name, "Compositor")) {
@@ -697,7 +712,11 @@
 	case GJS_OM_PROP_TYPE:
 		if (odm->type==GF_STREAM_SCENE) str = "Scene";
 		else if (odm->type==GF_STREAM_OD) str = "OD";
-		else if (odm->type==GF_STREAM_VISUAL) str = "Video";
+		else if (odm->type==GF_STREAM_VISUAL) {
+			//handle all sparse video as text (we could check the original stream type)
+			if (odm->flags & GF_ODM_IS_SPARSE) str = "Text";
+			else str = "Video";
+		}
 		else if (odm->type==GF_STREAM_AUDIO) str = "Audio";
 		else if (odm->type==GF_STREAM_TEXT) str = "Text";
 		else if (odm->subscene) str = "Subscene";
@@ -709,7 +728,9 @@
 		return JS_NewInt32(ctx, odm->mo ? odm->mo->num_channels : 0);
 	case GJS_OM_PROP_LANG:
 		gf_odm_get_object_info(odm, &odi);
-		return JS_NewString(ctx, odi.lang_code ? odi.lang_code : gf_4cc_to_str(odi.lang) );
+		if (odi.lang_code) return JS_NewString(ctx, odi.lang_code);
+		else if (odi.lang) return JS_NewString(ctx, gf_4cc_to_str(odi.lang) );
+		return JS_NewString(ctx, "und");
 	case GJS_OM_PROP_WIDTH:
 		return JS_NewInt32(ctx, odm->mo ? odm->mo->width : 0);
 	case GJS_OM_PROP_HEIGHT:
@@ -857,8 +878,8 @@
 		} else if (scene->main_addon_selected) {
 			GF_Clock *ck = scene->root_od->ck;
 			if (ck) {
-				u32 now = gf_clock_time(ck) ;
-				u32 live = scene->obj_clock_at_main_activation + gf_sys_clock() - scene->sys_clock_at_main_activation;
+				u64 now = gf_clock_time_absolute(ck) ;
+				u64 live = scene->obj_clock_at_main_activation + gf_sys_clock() - scene->sys_clock_at_main_activation;
 				dval = ((Double) live) / 1000.0;
 				dval -= ((Double) now) / 1000.0;
 
@@ -953,7 +974,7 @@
 			GF_ObjectManager *an_odm = gf_list_get(scene->resources, i);
 			if (an_odm && an_odm->addon && (an_odm->addon->addon_type==GF_ADDON_TYPE_MAIN)) {
 				if (an_odm->duration) {
-					Double now = gf_clock_time(scene->root_od->ck) / 1000.0;
+					Double now = gf_clock_time_absolute(scene->root_od->ck) / 1000.0;
 					now -= ((Double) an_odm->addon->media_pts) / 90000.0;
 					now += ((Double) an_odm->addon->media_timestamp) / an_odm->addon->media_timescale;
 					return JS_NewFloat64(ctx, now);
@@ -1361,6 +1382,33 @@
 	return JS_UNDEFINED;
 }
 
+static JSValue gjs_odm_get_chapters(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+	GF_ObjectManager *odm = JS_GetOpaque(this_val, odm_class_id);
+	if (!odm) return GF_JS_EXCEPTION(ctx);
+
+	if (odm->subscene) odm = gf_list_get(odm->subscene->resources, 0);
+	if (!odm || ! odm->pid) return JS_NULL;
+
+	const GF_PropertyValue *times = gf_filter_pid_get_property(odm->pid, GF_PROP_PID_CHAP_TIMES);
+	const GF_PropertyValue *names = gf_filter_pid_get_property(odm->pid, GF_PROP_PID_CHAP_NAMES);
+	if (!times || !names || (times->value.uint_list.nb_items!=times->value.string_list.nb_items))
+		return JS_NULL;
+
+	JSValue ret = JS_NewArray(ctx);
+	u32 i, count=times->value.uint_list.nb_items;
+	for (i=0; i<count; i++) {
+		char *name;
+		JSValue obj = JS_NewObject(ctx);
+		JS_SetPropertyStr(ctx, obj, "start", JS_NewInt32(ctx, times->value.uint_list.valsi));
+		name = names->value.string_list.valsi;
+		if (!name) name = "";
+		JS_SetPropertyStr(ctx, obj, "name", JS_NewString(ctx, name));
+		JS_SetPropertyUint32(ctx, ret, i, obj);
+	}
+	return ret;
+}
+
 static JSValue scenejs_get_object_manager(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
 {
 	JSValue anobj;
@@ -1395,6 +1443,15 @@
 				if (!strncmp(an_url, "file://", 7)) an_url = an_url + 7;
 				if (!strncmp(an_url, url, url_len))
 					break;
+
+				if (strstr(an_url, "://")) {
+					char *pc_url = gf_url_percent_encode(an_url);
+					if (!strncmp(pc_url, url, url_len)) {
+						gf_free(pc_url);
+						break;
+					}
+					gf_free(pc_url);
+				}
 			}
 			odm = NULL;
 		}
@@ -1687,6 +1744,7 @@
 	JS_CGETSET_MAGIC_DEF("sensors_active", scenejs_getProperty, scenejs_setProperty, GJS_SCENE_PROP_SENSORS_ACTIVE),
 	JS_CGETSET_MAGIC_DEF("zoom", scenejs_getProperty, NULL, GJS_SCENE_PROP_ZOOM),
 	JS_CGETSET_MAGIC_DEF("text_selection", scenejs_getProperty, NULL, GJS_SCENE_PROP_TEXT_SEL),
+	JS_CGETSET_MAGIC_DEF("orientation", scenejs_getProperty, scenejs_setProperty, GJS_SCENE_PROP_DISP_ORIENTATION),
 	JS_CFUNC_DEF("get_option", 0, scenejs_get_option),
 	JS_CFUNC_DEF("set_option", 0, scenejs_set_option),
 	JS_CFUNC_DEF("set_size", 0, scenejs_set_size),
@@ -1772,6 +1830,7 @@
 	JS_CFUNC_DEF("select", 0, gjs_odm_select),
 	JS_CFUNC_DEF("get_srd", 0, gjs_odm_get_srd),
 	JS_CFUNC_DEF("in_parent_chain", 0, gjs_odm_in_parent_chain),
+	JS_CFUNC_DEF("get_chapters", 0, gjs_odm_get_chapters),
 };
 
 #include "../filter_core/filter_session.h"

gpac-2.0.0.tar.gz/src/jsmods/webgl.c -> gpac-2.2.0.tar.gz/src/jsmods/webgl.c Changed

@@ -278,6 +278,19 @@
 	res = JS_GetArrayBuffer(ctx, &psize, v);
 	JS_FreeValue(ctx, v);
 	*size = (u32) psize;
+
+	v = JS_GetPropertyStr(ctx, obj, "byteOffset");
+	if (!JS_IsUndefined(v)) {
+		u64 offset;
+		JS_ToInt64(ctx, &offset, v);
+		JS_FreeValue(ctx, v);
+		v = JS_GetPropertyStr(ctx, obj, "byteLength");
+		JS_ToInt32(ctx, size, v);
+		JS_FreeValue(ctx, v);
+		res += offset;
+		return res;
+	}
+
 	return res;
 }
 
@@ -1865,7 +1878,7 @@
 
 	if (glc->fetch_required_pfmt) {
 		u32 i, hy;
-		jsf_set_gl_active(glc->ctx);
+		jsf_set_gl_active(glc->ctx, GF_TRUE);
 
 		if (glc->creation_attrs.primary) {
 			glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -1913,6 +1926,7 @@
 			memcpy(glc->pix_data + i * glc->pix_stride, glc->pix_data + (glc->height - 1 - i) * glc->pix_stride, glc->pix_stride);
 			memcpy(glc->pix_data + (glc->height - 1 - i) * glc->pix_stride, glc->pix_line, glc->pix_stride);
 		}
+		jsf_set_gl_active(glc->ctx, GF_FALSE);
 	}
 
 	*outPlane = glc->pix_data;
@@ -2150,13 +2164,21 @@
 	return JS_NewString(ctx, named_tx->tx_name);
 }
 
+Bool wgl_texture_get_id(JSContext *ctx, JSValueConst txval, u32 *tx_id)
+{
+	GF_WebGLObject *tx = tx = JS_GetOpaque(txval, WebGLTexture_class_id);
+	if (!tx || !tx->gl_id) return GF_FALSE;
+	*tx_id = tx->gl_id;
+	return GF_TRUE;
+}
+
 static JSValue wgl_activate_gl(JSContext *ctx, GF_WebGLContext *glc, Bool activate)
 {
 	if (activate) {
 		u32 i, count;
 		//clear error
 		glGetError();
-		jsf_set_gl_active(ctx);
+		jsf_set_gl_active(ctx, GF_TRUE);
 
 		if (glc->creation_attrs.primary) {
 			glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -2205,6 +2227,8 @@
 		glDisable(GL_TEXTURE_2D);
 		//clear error
 		glGetError();
+
+		jsf_set_gl_active(ctx, GF_FALSE);
 	}
 	return JS_UNDEFINED;
 }

gpac-2.0.0.tar.gz/src/jsmods/xhr.c -> gpac-2.2.0.tar.gz/src/jsmods/xhr.c Changed

gpac-2.0.0.tar.gz/src/laser/lsr_dec.c -> gpac-2.2.0.tar.gz/src/laser/lsr_dec.c Changed

@@ -300,11 +300,21 @@
 
 static void lsr_read_extend_class(GF_LASeRCodec *lsr, char **out_data, u32 *out_len, const char *name)
 {
-	u32 len;
+	u32 len, blen;
 	GF_LSR_READ_INT(lsr, len, lsr->info->cfg.extensionIDBits, "reserved");
 	len = lsr_read_vluimsbf5(lsr, "len");
-//	while (len) gf_bs_read_int(lsr->bs, 1);
-	gf_bs_read_long_int(lsr->bs, len);
+	while (len && !gf_bs_is_align(lsr->bs)) {
+		gf_bs_read_int(lsr->bs, len);
+		len--;
+	}
+	blen = len / 8;
+	gf_bs_skip_bytes(lsr->bs, blen);
+	len -= blen*8;
+
+	while (len) {
+		gf_bs_read_int(lsr->bs, 1);
+		len--;
+	}
 	if (out_data) *out_data = NULL;
 	if (out_len) *out_len = 0;
 }
@@ -810,7 +820,11 @@
 			if (gf_node_get_attribute_by_tag(listener, TAG_XMLEV_ATT_event, GF_FALSE, GF_FALSE, &info) == GF_OK) {
 				XMLEV_Event *ev = (XMLEV_Event *)info.far_ptr;
 				/*all non-UI get attched to root*/
-				if (ev && (ev->type>GF_EVENT_MOUSEWHEEL)) {
+				if (ev
+					&& (ev->type > GF_EVENT_MOUSEWHEEL)
+					&& (ev->type!=GF_EVENT_MOUSEOUT)
+					&& (ev->type!=GF_EVENT_MOUSEOVER)
+				) {
 					par = (GF_Node*) lsr->current_root;
 				}
 			}
@@ -838,9 +852,16 @@
 
 static Fixed lsr_translate_coords(GF_LASeRCodec *lsr, u32 val, u32 nb_bits)
 {
+	if (!nb_bits) return 0;
+	if (nb_bits>=32) return 0;
+
 #ifdef GPAC_FIXED_POINT
 	if (val >> (nb_bits-1) ) {
-		s32 neg = (s32) val - (1<<nb_bits);
+		s32 neg;
+		if (nb_bits == 31)
+			neg = (s32)val - 0x80000000;
+		else
+			neg = (s32)val - (1 << nb_bits);
 		if (neg < -FIX_ONE / 2)
 			return 2 * gf_divfix(INT2FIX(neg/2), lsr->res_factor);
 		return gf_divfix(INT2FIX(neg), lsr->res_factor);
@@ -851,10 +872,14 @@
 	}
 #else
 	if (val >> (nb_bits-1) ) {
-		s32 neg = (s32) val - (1<<nb_bits);
-		return gf_divfix(INT2FIX(neg), lsr->res_factor);
+		s32 neg;
+		if (nb_bits == 31)
+			neg = (s32)val - 0x80000000;
+		else
+			neg = (s32)val - (1 << nb_bits);
+		return ((Fixed)neg) / lsr->res_factor;
 	} else {
-		return gf_divfix(INT2FIX(val), lsr->res_factor);
+		return ((Fixed)val) / lsr->res_factor;
 	}
 #endif
 }
@@ -862,8 +887,12 @@
 static Fixed lsr_translate_scale(GF_LASeRCodec *lsr, u32 val)
 {
 	if (val >> (lsr->coord_bits-1) ) {
-		s32 v = val - (1<<lsr->coord_bits);
-		return INT2FIX(v) / 256 ;
+		s32 neg;
+		if (lsr->coord_bits >= 31)
+			neg = (s32)val - 0x80000000;
+		else
+			neg = (s32)val - (1 << lsr->coord_bits);
+		return INT2FIX(neg) / 256 ;
 	} else {
 		return INT2FIX(val) / 256;
 	}
@@ -2746,7 +2775,7 @@
 				gf_list_insert(val->values, f, i);
 			break;
 		case SVG_TRANSFORM_SCALE:
-			pt = (SVG_Point*)gf_malloc(sizeof(SVG_Point));
+			GF_SAFEALLOC(pt, SVG_Point);
 			if (!pt)
 				lsr->last_error = GF_OUT_OF_MEM;
 
@@ -4418,7 +4447,10 @@
 		/*FIXME - double check with XML events*/
 		if (!par && !observer) {
 			/*all non-UI get attched to root*/
-			if (ev && (ev->type>GF_EVENT_MOUSEWHEEL)) {
+			if (ev && (ev->type > GF_EVENT_MOUSEWHEEL)
+				&& (ev->type!=GF_EVENT_MOUSEOUT)
+				&& (ev->type!=GF_EVENT_MOUSEOVER)
+			) {
 				par = (SVG_Element*) lsr->current_root;
 			}
 			else if (parent) par = parent;

gpac-2.0.0.tar.gz/src/laser/lsr_enc.c -> gpac-2.2.0.tar.gz/src/laser/lsr_enc.c Changed

gpac-2.0.0.tar.gz/src/media_tools/av_parsers.c -> gpac-2.2.0.tar.gz/src/media_tools/av_parsers.c Changed

@@ -33,7 +33,7 @@
 #include <gpac/internal/ogg.h>
 #endif
 
-//uncomment/define globally to remove all bitstream parsing logging from code (this will break inspect mode ananlyze=bs)
+//uncomment/define globally to remove all bitstream parsing logging from code (this will break inspect mode analyze=bs)
 //#define GPAC_DISABLE_AVPARSE_LOGS
 
 #ifndef GPAC_DISABLE_AVPARSE_LOGS
@@ -677,7 +677,7 @@
 
 			/*val = */gf_bs_read_u8(m4v->bs);
 			val = gf_bs_read_u8(m4v->bs);
-			*frame_type = ((val >> 3) & 0x7) - 1;
+			*frame_type = ((val >> 3) & 0x7);
 			break;
 		case M2V_GOP_START_CODE:
 			if (firstObj) {
@@ -750,7 +750,7 @@
 			hasVOP = 1;
 
 			/*coding type*/
-			*frame_type = gf_bs_read_int(m4v->bs, 2);
+			*frame_type = 1 + gf_bs_read_int(m4v->bs, 2);
 			/*modulo time base*/
 			secs = 0;
 			while (gf_bs_read_int(m4v->bs, 1) != 0)
@@ -1985,9 +1985,9 @@
 	CS_RGB = 7,
 } VP9_color_space;
 
-static const int VP9_CS_to_23001_8_colour_primaries = { -1/*undefined*/, 5, 1, 6, 7, 9, -1/*reserved*/, 1 };
-static const int VP9_CS_to_23001_8_transfer_characteristics = { -1/*undefined*/, 5, 1, 6, 7, 9, -1/*reserved*/, 13 };
-static const int VP9_CS_to_23001_8_matrix_coefficients = { -1/*undefined*/, 6, 1, -1, -1, 9, -1/*reserved*/, 0 };
+static const int VP9_CS_to_23001_8_colour_primaries = { 2/*unspecified*/, 5, 1, 6, 7, 9, -1/*reserved*/, 1 };
+static const int VP9_CS_to_23001_8_transfer_characteristics = { 2/*unspecified*/, 5, 1, 6, 7, 9, -1/*reserved*/, 13 };
+static const int VP9_CS_to_23001_8_matrix_coefficients = { 2/*unspecified*/, 6, 1, -1, -1, 9, -1/*reserved*/, 0 };
 
 static GF_Err vp9_color_config(GF_BitStream *bs, GF_VPConfig *vp9_cfg)
 {
@@ -4040,7 +4040,7 @@
 static GF_Err av1_parse_tile_group(GF_BitStream *bs, AV1State *state, u64 obu_start, u64 obu_size)
 {
 	u32 TileNum, tg_start = 0, tg_end = 0;
-	Bool numTiles = state->tileCols * state->tileRows;
+	u32 numTiles = state->tileCols * state->tileRows;
 	Bool tile_start_and_end_present_flag = GF_FALSE;
 	GF_Err e = GF_OK;
 	if (numTiles > 1)
@@ -4126,7 +4126,10 @@
 {
 	av1_parse_frame_header(bs, state);
 	//byte alignment
-	gf_bs_align(bs);
+ {
+ u32 nbBits = gf_bs_align(bs);
+ gf_bs_log_idx(bs, nbBits, "alignment", 0, -1, -1, -1);
+ }
 	return av1_parse_tile_group(bs, state, obu_start, obu_size);
 }
 
@@ -4819,78 +4822,6 @@
 	gf_bs_write_ue(bs, v);
 }
 
-u32 gf_media_nalu_is_start_code(GF_BitStream *bs)
-{
-	u8 s1, s2, s3, s4;
-	Bool is_sc = 0;
-	u64 pos = gf_bs_get_position(bs);
-	s1 = gf_bs_read_int(bs, 8);
-	s2 = gf_bs_read_int(bs, 8);
-	if (!s1 && !s2) {
-		s3 = gf_bs_read_int(bs, 8);
-		if (s3 == 0x01) is_sc = 3;
-		else if (!s3) {
-			s4 = gf_bs_read_int(bs, 8);
-			if (s4 == 0x01) is_sc = 4;
-		}
-	}
-	gf_bs_seek(bs, pos + is_sc);
-	return is_sc;
-}
-
-/*read that amount of data at each IO access rather than fetching byte by byte...*/
-#define AVC_CACHE_SIZE	4096
-
-static u32 gf_media_nalu_locate_start_code_bs(GF_BitStream *bs, Bool locate_trailing)
-{
-	u32 v, bpos, nb_cons_zeros = 0;
-	char avc_cacheAVC_CACHE_SIZE;
-	u64 end, cache_start, load_size;
-	u64 start = gf_bs_get_position(bs);
-	if (start < 3) return 0;
-
-	load_size = 0;
-	bpos = 0;
-	cache_start = 0;
-	end = 0;
-	v = 0xffffffff;
-	while (!end) {
-		/*refill cache*/
-		if (bpos == (u32)load_size) {
-			if (!gf_bs_available(bs)) break;
-			load_size = gf_bs_available(bs);
-			if (load_size > AVC_CACHE_SIZE) load_size = AVC_CACHE_SIZE;
-			bpos = 0;
-			cache_start = gf_bs_get_position(bs);
-			gf_bs_read_data(bs, avc_cache, (u32)load_size);
-		}
-		v = ( (v<<8) & 0xFFFFFF00) | ((u32) avc_cachebpos);
-		bpos++;
-
-		if (locate_trailing) {
-			if ((v & 0x000000FF) == 0) nb_cons_zeros++;
-			else nb_cons_zeros = 0;
-		}
-
-		if (v == 0x00000001) end = cache_start + bpos - 4;
-		else if ((v & 0x00FFFFFF) == 0x00000001) end = cache_start + bpos - 3;
-	}
-
-	gf_bs_seek(bs, start);
-	if (!end) end = gf_bs_get_size(bs);
-	if (locate_trailing) {
-		if (nb_cons_zeros >= 3)
-			return (u32)(end - start - nb_cons_zeros);
-	}
-	return (u32)(end - start);
-}
-
-GF_EXPORT
-u32 gf_media_nalu_next_start_code_bs(GF_BitStream *bs)
-{
-	return gf_media_nalu_locate_start_code_bs(bs, 0);
-}
-
 GF_EXPORT
 u32 gf_media_nalu_next_start_code(const u8 *data, u32 data_len, u32 *sc_size)
 {
@@ -5232,7 +5163,17 @@
 	sps->level_idc = level_idc;
 	sps->prof_compat = pcomp;
 	sps->log2_max_frame_num = gf_bs_read_ue_log(bs, "log2_max_frame_num") + 4;
+	if (sps->log2_max_frame_num>16) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("avc-h264 invalid SPS: log2_max_frame_num_minus4 shall be less than 12, but is %d\n", sps->log2_max_frame_num-4));
+		sps->log2_max_frame_num=0;
+		return -1;
+	}
 	sps->poc_type = gf_bs_read_ue_log(bs, "poc_type");
+	if (sps->poc_type>2) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("avc-h264 invalid SPS: pic_order_cnt_type shall be less than 2, but is %d\n", sps->poc_type));
+		sps->log2_max_frame_num=0;
+		return -1;
+	}
 	sps->chroma_format = chroma_format_idc;
 	sps->luma_bit_depth_m8 = luma_bd;
 	sps->chroma_bit_depth_m8 = chroma_bd;
@@ -5343,6 +5284,9 @@
 		sps->vui.colour_primaries = 2;
 		sps->vui.transfer_characteristics = 2;
 		sps->vui.matrix_coefficients = 2;
+		//When the chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are not present, the values of chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field shall be inferred to be equal to 0.
+		sps->vui.chroma_sample_loc_type_top_field = sps->vui.chroma_sample_loc_type_bottom_field = 0;
+
 		/* now read values if possible */
 		sps->vui.video_signal_type_present_flag = gf_bs_read_int_log(bs, 1, "video_signal_type_present_flag");
 		if (sps->vui.video_signal_type_present_flag) {
@@ -5356,9 +5300,10 @@
 			}
 		}
 
-		if (gf_bs_read_int_log(bs, 1, "chroma_location_info_present_flag")) {
-			gf_bs_read_ue_log(bs, "chroma_sample_location_type_top_field");
-			gf_bs_read_ue_log(bs, "chroma_sample_location_type_bottom_field");
+		sps->vui.chroma_location_info_present_flag = gf_bs_read_int_log(bs, 1, "chroma_location_info_present_flag");
+		if (sps->vui.chroma_location_info_present_flag) {
+			sps->vui.chroma_sample_loc_type_top_field = gf_bs_read_ue_log(bs, "chroma_sample_location_type_top_field");
+			sps->vui.chroma_sample_loc_type_bottom_field = gf_bs_read_ue_log(bs, "chroma_sample_location_type_bottom_field");
 		}
 
 		sps->vui.timing_info_present_flag = gf_bs_read_int_log(bs, 1, "timing_info_present_flag");
@@ -5450,6 +5395,8 @@
 			return sps_id;
 		}
 	}
+	if (gf_bs_is_overflow(bs))
+		return -1;
 	return sps_id;
 }
 
@@ -5567,6 +5514,8 @@
 	gf_bs_read_int_log(bs, 1, "constrained_intra_pred");
 	pps->redundant_pic_cnt_present = gf_bs_read_int_log(bs, 1, "redundant_pic_cnt_present");
 
+	if (gf_bs_is_overflow(bs))
+		return -1;
 	return pps_id;
 }
 
@@ -6210,6 +6159,7 @@
 		avc->last_ps_idx = gf_avc_read_sps_bs_internal(bs, avc, 0, NULL, nal_hdr);
 		if (gf_bs_is_overflow(bs)) return -1;
 		if (avc->last_ps_idx < 0) return -1;
+		avc->last_sps_idx = avc->last_ps_idx;
 		return 0;
 
 	case GF_AVC_NALU_PIC_PARAM:
@@ -6385,7 +6335,10 @@
 		if (gf_bs_available(bs) <= 2) {
 			var = gf_bs_read_int(bs, 8);
 			if (var != 0x80) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("avc-h264 SEI user message has less than 2 bytes remaining but no end of sei found\n"));
+				GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("avc-h264 SEI user message has less than 2 bytes remaining but no end of sei found, keeping full SEI untouched\n"));
+				if (bs_dest) gf_bs_del(bs_dest);
+				gf_bs_del(bs);
+				return nal_size;
 			}
 			if (bs_dest) gf_bs_write_int(bs_dest, 0x80, 8);
 			break;
@@ -6411,7 +6364,6 @@
 	return nal_size;
 }
 
-
 static u8 avc_hevc_get_sar_idx(u32 w, u32 h)
 {
 	u32 i, count = GF_ARRAY_LENGTH(avc_hevc_sar);
@@ -6422,7 +6374,7 @@
 	return 0xFF;
 }
 
-static void avc_hevc_vvc_rewrite_vui(GF_VUIInfo *vui_info, GF_BitStream *orig, GF_BitStream *mod, Bool is_vvc)
+static void avc_hevc_vvc_rewrite_vui(GF_VUIInfo *vui_info, GF_BitStream *orig, GF_BitStream *mod, GF_CodecID codec)
 {
 	/* VUI present flag*/
 	Bool vui_present_flag = gf_bs_read_int(orig, 1);
@@ -6432,14 +6384,32 @@
 	s32 aspect_ratio_idc = -1;
 	u32 ar_n=0, ar_d=0;
 	Bool overscan_info_present_flag = 0;
-	u32 overscan_info=0;
-	u32 video_signal_type_present_flag=0;
+	u32 overscan_info = 0;
+	u32 video_signal_type_present_flag = 0;
 	u32 video_format = 5;
 	u32 video_full_range_flag = 0;
 	u32 colour_description_present_flag = 0;
 	u32 colour_primaries = 2;
 	u32 transfer_characteristics = 2;
 	u32 matrix_coefficients = 2;
+	//HEVC
+	Bool neutral_chroma_indication_flag = GF_FALSE;
+	Bool field_seq_flag = GF_FALSE;
+	Bool frame_field_info_present_flag = GF_FALSE;
+	Bool default_display_window_flag = GF_FALSE;
+	u32 def_disp_win_left_offset = 0;
+	u32 def_disp_win_right_offset = 0;
+	u32 def_disp_win_top_offset = 0;
+	u32 def_disp_win_bottom_offset = 0;
+	//AVC & HEVC
+	Bool timing_info_present_flag = GF_FALSE;
+	u32 num_units_in_tick = 0;
+	u32 time_scale = 0;
+	//AVC
+	Bool fixed_frame_rate_flag=GF_FALSE;
+	//HEVC
+	Bool poc_proportional_to_timing_flag = GF_FALSE;
+	u32 vui_num_ticks_poc_diff_one_minus1 = 0;
 	//VVC
 	Bool progressive_source_flag = 1;
 	Bool interlaced_source_flag = 0;
@@ -6448,14 +6418,14 @@
 	Bool aspect_ratio_constant_flag = 1;
 	u32 vui_start_pos = 0;
 	u32 orig_vvc_payload_size = 0;
-	Bool vui_chroma_loc_info_present_flag=0;
-	u32 chroma_loc1=0, chroma_loc2=0;
+	Bool vui_chroma_loc_info_present_flag = 0;
+	u32 chroma_loc1=0, chroma_loc2 = 0;
 	u32 final_vvc_payload_size = 8; //4 first bits + 4 flags (ar, overscan and colour desc, chroma pos)
 	u32 mod_vui_start_pos = 0;
 
 	//if VUI is present, read all SAR and overscan values
 	if (vui_present_flag) { /* VUI found in input bitstream */
-		if (is_vvc) {
+		if (codec == GF_CODECID_VVC) {
 			//align
 			orig_vvc_payload_size = 8 * ( 1 + gf_bs_read_ue(orig) );
 			gf_bs_align(orig);
@@ -6469,7 +6439,7 @@
 		aspect_ratio_info_present_flag = gf_bs_read_int(orig, 1);
 
 		if (aspect_ratio_info_present_flag) {
-			if (is_vvc) {
+			if (codec == GF_CODECID_VVC) {
 				aspect_ratio_constant_flag = gf_bs_read_int(orig, 1);
 			}
 			aspect_ratio_idc = gf_bs_read_int(orig, 8); /*aspect_ratio_idc*/
@@ -6489,7 +6459,7 @@
 		video_signal_type_present_flag = gf_bs_read_int(orig, 1);
 
 		if (video_signal_type_present_flag) {
-			if (!is_vvc) {
+			if (codec != GF_CODECID_VVC) {
 				video_format = gf_bs_read_int(orig, 3);
 				video_full_range_flag = gf_bs_read_int(orig, 1);
 				colour_description_present_flag = gf_bs_read_int(orig, 1);
@@ -6501,12 +6471,13 @@
 				colour_primaries = gf_bs_read_int(orig, 8);
 				transfer_characteristics = gf_bs_read_int(orig, 8);
 				matrix_coefficients = gf_bs_read_int(orig, 8);
-				if (is_vvc) {
+				if (codec == GF_CODECID_VVC) {
 					video_full_range_flag = gf_bs_read_int(orig, 1);
 				}
 			}
 		}
-		if (is_vvc) {
+
+		if (codec == GF_CODECID_VVC) {
 			vui_chroma_loc_info_present_flag = gf_bs_read_int(orig, 1);
 			if (vui_chroma_loc_info_present_flag) {
 				if (progressive_source_flag && !interlaced_source_flag) {
@@ -6516,8 +6487,44 @@
 					chroma_loc2 = gf_bs_read_ue(orig);
 				}
 			}
+			//LAST bit read for VVC
+		} else { //AVC, HEVC
+			vui_chroma_loc_info_present_flag = gf_bs_read_int(orig, 1);
+			if (vui_chroma_loc_info_present_flag) {
+				chroma_loc1 = gf_bs_read_ue(orig); //chroma_sample_loc_type_top_field
+				chroma_loc2 = gf_bs_read_ue(orig); //chroma_sample_loc_type_bottom_field
+			}
+
+			if (codec == GF_CODECID_HEVC) {
+				neutral_chroma_indication_flag = gf_bs_read_int(orig, 1);
+				field_seq_flag = gf_bs_read_int(orig, 1);
+				frame_field_info_present_flag = gf_bs_read_int(orig, 1);
+				default_display_window_flag = gf_bs_read_int(orig, 1);
+				if (default_display_window_flag) {
+					def_disp_win_left_offset = gf_bs_read_ue(orig);
+					def_disp_win_right_offset = gf_bs_read_ue(orig);
+					def_disp_win_top_offset = gf_bs_read_ue(orig);
+					def_disp_win_bottom_offset = gf_bs_read_ue(orig);
+				}
+			}
+
+			timing_info_present_flag = gf_bs_read_int(orig, 1);
+			if (timing_info_present_flag) {
+				num_units_in_tick = gf_bs_read_int(orig, 32);
+				time_scale = gf_bs_read_int(orig, 32);
+				if (codec == GF_CODECID_AVC) {
+					fixed_frame_rate_flag = gf_bs_read_int(orig, 1);
+
+					//LAST bit read for AVC
+				} else if (codec == GF_CODECID_HEVC) {
+					poc_proportional_to_timing_flag = gf_bs_read_int(orig, 1);
+					if (poc_proportional_to_timing_flag)
+						/*vui_num_ticks_poc_diff_one_minus1 = */gf_bs_read_ue(orig);
+
+					//LAST bit read for HEVC
+				}
+			}
 		}
-		//not VVC: don't read the rest
 	}
 
 	//recompute values
@@ -6538,7 +6545,7 @@
 		ar_n = vui_info->ar_num;
 		ar_d = vui_info->ar_den;
 		aspect_ratio_idc = avc_hevc_get_sar_idx((u32) ar_n, (u32) ar_d);
-		if (is_vvc) {
+		if (codec == GF_CODECID_VVC) {
 			final_vvc_payload_size += 9;
 			if (aspect_ratio_idc==0xFF)
 				final_vvc_payload_size += 32;
@@ -6569,7 +6576,7 @@
 				video_signal_type_present_flag = 0;
 		}
 
-		if (is_vvc) {
+		if (codec == GF_CODECID_VVC) {
 			if (!video_full_range_flag && !colour_description_present_flag) {
 				video_signal_type_present_flag = 0;
 			} else {
@@ -6578,7 +6585,7 @@
 		}
 	}
 
-	if (is_vvc && vui_chroma_loc_info_present_flag) {
+	if ((codec == GF_CODECID_VVC) && vui_chroma_loc_info_present_flag) {
 		if (progressive_source_flag && !interlaced_source_flag) {
 			final_vvc_payload_size += gf_get_ue_nb_bits(chroma_loc1);
 		} else {
@@ -6586,10 +6593,13 @@
 			final_vvc_payload_size += gf_get_ue_nb_bits(chroma_loc2);
 		}
 	}
+	//remove VUI timing
+	if (vui_info->remove_vui_timing_info)
+		timing_info_present_flag = 0;
 
 	//always rewrite VUI
 	gf_bs_write_int(mod, 1, 1);
-	if (is_vvc) {
+	if (codec == GF_CODECID_VVC) {
 		while (final_vvc_payload_size%8)
 			final_vvc_payload_size++;
 		final_vvc_payload_size/=8;
@@ -6607,7 +6617,7 @@
 
 	gf_bs_write_int(mod, aspect_ratio_info_present_flag, 1);
 	if (aspect_ratio_info_present_flag) {
-		if (is_vvc)
+		if (codec == GF_CODECID_VVC)
 			gf_bs_write_int(mod, aspect_ratio_constant_flag, 1);
 
 		gf_bs_write_int(mod, aspect_ratio_idc, 8);
@@ -6627,7 +6637,7 @@
 
 	gf_bs_write_int(mod, video_signal_type_present_flag, 1);
 	if (video_signal_type_present_flag) {
-		if (!is_vvc) {
+		if (codec != GF_CODECID_VVC) {
 			gf_bs_write_int(mod, video_format, 3);
 			gf_bs_write_int(mod, video_full_range_flag, 1);
 			gf_bs_write_int(mod, colour_description_present_flag, 1);
@@ -6639,7 +6649,7 @@
 			gf_bs_write_int(mod, colour_primaries, 8);
 			gf_bs_write_int(mod, transfer_characteristics, 8);
 			gf_bs_write_int(mod, matrix_coefficients, 8);
-			if (is_vvc)
+			if (codec == GF_CODECID_VVC)
 				gf_bs_write_int(mod, video_full_range_flag, 1);
 		}
 
@@ -6654,7 +6664,7 @@
 		}
 	}
 
-	if (is_vvc) {
+	if (codec == GF_CODECID_VVC) {
 		//write vui_chroma_loc_info_present_flag
 		gf_bs_write_int(mod, vui_chroma_loc_info_present_flag, 1);
 		if (vui_chroma_loc_info_present_flag) {
@@ -6706,19 +6716,58 @@
 			gf_bs_write_int(mod, 1, 1); //vui_payload_bit_equal_to_one
 			gf_bs_align(mod);
 		}
+		//VVC done
 		return;
 	}
 
+	//AVC and HEVC
+	gf_bs_write_int(mod, vui_chroma_loc_info_present_flag, 1);
+	if (vui_chroma_loc_info_present_flag) {
+		gf_bs_write_ue(mod, chroma_loc1); //chroma_sample_loc_type_top_field
+		gf_bs_write_ue(mod, chroma_loc2); //chroma_sample_loc_type_bottom_field
+	}
+
+	if (codec == GF_CODECID_HEVC) {
+		gf_bs_write_int(mod, neutral_chroma_indication_flag, 1);
+		gf_bs_write_int(mod, field_seq_flag, 1);
+		gf_bs_write_int(mod, frame_field_info_present_flag, 1);
+		gf_bs_write_int(mod, default_display_window_flag, 1);
+		if (default_display_window_flag) {
+			 gf_bs_write_ue(mod, def_disp_win_left_offset);
+			 gf_bs_write_ue(mod, def_disp_win_right_offset);
+			 gf_bs_write_ue(mod, def_disp_win_top_offset);
+			 gf_bs_write_ue(mod, def_disp_win_bottom_offset);
+		}
+	}
+
+	gf_bs_write_int(mod, timing_info_present_flag, 1);
+	if (timing_info_present_flag) {
+		gf_bs_write_int(mod, num_units_in_tick, 32);
+		gf_bs_write_int(mod, time_scale, 32);
+		if (codec == GF_CODECID_AVC) {
+			gf_bs_write_int(mod, fixed_frame_rate_flag, 1);
+		} else if (codec == GF_CODECID_HEVC) {
+			gf_bs_write_int(mod, poc_proportional_to_timing_flag, 1);
+			if (poc_proportional_to_timing_flag)
+				gf_bs_write_ue(mod, vui_num_ticks_poc_diff_one_minus1);
+		}
+	}
+
 	/*no VUI in input bitstream but we just inserted one, set all remaining vui flags to 0*/
 	if (!vui_present_flag) {
-		gf_bs_write_int(mod, 0, 1);		/*chroma_location_info_present_flag */
-		gf_bs_write_int(mod, 0, 1);		/*timing_info_present_flag*/
-		gf_bs_write_int(mod, 0, 1);		/*nal_hrd_parameters_present*/
-		gf_bs_write_int(mod, 0, 1);		/*vcl_hrd_parameters_present*/
-		gf_bs_write_int(mod, 0, 1);		/*pic_struct_present*/
-		gf_bs_write_int(mod, 0, 1);		/*bitstream_restriction*/
+		if (codec == GF_CODECID_AVC) {
+			gf_bs_write_int(mod, 0, 1);		/*nal_hrd_parameters_present*/
+			gf_bs_write_int(mod, 0, 1);		/*vcl_hrd_parameters_present*/
+			gf_bs_write_int(mod, 0, 1);		/*pic_struct_present*/
+			gf_bs_write_int(mod, 0, 1);		/*bitstream_restriction*/
+		} else if (codec == GF_CODECID_HEVC) {
+			if (timing_info_present_flag) {
+				gf_bs_write_int(mod, 0, 1);		/*vui_hrd_parameters_present_flag*/
+			}
+			gf_bs_write_int(mod, 0, 1);		/*bitstream_restriction*/
+		}
 	}
-	/*otherwise we copy over the bits from the input bitrate*/
+	/*otherwise we copy over the bits from the input bitstream*/
 }
 
 GF_Err gf_avc_change_vui(GF_AVCConfig *avcc, GF_VUIInfo *vui_info)
@@ -6761,7 +6810,7 @@
 			bit_offset--;
 		}
 
-		avc_hevc_vvc_rewrite_vui(vui_info, orig, mod, GF_FALSE);
+		avc_hevc_vvc_rewrite_vui(vui_info, orig, mod, GF_CODECID_AVC);
 
 		/*finally copy over remaining*/
 		while (gf_bs_bits_available(orig)) {
@@ -7303,7 +7352,8 @@
 
 static void gf_hevc_vvc_parse_sei(char *buffer, u32 nal_size, HEVCState *hevc, VVCState *vvc)
 {
-	u32 ptype, psize, hdr;
+	u32 ptype, psize, hdr, i;
+	u8 *dst_ptr;
 	u64 start;
 	GF_BitStream *bs;
 
@@ -7317,7 +7367,7 @@
 
 	/*parse SEI*/
 	while (gf_bs_available(bs)) {
-		u32 consumed;
+		u32 consumed, nb_zeros;
 		ptype = 0;
 		while (gf_bs_peek_bits(bs, 8, 0)==0xFF) {
 			gf_bs_read_int(bs, 8);
@@ -7337,40 +7387,54 @@
 			break;
 		}
 
+		nb_zeros = gf_bs_get_emulation_byte_removed(bs);
+
 		switch (ptype) {
 		case 4: /*user registered ITU-T T35*/
 			if (hevc) {
 				avc_parse_itu_t_t35_sei(bs, &hevc->sei.dovi);
 			}
 			break;
+		//clli
 		case 144:
-			//clli
+			dst_ptr = hevc ? hevc->clli_data : vvc->clli_data;
+			//do not use read data due to possible EPB
+			for (i=0; i<4; i++)
+				dst_ptri = gf_bs_read_u8(bs);
+
 			if (hevc) {
-				gf_bs_read_data(bs, hevc->clli_data, 4);
 				hevc->clli_valid = 1;
 			} else {
-				gf_bs_read_data(bs, vvc->clli_data, 4);
 				vvc->clli_valid = 1;
 			}
 			break;
+		//mdcv
 		case 137:
-			//mdcv
+			dst_ptr = hevc ? hevc->mdcv_data : vvc->mdcv_data;
+			//do not use read data due to possible EPB
+			for (i=0; i<24; i++)
+				dst_ptri = gf_bs_read_u8(bs);
+
 			if (hevc) {
-				gf_bs_read_data(bs, hevc->mdcv_data, 24);
 				hevc->mdcv_valid = 1;
 			} else {
-				gf_bs_read_data(bs, vvc->mdcv_data, 24);
 				vvc->mdcv_valid = 1;
 			}
 			break;
 		default:
 			break;
 		}
+		nb_zeros = gf_bs_get_emulation_byte_removed(bs) - nb_zeros;
 
 		gf_bs_align(bs);
 		consumed = (u32) (gf_bs_get_position(bs) - start);
+		consumed -= nb_zeros;
 		psize-=consumed;
-		gf_bs_skip_bytes(bs, psize);
+		//do not use skip bytes due to possible EPB
+		while (psize) {
+			gf_bs_read_u8(bs);
+			psize--;
+		}
 		if (gf_bs_available(bs) <= 2)
 			break;
 	}
@@ -7572,18 +7636,20 @@
 		num_scalability_types = 16;
 	}
 	dimension_id_len0 = 0;
-	for (i = 0; i < (num_scalability_types - splitting_flag); i++) {
-		dimension_id_leni = 1 + gf_bs_read_int_log_idx(bs, 3, "dimension_id_len_minus1", i);
-	}
+	if (num_scalability_types) {
+		for (i = 0; i < (num_scalability_types - splitting_flag); i++) {
+			dimension_id_leni = 1 + gf_bs_read_int_log_idx(bs, 3, "dimension_id_len_minus1", i);
+		}
 
-	if (splitting_flag) {
-		for (i = 0; i < num_scalability_types; i++) {
-			dim_bit_offseti = 0;
-			for (j = 0; j < i; j++)
-				dim_bit_offseti += dimension_id_lenj;
+		if (splitting_flag) {
+			for (i = 0; i < num_scalability_types; i++) {
+				dim_bit_offseti = 0;
+				for (j = 0; j < i; j++)
+					dim_bit_offseti += dimension_id_lenj;
+			}
+			dimension_id_lennum_scalability_types - 1 = 1 + (5 - dim_bit_offsetnum_scalability_types - 1);
+			dim_bit_offsetnum_scalability_types = 6;
 		}
-		dimension_id_lennum_scalability_types - 1 = 1 + (5 - dim_bit_offsetnum_scalability_types - 1);
-		dim_bit_offsetnum_scalability_types = 6;
 	}
 
 	vps_nuh_layer_id_present_flag = gf_bs_read_int_log(bs, 1, "vps_nuh_layer_id_present_flag");
@@ -7596,6 +7662,11 @@
 		else {
 			vps->layer_id_in_nuhi = i;
 		}
+		if (vps->layer_id_in_nuhi > MAX_LHVC_LAYERS) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC %d layers in VPS ext but only %d supported in GPAC\n", vps->layer_id_in_nuhi, MAX_LHVC_LAYERS));
+			vps->layer_id_in_nuhi = 0;
+			return -1;
+		}
 		vps->layer_id_in_vpsvps->layer_id_in_nuhi = i;
 
 		if (!splitting_flag) {
@@ -7937,7 +8008,8 @@
 	vps->base_layer_available_flag = gf_bs_read_int_log(bs, 1, "base_layer_available_flag");
 	vps->max_layers = 1 + gf_bs_read_int_log(bs, 6, "max_layers_minus1");
 	if (vps->max_layers > MAX_LHVC_LAYERS) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC sorry, %d layers in VPS but only %d supported\n", vps->max_layers, MAX_LHVC_LAYERS));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC %d layers in VPS but only %d supported in GPAC\n", vps->max_layers, MAX_LHVC_LAYERS));
+		vps->max_layers = MAX_LHVC_LAYERS;
 		return -1;
 	}
 	vps->max_sub_layers = gf_bs_read_int_log(bs, 3, "max_sub_layers_minus1") + 1;
@@ -7952,8 +8024,9 @@
 		gf_bs_read_ue_log_idx(bs, "vps_max_latency_increase_plus1", i);
 	}
 	vps->max_layer_id = gf_bs_read_int_log(bs, 6, "max_layer_id");
-	if (vps->max_layer_id > MAX_LHVC_LAYERS) {
+	if (vps->max_layer_id >= MAX_LHVC_LAYERS) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC VPS max layer ID %u but GPAC only supports %u\n", vps->max_layer_id, MAX_LHVC_LAYERS));
+		vps->max_layer_id = 0;
 		return -1;
 	}
 	vps->num_layer_sets = gf_bs_read_ue_log(bs, "num_layer_sets_minus1") + 1;
@@ -8195,11 +8268,17 @@
 		sps->update_rep_format_flag = gf_bs_read_int_log(bs, 1, "update_rep_format_flag");
 		if (sps->update_rep_format_flag) {
 			sps->rep_format_idx = gf_bs_read_int_log(bs, 8, "rep_format_idx");
-			if (sps->rep_format_idx>15) {
-				return -1;
-			}
 		} else {
-			sps->rep_format_idx = vps->rep_format_idxlayer_id;
+			if (layer_id<MAX_LHVC_LAYERS) {
+				u32 idx = vps->layer_id_in_vpslayer_id;
+				if (idx<=15)
+					sps->rep_format_idx = vps->rep_format_idxidx;
+			}
+		}
+		if (sps->rep_format_idx>15) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC Invalid rep_format_idx index %d\n", sps->rep_format_idx));
+			sps->rep_format_idx=0;
+			return -1;
 		}
 		sps->width = vps->rep_formatssps->rep_format_idx.pic_width_luma_samples;
 		sps->height = vps->rep_formatssps->rep_format_idx.pic_height_luma_samples;
@@ -8244,6 +8323,11 @@
 	}
 
 	sps->log2_max_pic_order_cnt_lsb = 4 + gf_bs_read_ue_log(bs, "log2_max_pic_order_cnt_lsb_minus4");
+	if (sps->log2_max_pic_order_cnt_lsb>16) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC Invalid log2_max_pic_order_cnt_lsb_minus4 %d, max shall be 12\n", sps->log2_max_pic_order_cnt_lsb-4));
+		sps->log2_max_pic_order_cnt_lsb = 16;
+		return -1;
+	}
 
 	if (!multiLayerExtSpsFlag) {
 		sps->sub_layer_ordering_info_present_flag = gf_bs_read_int_log(bs, 1, "sub_layer_ordering_info_present_flag");
@@ -8256,6 +8340,10 @@
 
 	sps->log2_min_luma_coding_block_size = 3 + gf_bs_read_ue_log(bs, "log2_min_luma_coding_block_size_minus3");
 	sps->log2_diff_max_min_luma_coding_block_size = gf_bs_read_ue_log(bs, "log2_diff_max_min_luma_coding_block_size");
+	//we allow more than in max profile, but make sure we don't overflow max CU W/H compute below
+	if (sps->log2_min_luma_coding_block_size + sps->log2_diff_max_min_luma_coding_block_size >= 30) {
+		return -1;
+	}
 	sps->max_CU_width = (1 << (sps->log2_min_luma_coding_block_size + sps->log2_diff_max_min_luma_coding_block_size));
 	sps->max_CU_height = (1 << (sps->log2_min_luma_coding_block_size + sps->log2_diff_max_min_luma_coding_block_size));
 
@@ -8364,7 +8452,7 @@
 			sps->chroma_sample_loc_type_bottom_field = gf_bs_read_ue_log(bs, "chroma_sample_loc_type_bottom_field");
 		}
 
-		sps->neutra_chroma_indication_flag = gf_bs_read_int_log(bs, 1, "neutra_chroma_indication_flag");
+		sps->neutral_chroma_indication_flag = gf_bs_read_int_log(bs, 1, "neutral_chroma_indication_flag");
 		sps->field_seq_flag = gf_bs_read_int_log(bs, 1, "field_seq_flag");
 		sps->frame_field_info_present_flag = gf_bs_read_int_log(bs, 1, "frame_field_info_present_flag");
 
@@ -8408,7 +8496,8 @@
 #endif
 
 	}
-
+	if (gf_bs_is_overflow(bs))
+		return -1;
 	return sps_id;
 }
 
@@ -8500,7 +8589,15 @@
 	pps->entropy_coding_sync_enabled_flag = gf_bs_read_int_log(bs, 1, "entropy_coding_sync_enabled_flag");
 	if (pps->tiles_enabled_flag) {
 		pps->num_tile_columns = 1 + gf_bs_read_ue_log(bs, "num_tile_columns_minus1");
+		if (pps->num_tile_columns > 22) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC Invalid num_tile_columns %u\n", pps->num_tile_columns));
+			return -1;
+		}
 		pps->num_tile_rows = 1 + gf_bs_read_ue_log(bs, "num_tile_rows_minus1");
+		if (pps->num_tile_rows > 20) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("HEVC Invalid num_tile_rows %u\n", pps->num_tile_rows));
+			return -1;
+		}
 		pps->uniform_spacing_flag = gf_bs_read_int_log(bs, 1, "uniform_spacing_flag");
 		if (!pps->uniform_spacing_flag) {
 			for (i = 0; i < pps->num_tile_columns - 1; i++) {
@@ -8534,6 +8631,9 @@
 #endif
 
 	}
+
+	if (gf_bs_is_overflow(bs))
+		return -1;
 	return pps_id;
 }
 
@@ -8744,7 +8844,7 @@
 			bit_offset--;
 		}
 
-		avc_hevc_vvc_rewrite_vui(vui_info, orig, mod, GF_FALSE);
+		avc_hevc_vvc_rewrite_vui(vui_info, orig, mod, GF_CODECID_HEVC);
 
 		/*finally copy over remaining*/
 		while (gf_bs_bits_available(orig)) {
@@ -8847,6 +8947,7 @@
 static Bool AC3_FindSyncCodeBS(GF_BitStream *bs)
 {
 	u8 b1;
+	if (gf_bs_available(bs)<6) return GF_FALSE;
 	u64 pos = gf_bs_get_position(bs);
 	u64 end = gf_bs_get_size(bs);
 
@@ -8884,15 +8985,27 @@
 	512, 640, 768, 896, 1024, 1152, 1280
 };
 
-static const u32 ac3_mod_to_chans = {
+static const u32 ac3_mod_to_total_chans = {
 	2, 1, 2, 3, 3, 4, 4, 5
 };
 
+static const u32 ac3_mod_to_surround_chans = {
+	0, 0, 0, 0, 1, 1, 2, 2
+};
+
 GF_EXPORT
-u32 gf_ac3_get_channels(u32 acmod)
+u32 gf_ac3_get_total_channels(u32 acmod)
 {
 	u32 nb_ch;
-	nb_ch = ac3_mod_to_chansacmod;
+	nb_ch = ac3_mod_to_total_chansacmod;
+	return nb_ch;
+}
+
+GF_EXPORT
+u32 gf_ac3_get_surround_channels(u32 acmod)
+{
+	u32 nb_ch;
+	nb_ch = ac3_mod_to_surround_chansacmod;
 	return nb_ch;
 }
 
@@ -8923,9 +9036,9 @@
 {
 	u32 fscod, frmsizecod, bsid, ac3_mod, freq, framesize, bsmod, syncword;
 	u64 pos;
-	if (!hdr || (gf_bs_available(bs) < 6)) return GF_FALSE;
-	if (!AC3_FindSyncCodeBS(bs)) return GF_FALSE;
+	if (!hdr || !AC3_FindSyncCodeBS(bs)) return GF_FALSE;
 
+	memset(hdr, 0, sizeof(GF_AC3Header));
 	pos = gf_bs_get_position(bs);
 
 	syncword = gf_bs_read_u16(bs);
@@ -8939,28 +9052,20 @@
 	bsid = gf_bs_read_int_log(bs, 5, "bsid");
 	bsmod = gf_bs_read_int_log(bs, 3, "bsmod");
 	ac3_mod = gf_bs_read_int_log(bs, 3, "ac3_mod");
+
 	if (frmsizecod >= 2 * sizeof(ac3_sizecod_to_bitrate) / sizeof(u32))
 		return GF_FALSE;
 
-	hdr->bitrate = ac3_sizecod_to_bitratefrmsizecod / 2;
-	if (bsid > 8) hdr->bitrate = hdr->bitrate >> (bsid - 8);
-
 	switch (fscod) {
 	case 0:
-		if (frmsizecod >= 2 * sizeof(ac3_sizecod0_to_framesize) / sizeof(u32))
-			return GF_FALSE;
 		freq = 48000;
 		framesize = ac3_sizecod0_to_framesizefrmsizecod / 2 * 2;
 		break;
 	case 1:
-		if (frmsizecod >= 2 * sizeof(ac3_sizecod1_to_framesize) / sizeof(u32))
-			return GF_FALSE;
 		freq = 44100;
 		framesize = (ac3_sizecod1_to_framesizefrmsizecod / 2 + (frmsizecod & 0x1)) * 2;
 		break;
 	case 2:
-		if (frmsizecod >= 2 * sizeof(ac3_sizecod2_to_framesize) / sizeof(u32))
-			return GF_FALSE;
 		freq = 32000;
 		framesize = ac3_sizecod2_to_framesizefrmsizecod / 2 * 2;
 		break;
@@ -8969,6 +9074,7 @@
 	}
 	hdr->sample_rate = freq;
 	hdr->framesize = framesize;
+	hdr->nb_streams = 1;
 
 	if (full_parse) {
 		hdr->streams0.bsid = bsid;
@@ -8978,16 +9084,17 @@
 		hdr->streams0.fscod = fscod;
 		hdr->brcode = frmsizecod / 2;
 	}
-	if (ac3_mod >= 2 * sizeof(ac3_mod_to_chans) / sizeof(u32))
+	if (ac3_mod >= 2 * sizeof(ac3_mod_to_total_chans) / sizeof(u32))
 		return GF_FALSE;
 
-	hdr->channels = ac3_mod_to_chansac3_mod;
+	hdr->streams0.channels = ac3_mod_to_total_chansac3_mod;
+	hdr->streams0.surround_channels = ac3_mod_to_surround_chansac3_mod;
 	if ((ac3_mod & 0x1) && (ac3_mod != 1)) gf_bs_read_int_log(bs, 2, "cmixlev");
 	if (ac3_mod & 0x4) gf_bs_read_int_log(bs, 2, "surmixlev");
 	if (ac3_mod == 0x2) gf_bs_read_int_log(bs, 2, "dsurmod");
 
 	if (gf_bs_read_int_log(bs, 1, "lfeon")) {
-		hdr->channels += 1;
+		hdr->streams0.channels += 1;
 		hdr->streams0.lfon = 1;
 	}
 
@@ -8997,69 +9104,179 @@
 }
 
 GF_EXPORT
-Bool gf_eac3_parser_bs(GF_BitStream *bs, GF_AC3Config *hdr, Bool full_parse)
+u32 gf_eac3_get_chan_loc_count(u32 chan_loc)
 {
-	u32 fscod, bsid, ac3_mod, freq, framesize, syncword, substreamid, lfon, channels, numblkscod, strmtyp, frmsiz;
-	u64 pos;
+	u32 nb_ch=0;
+	if (chan_loc & 1) nb_ch+=2; //Lc/Rc pair
+	if (chan_loc & (1<<1)) nb_ch+=2; //Lrs/Rrs pair
+	if (chan_loc & (1<<2)) nb_ch+=1; //Cs
+	if (chan_loc & (1<<3)) nb_ch+=1; //Ts
+	if (chan_loc & (1<<4)) nb_ch+=2; //Lsd/Rsd pair
+	if (chan_loc & (1<<5)) nb_ch+=2; //Lw/Rw pair
+	if (chan_loc & (1<<6)) nb_ch+=2; //Lvh/Rvh pair
+	if (chan_loc & (1<<7)) nb_ch+=1; //Cvh
+	if (chan_loc & (1<<8)) nb_ch+=1; //LFE2
+	return nb_ch;
+}
+
+static u32 eac3_chanmap_to_chan_loc(u32 chan_map)
+{
+	u32 chan_loc = 0;
+	if (chan_map & (1<<10)) chan_loc |= (1);
+	if (chan_map & (1<<9)) chan_loc |= (1<<1);
+	if (chan_map & (1<<8)) chan_loc |= (1<<2);
+	if (chan_map & (1<<7)) chan_loc |= (1<<3);
+	if (chan_map & (1<<6)) chan_loc |= (1<<4);
+	if (chan_map & (1<<5)) chan_loc |= (1<<5);
+	if (chan_map & (1<<4)) chan_loc |= (1<<6);
+	if (chan_map & (1<<3)) chan_loc |= (1<<7);
+	//Lts/Rts pair (LSB 2) is not exposed in chan_loc
+	if (chan_map & (1<<1)) chan_loc |= (1<<8);
+	return chan_loc;
+}
+
+static void eac3_update_channels(GF_AC3Config *hdr)
+{
+	u32 i;
+	for (i=0; i<hdr->nb_streams; i++) {
+		u32 nb_ch = ac3_mod_to_total_chanshdr->streamsi.acmod;
+		if (hdr->streamsi.nb_dep_sub) {
+			hdr->streamsi.chan_loc = eac3_chanmap_to_chan_loc(hdr->streamsi.chan_loc);
+			nb_ch += gf_eac3_get_chan_loc_count(hdr->streamsi.chan_loc);
+		}
+		if (hdr->streamsi.lfon) nb_ch++;
+		hdr->streamsi.channels = nb_ch;
+		hdr->streamsi.surround_channels = ac3_mod_to_surround_chanshdr->streamsi.acmod;
+	}
+}
+
+static Bool gf_eac3_parser_internal(GF_BitStream *bs, GF_AC3Config *hdr, Bool full_parse)
+{
+	u32 fscod, bsid, acmod, freq, framesize, syncword, substreamid, lfon, numblkscod, strmtyp, frmsiz, bsmod;
+	u64 pos, hdr_pos;
 	u16 chanmap;
+	Bool main_indep_found = GF_FALSE;
+	s32 cur_main_id = -1;
+	u32 nb_blocks_main;
+	u32 cur_main_ac3 = 0;
+	u16 main_substreams; //bit-mask of independent channels found so far
 	static u32 numblks4 = {1, 2, 3, 6};
 
-	if (!hdr || (gf_bs_available(bs) < 6))
-		return GF_FALSE;
-	if (!AC3_FindSyncCodeBS(bs))
+	if (!hdr || !AC3_FindSyncCodeBS(bs))
 		return GF_FALSE;
 
+retry_frame:
 	pos = gf_bs_get_position(bs);
 	framesize = 0;
 	numblkscod = 0;
+	bsmod = 0;
+	nb_blocks_main = 0;
+	main_substreams = 0;
 	memset(hdr, 0, sizeof(GF_AC3Config));
 
-block:
+next_block:
+	hdr_pos = gf_bs_get_position(bs);
+
+	bsid = gf_bs_peek_bits(bs, 5, 5);
+	//"If an AC-3 bit stream is present in the Enhanced AC-3 bit stream, then the AC-3 bit stream shall be treated
+	//as an independent substream assigned substream ID 0."
+	if (bsid<=8) {
+		GF_AC3Header ac3h;
+		//we are done
+		if (main_indep_found) {
+			eac3_update_channels(hdr);
+			gf_bs_seek(bs, pos);
+			return GF_TRUE;
+		}
+		if (!gf_ac3_parser_bs(bs, &ac3h, GF_TRUE)) {
+			gf_bs_seek(bs, pos);
+			return GF_FALSE;
+		}
+		hdr->streams0 = ac3h.streams0;
+		hdr->nb_streams = 1;
+		hdr->sample_rate = ac3h.sample_rate;
+		main_substreams |= 1;
+		hdr->framesize = ac3h.framesize;
+		nb_blocks_main = 6;
+		hdr->brcode = gf_ac3_get_bitrate(ac3h.brcode)/1000;
+
+		gf_bs_skip_bytes(bs, ac3h.framesize);
+		if (!AC3_FindSyncCodeBS(bs)) {
+			gf_bs_seek(bs, pos);
+			return GF_FALSE;
+		}
+		main_indep_found = GF_TRUE;
+		cur_main_id = 0;
+		cur_main_ac3 = 1;
+		goto next_block;
+	}
+	//corrupted frame, trash
+	if ((bsid<10) || (bsid>16)) {
+		gf_bs_skip_bytes(bs, 1);//we are still at the startcode
+		if (!AC3_FindSyncCodeBS(bs)) {
+			gf_bs_seek(bs, pos);
+			return GF_FALSE;
+		}
+		goto next_block;
+	}
 	syncword = gf_bs_read_u16(bs);
 	if (syncword != 0x0B77) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("E-AC3 Wrong sync word detected (0x%X - expecting 0x0B77).\n", syncword));
 		return GF_FALSE;
 	}
 
+	hdr->is_ec3 = 1;
 	strmtyp = gf_bs_read_int_log(bs, 2, "strmtyp");
 	substreamid = gf_bs_read_int_log(bs, 3, "substreamid");
-	//next main (independent) AU, done with this frame
-	if ((strmtyp!=0x1) && ((hdr->substreams >> substreamid) & 0x1)) {
-		hdr->framesize = framesize;
-		gf_bs_seek(bs, pos);
-		return GF_TRUE;
+
+	//independent stream
+	if (strmtyp!=0x1) {
+		cur_main_ac3 = 0;
+		//all blocks gathered and we have seen this substreamid, done with whole frame
+		if ( (nb_blocks_main>=6) && ( (main_substreams >> substreamid) & 0x1)) {
+			eac3_update_channels(hdr);
+			gf_bs_seek(bs, pos);
+			return GF_TRUE;
+		}
+		//main independent: "All Enhanced AC-3 bit streams shall contain an independent substream assigned substream ID 0.
+		// The independent substream assigned substream ID 0 shall be the first substream present in the bit stream."
+		if (!substreamid)
+			main_indep_found = 1;
+		if (cur_main_id != substreamid)
+			nb_blocks_main=0;
+		cur_main_id = substreamid;
 	}
 
+	//trash everything until we find first indep stream
+	if (!main_indep_found) {
+		gf_bs_align(bs);
+		if (!AC3_FindSyncCodeBS(bs)) {
+			gf_bs_seek(bs, pos);
+			return GF_FALSE;
+		}
+		goto retry_frame;
+	}
+	//quick hack (not sure if the spec forbids this): some AC3+EAC3 streams use substreamid=0 for the eac3
+	//which breaks nb_dep_sub / chan_loc signaling
+	//we increase by one in this case
+	if (cur_main_ac3 && !substreamid) cur_main_ac3=2;
+	if (cur_main_ac3==2) substreamid++;
+
 	frmsiz = gf_bs_read_int_log(bs, 11, "frmsiz");
 	framesize += 2 * (1 + frmsiz);
 	fscod = gf_bs_read_int_log(bs, 2, "fscod");
 	if (fscod == 0x3) {
 		fscod = gf_bs_read_int_log(bs, 2, "fscod2");
-		numblkscod += 6;
-	}
-	else {
-		numblkscod += gf_bs_read_int_log(bs, 2, "numblkscod");
+		numblkscod = 3;
+	} else {
+		numblkscod = gf_bs_read_int_log(bs, 2, "numblkscod");
 	}
-	assert(numblkscod <= 9);
-
 
-	if ((hdr->substreams >> substreamid) & 0x1) {
-		//we still have sync frames following
-		if (substreamid) {
-			if (gf_bs_seek(bs, pos + framesize) != GF_OK) {
-				gf_bs_seek(bs, pos);
-				return GF_FALSE;
-			}
-			if ((gf_bs_available(bs) < 6) || !AC3_FindSyncCodeBS(bs)) {
-				gf_bs_seek(bs, pos);
-				return GF_FALSE;
-			}
-			goto block;
-		}
+	//remember our independent substreams
+	if (strmtyp!=0x1) {
+		main_substreams |= (1 << substreamid);
 	}
 
-	hdr->substreams |= (1 << substreamid);
-
 	switch (fscod) {
 	case 0:
 		freq = 48000;
@@ -9071,19 +9288,20 @@
 		freq = 32000;
 		break;
 	default:
+		//do not sync
+		gf_bs_align(bs);
 		return GF_FALSE;
 	}
 
-	ac3_mod = gf_bs_read_int_log(bs, 3, "ac3_mod");
+	acmod = gf_bs_read_int_log(bs, 3, "acmod");
 	lfon = gf_bs_read_int_log(bs, 1, "lfon");
 	bsid = gf_bs_read_int_log(bs, 5, "bsid");
-	if (!substreamid && (bsid != 16/*E-AC3*/))
-		return GF_FALSE;
+
 	gf_bs_read_int_log(bs, 5, "dialnorm");
 	if (gf_bs_read_int_log(bs, 1, "compre")) {
 		gf_bs_read_int_log(bs, 8, "compr");
 	}
-	if (ac3_mod==0) {
+	if (acmod==0) {
 		gf_bs_read_int_log(bs, 5, "dialnorm2");
 		if (gf_bs_read_int_log(bs, 1, "compr2e")) {
 			gf_bs_read_int_log(bs, 8, "compr2");
@@ -9096,49 +9314,165 @@
 		}
 	}
 
-	channels = ac3_mod_to_chansac3_mod;
-	if (lfon)
-		channels += 1;
-
-	hdr->bitrate = 0;
 	hdr->sample_rate = freq;
-	hdr->framesize = framesize;
+	hdr->framesize += framesize;
 	if (strmtyp != 1) {
-		hdr->channels = channels;
+		assert(cur_main_id == substreamid);
 		hdr->streamssubstreamid.lfon = lfon;
-		if (full_parse) {
-			hdr->streamssubstreamid.bsid = bsid;
-			hdr->streamssubstreamid.bsmod = 0;
-			hdr->streamssubstreamid.acmod = ac3_mod;
-			hdr->streamssubstreamid.fscod = fscod;
-			hdr->brcode = 0;
-		}
-		hdr->nb_streams++;
-		//not clear if this is only for the independent streams
-		hdr->brcode += ((frmsiz+1) * freq) / (numblksnumblkscod*16) / 1000;
+		hdr->streamssubstreamid.bsid = bsid;
+		hdr->streamssubstreamid.bsmod = bsmod;
+		hdr->streamssubstreamid.acmod = acmod;
+		hdr->streamssubstreamid.fscod = fscod;
+		hdr->brcode = 0;
+		if (hdr->nb_streams<8)
+			hdr->nb_streams++;
+	}
+	//dependent stream, record max substream ID of dep and store chan map
+	else {
+		hdr->streamscur_main_id.nb_dep_sub = substreamid;
+		hdr->streamscur_main_id.chan_loc |= chanmap;
+	}
+
+	//not clear if this is only for the independent streams - spec says "The value is the sum of the data rates of all the substreams"
+	hdr->brcode += ((frmsiz+1) * freq) / (numblksnumblkscod*16) / 1000;
+
+	//start of header only, we are done - chan info might be wrong
+	if (!full_parse) {
+		eac3_update_channels(hdr);
+		gf_bs_seek(bs, pos);
+		return GF_TRUE;
+	}
 
-		if (lfon)
-			hdr->channels += 1;
+	//mix metadata
+	if (gf_bs_read_int(bs, 1)) {
+		if (acmod > 0x2) gf_bs_read_int(bs, 2);
+		if ((acmod & 0x1) && (acmod > 0x2)) gf_bs_read_int(bs, 6);
+		if (acmod & 0x4) gf_bs_read_int(bs, 6);
+		if (lfon) {
+			if (gf_bs_read_int(bs, 1))
+				gf_bs_read_int(bs, 5);
+		}
+		if (strmtyp == 0) {
+			//pgmscle
+			if (gf_bs_read_int(bs, 1))
+				gf_bs_read_int(bs, 6);
+			if (acmod==0) {
+				//pgmscl2e
+				if (gf_bs_read_int(bs, 1))
+					gf_bs_read_int(bs, 6);
+			}
+			//extpgmscle
+			if (gf_bs_read_int(bs, 1))
+				gf_bs_read_int(bs, 6);
+			u8 mixdef = gf_bs_read_int(bs, 2);
+			if (mixdef == 0x1) {
+				gf_bs_read_int(bs, 5);
+			} else if (mixdef == 0x2) {
+				gf_bs_read_int(bs, 12);
+			} else if (mixdef == 0x3) {
+				u32 mixdeflen = gf_bs_read_int(bs, 5);
+				mixdeflen = 8 * (mixdeflen + 2);
+				while (mixdeflen) {
+					gf_bs_read_int(bs, 1);
+					mixdeflen--;
+				}
+			}
+			if (acmod < 0x2) {
+				//paninfoe
+				if (gf_bs_read_int(bs, 1))
+					gf_bs_read_int(bs, 14);
+				if (acmod == 0) {
+					//paninfo2e
+					if (gf_bs_read_int(bs, 1))
+						gf_bs_read_int(bs, 14);
+				}
 
-	} else {
-		hdr->streamssubstreamid.nb_dep_sub = substreamid;
-		hdr->streamssubstreamid.chan_loc |= chanmap;
+			}
+			//frmmixcfginfoe
+			if (gf_bs_read_int(bs, 1)) {
+				if (numblkscod == 0x0) {
+					gf_bs_read_int(bs, 5);
+				} else {
+					u32 i, nb_blocks = numblksnumblkscod;
+					for (i=0; i<nb_blocks; i++) {
+						if (gf_bs_read_int(bs, 1))
+							gf_bs_read_int(bs, 5);
+					}
+				}
+			}
+		}
 	}
-
-	if (numblkscod < 6) { //we need 6 blocks to make a sample
-		if (gf_bs_seek(bs, pos + framesize) != GF_OK) {
-			gf_bs_seek(bs, pos);
-			return GF_FALSE;
+	//info metadata
+	if (gf_bs_read_int(bs, 1)) {
+		gf_bs_read_int(bs, 5);
+		if (acmod == 0x2) gf_bs_read_int(bs, 4);
+		if (acmod >= 0x6) gf_bs_read_int(bs, 2);
+		//audprodie
+		if (gf_bs_read_int(bs, 1)) gf_bs_read_int(bs, 8);
+		if (acmod == 0x0) {
+			//audprodi2e
+			if (gf_bs_read_int(bs, 1)) gf_bs_read_int(bs, 8);
+		}
+		if (fscod < 0x3) gf_bs_read_int(bs, 1);
+	}
+	if ((strmtyp == 0) && (numblkscod != 0x3)) gf_bs_read_int(bs, 1);
+	if (strmtyp == 0x2) {
+		u32 blkid=0;
+		if (numblkscod == 0x3) blkid=1;
+		else blkid = gf_bs_read_int(bs, 1);
+		if (blkid) gf_bs_read_int(bs, 6);
+	}
+	u8 addbsie = gf_bs_read_int(bs, 1);
+	if (addbsie) {
+		u32 addbsil = gf_bs_read_int(bs, 6) + 1;
+		//we only use the first 2 bytes - cf 8.3 of ETSI 103 420 V1.2.1
+		if (addbsil>=2) {
+			gf_bs_read_int(bs, 7);
+			if (gf_bs_read_int(bs, 1)) {
+				hdr->atmos_ec3_ext = 1;
+				hdr->complexity_index_type = gf_bs_read_int(bs, 8);
+			}
 		}
+	}
 
-		if ((gf_bs_available(bs) < 6) || !AC3_FindSyncCodeBS(bs))
-			return GF_FALSE;
-		goto block;
+	//remember numbers of block for main
+	if (strmtyp!=0x1) {
+		nb_blocks_main += numblksnumblkscod;
 	}
 
-	gf_bs_seek(bs, pos);
+	if (gf_bs_seek(bs, hdr_pos + framesize) != GF_OK) {
+		gf_bs_seek(bs, pos);
+		return GF_FALSE;
+	}
 
-	return GF_TRUE;
+	if (!AC3_FindSyncCodeBS(bs)) {
+		gf_bs_seek(bs, pos);
+		return GF_FALSE;
+	}
+	//we go to next block even if we have 6 of main (to check deps)
+	goto next_block;
+}
+
+GF_EXPORT
+Bool gf_eac3_parser_bs(GF_BitStream *bs, GF_AC3Config *hdr, Bool full_parse)
+{
+	return gf_eac3_parser_internal(bs, hdr, full_parse);
+}
+
+GF_EXPORT
+Bool gf_eac3_parser(u8 *buf, u32 buflen, u32 *pos, GF_AC3Config *hdr, Bool full_parse)
+{
+	GF_BitStream *bs;
+	Bool ret;
+
+	if (buflen < 6) return GF_FALSE;
+	(*pos) = AC3_FindSyncCode(buf, buflen);
+	if (*pos >= buflen) return GF_FALSE;
+
+	bs = gf_bs_new((const char*)(buf + *pos), buflen, GF_BITSTREAM_READ);
+	ret = gf_eac3_parser_internal(bs, hdr, full_parse);
+	gf_bs_del(bs);
+	return ret;
 }
 
 #endif /*GPAC_DISABLE_AV_PARSERS*/
@@ -9417,9 +9751,15 @@
 	return ((vp->mode_flagblock_size) ? vp->max_block : vp->min_block) / (2);
 }
 
+
+#endif /*!defined(GPAC_DISABLE_AV_PARSERS) && !defined (GPAC_DISABLE_OGG)*/
+
+
+#if !defined(GPAC_DISABLE_AV_PARSERS)
+
 /*call with vorbis header packets - initializes the parser on success, leave it to NULL otherwise
 returns 1 if success, 0 if error.*/
-Bool gf_opus_parse_header(GF_OpusParser *opus, u8 *data, u32 data_len)
+Bool gf_opus_parse_header(GF_OpusConfig *ocfg, u8 *data, u32 data_len)
 {
 	char tag9;
 	GF_BitStream *bs = gf_bs_new(data, data_len, GF_BITSTREAM_READ);
@@ -9431,36 +9771,35 @@
 		return GF_FALSE;
 	}
 	/*Identification Header*/
-	opus->version = gf_bs_read_u8(bs); /*version*/
-	if (opus->version != 1) {
+	ocfg->version = gf_bs_read_u8(bs); /*version*/
+	if (ocfg->version != 1) {
 		gf_bs_del(bs);
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Opus Unsupported version %d\n", opus->version));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Opus Unsupported version %d\n", ocfg->version));
 		return GF_FALSE;
 	}
-	opus->OutputChannelCount = gf_bs_read_u8(bs);
-	opus->PreSkip = gf_bs_read_u16_le(bs);
-	opus->InputSampleRate = gf_bs_read_u32_le(bs);
-	opus->OutputGain = gf_bs_read_u16_le(bs);
-	opus->ChannelMappingFamily = gf_bs_read_u8(bs);
-	if (opus->ChannelMappingFamily != 0) {
-		opus->StreamCount = gf_bs_read_u8(bs);
-		opus->CoupledCount = gf_bs_read_u8(bs);
-		gf_bs_read_data(bs, (char *) opus->ChannelMapping, opus->OutputChannelCount);
+	ocfg->OutputChannelCount = gf_bs_read_u8(bs);
+	ocfg->PreSkip = gf_bs_read_u16_le(bs);
+	ocfg->InputSampleRate = gf_bs_read_u32_le(bs);
+	ocfg->OutputGain = gf_bs_read_u16_le(bs);
+	ocfg->ChannelMappingFamily = gf_bs_read_u8(bs);
+	if (ocfg->ChannelMappingFamily != 0) {
+		ocfg->StreamCount = gf_bs_read_u8(bs);
+		ocfg->CoupledCount = gf_bs_read_u8(bs);
+		gf_bs_read_data(bs, (char *) ocfg->ChannelMapping, ocfg->OutputChannelCount);
 	}
 	gf_bs_del(bs);
 	return GF_TRUE;
 }
 
-/*returns 0 if init error or not a vorbis frame, otherwise returns the number of audio samples
+/*returns 0 if init error or not an opus frame, otherwise returns the number of audio samples
 in this frame*/
-u32 gf_opus_check_frame(GF_OpusParser *op, u8 *data, u32 data_length)
+u32 gf_opus_check_frame(GF_OpusConfig *ocfg, u8 *data, u32 data_length)
 {
 	u32 block_size;
 
-	if (!memcmp(data, "OpusHead", sizeof(char)*8))
-		return 0;
-	if (!memcmp(data, "OpusTags", sizeof(char)*8))
-		return 0;
+	if (!data || !data_length) return 0;
+	if (!memcmp(data, "OpusHead", sizeof(char)*8)) return 0;
+	if (!memcmp(data, "OpusTags", sizeof(char)*8)) return 0;
 
 	/*consider the whole packet as Ogg packets and ISOBMFF samples for Opus are framed similarly*/
 	static const int OpusFrameDurIn48k = { 480, 960, 1920, 2880, 480, 960, 1920, 2880, 480, 960, 1920, 2880,
@@ -9482,7 +9821,367 @@
 	return block_size;
 }
 
-#endif /*!defined(GPAC_DISABLE_AV_PARSERS) && !defined (GPAC_DISABLE_OGG)*/
+/* return nb bytes read */
+static u8 gf_opus_read_length(u8 *data, u32 data_length, u32 offset, u16 *read_length) {
+ if (!data || !data_length || !read_length) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Cannot read Opus length value\n"));
+ return 0;
+ }
+ if (offset >= data_length) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Not enough bytes to read Opus length\n"));
+ return 0;
+ }
+ if (dataoffset < 252) {
+ *read_length = dataoffset;
+ return 1;
+ } else {
+ if (offset+1 >= data_length) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Not enough bytes to read 2-byte Opus length\n"));
+ return 0;
+ }
+ *read_length = dataoffset+1*4+dataoffset;
+ return 2;
+ }
+}
+
+GF_EXPORT
+u8 gf_opus_parse_packet_header(u8 *data, u32 data_length, Bool self_delimited, GF_OpusPacketHeader *header)
+{
+ u32 i;
+ u32 nb_read_bytes;
+ if (!data || !data_length)
+ return 0;
+ if (!header)
+ return 0;
+ if (!memcmp(data, "OpusHead", sizeof(char)*8))
+ return 0;
+ if (!memcmp(data, "OpusTags", sizeof(char)*8))
+ return 0;
+
+ GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("Processing Opus packet, self: %d, size %d\n", self_delimited, data_length));
+
+ if (data_length < 1) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Opus packet size must be at least one to parse TOC byte\n"));
+ return 0;
+ }
+ memset(header, 0, sizeof(GF_OpusPacketHeader));
+ header->self_delimited = self_delimited;
+ header->TOC_config = (data0 & 0xf8) >> 3;
+ header->TOC_stereo = (data0 & 0x4) >> 2;
+ header->TOC_code = data0 & 0x03;
+ header->size = 1;
+ if (header->TOC_code == 0) {
+ header->nb_frames = 1;
+ if (self_delimited) {
+ nb_read_bytes = gf_opus_read_length(data, data_length, header->size, &header->self_delimited_length);
+ if (nb_read_bytes) {
+ header->size += nb_read_bytes;
+ } else {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Could not read self delimited length in Opus packet code 0\n"));
+ return 0;
+ }
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|0|0| N1 (1-2 bytes): |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
+// | Compressed frame 1 (N1 bytes)... :
+// : |
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ header->frame_lengths0 = header->self_delimited_length;
+ } else {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|0|0| |
+// +-+-+-+-+-+-+-+-+ |
+// | Compressed frame 1 (N-1 bytes)... :
+// : |
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ header->frame_lengths0 = data_length - header->size;
+ }
+ header->packet_size = header->size + header->frame_lengths0;
+ } else if (header->TOC_code == 1) {
+ header->nb_frames = 2;
+ if (self_delimited) {
+ nb_read_bytes = gf_opus_read_length(data, data_length, header->size, &header->self_delimited_length);
+ if (nb_read_bytes) {
+ header->size += nb_read_bytes;
+ } else {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Could not read self delimited length in Opus packet code 1\n"));
+ return 0;
+ }
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|0|1| N1 (1-2 bytes): |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ :
+// | Compressed frame 1 (N1 bytes)... |
+// : +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ :
+// | Compressed frame 2 (N1 bytes)... |
+// : +-+-+-+-+-+-+-+-+
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ header->frame_lengths0 = header->self_delimited_length;
+ header->frame_lengths1 = header->self_delimited_length;
+ } else {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|0|1| |
+// +-+-+-+-+-+-+-+-+ :
+// | Compressed frame 1 ((N-1)/2 bytes)... |
+// : +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ :
+// | Compressed frame 2 ((N-1)/2 bytes)... |
+// : +-+-+-+-+-+-+-+-+
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ if ((data_length-header->size) % 2) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Size of non-self-delimited Opus packet with code 2 must be even but is %d\n",data_length-header->size));
+ return 0;
+ }
+ header->frame_lengths0 = (data_length-header->size)/2;
+ header->frame_lengths1 = (data_length-header->size)/2;
+ }
+ header->packet_size = header->size + header->frame_lengths0 + header->frame_lengths1;
+ } else if (header->TOC_code == 2) {
+ header->nb_frames = 2;
+ if (self_delimited) {
+ nb_read_bytes = gf_opus_read_length(data, data_length, header->size, &header->self_delimited_length);
+ if (nb_read_bytes) {
+ header->size += nb_read_bytes;
+ } else {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Could not read self delimited length in Opus packet code 2\n"));
+ return 0;
+ }
+ }
+ nb_read_bytes = gf_opus_read_length(data, data_length, header->size, &header->code2_frame_length);
+ if (nb_read_bytes) {
+ header->size += nb_read_bytes;
+ } else {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Could not read frame length in Opus packet code 2\n"));
+ return 0;
+ }
+ if (self_delimited) {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|1|0| N1 (1-2 bytes): N2 (1-2 bytes : |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ :
+// | Compressed frame 1 (N1 bytes)... |
+// : +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
+// | Compressed frame 2 (N2 bytes)... :
+// : |
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ header->frame_lengths0 = header->self_delimited_length;
+ header->frame_lengths1 = header->code2_frame_length;
+ } else {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|1|0| N1 (1-2 bytes): |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ :
+// | Compressed frame 1 (N1 bytes)... |
+// : +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
+// | Compressed frame 2... :
+// : |
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ header->frame_lengths0 = header->code2_frame_length;
+ header->frame_lengths1 = data_length - header->size - header->code2_frame_length;
+ }
+ header->packet_size = header->size + header->frame_lengths0 + header->frame_lengths1;
+ } else if (header->TOC_code == 3) {
+ u32 sum = 0;
+ if (data_length <= header->size) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Not enough data to parse TOC code 3 data\n"));
+ return 0;
+ }
+ header->code3_vbr = (dataheader->size & 0x80) >> 7;
+ header->code3_padding = (dataheader->size & 0x40) >> 6;
+ header->nb_frames = dataheader->size & 0x3f;
+ header->size++;
+ if (header->code3_padding) {
+ if (data_length <= header->size) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Not enough data to parse TOC code 3 padding length\n"));
+ return 0;
+ }
+ if (dataheader->size == 255) {
+ header->code3_padding_length = 254 + dataheader->size+1;
+ header->size += 2;
+ } else {
+ header->code3_padding_length = dataheader->size;
+ header->size++;
+ }
+ } else {
+ header->code3_padding_length = 0;
+ }
+ if (self_delimited) {
+ nb_read_bytes = gf_opus_read_length(data, data_length, header->size, &header->self_delimited_length);
+ if (nb_read_bytes) {
+ header->size += nb_read_bytes;
+ } else {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Could not read self delimited length in Opus packet code 3\n"));
+ return 0;
+ }
+ }
+ if (header->code3_vbr) {
+ u32 max;
+ u32 min;
+ if (self_delimited) {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|1|1|1|p| M | Padding length (Optional) :
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// : N1 (1-2 bytes): ... : NM-1 | NM :
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 1 (N1 bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 2 (N2 bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : ... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame M (NM bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// : Opus Padding (Optional)... |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ header->frame_lengths0 = header->self_delimited_length;
+ min = 1;
+ max = header->nb_frames;
+ sum += header->frame_lengths0;
+ } else {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|1|1|1|p| M | Padding length (Optional) :
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// : N1 (1-2 bytes): N2 (1-2 bytes): ... : NM-1 |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 1 (N1 bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 2 (N2 bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : ... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame M... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// : Opus Padding (Optional)... |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ min = 0;
+ max = header->nb_frames-1;
+ }
+ for (i = min; i < max; i++) {
+ if (data_length <= header->size) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Not enough data to parse TOC code 3 length\n"));
+ return 0;
+ }
+ nb_read_bytes = gf_opus_read_length(data, data_length, header->size, &(header->frame_lengthsi));
+ if (nb_read_bytes) {
+ header->size += nb_read_bytes;
+ } else {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Could not read frame length in Opus packet code 3\n"));
+ return 0;
+ }
+ sum += header->frame_lengthsi;
+ }
+ if (!self_delimited) {
+ header->frame_lengthsheader->nb_frames-1 = data_length - header->size - header->code3_padding_length - sum;
+ sum += header->frame_lengthsheader->nb_frames-1;
+ }
+ } else {
+ u32 cbr_length;
+ if (self_delimited) {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|1|1|0|p| M | Pad len (Opt) : N1 (1-2 bytes):
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 1 (N1 bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 2 (N1 bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : ... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame M (N1 bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// : Opus Padding (Optional)... |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ cbr_length = header->self_delimited_length;
+ } else {
+// 0 1 2 3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | config |s|1|1|0|p| M | Padding length (Optional) :
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 1 (R/M bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame 2 (R/M bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : ... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | |
+// : Compressed frame M (R/M bytes)... :
+// | |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// : Opus Padding (Optional)... |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ if ((data_length - header->size - header->code3_padding_length) % header->nb_frames) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("Sum of frame lengths is not a multiple of the number of frames\n"));
+ return 0;
+ }
+ cbr_length = (data_length - header->size - header->code3_padding_length)/header->nb_frames;
+ }
+ for (i = 0; i < header->nb_frames; i++) {
+ header->frame_lengthsi = cbr_length;
+ sum += header->frame_lengthsi;
+ }
+ }
+ header->packet_size = header->size + header->code3_padding_length + sum;
+ }
+ return 1;
+}
 
 u64 gf_mpegh_escaped_value(GF_BitStream *bs, u32 nBits1, u32 nBits2, u32 nBits3)
 {
@@ -9550,9 +10249,6 @@
 	return PL;
 }
 
-
-#ifndef GPAC_DISABLE_AV_PARSERS
-
 GF_EXPORT
 void gf_vvc_parse_sei(char *buffer, u32 nal_size, VVCState *vvc)
 {
@@ -9644,8 +10340,9 @@
 		vps->state = 1;
 	}
 	vps->max_layers = 1 + gf_bs_read_int_log(bs, 6, "max_layers");
-	if (vps->max_layers > MAX_LHVC_LAYERS) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("VVC sorry, %d layers in VPS but only %d supported\n", vps->max_layers, MAX_LHVC_LAYERS));
+	if (vps->max_layers > VVC_MAX_LAYERS) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("VVC %d layers in VPS but only %d supported in GPAC\n", vps->max_layers, VVC_MAX_LAYERS));
+		vps->max_layers = VVC_MAX_LAYERS;
 		return -1;
 	}
 	vps->max_sub_layers = gf_bs_read_int_log(bs, 3, "max_sub_layers_minus1") + 1;
@@ -9710,6 +10407,10 @@
 	}
 
 	//TODO, parse multilayer stuff
+
+
+	if (gf_bs_is_overflow(bs))
+		return -1;
 	return vps_id;
 }
 
@@ -10046,6 +10747,7 @@
 	for (i=0; i<sps_rpl1_same_as_rpl0; i++) {
 		u32 j;
 		sps->num_ref_pic_listsi = gf_bs_read_ue_log_idx(bs, "sps_num_ref_pic_lists", i);
+		if (sps->num_ref_pic_listsi > 64) return -1;
 		for (j=0; j<sps->num_ref_pic_listsi; j++) {
 			s32 res = vvc_parse_ref_pic_list_struct(bs, sps, i, j, &sps->rpsij);
 			if (res<0) return res;
@@ -10213,6 +10915,9 @@
 		//WE DON'T PARSE vui_payload_bit_equal_to_one because we dont parse the rest (sps extensions)
 		//if needed, see rewrite_vui code
 	}
+
+	if (gf_bs_is_overflow(bs))
+		return -1;
 	return sps_id;
 }
 
@@ -10282,6 +10987,17 @@
 		u32 num_exp_tile_columns = 1 + gf_bs_read_ue_log(bs, "num_exp_tile_columns_minus1");
 		u32 num_exp_tile_rows = 1 + gf_bs_read_ue_log(bs, "num_exp_tile_rows_minus1");
 
+		if (num_exp_tile_columns > VVC_MAX_TILE_COLS) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("VVC wrong num tile columns %d in PPS\n", num_exp_tile_columns));
+			pps->sps_id=0;
+			return -1;
+		}
+		if (num_exp_tile_rows > VVC_MAX_TILE_ROWS) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("VVC wrong num tile rows %d in PPS\n", num_exp_tile_rows));
+			pps->sps_id=0;
+			return -1;
+		}
+
 		ctu_size = 1<<ctu_size;
 		pps->pic_width_in_ctbsY = pps->width / ctu_size;
 		if (pps->pic_width_in_ctbsY * ctu_size < pps->width) pps->pic_width_in_ctbsY++;
@@ -10293,18 +11009,34 @@
 		u32 nb_ctb_last=0;
 		for (i=0; i<num_exp_tile_columns; i++) {
 			u32 nb_ctb_width = 1 + gf_bs_read_ue_log_idx(bs, "tile_column_width_minus1", i);
+			if (nb_ctb_left < nb_ctb_width) {
+				pps->sps_id=0;
+				return -1;
+			}
 			nb_ctb_left -= nb_ctb_width;
 			pps->tile_cols_width_ctbi = nb_ctb_width;
 			nb_ctb_last = nb_ctb_width;
 			pps->num_tile_cols++;
+			if (pps->num_tile_cols > VVC_MAX_TILE_COLS) {
+				pps->sps_id=0;
+				return -1;
+			}
 		}
 		u32 uni_size_ctb = nb_ctb_last;
 		while (nb_ctb_left >= uni_size_ctb) {
 			nb_ctb_left -= uni_size_ctb;
+			if (pps->num_tile_cols >= VVC_MAX_TILE_COLS) {
+				pps->sps_id=0;
+				return -1;
+			}
 			pps->tile_cols_width_ctbpps->num_tile_cols = uni_size_ctb;
 			pps->num_tile_cols++;
 		}
 		if (nb_ctb_left>0) {
+			if (pps->num_tile_cols >= VVC_MAX_TILE_COLS) {
+				pps->sps_id=0;
+				return -1;
+			}
 			pps->tile_cols_width_ctbpps->num_tile_cols = nb_ctb_left;
 			pps->num_tile_cols++;
 		}
@@ -10314,18 +11046,34 @@
 		pps->num_tile_rows=0;
 		for (i=0; i<num_exp_tile_rows; i++) {
 			u32 nb_ctb_height = 1 + gf_bs_read_ue_log_idx(bs, "tile_row_height_minus1", i);
+			if (nb_ctb_left < nb_ctb_height) {
+				pps->sps_id=0;
+				return -1;
+			}
 			nb_ctb_left -= nb_ctb_height;
 			pps->tile_rows_height_ctbi = nb_ctb_height;
 			pps->num_tile_rows++;
 			nb_ctb_last = nb_ctb_height;
+			if (pps->num_tile_rows > VVC_MAX_TILE_ROWS) {
+				pps->sps_id=0;
+				return -1;
+			}
 		}
 		uni_size_ctb = nb_ctb_last;
 		while (nb_ctb_left >= uni_size_ctb) {
 			nb_ctb_left -= uni_size_ctb;
+			if (pps->num_tile_rows >= VVC_MAX_TILE_ROWS) {
+				pps->sps_id=0;
+				return -1;
+			}
 			pps->tile_rows_height_ctbpps->num_tile_rows = uni_size_ctb;
 			pps->num_tile_rows++;
 		}
 		if (nb_ctb_left>0) {
+			if (pps->num_tile_rows >= VVC_MAX_TILE_ROWS) {
+				pps->sps_id=0;
+				return -1;
+			}
 			pps->tile_rows_height_ctbpps->num_tile_rows = nb_ctb_left;
 			pps->num_tile_rows++;
 		}
@@ -10463,6 +11211,9 @@
 		//while ( more_rbsp_data()) bit(1);
 	}
 	//rbsp_trailing_bits()
+
+	if (gf_bs_is_overflow(bs))
+		return -1;
 	return pps_id;
 }
 
@@ -11460,7 +12211,7 @@
 			bit_offset--;
 		}
 
-		avc_hevc_vvc_rewrite_vui(vui_info, orig, mod, GF_TRUE);
+		avc_hevc_vvc_rewrite_vui(vui_info, orig, mod, GF_CODECID_VVC);
 
 		/*finally copy over remaining*/
 		while (gf_bs_bits_available(orig)) {
@@ -11583,4 +12334,53 @@
 		return "Unknown";
 	}
 }
+
+
+GF_Err gf_media_vc1_seq_header_to_dsi(const u8 *seq_hdr, u32 seq_hdr_len, u8 **dsi, u32 *dsi_size)
+{
+	GF_BitStream *bs;
+	u8 level=0, interlace=0;
+	u8 profile=12;
+	u8 *sqhdr = memchr(seq_hdr+1, 0x0F, seq_hdr_len);
+	if (sqhdr) {
+		u32 skip = (u32) (sqhdr - seq_hdr - 3);
+		seq_hdr+=skip;
+		seq_hdr_len-=skip;
+		bs = gf_bs_new(seq_hdr+4, seq_hdr_len-4, GF_BITSTREAM_READ);
+		profile = gf_bs_read_int(bs, 2);
+		if (profile==3) {
+			level = gf_bs_read_int(bs, 3);
+			/*cfmt*/gf_bs_read_int(bs, 2);
+			/*fps*/gf_bs_read_int(bs, 3);
+			/*btrt*/gf_bs_read_int(bs, 5);
+			gf_bs_read_int(bs, 1);
+			/*mw*/gf_bs_read_int(bs, 12);
+			/*mh*/gf_bs_read_int(bs, 12);
+			/*bcast*/gf_bs_read_int(bs, 1);
+			interlace = gf_bs_read_int(bs, 1);
+		}
+		gf_bs_del(bs);
+	}
+	*dsi_size = seq_hdr_len+7;
+	*dsi = gf_malloc(seq_hdr_len+7);
+	if (! (*dsi) ) return GF_OUT_OF_MEM;
+
+	bs = gf_bs_new(*dsi, *dsi_size, GF_BITSTREAM_WRITE);
+	gf_bs_write_int(bs, 12, 4); //profile
+	gf_bs_write_int(bs, level, 3); //level
+	gf_bs_write_int(bs, 0, 1); //reserved
+	gf_bs_write_int(bs, level, 3); //level
+	gf_bs_write_int(bs, 0, 1); //cbr
+	gf_bs_write_int(bs, 0, 6); //reserved
+	gf_bs_write_int(bs, !interlace, 1); //no interlace
+	gf_bs_write_int(bs, 1, 1); //no multiple seq
+	gf_bs_write_int(bs, 1, 1); //no multiple entry
+	gf_bs_write_int(bs, 1, 1); //no slice present
+	gf_bs_write_int(bs, 0, 1); //no b-frames
+	gf_bs_write_int(bs, 0, 1); //reserved
+	gf_bs_write_u32(bs, 0xFFFFFFFF); //framerate
+	gf_bs_write_data(bs, seq_hdr, seq_hdr_len); //VOS
+	gf_bs_del(bs);
+	return GF_OK;
+}
 #endif /*GPAC_DISABLE_AV_PARSERS*/

gpac-2.0.0.tar.gz/src/media_tools/avilib.c -> gpac-2.2.0.tar.gz/src/media_tools/avilib.c Changed

@@ -1884,8 +1884,8 @@
 
 int avi_parse_input_file(avi_t *AVI, int getIndex)
 {
-	int i, rate, scale, idx_type;
-	s64 n;
+	int rate, scale, idx_type;
+	s64 n, i;
 	unsigned char *hdrl_data;
 	u64 header_offset=0;
 	int hdrl_len=0;
@@ -1939,6 +1939,7 @@
 				n -= 4;
 			if(strnicmp(data,"hdrl",4) == 0)
 			{
+				if (n>0xFFFFFFFF) ERR_EXIT(AVI_ERR_READ)
 				hdrl_len = (u32) n;
 				hdrl_data = (unsigned char *) gf_malloc((u32)n);
 				if(hdrl_data==0) ERR_EXIT(AVI_ERR_NO_MEM);
@@ -2091,8 +2092,10 @@
 						AVI->compressor24 = 0;
 
 						if (n>40) {
+							if (n>0xFFFFFFFF) ERR_EXIT(AVI_ERR_READ)
 							AVI->extradata_size = (u32) (n - 40);
 							AVI->extradata = gf_malloc(sizeof(u8)* AVI->extradata_size);
+							if (!AVI->extradata) ERR_EXIT(AVI_ERR_NO_MEM)
 							memcpy(AVI->extradata, hdrl_data + i + 40, AVI->extradata_size);
 						}
 
@@ -2104,7 +2107,7 @@
 						int wfes;
 
 						if ((u32) (hdrl_len - i) < sizeof(alWAVEFORMATEX))
-							wfes = hdrl_len - i;
+							wfes = (int) (hdrl_len - i);
 						else
 							wfes = sizeof(alWAVEFORMATEX);
 						wfe = (alWAVEFORMATEX *)gf_malloc(sizeof(alWAVEFORMATEX));

gpac-2.0.0.tar.gz/src/media_tools/crypt_tools.c -> gpac-2.2.0.tar.gz/src/media_tools/crypt_tools.c Changed

@@ -219,10 +219,10 @@
 				else
 					tkc->IsEncrypted = 0;
 			}
-			else if (!stricmp(att->name, "IV_size")) {
+			else if (!stricmp(att->name, "IV_size") && (tkc->scheme_type != GF_CRYPT_TYPE_CBCS)) {
 				tkc->keys0.IV_size = atoi(att->value);
 			}
-			else if (!stricmp(att->name, "first_IV")) {
+			else if (!stricmp(att->name, "first_IV") && (tkc->scheme_type != GF_CRYPT_TYPE_CBCS)) {
 				char *sKey = att->value;
 				if (!strnicmp(sKey, "0x", 2)) sKey += 2;
 				if ((strlen(sKey) == 16) || (strlen(sKey) == 32)) {
@@ -280,7 +280,7 @@
 				}
 			}
 			else if (!stricmp(att->name, "metadata")) {
-				u32 l = 2 * (u32) strlen(att->value);
+				u32 l = 2 * (u32) strlen(att->value) + 3;
 				tkc->metadata = gf_malloc(sizeof(char) * l);
 				l = gf_base64_encode(att->value, (u32) strlen(att->value), tkc->metadata, l);
 				tkc->metadatal = 0;
@@ -294,13 +294,17 @@
 			else if (!stricmp(att->name, "clear_bytes")) {
 				tkc->clear_bytes = atoi(att->value);
 			}
-			else if (!stricmp(att->name, "constant_IV_size")) {
+			else if (!stricmp(att->name, "constant_IV_size")
+				|| (!stricmp(att->name, "IV_size") && (tkc->scheme_type == GF_CRYPT_TYPE_CBCS))
+			) {
 				tkc->keys0.constant_IV_size = atoi(att->value);
 				if ((tkc->keys0.constant_IV_size != 8) && (tkc->keys0.constant_IV_size != 16)) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("CENC Constant IV size %d is not 8 or 16\n", att->value));
 				}
 			}
-			else if (!stricmp(att->name, "constant_IV")) {
+			else if (!stricmp(att->name, "constant_IV")
+				|| (!stricmp(att->name, "first_IV") && (tkc->scheme_type == GF_CRYPT_TYPE_CBCS))
+			) {
 				char *sKey = att->value;
 				if (!strnicmp(sKey, "0x", 2)) sKey += 2;
 				if ((strlen(sKey) == 16) || (strlen(sKey) == 32)) {

gpac-2.0.0.tar.gz/src/media_tools/dash_client.c -> gpac-2.2.0.tar.gz/src/media_tools/dash_client.c Changed

@@ -154,10 +154,12 @@
 
 	Bool ignore_xlink;
 
+	s32 suggested_presentation_delay;
+
 	//0: not ROUTE - 1: ROUTE but clock not init - 2: ROUTE clock init
 	u32 route_clock_state;
 	//ROUTE AST shift in ms
-	u32 route_ast_shift;
+	s32 route_ast_shift;
 	u32 route_skip_segments_ms;
 Bool route_low_latency;
 	u32 route_last_retune;
@@ -229,6 +231,7 @@
 	char *key_url;
 	bin128 key_IV;
 	u32 seg_number;
+	u64 utc_map;
 	const char *seg_name_start;
 	GF_Fraction64 time;
 
@@ -346,9 +349,10 @@
 
 	/* maximum representation index we want to download*/
 	u32 max_complementary_rep_index;
-	//start time and timescales of currently downloaded segment
+	//MPD start time, timescale and PTO of currently downloaded segment
 	u64 current_start_time;
 	u32 current_timescale;
+	u64 current_pto;
 
 	void *udta;
 
@@ -905,6 +909,14 @@
 		availabilityStartTime = mpd->availabilityStartTime + group->dash->utc_shift + group->dash->utc_drift_estimate;
 	}
 
+	if (group->dash->mpd->suggested_presentation_delay || group->dash->suggested_presentation_delay) {
+		s32 spd = 0;
+		if (group->dash->suggested_presentation_delay != GF_INT_MIN)
+			spd = group->dash->suggested_presentation_delay + group->dash->mpd->suggested_presentation_delay;
+
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("DASH Applying suggested presentation delay of %ums\n", spd));
+		availabilityStartTime += spd;
+	}
 
 #ifdef FORCE_DESYNC
 	availabilityStartTime -= FORCE_DESYNC;
@@ -1020,6 +1032,7 @@
 
 	timeline = NULL;
 	timescale=1;
+	u64 rep_pto = 0;
 	start_number=0;
 	rep = gf_list_get(group->adaptation_set->representations, group->active_rep_index);
 
@@ -1028,18 +1041,21 @@
 		if (group->period->segment_list->timescale) timescale = group->period->segment_list->timescale;
 		if (group->period->segment_list->start_number) start_number = group->period->segment_list->start_number;
 		if (group->period->segment_list->availability_time_offset) ast_offset = group->period->segment_list->availability_time_offset;
+		if (group->period->segment_list->presentation_time_offset) rep_pto = group->period->segment_list->presentation_time_offset;
 	}
 	if (group->adaptation_set->segment_list) {
 		if (group->adaptation_set->segment_list->segment_timeline) timeline = group->adaptation_set->segment_list->segment_timeline;
 		if (group->adaptation_set->segment_list->timescale) timescale = group->adaptation_set->segment_list->timescale;
 		if (group->adaptation_set->segment_list->start_number) start_number = group->adaptation_set->segment_list->start_number;
 		if (group->adaptation_set->segment_list->availability_time_offset) ast_offset = group->adaptation_set->segment_list->availability_time_offset;
+		if (group->adaptation_set->segment_list->presentation_time_offset) rep_pto = group->adaptation_set->segment_list->presentation_time_offset;
 	}
 	if (rep->segment_list) {
 		if (rep->segment_list->segment_timeline) timeline = rep->segment_list->segment_timeline;
 		if (rep->segment_list->timescale) timescale = rep->segment_list->timescale;
 		if (rep->segment_list->start_number) start_number = rep->segment_list->start_number;
 		if (rep->segment_list->availability_time_offset) ast_offset = rep->segment_list->availability_time_offset;
+		if (rep->segment_list->presentation_time_offset) rep_pto = rep->segment_list->presentation_time_offset;
 	}
 
 	if (group->period->segment_template) {
@@ -1047,18 +1063,21 @@
 		if (group->period->segment_template->timescale) timescale = group->period->segment_template->timescale;
 		if (group->period->segment_template->start_number) start_number = group->period->segment_template->start_number;
 		if (group->period->segment_template->availability_time_offset) ast_offset = group->period->segment_template->availability_time_offset;
+		if (group->period->segment_template->presentation_time_offset) rep_pto = group->period->segment_template->presentation_time_offset;
 	}
 	if (group->adaptation_set->segment_template) {
 		if (group->adaptation_set->segment_template->segment_timeline) timeline = group->adaptation_set->segment_template->segment_timeline;
 		if (group->adaptation_set->segment_template->timescale) timescale = group->adaptation_set->segment_template->timescale;
 		if (group->adaptation_set->segment_template->start_number) start_number = group->adaptation_set->segment_template->start_number;
 		if (group->adaptation_set->segment_template->availability_time_offset) ast_offset = group->adaptation_set->segment_template->availability_time_offset;
+		if (group->adaptation_set->segment_template->presentation_time_offset) rep_pto = group->adaptation_set->segment_template->presentation_time_offset;
 	}
 	if (rep->segment_template) {
 		if (rep->segment_template->segment_timeline) timeline = rep->segment_template->segment_timeline;
 		if (rep->segment_template->timescale) timescale = rep->segment_template->timescale;
 		if (rep->segment_template->start_number) start_number = rep->segment_template->start_number;
 		if (rep->segment_template->availability_time_offset) ast_offset = rep->segment_template->availability_time_offset;
+		if (rep->segment_template->presentation_time_offset) rep_pto = rep->segment_template->presentation_time_offset;
 	}
 	if (start_number==(u32) -1)
 		start_number = 1;
@@ -1081,6 +1100,8 @@
 		current_time_rescale = current_time;
 		current_time_rescale *= timescale;
 		current_time_rescale /= 1000;
+		//warning, MPD time in SegmentTimeline is (t-pto), so add pto to current time rescaled before comaring to t@s
+		current_time_rescale += rep_pto;
 
 		count = gf_list_count(timeline->entries);
 		for (i=0; i<count; i++) {
@@ -1104,6 +1125,7 @@
 			group->dash->mpd->minimum_update_period = (u32) last_s_dur;
 		}
 
+		u32 segdur_in_timeline=0;
 		for (i=0; i<count; i++) {
 			u32 repeat;
 			GF_MPD_SegmentTimelineEntry *ent = gf_list_get(timeline->entries, i);
@@ -1115,7 +1137,7 @@
 					GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("DASH current time "LLU" is before start time "LLU" of first segment in timeline (timescale %d) by %g sec - using first segment as starting point\n", current_time_rescale, segtime, timescale, (segtime-current_time_rescale)*1.0/timescale));
 					group->download_segment_index = seg_idx;
 					group->nb_segments_in_rep = count;
-					group->start_playback_range = (segtime)*1.0/timescale;
+					group->start_playback_range = 0;
 					group->ast_at_init = availabilityStartTime;
 					group->ast_offset = (u32) (ast_offset*1000);
 					group->broken_timing = GF_TRUE;
@@ -1130,7 +1152,7 @@
 
 					group->download_segment_index = seg_idx;
 					group->nb_segments_in_rep = seg_idx + count - i;
-					group->start_playback_range = (current_time)/1000.0;
+					group->start_playback_range = (current_time)/1000.0 - ((Double)segdur_in_timeline)/timescale;
 					group->ast_at_init = availabilityStartTime;
 					group->ast_offset = (u32) (ast_offset*1000);
 
@@ -1144,6 +1166,7 @@
 				repeat--;
 				seg_idx++;
 				last_s_dur=ent->duration;
+				segdur_in_timeline += ent->duration;
 			}
 		}
 		//check if we're ahead of time but "reasonnably" ahead (max 1 min) - otherwise consider the timing is broken
@@ -1641,7 +1664,7 @@
 }
 
 
-static u64 gf_dash_get_segment_start_time_with_timescale(GF_DASH_Group *group, u64 *segment_duration, u32 *scale)
+static u64 gf_dash_get_segment_start_time_with_timescale(GF_DASH_Group *group, u64 *segment_duration, u32 *scale, u64 *current_pto)
 {
 	GF_MPD_Representation *rep = gf_list_get(group->adaptation_set->representations, group->active_rep_index);
 	GF_MPD_AdaptationSet *set = group->adaptation_set;
@@ -1653,6 +1676,35 @@
 		period, set, rep,
 		&start_time, segment_duration, scale);
 
+	if (current_pto) {
+		u32 pto_ts=1;
+		if (period->segment_list && period->segment_list->presentation_time_offset) {
+			*current_pto = period->segment_list->presentation_time_offset;
+			pto_ts = period->segment_list->timescale;
+		}
+		if (set->segment_list && set->segment_list->presentation_time_offset) {
+			*current_pto = set->segment_list->presentation_time_offset;
+			pto_ts = set->segment_list->timescale;
+		}
+		if (rep->segment_list && rep->segment_list->presentation_time_offset) {
+			*current_pto = rep->segment_list->presentation_time_offset;
+			pto_ts = rep->segment_list->timescale;
+		}
+		if (period->segment_template && period->segment_template->presentation_time_offset) {
+			*current_pto = period->segment_template->presentation_time_offset;
+			pto_ts = period->segment_template->timescale;
+		}
+		if (set->segment_template && set->segment_template->presentation_time_offset) {
+			*current_pto = set->segment_template->presentation_time_offset;
+			pto_ts = set->segment_template->timescale;
+		}
+		if (rep->segment_template && rep->segment_template->presentation_time_offset) {
+			*current_pto = rep->segment_template->presentation_time_offset;
+			pto_ts = rep->segment_template->timescale;
+		}
+		if (scale)
+			*current_pto = gf_timestamp_rescale(*current_pto, pto_ts, *scale);
+	}
 	return start_time;
 }
 
@@ -1662,7 +1714,7 @@
 	u64 dur = 0;
 	u32 scale = 1000;
 
-	start = gf_dash_get_segment_start_time_with_timescale(group, &dur, &scale);
+	start = gf_dash_get_segment_start_time_with_timescale(group, &dur, &scale, NULL);
 	if (segment_duration) {
 		*segment_duration = (Double) dur;
 		*segment_duration /= scale;
@@ -1756,11 +1808,11 @@
 	if (!old_timeline && !new_timeline) return GF_OK;
 
 	if (group) {
-		group->current_start_time = gf_dash_get_segment_start_time_with_timescale(group, NULL, &group->current_timescale);
+		group->current_start_time = gf_dash_get_segment_start_time_with_timescale(group, NULL, &group->current_timescale, &group->current_pto);
 	} else {
 		for (i=0; i<gf_list_count(dash->groups); i++) {
 			GF_DASH_Group *a_group = gf_list_get(dash->groups, i);
-			a_group->current_start_time = gf_dash_get_segment_start_time_with_timescale(a_group, NULL, &a_group->current_timescale);
+			a_group->current_start_time = gf_dash_get_segment_start_time_with_timescale(a_group, NULL, &a_group->current_timescale, &group->current_pto);
 		}
 	}
 
@@ -1775,7 +1827,7 @@
 		u32 prev_idx = group->download_segment_index;
 #endif
 		group->nb_segments_in_rep = nb_new_segs;
-		group->download_segment_index = gf_dash_get_index_in_timeline(new_timeline, group->current_start_time, group->current_timescale, timescale ? timescale : group->current_timescale);
+		group->download_segment_index = gf_dash_get_index_in_timeline(new_timeline, group->current_start_time+group->current_pto, group->current_timescale, timescale ? timescale : group->current_timescale);
 
 		GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("DASH Updated SegmentTimeline: New segment number %d - old %d - start time "LLD"\n", group->download_segment_index , prev_idx, group->current_start_time));
 	} else {
@@ -1785,7 +1837,7 @@
 			u32 prev_idx = a_group->download_segment_index;
 #endif
 			a_group->nb_segments_in_rep = nb_new_segs;
-			a_group->download_segment_index = gf_dash_get_index_in_timeline(new_timeline, a_group->current_start_time, a_group->current_timescale, timescale ? timescale : a_group->current_timescale);
+			a_group->download_segment_index = gf_dash_get_index_in_timeline(new_timeline, a_group->current_start_time+a_group->current_pto, a_group->current_timescale, timescale ? timescale : a_group->current_timescale);
 
 			GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("DASH Updated SegmentTimeline: New segment number %d - old %d - start time "LLD"\n", a_group->download_segment_index , prev_idx, a_group->current_start_time));
 		}
@@ -3161,9 +3213,9 @@
 		if (s->hls_ll_chunk_type == 1)
 			continue;
 		if (tsb_depth > timeshift) {
-			group->download_segment_index = i-1;
 			break;
 		}
+		group->download_segment_index = i-1;
 	}
 }
 
@@ -4422,6 +4474,12 @@
 		return;
 	}
 	group->rate_adaptation_postponed = GF_FALSE;
+	if (base_group->disabled) {
+		if (new_index!=-2) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("DASH base group disabled but group is not disabled by algo, forcing disabling\n"));
+			new_index = -2;
+		}
+	}
 	if (new_index < 0) {
 		if (new_index == -2) {
 			group->disabled = GF_TRUE;
@@ -4959,6 +5017,8 @@
 
 		seg_dur = 0;
 		nb_dependent_rep = 0;
+		u32 first_w=0, first_h=0;
+		Bool check_bs_switch = GF_FALSE;
 		for (j=0; j<gf_list_count(set->representations); j++) {
 			Double dur;
 			u32 nb_seg, k;
@@ -4972,6 +5032,23 @@
 				GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("DASH bitstreamSwitching set for onDemand content - ignoring flag\n"));
 			}
 
+			if (!j) {
+				first_w = rep->width;
+				first_h = rep->height;
+				if (rep->codecs) {
+					//for hvc1 and avc1 check we have the same with/height. If not consider MPD broken and force no bitstream switching
+					if (!strncmp(rep->codecs, "avc1", 4) || !strncmp(rep->codecs, "hvc1", 4)) {
+						check_bs_switch = GF_TRUE;
+					}
+				}
+			} else if (check_bs_switch && group->bitstream_switching) {
+				if ((first_w != rep->width) || (first_h != rep->height)) {
+					group->bitstream_switching = GF_FALSE;
+					GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("DASH bitstreamSwitching set, no inband params and different width/height detected - ignoring flag\n"));
+				}
+			}
+
+
 			if (dash->dash_io->dash_codec_supported) {
 				Bool res = dash->dash_io->dash_codec_supported(dash->dash_io, rep->codecs, rep->width, rep->height, (rep->scan_type==GF_MPD_SCANTYPE_INTERLACED) ? 1 : 0, rep->framerate ? rep->framerate->num : 0, rep->framerate ? rep->framerate->den : 0, rep->samplerate);
 				if (!res) {
@@ -5470,7 +5547,6 @@
 
 				cache_name = group->dash->dash_io->get_cache_name(group->dash->dash_io, *download_sess);
 				if (init_in_base) {
-					char szName100;
 					GF_SAFEALLOC(rep->segment_list->initialization_segment, GF_MPD_URL);
 					if (!rep->segment_list->initialization_segment) {
 						e = GF_OUT_OF_MEM;
@@ -5494,8 +5570,7 @@
 						rep->playback.init_segment.data = gf_malloc(sizeof(char) * rep->playback.init_segment.size);
 						memcpy(rep->playback.init_segment.data, mem_address, sizeof(char) * rep->playback.init_segment.size);
 
-						sprintf(szName, "gmem://%p", &rep->playback.init_segment);
-						rep->segment_list->initialization_segment->sourceURL = gf_strdup(szName);
+						rep->segment_list->initialization_segment->sourceURL = gf_blob_register(&rep->playback.init_segment);
 						rep->segment_list->initialization_segment->is_resolved = GF_TRUE;
 gf_blob_release(cache_name);
 					} else {
@@ -5509,8 +5584,7 @@
 							if (res != rep->playback.init_segment.size) {
 								GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("DASH Failed to store init segment\n"));
 							} else if (rep->segment_list && rep->segment_list->initialization_segment) {
-								sprintf(szName, "gmem://%p", &rep->playback.init_segment);
-								rep->segment_list->initialization_segment->sourceURL = gf_strdup(szName);
+								rep->segment_list->initialization_segment->sourceURL = gf_blob_register(&rep->playback.init_segment);
 								rep->segment_list->initialization_segment->is_resolved = GF_TRUE;
 							}
 						}
@@ -6524,7 +6598,7 @@
 	char *new_base_seg_url=NULL;
 	char *key_url=NULL;
 	bin128 key_iv;
-	u64 start_range, end_range;
+	u64 start_range, end_range, seg_utc=0;
 	Bool use_byterange;
 	u32 llhls_live_edge_type=0;
 	u32 representation_index;
@@ -6657,10 +6731,12 @@
 					if (dash->mpd->minimum_update_period) {
 						if (now - group->time_at_first_reload_required < dash->mpd->minimum_update_period)
 							return GF_DASH_DownloadCancel;
-					} else if (dyn_type==GF_MPD_TYPE_DYNAMIC) {
-						//use group last modification time
+					}
+
+					//dyn mode, check group last modification time, if time elapsed less than 2 seg dur, wait
+					if (dyn_type==GF_MPD_TYPE_DYNAMIC) {
 						timer = now - group->last_mpd_change_time;
-						if (timer < 2 * group->segment_duration * 2000)
+						if (timer < 2 * group->segment_duration * 1000)
 							return GF_DASH_DownloadCancel;
 					}
 
@@ -6682,7 +6758,7 @@
 	group->time_at_first_reload_required = 0;
 
 	if (group->force_switch_bandwidth && !dash->auto_switch_count) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("DASH Forcing representation switch, retesting group"));
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("DASH Forcing representation switch, retesting group\n"));
 		gf_dash_switch_group_representation(dash, group);
 		/*restart*/
 		return GF_DASH_DownloadRestart;
@@ -6735,6 +6811,8 @@
 			if (group->last_segment_time) {
 				GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("DASH %d ms elapsed since previous segment download\n", clock_time - group->last_segment_time));
 			}
+
+			seg_utc = segment_ast;
 		}
 group->time_at_last_request = gf_sys_clock();
 }
@@ -6744,6 +6822,12 @@
 	/* At this stage, there are some segments left to be downloaded */
 	e = gf_dash_resolve_url(dash->mpd, rep, group, base_url, GF_MPD_RESOLVE_URL_MEDIA, group->download_segment_index, &new_base_seg_url, &start_range, &end_range, &group->current_downloaded_segment_duration, NULL, &key_url, &key_iv, NULL, &start_number);
 
+	if (dash->is_m3u8 && rep->segment_list && (dyn_type==GF_MPD_TYPE_DYNAMIC)) {
+		GF_MPD_SegmentURL *seg = gf_list_get(rep->segment_list->segment_URLs, group->download_segment_index);
+		if (seg) {
+			seg_utc = seg->hls_utc_time;
+		}
+	}
 
 	if ((e==GF_EOS)	&& group->llhls_edge_chunk && group->llhls_edge_chunk->hls_ll_chunk_type) {
 		//no more segments, force update now
@@ -6868,8 +6952,11 @@
 	cache_entry->flags = group->loop_detected ? SEG_FLAG_LOOP_DETECTED : 0;
 	cache_entry->dep_group_idx = group->depend_on_group ? group->depend_on_group->current_dep_idx : group->current_dep_idx;
 	if (has_dep_following) cache_entry->flags |= SEG_FLAG_DEP_FOLLOWING;
-	if (group->disabled)
+	if (group->disabled) {
 		cache_entry->flags |= SEG_FLAG_DISABLED;
+		//a group can only be disabled for the current segment, not doing so would trigger EOS if all groups are deactivated
+		group->disabled = GF_FALSE;
+	}
 	if (key_url) {
 		cache_entry->key_url = key_url;
 		memcpy(cache_entry->key_IV, key_iv, sizeof(bin128));
@@ -6877,9 +6964,9 @@
 		key_url = NULL;
 	}
 
-	cache_entry->time.num = gf_dash_get_segment_start_time_with_timescale(group, &seg_dur, &seg_scale);
+	cache_entry->time.num = gf_dash_get_segment_start_time_with_timescale(group, &seg_dur, &seg_scale, NULL);
 	cache_entry->time.den = seg_scale;
-
+	cache_entry->utc_map = seg_utc;
 	cache_entry->seg_number = group->download_segment_index + start_number;
 	cache_entry->seg_name_start = dash_strip_base_url(cache_entry->url, base_url);
 	group->loop_detected = GF_FALSE;
@@ -8623,6 +8710,73 @@
 	return rep->playback.key_url;
 }
 
+const char *gf_dash_group_get_clearkey_uri(GF_DashClient *dash, u32 group_idx, bin128 *default_kid)
+{
+	GF_MPD_Descriptor *desc_kid=NULL;
+	GF_MPD_Descriptor *desc_ck=NULL;
+	GF_MPD_Representation *rep;
+	GF_DASH_Group *group = gf_list_get(dash->groups, group_idx);
+	if (!group) return NULL;
+
+	u32 i, count = gf_list_count(group->adaptation_set->content_protection);
+	for (i=0; i<count; i++) {
+		GF_MPD_Descriptor *cp = gf_list_get(group->adaptation_set->content_protection, i);
+		if (!strcmp(cp->scheme_id_uri, "urn:mpeg:dash:mp4protection:2011")) desc_kid = cp;
+		if (!strcmp(cp->scheme_id_uri, "urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e")) desc_ck = cp;
+	}
+	rep = gf_list_get(group->adaptation_set->representations, group->active_rep_index);
+	if (!rep) return NULL;
+	count = gf_list_count(rep->content_protection);
+	for (i=0; i<count; i++) {
+		GF_MPD_Descriptor *cp = gf_list_get(rep->content_protection, i);
+		if (!strcmp(cp->scheme_id_uri, "urn:mpeg:dash:mp4protection:2011")) desc_kid = cp;
+		if (!strcmp(cp->scheme_id_uri, "urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e")) desc_ck = cp;
+	}
+
+	if (!desc_ck) return NULL;
+	if (desc_kid && default_kid) {
+		char *key_id=NULL;
+		count = gf_list_count(desc_kid->x_attributes);
+		for (i=0; i<count; i++) {
+			GF_XMLAttribute *att = gf_list_get(desc_kid->x_attributes, i);
+			if (strstr(att->name, "default_KID")) key_id = att->value;
+		}
+		u32 idx=0;
+		memset(*default_kid, 0, sizeof(bin128) );
+		while (key_id && key_id0) {
+			if (key_id0=='-') {
+				key_id++;
+				continue;
+			}
+			char c = key_id2;
+			key_id2 = 0;
+			u32 val;
+			sscanf(key_id, "%02x", &val);
+			 (*default_kid)idx = (u8) val;
+			key_id2 = c;
+			idx++;
+			key_id+=2;
+			if (idx==16) break;
+		}
+		if (idx!=16) return NULL;
+	}
+	count = gf_list_count(desc_ck->x_children);
+	for (i=0; i<count; i++) {
+		GF_XMLNode *n = gf_list_get(desc_ck->x_children, i);
+		if (!strcmp(n->name, "Laurl")) {
+			count = gf_list_count(n->content);
+			for (i=0; i<count; i++) {
+				GF_XMLNode *url = gf_list_get(n->content, i);
+				if (url->type==GF_XML_TEXT_TYPE) return url->name;
+			}
+			break;
+		}
+
+	}
+	return NULL;
+}
+
+
 Bool gf_dash_group_init_segment_is_media(GF_DashClient *dash, u32 idx)
 {
 	GF_DASH_Group *group = gf_list_get(dash->groups, idx);
@@ -8985,7 +9139,7 @@
 }
 
 GF_EXPORT
-GF_Err gf_dash_group_get_next_segment_location(GF_DashClient *dash, u32 idx, u32 dependent_representation_index, const char **url, u64 *start_range, u64 *end_range, s32 *switching_index, const char **switching_url, u64 *switching_start_range, u64 *switching_end_range, const char **original_url, Bool *has_next_segment, const char **key_url, bin128 *key_IV)
+GF_Err gf_dash_group_get_next_segment_location(GF_DashClient *dash, u32 idx, u32 dependent_representation_index, const char **url, u64 *start_range, u64 *end_range, s32 *switching_index, const char **switching_url, u64 *switching_start_range, u64 *switching_end_range, const char **original_url, Bool *has_next_segment, const char **key_url, bin128 *key_IV, u64 *utc)
 {
 	GF_DASH_Group *group;
 	u32 index;
@@ -8999,6 +9153,7 @@
 	if (original_url) *original_url = NULL;
 	if (switching_index) *switching_index = -1;
 	if (has_next_segment) *has_next_segment = GF_FALSE;
+	if (utc) *utc = 0;
 
 	group = gf_list_get(dash->groups, idx);
 
@@ -9053,6 +9208,7 @@
 	if (original_url) *original_url = group->cachedindex.url;
 	if (key_url) *key_url = group->cachedindex.key_url;
 	if (key_IV) memcpy((*key_IV), group->cachedindex.key_IV, sizeof(bin128));
+	if (utc) *utc = group->cachedindex.utc_map;
 
 	if (!group->base_rep_index_plus_one && (group->cachedindex.representation_index != group->prev_active_rep_index)) {
 		GF_MPD_Representation *rep = gf_list_get(group->adaptation_set->representations, group->cached0.representation_index);
@@ -9529,13 +9685,14 @@
 }
 
 GF_EXPORT
-char *gf_dash_group_get_template(GF_DashClient *dash, u32 idx, u32 *segment_timeline_timescale, const char **init_url)
+char *gf_dash_group_get_template(GF_DashClient *dash, u32 idx, u32 *segment_timeline_timescale, const char **init_url, const char **hls_variant)
 {
 	GF_DASH_Group *group = gf_list_get(dash->groups, idx);
 	GF_MPD_Representation *rep;
 	const char *tpl;
 	char *solved_template;
 	if (init_url) *init_url = NULL;
+	if (hls_variant) *hls_variant = NULL;
 	if (segment_timeline_timescale) *segment_timeline_timescale = 0;
 
 	if (!group) return NULL;
@@ -9579,6 +9736,11 @@
 		}
 		*init_url = init;
 	}
+	if (hls_variant && rep && rep->segment_list) {
+		*hls_variant = rep->segment_list->previous_xlink_href;
+		if (! *hls_variant)
+			*hls_variant = rep->segment_list->xlink_href;
+	}
 
 	if (tpl) {
 		u64 range_start, range_end, segment_duration_in_ms;
@@ -9928,7 +10090,13 @@
 }
 
 GF_EXPORT
-void gf_dash_set_route_ast_shift(GF_DashClient *dash, u32 ast_shift)
+void gf_dash_set_suggested_presentation_delay(GF_DashClient *dash, s32 spd)
+{
+	dash->suggested_presentation_delay = spd;
+}
+
+GF_EXPORT
+void gf_dash_set_route_ast_shift(GF_DashClient *dash, s32 ast_shift)
 {
 	dash->route_ast_shift = ast_shift;
 }

gpac-2.0.0.tar.gz/src/media_tools/dash_segmenter.c -> gpac-2.2.0.tar.gz/src/media_tools/dash_segmenter.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre , Cyril Concolato
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Media Tools sub-project
@@ -160,7 +160,7 @@
 {
 	gf_list_reset(dasher->inputs);
 	if (dasher->fsess) {
-		gf_fs_print_unused_args(dasher->fsess, "smode");
+		gf_fs_print_unused_args(dasher->fsess, "smode,tkid");
 		gf_fs_del(dasher->fsess);
 		dasher->fsess = NULL;
 	}
@@ -525,7 +525,7 @@
 {
 	GF_Err e;
 	u32 i, count;
-	char *sep_ext;
+	char *sep_ext, *o_sep_ext=NULL;
 	char *args=NULL, szArg1024;
 	Bool multi_period = GF_FALSE;
 	Bool use_filter_chains = GF_FALSE;
@@ -549,16 +549,25 @@
 		return GF_OUT_OF_MEM;
 	}
 
-	sep_ext = gf_url_colon_suffix(dasher->mpd_name, '=');
-	if (sep_ext) {
-		if (sep_ext1 == '\\') sep_ext = strchr(sep_ext+1, ':');
-		else if (sep_ext1=='/') {
-			sep_ext = strchr(sep_ext+1, '/');
-			if (sep_ext) sep_ext = strchr(sep_ext, ':');
-		}
-	}
+
+	sep_ext = strstr(dasher->mpd_name, ":gpac:");
 	if (sep_ext) {
 		sep_ext0 = 0;
+		o_sep_ext = sep_ext;
+		sep_ext+=5;
+	} else {
+		sep_ext = gf_url_colon_suffix(dasher->mpd_name, '=');
+		if (sep_ext) {
+			if (sep_ext1 == '\\') sep_ext = strchr(sep_ext+1, ':');
+			else if (sep_ext1=='/') {
+				sep_ext = strchr(sep_ext+1, '/');
+				if (sep_ext) sep_ext = strchr(sep_ext, ':');
+			}
+		}
+		if (sep_ext) {
+			sep_ext0 = 0;
+			o_sep_ext = sep_ext;
+		}
 	}
 
 	if (dasher->segment_duration == (u32) dasher->segment_duration) {
@@ -597,6 +606,9 @@
 	case GF_DASH_BSMODE_INBAND_PPS:
 		e |= gf_dynstrcat(&args, "bs_switch=pps", ":");
 		break;
+	case GF_DASH_BSMODE_BOTH:
+		e |= gf_dynstrcat(&args, "bs_switch=both", ":");
+		break;
 	case GF_DASH_BSMODE_MERGED:
 		e |= gf_dynstrcat(&args, "bs_switch=on", ":");
 		break;
@@ -757,6 +769,9 @@
 	case GF_DASH_PSSH_MPD:
 		e |= gf_dynstrcat(&args, "pssh=m", ":");
 		break;
+	case GF_DASH_PSSH_NONE:
+		e |= gf_dynstrcat(&args, "pssh=n", ":");
+		break;
 	}
 
 
@@ -835,8 +850,8 @@
 
 	if (args) gf_free(args);
 
-	if (sep_ext) {
-		sep_ext0 = ':';
+	if (o_sep_ext) {
+		o_sep_ext0 = ':';
 	}
 
 	if (!dasher->output) {
@@ -888,6 +903,7 @@
 
 	for (i=0; i<count; i++) {
 		u32 j;
+		char szSourceID100;
 		GF_Filter *src = NULL;
 		GF_Filter *rt = NULL;
 		const char *url = NULL;
@@ -909,15 +925,30 @@
 		//if source is isobmf using extractors, we want to keep the extractors
 		e = gf_dynstrcat(&args, "smode=splitx", ":");
 
+		szSourceID0 = 0;
 		if (frag) {
-			if (!strncmp(frag+1, "trackID=", 8)) {
-				sprintf(szArg, "tkid=%s", frag+9 );
-			} else {
-				sprintf(szArg, "tkid=%s", frag+1);
+			char *frag_val;
+			u32 fID = 0;
+			if (!strncmp(frag+1, "trackID=", 8)) frag_val = frag + 9;
+			else frag_val = frag + 1;
+
+			if (sscanf(frag_val, "%u", &fID)!=1)
+				fID=0;
+			//ID
+			if (fID) {
+				sprintf(szSourceID, "PID=%s", frag_val);
+			}
+			//media type
+			else {
+				sprintf(szSourceID, "%s", frag_val);
 			}
+			//we need tkid for demuxers able to fetch specific tracks (eg isobmf)
+			sprintf(szArg, "tkid=%s", frag_val);
 			e |= gf_dynstrcat(&args, szArg, ":");
 		} else if (di->track_id) {
-			sprintf(szArg, "tkid=%d", di->track_id );
+			sprintf(szSourceID, "PID=%d", di->track_id);
+			//we need tkid for isobmf
+			sprintf(szArg, "tkid=%d", di->track_id);
 			e |= gf_dynstrcat(&args, szArg, ":");
 		}
 
@@ -1068,7 +1099,7 @@
 
 		if (!di->filter_chain) {
 			//assign this source 
-			gf_filter_set_source(dasher->output, src, NULL);
+			gf_filter_set_source(dasher->output, src, szSourceID0 ? szSourceID : NULL);
 			continue;
 		}
 		//create the filter chain between source (or rt if it was set) and dasher
@@ -1117,7 +1148,7 @@
 			}
 		}
 		if (prev_filter) {
-			gf_filter_set_source(dasher->output, prev_filter, NULL);
+			gf_filter_set_source(dasher->output, prev_filter, szSourceID0 ? szSourceID : NULL);
 		}
 	}
 
@@ -1126,7 +1157,6 @@
 
 GF_Err dash_state_check_timing(const char *dash_state, u64 *next_gen_ntp_ms, u32 *next_time_ms)
 {
-#ifndef GPAC_DISABLE_CORE_TOOLS
 	u64 next_gen_ntp = 0;
 	GF_Err e = GF_OK;
 	GF_DOMParser *mpd_parser;
@@ -1164,9 +1194,6 @@
 		}
 	}
 	return GF_OK;
-#else
-	return GF_NOT_SUPPORTED;
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
 }
 
 GF_EXPORT
@@ -1221,7 +1248,7 @@
 	GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("\n"));
 
 	if (dasher->no_cache) {
-		if (!e) gf_fs_print_unused_args(dasher->fsess, "smode");
+		if (!e) gf_fs_print_unused_args(dasher->fsess, "smode,tkid");
 		gf_fs_del(dasher->fsess);
 		dasher->fsess = NULL;
 	}

gpac-2.0.0.tar.gz/src/media_tools/dsmcc.c -> gpac-2.2.0.tar.gz/src/media_tools/dsmcc.c Changed

@@ -1,8 +1,8 @@
 /*
 *			GPAC - Multimedia Framework C SDK
 *
- *			Authors: Jonathan Sillan
- *			Copyright (c) Telecom ParisTech 2011-2020
+ *			Authors: Jonathan Sillan, Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2011-2022
 *					All rights reserved
 *
 * This file is part of GPAC / media tools sub-project
@@ -608,9 +608,9 @@
 			/*process buffer*/
 			if(dsmcc_module->Gzip) {
 				u32 uncomp_size;
-				char* uncompressed_data;
+				u8* uncompressed_data;
 
-				gf_gz_decompress_payload(dsmcc_module->buffer,dsmcc_module->byte_sift,&uncompressed_data, &uncomp_size);
+				gf_gz_decompress_payload(dsmcc_module->buffer,dsmcc_module->byte_sift, &uncompressed_data, &uncomp_size);
 				//dsmcc_process_biop_data(dsmcc_overlord,dsmcc_module,uncompressed_data,dsmcc_module->original_size);
 
 				if(dsmcc_module->original_size == uncomp_size) {
@@ -1197,7 +1197,6 @@
 		BIOP_StreamEvent->EventList = (GF_M2TS_DSMCC_BIOP_EVENT_LIST*)gf_calloc(BIOP_StreamEvent->eventNames_count,sizeof(GF_M2TS_DSMCC_BIOP_EVENT_LIST));
 		for(i=0; i<BIOP_StreamEvent->eventNames_count; i++) {
 			BIOP_StreamEvent->EventListi.eventName_length = gf_bs_read_int(bs,8);
-			BIOP_StreamEvent->EventListi.eventName_length;
 			if(BIOP_StreamEvent->EventListi.eventName_length) {
 				BIOP_StreamEvent->EventListi.eventName_data_byte = (char*)gf_calloc(BIOP_StreamEvent->EventListi.eventName_length,sizeof(char));
 				gf_bs_read_data(bs,BIOP_StreamEvent->EventListi.eventName_data_byte,(u8)(BIOP_StreamEvent->EventListi.eventName_length));

gpac-2.0.0.tar.gz/src/media_tools/dvb_mpe.c -> gpac-2.2.0.tar.gz/src/media_tools/dvb_mpe.c Changed

@@ -1,3 +1,28 @@
+/*
+ *			GPAC - Multimedia Framework C SDK
+ *
+ *			Authors: Jonathan Sillan, Jean Le Feuvre
+ *			Copyright (c) Telecom ParisTech 2011-2022
+ *					All rights reserved
+ *
+ * This file is part of GPAC / media tools sub-project
+ *
+ * GPAC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * GPAC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
 #include <gpac/internal/dvb_mpe_dev.h>
 #include <gpac/network.h>
 #include <string.h>
@@ -874,7 +899,7 @@
 }
 
 GF_EXPORT
-void gf_m2ts_print_mpe_info(GF_M2TS_Demuxer *ts)
+void gf_dvb_mpe_print_info(GF_M2TS_Demuxer *ts)
 {
 	u32 i_streams,i,j,l;
 	GF_M2TS_IP_Target *ip_targets;

gpac-2.0.0.tar.gz/src/media_tools/isom_hinter.c -> gpac-2.2.0.tar.gz/src/media_tools/isom_hinter.c Changed

@@ -532,6 +532,16 @@
 			streamType = GF_STREAM_AUDIO;
 			gf_isom_get_audio_info(file, TrackNum, 1, NULL, &nb_ch, NULL);
 			break;
+		case GF_ISOM_SUBTYPE_EC3:
+			hintType = GF_RTP_PAYT_EAC3;
+			streamType = GF_STREAM_AUDIO;
+			gf_isom_get_audio_info(file, TrackNum, 1, NULL, &nb_ch, NULL);
+			break;
+		case GF_ISOM_SUBTYPE_OPUS:
+			hintType = GF_RTP_PAYT_OPUS;
+			streamType = GF_STREAM_AUDIO;
+			gf_isom_get_audio_info(file, TrackNum, 1, NULL, &nb_ch, NULL);
+			break;
 		case GF_ISOM_SUBTYPE_MP3:
 		{
 			GF_ISOSample *samp = gf_isom_get_sample(file, TrackNum, 1, NULL);
@@ -1014,14 +1024,16 @@
 	}
 	/*MPEG-4 decoder config*/
 	else if (tkHint->rtp_p->rtp_payt==GF_RTP_PAYT_MPEG4) {
+		GF_Err e;
 		esd = gf_isom_get_esd(tkHint->file, tkHint->TrackNum, 1);
 
 		if (esd && esd->decoderConfig && esd->decoderConfig->decoderSpecificInfo && esd->decoderConfig->decoderSpecificInfo->data) {
-			gf_rtp_builder_format_sdp(tkHint->rtp_p, payloadName, sdpLine, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength);
+			e = gf_rtp_builder_format_sdp(tkHint->rtp_p, payloadName, sdpLine, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength);
 		} else {
-			gf_rtp_builder_format_sdp(tkHint->rtp_p, payloadName, sdpLine, NULL, 0);
+			e = gf_rtp_builder_format_sdp(tkHint->rtp_p, payloadName, sdpLine, NULL, 0);
 		}
 		if (esd) gf_odf_desc_del((GF_Descriptor *)esd);
+		if (e) return e;
 
 		if (tkHint->rtp_p->slMap.IV_length) {
 			const char *kms;

gpac-2.0.0.tar.gz/src/media_tools/isom_tools.c -> gpac-2.2.0.tar.gz/src/media_tools/isom_tools.c Changed

@@ -284,9 +284,6 @@
 GF_EXPORT
 GF_Err gf_media_get_file_hash(const char *file, u8 hash20)
 {
-#ifdef GPAC_DISABLE_CORE_TOOLS
-	return GF_NOT_SUPPORTED;
-#else
 	u8 block4096;
 	u32 read;
 	u64 size, tot;
@@ -356,7 +353,6 @@
 #endif
 	gf_fclose(in);
 	return e;
-#endif
 }
 
 #ifndef GPAC_DISABLE_ISOM
@@ -1080,6 +1076,7 @@
 	return GF_NOT_SUPPORTED;
 }
 
+GF_Err gf_isom_set_meta_qt(GF_ISOFile *file);
 
 GF_EXPORT
 GF_Err gf_media_check_qt_prores(GF_ISOFile *mp4)
@@ -1150,6 +1147,8 @@
 		}
 	}
 
+	gf_isom_set_meta_qt(mp4);
+
 	if (!video_tk) {
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("QTFF No visual track\n"));
 		return GF_OK;
@@ -1395,7 +1394,7 @@
 		esd->OCRESID = esd->ESID;
 		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
 		esd->decoderConfig->objectTypeIndication = GF_CODECID_HEVC;
-		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props);
+		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props, NULL);
 		if (e == GF_OK && props.config) {
 			gf_odf_hevc_cfg_write(((GF_HEVCConfigurationBox *)props.config)->config, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
 		}
@@ -1417,7 +1416,7 @@
 		esd->OCRESID = esd->ESID;
 		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
 		esd->decoderConfig->objectTypeIndication = GF_CODECID_AVC;
-		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props);
+		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props, NULL);
 		if (e == GF_OK && props.config) {
 			gf_odf_avc_cfg_write(((GF_AVCConfigurationBox *)props.config)->config, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
 		}
@@ -1438,7 +1437,7 @@
 		esd->OCRESID = esd->ESID;
 		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
 		esd->decoderConfig->objectTypeIndication = GF_CODECID_AV1;
-		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props);
+		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props, NULL);
 		if (e == GF_OK && props.config) {
 			gf_odf_av1_cfg_write( ((GF_AV1ConfigurationBox *)props.config)->config, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
 		}
@@ -1460,7 +1459,7 @@
 		esd->OCRESID = esd->ESID;
 		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
 		esd->decoderConfig->objectTypeIndication = GF_CODECID_JPEG;
-		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props);
+		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props, NULL);
 		if (e == GF_OK && props.config) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("JPEG image item decoder config not supported, patch welcome\n"));
 		}
@@ -1482,7 +1481,7 @@
 		esd->OCRESID = esd->ESID;
 		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
 		esd->decoderConfig->objectTypeIndication = GF_CODECID_PNG;
-		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props);
+		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props, NULL);
 		if (e) {
 			GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Error fetching item properties %s\n", gf_error_to_string(e) ));
 		}
@@ -1504,7 +1503,7 @@
 		esd->OCRESID = esd->ESID;
 		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
 		esd->decoderConfig->objectTypeIndication = GF_CODECID_VVC;
-		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props);
+		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props, NULL);
 		if (e == GF_OK && props.config) {
 			gf_odf_vvc_cfg_write(((GF_VVCConfigurationBox *)props.config)->config, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
 		}
@@ -1513,6 +1512,34 @@
 		esd->slConfig->timestampResolution = 1000;
 		return esd;
 	}
+	if ((item_type == GF_4CC('u','n','c','v')) || (item_type == GF_4CC('u','n','c','i'))) {
+		GF_ImageItemProperties props;
+		esd = gf_odf_desc_esd_new(0);
+		if (!esd) return NULL;
+
+		if (item_id > (1 << 16)) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Item ID greater than 16 bits, does not fit on ES ID\n"));
+		}
+		esd->ESID = (u16)item_id;
+		esd->OCRESID = esd->ESID;
+		esd->decoderConfig->streamType = GF_STREAM_VISUAL;
+		esd->decoderConfig->objectTypeIndication = GF_CODECID_RAW;
+		GF_List *other_props = gf_list_new();
+		e = gf_isom_get_meta_image_props(mp4, GF_TRUE, 0, item_id, &props, other_props);
+		if ((e == GF_OK) && gf_list_count(other_props)) {
+			GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+			gf_isom_box_array_write(NULL, other_props, bs);
+			gf_bs_get_content(bs, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
+			gf_bs_del(bs);
+		}
+		gf_list_del(other_props);
+		esd->slConfig->hasRandomAccessUnitsOnlyFlag = 1;
+		esd->slConfig->useTimestampsFlag = 1;
+		esd->slConfig->timestampResolution = 1000;
+		return esd;
+	}
+
+
 	return NULL;
 }
 
@@ -3515,6 +3542,10 @@
 		u32 size, nb_nalus=0, nb_nal_entries=0, last_tile_group=(u32) -1;
 		GF_BitStream *bs=NULL;
 		GF_ISOSample *sample = gf_isom_get_sample(file, track, i+1, &di);
+		if (!sample) {
+			e = gf_isom_last_error(file);
+			goto err_exit;
+		}
 
 		data = (u8 *) sample->data;
 		size = sample->dataLength;
@@ -4017,7 +4048,7 @@
 GF_Err rfc_6381_get_codec_vpx(char *szCodec, u32 subtype, GF_VPConfig *vpcc, COLR colr)
 {
 	assert(vpcc);
-	snprintf(szCodec, RFC6381_CODEC_NAME_SIZE_MAX, "%s.%02u.%02x.%02u.%02u.%02u.%02u.%02u.%02u", gf_4cc_to_str(subtype),
+	snprintf(szCodec, RFC6381_CODEC_NAME_SIZE_MAX, "%s.%02u.%02u.%02u.%02u.%02u.%02u.%02u.%02u", gf_4cc_to_str(subtype),
 		vpcc->profile,
 		vpcc->level,
 		vpcc->bit_depth,
@@ -4101,6 +4132,44 @@
 	return GF_OK;
 }
 
+// Selected (namespace,identifier) pairs from https://www.w3.org/TR/ttml-profile-registry/
+// ordered in decreasing order of preference
+static const char *ttml_namespaces = {
+	"im3t", "http://www.w3.org/ns/ttml/profile/imsc1.2/text",
+	"im2t", "http://www.w3.org/ns/ttml/profile/imsc1.1/text",
+	"im2i", "http://www.w3.org/ns/ttml/profile/imsc1.1/image",
+	"im1t", "http://www.w3.org/ns/ttml/profile/imsc1/text",
+	"im1i", "http://www.w3.org/ns/ttml/profile/imsc1/image"
+};
+static const int TTML_NAMESPACES_COUNT = GF_ARRAY_LENGTH(ttml_namespaces);
+
+
+GF_Err rfc_6381_get_codec_stpp(char *szCodec, u32 subtype,
+ const char *xmlnamespace,
+ const char *xml_schema_loc,
+ const char *mimes)
+{
+ // we ignore schema location and auxiliary mime types
+ // we focus on the provided list of namespaces
+ if (xmlnamespace != NULL) {
+ int i;
+ for (i = 0; i < TTML_NAMESPACES_COUNT; i+=2) {
+ if(strstr(xmlnamespace, ttml_namespacesi+1) != NULL) {
+ snprintf(szCodec, RFC6381_CODEC_NAME_SIZE_MAX, "%s.%s.%s", gf_4cc_to_str(subtype), "ttml", ttml_namespacesi);
+ return GF_OK;
+ }
+ }
+ // if none of the namespaces above have been found, search the default TTML namespace
+ if(strstr(xmlnamespace, "http://www.w3.org/ns/ttml")) {
+ snprintf(szCodec, RFC6381_CODEC_NAME_SIZE_MAX, "%s.%s", gf_4cc_to_str(subtype), "ttml");
+ return GF_OK;
+ }
+ }
+ // None of the known namespaces are found, default
+ snprintf(szCodec, RFC6381_CODEC_NAME_SIZE_MAX, "%s", gf_4cc_to_str(subtype));
+ return GF_OK;
+}
+
 GF_Err rfc6381_codec_name_default(char *szCodec, u32 subtype, u32 codec_id)
 {
 	if (codec_id && (codec_id<GF_CODECID_LAST_MPEG4_MAPPING)) {
@@ -4121,7 +4190,7 @@
 #ifndef GPAC_DISABLE_ISOM
 
 GF_EXPORT
-GF_Err gf_media_get_rfc_6381_codec_name(GF_ISOFile *movie, u32 track, char *szCodec, Bool force_inband, Bool force_sbr)
+GF_Err gf_media_get_rfc_6381_codec_name(GF_ISOFile *movie, u32 track, u32 stsd_idx, char *szCodec, Bool force_inband, Bool force_sbr)
 {
 	GF_ESD *esd;
 	GF_Err e;
@@ -4129,19 +4198,19 @@
 #ifndef GPAC_DISABLE_HEVC
 	GF_HEVCConfig *hvcc;
 #endif
-	u32 subtype = gf_isom_get_media_subtype(movie, track, 1);
+	u32 subtype = gf_isom_get_media_subtype(movie, track, stsd_idx);
 
 	if (subtype == GF_ISOM_SUBTYPE_MPEG4_CRYP) {
 		u32 originalFormat=0;
-		if (gf_isom_is_ismacryp_media(movie, track, 1)) {
-			e = gf_isom_get_ismacryp_info(movie, track, 1, &originalFormat, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
-		} else if (gf_isom_is_omadrm_media(movie, track, 1)) {
-			e = gf_isom_get_omadrm_info(movie, track, 1, &originalFormat, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
-		} else if(gf_isom_is_cenc_media(movie, track, 1)) {
-			e = gf_isom_get_cenc_info(movie, track, 1, &originalFormat, NULL, NULL);
+		if (gf_isom_is_ismacryp_media(movie, track, stsd_idx)) {
+			e = gf_isom_get_ismacryp_info(movie, track, stsd_idx, &originalFormat, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+		} else if (gf_isom_is_omadrm_media(movie, track, stsd_idx)) {
+			e = gf_isom_get_omadrm_info(movie, track, stsd_idx, &originalFormat, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+		} else if(gf_isom_is_cenc_media(movie, track, stsd_idx)) {
+			e = gf_isom_get_cenc_info(movie, track, stsd_idx, &originalFormat, NULL, NULL);
 		} else {
-			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("ISOM Tools Unknown protection scheme type %s\n", gf_4cc_to_str( gf_isom_is_media_encrypted(movie, track, 1)) ));
-			e = gf_isom_get_original_format_type(movie, track, 1, &originalFormat);
+			GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("ISOM Tools Unknown protection scheme type %s\n", gf_4cc_to_str( gf_isom_is_media_encrypted(movie, track, stsd_idx)) ));
+			e = gf_isom_get_original_format_type(movie, track, stsd_idx, &originalFormat);
 		}
 		if (e) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("ISOM Tools Error fetching protection information\n"));
@@ -4153,7 +4222,7 @@
 
 	switch (subtype) {
 	case GF_ISOM_SUBTYPE_MPEG4:
-		esd = gf_isom_get_esd(movie, track, 1);
+		esd = gf_isom_get_esd(movie, track, stsd_idx);
 		if (esd && esd->decoderConfig) {
 			switch (esd->decoderConfig->streamType) {
 			case GF_STREAM_AUDIO:
@@ -4186,8 +4255,7 @@
 	case GF_ISOM_SUBTYPE_AVC2_H264:
 	case GF_ISOM_SUBTYPE_AVC3_H264:
 	case GF_ISOM_SUBTYPE_AVC4_H264:
-		//FIXME: in avc1 with multiple descriptor, we should take the right description index
-		avcc = gf_isom_avc_config_get(movie, track, 1);
+		avcc = gf_isom_avc_config_get(movie, track, stsd_idx);
 		if (force_inband) {
 			if (subtype==GF_ISOM_SUBTYPE_AVC_H264)
 				subtype = GF_ISOM_SUBTYPE_AVC3_H264;
@@ -4204,8 +4272,8 @@
 
 	case GF_ISOM_SUBTYPE_SVC_H264:
 	case GF_ISOM_SUBTYPE_MVC_H264:
-		avcc = gf_isom_mvc_config_get(movie, track, 1);
-		if (!avcc) avcc = gf_isom_svc_config_get(movie, track, 1);
+		avcc = gf_isom_mvc_config_get(movie, track, stsd_idx);
+		if (!avcc) avcc = gf_isom_svc_config_get(movie, track, stsd_idx);
 		if (avcc) {
 			e = rfc_6381_get_codec_avc(szCodec, subtype, avcc);
 			gf_odf_avc_cfg_del(avcc);
@@ -4227,13 +4295,13 @@
 			if (subtype==GF_ISOM_SUBTYPE_HVC1) subtype = GF_ISOM_SUBTYPE_HEV1;
 			else if (subtype==GF_ISOM_SUBTYPE_HVC2) subtype = GF_ISOM_SUBTYPE_HEV2;
 		}
-		hvcc = gf_isom_hevc_config_get(movie, track, 1);
+		hvcc = gf_isom_hevc_config_get(movie, track, stsd_idx);
 		if (!hvcc) {
-			hvcc = gf_isom_lhvc_config_get(movie, track, 1);
+			hvcc = gf_isom_lhvc_config_get(movie, track, stsd_idx);
 		}
 		if (subtype==GF_ISOM_SUBTYPE_HVT1) {
 			u32 refTrack;
-			gf_isom_get_reference(movie, track, GF_ISOM_REF_TBAS, 1, &refTrack);
+			gf_isom_get_reference(movie, track, GF_ISOM_REF_TBAS, stsd_idx, &refTrack);
 			if (hvcc) gf_odf_hevc_cfg_del(hvcc);
 			hvcc = gf_isom_hevc_config_get(movie, refTrack, 1);
 		}
@@ -4251,12 +4319,12 @@
 #if !defined(GPAC_DISABLE_AV1) && !defined(GPAC_DISABLE_AV_PARSERS)
 	case GF_ISOM_SUBTYPE_AV01:
 	{
-		GF_AV1Config *av1c = gf_isom_av1_config_get(movie, track, 1);
+		GF_AV1Config *av1c = gf_isom_av1_config_get(movie, track, stsd_idx);
 		if (av1c) {
 			u32 colour_type;
 			COLR colr;
 			memset(&colr, 0, sizeof(colr));
-			if (GF_OK == gf_isom_get_color_info(movie, track, 1, &colour_type, &colr.colour_primaries, &colr.transfer_characteristics, &colr.matrix_coefficients, &colr.full_range)) {
+			if (GF_OK == gf_isom_get_color_info(movie, track, stsd_idx, &colour_type, &colr.colour_primaries, &colr.transfer_characteristics, &colr.matrix_coefficients, &colr.full_range)) {
 				colr.override = GF_TRUE;
 			}
 			e = rfc_6381_get_codec_av1(szCodec, subtype, av1c, colr);
@@ -4271,12 +4339,12 @@
 	case GF_ISOM_SUBTYPE_VP08:
 	case GF_ISOM_SUBTYPE_VP09:
 	{
-		GF_VPConfig *vpcc = gf_isom_vp_config_get(movie, track, 1);
+		GF_VPConfig *vpcc = gf_isom_vp_config_get(movie, track, stsd_idx);
 		if (vpcc) {
 			u32 colour_type;
 			COLR colr;
 			memset(&colr, 0, sizeof(colr));
-			if (GF_OK == gf_isom_get_color_info(movie, track, 1, &colour_type, &colr.colour_primaries, &colr.transfer_characteristics, &colr.matrix_coefficients, &colr.full_range)) {
+			if (GF_OK == gf_isom_get_color_info(movie, track, stsd_idx, &colour_type, &colr.colour_primaries, &colr.transfer_characteristics, &colr.matrix_coefficients, &colr.full_range)) {
 				colr.override = GF_TRUE;
 			}
 			e = rfc_6381_get_codec_vpx(szCodec, subtype, vpcc, colr);
@@ -4293,7 +4361,7 @@
 	case GF_ISOM_SUBTYPE_DVAV:
 	case GF_ISOM_SUBTYPE_DAV1:
 	{
-		GF_DOVIDecoderConfigurationRecord *dovi = gf_isom_dovi_config_get(movie, track, 1);
+		GF_DOVIDecoderConfigurationRecord *dovi = gf_isom_dovi_config_get(movie, track, stsd_idx);
 		if (!dovi) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("ISOM Tools No config found for Dolby Vision file (\"%s\") when computing RFC6381.\n", gf_4cc_to_str(subtype)));
 			return GF_NON_COMPLIANT_BITSTREAM;
@@ -4307,7 +4375,7 @@
 	case GF_ISOM_SUBTYPE_VVC1:
 	case GF_ISOM_SUBTYPE_VVI1:
 	{
-		GF_VVCConfig *vvcc = gf_isom_vvc_config_get(movie, track, 1);
+		GF_VVCConfig *vvcc = gf_isom_vvc_config_get(movie, track, stsd_idx);
 		if (vvcc) {
 			if (force_inband) subtype = GF_ISOM_SUBTYPE_VVI1;
 
@@ -4324,7 +4392,7 @@
 	case GF_ISOM_SUBTYPE_MH3D_MHM1:
 	case GF_ISOM_SUBTYPE_MH3D_MHM2:
 	{
-		esd = gf_media_map_esd(movie, track, 1);
+		esd = gf_media_map_esd(movie, track, stsd_idx);
 		if (!esd || !esd->decoderConfig || !esd->decoderConfig->decoderSpecificInfo
 			|| !esd->decoderConfig->decoderSpecificInfo->data
 		) {
@@ -4336,6 +4404,18 @@
 		return e;
 	}
 
+ case GF_ISOM_SUBTYPE_STPP:
+ {
+ const char *xmlnamespace;
+ const char *xml_schema_loc;
+ const char *mimes;
+ e = gf_isom_xml_subtitle_get_description(movie, track, stsd_idx,
+ &xmlnamespace, &xml_schema_loc, &mimes);
+ if (e == GF_OK) {
+ rfc_6381_get_codec_stpp(szCodec, subtype, xmlnamespace, xml_schema_loc, mimes);
+ }
+ return e;
+ }
 	default:
 		return rfc6381_codec_name_default(szCodec, subtype, gf_codec_id_from_isobmf(subtype));
 
@@ -4417,4 +4497,135 @@
 #endif
 }
 
+GF_EXPORT
+GF_Err gf_media_isom_apply_qt_key(GF_ISOFile *movie, const char *name, const char *val)
+{
+	GF_Err e;
+	u8 *data=NULL;
+	GF_QT_UDTAKey key;
+	if (!name) return GF_BAD_PARAM;
+
+	memset(&key, 0, sizeof(GF_QT_UDTAKey));
+	key.name = (char *) name;
+	key.ns = GF_4CC('m','d','t','a');
+	char *sep = strchr(name, '@');
+	if (sep) {
+		sep0 = 0;
+		key.name = sep+1;
+		if (strlen(name)!=4) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("Unrecognize namespace \"%s\" for key %s\n", name, sep+1));
+			return GF_BAD_PARAM;
+		}
+		key.ns = GF_4CC(name0, name1,name2,name3);
+		sep0 = '@';
+	}
+
+	if (!val || !val0) {
+		key.type = GF_QT_KEY_REMOVE;
+	} else if (!strcmp(val, "NULL")) {
+		key.type = GF_QT_KEY_REMOVE;
+	} else {
+		key.type = GF_QT_KEY_UTF8;
+		key.value.string = val;
+
+		if (gf_file_exists(val)) {
+			e = gf_file_load_data(val, &data, &key.value.data.data_len);
+			if (e!=GF_OK) {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("Failed to load file \"%s\" for key %s: %s\n", val, name, gf_error_to_string(e)));
+				return e;
+			}
+			key.value.data.data = data;
+			key.type = GF_QT_KEY_OPAQUE;
+			if (strstr(val, ".bmp")|| strstr(val, ".BMP")) {
+				key.type = GF_QT_KEY_BMP;
+			} else if (key.value.data.data_len>3) {
+				if ((data0==0xFF) && (data1==0xD8) && (data2==0xFF)) {
+					key.type = GF_QT_KEY_JPEG;
+				} else if ((data0==0x89) && (data1==0x50) && (data2==0x4E)) {
+					key.type = GF_QT_KEY_PNG;
+				}
+			}
+		} else {
+			char *force_str=NULL;
+			if (val0 == 'S') {
+				force_str = (char*)val+1;
+				val++;
+			}
+			char *rect_sep = strchr(val, '@');
+			char *pos_sep = strchr(val, 'x');
+			char *arr_sep = strchr(val, ',');
+			if (rect_sep && pos_sep && (sscanf(val, "%gx%g@%gx%g", &key.value.rect.x, &key.value.rect.y, &key.value.rect.w, &key.value.rect.h) == 4)) {
+				key.type = GF_QT_KEY_RECTF;
+			} else if (rect_sep && (sscanf(val, "%g@%g", &key.value.pos_size.x, &key.value.pos_size.y)==2)) {
+				key.type = GF_QT_KEY_SIZEF;
+			} else if (pos_sep && (sscanf(val, "%gx%g", &key.value.pos_size.x, &key.value.pos_size.y)==2)) {
+				key.type = GF_QT_KEY_POINTF;
+			} else if (arr_sep && strchr(arr_sep, ',')
+				&& (sscanf(val, "%lg,%lg,%lg,%lg,%lg,%lg,%lg,%lg,%lg", &key.value.matrix0, &key.value.matrix1, &key.value.matrix2
+				, &key.value.matrix3, &key.value.matrix4, &key.value.matrix5
+				, &key.value.matrix6, &key.value.matrix7, &key.value.matrix8
+				)==9)
+			) {
+				key.type = GF_QT_KEY_MATRIXF;
+			} else {
+				Bool force_flt=GF_FALSE,force_dbl=GF_FALSE,force_sign=GF_FALSE;
+				u32 force_size=0;
+				while (1) {
+					char c = val0;
+					if (c=='f') force_flt = GF_TRUE;
+					else if (c=='d') force_dbl = GF_TRUE;
+					else if (c=='+') force_sign = GF_TRUE;
+					else if (c=='b') force_size = 1;
+					else if (c=='s') force_size = 2;
+					else if (c=='l') force_size = 3;
+					else if (c=='L') force_size = 4;
+					else
+						break;
+					val++;
+				}
+				if (arr_sep || strchr(val, '.') || force_dbl || force_flt) {
+					Double res;
+					if (sscanf(val, "%lg", &res)==1) {
+						key.value.number = res;
+						key.type = force_flt ? GF_QT_KEY_FLOAT : GF_QT_KEY_DOUBLE;
+					}
+				}
+				else {
+					s64 res;
+					if (sscanf(val, LLD, &res)==1) {
+						key.value.sint = res;
+						if (!force_sign && (key.value.sint>0)) {
+							key.value.uint = key.value.sint;
+							if (force_size==1) key.type = GF_QT_KEY_UNSIGNED_8;
+							else if (force_size==2) key.type = GF_QT_KEY_UNSIGNED_16;
+							else if (force_size==3) key.type = GF_QT_KEY_UNSIGNED_32;
+							else if (force_size==4) key.type = GF_QT_KEY_UNSIGNED_64;
+							else key.type = GF_QT_KEY_UNSIGNED_VSIZE;
+
+						} else {
+							if (force_size==1) key.type = GF_QT_KEY_SIGNED_8;
+							else if (force_size==2) key.type = GF_QT_KEY_SIGNED_16;
+							else if (force_size==3) key.type = GF_QT_KEY_SIGNED_32;
+							else if (force_size==4) key.type = GF_QT_KEY_SIGNED_64;
+							else key.type = GF_QT_KEY_SIGNED_VSIZE;
+						}
+					}
+				}
+			}
+			if (force_str && (key.type != GF_QT_KEY_UTF8)) {
+				key.type = GF_QT_KEY_UTF8;
+				key.value.string = force_str;
+			}
+		}
+	}
+
+	e = gf_isom_set_qt_key(movie, &key);
+	if (data) gf_free(data);
+
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("Failed to add key %s: %s\n", name, gf_error_to_string(e) ));
+	}
+	return e;
+}
+
 #endif //GPAC_DISABLE_ISOM

gpac-2.0.0.tar.gz/src/media_tools/m2ts_mux.c -> gpac-2.2.0.tar.gz/src/media_tools/m2ts_mux.c Changed

@@ -534,16 +534,6 @@
 	assert(section);
 
 	bs = mux->pck_bs;
-	gf_bs_reassign_buffer(bs, packet, 188);
-
-	gf_bs_write_int(bs,	0x47, 8); // sync
-	gf_bs_write_int(bs,	0, 1); // error indicator
-	if (stream->current_section_offset == 0) {
-		gf_bs_write_int(bs,	1, 1); // payload start indicator
-	} else {
-		/* No section concatenation yet!!!*/
-		gf_bs_write_int(bs,	0, 1); // payload start indicator
-	}
 
 	if (!stream->current_section_offset) payload_length = 183;
 	else payload_length = 184;
@@ -580,6 +570,15 @@
 		else stream->continuity_counter--;
 	}
 
+	gf_bs_reassign_buffer(bs, packet, 188);
+	gf_bs_write_int(bs,	0x47, 8); // sync
+	gf_bs_write_int(bs,	0, 1); // error indicator
+	if (stream->current_section_offset == 0) {
+		gf_bs_write_int(bs,	1, 1); // payload start indicator
+	} else {
+		/* No section concatenation yet!!!*/
+		gf_bs_write_int(bs,	0, 1); // payload start indicator
+	}
 	gf_bs_write_int(bs,	0, 1); /*priority indicator*/
 	gf_bs_write_int(bs,	stream->pid, 13); /*pid*/
 	gf_bs_write_int(bs,	0, 2); /*scrambling indicator*/
@@ -815,6 +814,7 @@
 			nb_streams++;
 			GF_AVCConfig *avcc = NULL;
 			GF_HEVCConfig *hvcc = NULL;
+			GF_AV1Config *av1c = NULL;
 
 			switch (es->mpeg2_stream_type) {
 			case GF_M2TS_AUDIO_AC3:
@@ -832,6 +832,11 @@
 				es_info_length += 2 + 4;
 				type = GF_M2TS_PRIVATE_DATA;
 				break;
+			case GF_M2TS_VIDEO_AV1:
+				//reg desc + private data specifier desc
+				es_info_length += 2 + 4 + 2 + 4;
+				type = GF_M2TS_PRIVATE_DATA;
+				break;
 			case GF_M2TS_VIDEO_HEVC:
 			case GF_M2TS_VIDEO_H264:
 				//check dv
@@ -849,10 +854,21 @@
 				}
 				break;
 			default:
-				if (es->force_reg_desc) {
-					es_info_length += 2 + 4;
-					if (!es->ifce->ra_code)
-						es_info_length += 4;
+				if (es->ifce->codecid==GF_CODECID_DVB_SUBS) {
+					es_info_length += 2 + 5+3;
+				}
+				else if (es->ifce->codecid==GF_CODECID_DVB_TELETEXT) {
+					es_info_length += 2 + 2+3;
+				}
+				else if (es->force_reg_desc) {
+					es_info_length += 2 + 4; //desc size + reg 4CC
+					if (!es->ifce->ra_code) {
+						if (es->ifce->gpac_meta_dsi) {
+							es_info_length += es->ifce->gpac_meta_dsi_size;
+						} else {
+							es_info_length += 4; //codecID
+						}
+					}
 					type = GF_M2TS_PRIVATE_DATA;
 				}
 				break;
@@ -866,6 +882,10 @@
 				hvcc = gf_odf_hevc_cfg_read(es->ifce->decoder_config, es->ifce->decoder_config_size, GF_FALSE);
 				if (hvcc) es_info_length += 15;
 			}
+			if (es->ifce->decoder_config && (es->mpeg2_stream_type==GF_M2TS_VIDEO_AV1)) {
+				av1c = gf_odf_av1_cfg_read(es->ifce->decoder_config, es->ifce->decoder_config_size);
+				if (av1c) es_info_length += 2 + 4;
+			}
 
 			gf_bs_write_int(bs,	type, 8);
 			gf_bs_write_int(bs,	0x7, 3); // reserved
@@ -973,16 +993,29 @@
 				gf_bs_write_int(bs,	4, 8);
 				gf_bs_write_u32(bs,	GF_M2TS_RA_STREAM_OPUS);
 				break;
+			case GF_M2TS_VIDEO_AV1:
+				gf_bs_write_int(bs,	GF_M2TS_REGISTRATION_DESCRIPTOR, 8);
+				gf_bs_write_int(bs,	4, 8);
+				gf_bs_write_u32(bs,	GF_M2TS_RA_STREAM_AV1);
+				gf_bs_write_int(bs, GF_M2TS_DVB_PRIVATE_DATA_SPECIFIER_DESCRIPTOR, 8);
+				gf_bs_write_int(bs, 4, 8);
+				gf_bs_write_u32(bs, GF_4CC('A', 'O', 'M', 'S'));
+				break;
+
 			default:
 				if (es->force_reg_desc && es->ifce && es->ifce->codecid) {
-					gf_bs_write_int(bs,	GF_M2TS_REGISTRATION_DESCRIPTOR, 8);
+					gf_bs_write_u8(bs,	GF_M2TS_REGISTRATION_DESCRIPTOR);
 					if (es->ifce->ra_code) {
-						gf_bs_write_int(bs,	4, 8);
-						gf_bs_write_int(bs,	es->ifce->ra_code, 32);
+						gf_bs_write_u8(bs,	4);
+						gf_bs_write_u32(bs,	es->ifce->ra_code);
+					} else if (es->ifce->gpac_meta_dsi_size) {
+						gf_bs_write_u8(bs, 4 + es->ifce->gpac_meta_dsi_size);
+						gf_bs_write_u32(bs,	GF_M2TS_RA_STREAM_GPAC);
+						gf_bs_write_data(bs, es->ifce->gpac_meta_dsi, es->ifce->gpac_meta_dsi_size);
 					} else {
-						gf_bs_write_int(bs,	8, 8);
-						gf_bs_write_int(bs,	GF_M2TS_RA_STREAM_GPAC, 32);
-						gf_bs_write_int(bs,	es->ifce->codecid, 32);
+						gf_bs_write_u8(bs, 8);
+						gf_bs_write_u32(bs, GF_M2TS_RA_STREAM_GPAC);
+						gf_bs_write_u32(bs, es->ifce->codecid);
 					}
 				}
 				break;
@@ -1016,6 +1049,65 @@
 				gf_bs_write_u8(bs, es->ifce->dv_info4);
 			}
 
+			if (es->ifce->codecid==GF_CODECID_DVB_SUBS) {
+				gf_bs_write_int(bs,	GF_M2TS_DVB_SUBTITLING_DESCRIPTOR, 8);
+				gf_bs_write_int(bs,	8, 8);
+				gf_bs_write_u8(bs, (es->ifce->lang>>16) & 0xFF);
+				gf_bs_write_u8(bs, (es->ifce->lang>>6) & 0xFF);
+				gf_bs_write_u8(bs, (es->ifce->lang) & 0xFF);
+				if (es->ifce->decoder_config && (es->ifce->decoder_config_size==5)) {
+					gf_bs_write_u8(bs, es->ifce->decoder_config4);
+					gf_bs_write_u8(bs, es->ifce->decoder_config0);
+					gf_bs_write_u8(bs, es->ifce->decoder_config1);
+					gf_bs_write_u8(bs, es->ifce->decoder_config2);
+					gf_bs_write_u8(bs, es->ifce->decoder_config3);
+				} else {
+					gf_bs_write_u8(bs, 0x10); //use normal type, we coud use for hard of hearing (0x20)
+					gf_bs_write_u16(bs, 0);
+					gf_bs_write_u16(bs, 0);
+				}
+			}
+			else if (es->ifce->codecid==GF_CODECID_DVB_TELETEXT) {
+				gf_bs_write_int(bs,	GF_M2TS_DVB_SUBTITLING_DESCRIPTOR, 8);
+				gf_bs_write_int(bs,	5, 8);
+				gf_bs_write_u8(bs, (es->ifce->lang>>16) & 0xFF);
+				gf_bs_write_u8(bs, (es->ifce->lang>>6) & 0xFF);
+				gf_bs_write_u8(bs, (es->ifce->lang) & 0xFF);
+				if (es->ifce->decoder_config && (es->ifce->decoder_config_size==2)) {
+					gf_bs_write_u8(bs, es->ifce->decoder_config0);
+					gf_bs_write_u8(bs, es->ifce->decoder_config1);
+				} else {
+					gf_bs_write_int(bs, 0x02, 5);
+					gf_bs_write_int(bs, 0, 3);
+					gf_bs_write_int(bs, 0, 8);
+				}
+			}
+			if (av1c) {
+				gf_bs_write_int(bs, 0x80 /* TODO check value */, 8);
+				gf_bs_write_int(bs, 4, 8); // specifier tag and AV1 config
+				gf_bs_write_int(bs, av1c->marker, 1);
+				gf_bs_write_int(bs, av1c->version, 7);
+				gf_bs_write_int(bs, av1c->seq_profile, 3);
+				gf_bs_write_int(bs, av1c->seq_level_idx_0, 5);
+				gf_bs_write_int(bs, av1c->seq_tier_0, 1);
+				gf_bs_write_int(bs, av1c->high_bitdepth, 1);
+				gf_bs_write_int(bs, av1c->twelve_bit, 1);
+				gf_bs_write_int(bs, av1c->monochrome, 1);
+				gf_bs_write_int(bs, av1c->chroma_subsampling_x, 1);
+				gf_bs_write_int(bs, av1c->chroma_subsampling_y, 1);
+				gf_bs_write_int(bs, av1c->chroma_sample_position, 2);
+				gf_bs_write_int(bs, 3, 2); // hdr_wcg_idc
+				gf_bs_write_int(bs, 0, 1); // reserved_zeros
+				gf_bs_write_int(bs, av1c->initial_presentation_delay_present, 1);
+				if (av1c->initial_presentation_delay_present) {
+					gf_bs_write_int(bs, av1c->initial_presentation_delay_minus_one, 4);
+				} else {
+					gf_bs_write_int(bs, 0, 4); // reserved_zeros
+				}
+				gf_odf_av1_cfg_del(av1c);
+			}
+
+
 			if (es->loop_descriptors)
 			{
 				for (i=0; i<gf_list_count(es->loop_descriptors); i++)
@@ -1535,6 +1627,15 @@
 	}
 		break;
 	default:
+		if (stream->ifce->codecid==GF_CODECID_DVB_SUBS) {
+			GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+			gf_bs_write_u8(bs, 0x20);
+			gf_bs_write_u8(bs, 0);
+			gf_bs_write_data(bs, stream->curr_pck.data, stream->curr_pck.data_len);
+			gf_free(stream->curr_pck.data);
+			gf_bs_get_content(bs, &stream->curr_pck.data, &stream->curr_pck.data_len);
+			gf_bs_del(bs);
+		}
 		break;
 	}
 
@@ -1908,8 +2009,6 @@
 	u32 adaptation_field_control, payload_length, payload_to_copy, padding_length, hdr_len, pos, copy_next;
 
 	assert(stream->pid);
-	bs = stream->program->mux->pck_bs;
-	gf_bs_reassign_buffer(bs, packet, 188);
 
 	if (stream->pcr_only_mode) {
 		payload_length = 184 - 8;
@@ -2050,6 +2149,11 @@
 		else stream->continuity_counter--;
 	}
 
+	bs = stream->program->mux->pck_bs;
+	gf_bs_reassign_buffer(bs, packet, 188);
+
+	//small opt for formatting TS header for PES, don't use bitstream for header, slightly faster
+#if 0
 	gf_bs_write_int(bs,	0x47, 8); // sync byte
 	gf_bs_write_int(bs,	0, 1); // error indicator
 	gf_bs_write_int(bs,	hdr_len ? 1 : 0, 1); // start ind
@@ -2058,6 +2162,14 @@
 	gf_bs_write_int(bs,	0, 2); // scrambling
 	gf_bs_write_int(bs,	adaptation_field_control, 2); // we do not use adaptation field for sections
 	gf_bs_write_int(bs,	stream->continuity_counter, 4); // continuity counter
+#else
+	packet0 = 0x47; // sync byte
+	packet1 = (stream->pid>>8) & 0x1F; //high bits of PID
+	if (hdr_len) packet1 |= 0x40; // start ind
+	packet2 = stream->pid & 0xFF; //low bits of PID
+	packet3 = (adaptation_field_control<<4) | (stream->continuity_counter & 0xF); //AF + CC
+	gf_bs_seek(bs, 4);
+#endif
 
 	if (stream->continuity_counter < 15) stream->continuity_counter++;
 	else stream->continuity_counter=0;
@@ -2556,9 +2668,17 @@
 		case GF_CODECID_SMPTE_VC1:
 			stream->mpeg2_stream_type = GF_M2TS_VIDEO_VC1;
 			break;
+		case GF_CODECID_AV1:
+			stream->mpeg2_stream_type = GF_M2TS_VIDEO_AV1;
+			stream->force_single_au = GF_TRUE;
+			break;
 		default:
-			if (!ifce->ra_code) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS Muxer Unsupported mpeg2-ts video type for codec %s, signaling as PES private using codec 4CC %s in registration descriptor\n", gf_codecid_name(ifce->codecid), gf_4cc_to_str(ifce->codecid) ));
+			if (!ifce->ra_code && !stream->force_reg_desc) {
+				if (ifce->gpac_meta_dsi) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS Muxer Unsupported mpeg2-ts audio type for codec %s, signaling as PES private using GPAC 4CC in registration descriptor\n", ifce->gpac_meta_name ? ifce->gpac_meta_name : gf_codecid_name(ifce->codecid) ));
+				} else {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS Muxer Unsupported mpeg2-ts video type for codec %s, signaling as PES private using codec 4CC %s in registration descriptor\n", gf_codecid_name(ifce->codecid), gf_4cc_to_str(ifce->codecid) ));
+				}
 			}
 
 			stream->mpeg2_stream_type = GF_M2TS_PRIVATE_DATA;
@@ -2605,9 +2725,23 @@
 			else
 				stream->mpeg2_stream_type = GF_M2TS_AUDIO_EC3;
 			break;
+
+		case GF_CODECID_DTS_CA:
+		case GF_CODECID_DTS_X:
+		case GF_CODECID_DTS_HD_HR:
+		case GF_CODECID_DTS_HD_MASTER:
+		case GF_CODECID_DTS_LBR:
+			stream->mpeg2_stream_type = GF_M2TS_AUDIO_DTS;
+			break;
+
+
 		default:
-			if (!ifce->ra_code) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS Muxer Unsupported mpeg2-ts audio type for codec %s, signaling as PES private using codec 4CC in registration descriptor\n", gf_codecid_name(ifce->codecid) ));
+			if (!ifce->ra_code && !stream->force_reg_desc) {
+				if (ifce->gpac_meta_dsi) {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS Muxer Unsupported mpeg2-ts audio type for codec %s, signaling as PES private using GPAC 4CC in registration descriptor\n", ifce->gpac_meta_name ? ifce->gpac_meta_name : gf_codecid_name(ifce->codecid) ));
+				} else {
+					GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS Muxer Unsupported mpeg2-ts audio type for codec %s, signaling as PES private using codec 4CC in registration descriptor\n", gf_codecid_name(ifce->codecid) ));
+				}
 			}
 			stream->mpeg2_stream_type = GF_M2TS_PRIVATE_DATA;
 			stream->force_single_au = GF_TRUE;
@@ -2642,9 +2776,20 @@
 		break;
 	case GF_STREAM_TEXT:
 		stream->mpeg2_stream_id = 0xBD;
-		stream->mpeg2_stream_type = GF_M2TS_METADATA_PES;
-		gf_m2ts_stream_add_metadata_pointer_descriptor(stream->program);
-		gf_m2ts_stream_add_metadata_descriptor(stream);
+		stream->force_single_au = GF_TRUE;
+		switch (ifce->codecid) {
+		case GF_CODECID_DVB_SUBS:
+			stream->mpeg2_stream_type = GF_M2TS_PRIVATE_DATA;
+			break;
+		case GF_CODECID_DVB_TELETEXT:
+			stream->mpeg2_stream_type = GF_M2TS_PRIVATE_DATA;
+			break;
+		default:
+			stream->mpeg2_stream_type = GF_M2TS_METADATA_PES;
+			gf_m2ts_stream_add_metadata_pointer_descriptor(stream->program);
+			gf_m2ts_stream_add_metadata_descriptor(stream);
+			break;
+		}
 		break;
 	default:
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MPEG-2 TS Muxer Unsupported codec %s, signaling as raw data\n", gf_codecid_name(ifce->codecid) ));
@@ -3086,7 +3231,7 @@
 	}
 	//if PCR stream is over, flush
 	if (stream->program->pcr->ifce) {
-		if (stream->program->pcr->ifce->caps & (GF_ESI_STREAM_FLUSH|GF_ESI_STREAM_IS_OVER))
+		if (stream->program->pcr->ifce->caps & (GF_ESI_STREAM_FLUSH|GF_ESI_STREAM_IS_OVER|GF_ESI_STREAM_SPARSE))
 			return GF_FALSE;
 	}
 	//PCR is in pure pcr mode (no associated data), check is any stream is less than PCR
@@ -3098,7 +3243,7 @@
 		while (a_stream) {
 			//a_stream time less than stream time, we must wait on stream to process a_stream
 			if ((a_stream != stream)
-				&& a_stream->ifce && !(a_stream->ifce->caps & (GF_ESI_STREAM_FLUSH|GF_ESI_STREAM_IS_OVER))
+				&& a_stream->ifce && !(a_stream->ifce->caps & (GF_ESI_STREAM_FLUSH|GF_ESI_STREAM_IS_OVER|GF_ESI_STREAM_SPARSE))
 				&& gf_m2ts_time_less(&a_stream->time, &stream->time)
 			) {
 				return GF_TRUE;
@@ -3108,7 +3253,7 @@
 		return GF_FALSE;
 	}
 	//PCR done or flush, we're not too early
-	else if (stream->program->pcr->ifce && (stream->program->pcr->ifce->caps & (GF_ESI_STREAM_FLUSH|GF_ESI_STREAM_IS_OVER)))
+	else if (stream->program->pcr->ifce && (stream->program->pcr->ifce->caps & (GF_ESI_STREAM_FLUSH|GF_ESI_STREAM_IS_OVER|GF_ESI_STREAM_SPARSE)))
 		return GF_FALSE;
 
 	//not PCR, we're too early

gpac-2.0.0.tar.gz/src/media_tools/m3u8.c -> gpac-2.2.0.tar.gz/src/media_tools/m3u8.c Changed

@@ -40,6 +40,8 @@
 	int stream_id;
 	char *codecs;
 	char *language;
+	char *name;
+	u32 channels;
 	MediaType type;
 	union {
 		char *audio;
@@ -55,6 +57,8 @@
 	Bool is_master_playlist;
 	Bool is_media_segment;
 	Bool is_playlist_ended;
+	Bool is_default;
+	Bool is_autoselect;
 	u64 playlist_utc_timestamp;
 	u64 byte_range_start, byte_range_end;
 	u64 init_byte_range_start, init_byte_range_end;
@@ -103,6 +107,9 @@
 	if (e->language) {
 		gf_free(e->language);
 	}
+	if (e->name) {
+		gf_free(e->name);
+	}
 	if (e->audio_group) {
 		gf_free(e->audio_group);
 	}
@@ -136,7 +143,7 @@
 /**
  * Creates an Playlist element.
  * This element can be either a playlist of a stream according to first parameter.
-\param NULL if element could not be created. Elements will be deleted recursively.
+ * \return The PlaylistElement or NULL if it could not be created. Elements will be deleted recursively.
  */
 static PlaylistElement* playlist_element_new(PlaylistElementType element_type, const char *url, s_accumulated_attributes *attribs)
 {
@@ -155,6 +162,7 @@
 	e->title = (attribs->title ? gf_strdup(attribs->title) : NULL);
 	e->codecs = (attribs->codecs ? gf_strdup(attribs->codecs) : NULL);
 	e->language = (attribs->language ? gf_strdup(attribs->language) : NULL);
+	e->name = (attribs->name ? gf_strdup(attribs->name) : NULL);
 	e->drm_method = attribs->key_method;
 	e->init_segment_url = attribs->init_url ? gf_strdup(attribs->init_url) : NULL;
 	e->init_byte_range_start = attribs->init_byte_range_start;
@@ -196,6 +204,8 @@
 				gf_free(e->codecs);
 			if (e->language)
 				gf_free(e->language);
+			if (e->name)
+				gf_free(e->name);
 			if (e->audio_group)
 				gf_free(e->audio_group);
 			if (e->video_group)
@@ -210,6 +220,7 @@
 			e->title = NULL;
 			e->codecs = NULL;
 			e->language = NULL;
+			e->name = NULL;
 			e->audio_group = NULL;
 			e->video_group = NULL;
 			e->key_uri = NULL;
@@ -692,26 +703,31 @@
 					GF_LOG(GF_LOG_WARNING, GF_LOG_DASH,("M3U8 Misformed #EXT-X-MEDIA:LANGUAGE=%s. Quotes are incorrect.\n", reti+5));
 				}
 			} else if (safe_start_equals("NAME=", reti)) {
-				GF_LOG(GF_LOG_INFO, GF_LOG_DASH,("M3U8 EXT-X-MEDIA:NAME not supported\n"));
-				//attributes->name = gf_strdup(reti+5);
+				if (attributes->name) gf_free(attributes->name);
+				attributes->name = gf_strdup(reti+5+1);
+				u32 len = (u32) strlen(attributes->name);
+				if (len) attributes->namelen-1=0;
 			} else if (safe_start_equals("DEFAULT=", reti)) {
-				GF_LOG(GF_LOG_INFO, GF_LOG_DASH,("M3U8 EXT-X-MEDIA:DEFAULT not supported\n"));
 				if (!strncmp(reti+8, "YES", 3)) {
-					//TODO
+					attributes->is_default = GF_TRUE;
 				} else if (!strncmp(reti+8, "NO", 2)) {
-					//TODO
+					attributes->is_default = GF_FALSE;
 				} else {
 					GF_LOG(GF_LOG_WARNING, GF_LOG_DASH,("M3U8 Invalid #EXT-X-MEDIA:DEFAULT=%s\n", reti+8));
 				}
 			} else if (safe_start_equals("AUTOSELECT=", reti)) {
-				GF_LOG(GF_LOG_INFO, GF_LOG_DASH,("M3U8 EXT-X-MEDIA:AUTOSELECT not supported\n"));
 				if (!strncmp(reti+11, "YES", 3)) {
-					//TODO
+					attributes->is_autoselect = GF_TRUE;
 				} else if (!strncmp(reti+11, "NO", 2)) {
-					//TODO
+					attributes->is_autoselect = GF_TRUE;
 				} else {
 					GF_LOG(GF_LOG_WARNING, GF_LOG_DASH,("M3U8 Invalid #EXT-X-MEDIA:AUTOSELECT=%s\n", reti+11));
 				}
+			} else if (safe_start_equals("CHANNELS=", reti)) {
+				sscanf(reti + 9, "\"%u\"", &attributes->channels);
+
+			} else {
+				GF_LOG(GF_LOG_WARNING, GF_LOG_DASH,("M3U8 Attribute %s not supported\n", reti));
 			}
 
 			i++;
@@ -937,6 +953,7 @@
 			gf_list_add(stream->variants, curr_playlist);
 			curr_playlist->width = attribs->width;
 			curr_playlist->height = attribs->height;
+			curr_playlist->channels = attribs->channels;
 		} else {
 			/* Normal Playlist */
 			assert((*playlist)->streams);
@@ -1020,6 +1037,8 @@
 	attribs->playlist_utc_timestamp = 0;
 	attribs->bandwidth = 0;
 	attribs->stream_id = 0;
+	attribs->is_default = 0;
+	attribs->is_autoselect = 0;
 	if (attribs->codecs != NULL) {
 		gf_free(attribs->codecs);
 		attribs->codecs = NULL;
@@ -1028,6 +1047,10 @@
 		gf_free(attribs->language);
 		attribs->language = NULL;
 	}
+	if (attribs->name != NULL) {
+		gf_free(attribs->name);
+		attribs->name = NULL;
+	}
 	if (attribs->group.audio != NULL) {
 		gf_free(attribs->group.audio);
 		attribs->group.audio = NULL;

gpac-2.0.0.tar.gz/src/media_tools/media_export.c -> gpac-2.2.0.tar.gz/src/media_tools/media_export.c Changed

@@ -66,167 +66,6 @@
 }
 
 #ifndef GPAC_DISABLE_AV_PARSERS
-/*that's very very crude, we only support vorbis & theora in MP4 - this will need cleanup as soon as possible*/
-static GF_Err gf_dump_to_ogg(GF_MediaExporter *dumper, char *szName, u32 track)
-{
-#ifdef GPAC_DISABLE_OGG
-	return GF_NOT_SUPPORTED;
-#else
-	FILE *out;
-	ogg_stream_state os;
-	ogg_packet op;
-	ogg_page og;
-	u32 count, i, di, theora_kgs, nb_i, nb_p;
-	Bool flush_first = GF_TRUE;
-	GF_ISOSample *samp;
-	GF_ESD *esd = gf_isom_get_esd(dumper->file, track, 1);
-
-
-	memset(&os, 0, sizeof(ogg_stream_state));
-	memset(&og, 0, sizeof(ogg_page));
-	memset(&op, 0, sizeof(ogg_packet));
-
-	if (gf_sys_is_test_mode()) {
-		ogg_stream_init(&os, 1);
-	} else {
-		gf_rand_init(GF_TRUE);
-		ogg_stream_init(&os, gf_rand());
-	}
-
-	out = szName ? gf_fopen(szName, "wb") : stdout;
-	if (!out) return gf_export_message(dumper, GF_IO_ERR, "Error opening %s for writing - check disk access & permissions", szName);
-
-	theora_kgs = 0;
-	if (esd && esd->decoderConfig
-		&& esd->decoderConfig->decoderSpecificInfo
-		&& esd->decoderConfig->decoderSpecificInfo->data
-	) {
-		GF_BitStream *bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
-		if (esd->decoderConfig->objectTypeIndication==GF_CODECID_OPUS) {
-			GF_BitStream *bs_out;
-			GF_OpusSpecificBox *dops = (GF_OpusSpecificBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_DOPS);
-			dops->size = gf_bs_read_u32(bs);
-			gf_bs_read_u32(bs);
-			gf_isom_box_read((GF_Box *)dops, bs);
-			bs_out = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
-			gf_bs_write_data(bs_out, "OpusHead", 8);
-			gf_bs_write_u8(bs_out, 1);//version
-			gf_bs_write_u8(bs_out, dops->OutputChannelCount);
-			gf_bs_write_u16_le(bs_out, dops->PreSkip);
-			gf_bs_write_u32_le(bs_out, dops->InputSampleRate);
-			gf_bs_write_u16_le(bs_out, dops->OutputGain);
-			gf_bs_write_u8(bs_out, dops->ChannelMappingFamily);
-			if (dops->ChannelMappingFamily) {
-				gf_bs_write_u8(bs_out, dops->StreamCount);
-				gf_bs_write_u8(bs_out, dops->CoupledCount);
-				gf_bs_write_data(bs, (char *) dops->ChannelMapping, dops->OutputChannelCount);
-			}
-			gf_isom_box_del((GF_Box*)dops);
-
-			gf_bs_get_content(bs_out, &op.packet, &op.bytes);
-			gf_bs_del(bs_out);
-			ogg_stream_packetin(&os, &op);
-			gf_free(op.packet);
-			op.packetno ++;
-
-		} else {
-			while (gf_bs_available(bs)) {
-				op.bytes = gf_bs_read_u16(bs);
-				op.packet = (unsigned char*)gf_malloc(sizeof(char) * op.bytes);
-				gf_bs_read_data(bs, (char*)op.packet, op.bytes);
-				ogg_stream_packetin(&os, &op);
-
-				if (flush_first) {
-					ogg_stream_pageout(&os, &og);
-					gf_fwrite(og.header, og.header_len, out);
-					gf_fwrite(og.body, og.body_len, out);
-					flush_first = 0;
-
-					if (esd->decoderConfig->objectTypeIndication==GF_CODECID_THEORA) {
-						u32 kff;
-						GF_BitStream *vbs = gf_bs_new((char*)op.packet, op.bytes, GF_BITSTREAM_READ);
-						gf_bs_skip_bytes(vbs, 40);
-						gf_bs_read_int(vbs, 6); /* quality */
-						kff = 1 << gf_bs_read_int(vbs, 5);
-						gf_bs_del(vbs);
-
-						theora_kgs = 0;
-						kff--;
-						while (kff) {
-							theora_kgs ++;
-							kff >>= 1;
-						}
-					}
-				}
-				gf_free(op.packet);
-				op.packetno ++;
-			}
-		}
-		gf_bs_del(bs);
-	}
-	gf_odf_desc_del((GF_Descriptor *)esd);
-
-	while (ogg_stream_pageout(&os, &og)>0) {
-		gf_fwrite(og.header, og.header_len, out);
-		gf_fwrite(og.body, og.body_len, out);
-	}
-
-	op.granulepos = -1;
-
-	count = gf_isom_get_sample_count(dumper->file, track);
-
-	nb_i = nb_p = 0;
-	samp = gf_isom_get_sample(dumper->file, track, 1, &di);
-	for (i=0; i<count; i++) {
-		GF_ISOSample *next_samp = gf_isom_get_sample(dumper->file, track, i+2, &di);
-		if (!samp) break;
-		op.bytes = samp->dataLength;
-		op.packet = (unsigned char*)samp->data;
-		op.packetno ++;
-
-		if (theora_kgs) {
-			if (samp->IsRAP) {
-				if (i) nb_i+=nb_p+1;
-				nb_p = 0;
-			} else {
-				nb_p++;
-			}
-			op.granulepos = nb_i;
-			op.granulepos <<= theora_kgs;
-			op.granulepos |= nb_p;
-		} else {
-			if (next_samp) op.granulepos = next_samp->DTS;
-		}
-		if (!next_samp) op.e_o_s = 1;
-
-		ogg_stream_packetin(&os, &op);
-
-		gf_isom_sample_del(&samp);
-		samp = next_samp;
-		next_samp = NULL;
-		gf_set_progress("OGG Export", i+1, count);
-		if (dumper->flags & GF_EXPORT_DO_ABORT) break;
-
-		while (ogg_stream_pageout(&os, &og)>0) {
-			gf_fwrite(og.header, og.header_len, out);
-			gf_fwrite(og.body, og.body_len, out);
-		}
-	}
-	if (samp) gf_isom_sample_del(&samp);
-
-	while (ogg_stream_flush(&os, &og)>0) {
-		gf_fwrite(og.header, og.header_len, out);
-		gf_fwrite(og.body, og.body_len, out);
-	}
-	ogg_stream_clear(&os);
-	if (szName) gf_fclose(out);
-	return GF_OK;
-#endif
-}
-#endif
-
-
-#ifndef GPAC_DISABLE_AV_PARSERS
 static GF_Err gf_dump_to_vobsub(GF_MediaExporter *dumper, char *szName, u32 track, char *dsi, u32 dsiSize)
 {
 #ifndef GPAC_DISABLE_VOBSUB
@@ -631,6 +470,7 @@
 GF_Err gf_media_export_webvtt_metadata(GF_MediaExporter *dumper)
 {
 	GF_ESD *esd;
+	GF_Err e = GF_OK;
 	char szName1000, szMedia1000;
 	FILE *med, *vtt;
 	u32 w, h;
@@ -827,21 +667,20 @@
 			gf_fprintf(vtt, "\n");
 		}
 		if (med) {
-			gf_fwrite(samp->data, samp->dataLength, med);
+			if (gf_fwrite(samp->data, samp->dataLength, med) != samp->dataLength)
+				e = GF_IO_ERR;
 		} else if (dumper->flags & GF_EXPORT_WEBVTT_META_EMBEDDED) {
 			if (isText) {
 				samp->data = (char *)gf_realloc(samp->data, samp->dataLength+1);
 				samp->datasamp->dataLength = 0;
 				gf_fprintf(vtt, "%s\n", samp->data);
 			} else {
-				u32 b64_size;
+				u32 b64_size = samp->dataLength*2 + 3;
 				char *b64;
-				b64 = (char *)gf_malloc(samp->dataLength*3);
-				b64_size = gf_base64_encode(samp->data, samp->dataLength, b64, samp->dataLength*3);
-				if (b64_size != (u32)-1) {
-					b64b64_size = 0;
-					gf_fprintf(vtt, "%s\n", b64);
-				}
+				b64 = (char *)gf_malloc(sizeof(char)*b64_size);
+				b64_size = gf_base64_encode(samp->data, samp->dataLength, b64, b64_size);
+				b64b64_size = 0;
+				gf_fprintf(vtt, "%s\n", b64);
 				gf_free(b64);
 			}
 		}
@@ -854,7 +693,7 @@
 	}
 	if (med) gf_fclose(med);
 	gf_fclose(vtt);
-	return GF_OK;
+	return e;
 }
 
 #endif /*GPAC_DISABLE_VTT*/
@@ -863,6 +702,7 @@
 GF_Err gf_media_export_six(GF_MediaExporter *dumper)
 {
 	GF_ESD *esd;
+	GF_Err e=GF_OK;
 	char szName1000, szMedia1000;
 	FILE *media, *six;
 	u32 track, i, di, count, pos, header_size;
@@ -930,7 +770,8 @@
 			} else
 #endif
 			{
-				gf_fwrite(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, media);
+				if (gf_fwrite(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, media) != esd->decoderConfig->decoderSpecificInfo->dataLength)
+					e = GF_IO_ERR;
 				header_size = esd->decoderConfig->decoderSpecificInfo->dataLength;
 			}
 		}
@@ -951,7 +792,8 @@
 		if (!samp) break;
 
 		if (media) {
-			gf_fwrite(samp->data, samp->dataLength, media);
+			if (gf_fwrite(samp->data, samp->dataLength, media)!=samp->dataLength)
+				e = GF_IO_ERR;
 		}
 
 		gf_fprintf(six, "<unit time=\""LLU"\" ", samp->DTS);
@@ -969,7 +811,7 @@
 	gf_fprintf(six, "</%s>\n", szRootName);
 	if (media) gf_fclose(media);
 	gf_fclose(six);
-	return GF_OK;
+	return e;
 
 }
 
@@ -989,7 +831,7 @@
 	Bool is_stdout = 0;
 	FILE *saf_f;
 	SAFInfo safs1024;
-
+	GF_Err e=GF_OK;
 	if (dumper->flags & GF_EXPORT_PROBE_ONLY) return GF_OK;
 
 	s_count = tot_samp = 0;
@@ -1032,13 +874,13 @@
 				mime = "audio/amr-wb";
 				break;
 			case GF_ISOM_SUBTYPE_3GP_EVRC:
-				mime = "audio/evrc";
+				mime = "audio/x-evrc-es";
 				break;
 			case GF_ISOM_SUBTYPE_3GP_QCELP:
-				mime = "audio/qcelp";
+				mime = "audio/x-qcelp-es";
 				break;
 			case GF_ISOM_SUBTYPE_3GP_SMV:
-				mime = "audio/smv";
+				mime = "audio/x-smv-es";
 				break;
 			}
 			if (!mime) continue;
@@ -1089,7 +931,7 @@
 		while (1) {
 			gf_saf_mux_for_time(mux, (u32) -1, 0, &data, &size);
 			if (!data) break;
-			gf_fwrite(data, size, saf_f);
+			if (gf_fwrite(data, size, saf_f) != size) e = GF_IO_ERR;
 			gf_free(data);
 		}
 		gf_set_progress("SAF Export", samp_done, tot_samp);
@@ -1097,14 +939,14 @@
 	}
 	gf_saf_mux_for_time(mux, (u32) -1, 1, &data, &size);
 	if (data) {
-		gf_fwrite(data, size, saf_f);
+		if (gf_fwrite(data, size, saf_f)!=size) e = GF_IO_ERR;
 		gf_free(data);
 	}
 	if (!is_stdout)
 		gf_fclose(saf_f);
 
 	gf_saf_mux_del(mux);
-	return GF_OK;
+	return e;
 #else
 	return GF_NOT_SUPPORTED;
 #endif
@@ -1220,18 +1062,12 @@
 			}
 			break;
 		}
-		//TODO, move these two to filters one of these days
-		if ((codec_id==GF_CODECID_VORBIS) || (codec_id==GF_CODECID_THEORA) || (codec_id==GF_CODECID_OPUS)) {
-			char *outname = dumper->out_name;
-			if (outname && !strcmp(outname, "std")) outname=NULL;
-			if (esd) gf_odf_desc_del((GF_Descriptor *) esd);
-#ifndef GPAC_DISABLE_AV_PARSERS
-			return gf_dump_to_ogg(dumper, outname, track_num);
-#else
-			return GF_NOT_SUPPORTED;
-#endif
 
-		}
+		if ((codec_id==GF_CODECID_VORBIS) || (codec_id==GF_CODECID_THEORA) || (codec_id==GF_CODECID_SPEEX))
+			strcpy(szExt, "ogg");
+		else if (codec_id==GF_CODECID_OPUS)
+			strcpy(szExt, "opus");
+
 		if (codec_id==GF_CODECID_SUBPIC) {
 #ifndef GPAC_DISABLE_AV_PARSERS
 			char *dsi = NULL;
@@ -1269,6 +1105,7 @@
 					} else if (dumper->track_type) {
 						if ((dumper->track_type==1) && (tki->stream_type!=GF_STREAM_VISUAL)) continue;
 						if ((dumper->track_type==2) && (tki->stream_type!=GF_STREAM_AUDIO)) continue;
+						if ((dumper->track_type==3) && (tki->stream_type!=GF_STREAM_TEXT)) continue;
 					}
 
 					found = GF_TRUE;
@@ -1303,6 +1140,7 @@
 	}
 	file_out = NULL;
 	args = NULL;
+	Bool load_dest = GF_FALSE;
 
 	if (dumper->flags & GF_EXPORT_REMUX) {
 		file_out = gf_fs_load_destination(fsess, dumper->out_name, NULL, NULL, &e);
@@ -1361,6 +1199,7 @@
 				e |= gf_dynstrcat(&args, ":ext=", NULL);
 				e |= gf_dynstrcat(&args, szExt, NULL);
 			}
+			load_dest = GF_TRUE;
 		} else if ((dumper->trackID || dumper->track_type) && use_dynext) {
 			e |= gf_dynstrcat(&args, ":dynext", NULL);
 		}
@@ -1371,7 +1210,12 @@
 			return e;
 		}
 
-		file_out = gf_fs_load_filter(fsess, args, &e);
+		if (load_dest) {
+			//skip fout:dst= whenever we have an extension specified, to allow using meta filters (ffmx) 
+			file_out = gf_fs_load_destination(fsess, args+9, NULL, NULL, &e);
+		} else {
+			file_out = gf_fs_load_filter(fsess, args, &e);
+		}
 		if (!file_out) {
 			gf_fs_del(fsess);
 			if (args) gf_free(args);
@@ -1488,7 +1332,7 @@
 	}
 
 	if (dumper->track_type) {
-		const char *mtype = (dumper->track_type==1) ? "video" : "audio";
+		const char *mtype = (dumper->track_type==1) ? "video" : ((dumper->track_type==2) ? "audio" : "text");
 		if (dumper->trackID) {
 			sprintf(szSubArgs, "%s%d", mtype, dumper->trackID);
 		} else {

gpac-2.0.0.tar.gz/src/media_tools/media_import.c -> gpac-2.2.0.tar.gz/src/media_tools/media_import.c Changed

@@ -99,7 +99,7 @@
 
 	br = (Double) (s64) gf_isom_get_media_duration(file, track);
 	br /= timescale;
-	if (br) {
+	if (br>0) {
 		GF_ESD *esd = NULL;
 		if (!csize || !cdur) {
 			bitrate = (u32) ((Double) (s64)avg_rate / br);
@@ -155,10 +155,10 @@
 u32 gf_dolby_vision_level(u32 width, u32 height, u64 fps_num, u64 fps_den, u32 codecid)
 {
 	u32 dv_level = 0;
+	u32 fps = fps_den ? (u32) (fps_num/fps_den) : 25;
 	u64 level_check = width;
-	level_check *= height * fps_num;
-	if (fps_den)
-		level_check /= fps_den;
+	level_check *= height * fps;
+
 	if (codecid==GF_CODECID_AVC) {
 		if (level_check <= 1280*720*24) dv_level = 1;
 		else if (level_check <= 1280*720*30) dv_level = 2;
@@ -184,7 +184,7 @@
 else dv_level = 10;
 }
 else if (level_check <= 7680*4320*60) dv_level = 12;
- else level_check = 13;
+ else dv_level = 13;
 	}
 	return dv_level;
 }
@@ -282,6 +282,7 @@
 	gf_set_progress("Importing SC3DMC", 1, 1);
 
 	gf_isom_sample_del(&samp);
+	gf_isom_update_duration(import->dest);
 
 exit:
 	gf_free(data);
@@ -345,7 +346,7 @@
 				gf_free(lang);
 				lang = NULL;
 			}
-			gf_media_get_rfc_6381_codec_name(import->orig, i+1, import->tk_infoi.szCodecProfile, GF_FALSE, GF_FALSE);
+			gf_media_get_rfc_6381_codec_name(import->orig, i+1, 1, import->tk_infoi.szCodecProfile, GF_FALSE, GF_FALSE);
 
 			import->nb_tracks ++;
 		}
@@ -450,7 +451,8 @@
 		if (dst && strstr(dst, ".mov"))
 			clone_flags = 0;
 	}
-
+	clone_flags |= GF_ISOM_CLONE_RESET_DURATION;
+	
 	if (import->flags & GF_IMPORT_USE_DATAREF)
 		clone_flags |= GF_ISOM_CLONE_TRACK_KEEP_DREF;
 	if (import->target_trackID && (import->target_trackID==(u32)-1))
@@ -740,6 +742,7 @@
 			if (e) goto exit;
 		}
 	}
+	gf_isom_update_duration(import->dest);
 
 exit:
 	if (sai_buffer) gf_free(sai_buffer);
@@ -1252,6 +1255,7 @@
 			p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION);
 			if (p) {
 				Double d = (Double) p->value.lfrac.num;
+				if (d<0) d = -d;
 				d*=1000;
 				if (p->value.lfrac.den) d /= p->value.lfrac.den;
 				if (d > importer->probe_duration) importer->probe_duration = (u64) d;
@@ -1498,6 +1502,20 @@
 
 	if (importer->streamFormat && !strcmp(importer->streamFormat, "VTT")) e |= gf_dynstrcat(&args, "webvtt", ":");
 
+	//SRT-related legacy params
+	if (importer->fontName) {
+		e |= gf_dynstrcat(&args, "fontname=", ":");
+		e |= gf_dynstrcat(&args, importer->fontName, NULL);
+	}
+	if (importer->fontName) {
+		sprintf(szSubArg, "fontsize=%d", importer->fontSize);
+		e |= gf_dynstrcat(&args, szSubArg, ":");
+	}
+	if (importer->text_width && importer->text_height) {
+		sprintf(szSubArg, "width=%d:height=%d:txtx=%d:txty=%d", importer->text_width, importer->text_height, importer->text_x, importer->text_y);
+		e |= gf_dynstrcat(&args, szSubArg, ":");
+	}
+
 	if (importer->source_magic) {
 		sprintf(szSubArg, "#SrcMagic="LLU, importer->source_magic);
 		e |= gf_dynstrcat(&args, szSubArg, ":");
@@ -1506,7 +1524,6 @@
 		sprintf(szSubArg, "#MuxIndex=%d", importer->track_index);
 		e |= gf_dynstrcat(&args, szSubArg, ":");
 	}
-
 	if (e) {
 		if (!importer->run_in_session)
 			gf_fs_del(fsess);

gpac-2.0.0.tar.gz/src/media_tools/mpd.c -> gpac-2.2.0.tar.gz/src/media_tools/mpd.c Changed

@@ -29,7 +29,7 @@
 #include <gpac/network.h>
 #include <gpac/maths.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
+#ifndef GPAC_DISABLE_MPD
 
 #define MPD_STORE_EXTENSION_ATTR(_elem)	\
 			if (!_elem->x_attributes) _elem->x_attributes = gf_list_new();	\
@@ -660,7 +660,7 @@
 		if (!strcmp(att->value, "progressive")) com->scan_type = GF_MPD_SCANTYPE_PROGRESSIVE;
 		else if (!strcmp(att->value, "interlaced")) com->scan_type = GF_MPD_SCANTYPE_INTERLACED;
 	}
-	else if (!strcmp(att->name, "selectionRriority")) com->selection_priority = gf_mpd_parse_int(att->value);
+	else if (!strcmp(att->name, "selectionPriority")) com->selection_priority = gf_mpd_parse_int(att->value);
 	else if (!strcmp(att->name, "tag")) com->tag = gf_mpd_parse_string(att->value);
 
 	else {
@@ -718,6 +718,7 @@
 	gf_mpd_init_common_attributes((GF_MPD_CommonAttributes *)rep);
 	rep->base_URLs = gf_list_new();
 	rep->sub_representations = gf_list_new();
+	rep->hls_max_seg_dur.den = 1;
 	return rep;
 }
 
@@ -1241,17 +1242,21 @@
 	if (ptr->media_stream_structure_id) gf_free(ptr->media_stream_structure_id);
 
 	if (ptr->playback.cached_init_segment_url) {
+		//free blob created to hold base64 embedded data
 		if (ptr->playback.owned_gmem && !strnicmp(ptr->playback.cached_init_segment_url, "gmem://", 7)) {
-			u32 size;
-			char *mem_address;
-			if (sscanf(ptr->playback.cached_init_segment_url, "gmem://%d@%p", &size, &mem_address) != 2) {
-				assert(0);
+			GF_Blob *mem_blob;
+			if (sscanf(ptr->playback.cached_init_segment_url, "gmem://%p", &mem_blob) == 1) {
+				gf_blob_unregister(mem_blob);
+				if (mem_blob->data) gf_free(mem_blob->data);
+				gf_free(mem_blob);
 			}
-			gf_free(mem_address);
 		}
 		gf_free(ptr->playback.cached_init_segment_url);
 	}
-	if (ptr->playback.init_segment.data) gf_free(ptr->playback.init_segment.data);
+	if (ptr->playback.init_segment.data) {
+		gf_blob_unregister(&ptr->playback.init_segment);
+		gf_free(ptr->playback.init_segment.data);
+	}
 	if (ptr->playback.key_url) gf_free(ptr->playback.key_url);
 
 	gf_mpd_del_list(ptr->base_URLs, gf_mpd_base_url_free, 0);
@@ -1515,7 +1520,6 @@
 	mpd->time_shift_buffer_depth = (u32) -1; /*infinite by default*/
 	mpd->type = is_end ? GF_MPD_TYPE_STATIC : GF_MPD_TYPE_DYNAMIC;
 
-
 	sep = strrchr(m3u8_file, '/');
 	if (!sep)
 		sep = strrchr(m3u8_file, '\\');
@@ -1739,7 +1743,7 @@
 			if (parse_sub_playlist && !elt)
 				break;
 
-			//get base URL of child manifest, only needed when injecting base URL
+			//get base URL of child manifest, only needed when injecting base URL
 			variant_base_url = gf_strdup(pe->url);
 
 			sep = strrchr(variant_base_url, '/');
@@ -1761,7 +1765,8 @@
 
 			width = pe->width;
 			height = pe->height;
-			samplerate = num_channels = 0;
+			samplerate = 0;
+			num_channels = pe->channels;
 
 retry_import:
 
@@ -1866,6 +1871,10 @@
 			if (elt && strstr(elt->url, ".aac"))
 				rep->playback.disabled = GF_TRUE;
 
+			//if hls advertises more than our importer, use hls info (some files signal always stereo in audio sample entry)
+			if (num_channels && pe->channels && (num_channels<pe->channels))
+				num_channels = pe->channels;
+
 			e = gf_list_add(set->representations, rep);
 			if (e) return e;
 			sprintf(szName, "R%d_%d", i+1, j+1);
@@ -1875,7 +1884,8 @@
 			if (!strcmp(M3U8_UNKNOWN_MIME_TYPE, mimeTypeForM3U8Segments)) {
 				GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("M3U8 Unknown mime-type when converting from M3U8 HLS playlist, setting %s\n", mimeTypeForM3U8Segments));
 			}
-			if (elt && elt->init_segment_url && (strstr(elt->init_segment_url, ".mp4") || strstr(elt->init_segment_url, ".MP4")) ) {
+			char *fext = (elt && elt->init_segment_url) ? gf_file_ext_start(elt->init_segment_url) : NULL;
+			if (fext && (!stricmp(fext, ".mp4") || !stricmp(fext, ".m4s")) ) {
 				rep->mime_type = gf_strdup(samplerate ? "audio/mp4" : "video/mp4");
 			} else {
 				rep->mime_type = gf_strdup(mimeTypeForM3U8Segments);
@@ -1961,6 +1971,34 @@
 
 				if (rel_url) gf_free(rel_url);
 				if (variant_base_url) gf_free(variant_base_url);
+
+				if (use_segment_timeline) {
+					GF_MPD_SegmentTimelineEntry *prev_e = NULL;
+					u64 start_time = 0;
+					rep->segment_template->timescale = 1000;
+					GF_SAFEALLOC(rep->segment_template->segment_timeline, GF_MPD_SegmentTimeline);
+					if (!rep->segment_template->segment_timeline) return GF_OUT_OF_MEM;
+
+					rep->segment_template->segment_timeline->entries = gf_list_new();
+					for (k=0; k<count_elements; k++) {
+						u64 dur;
+						GF_MPD_SegmentTimelineEntry *se;
+						elt = gf_list_get(pe->element.playlist.elements, k);
+
+						dur = (u64) ( elt->duration_info * rep->segment_template->timescale);
+						if (prev_e && (prev_e->duration == dur)) {
+							prev_e->repeat_count++;
+						} else {
+							GF_SAFEALLOC(se, GF_MPD_SegmentTimelineEntry);
+							if (!se) return GF_OUT_OF_MEM;
+							se->duration = (u32) dur;
+							se->start_time = start_time;
+							gf_list_add(rep->segment_template->segment_timeline->entries, se);
+							prev_e = se;
+						}
+						start_time += dur;
+					}
+				}
 				continue;
 			}
 
@@ -1976,7 +2014,7 @@
 				//if byte-range media file, add base URL
 				byte_range_media_file
 				//otherwise if we have different location for HLS vs MPD url or if child playlist is not in same path as master HLS
-				|| (rel_url || strchr(elt->url, '/') || strchr(elt->url, '\\'))
+				|| (rel_url || variant_base_url || strchr(elt->url, '/') || strchr(elt->url, '\\'))
 			)) {
 				GF_MPD_BaseURL *url;
 				GF_SAFEALLOC(url, GF_MPD_BaseURL);
@@ -1999,9 +2037,11 @@
 					} else {
 						url->URL = gf_strdup(rel_url);
 					}
-				}
-				else
+				} else if (variant_base_url) {
+					url->URL = gf_strdup(variant_base_url);
+				} else {
 					url->URL = gf_strdup(elt->url);
+				}
 			}
 			if (rel_url) gf_free(rel_url);
 			//no longer needed
@@ -2425,6 +2465,7 @@
 	seq_num = pe->element.playlist.media_seq_min;
 	seq_num += pe->element.playlist.discontinuity;
 
+	u64 seg_utc = 0;
 	for (k=0; k<count_elements; k++) {
 		GF_MPD_SegmentURL *segment_url;
 		PlaylistElement *elt = gf_list_get(pe->element.playlist.elements, k);
@@ -2489,7 +2530,13 @@
 
 		segment_url->duration = (u64) (rep->segment_list->timescale * elt->duration_info);
 
-		segment_url->hls_utc_time = elt->utc_start_time;
+		if (elt->utc_start_time) {
+			seg_utc = elt->utc_start_time;
+		}
+
+		segment_url->hls_utc_time = seg_utc;
+		if (seg_utc)
+			seg_utc += (u32) (elt->duration_info*1000);
 
 		//we keep the same seq num for each part
 		segment_url->hls_seq_num = seq_num;
@@ -2648,8 +2695,10 @@
 {
 	if (s->timescale) gf_fprintf(out, " timescale=\"%d\"", s->timescale);
 	if (s->presentation_time_offset) gf_fprintf(out, " presentationTimeOffset=\""LLU"\"", s->presentation_time_offset);
-	if (s->index_range_exact) gf_fprintf(out, " indexRangeExact=\"true\"");
-	if (s->index_range) gf_fprintf(out, " indexRange=\""LLD"-"LLD"\"", s->index_range->start_range, s->index_range->end_range);
+	if (s->index_range && s->index_range->end_range) {
+		if (s->index_range_exact) gf_fprintf(out, " indexRangeExact=\"true\"");
+		if (s->index_range) gf_fprintf(out, " indexRange=\""LLD"-"LLD"\"", s->index_range->start_range, s->index_range->end_range);
+	}
 	if (s->availability_time_offset) gf_fprintf(out, " availabilityTimeOffset=\"%g\"", s->availability_time_offset);
 	if ((s32) s->time_shift_buffer_depth > 0)
 		gf_mpd_print_duration(out, "timeShiftBufferDepth", s->time_shift_buffer_depth, GF_TRUE);
@@ -2713,8 +2762,9 @@
 {
 	gf_mpd_print_segment_base_attr(out, (GF_MPD_SegmentBase *)ms);
 
-	if (ms->start_number != (u32) -1) gf_fprintf(out, " startNumber=\"%d\"", ms->start_number);
-	if (ms->duration) gf_fprintf(out, " duration=\""LLD"\"", ms->duration);
+	if ((int)ms->start_number >= 0) gf_fprintf(out, " startNumber=\"%d\"", ms->start_number);
+	//"The attribute @duration and the element SegmentTimeline shall not be present at the same time" ...
+	if (ms->duration && !ms->segment_timeline) gf_fprintf(out, " duration=\""LLD"\"", ms->duration);
 
 
 	if (!ms->bitstream_switching_url && !ms->segment_timeline && !ms->initialization_segment && !ms->representation_index) {
@@ -3097,6 +3147,10 @@
 	if (rep->quality_ranking) gf_fprintf(out, " qualityRanking=\"%d\"", rep->quality_ranking);
 	if (rep->dependency_id) gf_fprintf(out, " dependencyId=\"%s\"", rep->dependency_id);
 	if (rep->media_stream_structure_id) gf_fprintf(out, " mediaStreamStructureId=\"%s\"", rep->media_stream_structure_id);
+	if (rep->first_tfdt_plus_one) {
+		gf_fprintf(out, " gpac:first_tfdt=\""LLU"\"", rep->first_tfdt_plus_one-1);
+		gf_fprintf(out, " gpac:tfdt_timescale=\""LLU"\"", rep->first_tfdt_timescale);
+	}
 
 	if (bck_codecs) {
 		gf_free(rep->codecs);
@@ -3510,11 +3564,12 @@
 	return url;
 }
 
-static GF_Err gf_mpd_write_m3u8_playlist(const GF_MPD *mpd, const GF_MPD_Period *period, const GF_MPD_AdaptationSet *as, GF_MPD_Representation *rep, char *m3u8_name, u32 hls_version, Double max_part_dur_session)
+static GF_Err gf_mpd_write_m3u8_playlist(const GF_MPD *mpd, const GF_MPD_Period *period, const GF_MPD_AdaptationSet *as, GF_MPD_Representation *rep, char *m3u8_name, u32 hls_version, Double max_part_dur_session, const char *force_base_url)
 {
 	u32 i, count;
 	GF_DASH_SegmentContext *sctx;
 	FILE *out;
+	char *force_url=NULL;
 	const char *last_kms = NULL;
 	Bool close_file = GF_FALSE;
 
@@ -3533,20 +3588,24 @@
 	sctx = gf_list_get(rep->state_seg_list, 0);
 
 	gf_fprintf(out,"#EXTM3U\n");
-	gf_fprintf(out,"#EXT-X-TARGETDURATION:%d\n", (u32) ((Double) rep->dash_dur.num) / rep->dash_dur.den);
+	gf_fprintf(out,"#EXT-X-TARGETDURATION:%d\n", (u32) gf_ceil( ((Double) rep->hls_max_seg_dur.num) / rep->hls_max_seg_dur.den) );
 	gf_fprintf(out,"#EXT-X-VERSION:%d\n", hls_version);
 	gf_fprintf(out,"#EXT-X-MEDIA-SEQUENCE:%d\n", sctx->seg_num);
 	if (as->use_hls_ll) {
 		//PART-HOLD-BACK is REQUIRED if the Playlist contains the EXT-X-PART-INF tag
 		//we use the recommended (should) PART-TARGET x 3
-		gf_fprintf(out,"#EXT-X-SERVER-CONTROL:PART-HOLD-BACK=%g\n", 3 * max_part_dur_session);
+		if (mpd->llhls_part_holdback>0) {
+			gf_fprintf(out,"#EXT-X-SERVER-CONTROL:PART-HOLD-BACK=%g\n", mpd->llhls_part_holdback);
+		} else {
+			gf_fprintf(out,"#EXT-X-SERVER-CONTROL:PART-HOLD-BACK=%g\n", 3 * max_part_dur_session);
+		}
 		gf_fprintf(out,"#EXT-X-PART-INF:PART-TARGET=%g\n", rep->hls_ll_part_dur);
 	}
 	for (i=0; i<rep->nb_hls_variant_tags; i++) {
 		gf_fprintf(out,"%s\n", rep->hls_variant_tagsi);
 	}
 
-	if (as->starts_with_sap<SAP_TYPE_3)
+	if (as->starts_with_sap<GF_FILTER_SAP_3)
 		gf_fprintf(out,"#EXT-X-INDEPENDENT-SEGMENTS\n");
 
 	if (mpd->m3u8_time && rep->timescale_mpd && (mpd->type == GF_MPD_TYPE_DYNAMIC)) {
@@ -3563,7 +3622,15 @@
 			gf_fprintf(out,"#EXT-X-I-FRAMES-ONLY\n");
 		}
 		if (rep->hls_single_file_name) {
-			gf_fprintf(out,"#EXT-X-MAP:URI=\"%s\"\n", rep->hls_single_file_name);
+			if (force_base_url)
+				force_url = gf_url_concatenate(force_base_url, rep->hls_single_file_name);
+
+			gf_fprintf(out,"#EXT-X-MAP:URI=\"%s\"\n", force_url ? force_url : rep->hls_single_file_name);
+
+			if (force_url) {
+				gf_free(force_url);
+				force_url = NULL;
+			}
 		}
 
 		for (i=0; i<count; i++) {
@@ -3617,7 +3684,15 @@
 					Bool write_br = GF_FALSE;
 					dur = sctx->fragsk.duration;
 					dur /= rep->timescale;
-					gf_fprintf(out, "#EXT-X-PART:DURATION=%g,URI=\"%s", dur, sctx->filename);
+
+					if (force_base_url)
+						force_url = gf_url_concatenate(force_base_url, sctx->filename);
+
+					gf_fprintf(out, "#EXT-X-PART:DURATION=%g,URI=\"%s", dur, force_url ? force_url : sctx->filename);
+					if (force_url ) {
+						gf_free(force_url);
+						force_url = NULL;
+					}
 
 					if (mpd->force_llhls_mode==1) write_br = GF_TRUE;
 					else if (mpd->force_llhls_mode==2) write_br = GF_FALSE;
@@ -3654,11 +3729,18 @@
 						else next_br_start_plus_one = 1;
 					}
 
+					if (force_base_url)
+						force_url = gf_url_concatenate(force_base_url, sctx->filename);
+
 					if (next_seg_idx)
-						gf_fprintf(out, "#EXT-X-PRELOAD-HINT:TYPE=PART,URI=\"%s.%d\"\n", sctx->filename, next_seg_idx);
+						gf_fprintf(out, "#EXT-X-PRELOAD-HINT:TYPE=PART,URI=\"%s.%d\"\n", force_url ? force_url : sctx->filename, next_seg_idx);
 					else if (next_br_start_plus_one)
-						gf_fprintf(out, "#EXT-X-PRELOAD-HINT:TYPE=PART,URI=\"%s\",BYTERANGE-START="LLU"\n", sctx->filename, next_br_start_plus_one-1);
+						gf_fprintf(out, "#EXT-X-PRELOAD-HINT:TYPE=PART,URI=\"%s\",BYTERANGE-START="LLU"\n", force_url ? force_url : sctx->filename, next_br_start_plus_one-1);
 
+					if (force_url) {
+						gf_free(force_url);
+						force_url = NULL;
+					}
 				}
 				//generate rendition report
 				if (mpd->llhls_rendition_reports) {
@@ -3674,7 +3756,7 @@
 							o_sctx = gf_list_last(o_rep->state_seg_list);
 							if (!o_sctx || !o_sctx->llhls_mode) continue;
 							//not clear in the spec, we assume what is listed must be the last PART completely produced
-							//if no frag and a segemnt exists before, use last part of that segment
+							//if no frag and a segment exists before, use last part of that segment
 							if (!o_sctx->nb_frags) {
 								u32 idx = gf_list_count(o_rep->state_seg_list);
 								if (idx<2) continue;
@@ -3706,7 +3788,16 @@
 			dur = (Double) sctx->dur;
 			dur /= rep->timescale;
 			gf_fprintf(out,"#EXTINF:%g,\n", dur);
-			gf_fprintf(out,"%s\n", sctx->filename);
+
+			if (force_base_url)
+				force_url = gf_url_concatenate(force_base_url, sctx->filename);
+
+			gf_fprintf(out,"%s\n", force_url ? force_url : sctx->filename);
+
+			if (force_url) {
+				gf_free(force_url);
+				force_url = NULL;
+			}
 		}
 	} else {
 		GF_MPD_BaseURL *base_url=NULL;
@@ -3724,10 +3815,19 @@
 		assert(base_url);
 
 		if (init) {
+
+			if (force_base_url)
+				force_url = gf_url_concatenate(force_base_url, base_url->URL);
+
 			if (init->byte_range) {
-				gf_fprintf(out,"#EXT-X-MAP:URI=\"%s\",BYTERANGE=\"%d@"LLU"\"\n", base_url->URL, (u32) (1+init->byte_range->end_range - init->byte_range->start_range), init->byte_range->start_range);
+				gf_fprintf(out,"#EXT-X-MAP:URI=\"%s\",BYTERANGE=\"%d@"LLU"\"\n", force_url ? force_url : base_url->URL, (u32) (1+init->byte_range->end_range - init->byte_range->start_range), init->byte_range->start_range);
 			} else {
-				gf_fprintf(out,"#EXT-X-MAP:URI=\"%s\"\n", base_url->URL);
+				gf_fprintf(out,"#EXT-X-MAP:URI=\"%s\"\n", force_url ? force_url : base_url->URL);
+			}
+
+			if (force_url) {
+				gf_free(force_url);
+				force_url = NULL;
 			}
 		}
 
@@ -3741,7 +3841,15 @@
 			dur /= rep->timescale;
 			gf_fprintf(out,"#EXTINF:%g\n", dur);
 			gf_fprintf(out,"#EXT-X-BYTERANGE:%d@"LLU"\n", sctx->file_size, sctx->file_offset);
-			gf_fprintf(out,"%s\n", base_url->URL);
+			if (force_base_url)
+				force_url = gf_url_concatenate(force_base_url, base_url->URL);
+
+			gf_fprintf(out,"%s\n", force_url ? force_url : base_url->URL);
+
+			if (force_url) {
+				gf_free(force_url);
+				force_url = NULL;
+			}
 		}
 	}
 
@@ -3768,7 +3876,7 @@
 	Bool use_ind_segments = GF_TRUE;
 	Bool is_fmp4 = GF_FALSE;
 	char *szVariantName;
-	char *m3u8_name_rad, *sep;
+	char *m3u8_name_rad, *sep, *force_base_url=NULL;
 	u32 nb_audio=0;
 	u32 nb_cc=0;
 	u32 nb_subs=0;
@@ -3834,14 +3942,20 @@
 	if (sep) sep0 = 0;
 	szVariantName = gf_malloc(sizeof(char) * (100 + strlen(m3u8_name_rad)) );
 
+
+	if (mpd->hls_abs_url) {
+		GF_MPD_BaseURL *burl = gf_list_get(mpd->base_URLs, 0);
+		if (burl)
+			force_base_url = burl->URL;
+	}
+
 	//if live low lat, update parts dur
 	Double max_part_dur_session=0;
 	i=0;
 	while ( (as = (GF_MPD_AdaptationSet *) gf_list_enum(period->adaptation_sets, &i))) {
-		u32 j=0;
-		GF_MPD_Representation *rep;
 		if (!as->use_hls_ll) continue;
 
+		j=0;
 		while ( (rep = (GF_MPD_Representation *) gf_list_enum(as->representations, &j))) {
 			u32 k=0;
 			//figure out max part duration for this version of the playlist
@@ -3920,7 +4034,9 @@
 			if (!name) {
 				name = gf_file_basename(rep->m3u8_var_name);
 			}
-			e = gf_mpd_write_m3u8_playlist(mpd, period, as, rep, name, hls_version, max_part_dur_session);
+
+			e = gf_mpd_write_m3u8_playlist(mpd, period, as, rep, name, hls_version, max_part_dur_session,
+				((mpd->hls_abs_url==1) || (mpd->hls_abs_url==3)) ? force_base_url : NULL);
 			if (e) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("M3U8 IO error while opening m3u8 files\n"));
 				return GF_IO_ERR;
@@ -3989,8 +4105,14 @@
 				name = szSuffixName;
 			}
 
-			gf_mpd_write_m3u8_playlist_tags(as, i, rep, out, name, is_primary ? period : NULL, nb_audio, nb_subs, nb_cc);
+
+			char *force_url = NULL;
+			if (force_base_url && ((mpd->hls_abs_url==2) || (mpd->hls_abs_url==3)))
+				force_url = gf_url_concatenate(force_base_url, name);
+
+			gf_mpd_write_m3u8_playlist_tags(as, i, rep, out, force_url ? force_url : name, is_primary ? period : NULL, nb_audio, nb_subs, nb_cc);
 			gf_fprintf(out, "\n");
+			if (force_url) gf_free(force_url);
 		}
 	}
 	gf_free(m3u8_name_rad);
@@ -4037,7 +4159,7 @@
 	mpd_write_generation_comment(mpd, out);
 	gf_fprintf(out, "<MPD xmlns=\"%s\"", (mpd->xml_namespace ? mpd->xml_namespace : "urn:mpeg:dash:schema:mpd:2011"));
 
-	if (mpd->write_context) {
+	if (mpd->write_context || mpd->use_gpac_ext) {
 	 	gf_fprintf(out, " xmlns:gpac=\"urn:gpac:filters:dasher:2018\"" );
 	}
 
@@ -4793,7 +4915,7 @@
 	GF_MPD_Period const * const period, GF_MPD_AdaptationSet const * const set, GF_MPD_Representation const * const rep,
 	u64 *out_segment_start_time, u64 *out_opt_segment_duration, u32 *out_opt_scale)
 {
-	u64 duration = 0, start_time = 0;
+	u64 duration = 0, start_time = 0, pto = 0;
 	u32 timescale = 0;
 	GF_List *seglist = NULL;
 	GF_MPD_SegmentTimeline *timeline = NULL;
@@ -4812,23 +4934,27 @@
 			if (period->segment_list->duration) duration = period->segment_list->duration;
 			if (period->segment_list->timescale) timescale = period->segment_list->timescale;
 			if (period->segment_list->segment_timeline) timeline = period->segment_list->segment_timeline;
+			if (period->segment_list->presentation_time_offset) pto = period->segment_list->presentation_time_offset;
 			if (gf_list_count(period->segment_list->segment_URLs)) seglist = period->segment_list->segment_URLs;
 		}
 		if (set->segment_list) {
 			if (set->segment_list->duration) duration = set->segment_list->duration;
 			if (set->segment_list->timescale) timescale = set->segment_list->timescale;
 			if (set->segment_list->segment_timeline) timeline = set->segment_list->segment_timeline;
+			if (set->segment_list->presentation_time_offset) pto = set->segment_list->presentation_time_offset;
 			if (gf_list_count(set->segment_list->segment_URLs)) seglist = set->segment_list->segment_URLs;
 		}
 		if (rep->segment_list) {
 			if (rep->segment_list->duration) duration = rep->segment_list->duration;
 			if (rep->segment_list->timescale) timescale = rep->segment_list->timescale;
+			if (rep->segment_list->presentation_time_offset) pto = rep->segment_list->presentation_time_offset;
 			if (gf_list_count(rep->segment_list->segment_URLs)) seglist = rep->segment_list->segment_URLs;
 		}
 		if (!timescale) timescale = 1;
 
 		if (timeline) {
 			start_time = gf_mpd_segment_timeline_start(timeline, in_segment_index, &duration);
+			start_time -= pto;
 		}
 		else if (duration) {
 			start_time = in_segment_index * duration;
@@ -4861,22 +4987,26 @@
 		if (period->segment_template->duration) duration = period->segment_template->duration;
 		if (period->segment_template->timescale) timescale = period->segment_template->timescale;
 		if (period->segment_template->segment_timeline) timeline = period->segment_template->segment_timeline;
+		if (period->segment_template->presentation_time_offset) pto = period->segment_template->presentation_time_offset;
 
 	}
 	if (set->segment_template) {
 		if (set->segment_template->duration) duration = set->segment_template->duration;
 		if (set->segment_template->timescale) timescale = set->segment_template->timescale;
 		if (set->segment_template->segment_timeline) timeline = set->segment_template->segment_timeline;
+		if (set->segment_template->presentation_time_offset) pto = set->segment_template->presentation_time_offset;
 	}
 	if (rep->segment_template) {
 		if (rep->segment_template->duration) duration = rep->segment_template->duration;
 		if (rep->segment_template->timescale) timescale = rep->segment_template->timescale;
 		if (rep->segment_template->segment_timeline) timeline = rep->segment_template->segment_timeline;
+		if (rep->segment_template->presentation_time_offset) pto = rep->segment_template->presentation_time_offset;
 	}
 	if (!timescale) timescale = 1;
 
 	if (timeline) {
 		start_time = gf_mpd_segment_timeline_start(timeline, in_segment_index, &duration);
+		start_time -= pto;
 	}
 	else {
 		start_time = in_segment_index * duration;
@@ -5646,7 +5776,7 @@
 			while (gf_list_count(set->representations)>1) {
 				FILE *f = gf_file_temp(NULL);
 				u32 size;
-				char *data, szAdd100;
+				char *data, *blob_add;
 				GF_Blob blob;
 				GF_DOMParser *dom;
 				GF_XMLNode *root;
@@ -5671,18 +5801,22 @@
 				gf_fseek(f, 0, SEEK_SET);
 				size = (u32) gf_fread(data, size, f);
 				datasize=0;
+
 				memset(&blob, 0, sizeof(GF_Blob));
 				blob.data = data;
 				blob.size = size;
-				sprintf(szAdd, "gmem://%p", &blob);
+
+				blob_add = gf_blob_register(&blob);
 
 				//parse
 				dom = gf_xml_dom_new();
-				gf_xml_dom_parse(dom, szAdd, NULL, NULL);
+				gf_xml_dom_parse(dom, blob_add, NULL, NULL);
 				root = gf_xml_dom_get_root(dom);
 				gf_mpd_parse_adaptation_set(mpd, new_as, root);
 				gf_xml_dom_del(dom);
 				gf_free(data);
+				if (blob_add) gf_free(blob_add);
+				gf_blob_unregister(&blob);
 				gf_fclose(f);
 
 				
@@ -5708,4 +5842,4 @@
 }
 
 
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
+#endif /*GPAC_DISABLE_MPD*/

gpac-2.0.0.tar.gz/src/media_tools/mpeg2_ps.c -> gpac-2.2.0.tar.gz/src/media_tools/mpeg2_ps.c Changed

gpac-2.0.0.tar.gz/src/media_tools/mpegts.c -> gpac-2.2.0.tar.gz/src/media_tools/mpegts.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2005-2020
+ *			Copyright (c) Telecom ParisTech 2005-2022
 *
 * This file is part of GPAC / MPEG2-TS sub-project
 *
@@ -332,6 +332,11 @@
 
 static void gf_m2ts_es_del(GF_M2TS_ES *es, GF_M2TS_Demuxer *ts)
 {
+	//es is reused (PCR streams only, reuse at most one), remove reuse flag
+	if (es->flags & GF_M2TS_ES_IS_PCR_REUSE) {
+		es->flags &= ~GF_M2TS_ES_IS_PCR_REUSE;
+		return;
+	}
 	gf_list_del_item(es->program->streams, es);
 
 	if (ts->on_event)
@@ -1361,6 +1366,7 @@
 		case GF_M2TS_AUDIO_AC3:
 		case GF_M2TS_AUDIO_EC3:
 		case GF_M2TS_AUDIO_DTS:
+		case GF_M2TS_AUDIO_TRUEHD:
 		case GF_M2TS_AUDIO_OPUS:
 		case GF_M2TS_MHAS_MAIN:
 		case GF_M2TS_MHAS_AUX:
@@ -1502,10 +1508,14 @@
 						/* cf https://smpte-ra.org/registered-mpeg-ts-ids */
 						switch (reg_desc_format) {
 						case GF_M2TS_RA_STREAM_AC3:
-							es->stream_type = GF_M2TS_AUDIO_AC3;
+							//don't overwrite if alread EAC3 or TrueHD
+							if ((es->stream_type != GF_M2TS_AUDIO_EC3) && (es->stream_type != GF_M2TS_AUDIO_TRUEHD))
+								es->stream_type = GF_M2TS_AUDIO_AC3;
 							break;
 						case GF_M2TS_RA_STREAM_EAC3:
-							es->stream_type = GF_M2TS_AUDIO_EC3;
+							//don't overwrite if alread AC3 or TrueHD
+							if ((es->stream_type != GF_M2TS_AUDIO_AC3) && (es->stream_type != GF_M2TS_AUDIO_TRUEHD))
+								es->stream_type = GF_M2TS_AUDIO_EC3;
 							break;
 						case GF_M2TS_RA_STREAM_VC1:
 							es->stream_type = GF_M2TS_VIDEO_VC1;
@@ -1523,13 +1533,22 @@
 							break;
 						case GF_M2TS_RA_STREAM_DOVI:
 							break;
+						case GF_M2TS_RA_STREAM_AV1:
+							es->stream_type = GF_M2TS_VIDEO_AV1;
+							break;
 
 						case GF_M2TS_RA_STREAM_GPAC:
-							if (len==8) {
-								es->stream_type = GF_4CC(data6, data7, data8, data9);
-								es->flags |= GF_M2TS_GPAC_CODEC_ID;
-								break;
+							if (len<8) break;
+							es->stream_type = GF_4CC(data6, data7, data8, data9);
+							es->flags |= GF_M2TS_GPAC_CODEC_ID;
+							if ((len>12) && (es->flags & GF_M2TS_ES_IS_PES)) {
+								pes = (GF_M2TS_PES*)es;
+								pes->gpac_meta_dsi_size = len-4;
+								pes->gpac_meta_dsi = gf_realloc(pes->gpac_meta_dsi, pes->gpac_meta_dsi_size);
+								if (pes->gpac_meta_dsi)
+									memcpy(pes->gpac_meta_dsi, data+6, pes->gpac_meta_dsi_size);
 							}
+							break;
 						default:
 							GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("Unknown registration descriptor %s\n", gf_4cc_to_str(reg_desc_format) ));
 							break;
@@ -1838,11 +1857,6 @@
 			gf_list_add(prog->streams, pmt);
 			pmt->pid = prog->pmt_pid;
 			pmt->program = prog;
-/*			if (ts->esspmt->pid) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("Redefinition of pmt for pid %d\n", pid));
-				gf_m2ts_es_del(ts->esspmt->pid, ts);
-			}
-*/
 			ts->esspmt->pid = (GF_M2TS_ES *)pmt;
 			pmt->sec = gf_m2ts_section_filter_new(gf_m2ts_process_pmt, 0);
 		}
@@ -2035,12 +2049,14 @@
 	if ((pes->pck_data_len >= 4) && !pes->pck_data0 && !pes->pck_data1 && (pes->pck_data2 == 0x1)) {
 		u32 len;
 		Bool has_pes_header = GF_TRUE;
+		Bool has_data = GF_TRUE;
 		u32 stream_id = pes->pck_data3;
 		Bool same_pts = GF_FALSE;
 
 		switch (stream_id) {
-		case GF_M2_STREAMID_PROGRAM_STREAM_MAP:
 		case GF_M2_STREAMID_PADDING:
+			has_data = GF_FALSE;
+		case GF_M2_STREAMID_PROGRAM_STREAM_MAP:
 		case GF_M2_STREAMID_PRIVATE_2:
 		case GF_M2_STREAMID_ECM:
 		case GF_M2_STREAMID_EMM:
@@ -2072,7 +2088,9 @@
 			if (pesh.PTS) {
 				if (pesh.PTS == pes->PTS) {
 					same_pts = GF_TRUE;
-					if (!pes->is_resume) {
+					if ((pes->stream_type==GF_M2TS_AUDIO_TRUEHD) || (pes->stream_type==GF_M2TS_AUDIO_EC3)) {
+						same_pts = GF_FALSE;
+					} else if (!pes->is_resume) {
 						GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS PID %d - same PTS "LLU" for two consecutive PES packets \n", pes->pid, pes->PTS));
 					}
 				}
@@ -2088,7 +2106,10 @@
 #ifndef GPAC_DISABLE_LOG
 				{
 					if (!pes->is_resume && pes->DTS && (pesh.DTS == pes->DTS)) {
-						GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS PID %d - same DTS "LLU" for two consecutive PES packets \n", pes->pid, pes->DTS));
+						if ((pes->stream_type==GF_M2TS_AUDIO_TRUEHD) || (pes->stream_type==GF_M2TS_AUDIO_EC3)) {
+						} else {
+							GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS PID %d - same DTS "LLU" for two consecutive PES packets \n", pes->pid, pes->DTS));
+						}
 					}
 					if (pesh.DTS < pes->DTS) {
 						GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS PID %d - DTS "LLU" less than previous DTS "LLU"\n", pes->pid, pesh.DTS, pes->DTS));
@@ -2108,6 +2129,8 @@
 			len = 9 + pesh.hdr_data_len;
 
 		} else {
+			if (!has_data) goto exit;
+			
 			/*3-byte start-code + 1 byte streamid*/
 			len = 4;
 			memset(&pesh, 0, sizeof(pesh));
@@ -2126,7 +2149,10 @@
 			} else {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("MPEG-2 TS Bad SL Packet size: (%d indicated < %d header)\n", pes->pid, pes->pck_data_len, len));
 			}
-		} else if (pes->reframe) {
+			goto exit;
+		}
+
+		if (pes->reframe) {
 			u32 remain = 0;
 			u32 offset = len;
 
@@ -2178,6 +2204,8 @@
 	} else if (pes->pck_data_len) {
 		GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("MPEG-2 TS PES %d: Bad PES Header, discarding packet (maybe stream is encrypted ?)\n", pes->pid));
 	}
+
+exit:
 	pes->pck_data_len = 0;
 	pes->pes_len = 0;
 	pes->rap = 0;
@@ -2571,7 +2599,7 @@
 					GF_M2TS_PES *pes = (GF_M2TS_PES *) gf_list_get(program->streams, j);
 					if (pes->flags & GF_M2TS_INHERIT_PCR) {
 						ts->esshdr.pid = (GF_M2TS_ES *) pes;
-						pes->flags |= GF_M2TS_FAKE_PCR;
+						pes->flags |= GF_M2TS_FAKE_PCR | GF_M2TS_ES_IS_PCR_REUSE;
 						break;
 					}
 					if (pes->flags & GF_M2TS_ES_IS_PES) {
@@ -2646,7 +2674,7 @@
 					pck.flags = GF_M2TS_PES_PCK_DISCONTINUITY;
 				}
 			}
-			else if ( (es->program->last_pcr_value < es->program->before_last_pcr_value) ) {
+			else if ((es->flags & GF_M2TS_CHECK_DISC) && (es->program->last_pcr_value < es->program->before_last_pcr_value) ) {
 				s64 diff_in_us = (s64) (es->program->last_pcr_value - es->program->before_last_pcr_value) / 27;
 				//if less than 200 ms before PCR loop at the last PCR, this is a PCR loop
 				if (GF_M2TS_MAX_PCR - es->program->before_last_pcr_value < 5400000 /*2*2700000*/) {
@@ -2782,7 +2810,10 @@
 			return e;
 		}
 		/*process*/
-		e |= gf_m2ts_process_packet(ts, (unsigned char *)data + pos);
+		GF_Err pck_e = gf_m2ts_process_packet(ts, (unsigned char *)data + pos);
+		if (pck_e==GF_NOT_SUPPORTED) pck_e = GF_OK;
+		e |= pck_e;
+
 		pos += pck_size;
 	}
 	return e;
@@ -3077,7 +3108,7 @@
 	if (ts->tdt_tot) gf_m2ts_section_filter_del(ts->tdt_tot);
 
 	for (i=0; i<GF_M2TS_MAX_STREAMS; i++) {
-		//bacause of pure PCR streams, en ES might be reassigned on 2 PIDs, one for the ES and one for the PCR
+		//because of pure PCR streams, an ES might be reassigned on 2 PIDs, one for the ES and one for the PCR
 		if (ts->essi && (ts->essi->pid==i)) {
 			gf_m2ts_es_del(ts->essi, ts);
 		}
@@ -3090,6 +3121,8 @@
 		while (gf_list_count(p->streams)) {
 			GF_M2TS_ES *es = (GF_M2TS_ES *)gf_list_last(p->streams);
 			gf_list_rem_last(p->streams);
+			//force destroy
+			es->flags &= ~GF_M2TS_ES_IS_PCR_REUSE;
 			gf_m2ts_es_del(es, ts);
 		}
 		gf_list_del(p->streams);
@@ -3145,7 +3178,7 @@
 void gf_m2ts_print_info(GF_M2TS_Demuxer *ts)
 {
 #ifdef GPAC_ENABLE_MPE
-	gf_m2ts_print_mpe_info(ts);
+	gf_dvb_mpe_print_info(ts);
 #endif
 }
 #endif
@@ -3172,6 +3205,8 @@
 			nb_pck = size/192;
 		else
 			nb_pck = size/188;
+		//incomplete last packet
+		if (ts->buffer_size) nb_pck--;
 		//probe success if after align we have nb_pck - 2 and at least 2 packets
 		if ((nb_pck<2) || (ts->pck_number + 2 < nb_pck))
 			e = GF_BAD_PARAM;

gpac-2.0.0.tar.gz/src/media_tools/route_dmx.c -> gpac-2.2.0.tar.gz/src/media_tools/route_dmx.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2018-2020
+ *			Copyright (c) Telecom ParisTech 2018-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Media Tools ROUTE (ATSC3, DVB-I) demux sub-project
@@ -25,7 +25,7 @@
 
 #include <gpac/route.h>
 
-#if !defined(GPAC_DISABLE_ROUTE) && !defined(GPAC_DISABLE_CORE_TOOLS)
+#if !defined(GPAC_DISABLE_ROUTE)
 
 #include <gpac/network.h>
 #include <gpac/bitstream.h>
@@ -329,7 +329,6 @@
 		GF_LOG(GF_LOG_ERROR, GF_LOG_ROUTE, ("ROUTE Failed to create UDP socket\n"));
 		return NULL;
 	}
-	gf_sk_group_register(routedmx->active_sockets, routedmx->atsc_sock);
 
 	gf_sk_set_usec_wait(routedmx->atsc_sock, 1);
 	e = gf_sk_setup_multicast(routedmx->atsc_sock, GF_ATSC_MCAST_ADDR, GF_ATSC_MCAST_PORT, 1, GF_FALSE, (char *) ifce);
@@ -340,6 +339,8 @@
 	}
 	gf_sk_set_buffer_size(routedmx->atsc_sock, GF_FALSE, sock_buffer_size);
 	//gf_sk_set_block_mode(routedmx->sock, GF_TRUE);
+
+	gf_sk_group_register(routedmx->active_sockets, routedmx->atsc_sock);
 	return routedmx;
 }
 
@@ -766,6 +767,14 @@
 				obj->nb_frags = obj->nb_recv_frags = 0;
 				obj->nb_bytes = obj->nb_recv_bytes = 0;
 				obj->total_length = total_len;
+				if (obj->total_length>obj->alloc_size) {
+					gf_mx_p(routedmx->blob_mx);
+					obj->payload = gf_realloc(obj->payload, obj->total_length);
+					obj->alloc_size = obj->total_length;
+					obj->blob.size = obj->total_length;
+					obj->blob.data = obj->payload;
+					gf_mx_v(routedmx->blob_mx);
+				}
 				obj->toi = toi;
 				obj->status = GF_LCT_OBJ_INIT;
 				break;
@@ -2044,4 +2053,4 @@
 	if (routedmx) routedmx->debug_tsi = tsi;
 }
 
-#endif /* !GPAC_DISABLE_ROUTE && !GPAC_DISABLE_CORE_TOOLS */
+#endif /* !GPAC_DISABLE_ROUTE */

gpac-2.0.0.tar.gz/src/media_tools/webvtt.c -> gpac-2.2.0.tar.gz/src/media_tools/webvtt.c Changed

@@ -1,8 +1,8 @@
 /*
  *          GPAC - Multimedia Framework C SDK
  *
- *          Authors: Cyril Concolato
- *          Copyright (c) Telecom ParisTech 2000-2021
+ *          Authors: Cyril Concolato, Jean Le Feuvre
+ *          Copyright (c) Telecom ParisTech 2000-2022
  *                  All rights reserved
  *
  *  This file is part of GPAC / ISO Media File Format sub-project
@@ -272,6 +272,13 @@
 	GF_VTTCueBox *cuebox;
 	if (!cue) return GF_OK;
 
+	if (cue->pre_text) {
+		GF_Box *b = boxstring_new_with_data(GF_ISOM_BOX_TYPE_VTTA, cue->pre_text, NULL);
+		e = gf_isom_box_size(b);
+		if (!e) e = gf_isom_box_write(b, bs);
+		gf_isom_box_del(b);
+	}
+
 	cuebox = (GF_VTTCueBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_VTCC_CUE);
 
 	if (cue->id) {
@@ -333,6 +340,14 @@
 	res->IsRAP = RAP;
 	return res;
 }
+
+u32 gf_isom_webvtt_cues_count(void *s)
+{
+	GF_WebVTTSample *samp = (GF_WebVTTSample *)s;
+	if (!samp) return 0;
+	return gf_list_count(samp->cues);
+}
+
 #endif /*GPAC_DISABLE_ISOM_WRITE*/
 
 #ifndef GPAC_DISABLE_ISOM_DUMP
@@ -409,7 +424,8 @@
 
 struct _webvtt_parser {
 	GF_WebVTTParserState state;
-	Bool is_srt, suspend, is_eof;
+	Bool is_srt, suspend, is_eof, prev_line_empty, in_comment;
+	char *comment_text;
 
 	/* List of non-overlapping GF_WebVTTSample */
 	GF_List *samples;
@@ -495,7 +511,7 @@
 	if (*prop) {
 		len = (u32) strlen(*prop);
 		(*prop) = (char*)gf_realloc((*prop), sizeof(char) * (len + text_len + 1) );
-		strncpy((*prop) + len, text_data, text_len);
+		memcpy((*prop) + len, text_data, text_len);
 		(*prop)len+text_len = 0;
 	} else {
 		*prop = gf_strdup(text_data);
@@ -615,6 +631,10 @@
 		gf_webvtt_sample_del((GF_WebVTTSample *)gf_list_get(parser->samples, 0));
 		gf_list_rem(parser->samples, 0);
 	}
+	if (parser->comment_text) gf_free(parser->comment_text);
+	parser->comment_text = NULL;
+	parser->prev_line_empty = GF_FALSE;
+	parser->in_comment = GF_FALSE;
 	parser->last_duration = 0;
 	parser->on_header_parsed = NULL;
 	parser->on_sample_parsed = NULL;
@@ -911,13 +931,12 @@
 	return e;
 }
 
-GF_Err gf_webvtt_parser_parse(GF_WebVTTParser *parser)
+GF_Err gf_webvtt_parser_parse_internal(GF_WebVTTParser *parser, GF_WebVTTCue *cue)
 {
 	char szLine2048;
 	char *sOK;
 	u32 len;
 	GF_Err e;
-	GF_WebVTTCue *cue = NULL;
 	char *prevLine = NULL;
 	char *header = NULL;
 	u32 header_len = 0;
@@ -997,7 +1016,7 @@
 				} else {
 					/* discard the previous line */
 					/* should we do something with it ? callback ?*/
-					if (prevLine) {
+					if (prevLine && !parser->in_comment) {
 						gf_free(prevLine);
 						prevLine = NULL;
 					}
@@ -1006,13 +1025,29 @@
 						szLinelen = '\n';
 						len++;
 					}
-					prevLine = gf_strdup(szLine);
+					if (prevLine)
+						gf_dynstrcat(&prevLine, szLine, NULL);
+					else
+						prevLine = gf_strdup(szLine);
+					if (parser->prev_line_empty && (!strncmp(prevLine, "NOTE ", 5) || !strcmp(prevLine, "NOTE\n")))
+						parser->in_comment = GF_TRUE;
 					/* stay in the same state */
 					break;
 				}
 			} else {
 				/* discard the previous line */
 				/* should we do something with it ? callback ?*/
+				if (parser->in_comment) {
+					if (!parser->comment_text) {
+						parser->comment_text = prevLine;
+						prevLine = NULL;
+					} else {
+						gf_dynstrcat(&parser->comment_text, prevLine, "\n");
+						gf_free(prevLine);
+						prevLine = NULL;
+					}
+					parser->in_comment = GF_FALSE;
+				}
 				if (prevLine) {
 					gf_free(prevLine);
 					prevLine = NULL;
@@ -1035,6 +1070,11 @@
 					gf_free(prevLine);
 					prevLine = NULL;
 				}
+				if (parser->comment_text) {
+					gf_webvtt_cue_add_property(cue, WEBVTT_PRECUE_TEXT, parser->comment_text, (u32) strlen(parser->comment_text));
+					gf_free(parser->comment_text);
+					parser->comment_text = NULL;
+				}
 				e = gf_webvtt_parser_parse_timings_settings(parser, cue, szLine, len);
 				if (e) {
 					if (cue) gf_webvtt_cue_del(cue);
@@ -1052,17 +1092,31 @@
 			break;
 		case WEBVTT_PARSER_STATE_WAITING_CUE_PAYLOAD:
 			if (sOK && len) {
+				if (!strncmp(szLine, "NOTE ", 5)) {
+					if (had_marks) {
+						szLinelen = '\n';
+						len++;
+					}
+					gf_webvtt_cue_add_property(cue, WEBVTT_POSTCUE_TEXT, szLine, len);
+					parser->in_comment = GF_TRUE;
+					len = 0;
+				} else if (parser->in_comment) {
+					parser->in_comment = GF_FALSE;
+				}
+			}
+			if (sOK && len) {
 				if (had_marks) {
 					szLinelen = '\n';
 					len++;
 				}
-				gf_webvtt_cue_add_property(cue, WEBVTT_PAYLOAD, szLine, len);
+				gf_webvtt_cue_add_property(cue, parser->in_comment ? WEBVTT_POSTCUE_TEXT : WEBVTT_PAYLOAD, szLine, len);
 				/* remain in the same state as a cue payload can have multiple lines */
 				break;
 			} else {
 				/* end of the current cue */
 				gf_webvtt_add_cue_to_samples(parser, parser->samples, cue);
 				cue = NULL;
+				parser->in_comment = GF_FALSE;
 
 				if (!sOK) {
 					parser->is_eof = GF_TRUE;
@@ -1074,6 +1128,7 @@
 				}
 			}
 		}
+		parser->prev_line_empty = len ? GF_FALSE : GF_TRUE;
 	}
 	if (header) gf_free(header);
 	header = NULL;
@@ -1100,6 +1155,38 @@
 	return e;
 }
 
+GF_Err gf_webvtt_parser_parse(GF_WebVTTParser *parser)
+{
+	return gf_webvtt_parser_parse_internal(parser, NULL);
+}
+
+GF_Err gf_webvtt_parser_flush(GF_WebVTTParser *parser)
+{
+	while (gf_list_count(parser->samples) > 0) {
+		GF_WebVTTSample *sample = (GF_WebVTTSample *)gf_list_get(parser->samples, 0);
+		parser->last_duration = (sample->end > sample->start) ? sample->end - sample->start : 0;
+		gf_list_rem(parser->samples, 0);
+		parser->on_sample_parsed(parser->user, sample);
+	}
+	return GF_OK;
+}
+
+GF_Err gf_webvtt_parser_parse_payload(GF_WebVTTParser *parser, u64 start, u64 end, const char *vtt_pre, const char *vtt_cueid, const char *vtt_settings)
+{
+	GF_WebVTTCue *cue = gf_webvtt_cue_new();
+	parser->state = WEBVTT_PARSER_STATE_WAITING_CUE_PAYLOAD;
+	gf_webvtt_timestamp_set(&cue->start, start);
+	gf_webvtt_timestamp_set(&cue->end, end);
+
+	if (vtt_cueid) cue->id = gf_strdup(vtt_cueid);
+	if (vtt_settings) cue->settings = gf_strdup(vtt_settings);
+	if (vtt_pre) cue->pre_text = gf_strdup(vtt_pre);
+
+	GF_Err e = gf_webvtt_parser_parse_internal(parser, cue);
+	parser->is_eof = GF_FALSE;
+	return e;
+}
+
 GF_EXPORT
 GF_List *gf_webvtt_parse_iso_cues(GF_ISOSample *iso_sample, u64 start, u64 end)
 {

gpac-2.0.0.tar.gz/src/odf/desc_private.c -> gpac-2.2.0.tar.gz/src/odf/desc_private.c Changed

gpac-2.0.0.tar.gz/src/odf/descriptors.c -> gpac-2.2.0.tar.gz/src/odf/descriptors.c Changed

@@ -605,17 +605,20 @@
 		u32 size = gf_bs_read_int(bs, 16);
 		if ((size>gf_bs_available(bs)) || (size<2)) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("AVC Wrong param set size %d\n", size));
+			gf_bs_del(bs);
 			gf_odf_avc_cfg_del(avcc);
 			return NULL;
 		}
 		GF_SAFEALLOC(sl, GF_NALUFFParam );
 		if (!sl) {
+			gf_bs_del(bs);
 			gf_odf_avc_cfg_del(avcc);
 			return NULL;
 		}
 		sl->size = size;
 		sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
 		if (!sl->data) {
+			gf_bs_del(bs);
 			gf_odf_avc_cfg_del(avcc);
 			return NULL;
 		}
@@ -628,17 +631,20 @@
 		u32 size = gf_bs_read_int(bs, 16);
 		if ((size>gf_bs_available(bs)) || (size<2)) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("AVC Wrong param set size %d\n", size));
+			gf_bs_del(bs);
 			gf_odf_avc_cfg_del(avcc);
 			return NULL;
 		}
 		GF_SAFEALLOC(sl, GF_NALUFFParam );
 		if (!sl) {
+			gf_bs_del(bs);
 			gf_odf_avc_cfg_del(avcc);
 			return NULL;
 		}
 		sl->size = size;
 		sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
 		if (!sl->data) {
+			gf_bs_del(bs);
 			gf_odf_avc_cfg_del(avcc);
 			return NULL;
 		}
@@ -661,17 +667,20 @@
 				u32 size = gf_bs_read_int(bs, 16);
 				if ((size>gf_bs_available(bs)) || (size<2)) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("AVC Wrong param set size %d\n", size));
+					gf_bs_del(bs);
 					gf_odf_avc_cfg_del(avcc);
 					return NULL;
 				}
 				GF_SAFEALLOC(sl, GF_NALUFFParam );
 				if (!sl) {
+					gf_bs_del(bs);
 					gf_odf_avc_cfg_del(avcc);
 					return NULL;
 				}
 				sl->size = size;
 				sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
 				if (!sl->data) {
+					gf_bs_del(bs);
 					gf_odf_avc_cfg_del(avcc);
 					return NULL;
 				}
@@ -708,6 +717,7 @@
 GF_EXPORT
 GF_TextSampleDescriptor *gf_odf_tx3g_read(u8 *dsi, u32 dsi_size)
 {
+#ifndef GPAC_DISABLE_ISOM
 	u32 i;
 	u32 gpp_read_rgba(GF_BitStream *bs);
 	void gpp_read_style(GF_BitStream *bs, GF_StyleRecord *rec);
@@ -733,10 +743,14 @@
 	}
 	gf_bs_del(bs);
 	return txtc;
+#else
+	return NULL;
+#endif
 }
 
 GF_Err gf_odf_tx3g_write(GF_TextSampleDescriptor *a, u8 **outData, u32 *outSize)
 {
+#ifndef GPAC_DISABLE_ISOM
 	u32 j;
 	void gpp_write_rgba(GF_BitStream *bs, u32 col);
 	void gpp_write_box(GF_BitStream *bs, GF_BoxRecord *rec);
@@ -763,6 +777,9 @@
 	gf_bs_get_content(bs, outData, outSize);
 	gf_bs_del(bs);
 	return GF_OK;
+#else
+	return GF_NOT_SUPPORTED;
+#endif
 }
 
 /*TextConfig*/
@@ -1353,6 +1370,7 @@
 	count = gf_bs_read_int(bs, 8);
 	for (i=0; i<count; i++) {
 		u32 nalucount, j;
+		Bool valid = GF_FALSE;
 		GF_NALUFFParamArray *ar;
 		GF_SAFEALLOC(ar, GF_NALUFFParamArray);
 		if (!ar) {
@@ -1360,13 +1378,28 @@
 			GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("VVC alloc failed while parsing vvc config\n"));
 			return NULL;
 		}
-		ar->nalus = gf_list_new();
-		gf_list_add(cfg->param_array, ar);
-
 		ar->array_completeness = gf_bs_read_int(bs, 1);
 		gf_bs_read_int(bs, 2);
 		ar->type = gf_bs_read_int(bs, 5);
 
+		switch (ar->type) {
+		case GF_VVC_NALU_DEC_PARAM:
+		case GF_VVC_NALU_OPI:
+		case GF_VVC_NALU_VID_PARAM:
+		case GF_VVC_NALU_SEQ_PARAM:
+		case GF_VVC_NALU_PIC_PARAM:
+		case GF_VVC_NALU_SEI_PREFIX:
+		case GF_VVC_NALU_SEI_SUFFIX:
+			valid = GF_TRUE;
+			ar->nalus = gf_list_new();
+			gf_list_add(cfg->param_array, ar);
+			break;
+		default:
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("VVC Invalid NALU type in vvcC - ignoring\n", ar->nalus));
+			gf_free(ar);
+			break;
+		}
+
 		if ((ar->type != GF_VVC_NALU_DEC_PARAM) && (ar->type != GF_VVC_NALU_OPI))
 			nalucount = gf_bs_read_int(bs, 16);
 		else
@@ -1380,6 +1413,10 @@
 				gf_odf_vvc_cfg_del(cfg);
 				return NULL;
 			}
+			if (!valid) {
+				gf_bs_skip_bytes(bs, size);
+				continue;
+			}
 			GF_SAFEALLOC(sl, GF_NALUFFParam );
 			if (!sl) {
 				gf_odf_vvc_cfg_del(cfg);
@@ -1768,7 +1805,13 @@
 	GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 	GF_Err e = gf_odf_ac3_cfg_write_bs(cfg, bs);
 
+	if (cfg->is_ec3 && (cfg->atmos_ec3_ext || cfg->complexity_index_type)) {
+		gf_bs_write_int(bs, 0, 7);
+		gf_bs_write_int(bs, cfg->atmos_ec3_ext, 1);
+		gf_bs_write_u8(bs, cfg->complexity_index_type);
+	}
 	gf_bs_get_content(bs, data, size);
+
 	gf_bs_del(bs);
 	return e;
 }
@@ -1819,6 +1862,66 @@
 	if (!cfg || !dsi) return GF_BAD_PARAM;
 	bs = gf_bs_new(dsi, dsi_len, GF_BITSTREAM_READ);
 	e = gf_odf_ac3_config_parse_bs(bs, is_ec3, cfg);
+	if (is_ec3 && gf_bs_available(bs)>=2) {
+		gf_bs_read_int(bs, 7);
+		cfg->atmos_ec3_ext = gf_bs_read_int(bs, 1);
+		cfg->complexity_index_type = gf_bs_read_u8(bs);
+	}
+	gf_bs_del(bs);
+	return e;
+}
+
+
+GF_Err gf_odf_opus_cfg_parse_bs(GF_BitStream *bs, GF_OpusConfig *cfg)
+{
+	memset(cfg, 0, sizeof(GF_OpusConfig));
+	cfg->version = gf_bs_read_u8(bs);
+	cfg->OutputChannelCount = gf_bs_read_u8(bs);
+	cfg->PreSkip = gf_bs_read_u16_le(bs);
+	cfg->InputSampleRate = gf_bs_read_u32_le(bs);
+	cfg->OutputGain = gf_bs_read_u16_le(bs);
+	cfg->ChannelMappingFamily = gf_bs_read_u8(bs);
+	if (cfg->ChannelMappingFamily) {
+		cfg->StreamCount = gf_bs_read_u8(bs);
+		cfg->CoupledCount = gf_bs_read_u8(bs);
+		gf_bs_read_data(bs, (char *) cfg->ChannelMapping, cfg->OutputChannelCount);
+	}
+	return GF_OK;
+}
+GF_Err gf_odf_opus_cfg_parse(u8 *dsi, u32 dsi_len, GF_OpusConfig *cfg)
+{
+	GF_BitStream *bs;
+	GF_Err e;
+	if (!cfg || !dsi) return GF_BAD_PARAM;
+	bs = gf_bs_new(dsi, dsi_len, GF_BITSTREAM_READ);
+	e = gf_odf_opus_cfg_parse_bs(bs, cfg);
+	gf_bs_del(bs);
+	return e;
+}
+
+GF_Err gf_odf_opus_cfg_write_bs(GF_OpusConfig *cfg, GF_BitStream *bs)
+{
+	if (!cfg || !bs) return GF_BAD_PARAM;
+	gf_bs_write_u8(bs, cfg->version);
+	gf_bs_write_u8(bs, cfg->OutputChannelCount);
+	gf_bs_write_u16_le(bs, cfg->PreSkip);
+	gf_bs_write_u32_le(bs, cfg->InputSampleRate);
+	gf_bs_write_u16_le(bs, cfg->OutputGain);
+	gf_bs_write_u8(bs, cfg->ChannelMappingFamily);
+	if (cfg->ChannelMappingFamily) {
+		gf_bs_write_u8(bs, cfg->StreamCount);
+		gf_bs_write_u8(bs, cfg->CoupledCount);
+		gf_bs_write_data(bs, (char *) cfg->ChannelMapping, cfg->OutputChannelCount);
+	}
+	return GF_OK;
+}
+
+GF_Err gf_odf_opus_cfg_write(GF_OpusConfig *cfg, u8 **data, u32 *size)
+{
+	GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
+	GF_Err e = gf_odf_opus_cfg_write_bs(cfg, bs);
+
+	gf_bs_get_content(bs, data, size);
 	gf_bs_del(bs);
 	return e;
 }

gpac-2.0.0.tar.gz/src/quickjs/quickjs-libc.c -> gpac-2.2.0.tar.gz/src/quickjs/quickjs-libc.c Changed

@@ -1,6 +1,6 @@
 /*
 * QuickJS C library
- * 
+ *
 * Copyright (c) 2017-2021 Fabrice Bellard
 * Copyright (c) 2017-2021 Charlie Gordon
 *
@@ -25,8 +25,6 @@
 
 #include <gpac/setup.h>
 
-#ifndef GPAC_DISABLE_QJS_LIBC
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
@@ -110,6 +108,9 @@
 
 #endif
 
+
+#ifndef GPAC_DISABLE_QJS_LIBC
+
 /* enable the os.Worker API. We rely on GF_Thread */
 #define USE_WORKER
 
@@ -249,7 +250,7 @@
 break;
 q = fmtbuf;
 *q++ = *fmt++; /* copy '%' */
- 
+
 /* flags */
 for(;;) {
 c = *fmt;
@@ -303,14 +304,14 @@
 if (*fmt == 'l') {
 mod = *fmt++;
 }
- 
+
 /* type */
 c = *fmt++;
 if (q >= fmtbuf + sizeof(fmtbuf) - 1)
 goto invalid;
 *q++ = c;
 *q = '\0';
- 
+
 switch (c) {
 case 'c':
 if (i >= argc)
@@ -332,7 +333,7 @@
 len = unicode_to_utf8(cbuf, int32_arg);
 dbuf_put(&dbuf, cbuf, len);
 break;
- 
+
 case 'd':
 case 'i':
 case 'o':
@@ -377,7 +378,7 @@
 dbuf_printf_fun(&dbuf, fmtbuf, string_arg);
 JS_FreeCString(ctx, string_arg);
 break;
- 
+
 case 'e':
 case 'f':
 case 'g':
@@ -392,11 +393,11 @@
 goto fail;
 dbuf_printf_fun(&dbuf, fmtbuf, double_arg);
 break;
- 
+
 case '%':
 dbuf_putc(&dbuf, '%');
 break;
- 
+
 default:
 /* XXX: should support an extension mechanism */
 invalid:
@@ -433,7 +434,7 @@
 uint8_t *buf;
 size_t buf_len;
 long lret;
- 
+
 f = fopen(filename, "rb");
 if (!f)
 return NULL;
@@ -480,7 +481,7 @@
 const char *filename;
 JSValue ret;
 size_t buf_len;
- 
+
 filename = JS_ToCString(ctx, argv0);
 if (!filename)
 return JS_EXCEPTION;
@@ -505,7 +506,7 @@
 const char *filename;
 JSValue ret;
 size_t buf_len;
- 
+
 filename = JS_ToCString(ctx, argv0);
 if (!filename)
 return JS_EXCEPTION;
@@ -538,7 +539,7 @@
 void *hd;
 JSInitModuleFunc *init;
 char *filename;
- 
+
 if (!strchr(module_name, '/')) {
 /* must add a '/' so that the DLL is not searched in the
 system library paths */
@@ -550,7 +551,7 @@
 } else {
 filename = (char *)module_name;
 }
- 
+
 /* C module */
 hd = dlopen(filename, RTLD_NOW | RTLD_LOCAL);
 if (filename != module_name)
@@ -598,7 +599,7 @@
 JSValue meta_obj;
 JSAtom module_name_atom;
 const char *module_name;
- 
+
 assert(JS_VALUE_GET_TAG(func_val) == JS_TAG_MODULE);
 m = JS_VALUE_GET_PTR(func_val);
 
@@ -629,7 +630,7 @@
 pstrcpy(buf, sizeof(buf), module_name);
 }
 JS_FreeCString(ctx, module_name);
- 
+
 meta_obj = JS_GetImportMeta(ctx, m);
 if (JS_IsException(meta_obj))
 return -1;
@@ -658,14 +659,14 @@
 size_t buf_len;
 uint8_t *buf;
 JSValue func_val;
- 
+
 buf = js_load_file(ctx, &buf_len, module_name);
 if (!buf) {
 JS_ThrowReferenceError(ctx, "could not load module filename '%s'",
 module_name);
 return NULL;
 }
- 
+
 /* compile the module */
 func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
 JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
@@ -836,7 +837,7 @@
 JSValueConst options_obj;
 BOOL backtrace_barrier = FALSE;
 int flags;
- 
+
 if (argc >= 2) {
 options_obj = argv1;
 if (get_bool_option(ctx, &backtrace_barrier, options_obj,
@@ -851,7 +852,7 @@
 /* install the interrupt handler */
 JS_SetInterruptHandler(JS_GetRuntime(ctx), interrupt_handler, NULL);
 }
- flags = JS_EVAL_TYPE_GLOBAL; 
+ flags = JS_EVAL_TYPE_GLOBAL;
 if (backtrace_barrier)
 flags |= JS_EVAL_FLAG_BACKTRACE_BARRIER;
 ret = JS_Eval(ctx, str, len, "<evalScript>", flags);
@@ -955,7 +956,7 @@
 const char *filename, *mode = NULL;
 FILE *f;
 int err;
- 
+
 filename = JS_ToCString(ctx, argv0);
 if (!filename)
 goto fail;
@@ -991,7 +992,7 @@
 const char *filename, *mode = NULL;
 FILE *f;
 int err;
- 
+
 filename = JS_ToCString(ctx, argv0);
 if (!filename)
 goto fail;
@@ -1105,7 +1106,7 @@
 if (!f)
 return JS_EXCEPTION;
 }
- 
+
 for(i = 0; i < argc; i++) {
 str = JS_ToCStringLen(ctx, &len, argvi);
 if (!str)
@@ -1228,7 +1229,7 @@
 uint64_t pos, len;
 size_t size, ret;
 uint8_t *buf;
- 
+
 if (!f)
 return JS_EXCEPTION;
 if (JS_ToIndex(ctx, &pos, argv1))
@@ -1255,7 +1256,7 @@
 int c;
 DynBuf dbuf;
 JSValue obj;
- 
+
 if (!f)
 return JS_EXCEPTION;
 
@@ -1294,7 +1295,7 @@
 uint64_t max_size64;
 size_t max_size;
 JSValueConst max_size_val;
- 
+
 if (!f)
 return JS_EXCEPTION;
 
@@ -1358,7 +1359,7 @@
 {
 int c;
 char *p;
- 
+
 p = buf;
 for(;;) {
 c = fgetc(f);
@@ -1394,21 +1395,21 @@
 DynBuf cmd_buf;
 DynBuf data_buf_s, *data_buf = &data_buf_s;
 DynBuf header_buf_s, *header_buf = &header_buf_s;
- char *buf; 
+ char *buf;
 size_t i, len;
 int c, status;
 JSValue response = JS_UNDEFINED, ret_obj;
 JSValueConst options_obj;
 FILE *f;
 BOOL binary_flag, full_flag;
- 
+
 url = JS_ToCString(ctx, argv0);
 if (!url)
 return JS_EXCEPTION;
- 
+
 binary_flag = FALSE;
 full_flag = FALSE;
- 
+
 if (argc >= 2) {
 options_obj = argv1;
 
@@ -1421,7 +1422,7 @@
 return JS_EXCEPTION;
 }
 }
- 
+
 js_std_dbuf_init(ctx, &cmd_buf);
 dbuf_printf(&cmd_buf, "%s ''", URL_GET_PROGRAM);
 len = strlen(url);
@@ -1447,7 +1448,7 @@
 
 js_std_dbuf_init(ctx, data_buf);
 js_std_dbuf_init(ctx, header_buf);
- 
+
 buf = js_malloc(ctx, URL_GET_BUF_SIZE);
 if (!buf)
 goto fail;
@@ -1461,7 +1462,7 @@
 if (!full_flag && !(status >= 200 && status <= 299)) {
 goto bad_header;
 }
- 
+
 /* wait until there is an empty line */
 for(;;) {
 if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, header_buf) < 0) {
@@ -1537,7 +1538,7 @@
 static JSClassDef js_std_file_class = {
 "FILE",
 .finalizer = js_std_file_finalizer,
-}; 
+};
 
 static const JSCFunctionListEntry js_std_error_props = {
 /* various errno values */
@@ -1569,7 +1570,7 @@
 JS_CFUNC_DEF("loadFile", 1, js_std_loadFile ),
 JS_CFUNC_DEF("strerror", 1, js_std_strerror ),
 JS_CFUNC_DEF("parseExtJSON", 1, js_std_parseExtJSON ),
- 
+
 /* FILE I/O */
 JS_CFUNC_DEF("open", 2, js_std_open ),
 JS_CFUNC_DEF("popen", 2, js_std_popen ),
@@ -1583,7 +1584,7 @@
 JS_PROP_INT32_DEF("SEEK_END", SEEK_END, JS_PROP_CONFIGURABLE ),
 JS_OBJECT_DEF("Error", js_std_error_props, countof(js_std_error_props), JS_PROP_CONFIGURABLE),
 };
- 
+
 static const JSCFunctionListEntry js_std_file_proto_funcs = {
 JS_CFUNC_DEF("close", 0, js_std_file_close ),
 JS_CFUNC_MAGIC_DEF("puts", 1, js_std_file_puts, 1 ),
@@ -1608,7 +1609,7 @@
 static int js_std_init(JSContext *ctx, JSModuleDef *m)
 {
 JSValue proto;
- 
+
 /* FILE class */
 /* the class ID is created once */
 JS_NewClassID(&js_std_file_class_id);
@@ -1689,7 +1690,7 @@
 int fd, whence;
 int64_t pos, ret;
 BOOL is_bigint;
- 
+
 if (JS_ToInt32(ctx, &fd, argv0))
 return JS_EXCEPTION;
 is_bigint = JS_IsBigInt(ctx, argv1);
@@ -1718,7 +1719,7 @@
 size_t size;
 ssize_t ret;
 uint8_t *buf;
- 
+
 if (JS_ToInt32(ctx, &fd, argv0))
 return JS_EXCEPTION;
 if (JS_ToIndex(ctx, &pos, argv2))
@@ -1766,7 +1767,7 @@
 if (JS_ToInt32(ctx, &fd, argv0))
 return JS_EXCEPTION;
 handle = (HANDLE)_get_osfhandle(fd);
- 
+
 if (!GetConsoleScreenBufferInfo(handle, &info))
 return JS_NULL;
 obj = JS_NewArray(ctx);
@@ -1805,7 +1806,7 @@
 int fd;
 struct winsize ws;
 JSValue obj;
- 
+
 if (JS_ToInt32(ctx, &fd, argv0))
 return JS_EXCEPTION;
 if (ioctl(fd, TIOCGWINSZ, &ws) == 0 &&
@@ -1834,10 +1835,10 @@
 {
 struct termios tty;
 int fd;
- 
+
 if (JS_ToInt32(ctx, &fd, argv0))
 return JS_EXCEPTION;
- 
+
 memset(&tty, 0, sizeof(tty));
 tcgetattr(fd, &tty);
 oldtty = tty;
@@ -1864,7 +1865,7 @@
 {
 const char *filename;
 int ret;
- 
+
 filename = JS_ToCString(ctx, argv0);
 if (!filename)
 return JS_EXCEPTION;
@@ -1890,7 +1891,7 @@
 {
 const char *oldpath, *newpath;
 int ret;
- 
+
 oldpath = JS_ToCString(ctx, argv0);
 if (!oldpath)
 return JS_EXCEPTION;
@@ -1942,7 +1943,7 @@
 JSOSRWHandler *rh;
 int fd;
 JSValueConst func;
- 
+
 if (JS_ToInt32(ctx, &fd, argv0))
 return JS_EXCEPTION;
 func = argv1;
@@ -2016,7 +2017,7 @@
 
 if (!is_main_thread(rt))
 return JS_ThrowTypeError(ctx, "signal handler can only be set in the main thread");
- 
+
 if (JS_ToUint32(ctx, &sig_num, argv0))
 return JS_EXCEPTION;
 if (sig_num >= 64)
@@ -2051,7 +2052,7 @@
 return JS_UNDEFINED;
 }
 
-#if defined(__linux__) || defined(__APPLE__)
+#if defined(__linux__) || ( defined(__APPLE__) && defined(CLOCK_MONOTONIC) )
 static int64_t get_time_ms(void)
 {
 struct timespec ts;
@@ -2159,7 +2160,7 @@
 "OSTimer",
 .finalizer = js_os_timer_finalizer,
 .gc_mark = js_os_timer_mark,
-}; 
+};
 
 static void call_handler(JSContext *ctx, JSValueConst func)
 {
@@ -2264,12 +2265,12 @@
 int64_t cur_time, delay;
 JSOSRWHandler *rh;
 struct list_head *el;
- 
+
 /* XXX: handle signals if useful */
 
 if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers) && list_empty(&ts->port_list))
 		return -1; /* no more events */
- 
+
 /* XXX: only timers and basic console input are supported */
 if (!list_empty(&ts->os_timers)) {
 cur_time = get_time_ms();
@@ -2375,7 +2376,7 @@
 unlikely(os_pending_signals != 0)) {
 JSOSSignalHandler *sh;
 uint64_t mask;
- 
+
 list_for_each(el, &ts->os_signal_handlers) {
 sh = list_entry(el, JSOSSignalHandler, link);
 mask = (uint64_t)1 << sh->sig_num;
@@ -2390,7 +2391,7 @@
 if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers) &&
 list_empty(&ts->port_list))
 return -1; /* no more events */
- 
+
 if (!list_empty(&ts->os_timers)) {
 cur_time = get_time_ms();
 min_delay = 10000;
@@ -2424,7 +2425,7 @@
 tvp = NULL;
 #endif
 	}
- 
+
 FD_ZERO(&rfds);
 FD_ZERO(&wfds);
 fd_max = -1;
@@ -2514,7 +2515,7 @@
 {
 char bufPATH_MAX;
 int err;
- 
+
 if (!getcwd(buf, sizeof(buf))) {
 buf0 = '\0';
 err = errno;
@@ -2543,7 +2544,7 @@
 {
 int mode, ret;
 const char *path;
- 
+
 if (argc >= 2) {
 if (JS_ToInt32(ctx, &mode, argv1))
 return JS_EXCEPTION;
@@ -2576,7 +2577,7 @@
 JSValue obj;
 int err;
 uint32_t len;
- 
+
 path = JS_ToCString(ctx, argv0);
 if (!path)
 return JS_EXCEPTION;
@@ -2725,7 +2726,7 @@
 const char *path;
 int64_t atime, mtime;
 int ret;
- 
+
 if (JS_ToInt64(ctx, &atime, argv1))
 return JS_EXCEPTION;
 if (JS_ToInt64(ctx, &mtime, argv2))
@@ -2758,7 +2759,7 @@
 {
 int64_t delay;
 int ret;
- 
+
 if (JS_ToInt64(ctx, &delay, argv0))
 return JS_EXCEPTION;
 if (delay < 0)
@@ -2822,7 +2823,7 @@
 {
 const char *target, *linkpath;
 int err;
- 
+
 target = JS_ToCString(ctx, argv0);
 if (!target)
 return JS_EXCEPTION;
@@ -2845,7 +2846,7 @@
 char bufPATH_MAX;
 int err;
 ssize_t res;
- 
+
 path = JS_ToCString(ctx, argv0);
 if (!path)
 return JS_EXCEPTION;
@@ -2869,7 +2870,7 @@
 const char *key, *str;
 JSValue val;
 size_t key_len, str_len;
- 
+
 if (JS_GetOwnPropertyNames(ctx, &tab, &len, obj,
 JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
 return NULL;
@@ -2927,7 +2928,7 @@
 char bufPATH_MAX;
 size_t filename_len, path_len;
 BOOL eacces_error;
- 
+
 filename_len = strlen(filename);
 if (filename_len == 0) {
 errno = ENOENT;
@@ -2935,7 +2936,7 @@
 }
 if (strchr(filename, '/'))
 return execve(filename, argv, envp);
- 
+
 path = getenv("PATH");
 if (!path)
 path = (char *)"/bin:/usr/bin";
@@ -2957,7 +2958,7 @@
 bufpath_len = '/';
 memcpy(buf + path_len + 1, filename, filename_len);
 bufpath_len + 1 + filename_len = '\0';
- 
+
 execve(buf, argv, envp);
 
 switch(errno) {
@@ -2990,7 +2991,7 @@
 static const char *std_name3 = { "stdin", "stdout", "stderr" };
 int std_fds3;
 uint32_t uid = -1, gid = -1;
- 
+
 val = JS_GetPropertyStr(ctx, args, "length");
 if (JS_IsException(val))
 return JS_EXCEPTION;
@@ -3019,7 +3020,7 @@
 
 for(i = 0; i < 3; i++)
 std_fdsi = i;
- 
+
 /* get the options, if any */
 if (argc >= 2) {
 options = argv1;
@@ -3028,7 +3029,7 @@
 goto exception;
 if (get_bool_option(ctx, &use_path, options, "usePath"))
 goto exception;
- 
+
 val = JS_GetPropertyStr(ctx, options, "file");
 if (JS_IsException(val))
 goto exception;
@@ -3073,7 +3074,7 @@
 if (!envp)
 goto exception;
 }
- 
+
 val = JS_GetPropertyStr(ctx, options, "uid");
 if (JS_IsException(val))
 goto exception;
@@ -3180,7 +3181,7 @@
 {
 int pid, status, options, ret;
 JSValue obj;
- 
+
 if (JS_ToInt32(ctx, &pid, argv0))
 return JS_EXCEPTION;
 if (JS_ToInt32(ctx, &options, argv1))
@@ -3200,14 +3201,14 @@
 JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
 JS_PROP_C_W_E);
 return obj;
-} 
+}
 
 /* kill(pid, sig) */
 static JSValue js_os_kill(JSContext *ctx, JSValueConst this_val,
 int argc, JSValueConst *argv)
 {
 int pid, sig, ret;
- 
+
 if (JS_ToInt32(ctx, &pid, argv0))
 return JS_EXCEPTION;
 if (JS_ToInt32(ctx, &sig, argv1))
@@ -3358,7 +3359,7 @@
 	si.cb = sizeof(si);
 	ZeroMemory(&pi, sizeof(pi));
 
-	// Start the child process. 
+	// Start the child process.
 	if (!CreateProcess(file, exec_argv, NULL, NULL, FALSE, 0, envp, cwd, &si, &pi)) {
 		JS_ThrowTypeError(ctx, "CreateProcess error");
 		goto exception;
@@ -3610,7 +3611,7 @@
 JSWorkerMessagePipe *ps;
 int pipe_fds2;
 	char mxName200;
- 
+
 if (pipe(pipe_fds) < 0)
 return NULL;
 
@@ -3652,10 +3653,10 @@
 struct list_head *el, *el1;
 JSWorkerMessage *msg;
 int ref_count;
- 
+
 if (!ps)
 return;
- 
+
 ref_count = atomic_add_int(&ps->ref_count, -1);
 assert(ref_count >= 0);
 if (ref_count == 0) {
@@ -3700,7 +3701,7 @@
 static JSClassDef js_worker_class = {
 "Worker",
 .finalizer = js_worker_finalizer,
-}; 
+};
 
 static void js_std_free_handlers_ex(JSRuntime *rt, int no_free_ts);
 
@@ -3711,12 +3712,12 @@
 	JSWorkerData *worker;
 JSThreadState *ts;
 JSContext *ctx;
- 
+
 rt = JS_NewRuntime();
 if (rt == NULL) {
 fprintf(stderr, "JS_NewRuntime failure");
 exit(1);
- } 
+ }
 js_std_init_handlers(rt);
 
 JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
@@ -3770,7 +3771,7 @@
 {
 JSValue obj = JS_UNDEFINED, proto;
 JSWorkerData *s;
- 
+
 /* create the object */
 if (JS_IsUndefined(new_target)) {
 proto = JS_GetClassProto(ctx, js_worker_class_id);
@@ -3805,7 +3806,7 @@
 int ret;
 const char *filename = NULL, *basename;
 JSAtom basename_atom;
- 
+
 /* XXX: in order to avoid problems with resource liberation, we
 don't support creating workers inside workers */
 if (!is_main_thread(rt))
@@ -3821,7 +3822,7 @@
 JS_FreeAtom(ctx, basename_atom);
 if (!basename)
 goto fail;
- 
+
 /* module name */
 filename = JS_ToCString(ctx, argv0);
 if (!filename)
@@ -3846,7 +3847,7 @@
 args->send_pipe, args->recv_pipe);
 if (JS_IsException(obj))
 goto fail;
- 
+
 args->worker = JS_GetOpaque(obj, js_worker_class_id);
 args->worker->th = gf_th_new("gf_js_worker");
 if (!args->worker->th) {
@@ -3886,10 +3887,10 @@
 uint8_t *data;
 JSWorkerMessage *msg;
 uint8_t **sab_tab;
- 
+
 if (!worker)
 return JS_EXCEPTION;
- 
+
 data = JS_WriteObject2(ctx, &data_len, argv0,
 JS_WRITE_OBJ_SAB | JS_WRITE_OBJ_REFERENCE,
 &sab_tab, &sab_tab_len);
@@ -3917,7 +3918,7 @@
 
 js_free(ctx, data);
 js_free(ctx, sab_tab);
- 
+
 /* increment the SAB reference counts */
 for(i = 0; i < msg->sab_tab_len; i++) {
 js_sab_dup(NULL, msg->sab_tabi);
@@ -3949,7 +3950,7 @@
 js_free(ctx, data);
 js_free(ctx, sab_tab);
 return JS_EXCEPTION;
- 
+
 }
 
 static JSValue js_worker_set_onmessage(JSContext *ctx, JSValueConst this_val,
@@ -3959,7 +3960,7 @@
 JSThreadState *ts = JS_GetRuntimeOpaque(rt);
 JSWorkerData *worker = JS_GetOpaque2(ctx, this_val, js_worker_class_id);
 JSWorkerMessageHandler *port;
- 
+
 if (!worker)
 return JS_EXCEPTION;
 
@@ -4114,7 +4115,7 @@
 static int js_os_init(JSContext *ctx, JSModuleDef *m)
 {
 os_poll_func = js_os_poll;
- 
+
 /* OSTimer class */
 JS_NewClassID(&js_os_timer_class_id);
 JS_NewClass(JS_GetRuntime(ctx), js_os_timer_class_id, &js_os_timer_class);
@@ -4129,20 +4130,20 @@
 JS_NewClass(JS_GetRuntime(ctx), js_worker_class_id, &js_worker_class);
 proto = JS_NewObject(ctx);
 JS_SetPropertyFunctionList(ctx, proto, js_worker_proto_funcs, countof(js_worker_proto_funcs));
- 
+
 obj = JS_NewCFunction2(ctx, js_worker_ctor, "Worker", 1,
 JS_CFUNC_constructor, 0);
 JS_SetConstructor(ctx, obj, proto);
- 
+
 JS_SetClassProto(ctx, js_worker_class_id, proto);
- 
+
 /* set 'Worker.parent' if necessary */
 if (ts->recv_pipe && ts->send_pipe) {
 JS_DefinePropertyValueStr(ctx, obj, "parent",
 js_worker_ctor_internal(ctx, JS_UNDEFINED, ts->recv_pipe, ts->send_pipe),
 JS_PROP_C_W_E);
 }
- 
+
 JS_SetModuleExport(ctx, m, "Worker", obj);
 }
 #endif /* USE_WORKER */
@@ -4207,12 +4208,12 @@
 }
 JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
 }
- 
+
 JS_SetPropertyStr(ctx, global_obj, "print",
 JS_NewCFunction(ctx, js_print, "print", 1));
 JS_SetPropertyStr(ctx, global_obj, "__loadScript",
 JS_NewCFunction(ctx, js_loadScript, "__loadScript", 1));
- 
+
 JS_FreeValue(ctx, global_obj);
 }
 #endif
@@ -4261,7 +4262,7 @@
 JSOSSignalHandler *sh = list_entry(el, JSOSSignalHandler, link);
 free_sh(rt, sh);
 }
- 
+
 list_for_each_safe(el, el1, &ts->os_timers) {
 JSOSTimer *th = list_entry(el, JSOSTimer, link);
 unlink_timer(rt, th);
@@ -4312,7 +4313,7 @@
 {
 JSValue val;
 BOOL is_error;
- 
+
 is_error = JS_IsError(ctx, exception_val);
 js_dump_obj(ctx, stderr, exception_val);
 if (is_error) {
@@ -4327,7 +4328,7 @@
 void js_std_dump_error(JSContext *ctx)
 {
 JSValue exception_val;
- 
+
 exception_val = JS_GetException(ctx);
 js_std_dump_error1(ctx, exception_val);
 JS_FreeValue(ctx, exception_val);

gpac-2.0.0.tar.gz/src/quickjs/quickjs.c -> gpac-2.2.0.tar.gz/src/quickjs/quickjs.c Changed

@@ -1,6 +1,6 @@
 /*
 * QuickJS Javascript Engine
- * 
+ *
 * Copyright (c) 2017-2021 Fabrice Bellard
 * Copyright (c) 2017-2021 Charlie Gordon
 *
@@ -28,7 +28,7 @@
 #include <inttypes.h>
 #include <string.h>
 #include <assert.h>
-#if !defined(_WIN32)
+#if !defined(_MSC_VER)
 #include <sys/time.h>
 #endif
 #include <time.h>
@@ -205,7 +205,7 @@
 JS_URI_ERROR,
 JS_INTERNAL_ERROR,
 JS_AGGREGATE_ERROR,
- 
+
 JS_NATIVE_ERROR_COUNT, /* number of different NativeError objects */
 } JSErrorEnum;
 
@@ -273,7 +273,7 @@
 by the garbage collector) */
 struct list_head gc_obj_list;
 /* list of JSGCObjectHeader.link. Used during JS_FreeValueRT() */
- struct list_head gc_zero_ref_count_list; 
+ struct list_head gc_zero_ref_count_list;
 struct list_head tmp_obj_list; /* used during GC */
 JSGCPhaseEnum gc_phase : 8;
 size_t malloc_gc_threshold;
@@ -284,7 +284,7 @@
 uintptr_t stack_size; /* in bytes, 0 if no limit */
 uintptr_t stack_top;
 uintptr_t stack_limit; /* lower stack limit */
- 
+
 JSValue current_exception;
 /* true if inside an out of memory error, to avoid recursing */
 BOOL in_out_of_memory : 8;
@@ -296,7 +296,7 @@
 
 JSHostPromiseRejectionTracker *host_promise_rejection_tracker;
 void *host_promise_rejection_tracker_opaque;
- 
+
 struct list_head job_list; /* list of JSJobEntry.link */
 
 JSModuleNormalizeFunc *module_normalize_func;
@@ -306,7 +306,7 @@
 BOOL can_block : 8; /* TRUE if Atomics.wait can block */
 /* used to allocate, free and clone SharedArrayBuffers */
 JSSharedArrayBufferFunctions sab_funcs;
- 
+
 /* Shape hash table */
 int shape_hash_bits;
 int shape_hash_size;
@@ -347,7 +347,7 @@
 int arg_count;
 int js_mode; /* 0 or JS_MODE_MATH for C functions */
 /* only used in generators. Current stack pointer value. NULL if
- the function is running. */ 
+ the function is running. */
 JSValue *cur_sp;
 } JSStackFrame;
 
@@ -381,9 +381,9 @@
 
 /* 0 : the JSVarRef is on the stack. header.link is an element
 of JSStackFrame.var_ref_list.
- 1 : the JSVarRef is detached. header.link has the normal meanning 
+ 1 : the JSVarRef is detached. header.link has the normal meanning
 */
- uint8_t is_detached : 1; 
+ uint8_t is_detached : 1;
 uint8_t is_arg : 1;
 uint16_t var_idx; /* index of the corresponding function variable on
 the stack */
@@ -560,7 +560,7 @@
 JSAtom var_name;
 /* index into fd->scopes of this variable lexical scope */
 int scope_level;
- /* during compilation: 
+ /* during compilation:
 - if scope_level = 0: scope in which the variable is defined
 - if scope_level != 0: index into fd->vars of the next
 variable in the same or enclosing lexical scope
@@ -568,7 +568,7 @@
 index into fd->vars of the next
 variable in the same or enclosing lexical scope
 */
- int scope_next; 
+ int scope_next;
 uint8_t is_const : 1;
 uint8_t is_lexical : 1;
 uint8_t is_captured : 1;
@@ -815,7 +815,7 @@
 BOOL eval_mark : 8; /* temporary use during js_evaluate_module() */
 /* true if evaluation yielded an exception. It is saved in
 eval_exception */
- BOOL eval_has_exception : 8; 
+ BOOL eval_has_exception : 8;
 JSValue eval_exception;
 JSValue meta_obj; /* for import.meta */
 };
@@ -883,7 +883,7 @@
 struct {
 int __gc_ref_count; /* corresponds to header.ref_count */
 uint8_t __gc_mark; /* corresponds to header.mark/gc_obj_type */
- 
+
 uint8_t extensible : 1;
 uint8_t free_mark : 1; /* only used when freeing objects with cycles */
 uint8_t is_exotic : 1; /* TRUE if object has exotic property handlers */
@@ -943,7 +943,7 @@
 struct JSTypedArray *typed_array; /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_FLOAT64_ARRAY */
 } u1;
 union {
- JSValue *values; /* JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS */ 
+ JSValue *values; /* JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS */
 void *ptr; /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_FLOAT64_ARRAY */
 int8_t *int8_ptr; /* JS_CLASS_INT8_ARRAY */
 uint8_t *uint8_ptr; /* JS_CLASS_UINT8_ARRAY, JS_CLASS_UINT8C_ARRAY */
@@ -1650,7 +1650,7 @@
 init_list_head(&rt->gc_obj_list);
 init_list_head(&rt->gc_zero_ref_count_list);
 rt->gc_phase = JS_GC_PHASE_NONE;
- 
+
 #ifdef DUMP_LEAKS
 init_list_head(&rt->string_list);
 #endif
@@ -2304,7 +2304,7 @@
 if (--ctx->header.ref_count > 0)
 return;
 assert(ctx->header.ref_count == 0);
- 
+
 #ifdef DUMP_ATOMS
 JS_DumpAtoms(ctx->rt);
 #endif
@@ -3356,7 +3356,7 @@
 const char *cstr;
 char *cstr2;
 size_t len, len1;
- 
+
 str = JS_AtomToString(ctx, name);
 if (JS_IsException(str))
 return JS_ATOM_NULL;
@@ -3894,7 +3894,7 @@
 uint32_t c;
 StringBuffer b_s, *b = &b_s;
 size_t len1;
- 
+
 p_start = (const uint8_t *)buf;
 p_end = p_start + buf_len;
 p = p_start;
@@ -4386,7 +4386,7 @@
 sh->prop_size = prop_size;
 sh->prop_count = 0;
 sh->deleted_prop_count = 0;
- 
+
 /* insert in the hash table */
 sh->hash = shape_initial_hash(proto);
 sh->is_hashed = TRUE;
@@ -4546,7 +4546,7 @@
 uint32_t new_hash_size, i, j, new_hash_mask, new_size;
 JSShapeProperty *old_pr, *pr;
 JSProperty *prop, *new_prop;
- 
+
 sh = p->shape;
 assert(!sh->is_hashed);
 
@@ -4568,7 +4568,7 @@
 list_del(&old_sh->header.link);
 memcpy(sh, old_sh, sizeof(JSShape));
 list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
- 
+
 memset(prop_hash_end(sh) - new_hash_size, 0,
 sizeof(prop_hash_end(sh)0) * new_hash_size);
 
@@ -4597,7 +4597,7 @@
 
 p->shape = sh;
 js_free(ctx, get_alloc_from_shape(old_sh));
- 
+
 /* reduce the size of the object properties */
 new_prop = js_realloc(ctx, p->prop, sizeof(new_prop0) * new_size);
 if (new_prop)
@@ -4724,7 +4724,7 @@
 struct list_head *el;
 JSObject *p;
 JSGCObjectHeader *gp;
- 
+
 printf("JSShapes: {\n");
 printf("%5s %4s %14s %5s %5s %s\n", "SLOT", "REFS", "PROTO", "SIZE", "COUNT", "PROPS");
 for(i = 0; i < rt->shape_hash_size; i++) {
@@ -5052,7 +5052,7 @@
 JSValue func_obj;
 JSObject *p;
 JSAtom name_atom;
- 
+
 func_obj = JS_NewObjectProtoClass(ctx, proto_val, JS_CLASS_C_FUNCTION);
 if (JS_IsException(func_obj))
 return func_obj;
@@ -5483,7 +5483,7 @@
 {
 struct list_head *el;
 JSGCObjectHeader *p;
- 
+
 rt->gc_phase = JS_GC_PHASE_DECREF;
 for(;;) {
 el = rt->gc_zero_ref_count_list.next;
@@ -5715,7 +5715,7 @@
 {
 struct list_head *el, *el1;
 JSGCObjectHeader *p;
- 
+
 init_list_head(&rt->tmp_obj_list);
 
 /* decrement the refcount of all the children of all the GC
@@ -5762,7 +5762,7 @@
 p->mark = 0; /* reset the mark for the next GC call */
 mark_children(rt, p, gc_scan_incref_child);
 }
- 
+
 /* restore the refcount of the objects to be deleted. */
 list_for_each(el, &rt->tmp_obj_list) {
 p = list_entry(el, JSGCObjectHeader, link);
@@ -5808,7 +5808,7 @@
 }
 }
 rt->gc_phase = JS_GC_PHASE_NONE;
- 
+
 list_for_each_safe(el, el1, &rt->gc_zero_ref_count_list) {
 p = list_entry(el, JSGCObjectHeader, link);
 assert(p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT ||
@@ -6475,7 +6475,7 @@
 JSProperty *pr;
 JSShapeProperty *prs;
 JSValueConst val;
- 
+
 if (JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)
 return NULL;
 prs = find_own_property(&pr, JS_VALUE_GET_OBJ(func), JS_ATOM_name);
@@ -6506,7 +6506,7 @@
 const char *str1;
 JSObject *p;
 BOOL backtrace_barrier;
- 
+
 js_dbuf_init(ctx, &dbuf);
 if (filename) {
 dbuf_printf(&dbuf, " at %s", filename);
@@ -7390,7 +7390,7 @@
 JSProperty *pr;
 JSValue brand;
 JSAtom brand_atom;
- 
+
 if (unlikely(JS_VALUE_GET_TAG(home_obj) != JS_TAG_OBJECT)) {
 JS_ThrowTypeErrorNotAnObject(ctx);
 return -1;
@@ -7412,7 +7412,7 @@
 brand = JS_DupValue(ctx, pr->u.value);
 }
 brand_atom = js_symbol_to_atom(ctx, brand);
- 
+
 if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)) {
 JS_ThrowTypeErrorNotAnObject(ctx);
 JS_FreeAtom(ctx, brand_atom);
@@ -7433,7 +7433,7 @@
 JSShapeProperty *prs;
 JSProperty *pr;
 JSValueConst brand;
- 
+
 /* get the home object of 'func' */
 if (unlikely(JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)) {
 not_obj:
@@ -7455,7 +7455,7 @@
 /* safety check */
 if (unlikely(JS_VALUE_GET_TAG(brand) != JS_TAG_SYMBOL))
 goto not_obj;
- 
+
 /* get the brand array of 'obj' */
 if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
 goto not_obj;
@@ -7539,7 +7539,7 @@
 BOOL is_enumerable, num_sorted;
 uint32_t num_key;
 JSAtomKindEnum kind;
- 
+
 /* clear pointer for consistency in case of failure */
 *ptab = NULL;
 *plen = 0;
@@ -8399,7 +8399,7 @@
 JSPropertyDescriptor desc;
 JSValue obj1;
 JSObject *p;
- 
+
 obj1 = JS_DupValue(ctx, obj);
 for(;;) {
 p = JS_VALUE_GET_OBJ(obj1);
@@ -8453,7 +8453,7 @@
 JS_FreeValue(ctx, val);
 return JS_ThrowTypeErrorOrFalse(ctx, flags, "receiver is not an object");
 }
- 
+
 p = JS_VALUE_GET_OBJ(this_obj);
 
 /* modify the property in this_obj if it already exists */
@@ -9479,7 +9479,7 @@
 JSShapeProperty *prs;
 JSValueConst val;
 JSString *p;
- 
+
 prs = find_own_property(&pr, JS_VALUE_GET_OBJ(obj), JS_ATOM_name);
 if (!prs)
 return FALSE;
@@ -9739,7 +9739,7 @@
 return 0;
 }
 flags = JS_PROP_THROW_STRICT;
- if (is_strict_mode(ctx)) 
+ if (is_strict_mode(ctx))
 flags |= JS_PROP_NO_ADD;
 return JS_SetPropertyInternal(ctx, ctx->global_obj, prop, val, flags);
 }
@@ -9752,7 +9752,7 @@
 JSValue obj1;
 JSObject *p;
 int res;
- 
+
 obj1 = JS_ToObject(ctx, obj);
 if (JS_IsException(obj1))
 return -1;
@@ -10008,7 +10008,7 @@
 p = JS_VALUE_GET_OBJ(obj);
 return p->is_HTMLDDA;
 }
- 
+
 static int JS_ToBoolFree(JSContext *ctx, JSValue val)
 {
 uint32_t tag = JS_VALUE_GET_TAG(val);
@@ -10110,11 +10110,11 @@
 {
 double d;
 int c;
- 
+
 if (!is_float || radix != 10) {
 uint64_t n_max, n;
 int int_exp, is_neg;
- 
+
 is_neg = 0;
 if (*p == '-') {
 is_neg = 1;
@@ -10162,7 +10162,7 @@
 /* accept _ between digits as a digit separator */
 #define ATOD_ACCEPT_UNDERSCORES (1 << 5)
 /* allow a suffix to override the type */
-#define ATOD_ACCEPT_SUFFIX (1 << 6) 
+#define ATOD_ACCEPT_SUFFIX (1 << 6)
 /* default type */
 #define ATOD_TYPE_MASK (3 << 7)
 #define ATOD_TYPE_FLOAT64 (0 << 7)
@@ -10171,7 +10171,7 @@
 #define ATOD_TYPE_BIG_DECIMAL (3 << 7)
 /* assume bigint mode: floats are parsed as integers if no decimal
 point nor exponent */
-#define ATOD_MODE_BIGINT (1 << 9) 
+#define ATOD_MODE_BIGINT (1 << 9)
 /* accept -0x1 */
 #define ATOD_ACCEPT_PREFIX_AFTER_SIGN (1 << 10)
 
@@ -10201,7 +10201,7 @@
 bf_t *a;
 int ret;
 JSValue val;
- 
+
 val = JS_NewBigFloat(ctx);
 if (JS_IsException(val))
 return val;
@@ -10227,7 +10227,7 @@
 bfdec_t *a;
 int ret;
 JSValue val;
- 
+
 val = JS_NewBigDecimal(ctx);
 if (JS_IsException(val))
 return val;
@@ -10261,11 +10261,11 @@
 int i, j, len;
 BOOL buf_allocated = FALSE;
 JSValue val;
- 
+
 /* optional separator between digits */
 sep = (flags & ATOD_ACCEPT_UNDERSCORES) ? '_' : 256;
 has_legacy_octal = FALSE;
- 
+
 p = str;
 p_start = p;
 is_neg = 0;
@@ -10475,7 +10475,7 @@
 val = JS_NewFloat64(ctx, d);
 }
 #endif
- 
+
 done:
 if (buf_allocated)
 js_free_rt(ctx->rt, buf);
@@ -10557,7 +10557,7 @@
 const char *str;
 const char *p;
 size_t len;
- 
+
 str = JS_ToCStringLen(ctx, &len, val);
 JS_FreeValue(ctx, val);
 if (!str)
@@ -11890,7 +11890,7 @@
 }
 printf(" }");
 }
- 
+
 if (js_class_has_bytecode(p->class_id)) {
 JSFunctionBytecode *b = p->u.func.function_bytecode;
 JSVarRef **var_refs;
@@ -12182,7 +12182,7 @@
 uint32_t tag;
 JSBigDecimal *p;
 bfdec_t *r;
- 
+
 tag = JS_VALUE_GET_NORM_TAG(val);
 switch(tag) {
 case JS_TAG_BIG_DECIMAL:
@@ -12203,7 +12203,7 @@
 const char *str, *p;
 size_t len;
 int flags;
- 
+
 str = JS_ToCStringLen(ctx, &len, val);
 JS_FreeValue(ctx, val);
 if (!str)
@@ -12319,7 +12319,7 @@
 } else {
 bf_t a_s, *a, *r;
 int ret;
- JSValue res; 
+ JSValue res;
 
 res = JS_NewBigInt(ctx);
 if (JS_IsException(res))
@@ -12421,7 +12421,7 @@
 {
 int64_t v;
 bf_t *a;
- 
+
 if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT)
 return val; /* fail safe */
 a = JS_GetBigInt(val);
@@ -12549,10 +12549,10 @@
 JSOverloadableOperatorEnum ovop;
 JSObject *p;
 JSValueConst args2;
- 
+
 if (!ctx->allow_operator_overloading)
 return 0;
- 
+
 opset2_obj = JS_UNDEFINED;
 opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
 if (JS_IsException(opset1_obj))
@@ -12581,7 +12581,7 @@
 }
 
 ovop = get_ovop_from_opcode(op);
- 
+
 if (opset1->operator_counter == opset2->operator_counter) {
 p = opset1->self_opsovop;
 } else if (opset1->operator_counter > opset2->operator_counter) {
@@ -12606,7 +12606,7 @@
 } else {
 new_op1 = JS_DupValue(ctx, op1);
 }
- 
+
 if (opset2->is_primitive) {
 if (is_numeric) {
 new_op2 = JS_ToNumeric(ctx, op2);
@@ -12623,7 +12623,7 @@
 
 /* XXX: could apply JS_ToPrimitive() if primitive type so that the
 operator function does not get a value object */
- 
+
 method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
 if (ovop == JS_OVOP_LESS && (op == OP_lte || op == OP_gt)) {
 args0 = new_op2;
@@ -12734,7 +12734,7 @@
 
 if (!ctx->allow_operator_overloading)
 return 0;
- 
+
 opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
 if (JS_IsException(opset1_obj))
 goto exception;
@@ -12790,7 +12790,7 @@
 bf_t a_s, *r, *a;
 int ret, v;
 JSValue res;
- 
+
 if (op == OP_plus && !is_math_mode(ctx)) {
 JS_ThrowTypeError(ctx, "bigint argument with unary +");
 JS_FreeValue(ctx, op1);
@@ -12842,7 +12842,7 @@
 bf_t a_s, *r, *a;
 int ret, v;
 JSValue res;
- 
+
 if (op == OP_plus && !is_math_mode(ctx)) {
 JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
 JS_FreeValue(ctx, op1);
@@ -12891,7 +12891,7 @@
 bfdec_t *r, *a;
 int ret, v;
 JSValue res;
- 
+
 if (op == OP_plus && !is_math_mode(ctx)) {
 JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
 JS_FreeValue(ctx, op1);
@@ -13051,7 +13051,7 @@
 {
 JSValue op1, val;
 int ret;
- 
+
 op1 = sp-1;
 if (JS_IsObject(op1)) {
 ret = js_call_unary_op_fallback(ctx, &val, op1, OP_not);
@@ -13088,7 +13088,7 @@
 bf_t a_s, b_s, *r, *a, *b;
 int ret;
 JSValue res;
- 
+
 res = JS_NewBigFloat(ctx);
 if (JS_IsException(res)) {
 JS_FreeValue(ctx, op1);
@@ -13149,7 +13149,7 @@
 bf_t a_s, b_s, *r, *a, *b;
 int ret;
 JSValue res;
- 
+
 res = JS_NewBigInt(ctx);
 if (JS_IsException(res))
 goto fail;
@@ -13336,7 +13336,7 @@
 if (JS_IsException(res))
 goto fail;
 r = JS_GetBigDecimal(res);
- 
+
 a = JS_ToBigDecimal(ctx, op1);
 if (!a)
 goto fail;
@@ -13763,7 +13763,7 @@
 {
 bf_t a_s, b_s, *a, *b;
 int res;
- 
+
 a = JS_ToBigFloat(ctx, &a_s, op1);
 if (!a) {
 JS_FreeValue(ctx, op2);
@@ -13825,7 +13825,7 @@
 }
 a = JS_ToBigDecimal(ctx, op1);
 b = JS_ToBigDecimal(ctx, op2);
- 
+
 switch(op) {
 case OP_lt:
 res = bfdec_cmp_lt(a, b); /* if NaN return false */
@@ -14214,7 +14214,7 @@
 bf_t r_s, *r = &r_s;
 double d;
 int ret;
- 
+
 /* always convert to Float64 */
 bf_init(ctx->bf_ctx, r);
 ret = bf_mul_pow_radix(r, a, 10, exponent,
@@ -14936,7 +14936,7 @@
 {
 JSObject *p;
 p = JS_VALUE_GET_OBJ(op1);
- if (unlikely(p->is_HTMLDDA)) 
+ if (unlikely(p->is_HTMLDDA))
 atom = JS_ATOM_undefined;
 else if (JS_IsFunction(ctx, op1))
 atom = JS_ATOM_function;
@@ -15657,7 +15657,7 @@
 int is_array_iterator;
 JSValue *arrp;
 uint32_t i, count32, pos;
- 
+
 if (JS_VALUE_GET_TAG(sp-2) != JS_TAG_INT) {
 JS_ThrowInternalError(ctx, "invalid index for append");
 return -1;
@@ -15745,7 +15745,7 @@
 int ret, gpn_flags;
 JSPropertyDescriptor desc;
 BOOL is_enumerable;
- 
+
 if (JS_VALUE_GET_TAG(source) != JS_TAG_OBJECT)
 return 0;
 
@@ -15766,7 +15766,7 @@
 if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
 gpn_flags))
 return -1;
- 
+
 for (i = 0; i < tab_atom_count; i++) {
 if (pexcl) {
 ret = JS_GetOwnPropertyInternal(ctx, NULL, pexcl, tab_atomi.atom);
@@ -16129,7 +16129,7 @@
 sf->prev_frame = prev_sf;
 rt->current_stack_frame = sf;
 ctx = p->u.cfunc.realm; /* change the current realm */
- 
+
 #ifdef CONFIG_BIGNUM
 /* we only propagate the bignum mode as some runtime functions
 test it */
@@ -16322,7 +16322,7 @@
 #define DEF(id, size, n_pop, n_push, f) && case_OP_ ## id,
 #if SHORT_OPCODES
 #define def(id, size, n_pop, n_push, f)
-#else 
+#else
 #define def(id, size, n_pop, n_push, f) && case_default,
 #endif
 #include "quickjs-opcode.h"
@@ -16420,7 +16420,7 @@
 sf->prev_frame = rt->current_stack_frame;
 rt->current_stack_frame = sf;
 ctx = b->realm; /* set the current realm */
- 
+
 restart:
 for(;;) {
 int call_argc;
@@ -16870,7 +16870,7 @@
 JS_FreeValue(ctx, sp-1);
 sp -= 2;
 BREAK;
- 
+
 CASE(OP_throw):
 JS_Throw(ctx, *--sp);
 goto exception;
@@ -17685,7 +17685,7 @@
 {
 JSAtom atom;
 JSValue val;
- 
+
 atom = get_u32(pc);
 pc += 4;
 val = JS_NewSymbolFromAtom(ctx, atom, JS_ATOM_TYPE_PRIVATE);
@@ -17694,7 +17694,7 @@
 *sp++ = val;
 }
 BREAK;
- 
+
 CASE(OP_get_private_field):
 {
 JSValue val;
@@ -17847,7 +17847,7 @@
 {
 int class_flags;
 JSAtom atom;
- 
+
 atom = get_u32(pc);
 class_flags = pc4;
 pc += 5;
@@ -18837,7 +18837,7 @@
 {
 JSObject *p;
 JSContext *realm;
- 
+
 if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
 return ctx;
 p = JS_VALUE_GET_OBJ(func_obj);
@@ -18886,7 +18886,7 @@
 {
 JSValue proto, obj;
 JSContext *realm;
- 
+
 if (JS_IsUndefined(ctor)) {
 proto = JS_DupValue(ctx, ctx->class_protoclass_id);
 } else {
@@ -19053,7 +19053,7 @@
 
 /* close the closure variables. */
 close_var_refs(rt, sf);
- 
+
 if (sf->arg_buf) {
 /* cannot free the function if it is running */
 assert(sf->cur_sp != NULL);
@@ -20099,7 +20099,7 @@
 int var_object_idx; /* -1 if none */
 int arg_var_object_idx; /* -1 if none (var object for the argument scope) */
 int arguments_var_idx; /* -1 if none */
- int arguments_arg_idx; /* argument variable definition in argument scope, 
+ int arguments_arg_idx; /* argument variable definition in argument scope,
 -1 if none */
 int func_var_idx; /* variable containing the current function (-1
 if none, only used if is_func_expr is true) */
@@ -20109,7 +20109,7 @@
 int this_active_func_var_idx; /* variable containg the 'this.active_func' value, -1 if none */
 int home_object_var_idx;
 BOOL need_home_object;
- 
+
 int scope_level; /* index into fd->scopes if the current lexical scope */
 int scope_first; /* index into vd->vars of first lexically scoped variable */
 int scope_size; /* allocated size of fd->scopes array */
@@ -20126,7 +20126,7 @@
 int last_opcode_pos; /* -1 if no last opcode */
 int last_opcode_line_num;
 BOOL use_short_opcodes; /* true if short opcodes are used in byte_code */
- 
+
 LabelSlot *label_slots;
 int label_size; /* allocated size for label_slots */
 int label_count;
@@ -20345,7 +20345,7 @@
 JSContext *ctx = s->ctx;
 va_list ap;
 int backtrace_flags;
- 
+
 va_start(ap, fmt);
 JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
 va_end(ap);
@@ -20695,7 +20695,7 @@
 {
 char *buf, *new_buf;
 size_t size, new_size;
- 
+
 buf = *pbuf;
 size = *psize;
 if (size >= (SIZE_MAX / 3) * 2)
@@ -20725,7 +20725,7 @@
 char ident_buf128, *buf;
 size_t ident_size, ident_pos;
 JSAtom atom;
- 
+
 p = *pp;
 buf = ident_buf;
 ident_size = sizeof(ident_buf);
@@ -20734,7 +20734,7 @@
 bufident_pos++ = '#';
 for(;;) {
 p1 = p;
- 
+
 if (c < 128) {
 bufident_pos++ = c;
 } else {
@@ -20772,11 +20772,11 @@
 int c;
 BOOL ident_has_escape;
 JSAtom atom;
- 
+
 if (js_check_stack_overflow(s->ctx->rt, 0)) {
 return js_parse_error(s, "stack overflow");
 }
- 
+
 free_token(s, &s->token);
 
 p = s->last_ptr = s->buf_ptr;
@@ -20903,14 +20903,14 @@
 case 'm': case 'n': case 'o': case 'p':
 case 'q': case 'r': case 's': case 't':
 case 'u': case 'v': case 'w': case 'x':
- case 'y': case 'z': 
+ case 'y': case 'z':
 case 'A': case 'B': case 'C': case 'D':
 case 'E': case 'F': case 'G': case 'H':
 case 'I': case 'J': case 'K': case 'L':
 case 'M': case 'N': case 'O': case 'P':
 case 'Q': case 'R': case 'S': case 'T':
 case 'U': case 'V': case 'W': case 'X':
- case 'Y': case 'Z': 
+ case 'Y': case 'Z':
 case '_':
 case '$':
 /* identifier */
@@ -20994,7 +20994,7 @@
 goto parse_number;
 case '1': case '2': case '3': case '4':
 case '5': case '6': case '7': case '8':
- case '9': 
+ case '9':
 /* number */
 parse_number:
 {
@@ -21252,7 +21252,7 @@
 case CP_LS:
 /* XXX: should avoid incrementing line_number, but
 needed to handle HTML comments */
- goto line_terminator; 
+ goto line_terminator;
 default:
 if (lre_is_space(c)) {
 goto redo;
@@ -21287,7 +21287,7 @@
 char ident_buf128, *buf;
 size_t ident_size, ident_pos;
 JSAtom atom;
- 
+
 p = *pp;
 buf = ident_buf;
 ident_size = sizeof(ident_buf);
@@ -21319,11 +21319,11 @@
 const uint8_t *p;
 int c;
 JSAtom atom;
- 
+
 if (js_check_stack_overflow(s->ctx->rt, 0)) {
 return js_parse_error(s, "stack overflow");
 }
- 
+
 free_token(s, &s->token);
 
 p = s->last_ptr = s->buf_ptr;
@@ -21433,14 +21433,14 @@
 case 'm': case 'n': case 'o': case 'p':
 case 'q': case 'r': case 's': case 't':
 case 'u': case 'v': case 'w': case 'x':
- case 'y': case 'z': 
+ case 'y': case 'z':
 case 'A': case 'B': case 'C': case 'D':
 case 'E': case 'F': case 'G': case 'H':
 case 'I': case 'J': case 'K': case 'L':
 case 'M': case 'N': case 'O': case 'P':
 case 'Q': case 'R': case 'S': case 'T':
 case 'U': case 'V': case 'W': case 'X':
- case 'Y': case 'Z': 
+ case 'Y': case 'Z':
 case '_':
 case '$':
 /* identifier : only pure ascii characters are accepted */
@@ -21467,7 +21467,7 @@
 goto parse_number;
 case '1': case '2': case '3': case '4':
 case '5': case '6': case '7': case '8':
- case '9': 
+ case '9':
 /* number */
 parse_number:
 {
@@ -21515,7 +21515,7 @@
 {
 const uint8_t *p;
 uint32_t c;
- 
+
 /* skip spaces and comments */
 p = *pp;
 for (;;) {
@@ -21746,7 +21746,7 @@
 static int cpool_add(JSParseState *s, JSValue val)
 {
 JSFunctionDef *fd = s->cur_func;
- 
+
 if (js_resize_array(s->ctx, (void *)&fd->cpool, sizeof(fd->cpool0),
 &fd->cpool_size, fd->cpool_count + 1))
 return -1;
@@ -22132,7 +22132,7 @@
 if (find_var_in_child_scope(ctx, fd, name, fd->scope_level) >= 0) {
 return js_parse_error(s, "invalid redefinition of a variable");
 }
- 
+
 if (fd->is_global_var) {
 JSGlobalVar *hf;
 hf = find_global_var(fd, name);
@@ -22141,7 +22141,7 @@
 return js_parse_error(s, "invalid redefinition of global identifier");
 }
 }
- 
+
 if (fd->is_eval &&
 (fd->eval_type == JS_EVAL_TYPE_GLOBAL ||
 fd->eval_type == JS_EVAL_TYPE_MODULE) &&
@@ -22412,7 +22412,7 @@
 BOOL is_non_reserved_ident;
 JSAtom name;
 int prop_type;
- 
+
 prop_type = PROP_TYPE_IDENT;
 if (allow_method) {
 if (token_is_pseudo_keyword(s, JS_ATOM_get)
@@ -22638,7 +22638,7 @@
 if (level >= sizeof(state))
 goto done;
 statelevel++ = '`';
- } 
+ }
 break;
 case TOK_EOF:
 goto done;
@@ -22655,7 +22655,7 @@
 case '=':
 bits |= SKIP_HAS_ASSIGNMENT;
 break;
- 
+
 case TOK_DIV_ASSIGN:
 tok_len = 2;
 goto parse_regexp;
@@ -22865,15 +22865,15 @@
 }
 
 /* allow the 'in' binary operator */
-#define PF_IN_ACCEPTED (1 << 0) 
+#define PF_IN_ACCEPTED (1 << 0)
 /* allow function calls parsing in js_parse_postfix_expr() */
-#define PF_POSTFIX_CALL (1 << 1) 
+#define PF_POSTFIX_CALL (1 << 1)
 /* allow arrow functions parsing in js_parse_postfix_expr() */
-#define PF_ARROW_FUNC (1 << 2) 
+#define PF_ARROW_FUNC (1 << 2)
 /* allow the exponentiation operator in js_parse_unary() */
-#define PF_POW_ALLOWED (1 << 3) 
+#define PF_POW_ALLOWED (1 << 3)
 /* forbid the exponentiation operator in js_parse_unary() */
-#define PF_POW_FORBIDDEN (1 << 4) 
+#define PF_POW_FORBIDDEN (1 << 4)
 
 static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags);
 
@@ -22892,7 +22892,7 @@
 int ret, line_num;
 JSParseFunctionEnum func_type;
 const uint8_t *saved_buf_end;
- 
+
 js_parse_get_pos(s, &pos);
 if (has_super) {
 /* spec change: no argument evaluation */
@@ -22939,7 +22939,7 @@
 static void emit_class_field_init(JSParseState *s)
 {
 int label_next;
- 
+
 emit_op(s, OP_scope_get_var);
 emit_atom(s, JS_ATOM_class_fields_init);
 emit_u16(s, s->cur_func->scope_level);
@@ -22947,13 +22947,13 @@
 /* no need to call the class field initializer if not defined */
 emit_op(s, OP_dup);
 label_next = emit_goto(s, OP_if_false, -1);
- 
+
 emit_op(s, OP_scope_get_var);
 emit_atom(s, JS_ATOM_this);
 emit_u16(s, 0);
- 
+
 emit_op(s, OP_swap);
- 
+
 emit_op(s, OP_call_method);
 emit_u16(s, 0);
 
@@ -22978,29 +22978,29 @@
 ClassFieldsDef *cf)
 {
 int label_add_brand;
- 
+
 cf->fields_init_fd = js_parse_function_class_fields_init(s);
 if (!cf->fields_init_fd)
 return -1;
 
 s->cur_func = cf->fields_init_fd;
- 
+
 /* XXX: would be better to add the code only if needed, maybe in a
 later pass */
 emit_op(s, OP_push_false); /* will be patched later */
 cf->brand_push_pos = cf->fields_init_fd->last_opcode_pos;
 label_add_brand = emit_goto(s, OP_if_false, -1);
- 
+
 emit_op(s, OP_scope_get_var);
 emit_atom(s, JS_ATOM_this);
 emit_u16(s, 0);
- 
+
 emit_op(s, OP_scope_get_var);
 emit_atom(s, JS_ATOM_home_object);
 emit_u16(s, 0);
- 
+
 emit_op(s, OP_add_brand);
- 
+
 emit_label(s, label_add_brand);
 
 s->cur_func = s->cur_func->parent;
@@ -23017,7 +23017,7 @@
 }
 /* patch the start of the function to enable the OP_add_brand code */
 cf->fields_init_fd->byte_code.bufcf->brand_push_pos = OP_push_true;
- 
+
 cf->has_brand = TRUE;
 }
 return 0;
@@ -23026,11 +23026,11 @@
 static void emit_class_init_end(JSParseState *s, ClassFieldsDef *cf)
 {
 int cpool_idx;
- 
+
 s->cur_func = cf->fields_init_fd;
 emit_op(s, OP_return_undef);
 s->cur_func = s->cur_func->parent;
- 
+
 cpool_idx = cpool_add(s, JS_NULL);
 cf->fields_init_fd->parent_cpool_idx = cpool_idx;
 emit_op(s, OP_fclosure);
@@ -23053,7 +23053,7 @@
 const uint8_t *class_start_ptr = s->token.ptr;
 const uint8_t *start_ptr;
 ClassFieldsDef class_fields2;
- 
+
 /* classes are parsed and executed in strict mode */
 saved_js_mode = fd->js_mode;
 fd->js_mode |= JS_MODE_STRICT;
@@ -23116,7 +23116,7 @@
 } else {
 class_name1 = class_name;
 }
- 
+
 emit_op(s, OP_define_class);
 emit_atom(s, class_name1);
 emit_u8(s, class_flags);
@@ -23128,7 +23128,7 @@
 cf->computed_fields_count = 0;
 cf->has_brand = FALSE;
 }
- 
+
 ctor_fd = NULL;
 while (s->token.val != '}') {
 if (s->token.val == ';') {
@@ -23158,7 +23158,7 @@
 }
 is_private = prop_type & PROP_TYPE_PRIVATE;
 prop_type &= ~PROP_TYPE_PRIVATE;
- 
+
 if ((name == JS_ATOM_constructor && !is_static &&
 prop_type != PROP_TYPE_IDENT) ||
 (name == JS_ATOM_prototype && is_static) ||
@@ -23204,7 +23204,7 @@
 if (is_set) {
 JSAtom setter_name;
 int ret;
- 
+
 setter_name = get_private_setter_name(ctx, name);
 if (setter_name == JS_ATOM_NULL)
 goto fail;
@@ -23230,7 +23230,7 @@
 } else if (prop_type == PROP_TYPE_IDENT && s->token.val != '(') {
 ClassFieldsDef *cf = &class_fieldsis_static;
 JSAtom field_var_name = JS_ATOM_NULL;
- 
+
 /* class field */
 
 /* XXX: spec: not consistent with method name checks */
@@ -23238,7 +23238,7 @@
 js_parse_error(s, "invalid field name");
 goto fail;
 }
- 
+
 if (is_private) {
 if (find_private_class_field(ctx, fd, name,
 fd->scope_level) >= 0) {
@@ -23288,7 +23288,7 @@
 emit_atom(s, name);
 emit_u16(s, s->cur_func->scope_level);
 }
- 
+
 if (s->token.val == '=') {
 if (next_token(s))
 goto fail;
@@ -23315,7 +23315,7 @@
 } else {
 JSParseFunctionEnum func_type;
 JSFunctionKindEnum func_kind;
- 
+
 func_type = JS_PARSE_FUNC_METHOD;
 func_kind = JS_FUNC_NORMAL;
 if (prop_type == PROP_TYPE_STAR) {
@@ -23407,7 +23407,7 @@
 {
 ClassFieldsDef *cf = &class_fields0;
 int var_idx;
- 
+
 var_idx = define_var(s, fd, JS_ATOM_class_fields_init,
 JS_VAR_DEF_CONST);
 if (var_idx < 0)
@@ -23434,7 +23434,7 @@
 emit_u16(s, 0);
 emit_op(s, OP_drop);
 }
- 
+
 if (class_name != JS_ATOM_NULL) {
 /* store the class name in the scoped class name variable (it
 is independent from the class statement variable
@@ -23838,7 +23838,7 @@
 default:
 break;
 }
- 
+
 switch(opcode) {
 case OP_scope_get_var: /* val -- */
 assert(special == PUT_LVALUE_NOKEEP ||
@@ -23892,7 +23892,7 @@
 {
 JSFunctionDef *fd = s->cur_func;
 JSVarDefEnum var_def_type;
- 
+
 if (name == JS_ATOM_yield && fd->func_kind == JS_FUNC_GENERATOR) {
 return js_parse_error(s, "yield is a reserved identifier");
 }
@@ -24003,7 +24003,7 @@
 JSAtom prop_name, var_name;
 int opcode, scope, tok1, skip_bits;
 BOOL has_initializer;
- 
+
 if (has_ellipsis < 0) {
 /* pre-parse destructuration target for spread detection */
 js_parse_skip_parens_token(s, &skip_bits, FALSE);
@@ -24442,7 +24442,7 @@
 FuncCallType call_type;
 int optional_chaining_label;
 BOOL accept_lparen = (parse_flags & PF_POSTFIX_CALL) != 0;
- 
+
 call_type = FUNC_CALL_NORMAL;
 switch(s->token.val) {
 case TOK_NUMBER:
@@ -24498,7 +24498,7 @@
 if (next_token(s))
 return -1;
 break;
- 
+
 case TOK_DIV_ASSIGN:
 s->buf_ptr -= 2;
 goto parse_regexp;
@@ -24740,7 +24740,7 @@
 for(;;) {
 JSFunctionDef *fd = s->cur_func;
 BOOL has_optional_chain = FALSE;
- 
+
 if (s->token.val == TOK_QUESTION_MARK_DOT) {
 /* optional chaining */
 if (next_token(s))
@@ -25237,7 +25237,7 @@
 put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_SECOND,
 FALSE);
 if (next_token(s))
- return -1; 
+ return -1;
 }
 break;
 }
@@ -25474,7 +25474,7 @@
 static __exception int js_parse_coalesce_expr(JSParseState *s, int parse_flags)
 {
 int label1;
- 
+
 if (js_parse_logical_and_or(s, TOK_LOR, parse_flags))
 return -1;
 if (s->token.val == TOK_DOUBLE_QUESTION_MARK) {
@@ -25482,12 +25482,12 @@
 for(;;) {
 if (next_token(s))
 return -1;
- 
+
 emit_op(s, OP_dup);
 emit_op(s, OP_is_undefined_or_null);
 emit_goto(s, OP_if_false, label1);
 emit_op(s, OP_drop);
- 
+
 if (js_parse_expr_binary(s, 8, parse_flags & ~PF_ARROW_FUNC))
 return -1;
 if (s->token.val != TOK_DOUBLE_QUESTION_MARK)
@@ -25538,7 +25538,7 @@
 
 if (s->token.val == TOK_YIELD) {
 BOOL is_star = FALSE, is_async;
- 
+
 if (!(s->cur_func->func_kind & JS_FUNC_GENERATOR))
 return js_parse_error(s, "unexpected 'yield' keyword");
 if (!s->cur_func->in_function_body)
@@ -25576,9 +25576,9 @@
 undefined) */
 emit_op(s, OP_drop);
 emit_op(s, OP_undefined);
- 
+
 emit_op(s, OP_undefined); /* initial value */
- 
+
 emit_label(s, label_loop);
 emit_op(s, OP_iterator_next);
 if (is_async)
@@ -25602,13 +25602,13 @@
 label_return = emit_goto(s, OP_if_true, -1);
 emit_op(s, OP_drop);
 emit_goto(s, OP_goto, label_loop);
- 
+
 emit_label(s, label_return);
 emit_op(s, OP_push_i32);
 emit_u32(s, 2);
 emit_op(s, OP_strict_eq);
 label_throw = emit_goto(s, OP_if_true, -1);
- 
+
 /* return handling */
 if (is_async)
 emit_op(s, OP_await);
@@ -25624,13 +25624,13 @@
 
 emit_op(s, OP_get_field);
 emit_atom(s, JS_ATOM_value);
- 
+
 emit_label(s, label_return1);
 emit_op(s, OP_nip);
 emit_op(s, OP_nip);
 emit_op(s, OP_nip);
 emit_return(s, TRUE);
- 
+
 /* throw handling */
 emit_label(s, label_throw);
 emit_op(s, OP_iterator_call);
@@ -25655,7 +25655,7 @@
 emit_op(s, OP_throw_error);
 emit_atom(s, JS_ATOM_NULL);
 emit_u8(s, JS_THROW_ERROR_ITERATOR_THROW);
- 
+
 emit_label(s, label_next);
 emit_op(s, OP_get_field);
 emit_atom(s, JS_ATOM_value);
@@ -25665,7 +25665,7 @@
 emit_op(s, OP_nip);
 } else {
 int label_next;
- 
+
 if (is_async)
 emit_op(s, OP_await);
 emit_op(s, OP_yield);
@@ -25720,7 +25720,7 @@
 put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP, FALSE);
 } else if (op >= TOK_LAND_ASSIGN && op <= TOK_DOUBLE_QUESTION_MARK_ASSIGN) {
 int label, label1, depth_lvalue, label2;
- 
+
 if (next_token(s))
 return -1;
 if (get_lvalue(s, &opcode, &scope, &name, &label,
@@ -25733,7 +25733,7 @@
 label1 = emit_goto(s, op == TOK_LOR_ASSIGN ? OP_if_true : OP_if_false,
 -1);
 emit_op(s, OP_drop);
- 
+
 if (js_parse_assign_expr2(s, parse_flags)) {
 JS_FreeAtom(s->ctx, name);
 return -1;
@@ -25742,7 +25742,7 @@
 if (opcode == OP_get_ref_value && name == name0) {
 set_object_name(s, name);
 }
- 
+
 switch(depth_lvalue) {
 case 1:
 emit_op(s, OP_insert2);
@@ -25762,7 +25762,7 @@
 put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_NOKEEP_DEPTH,
 FALSE);
 label2 = emit_goto(s, OP_goto, -1);
- 
+
 emit_label(s, label1);
 
 /* remove the lvalue stack entries */
@@ -26980,7 +26980,7 @@
 emit_label(s, label_finally);
 if (s->token.val == TOK_FINALLY) {
 int saved_eval_ret_idx = 0; /* avoid warning */
- 
+
 if (next_token(s))
 goto fail;
 /* on the stack: ret_value gosub_ret_value */
@@ -27000,7 +27000,7 @@
 emit_u16(s, saved_eval_ret_idx);
 set_eval_ret_undefined(s);
 }
- 
+
 if (js_parse_block(s))
 goto fail;
 
@@ -27105,7 +27105,7 @@
 if (js_parse_expect_semi(s))
 goto fail;
 break;
- 
+
 case TOK_ENUM:
 case TOK_EXPORT:
 case TOK_EXTENDS:
@@ -27422,7 +27422,7 @@
 {
 struct list_head *el;
 JSModuleDef *m;
- 
+
 /* first look at the loaded modules */
 list_for_each(el, &ctx->loaded_modules) {
 m = list_entry(el, JSModuleDef, link);
@@ -27487,7 +27487,7 @@
 {
 const char *base_cname, *cname;
 JSModuleDef *m;
- 
+
 base_cname = JS_AtomToCString(ctx, base_module_name);
 if (!base_cname)
 return NULL;
@@ -28025,7 +28025,7 @@
 BOOL is_c_module;
 int i;
 JSVarRef *var_ref;
- 
+
 if (m->func_created)
 return 0;
 
@@ -28049,7 +28049,7 @@
 m->func_created = TRUE;
 
 /* do it on the dependencies */
- 
+
 for(i = 0; i < m->req_module_entries_count; i++) {
 JSReqModuleEntry *rme = &m->req_module_entriesi;
 if (js_create_module_function(ctx, rme->module) < 0)
@@ -28057,9 +28057,9 @@
 }
 
 return 0;
-} 
+}
+
 
- 
 /* Prepare a module to be executed by resolving all the imported
 variables. */
 static int js_link_module(JSContext *ctx, JSModuleDef *m)
@@ -28071,7 +28071,7 @@
 JSObject *p;
 BOOL is_c_module;
 JSValue ret_val;
- 
+
 if (m->instantiated)
 return 0;
 m->instantiated = TRUE;
@@ -28272,7 +28272,7 @@
 {
 JSAtom filename;
 JSModuleDef *m;
- 
+
 filename = JS_GetScriptOrModuleName(ctx, 0);
 if (filename == JS_ATOM_NULL)
 goto fail;
@@ -28295,11 +28295,11 @@
 {
 JSModuleDef *m;
 JSValue ret, func_obj;
- 
+
 m = js_host_resolve_imported_module(ctx, basename, filename);
 if (!m)
 return NULL;
- 
+
 if (js_resolve_module(ctx, m) < 0) {
 js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
 return NULL;
@@ -28335,7 +28335,7 @@
 filename = JS_ToCString(ctx, specifier);
 if (!filename)
 goto exception;
- 
+
 m = JS_RunModule(ctx, basename, filename);
 JS_FreeCString(ctx, filename);
 if (!m)
@@ -28377,7 +28377,7 @@
 JS_FreeAtom(ctx, basename);
 if (JS_IsException(basename_val))
 return basename_val;
- 
+
 promise = JS_NewPromiseCapability(ctx, resolving_funcs);
 if (JS_IsException(promise)) {
 JS_FreeValue(ctx, basename_val);
@@ -28388,7 +28388,7 @@
 args1 = resolving_funcs1;
 args2 = basename_val;
 args3 = specifier;
- 
+
 JS_EnqueueJob(ctx, js_dynamic_import_job, 4, args);
 
 JS_FreeValue(ctx, basename_val);
@@ -28798,7 +28798,7 @@
 {
 JSFunctionDef *fd = s->cur_func;
 int tok;
- 
+
 if (s->token.val == TOK_FUNCTION ||
 (token_is_pseudo_keyword(s, JS_ATOM_async) &&
 peek_token(s, TRUE) == TOK_FUNCTION)) {
@@ -28890,7 +28890,7 @@
 int pos, len, op;
 JSAtom atom;
 const JSOpCode *oi;
- 
+
 pos = 0;
 while (pos < bc_len) {
 op = bc_bufpos;
@@ -28898,7 +28898,7 @@
 oi = &short_opcode_info(op);
 else
 oi = &opcode_infoop;
- 
+
 len = oi->size;
 switch(oi->fmt) {
 case OP_FMT_atom:
@@ -29681,7 +29681,7 @@
 update_label(s, *plabel_done, 1);
 s->jump_size++;
 }
- 
+
 /* return the position of the next opcode */
 static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
 JSAtom var_name, int scope_level, int op,
@@ -29887,7 +29887,7 @@
 is_arg_scope = (idx == ARG_SCOPE_END);
 if (var_idx >= 0)
 break;
- 
+
 if (!is_arg_scope) {
 var_idx = find_var(ctx, fd, var_name);
 if (var_idx >= 0)
@@ -29931,7 +29931,7 @@
 dbuf_put_u16(bc, idx);
 var_object_test(ctx, s, var_name, op, bc, &label_done, 0);
 }
- 
+
 if (fd->is_eval)
 break; /* it it necessarily the top level function */
 }
@@ -30134,7 +30134,7 @@
 {
 /* if the field is not initialized, the error is catched when
 accessing it */
- if (is_ref) 
+ if (is_ref)
 dbuf_putc(bc, OP_get_var_ref);
 else
 dbuf_putc(bc, OP_get_loc);
@@ -30149,7 +30149,7 @@
 int idx, var_kind;
 JSFunctionDef *fd;
 BOOL is_ref;
- 
+
 fd = s;
 is_ref = FALSE;
 for(;;) {
@@ -30475,7 +30475,7 @@
 int i, count;
 JSVarDef *vd;
 BOOL is_arg_scope;
- 
+
 count = b->arg_count + b->var_count + b->closure_var_count;
 s->closure_var = NULL;
 s->closure_var_count = 0;
@@ -30709,7 +30709,7 @@
 visible if there are cyclic module references */
 if (s->module) {
 label_next = new_label_fd(s, -1);
- 
+
 /* if 'this' is true, initialize the global variables and return */
 dbuf_putc(bc, OP_push_this);
 dbuf_putc(bc, OP_if_false);
@@ -30717,7 +30717,7 @@
 update_label(s, label_next, 1);
 s->jump_size++;
 }
- 
+
 /* add the global variables (only happens if s->is_global_var is
 true) */
 for(i = 0; i < s->global_var_count; i++) {
@@ -30746,7 +30746,7 @@
 }
 if (!has_closure) {
 int flags;
- 
+
 flags = 0;
 if (s->eval_type != JS_EVAL_TYPE_GLOBAL)
 flags |= JS_PROP_CONFIGURABLE;
@@ -30754,11 +30754,11 @@
 /* global function definitions need a specific handling */
 dbuf_putc(bc, OP_fclosure);
 dbuf_put_u32(bc, hf->cpool_idx);
- 
+
 dbuf_putc(bc, OP_define_func);
 dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
 dbuf_putc(bc, flags);
- 
+
 goto done_global_var;
 } else {
 if (hf->is_lexical) {
@@ -30802,7 +30802,7 @@
 
 if (s->module) {
 dbuf_putc(bc, OP_return_undef);
- 
+
 dbuf_putc(bc, OP_label);
 dbuf_put_u32(bc, label_next);
 s->label_slotslabel_next.pos2 = bc->size;
@@ -30907,7 +30907,7 @@
 for(i = 0; i < s->global_var_count; i++) {
 JSGlobalVar *hf = &s->global_varsi;
 int flags;
- 
+
 /* check if global variable (XXX: simplify) */
 for(idx = 0; idx < s->closure_var_count; idx++) {
 JSClosureVar *cv = &s->closure_varidx;
@@ -30929,7 +30929,7 @@
 cv->var_name == JS_ATOM__arg_var_)
 goto next;
 }
- 
+
 dbuf_putc(&bc_out, OP_check_define_var);
 dbuf_put_u32(&bc_out, JS_DupAtom(ctx, hf->var_name));
 flags = 0;
@@ -31210,7 +31210,7 @@
 case OP_set_class_name:
 /* only used during parsing */
 break;
- 
+
 default:
 no_change:
 dbuf_put(&bc_out, bc_buf + pos, len);
@@ -32775,7 +32775,7 @@
 b->realm = JS_DupContext(ctx);
 
 add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
- 
+
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 1)
 if (!(fd->js_mode & JS_MODE_STRIP)) {
 js_dump_function_bytecode(ctx, b);
@@ -32987,7 +32987,7 @@
 static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s)
 {
 JSFunctionDef *fd;
- 
+
 fd = js_new_function_def(s->ctx, s->cur_func, FALSE, FALSE,
 s->filename, 0);
 if (!fd)
@@ -32995,7 +32995,7 @@
 fd->func_name = JS_ATOM_NULL;
 fd->has_prototype = FALSE;
 fd->has_home_object = TRUE;
- 
+
 fd->has_arguments_binding = FALSE;
 fd->has_this_binding = TRUE;
 fd->is_derived_class_constructor = FALSE;
@@ -33003,7 +33003,7 @@
 fd->super_call_allowed = FALSE;
 fd->super_allowed = fd->has_home_object;
 fd->arguments_allowed = FALSE;
- 
+
 fd->func_kind = JS_FUNC_NORMAL;
 fd->func_type = JS_PARSE_FUNC_METHOD;
 return fd;
@@ -33179,7 +33179,7 @@
 if (func_type == JS_PARSE_FUNC_CLASS_CONSTRUCTOR) {
 emit_class_field_init(s);
 }
- 
+
 /* parse arguments */
 fd->has_simple_parameter_list = TRUE;
 fd->has_parameter_expressions = FALSE;
@@ -33214,7 +33214,7 @@
 if (push_scope(s) < 0)
 return -1;
 }
- 
+
 while (s->token.val != ')') {
 JSAtom name;
 BOOL rest = FALSE;
@@ -33279,7 +33279,7 @@
 has_opt_arg = TRUE;
 } else if (s->token.val == '=') {
 int label;
- 
+
 fd->has_simple_parameter_list = FALSE;
 has_opt_arg = TRUE;
 
@@ -33362,7 +33362,7 @@
 }
 idx = vd->scope_next;
 }
- 
+
 /* the argument scope has no parent, hence we don't use pop_scope(s) */
 emit_op(s, OP_leave_scope);
 emit_u16(s, fd->scope_level);
@@ -33371,7 +33371,7 @@
 fd->scope_level = 0;
 fd->scope_first = fd->scopesfd->scope_level.first;
 }
- 
+
 if (next_token(s))
 goto fail;
 
@@ -33485,7 +33485,7 @@
 /* it is considered as defined at the top level
 (needed for annex B.3.3.4 and B.3.3.5
 checks) */
- hf->scope_level = 0; 
+ hf->scope_level = 0;
 hf->force_init = ((s->cur_func->js_mode & JS_MODE_STRICT) != 0);
 /* store directly into global var, bypass lexical scope */
 emit_op(s, OP_dup);
@@ -33766,7 +33766,7 @@
 
 push_scope(s); /* body scope */
 fd->body_scope = fd->scope_level;
- 
+
 err = js_parse_program(s);
 if (err) {
 fail:
@@ -33903,13 +33903,13 @@
 js_free(ctx, s->hash_table);
 s->hash_table = new_hash_table;
 s->hash_size = new_hash_size;
- 
+
 for(i = 0; i < s->hash_size; i++) {
 s->hash_tablei = -1;
 }
 for(i = 0; i < s->object_count; i++) {
 e = &s->object_tabi;
- h = js_object_list_get_hash(e->obj, s->hash_size); 
+ h = js_object_list_get_hash(e->obj, s->hash_size);
 e->hash_next = s->hash_tableh;
 s->hash_tableh = i;
 }
@@ -33922,7 +33922,7 @@
 {
 JSObjectListEntry *e;
 uint32_t h, new_hash_size;
- 
+
 if (js_resize_array(ctx, (void *)&s->object_tab,
 sizeof(s->object_tab0),
 &s->object_size, s->object_count + 1))
@@ -33935,7 +33935,7 @@
 return -1;
 }
 e = &s->object_tabs->object_count++;
- h = js_object_list_get_hash(obj, s->hash_size); 
+ h = js_object_list_get_hash(obj, s->hash_size);
 e->obj = obj;
 e->hash_next = s->hash_tableh;
 s->hash_tableh = s->object_count - 1;
@@ -33951,7 +33951,7 @@
 /* must test empty size because there is no hash table */
 if (s->object_count == 0)
 return -1;
- h = js_object_list_get_hash(obj, s->hash_size); 
+ h = js_object_list_get_hash(obj, s->hash_size);
 p = s->hash_tableh;
 while (p != -1) {
 e = &s->object_tabp;
@@ -34355,7 +34355,7 @@
 int bpos, d;
 uint8_t v8;
 size_t i0;
- 
+
 /* little endian BCD */
 i = 0;
 while (i < a->len && a->tabi == 0)
@@ -34375,7 +34375,7 @@
 return -1;
 }
 bc_put_leb128(s, len);
- 
+
 bpos = 0;
 v8 = 0;
 i0 = i;
@@ -34413,7 +34413,7 @@
 JSFunctionBytecode *b = JS_VALUE_GET_PTR(obj);
 uint32_t flags;
 int idx, i;
- 
+
 bc_put_u8(s, BC_TAG_FUNCTION_BYTECODE);
 flags = idx = 0;
 bc_set_flags(&flags, &idx, b->has_prototype, 1);
@@ -34431,7 +34431,7 @@
 bc_put_u16(s, flags);
 bc_put_u8(s, b->js_mode);
 bc_put_atom(s, b->func_name);
- 
+
 bc_put_leb128(s, b->arg_count);
 bc_put_leb128(s, b->var_count);
 bc_put_leb128(s, b->defined_arg_count);
@@ -34458,7 +34458,7 @@
 } else {
 bc_put_leb128(s, 0);
 }
- 
+
 for(i = 0; i < b->closure_var_count; i++) {
 JSClosureVar *cv = &b->closure_vari;
 bc_put_atom(s, cv->var_name);
@@ -34472,17 +34472,17 @@
 assert(idx <= 8);
 bc_put_u8(s, flags);
 }
- 
+
 if (JS_WriteFunctionBytecode(s, b->byte_code_buf, b->byte_code_len))
 goto fail;
- 
+
 if (b->has_debug) {
 bc_put_atom(s, b->debug.filename);
 bc_put_leb128(s, b->debug.line_num);
 bc_put_leb128(s, b->debug.pc2line_len);
 dbuf_put(&s->dbuf, b->debug.pc2line_buf, b->debug.pc2line_len);
 }
- 
+
 for(i = 0; i < b->cpool_count; i++) {
 if (JS_WriteObjectRec(s, b->cpooli))
 goto fail;
@@ -34496,16 +34496,16 @@
 {
 JSModuleDef *m = JS_VALUE_GET_PTR(obj);
 int i;
- 
+
 bc_put_u8(s, BC_TAG_MODULE);
 bc_put_atom(s, m->module_name);
- 
+
 bc_put_leb128(s, m->req_module_entries_count);
 for(i = 0; i < m->req_module_entries_count; i++) {
 JSReqModuleEntry *rme = &m->req_module_entriesi;
 bc_put_atom(s, rme->module_name);
 }
- 
+
 bc_put_leb128(s, m->export_entries_count);
 for(i = 0; i < m->export_entries_count; i++) {
 JSExportEntry *me = &m->export_entriesi;
@@ -34518,13 +34518,13 @@
 }
 bc_put_atom(s, me->export_name);
 }
- 
+
 bc_put_leb128(s, m->star_export_entries_count);
 for(i = 0; i < m->star_export_entries_count; i++) {
 JSStarExportEntry *se = &m->star_export_entriesi;
 bc_put_leb128(s, se->req_module_idx);
 }
- 
+
 bc_put_leb128(s, m->import_entries_count);
 for(i = 0; i < m->import_entries_count; i++) {
 JSImportEntry *mi = &m->import_entriesi;
@@ -34532,7 +34532,7 @@
 bc_put_atom(s, mi->import_name);
 bc_put_leb128(s, mi->req_module_idx);
 }
- 
+
 if (JS_WriteObjectRec(s, m->func_obj))
 goto fail;
 return 0;
@@ -34547,7 +34547,7 @@
 JSValue val;
 int ret;
 BOOL is_template;
- 
+
 if (s->allow_bytecode && !p->extensible) {
 /* not extensible array: we consider it is a
 template when we are saving bytecode */
@@ -34721,7 +34721,7 @@
 {
 JSObject *p = JS_VALUE_GET_OBJ(obj);
 int ret, idx;
- 
+
 if (s->allow_reference) {
 idx = js_object_list_find(s->ctx, &s->object_list, p);
 if (idx >= 0) {
@@ -34862,7 +34862,7 @@
 s->first_atom = 1;
 js_dbuf_init(ctx, &s->dbuf);
 js_object_list_init(&s->object_list);
- 
+
 if (JS_WriteObjectRec(s, obj))
 goto fail;
 if (JS_WriteObjectAtoms(s))
@@ -34910,7 +34910,7 @@
 JSObject **objects;
 int objects_count;
 int objects_size;
- 
+
 #ifdef DUMP_READ_OBJECT
 const uint8_t *ptr_last;
 int level;
@@ -35195,7 +35195,7 @@
 limb_t v;
 bf_t *a;
 int bpos, d;
- 
+
 p = js_new_bf(s->ctx);
 if (!p)
 goto fail;
@@ -35407,7 +35407,7 @@
 b = js_mallocz(ctx, function_size);
 if (!b)
 return JS_EXCEPTION;
- 
+
 memcpy(b, &bc, offsetof(JSFunctionBytecode, debug));
 b->header.ref_count = 1;
 if (local_count != 0) {
@@ -35419,9 +35419,9 @@
 if (b->cpool_count != 0) {
 b->cpool = (void *)((uint8_t*)b + cpool_offset);
 }
- 
+
 add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
- 
+
 obj = JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
 
 #ifdef DUMP_READ_OBJECT
@@ -35534,7 +35534,7 @@
 JSAtom module_name;
 int i;
 uint8_t v8;
- 
+
 if (bc_get_atom(s, &module_name))
 goto fail;
 #ifdef DUMP_READ_OBJECT
@@ -35635,7 +35635,7 @@
 JSAtom atom;
 JSValue val;
 int ret;
- 
+
 obj = JS_NewObject(ctx);
 if (BC_add_object_ref(s, obj))
 goto fail;
@@ -35715,7 +35715,7 @@
 uint8_t array_tag;
 JSValueConst args3;
 uint32_t offset, len, idx;
- 
+
 if (bc_get_u8(s, &array_tag))
 return JS_EXCEPTION;
 if (array_tag >= JS_TYPED_ARRAY_COUNT)
@@ -35760,7 +35760,7 @@
 JSContext *ctx = s->ctx;
 uint32_t byte_length;
 JSValue obj;
- 
+
 if (bc_get_leb128(s, &byte_length))
 return JS_EXCEPTION;
 if (unlikely(s->buf_end - s->ptr < byte_length)) {
@@ -35786,7 +35786,7 @@
 uint8_t *data_ptr;
 JSValue obj;
 uint64_t u64;
- 
+
 if (bc_get_leb128(s, &byte_length))
 return JS_EXCEPTION;
 if (bc_get_u64(s, &u64))
@@ -36296,7 +36296,7 @@
 set_cycle_flag(ctx, proto);
 }
 
-void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj, 
+void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
 JSValueConst proto)
 {
 JS_SetConstructor2(ctx, func_obj, proto,
@@ -37113,7 +37113,7 @@
 if (!res) {
 return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
 }
- 
+
 p = JS_VALUE_GET_OBJ(obj);
 flags = JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK;
 if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p, flags))
@@ -37154,7 +37154,7 @@
 JSPropertyEnum *props;
 uint32_t len, i;
 int flags, res;
- 
+
 if (!JS_IsObject(obj))
 return JS_TRUE;
 
@@ -37183,7 +37183,7 @@
 if (res < 0)
 return JS_EXCEPTION;
 res ^= 1;
-done: 
+done:
 js_free_prop_enum(ctx, props, len);
 return JS_NewBool(ctx, res);
 
@@ -37206,14 +37206,14 @@
 obj = JS_NewObject(ctx);
 if (JS_IsException(obj))
 return obj;
- 
+
 iter = JS_GetIterator(ctx, iterable, FALSE);
 if (JS_IsException(iter))
 goto fail;
 next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
 if (JS_IsException(next_method))
 goto fail;
- 
+
 for(;;) {
 JSValue key, value, item;
 item = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
@@ -37223,7 +37223,7 @@
 JS_FreeValue(ctx, item);
 break;
 }
- 
+
 key = JS_UNDEFINED;
 value = JS_UNDEFINED;
 if (!JS_IsObject(item)) {
@@ -37607,7 +37607,7 @@
 
 string_buffer_init(ctx, b, 0);
 string_buffer_putc8(b, '(');
- 
+
 if (func_kind == JS_FUNC_ASYNC || func_kind == JS_FUNC_ASYNC_GENERATOR) {
 string_buffer_puts8(b, "async ");
 }
@@ -37940,7 +37940,7 @@
 JSValue v, r = JS_UNDEFINED;
 int64_t k;
 BOOL done;
- 
+
 iter = JS_GetIterator(ctx, items, FALSE);
 if (JS_IsException(iter))
 goto exception;
@@ -37986,7 +37986,7 @@
 if (!JS_IsObject(proto)) {
 JSContext *realm;
 JSValueConst proto1;
- 
+
 JS_FreeValue(ctx, proto);
 realm = JS_GetFunctionRealm(ctx, new_target);
 if (!realm)
@@ -38074,7 +38074,7 @@
 JSValueConst errors)
 {
 JSValue obj;
- 
+
 obj = JS_NewObjectProtoClass(ctx,
 ctx->native_error_protoJS_AGGREGATE_ERROR,
 JS_CLASS_ERROR);
@@ -38313,7 +38313,7 @@
 JSValue ctor, ret, species;
 int res;
 JSContext *realm;
- 
+
 res = JS_IsArray(ctx, obj);
 if (res < 0)
 return JS_EXCEPTION;
@@ -38478,7 +38478,7 @@
 this_arg = JS_UNDEFINED;
 if (argc > 1)
 this_arg = argv1;
- 
+
 if (check_function(ctx, func))
 goto exception;
 
@@ -40219,7 +40219,7 @@
 uint32_t idx;
 JSObject *p;
 JSString *p1, *p2;
- 
+
 if (__JS_AtomIsTaggedInt(prop)) {
 idx = __JS_AtomToUInt32(prop);
 p = JS_VALUE_GET_OBJ(this_obj);
@@ -40385,7 +40385,7 @@
 goto exception;
 if (js_get_length64(ctx, &n, raw) < 0)
 goto exception;
- 
+
 for (i = 0; i < n; i++) {
 val = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, raw, i));
 if (JS_IsException(val))
@@ -40738,7 +40738,7 @@
 {
 int ret;
 JSValue flags;
- 
+
 ret = js_is_regexp(ctx, regexp);
 if (ret < 0)
 return -1;
@@ -41017,7 +41017,7 @@
 }
 if (JS_IsException(repl_str))
 goto exception;
- 
+
 string_buffer_concat(b, sp, endOfLastMatch, pos);
 string_buffer_concat_value_free(b, repl_str);
 endOfLastMatch = pos + searchp->len;
@@ -41695,7 +41695,7 @@
 static struct { const char *tag, *attr; } const defs = {
 { "a", "name" }, { "big", NULL }, { "blink", NULL }, { "b", NULL },
 { "tt", NULL }, { "font", "color" }, { "font", "size" }, { "i", NULL },
- { "a", "href" }, { "small", NULL }, { "strike", NULL }, 
+ { "a", "href" }, { "small", NULL }, { "strike", NULL },
 { "sub", NULL }, { "sup", NULL },
 };
 
@@ -42054,6 +42054,7 @@
 #if defined(_MSC_VER)
 static double const_floor(double x) { return floor(x); }
 static double const_ceil(double x) { return ceil(x); }
+static double const_log2(double x) { return log2(x); }
 #endif
 
 static const JSCFunctionListEntry js_math_funcs = {
@@ -42091,7 +42092,11 @@
 JS_CFUNC_SPECIAL_DEF("atanh", 1, f_f, atanh ),
 JS_CFUNC_SPECIAL_DEF("expm1", 1, f_f, expm1 ),
 JS_CFUNC_SPECIAL_DEF("log1p", 1, f_f, log1p ),
- JS_CFUNC_SPECIAL_DEF("log2", 1, f_f, log2 ),
+#if defined(_MSC_VER)
+ JS_CFUNC_SPECIAL_DEF("log2", 1, f_f, const_log2),
+#else
+ JS_CFUNC_SPECIAL_DEF("log2", 1, f_f, log2),
+#endif
 JS_CFUNC_SPECIAL_DEF("log10", 1, f_f, log10 ),
 JS_CFUNC_SPECIAL_DEF("cbrt", 1, f_f, cbrt ),
 JS_CFUNC_DEF("hypot", 2, js_math_hypot ),
@@ -42528,7 +42533,7 @@
 if (p->len == 0) {
 empty_regex:
 return JS_NewString(ctx, "(?:)");
- } 
+ }
 string_buffer_init2(ctx, b, p->len, p->is_wide_char);
 
 /* Escape '/' and newline sequences as needed */
@@ -42587,7 +42592,7 @@
 else
 return JS_ThrowTypeErrorInvalidClass(ctx, JS_CLASS_REGEXP);
 }
- 
+
 flags = lre_get_flags(re->bytecode->u.str8);
 return JS_NewBool(ctx, (flags & mask) != 0);
 }
@@ -43114,7 +43119,7 @@
 JSString *strp;
 int64_t lastIndex;
 JSRegExpStringIteratorData *it;
- 
+
 if (!JS_IsObject(R))
 return JS_ThrowTypeErrorNotAnObject(ctx);
 
@@ -43122,7 +43127,7 @@
 flags = JS_UNDEFINED;
 matcher = JS_UNDEFINED;
 iter = JS_UNDEFINED;
- 
+
 S = JS_ToString(ctx, argv0);
 if (JS_IsException(S))
 goto exception;
@@ -43143,7 +43148,7 @@
 if (JS_SetProperty(ctx, matcher, JS_ATOM_lastIndex,
 JS_NewInt64(ctx, lastIndex)) < 0)
 goto exception;
- 
+
 iter = JS_NewObjectClass(ctx, JS_CLASS_REGEXP_STRING_ITERATOR);
 if (JS_IsException(iter))
 goto exception;
@@ -43281,7 +43286,7 @@
 str = JS_ToString(ctx, argv0);
 if (JS_IsException(str))
 goto exception;
- 
+
 sp = JS_VALUE_GET_STRING(str);
 rp = NULL;
 functionalReplace = JS_IsFunction(ctx, rep);
@@ -43560,7 +43565,7 @@
 while (q < size) {
 if (JS_SetProperty(ctx, splitter, JS_ATOM_lastIndex, JS_NewInt32(ctx, q)) < 0)
 goto exception;
- JS_FreeValue(ctx, z); 
+ JS_FreeValue(ctx, z);
 z = JS_RegExpExec(ctx, splitter, str);
 if (JS_IsException(z))
 goto exception;
@@ -43615,7 +43620,7 @@
 JS_FreeValue(ctx, ctor);
 JS_FreeValue(ctx, splitter);
 JS_FreeValue(ctx, flags);
- JS_FreeValue(ctx, z); 
+ JS_FreeValue(ctx, z);
 return A;
 }
 
@@ -43700,7 +43705,7 @@
 {
 JSValue prop_val;
 JSAtom prop_name;
- 
+
 if (json_next_token(s))
 goto fail;
 val = JS_NewObject(ctx);
@@ -43843,7 +43848,7 @@
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
 const char *filename)
 {
- return JS_ParseJSON2(ctx, buf, buf_len, filename, 0); 
+ return JS_ParseJSON2(ctx, buf, buf_len, filename, 0);
 }
 
 static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
@@ -44036,7 +44041,7 @@
 int64_t i, len;
 int cl, ret;
 BOOL has_content;
- 
+
 indent1 = JS_UNDEFINED;
 sep = JS_UNDEFINED;
 sep1 = JS_UNDEFINED;
@@ -44211,7 +44216,7 @@
 JS_FreeValue(ctx, val);
 return 0;
 }
- 
+
 exception:
 JS_FreeValue(ctx, val);
 JS_FreeValue(ctx, tab);
@@ -44329,7 +44334,7 @@
 JS_DupValue(ctx, obj), JS_PROP_C_W_E) < 0)
 goto exception;
 val = JS_DupValue(ctx, obj);
- 
+
 val = js_json_check(ctx, jsc, wrapper, val, jsc->empty);
 if (JS_IsException(val))
 goto exception;
@@ -44585,7 +44590,7 @@
 JS_ThrowStackOverflow(ctx);
 return NULL;
 }
- 
+
 /* 's' should never be NULL */
 if (s->is_revoked) {
 JS_ThrowTypeErrorRevokedProxy(ctx);
@@ -44984,7 +44989,7 @@
 JS_FreeValue(ctx, trap_result_obj);
 if (res < 0)
 return -1;
- 
+
 if (target_desc_ret) {
 /* convert result_desc.flags to defineProperty flags */
 flags1 = result_desc.flags | JS_PROP_HAS_CONFIGURABLE | JS_PROP_HAS_ENUMERABLE;
@@ -45349,7 +45354,7 @@
 
 if (flags & JS_CALL_FLAG_CONSTRUCTOR)
 return js_proxy_call_constructor(ctx, func_obj, this_obj, argc, argv);
- 
+
 s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_apply);
 if (!s)
 return JS_EXCEPTION;
@@ -45946,7 +45951,7 @@
 list_del(&mr->hash_link);
 list_del(&mr->link);
 }
- 
+
 /* second pass to free the values to avoid modifying the weak
 reference list while traversing it. */
 for(mr = p->first_weak_ref; mr != NULL; mr = mr_next) {
@@ -46949,7 +46954,7 @@
 JSValueConst resolve_element_env = func_data4;
 JSValue ret, obj;
 int is_zero, index;
- 
+
 if (JS_ToInt32(ctx, &index, func_data1))
 return JS_EXCEPTION;
 if (alreadyCalled)
@@ -46958,7 +46963,7 @@
 
 if (resolve_type == PROMISE_MAGIC_allSettled) {
 JSValue str;
- 
+
 obj = JS_NewObject(ctx);
 if (JS_IsException(obj))
 return JS_EXCEPTION;
@@ -46983,7 +46988,7 @@
 if (JS_DefinePropertyValueUint32(ctx, values, index,
 obj, JS_PROP_C_W_E) < 0)
 return JS_EXCEPTION;
- 
+
 is_zero = remainingElementsCount_add(ctx, resolve_element_env, -1);
 if (is_zero < 0)
 return JS_EXCEPTION;
@@ -47016,7 +47021,7 @@
 JSValueConst then_args2, resolve_element_data5;
 BOOL done;
 int index, is_zero, is_promise_any = (magic == PROMISE_MAGIC_any);
- 
+
 if (!JS_IsObject(this_val))
 return JS_ThrowTypeErrorNotAnObject(ctx);
 result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
@@ -47052,7 +47057,7 @@
 JS_NewInt32(ctx, 1),
 JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
 goto fail_reject;
- 
+
 index = 0;
 for(;;) {
 /* XXX: conformance: should close the iterator if error on 'done'
@@ -47062,7 +47067,7 @@
 goto fail_reject;
 if (done)
 break;
- next_promise = JS_Call(ctx, promise_resolve, 
+ next_promise = JS_Call(ctx, promise_resolve,
 this_val, 1, (JSValueConst *)&item);
 JS_FreeValue(ctx, item);
 if (JS_IsException(next_promise)) {
@@ -47086,7 +47091,7 @@
 JS_FreeValue(ctx, next_promise);
 goto fail_reject1;
 }
- 
+
 if (magic == PROMISE_MAGIC_allSettled) {
 reject_element =
 JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1,
@@ -48174,7 +48179,7 @@
 int64_t y;
 double days, d, h, m1;
 int i, m, md;
- 
+
 m1 = fields1;
 m = fmod(m1, 12);
 if (m < 0)
@@ -48189,7 +48194,7 @@
 days += md;
 }
 days += fields2 - 1;
- h = fields3 * 3600000 + fields4 * 60000 + 
+ h = fields3 * 3600000 + fields4 * 60000 +
 fields5 * 1000 + fields6;
 d = days * 86400000 + h;
 if (is_local)
@@ -48494,7 +48499,7 @@
 static int string_get_digits(JSString *sp, int *pp, int64_t *pval) {
 int64_t v = 0;
 int c, p = *pp, p_start;
- 
+
 if (p >= sp->len)
 return -1;
 p_start = p;
@@ -48516,14 +48521,14 @@
 
 static int string_get_signed_digits(JSString *sp, int *pp, int64_t *pval) {
 int res, sgn, p = *pp;
- 
+
 if (p >= sp->len)
 return -1;
 
 sgn = string_get(sp, p);
 if (sgn == '-' || sgn == '+')
 p++;
- 
+
 res = string_get_digits(sp, &p, pval);
 if (res == 0 && sgn == '-')
 *pval = -*pval;
@@ -48617,13 +48622,13 @@
 int p, i, c, sgn, l;
 JSString *sp;
 BOOL is_local;
- 
+
 rv = JS_NAN;
 
 s = JS_ToString(ctx, argv0);
 if (JS_IsException(s))
 return JS_EXCEPTION;
- 
+
 sp = JS_VALUE_GET_STRING(s);
 p = 0;
 if (p < sp->len && (((c = string_get(sp, p)) >= '0' && c <= '9') || c == '+' || c == '-')) {
@@ -48987,7 +48992,7 @@
 JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
 int i, j;
 JSBinaryOperatorDefEntry *ent;
- 
+
 if (opset) {
 for(i = 0; i < JS_OVOP_COUNT; i++) {
 if (opset->self_opsi)
@@ -49019,7 +49024,7 @@
 JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
 int i, j;
 JSBinaryOperatorDefEntry *ent;
- 
+
 if (opset) {
 for(i = 0; i < JS_OVOP_COUNT; i++) {
 if (opset->self_opsi)
@@ -49119,7 +49124,7 @@
 }
 op_count = opset1->operator_counter;
 JS_FreeValue(ctx, prop);
- 
+
 /* we assume there are few entries */
 new_tab = js_realloc(ctx, def->tab,
 (def->count + 1) * sizeof(def->tab0));
@@ -49130,7 +49135,7 @@
 ent = def->tab + def->count - 1;
 memset(ent, 0, sizeof(def->tab0));
 ent->operator_index = op_count;
- 
+
 for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
 prop = JS_GetPropertyStr(ctx, arg,
 js_overloadable_operator_namesi);
@@ -49167,7 +49172,7 @@
 const JSOverloadableOperatorEnum ops2 = { JS_OVOP_DIV, JS_OVOP_POW };
 JSOverloadableOperatorEnum op;
 int i;
- 
+
 opset_obj = JS_GetProperty(ctx, ctx->class_protoJS_CLASS_BIG_INT,
 JS_ATOM_Symbol_operatorSet);
 if (JS_IsException(opset_obj))
@@ -49297,7 +49302,7 @@
 case JS_TAG_BIG_FLOAT:
 {
 bf_t *a, a_s;
- 
+
 a = JS_ToBigFloat(ctx, &a_s, val);
 if (!bf_is_finite(a)) {
 JS_FreeValue(ctx, val);
@@ -49412,7 +49417,7 @@
 bf_t a_s, b_s, *a, *b, *r, *q;
 int status;
 JSValue q_val, r_val;
- 
+
 q_val = JS_NewBigInt(ctx);
 if (JS_IsException(q_val))
 return JS_EXCEPTION;
@@ -49463,7 +49468,7 @@
 bf_t a_s, *a, *r, *rem;
 int status;
 JSValue r_val, rem_val;
- 
+
 r_val = JS_NewBigInt(ctx);
 if (JS_IsException(r_val))
 return JS_EXCEPTION;
@@ -49541,7 +49546,7 @@
 uint64_t bits;
 bf_t a_s, *a = &a_s, *r, mask_s, *mask = &mask_s;
 JSValue res;
- 
+
 if (JS_ToIndex(ctx, &bits, argv0))
 return JS_EXCEPTION;
 res = JS_NewBigInt(ctx);
@@ -49608,7 +49613,7 @@
 rt->bigint_ops.unary_arith = js_unary_arith_bigint;
 rt->bigint_ops.binary_arith = js_binary_arith_bigint;
 rt->bigint_ops.compare = js_compare_bigfloat;
- 
+
 ctx->class_protoJS_CLASS_BIG_INT = JS_NewObject(ctx);
 JS_SetPropertyFunctionList(ctx, ctx->class_protoJS_CLASS_BIG_INT,
 js_bigint_proto_funcs,
@@ -50033,7 +50038,7 @@
 {
 JSValueConst val = argv0;
 JSBigFloat *p;
- 
+
 if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
 return JS_FALSE;
 p = JS_VALUE_GET_PTR(val);
@@ -50045,7 +50050,7 @@
 {
 JSValueConst val = argv0;
 JSBigFloat *p;
- 
+
 if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
 return JS_FALSE;
 p = JS_VALUE_GET_PTR(val);
@@ -50499,7 +50504,7 @@
 {
 JSRuntime *rt = ctx->rt;
 JSValueConst obj1;
- 
+
 rt->bigfloat_ops.to_string = js_bigfloat_to_string;
 rt->bigfloat_ops.from_string = js_string_to_bigfloat;
 rt->bigfloat_ops.unary_arith = js_unary_arith_bigfloat;
@@ -50507,7 +50512,7 @@
 rt->bigfloat_ops.compare = js_compare_bigfloat;
 rt->bigfloat_ops.mul_pow10_to_float64 = js_mul_pow10_to_float64;
 rt->bigfloat_ops.mul_pow10 = js_mul_pow10;
- 
+
 ctx->class_protoJS_CLASS_BIG_FLOAT = JS_NewObject(ctx);
 JS_SetPropertyFunctionList(ctx, ctx->class_protoJS_CLASS_BIG_FLOAT,
 js_bigfloat_proto_funcs,
@@ -50683,7 +50688,7 @@
 const char *str;
 size_t size;
 int rnd_mode;
- 
+
 str = JS_ToCStringLen(ctx, &size, obj);
 if (!str)
 return -1;
@@ -50723,7 +50728,7 @@
 int64_t val;
 BOOL has_prec;
 int rnd_mode;
- 
+
 if (!JS_IsObject(obj)) {
 JS_ThrowTypeErrorNotAnObject(ctx);
 return -1;
@@ -50736,7 +50741,7 @@
 if (rnd_mode < 0)
 return -1;
 fe->flags = rnd_mode;
- 
+
 prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumSignificantDigits);
 if (JS_IsException(prop))
 return -1;
@@ -50791,7 +50796,7 @@
 op_count = 1;
 else
 op_count = 2;
- 
+
 op1 = JS_ToNumeric(ctx, argv0);
 if (JS_IsException(op1))
 return op1;
@@ -51748,7 +51753,7 @@
 }
 return JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, ta->buffer));
 }
- 
+
 static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
 JSValueConst this_val)
 {
@@ -52168,7 +52173,7 @@
 
 if (typed_array_is_detached(ctx, p))
 return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
- 
+
 shift = typed_array_size_log2(p->class_id);
 switch(shift) {
 case 0:
@@ -52309,7 +52314,7 @@
 res = 0;
 goto done;
 }
- 
+
 is_bigint = 0;
 is_int = 0; /* avoid warning */
 v64 = 0; /* avoid warning */
@@ -52327,7 +52332,7 @@
 #ifdef CONFIG_BIGNUM
 if (tag == JS_TAG_BIG_INT) {
 JSBigFloat *p1 = JS_VALUE_GET_PTR(argv0);
- 
+
 if (p->class_id == JS_CLASS_BIG_INT64_ARRAY) {
 if (bf_get_int64(&v64, &p1->num, 0) != 0)
 goto done;
@@ -52966,7 +52971,7 @@
 uint32_t *array_idx;
 void *array_tmp;
 size_t i, j;
- 
+
 /* XXX: a stable sort would use less memory */
 array_idx = js_malloc(ctx, len * sizeof(array_idx0));
 if (!array_idx)
@@ -53780,7 +53785,7 @@
 }
 
 switch(op | (size_log2 << 3)) {
- 
+
 #ifdef CONFIG_BIGNUM
 #define OP(op_name, func_name) \
 case ATOMICS_OP_ ## op_name | (0 << 3): \
@@ -53829,7 +53834,7 @@
 a = atomic_load((_Atomic(uint64_t) *)ptr);
 break;
 #endif
- 
+
 case ATOMICS_OP_COMPARE_EXCHANGE | (0 << 3):
 {
 uint8_t v1 = v;
@@ -54009,7 +54014,7 @@
 return JS_EXCEPTION;
 } else
 #endif
- { 
+ {
 if (JS_ToInt32(ctx, &v32, argv2))
 return JS_EXCEPTION;
 v = v32;

gpac-2.0.0.tar.gz/src/scene_manager/encode_isom.c -> gpac-2.2.0.tar.gz/src/scene_manager/encode_isom.c Changed

gpac-2.0.0.tar.gz/src/scene_manager/loader_bt.c -> gpac-2.2.0.tar.gz/src/scene_manager/loader_bt.c Changed

gpac-2.0.0.tar.gz/src/scene_manager/loader_qt.c -> gpac-2.2.0.tar.gz/src/scene_manager/loader_qt.c Changed

gpac-2.0.0.tar.gz/src/scene_manager/loader_svg.c -> gpac-2.2.0.tar.gz/src/scene_manager/loader_svg.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre, Cyril Concolato
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Management sub-project
@@ -259,10 +259,10 @@
 		} else {
 			char *mtype;
 			char *buf64;
-			u64 size64;
+			u32 size64 = size*2 + 3;
 			char *ext;
-			buf64 = (char *)gf_malloc((size_t)size*2);
-			size64 = gf_base64_encode(buffer, (u32)size, buf64, (u32)size*2);
+			buf64 = (char *)gf_malloc(sizeof(char) * size64);
+			size64 = gf_base64_encode(buffer, (u32)size, buf64, size64);
 			buf64size64 = 0;
 			mtype = "application/data";
 			ext = strchr(iri->string, '.');
@@ -329,13 +329,15 @@
 	}
 	if (iri->type != XMLRI_STRING) return;
 	e = gf_node_store_embedded_data(iri, parser->load->localPath, parser->load->fileName);
-	if (e) svg_report(parser, e, "Error storing embedded IRI data");
+	if (e)
+		svg_report(parser, e, "Error storing embedded IRI data");
 }
 
 static void svg_delete_deferred_anim(SVG_DeferredAnimation *anim, GF_List *deferred_animations)
 {
 	if (deferred_animations) gf_list_del_item(deferred_animations, anim);
 
+	if (anim->animation_elt) gf_node_unregister((GF_Node*)anim->animation_elt, NULL);
 	if (anim->target_id) gf_free(anim->target_id);
 	if (anim->to) gf_free(anim->to);
 	if (anim->from) gf_free(anim->from);
@@ -351,12 +353,14 @@
 	u32 tag;
 	u8 anim_value_type = 0;
 
+	if (!anim->animation_elt)
+		return GF_FALSE;
 	if (anim->resolve_stage==0) {
 		/* Stage 0: parsing the animation attribute values
 					for that we need to resolve the target first */
 
 		/* if we don't have a target, try to get it */
-		if (!anim->target)
+		if (!anim->target && anim->target_id)
 			anim->target = (SVG_Element *) gf_sg_find_node_by_name(sg, anim->target_id + 1);
 
 		/* if now we have a target, create the xlink:href attribute on the animation element and set it to the found target */
@@ -446,6 +450,7 @@
 		if (anim->to) {
 			/* now that we have a target, if there is a to value to parse, create the attribute and parse it */
 			gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_to, GF_TRUE, GF_FALSE, &info);
+			if (!info.name) info.name = "to";
 			gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->to, anim_value_type);
 			if (anim_value_type==XMLRI_datatype) {
 				svg_post_process_href(parser, (GF_Node *) anim->target, (XMLRI*)((SMIL_AnimateValue *)info.far_ptr)->value);
@@ -454,6 +459,7 @@
 		if (anim->from) {
 			/* now that we have a target, if there is a from value to parse, create the attribute and parse it */
 			gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_from, GF_TRUE, GF_FALSE, &info);
+			if (!info.name) info.name = "from";
 			gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->from, anim_value_type);
 			if (anim_value_type==XMLRI_datatype)
 				svg_post_process_href(parser, (GF_Node *) anim->target, (XMLRI*)((SMIL_AnimateValue *)info.far_ptr)->value);
@@ -461,6 +467,7 @@
 		if (anim->by) {
 			/* now that we have a target, if there is a by value to parse, create the attribute and parse it */
 			gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_by, GF_TRUE, GF_FALSE, &info);
+			if (!info.name) info.name = "by";
 			gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->by, anim_value_type);
 			if (anim_value_type==XMLRI_datatype)
 				svg_post_process_href(parser, (GF_Node *) anim->target, (XMLRI*)((SMIL_AnimateValue *)info.far_ptr)->value);
@@ -468,6 +475,7 @@
 		if (anim->values) {
 			/* now that we have a target, if there is a 'values' value to parse, create the attribute and parse it */
 			gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_values, GF_TRUE, GF_FALSE, &info);
+			if (!info.name) info.name = "values";
 			gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->values, anim_value_type);
 			if (anim_value_type==XMLRI_datatype) {
 				u32 i, count;
@@ -740,6 +748,7 @@
 		}
 		/*default anim target is parent node*/
 		anim->animation_elt = elt;
+		gf_node_register((GF_Node*)elt, NULL);
 		if (!parent) {
 			if (parser->command) {
 				anim->target = anim->anim_parent = (SVG_Element*) parser->command->node;
@@ -757,6 +766,7 @@
 		}
 		/*default anim target is parent node*/
 		anim->animation_elt = elt;
+		gf_node_register((GF_Node*)elt, NULL);
 		if (!parent) {
 			if (parser->command) {
 				anim->target = anim->anim_parent = (SVG_Element*) parser->command->node;
@@ -882,8 +892,9 @@
 			if (!stricmp(att_name, "scale") ) {
 				if (gf_node_get_attribute_by_tag((GF_Node *)elt, TAG_SVG_ATT_transform, GF_TRUE, GF_TRUE, &info)==GF_OK) {
 					SVG_Point pt;
+					GF_Err e;
 					SVG_Transform *mat = (SVG_Transform *)info.far_ptr;
-					svg_parse_point(&pt, att->value);
+					svg_parse_point(&pt, att->value, &e);
 					gf_mx2d_add_scale(&mat->mat, pt.x, pt.y);
 					continue;
 				}
@@ -891,8 +902,9 @@
 			if (!stricmp(att_name, "translation") ) {
 				if (gf_node_get_attribute_by_tag((GF_Node *)elt, TAG_SVG_ATT_transform, GF_TRUE, GF_TRUE, &info)==GF_OK) {
 					SVG_Point pt;
+					GF_Err e;
 					SVG_Transform *mat = (SVG_Transform *)info.far_ptr;
-					svg_parse_point(&pt, att->value);
+					svg_parse_point(&pt, att->value, &e);
 					gf_mx2d_add_translation(&mat->mat, pt.x, pt.y);
 					continue;
 				}
@@ -918,6 +930,7 @@
 		/* General attribute creation and parsing */
 		if (gf_node_get_attribute_by_name((GF_Node *)elt, att_name, ns, GF_TRUE, GF_FALSE, &info)==GF_OK) {
 #ifndef SKIP_ATTS_PARSING
+			if (!info.name) info.name = att_name;
 			GF_Err e = gf_svg_parse_attribute((GF_Node *)elt, &info, att->value, 0);
 			if (e) {
 				svg_report(parser, e, "Error parsing attribute %s on node %s", att->name, name);
@@ -1067,7 +1080,7 @@
 		/*if event is a key event, register it with root*/
 		if (!par && gf_node_get_attribute_by_tag((GF_Node *)listener, TAG_XMLEV_ATT_event, GF_FALSE, GF_FALSE, &info) == GF_OK) {
 			XMLEV_Event *ev = (XMLEV_Event *)info.far_ptr;
-			if ((ev->type>=GF_EVENT_KEYUP) && (ev->type<=GF_EVENT_TEXTINPUT)) par = (SVG_Element*) listener->sgprivate->scenegraph->RootNode;
+			if ((ev->type >= GF_EVENT_KEYUP) && (ev->type <= GF_EVENT_TEXTINPUT)) par = (SVG_Element*) listener->sgprivate->scenegraph->RootNode;
 		}
 
 		if (post_pone) {
@@ -1274,7 +1287,8 @@
 		if (atInteger) parser->command->send_event_integer = atoi(atInteger);
 		if (atPoint) {
 			SVG_Point pt;
-			svg_parse_point(&pt, atPoint);
+			GF_Err e;
+			svg_parse_point(&pt, atPoint, &e);
 			parser->command->send_event_x = FIX2INT(pt.x);
 			parser->command->send_event_y = FIX2INT(pt.y);
 		}
@@ -2110,13 +2124,13 @@
 
 	in_time = gf_sys_clock();
 	e = gf_xml_sax_parse_file(parser->sax_parser, (const char *)load->fileName, svg_progress);
+	svg_flush_animations(parser);
+	gf_sm_svg_flush_state(parser);
 	if (parser->last_error<0) e = parser->last_error;
-	
+
 	if (e<0) return svg_report(parser, e, "Unable to parse file %s: %s", load->fileName, gf_xml_sax_get_error(parser->sax_parser) );
 	GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("Parser Scene parsed and Scene Graph built in %d ms\n", gf_sys_clock() - in_time));
 
-	svg_flush_animations(parser);
-	gf_sm_svg_flush_state(parser);
 	return e;
 
 }

gpac-2.0.0.tar.gz/src/scene_manager/loader_xmt.c -> gpac-2.2.0.tar.gz/src/scene_manager/loader_xmt.c Changed

gpac-2.0.0.tar.gz/src/scene_manager/scene_dump.c -> gpac-2.2.0.tar.gz/src/scene_manager/scene_dump.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Management sub-project
@@ -650,8 +650,8 @@
 		str = ((SFString *)ptr)->buffer;
 
 		if (node && (gf_node_get_tag(node)==TAG_MPEG4_BitWrapper)) {
-			u32 bufsize = 50+ ((M_BitWrapper*)node)->buffer_len * 2;
-			str = gf_malloc(sizeof(char)* bufsize);
+			u32 bufsize = 37 + ((M_BitWrapper*)node)->buffer_len * 2 + 3;
+			str = gf_malloc(sizeof(char) * bufsize);
 			if (str) {
 				s32 res;
 				strcpy(str, "data:application/octet-string;base64,");
@@ -755,8 +755,7 @@
 
 	switch (field.fieldType) {
 	case GF_SG_VRML_SFNODE:
-		assert ( *(GF_Node **)field.far_ptr);
-		gf_dump_vrml_node(sdump, *(GF_Node **)field.far_ptr, 0, NULL);
+		gf_dump_vrml_node(sdump, field.far_ptr ? *(GF_Node **)field.far_ptr : NULL, 0, NULL);
 		return;
 	case GF_SG_VRML_MFNODE:
 		list = * ((GF_ChildNodeItem **) field.far_ptr);
@@ -773,7 +772,8 @@
 	}
 	if (gf_sg_vrml_is_sf_field(field.fieldType)) {
 		if (sdump->XMLDump) StartAttribute(sdump, "value");
-		gf_dump_vrml_sffield(sdump, field.fieldType, field.far_ptr, 0, parent);
+		if (field.far_ptr)
+			gf_dump_vrml_sffield(sdump, field.fieldType, field.far_ptr, 0, parent);
 		if (sdump->XMLDump) EndAttribute(sdump);
 	} else {
 		GenMFField *mffield;
@@ -786,7 +786,7 @@
 		} else {
 			StartAttribute(sdump, "value");
 		}
-		for (i=0; i<mffield->count; i++) {
+		for (i=0; mffield && (i<mffield->count); i++) {
 			if (i) gf_fprintf(sdump->trace, " ");
 			gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, &slot_ptr, i);
 			/*this is to cope with single MFString which shall appear as SF in XMT*/
@@ -917,7 +917,8 @@
 
 	if (gf_sg_vrml_is_sf_field(field.fieldType)) {
 		StartAttribute(sdump, field.name);
-		gf_dump_vrml_sffield(sdump, field.fieldType, field.far_ptr, 0, node);
+		if (field.far_ptr)
+			gf_dump_vrml_sffield(sdump, field.fieldType, field.far_ptr, 0, node);
 		EndAttribute(sdump);
 	} else {
 		GenMFField *mffield = (GenMFField *) field.far_ptr;
@@ -939,12 +940,10 @@
 		}
 
 		if (!sdump->XMLDump) gf_fprintf(sdump->trace, "");
-		if (mffield) {
-			for (i=0; i<mffield->count; i++) {
-				if (i) gf_fprintf(sdump->trace, " ");
-				gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, &slot_ptr, i);
-				gf_dump_vrml_sffield(sdump, sf_type, slot_ptr, 1, node);
-			}
+		for (i=0; mffield && (i<mffield->count); i++) {
+			if (i) gf_fprintf(sdump->trace, " ");
+			gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, &slot_ptr, i);
+			gf_dump_vrml_sffield(sdump, sf_type, slot_ptr, 1, node);
 		}
 		if (!sdump->XMLDump) gf_fprintf(sdump->trace, "");
 
@@ -1151,7 +1150,7 @@
 					sdump->indent--;
 					DUMP_IND(sdump);
 				} else {
-					for (i=0; i<mffield->count; i++) {
+					for (i=0; mffield && (i<mffield->count); i++) {
 						if (i) gf_fprintf(sdump->trace, " ");
 						if (field.fieldType != GF_SG_VRML_MFNODE) {
 							gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, &slot_ptr, i);
@@ -1192,7 +1191,7 @@
 					} else {
 						gf_fprintf(sdump->trace, " %s=\"", GetXMTFieldTypeValueName(field.fieldType));
 					}
-					for (i=0; i<mffield->count; i++) {
+					for (i=0; mffield && (i<mffield->count); i++) {
 						if (i) gf_fprintf(sdump->trace, " ");
 						if (field.fieldType != GF_SG_VRML_MFNODE) {
 							gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, &slot_ptr, i);
@@ -1236,7 +1235,8 @@
 			} else {
 				gf_fprintf(sdump->trace, " %s=\"", GetXMTFieldTypeValueName(field.fieldType));
 			}
-			gf_dump_vrml_sffield(sdump, field.fieldType, field.far_ptr, 0, node);
+			if (field.far_ptr)
+				gf_dump_vrml_sffield(sdump, field.fieldType, field.far_ptr, 0, node);
 			gf_fprintf(sdump->trace, "\"/>\n");
 		}
 	} else {
@@ -1263,13 +1263,11 @@
 				} else {
 					gf_fprintf(sdump->trace, " %s=\"", GetXMTFieldTypeValueName(field.fieldType));
 				}
-				if (mffield) {
-					for (i=0; i<mffield->count; i++) {
-						if (i) gf_fprintf(sdump->trace, " ");
-						if (field.fieldType != GF_SG_VRML_MFNODE) {
-							gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, &slot_ptr, i);
-							gf_dump_vrml_sffield(sdump, sf_type, slot_ptr, (mffield->count>1) ? 1 : 0, node);
-						}
+				for (i=0; mffield && (i<mffield->count); i++) {
+					if (i) gf_fprintf(sdump->trace, " ");
+					if (field.fieldType != GF_SG_VRML_MFNODE) {
+						gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, &slot_ptr, i);
+						gf_dump_vrml_sffield(sdump, sf_type, slot_ptr, (mffield->count>1) ? 1 : 0, node);
 					}
 				}
 				gf_fprintf(sdump->trace, "\"/>\n");
@@ -2781,9 +2779,13 @@
 	 lsr_format_node_id(com->node, com->RouteID, szID),
 	 gf_dom_event_get_name(com->send_event_name)
 	 );
-	if (com->send_event_name <= GF_EVENT_MOUSEWHEEL)
+	if ((com->send_event_name <= GF_EVENT_MOUSEWHEEL)
+		|| (com->send_event_name == GF_EVENT_MOUSEOUT)
+		|| (com->send_event_name == GF_EVENT_MOUSEOVER)
+	) {
 		gf_fprintf(sdump->trace, " pointvalue=\"%g %g\"", FIX2FLT(com->send_event_x), FIX2FLT(com->send_event_y) );
-
+	}
+	
 	switch (com->send_event_name) {
 	case GF_EVENT_KEYDOWN:
 	case GF_EVENT_LONGKEYPRESS:
@@ -3022,7 +3024,6 @@
 		DUMP_IND(sdump);
 		gf_fprintf(sdump->trace, "}\n");
 	}
-#endif
 
 	if (has_scene_replace && sdump->XMLDump) {
 		sdump->indent--;
@@ -3032,6 +3033,7 @@
 			EndElement(sdump, "Replace", 1);
 		}
 	}
+#endif
 
 	sdump->indent = prev_ind;
 	sdump->skip_scene_replace = prev_skip;

gpac-2.0.0.tar.gz/src/scene_manager/scene_engine.c -> gpac-2.2.0.tar.gz/src/scene_manager/scene_engine.c Changed

gpac-2.0.0.tar.gz/src/scene_manager/swf_parse.c -> gpac-2.2.0.tar.gz/src/scene_manager/swf_parse.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2020
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / Scene Management sub-project
@@ -1816,6 +1816,7 @@
 		char szName1024;
 		u32 alloc_size, tot_size;
 		char *frame;
+		GF_Err e=GF_OK;
 
 		sprintf(szName, "swf_sound_%d.mp3", snd->ID);
 		if (read->localPath) {
@@ -1838,11 +1839,16 @@
 			u32 toread = read->size - tot_size;
 			if (toread>alloc_size) toread = alloc_size;
 			swf_read_data(read, frame, toread);
-			gf_fwrite(frame, sizeof(char)*toread, snd->output);
+			if (gf_fwrite(frame, sizeof(char)*toread, snd->output) != toread)
+				e = GF_IO_ERR;
 			tot_size += toread;
 		}
 
 		gf_free(frame);
+		if (e) {
+			gf_free(snd);
+			return e;
+		}
 		return gf_list_add(read->sounds, snd);
 	}
 	case 3:
@@ -1982,6 +1988,7 @@
 	unsigned char bytes4;
 	u32 hdr, alloc_size, size, tot_size, samplesPerFrame;
 	char *frame;
+	GF_Err e = GF_OK;
 
 	/*note we're doing only MP3*/
 	if (!read->sound_stream) return swf_func_skip(read);
@@ -2025,13 +2032,13 @@
 		if (tot_size + size >= read->size) size = read->size - tot_size;
 
 		swf_read_data(read, frame, size-4);
-		gf_fwrite(bytes, sizeof(char)*4, read->sound_stream->output);
-		gf_fwrite(frame, sizeof(char)*(size-4), read->sound_stream->output);
+		if (gf_fwrite(bytes, sizeof(char)*4, read->sound_stream->output)!=4) e = GF_IO_ERR;
+		if (gf_fwrite(frame, sizeof(char)*(size-4), read->sound_stream->output) != size-4) e = GF_IO_ERR;
 		if (tot_size + size >= read->size) break;
 		tot_size += size;
 	}
 	gf_free(frame);
-	return GF_OK;
+	return e;
 #endif
 }
 
@@ -2062,6 +2069,7 @@
 	u32 AlphaPlaneSize = 0;
 #endif
 	u32 size = read->size;
+	GF_Err e=GF_OK;
 
 	ID = swf_get_16(read);
 	size -= 2;
@@ -2086,15 +2094,18 @@
 
 	if (version==1 && read->jpeg_hdr_size) {
 		/*remove JPEG EOI*/
-		gf_fwrite(read->jpeg_hdr, read->jpeg_hdr_size-2, file);
+		if (gf_fwrite(read->jpeg_hdr, read->jpeg_hdr_size-2, file)!=read->jpeg_hdr_size-2)
+			return GF_IO_ERR;
 		/*remove JPEG SOI*/
 		swf_get_16(read);
 		size-=2;
 	}
 	buf = gf_malloc(sizeof(u8)*size);
+	if (!buf) return GF_OUT_OF_MEM;
 	swf_read_data(read, (char *) buf, size);
 	if (version==1) {
-		gf_fwrite(buf, size, file);
+		if (gf_fwrite(buf, size, file)!=size)
+			e = GF_IO_ERR;
 	} else {
 		u32 i;
 		for (i=0; i<size; i++) {
@@ -2110,16 +2121,21 @@
 		if ((buf0==0xFF) && (buf1==0xD8) && (buf2==0xFF) && (buf3==0xD8)) {
 			skip = 2;
 		}
-		if (version==2)
-			gf_fwrite(buf+skip, size-skip, file);
+		if (version==2) {
+			if (gf_fwrite(buf+skip, size-skip, file) != size-skip) e = GF_IO_ERR;
+		}
 	}
 	if (version!=3)
 		gf_fclose(file);
 
+	if (e) {
+		gf_free(buf);
+		return e;
+	}
+
 	if (version==3) {
 #ifndef GPAC_DISABLE_AV_PARSERS
 		char *dst, *raw;
-		GF_Err e;
 		u32 codecid;
 		u32 osize, w, h, j, pf;
 		GF_BitStream *bs;
@@ -2131,10 +2147,14 @@
 
 		osize = w*h*4;
 		raw = gf_malloc(sizeof(char)*osize);
+		if (!raw) {
+			gf_free(buf);
+			return GF_OUT_OF_MEM;
+		}
 		memset(raw, 0, sizeof(char)*osize);
 		e = gf_img_jpeg_dec(buf+skip, size-skip, &w, &h, &pf, raw, &osize, 4);
 		if (e != GF_OK) {
-			swf_report(read, e, "Cannopt decode JPEG image");
+			swf_report(read, e, "Cannot decode JPEG image");
 		}
 
 		/*read alpha map and decompress it*/
@@ -2162,13 +2182,14 @@
 		gf_img_png_enc(raw, w, h, h*4, GF_PIXEL_RGBA, (char *)buf, &osize);
 
 		file = gf_fopen(szName, "wb");
-		gf_fwrite(buf, osize, file);
+		if (gf_fwrite(buf, osize, file)!=osize) e = GF_IO_ERR;
 		gf_fclose(file);
 
 		gf_free(raw);
 #endif //GPAC_DISABLE_AV_PARSERS
 	}
 	gf_free(buf);
+	if (e) return e;
 
 	return read->setup_image(read, ID, szName);
 }
@@ -2547,7 +2568,7 @@
 	read->inputName = gf_strdup(inputName);
 	read->input = input;
 	read->bs = gf_bs_from_file(input, GF_BITSTREAM_READ);
-	gf_bs_set_eos_callback(read->bs, swf_io_error, &read);
+	gf_bs_set_eos_callback(read->bs, swf_io_error, read);
 	read->display_list = gf_list_new();
 	read->fonts = gf_list_new();
 	read->apps = gf_list_new();
@@ -2591,7 +2612,7 @@
 	sig2 = gf_bs_read_u8(read->bs);
 	/*"FWS" or "CWS"*/
 	if ( ((sig0 != 'F') && (sig0 != 'C')) || (sig1 != 'W') || (sig2 != 'S') ) {
-		return GF_URL_ERROR;
+		return GF_NON_COMPLIANT_BITSTREAM;
 	}
 	/*version = */gf_bs_read_u8(read->bs);
 	read->length = swf_get_32(read);
@@ -2642,7 +2663,8 @@
 	read->flat_limit = FLT2FIX(load->swf_flatten_limit);
 	load->loader_priv = read;
 
-	gf_swf_read_header(read);
+	e = gf_swf_read_header(read);
+	if (e) goto exit;
 	load->ctx->scene_width = FIX2INT(read->width);
 	load->ctx->scene_height = FIX2INT(read->height);
 	load->ctx->is_pixel_metrics = 1;

gpac-2.0.0.tar.gz/src/scene_manager/swf_svg.c -> gpac-2.2.0.tar.gz/src/scene_manager/swf_svg.c Changed

gpac-2.0.0.tar.gz/src/scenegraph/base_scenegraph.c -> gpac-2.2.0.tar.gz/src/scenegraph/base_scenegraph.c Changed

gpac-2.0.0.tar.gz/src/scenegraph/commands.c -> gpac-2.2.0.tar.gz/src/scenegraph/commands.c Changed

gpac-2.0.0.tar.gz/src/scenegraph/dom_events.c -> gpac-2.2.0.tar.gz/src/scenegraph/dom_events.c Changed

@@ -361,10 +361,15 @@
 	}
 }
 
+void gf_sg_set_destroy_cookie(GF_SceneGraph *sg, Bool *cookie);
+
 GF_EXPORT
 Bool gf_sg_fire_dom_event(GF_DOMEventTarget *et, GF_DOM_Event *event, GF_SceneGraph *sg, GF_Node *n)
 {
 	if (et) {
+		//take care of event process destroying the parent scene graph
+		Bool sg_destroyed = GF_FALSE;
+		gf_sg_set_destroy_cookie(sg, &sg_destroyed);
 		if (et->ptr_type==GF_DOM_EVENT_TARGET_NODE ||
 		 et->ptr_type == GF_DOM_EVENT_TARGET_DOCUMENT ||
 		 et->ptr_type == GF_DOM_EVENT_TARGET_XHR ||
@@ -398,7 +403,7 @@
 				default:
 					continue;
 				}
-				if (listened_event->type <= GF_EVENT_MOUSEMOVE) event->has_ui_events=1;
+				if (listened_event->type <= GF_EVENT_LAST_MOUSE_COORDS) event->has_ui_events=1;
 				if (listened_event->type != event->type) continue;
 				if (listened_event->parameter && (listened_event->parameter != event->detail)) continue;
 				event->currentTarget = et;
@@ -429,7 +434,10 @@
 				}
 				/*canceled*/
 				if (event->event_phase & GF_DOM_EVENT_PHASE_CANCEL_ALL) {
-					gf_dom_listener_process_add(sg);
+					if (!sg_destroyed) {
+						gf_sg_set_destroy_cookie(sg, NULL);
+						gf_dom_listener_process_add(sg);
+					}
 					return GF_FALSE;
 				}
 
@@ -445,11 +453,17 @@
 			}
 			/*propagation stopped*/
 			if (event->event_phase & (GF_DOM_EVENT_PHASE_CANCEL|GF_DOM_EVENT_PHASE_CANCEL_ALL) ) {
-				gf_dom_listener_process_add(sg);
+				if (!sg_destroyed) {
+					gf_sg_set_destroy_cookie(sg, NULL);
+					gf_dom_listener_process_add(sg);
+				}
 				return GF_FALSE;
 			}
 		}
-		gf_dom_listener_process_add(sg);
+		if (!sg_destroyed) {
+			gf_sg_set_destroy_cookie(sg, NULL);
+			gf_dom_listener_process_add(sg);
+		}
 		/*if the current target is a node, we can bubble*/
 		return n ? GF_TRUE : GF_FALSE;
 	} else {

gpac-2.0.0.tar.gz/src/scenegraph/dom_js.c -> gpac-2.2.0.tar.gz/src/scenegraph/dom_js.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2007-2019
+ *			Copyright (c) Telecom ParisTech 2007-2022
  *			All rights reserved
  *
  *  This file is part of GPAC / Scene Graph sub-project
@@ -1708,10 +1708,25 @@
 	if (n->sgprivate->tag==TAG_DOMFullNode) {
 		GF_DOMFullNode *node = (GF_DOMFullNode*)n;
 		GF_DOMFullAttribute *att = (GF_DOMFullAttribute*)node->attributes;
+		u32 ns_code = ns ? gf_sg_get_namespace_code_from_name(n->sgprivate->scenegraph, (char *) ns) : 0;
 		while (att) {
-			if ((att->tag==TAG_DOM_ATT_any) && !strcmp(att->name, name)) {
-				ret = JS_NewString(c, *(char**)att->data );
-				goto exit;
+			if (att->tag==TAG_DOM_ATT_any) {
+				Bool found = GF_FALSE;
+				if (!strcmp(att->name, name) && (ns_code == att->xmlns))
+					found = GF_TRUE;
+				else if (ns) {
+					char *nssep = strchr(att->name, ':');
+					if (nssep && !strcmp(nssep+1, name)) {
+						u32 ns_len = (u32) (nssep - att->name);
+						//todo check namespace
+						if (!strcmp(ns, "*") || !strncmp(ns, att->name, ns_len))
+							found = GF_TRUE;
+					}
+				}
+				if (found) {
+					ret = JS_NewString(c, *(char**)att->data );
+					goto exit;
+				}
 			}
 			att = (GF_DOMFullAttribute *) att->next;
 		}
@@ -2008,6 +2023,7 @@
 					attname->type = attType.fieldType;
 				} else {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("DOM Cannot find target of the animation to parse attribute %s\n", attname->name));
+					return;
 				}
 			}

gpac-2.0.0.tar.gz/src/scenegraph/qjs_common.h -> gpac-2.2.0.tar.gz/src/scenegraph/qjs_common.h Changed

gpac-2.0.0.tar.gz/src/scenegraph/smil_anim.c -> gpac-2.2.0.tar.gz/src/scenegraph/smil_anim.c Changed

gpac-2.0.0.tar.gz/src/scenegraph/svg_attributes.c -> gpac-2.2.0.tar.gz/src/scenegraph/svg_attributes.c Changed

@@ -153,6 +153,7 @@
 	{ GF_EVENT_MEDIA_RATECHANGE, "ratechange", GF_DOM_EVENT_MEDIA },
 	{ GF_EVENT_MEDIA_VOLUME_CHANGED, "volumechange", GF_DOM_EVENT_MEDIA },
 
+#if 0
 	/* Media Source Events */
 	{ GF_EVENT_HTML_MSE_SOURCE_OPEN, "sourceopen", GF_DOM_EVENT_MEDIASOURCE },
 	{ GF_EVENT_HTML_MSE_SOURCE_ENDED, "sourceended", GF_DOM_EVENT_MEDIASOURCE },
@@ -164,6 +165,7 @@
 	{ GF_EVENT_HTML_MSE_UPDATE_ABORT, "abort", GF_DOM_EVENT_MEDIASOURCE },
 	{ GF_EVENT_HTML_MSE_ADD_SOURCE_BUFFER, "addsourcebuffer", GF_DOM_EVENT_MEDIASOURCE },
 	{ GF_EVENT_HTML_MSE_REMOVE_SOURCE_BUFFER, "removesourcebuffer", GF_DOM_EVENT_MEDIASOURCE },
+#endif
 
 	/*GPAC internals*/
 	{ GF_EVENT_SCENE_ATTACHED, "gpac_scene_attached", GF_DOM_EVENT_GPAC},
@@ -173,17 +175,18 @@
 	{ GF_EVENT_MAIN_ADDON_STATE, "gpac_main_addon_state", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_STREAMLIST, "gpac_streamlist_changed", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_TIMESHIFT_DEPTH, "gpac_timeshift_depth_changed", GF_DOM_EVENT_GPAC},
+	{ GF_EVENT_CODEC_SLOW, "gpac_codec_slow", GF_DOM_EVENT_GPAC},
+	{ GF_EVENT_CODEC_OK, "gpac_codec_ok", GF_DOM_EVENT_GPAC},
 
 
 #if 0
 	{ GF_EVENT_DBLCLICK, "gpac_dbl_click", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_SIZE, "gpac_size_changed", GF_DOM_EVENT_GPAC},
-	{ GF_EVENT_SCENE_SIZE, "gpac_scene_size", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_SHOWHIDE, "gpac_show_hide", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_SET_CURSOR, "gpac_set_cursor", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_SET_CAPTION, "gpac_set_caption", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_MOVE, "gpac_move", GF_DOM_EVENT_GPAC},
-	{ GF_EVENT_REFRESH, "gpac_move", GF_DOM_EVENT_GPAC},
+	{ GF_EVENT_REFRESH, "gpac_refresh", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_QUIT, "gpac_quit", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_PASTE_TEXT, "gpac_paste", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_COPY_TEXT, "gpac_copy", GF_DOM_EVENT_GPAC},
@@ -196,7 +199,6 @@
 	{ GF_EVENT_MESSAGE, "gpac_on_message", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_PROGRESS, "gpac_on_progress", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_VIEWPOINTS, "gpac_viewpoints_changed", GF_DOM_EVENT_GPAC},
-	{ GF_EVENT_STREAMLIST, "gpac_streamlist_changed", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_METADATA, "gpac_metadata_changed", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_MIGRATE, "gpac_session_migrate", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_DISCONNECT, "gpac_request_disconnect", GF_DOM_EVENT_GPAC},
@@ -207,6 +209,7 @@
 	{ GF_EVENT_QUALITY_SWITCHED, "gpac_quality_switch", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_TIMESHIFT_OVERFLOW, "gpac_timeshift_overflow", GF_DOM_EVENT_GPAC},
 	{ GF_EVENT_TIMESHIFT_UPDATE, "gpac_timeshift_update", GF_DOM_EVENT_GPAC}
+	{ GF_EVENT_TIMESHIFT_UNDERRUN, "gpac_timeshift_underrun", GF_DOM_EVENT_GPAC}
 #endif
 
 };
@@ -710,7 +713,7 @@
 	transform the char into char and duplicate the input, instead of modifying it
 		be more robust to errors in color description ex rgb(0 0 0)
 */
-static void svg_parse_color(SVG_Color *col, char *attribute_content)
+static void svg_parse_color(SVG_Color *col, char *attribute_content, GF_Err *out_e)
 {
 	char *str = attribute_content;
 	while (strstrlen(attribute_content)-1 == ' ') strstrlen(attribute_content)-1 = 0;
@@ -776,11 +779,14 @@
 		svg_parse_named_color(col, str);
 	} else {
 		Float _r, _g, _b;
-		sscanf(str, "%f %f %f", &_r, &_g, &_b);
-		col->red = FLT2FIX(_r);
-		col->green = FLT2FIX(_g);
-		col->blue = FLT2FIX(_b);
-		col->type = SVG_COLOR_RGBCOLOR;
+		if (sscanf(str, "%f %f %f", &_r, &_g, &_b)==3) {
+			col->red = FLT2FIX(_r);
+			col->green = FLT2FIX(_g);
+			col->blue = FLT2FIX(_b);
+			col->type = SVG_COLOR_RGBCOLOR;
+		} else {
+			*out_e = GF_NON_COMPLIANT_BITSTREAM;
+		}
 	}
 }
 
@@ -793,7 +799,7 @@
 		optionally followed by e or E and digits between 0 and 9
 	Returns the number of chars read in d
 */
-static u32 svg_parse_number(char *d, Fixed *f, Bool is_angle)
+static u32 svg_parse_number(char *d, Fixed *f, Bool is_angle, GF_Err *out_e)
 {
 	u32 nb_digit_before = 0;
 	u32 nb_digit_after = 0;
@@ -807,6 +813,7 @@
 
 	if (!di) {
 		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("SVG Parsing Parsing number with empty string or only spaces: %s\n", d));
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 		return 0;
 	}
 	if (di == '+') {
@@ -839,6 +846,7 @@
 			_val /= (Float)pow(10,nb_digit_after);
 		} else if (nb_digit_before == 0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error in parsing number (expecting digits before or after a '.': %s\n", d));
+			*out_e = GF_NON_COMPLIANT_BITSTREAM;
 			return 0;
 		} else {
 			/* dangling '.' without digits after. This is allowed by the BNF */
@@ -846,6 +854,7 @@
 	}
 	if ((nb_digit_before == 0) && (has_fractional == 0)) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error in parsing number (expecting digits):%s\n", d));
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 		return 0;
 	}
 	/* reading the exponent */
@@ -868,6 +877,7 @@
 			_val *= (Float)pow(10, neg_exp ? -exp : exp);
 		} else {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error in parsing exponent, 'e' or 'E' should be followed by digits: %s\n", d));
+			*out_e = GF_NON_COMPLIANT_BITSTREAM;
 			return 0;
 		}
 	}
@@ -1098,7 +1108,7 @@
 Bool gf_svg_parse_transformlist(GF_Matrix2D *mat, char *attribute_content)
 {
 	GF_Matrix2D tmp;
-
+	GF_Err e;
 	char *str;
 	u32 read_chars;
 	u32 i;
@@ -1117,7 +1127,7 @@
 			if (stri == '(') {
 				Fixed sx, sy;
 				i++;
-				read_chars = svg_parse_number(&(stri), &sx, 0);
+				read_chars = svg_parse_number(&(stri), &sx, 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading sx component in scale: %s\n", attribute_content));
 					return 0;
@@ -1127,7 +1137,7 @@
 				if (stri == ')') {
 					sy = sx;
 				} else {
-					read_chars = svg_parse_number(&(stri), &sy, 0);
+					read_chars = svg_parse_number(&(stri), &sy, 0, &e);
 					if (!read_chars) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading sy component in scale: %s\n", attribute_content));
 						return 0;
@@ -1155,7 +1165,7 @@
 			if (stri == '(') {
 				Fixed tx, ty;
 				i++;
-				read_chars = svg_parse_number(&(stri), &tx, 0);
+				read_chars = svg_parse_number(&(stri), &tx, 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading tx component in translate: %s\n", attribute_content));
 					return 0;
@@ -1164,7 +1174,7 @@
 				if (stri == ')') {
 					ty = 0;
 				} else {
-					read_chars = svg_parse_number(&(stri), &ty, 0);
+					read_chars = svg_parse_number(&(stri), &ty, 0, &e);
 					if (!read_chars) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading ty component in translate: %s\n", attribute_content));
 						return 0;
@@ -1191,7 +1201,7 @@
 			if (stri == '(') {
 				Fixed angle, cx, cy;
 				i++;
-				read_chars = svg_parse_number(&(stri), &angle, 1);
+				read_chars = svg_parse_number(&(stri), &angle, 1, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading angle component in rotate: %s\n", attribute_content));
 					return 0;
@@ -1200,13 +1210,13 @@
 				if (stri == ')') {
 					cx = cy = 0;
 				} else {
-					read_chars = svg_parse_number(&(stri), &cx, 0);
+					read_chars = svg_parse_number(&(stri), &cx, 0, &e);
 					if (!read_chars) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading cx component in rotate: %s\n", attribute_content));
 						return 0;
 					}
 					i += read_chars;
-					read_chars = svg_parse_number(&(stri), &cy, 0);
+					read_chars = svg_parse_number(&(stri), &cy, 0, &e);
 					if (!read_chars) {
 						GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading cy component in rotate: %s\n", attribute_content));
 						return 0;
@@ -1233,7 +1243,7 @@
 			if (stri == '(') {
 				Fixed angle;
 				i++;
-				read_chars = svg_parse_number(&(stri), &angle, 1);
+				read_chars = svg_parse_number(&(stri), &angle, 1, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading angle in skewX: %s\n", attribute_content));
 					return 0;
@@ -1259,7 +1269,7 @@
 			if (stri == '(') {
 				Fixed angle;
 				i++;
-				read_chars = svg_parse_number(&(stri), &angle, 1);
+				read_chars = svg_parse_number(&(stri), &angle, 1, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading angle component in skewY: %s\n", attribute_content));
 					return 0;
@@ -1284,37 +1294,37 @@
 			while(stri == ' ') i++;
 			if (stri == '(') {
 				i++;
-				read_chars = svg_parse_number(&(stri), &(tmp.m0), 0);
+				read_chars = svg_parse_number(&(stri), &(tmp.m0), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient a in matrix: %s\n", attribute_content));
 					return 0;
 				}
 				i += read_chars;
-				read_chars = svg_parse_number(&(stri), &(tmp.m3), 0);
+				read_chars = svg_parse_number(&(stri), &(tmp.m3), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient b in matrix: %s\n", attribute_content));
 					return 0;
 				}
 				i += read_chars;
-				read_chars = svg_parse_number(&(stri), &(tmp.m1), 0);
+				read_chars = svg_parse_number(&(stri), &(tmp.m1), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient c in matrix: %s\n", attribute_content));
 					return 0;
 				}
 				i += read_chars;
-				read_chars = svg_parse_number(&(stri), &(tmp.m4), 0);
+				read_chars = svg_parse_number(&(stri), &(tmp.m4), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient d in matrix: %s\n", attribute_content));
 					return 0;
 				}
 				i += read_chars;
-				read_chars = svg_parse_number(&(stri), &(tmp.m2), 0);
+				read_chars = svg_parse_number(&(stri), &(tmp.m2), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient e in matrix: %s\n", attribute_content));
 					return 0;
 				}
 				i += read_chars;
-				read_chars = svg_parse_number(&(stri), &(tmp.m5), 0);
+				read_chars = svg_parse_number(&(stri), &(tmp.m5), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient f in matrix: %s\n", attribute_content));
 					return 0;
@@ -1349,6 +1359,7 @@
 	u32 i;
 	u32 read_chars;
 	i = 0;
+	GF_Err e;
 
 	if ((str = strstr(attribute_content, "ref"))) {
 		t->is_ref = 1;
@@ -1367,16 +1378,16 @@
 					//i++;
 					return GF_OK;
 				}
-				read_chars = svg_parse_number(&(stri), &(t->mat.m2), 0);
+				read_chars = svg_parse_number(&(stri), &(t->mat.m2), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient tx in ref transform: %s\n", attribute_content));
-					return GF_BAD_PARAM;
+					return e;
 				}
 				i += read_chars;
-				read_chars = svg_parse_number(&(stri), &(t->mat.m5), 0);
+				read_chars = svg_parse_number(&(stri), &(t->mat.m5), 0, &e);
 				if (!read_chars) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error reading coefficient ty in ref transform: %s\n", attribute_content));
-					return GF_BAD_PARAM;
+					return e;
 				}
 				i += read_chars;
 			} else {
@@ -1409,7 +1420,7 @@
 
 //#define PARSE_PATH_ONLY
 
-static void svg_parse_path(SVG_PathData *path, char *attribute_content)
+static void svg_parse_path(SVG_PathData *path, char *attribute_content, GF_Err *out_e)
 {
 	char *d = attribute_content;
 
@@ -1444,10 +1455,10 @@
 		case 'm':
 		case 'M':
 			i++;
-			read_chars = svg_parse_number(&(di), &(orig.x), 0);
+			read_chars = svg_parse_number(&(di), &(orig.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(orig.y), 0);
+			read_chars = svg_parse_number(&(di), &(orig.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'm') {
@@ -1469,10 +1480,10 @@
 		case 'L':
 		case 'l':
 			i++;
-			read_chars = svg_parse_number(&(di), &(orig.x), 0);
+			read_chars = svg_parse_number(&(di), &(orig.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(orig.y), 0);
+			read_chars = svg_parse_number(&(di), &(orig.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'l') {
@@ -1491,7 +1502,7 @@
 		case 'H':
 		case 'h':
 			i++;
-			read_chars = svg_parse_number(&(di), &(orig.x), 0);
+			read_chars = svg_parse_number(&(di), &(orig.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'h') {
@@ -1510,7 +1521,7 @@
 		case 'V':
 		case 'v':
 			i++;
-			read_chars = svg_parse_number(&(di), &(orig.y), 0);
+			read_chars = svg_parse_number(&(di), &(orig.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'v') {
@@ -1529,30 +1540,30 @@
 		case 'C':
 		case 'c':
 			i++;
-			read_chars = svg_parse_number(&(di), &(ct_orig.x), 0);
+			read_chars = svg_parse_number(&(di), &(ct_orig.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(ct_orig.y), 0);
+			read_chars = svg_parse_number(&(di), &(ct_orig.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'c') {
 				ct_orig.x += rel_ref_pt.x;
 				ct_orig.y += rel_ref_pt.y;
 			}
-			read_chars = svg_parse_number(&(di), &(ct_end.x), 0);
+			read_chars = svg_parse_number(&(di), &(ct_end.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(ct_end.y), 0);
+			read_chars = svg_parse_number(&(di), &(ct_end.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'c') {
 				ct_end.x += rel_ref_pt.x;
 				ct_end.y += rel_ref_pt.y;
 			}
-			read_chars = svg_parse_number(&(di), &(end.x), 0);
+			read_chars = svg_parse_number(&(di), &(end.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(end.y), 0);
+			read_chars = svg_parse_number(&(di), &(end.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'c') {
@@ -1572,20 +1583,20 @@
 			i++;
 			ct_orig.x = 2*orig.x - ct_orig.x;
 			ct_orig.y = 2*orig.y - ct_orig.y;
-			read_chars = svg_parse_number(&(di), &(ct_end.x), 0);
+			read_chars = svg_parse_number(&(di), &(ct_end.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(ct_end.y), 0);
+			read_chars = svg_parse_number(&(di), &(ct_end.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 's') {
 				ct_end.x += rel_ref_pt.x;
 				ct_end.y += rel_ref_pt.y;
 			}
-			read_chars = svg_parse_number(&(di), &(end.x), 0);
+			read_chars = svg_parse_number(&(di), &(end.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(end.y), 0);
+			read_chars = svg_parse_number(&(di), &(end.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 's') {
@@ -1614,20 +1625,20 @@
 		case 'Q':
 		case 'q':
 			i++;
-			read_chars = svg_parse_number(&(di), &(ct_orig.x), 0);
+			read_chars = svg_parse_number(&(di), &(ct_orig.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(ct_orig.y), 0);
+			read_chars = svg_parse_number(&(di), &(ct_orig.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'q') {
 				ct_orig.x += rel_ref_pt.x;
 				ct_orig.y += rel_ref_pt.y;
 			}
-			read_chars = svg_parse_number(&(di), &(end.x), 0);
+			read_chars = svg_parse_number(&(di), &(end.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(end.y), 0);
+			read_chars = svg_parse_number(&(di), &(end.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'q') {
@@ -1646,10 +1657,10 @@
 			i++;
 			ct_orig.x = 2*orig.x - ct_orig.x;
 			ct_orig.y = 2*orig.y - ct_orig.y;
-			read_chars = svg_parse_number(&(di), &(end.x), 0);
+			read_chars = svg_parse_number(&(di), &(end.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(end.y), 0);
+			read_chars = svg_parse_number(&(di), &(end.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 't') {
@@ -1667,27 +1678,27 @@
 		case 'a':
 			i++;
 
-			read_chars = svg_parse_number(&(di), &(orig.x), 0);
+			read_chars = svg_parse_number(&(di), &(orig.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(orig.y), 0);
+			read_chars = svg_parse_number(&(di), &(orig.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 
-			read_chars = svg_parse_number(&(di), &(x_axis_rotation), 0);
+			read_chars = svg_parse_number(&(di), &(x_axis_rotation), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(large_arc_flag), 0);
+			read_chars = svg_parse_number(&(di), &(large_arc_flag), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(sweep_flag), 0);
+			read_chars = svg_parse_number(&(di), &(sweep_flag), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 
-			read_chars = svg_parse_number(&(di), &(end.x), 0);
+			read_chars = svg_parse_number(&(di), &(end.x), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
-			read_chars = svg_parse_number(&(di), &(end.y), 0);
+			read_chars = svg_parse_number(&(di), &(end.y), 0, out_e);
 			if (!read_chars) return;
 			i += read_chars;
 			if (c == 'a') {
@@ -1728,7 +1739,7 @@
 }
 #else
 /* TODO: Change the function to handle elliptical arcs, requires changing data structure */
-static void svg_parse_path(SVG_PathData *d_attribute, char *attribute_content)
+static void svg_parse_path(SVG_PathData *d_attribute, char *attribute_content, GF_Err *out_e)
 {
 	GF_List *d_commands = d_attribute->commands;
 	GF_List *d_points = d_attribute->points;
@@ -1765,8 +1776,8 @@
 				if (!pt) return;
 				gf_list_add(d_points, pt);
 #endif
-				i += svg_parse_number(&(di), &(pt->x), 0);
-				i += svg_parse_number(&(di), &(pt->y), 0);
+				i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+				i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 				if (c == 'm') {
 					pt->x += cur_pt.x;
 					pt->y += cur_pt.y;
@@ -1789,8 +1800,8 @@
 				if (!pt) return;
 				gf_list_add(d_points, pt);
 #endif
-				i += svg_parse_number(&(di), &(pt->x), 0);
-				i += svg_parse_number(&(di), &(pt->y), 0);
+				i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+				i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 				if (c == 'l') {
 					pt->x += cur_pt.x;
 					pt->y += cur_pt.y;
@@ -1812,7 +1823,7 @@
 				if (!pt) return;
 				gf_list_add(d_points, pt);
 #endif
-				i += svg_parse_number(&(di), &(pt->x), 0);
+				i += svg_parse_number(&(di), &(pt->x), 0, out_e);
 				if (c == 'h') {
 					pt->x += cur_pt.x;
 				}
@@ -1833,7 +1844,7 @@
 				if (!pt) return;
 				gf_list_add(d_points, pt);
 #endif
-				i += svg_parse_number(&(di), &(pt->y), 0);
+				i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 				if (c == 'v') {
 					pt->y += cur_pt.y;
 				}
@@ -1857,8 +1868,8 @@
 					if (!pt) return;
 					gf_list_add(d_points, pt);
 #endif
-					i += svg_parse_number(&(di), &(pt->x), 0);
-					i += svg_parse_number(&(di), &(pt->y), 0);
+					i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+					i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 					if (c == 'c') {
 						pt->x += cur_pt.x;
 						pt->y += cur_pt.y;
@@ -1884,8 +1895,8 @@
 					if (!pt) return;
 					gf_list_add(d_points, pt);
 #endif
-					i += svg_parse_number(&(di), &(pt->x), 0);
-					i += svg_parse_number(&(di), &(pt->y), 0);
+					i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+					i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 					if (c == 's') {
 						pt->x += cur_pt.x;
 						pt->y += cur_pt.y;
@@ -1911,8 +1922,8 @@
 					if (!pt) return;
 					gf_list_add(d_points, pt);
 #endif
-					i += svg_parse_number(&(di), &(pt->x), 0);
-					i += svg_parse_number(&(di), &(pt->y), 0);
+					i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+					i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 					if (c == 'q') {
 						pt->x += cur_pt.x;
 						pt->y += cur_pt.y;
@@ -1935,8 +1946,8 @@
 				if (!pt) return;
 				gf_list_add(d_points, pt);
 #endif
-				i += svg_parse_number(&(di), &(pt->x), 0);
-				i += svg_parse_number(&(di), &(pt->y), 0);
+				i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+				i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 				if (c == 't') {
 					pt->x += cur_pt.x;
 					pt->y += cur_pt.y;
@@ -1960,20 +1971,20 @@
 				if (!pt) return;
 				gf_list_add(d_points, pt);
 #endif
-				i += svg_parse_number(&(di), &(pt->x), 0);
-				i += svg_parse_number(&(di), &(pt->y), 0);
+				i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+				i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 
-				i += svg_parse_number(&(di), &(tmp), 0);
-				i += svg_parse_number(&(di), &(tmp), 0);
-				i += svg_parse_number(&(di), &(tmp), 0);
+				i += svg_parse_number(&(di), &(tmp), 0, out_e);
+				i += svg_parse_number(&(di), &(tmp), 0, out_e);
+				i += svg_parse_number(&(di), &(tmp), 0, out_e);
 
 #ifndef REMOVE_ALLOC
 				pt = gf_malloc(sizeof(SVG_Point));
 				if (!pt) return;
 				gf_list_add(d_points, pt);
 #endif
-				i += svg_parse_number(&(di), &(pt->x), 0);
-				i += svg_parse_number(&(di), &(pt->y), 0);
+				i += svg_parse_number(&(di), &(pt->x), 0, out_e);
+				i += svg_parse_number(&(di), &(pt->y), 0, out_e);
 				if (c == 'a') {
 					pt->x += cur_pt.x;
 					pt->y += cur_pt.y;
@@ -2048,7 +2059,7 @@
 }
 
 /* Parses a paint attribute: none, inherit or color */
-static void svg_parse_paint(GF_Node *n, SVG_Paint *paint, char *attribute_content)
+static void svg_parse_paint(GF_Node *n, SVG_Paint *paint, char *attribute_content, GF_Err *out_e)
 {
 	if (!strcmp(attribute_content, "none")) {
 		paint->type = SVG_PAINT_NONE;
@@ -2062,12 +2073,12 @@
 		if (ext) ext0 = ')';
 	} else {
 		paint->type = SVG_PAINT_COLOR;
-		svg_parse_color(&paint->color, attribute_content);
+		svg_parse_color(&paint->color, attribute_content, out_e);
 	}
 }
 
 /* Parses a length which is a number with a unit */
-static u32 svg_parse_length(SVG_Number *number, char *value_string, Bool clamp0to1)
+static u32 svg_parse_length(SVG_Number *number, char *value_string, Bool clamp0to1, GF_Err *out_e)
 {
 	char c = '\0';
 	char *unit = NULL;
@@ -2115,13 +2126,14 @@
 		c = value_stringunit_pos;
 		value_stringunit_pos = 0;
 	}
-	read_chars = svg_parse_number(value_string, &(number->value), 0);
+	read_chars = svg_parse_number(value_string, &(number->value), 0, out_e);
 	if (unit) {
 		value_stringunit_pos = c;
 	}
 	if (!read_chars) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Error in parsing: %s\n", value_string));
 		len = 0;
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	} else {
 		len = unit_len + read_chars;
 	}
@@ -2130,7 +2142,7 @@
 	return len;
 }
 
-static void svg_parse_visibility(SVG_Visibility *value, char *value_string)
+static void svg_parse_visibility(SVG_Visibility *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_VISIBILITY_INHERIT;
@@ -2140,10 +2152,12 @@
 		*value = SVG_VISIBILITY_HIDDEN;
 	} else if (!strcmp(value_string, "collapse")) {
 		*value = SVG_VISIBILITY_COLLAPSE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_display(SVG_Display *value, char *value_string)
+static void svg_parse_display(SVG_Display *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_DISPLAY_INHERIT;
@@ -2181,10 +2195,12 @@
 		*value = SVG_DISPLAY_TABLE_CELL;
 	} else if (!strcmp(value_string, "table-caption")) {
 		*value = SVG_DISPLAY_TABLE_CAPTION;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_displayalign(SVG_DisplayAlign *value, char *value_string)
+static void svg_parse_displayalign(SVG_DisplayAlign *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_DISPLAYALIGN_INHERIT;
@@ -2196,10 +2212,12 @@
 		*value = SVG_DISPLAYALIGN_CENTER;
 	} else if (!strcmp(value_string, "after")) {
 		*value = SVG_DISPLAYALIGN_AFTER;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_textalign(SVG_TextAlign *value, char *value_string)
+static void svg_parse_textalign(SVG_TextAlign *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_TEXTALIGN_INHERIT;
@@ -2209,10 +2227,12 @@
 		*value = SVG_TEXTALIGN_CENTER;
 	} else if (!strcmp(value_string, "end")) {
 		*value = SVG_TEXTALIGN_END;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_pointerevents(SVG_PointerEvents *value, char *value_string)
+static void svg_parse_pointerevents(SVG_PointerEvents *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_POINTEREVENTS_INHERIT;
@@ -2236,10 +2256,12 @@
 		*value = SVG_POINTEREVENTS_BOUNDINGBOX;
 	} else if (!strcmp(value_string, "none")) {
 		*value = SVG_POINTEREVENTS_NONE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_renderinghint(SVG_RenderingHint *value, char *value_string)
+static void svg_parse_renderinghint(SVG_RenderingHint *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_RENDERINGHINT_INHERIT;
@@ -2255,10 +2277,12 @@
 		*value = SVG_RENDERINGHINT_CRISPEDGES;
 	} else if (!strcmp(value_string, "geometricPrecision")) {
 		*value = SVG_RENDERINGHINT_GEOMETRICPRECISION;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_vectoreffect(SVG_VectorEffect *value, char *value_string)
+static void svg_parse_vectoreffect(SVG_VectorEffect *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_VECTOREFFECT_INHERIT;
@@ -2266,64 +2290,78 @@
 		*value = SVG_VECTOREFFECT_NONE;
 	} else if (!strcmp(value_string, "non-scaling-stroke")) {
 		*value = SVG_VECTOREFFECT_NONSCALINGSTROKE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_playbackorder(SVG_VectorEffect *value, char *value_string)
+static void svg_parse_playbackorder(SVG_VectorEffect *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "forwardOnly")) {
 		*value = SVG_PLAYBACKORDER_FORWARDONLY;
 	} else if (!strcmp(value_string, "all")) {
 		*value = SVG_PLAYBACKORDER_ALL;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_timelinebegin(SVG_TimelineBegin *value, char *value_string)
+static void svg_parse_timelinebegin(SVG_TimelineBegin *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "onStart")) {
 		*value = SVG_TIMELINEBEGIN_ONSTART;
 	} else if (!strcmp(value_string, "onLoad")) {
 		*value = SVG_TIMELINEBEGIN_ONLOAD;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_xmlspace(XML_Space *value, char *value_string)
+static void svg_parse_xmlspace(XML_Space *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "default")) {
 		*value = XML_SPACE_DEFAULT;
 	} else if (!strcmp(value_string, "preserve")) {
 		*value = XML_SPACE_PRESERVE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_xmlev_propagate(XMLEV_Propagate *value, char *value_string)
+static void svg_parse_xmlev_propagate(XMLEV_Propagate *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "continue")) {
 		*value = XMLEVENT_PROPAGATE_CONTINUE;
 	} else if (!strcmp(value_string, "stop")) {
 		*value = XMLEVENT_PROPAGATE_STOP;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_xmlev_defaultAction(XMLEV_DefaultAction *value, char *value_string)
+static void svg_parse_xmlev_defaultAction(XMLEV_DefaultAction *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "cancel")) {
 		*value = XMLEVENT_DEFAULTACTION_CANCEL;
 	} else if (!strcmp(value_string, "perform")) {
 		*value = XMLEVENT_DEFAULTACTION_PERFORM;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_xmlev_phase(XMLEV_Phase *value, char *value_string)
+static void svg_parse_xmlev_phase(XMLEV_Phase *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "default")) {
 		*value = XMLEVENT_PHASE_DEFAULT;
 	} else if (!strcmp(value_string, "capture")) {
 		*value = XMLEVENT_PHASE_CAPTURE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_overflow(SVG_Overflow *value, char *value_string)
+static void svg_parse_overflow(SVG_Overflow *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_OVERFLOW_INHERIT;
@@ -2335,10 +2373,12 @@
 		*value = SVG_OVERFLOW_SCROLL;
 	} else if (!strcmp(value_string, "auto")) {
 		*value = SVG_OVERFLOW_AUTO;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_textanchor(SVG_TextAnchor *value, char *value_string)
+static void svg_parse_textanchor(SVG_TextAnchor *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_TEXTANCHOR_INHERIT;
@@ -2348,10 +2388,12 @@
 		*value = SVG_TEXTANCHOR_MIDDLE;
 	} else if (!strcmp(value_string, "end")) {
 		*value = SVG_TEXTANCHOR_END;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_clipfillrule(SVG_FillRule *value, char *value_string)
+static void svg_parse_clipfillrule(SVG_FillRule *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_FILLRULE_INHERIT;
@@ -2359,10 +2401,12 @@
 		*value = SVG_FILLRULE_NONZERO;
 	} else if (!strcmp(value_string, "evenodd")) {
 		*value = SVG_FILLRULE_EVENODD;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_strokelinejoin(SVG_StrokeLineJoin *value, char *value_string)
+static void svg_parse_strokelinejoin(SVG_StrokeLineJoin *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_STROKELINEJOIN_INHERIT;
@@ -2372,10 +2416,12 @@
 		*value = SVG_STROKELINEJOIN_ROUND;
 	} else if (!strcmp(value_string, "bevel")) {
 		*value = SVG_STROKELINEJOIN_BEVEL;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_strokelinecap(SVG_StrokeLineCap *value, char *value_string)
+static void svg_parse_strokelinecap(SVG_StrokeLineCap *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_STROKELINECAP_INHERIT;
@@ -2385,10 +2431,12 @@
 		*value = SVG_STROKELINECAP_ROUND;
 	} else if (!strcmp(value_string, "square")) {
 		*value = SVG_STROKELINECAP_SQUARE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_fontfamily(SVG_FontFamily *value, char *value_string)
+static void svg_parse_fontfamily(SVG_FontFamily *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		value->type = SVG_FONTFAMILY_INHERIT;
@@ -2398,7 +2446,7 @@
 	}
 }
 
-static void svg_parse_fontstyle(SVG_FontStyle *value, char *value_string)
+static void svg_parse_fontstyle(SVG_FontStyle *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_FONTSTYLE_INHERIT;
@@ -2408,10 +2456,14 @@
 		*value = SVG_FONTSTYLE_ITALIC;
 	} else if (!strcmp(value_string, "oblique")) {
 		*value = SVG_FONTSTYLE_OBLIQUE;
+	} else if (!strcmp(value_string, "all")) {
+		*value = SVG_FONTSTYLE_INHERIT;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_fontweight(SVG_FontWeight *value, char *value_string)
+static void svg_parse_fontweight(SVG_FontWeight *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_FONTWEIGHT_INHERIT;
@@ -2441,10 +2493,14 @@
 		*value = SVG_FONTWEIGHT_800;
 	} else if (!strcmp(value_string, "900")) {
 		*value = SVG_FONTWEIGHT_900;
+	} else if (!strcmp(value_string, "all")) {
+		*value = SVG_FONTWEIGHT_INHERIT;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_fontvariant(SVG_FontVariant *value, char *value_string)
+static void svg_parse_fontvariant(SVG_FontVariant *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SVG_FONTVARIANT_INHERIT;
@@ -2452,10 +2508,12 @@
 		*value = SVG_FONTVARIANT_NORMAL;
 	} else if (!strcmp(value_string, "small-caps")) {
 		*value = SVG_FONTVARIANT_SMALLCAPS;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_boolean(SVG_Boolean *value, char *value_string)
+static void svg_parse_boolean(SVG_Boolean *value, char *value_string, GF_Err *out_e)
 {
 	/*simple for text editable*/
 	if (!strcmp(value_string, "1") || !strcmp(value_string, "true") || !strcmp(value_string, "simple"))
@@ -2468,17 +2526,22 @@
 static void smil_parse_time_list(GF_Node *e, GF_List *values, char *begin_or_end_list)
 {
 	SMIL_Time *value;
-	char value_string500;
+	char value_string1025;
 	char *str = begin_or_end_list, *tmp;
 	u32 len;
 
 	/* get rid of leading spaces */
 	while (*str == ' ') str++;
 
+	value_string1024 = 0;
 	while (1) {
 		tmp = strchr(str, ';');
 		if (tmp) len = (u32) (tmp-str);
 		else len = (u32) strlen(str);
+		if (len>1024) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing SMIL time list attribute too long, max supported 1024 bytes\n"));
+			goto err;
+		}
 		memcpy(value_string, str, len);
 		while ((len > 0) && (value_stringlen - 1 == ' '))
 			len--;
@@ -2573,7 +2636,7 @@
 	return;
 }
 
-static void smil_parse_attributeType(SMIL_AttributeType *value, char *value_string)
+static void smil_parse_attributeType(SMIL_AttributeType *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "auto")) {
 		*value = SMIL_ATTRIBUTETYPE_AUTO;
@@ -2581,10 +2644,12 @@
 		*value = SMIL_ATTRIBUTETYPE_XML;
 	} else if (!strcmp(value_string, "CSS")) {
 		*value = SMIL_ATTRIBUTETYPE_CSS;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void smil_parse_min_max_dur_repeatdur(SMIL_Duration *value, char *value_string)
+static void smil_parse_min_max_dur_repeatdur(SMIL_Duration *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "indefinite")) {
 		value->type = SMIL_DURATION_INDEFINITE;
@@ -2602,28 +2667,33 @@
 	}
 }
 
-static void smil_parse_repeatcount(SMIL_RepeatCount *value, char *value_string)
+static void smil_parse_repeatcount(SMIL_RepeatCount *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "indefinite")) {
 		value->type = SMIL_REPEATCOUNT_INDEFINITE;
 	} else {
 		Float _val;
-		sscanf(value_string, "%f", &_val);
-		value->type = SMIL_REPEATCOUNT_DEFINED;
-		value->count = FLT2FIX(_val);
+		if (sscanf(value_string, "%f", &_val)==1) {
+			value->type = SMIL_REPEATCOUNT_DEFINED;
+			value->count = FLT2FIX(_val);
+		} else {
+			*out_e = GF_NON_COMPLIANT_BITSTREAM;
+		}
 	}
 }
 
-static void smil_parse_fill(SMIL_Fill *value, char *value_string)
+static void smil_parse_fill(SMIL_Fill *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "freeze")) {
 		*value = SMIL_FILL_FREEZE;
 	} else if (!strcmp(value_string, "remove")) {
 		*value = SMIL_FILL_REMOVE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void smil_parse_restart(SMIL_Restart *value, char *value_string)
+static void smil_parse_restart(SMIL_Restart *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "always")) {
 		*value = SMIL_RESTART_ALWAYS;
@@ -2631,10 +2701,12 @@
 		*value = SMIL_RESTART_WHENNOTACTIVE;
 	} else if (!strcmp(value_string, "never")) {
 		*value = SMIL_RESTART_NEVER;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void smil_parse_calcmode(SMIL_CalcMode *value, char *value_string)
+static void smil_parse_calcmode(SMIL_CalcMode *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "discrete")) {
 		*value = SMIL_CALCMODE_DISCRETE;
@@ -2644,28 +2716,34 @@
 		*value = SMIL_CALCMODE_PACED;
 	} else if (!strcmp(value_string, "spline")) {
 		*value = SMIL_CALCMODE_SPLINE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void smil_parse_additive(SMIL_Additive *value, char *value_string)
+static void smil_parse_additive(SMIL_Additive *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "replace")) {
 		*value = SMIL_ADDITIVE_REPLACE;
 	} else if (!strcmp(value_string, "sum")) {
 		*value = SMIL_ADDITIVE_SUM;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void smil_parse_accumulate(SMIL_Accumulate *value, char *value_string)
+static void smil_parse_accumulate(SMIL_Accumulate *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "none")) {
 		*value = SMIL_ACCUMULATE_NONE;
 	} else if (!strcmp(value_string, "sum")) {
 		*value = SMIL_ACCUMULATE_SUM;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void smil_parse_syncBehaviorOrDefault(SMIL_SyncBehavior *value, char *value_string)
+static void smil_parse_syncBehaviorOrDefault(SMIL_SyncBehavior *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		*value = SMIL_SYNCBEHAVIOR_INHERIT;
@@ -2677,10 +2755,12 @@
 		*value = SMIL_SYNCBEHAVIOR_CANSLIP;
 	} else if (!strcmp(value_string, "independent")) {
 		*value = SMIL_SYNCBEHAVIOR_INDEPENDENT;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void smil_parse_syncToleranceOrDefault(SMIL_SyncTolerance *value, char *value_string)
+static void smil_parse_syncToleranceOrDefault(SMIL_SyncTolerance *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "inherit")) {
 		value->type = SMIL_SYNCTOLERANCE_INHERIT;
@@ -2692,7 +2772,7 @@
 	}
 }
 
-static void svg_parse_viewbox(SVG_ViewBox *value, char *value_string)
+static void svg_parse_viewbox(SVG_ViewBox *value, char *value_string, GF_Err *out_e)
 {
 	u32 read_chars;
 	char *str = value_string;
@@ -2701,23 +2781,23 @@
 	} else {
 		u32 i = 0;
 		value->is_set = 1;
-		read_chars = svg_parse_number(&(stri), &(value->x), 0);
+		read_chars = svg_parse_number(&(stri), &(value->x), 0, out_e);
 		if (!read_chars) return;
 		i += read_chars;
-		read_chars = svg_parse_number(&(stri), &(value->y), 0);
+		read_chars = svg_parse_number(&(stri), &(value->y), 0, out_e);
 		if (!read_chars) return;
 		i += read_chars;
-		read_chars = svg_parse_number(&(stri), &(value->width), 0);
+		read_chars = svg_parse_number(&(stri), &(value->width), 0, out_e);
 		if (!read_chars) return;
 		i += read_chars;
-		read_chars = svg_parse_number(&(stri), &(value->height), 0);
+		read_chars = svg_parse_number(&(stri), &(value->height), 0, out_e);
 		if (!read_chars) return;
 //		i += read_chars;
 	}
 }
 
 /* Parses a list of coordinates or a list of lengths (in SVG, length and coordinate is the same type )*/
-static void svg_parse_coordinates(GF_List *values, char *value_string)
+static void svg_parse_coordinates(GF_List *values, char *value_string, GF_Err *out_e)
 {
 	SVG_Coordinate *c;
 	u32 i = 0;
@@ -2733,7 +2813,7 @@
 		u32 sub;
 		GF_SAFEALLOC(c, SVG_Coordinate)
 		if (!c) break;
-		sub = svg_parse_length(c, &(stri), 0);
+		sub = svg_parse_length(c, &(stri), 0, out_e);
 		if (!sub) {
 			gf_free(c);
 			return;
@@ -2744,12 +2824,12 @@
 }
 
 /* Parse a point as a pair of number without units */
-u32 svg_parse_point(SVG_Point *p, char *value_string)
+u32 svg_parse_point(SVG_Point *p, char *value_string, GF_Err *out_e)
 {
 	u32 i = 0, j = 0;
-	i = svg_parse_number(&(value_stringi), &(p->x), 0);
+	i = svg_parse_number(&(value_stringi), &(p->x), 0, out_e);
 	/* TODO: handle cases where a point has an invalid syntax */
-	j = svg_parse_number(&(value_stringi), &(p->y), 0);
+	j = svg_parse_number(&(value_stringi), &(p->y), 0, out_e);
 	/* we need to detect an odd number of coordinates in polygon points list
 	 cf. http://www.w3.org/TR/SVGMobile12/shapes.html#PolygonElement
 	 see svg_parse_points */
@@ -2757,19 +2837,8 @@
 	else return i+j;
 }
 
-static u32 svg_parse_point_into_matrix(GF_Matrix2D *p, char *value_string)
-{
-	u32 i = 0, j = 0;
-	gf_mx2d_init(*p);
-	i = svg_parse_number(&(value_stringi), &(p->m2), 0);
-	if (i == 0) return 0;
-	j = svg_parse_number(&(value_stringi), &(p->m5), 0);
-	if (j == 0) return 0;
-	return i+j;
-}
-
 /* Parses the points attribute of a polygon or polyline element */
-static void svg_parse_points(GF_List *values, char *value_string)
+static void svg_parse_points(GF_List *values, char *value_string, GF_Err *out_e)
 {
 	u32 i = 0, j;
 	char *str = value_string;
@@ -2778,7 +2847,7 @@
 		SVG_Point *p;
 		GF_SAFEALLOC(p, SVG_Point)
 		if (!p) break;
-		j = svg_parse_point(p, &stri);
+		j = svg_parse_point(p, &stri, out_e);
 		if (j == 0) {
 			/* cf. http://www.w3.org/TR/SVGMobile12/shapes.html#PolygonElement
 			 If an odd number of coordinates is provided, then the element
@@ -2796,7 +2865,7 @@
 }
 
 /* Parses a list of numbers */
-static void svg_parse_numbers(GF_List *values, char *value_string, Bool is_angle)
+static void svg_parse_numbers(GF_List *values, char *value_string, Bool is_angle, GF_Err *out_e)
 {
 	u32 read_chars;
 	u32 i = 0;
@@ -2806,7 +2875,7 @@
 		Fixed *f;
 		GF_SAFEALLOC(f, Fixed)
 		if (!f) break;
-		read_chars = svg_parse_number(&(stri), f, is_angle);
+		read_chars = svg_parse_number(&(stri), f, is_angle, out_e);
 		if (!read_chars) {
 			gf_free(f);
 			return;
@@ -2862,7 +2931,7 @@
 	}
 }
 
-static void svg_parse_strokedasharray(SVG_StrokeDashArray *value, char *value_string)
+static void svg_parse_strokedasharray(SVG_StrokeDashArray *value, char *value_string, GF_Err *out_e)
 {
 	u32 read_chars;
 	if (!strcmp(value_string, "none")) {
@@ -2879,7 +2948,7 @@
 			SVG_Length *f;
 			GF_SAFEALLOC(f, SVG_Length)
 			if (!f) break;
-			read_chars = svg_parse_length(f, &(stri), 0);
+			read_chars = svg_parse_length(f, &(stri), 0, out_e);
 			if (!read_chars) {
 				gf_free(f);
 				return;
@@ -2901,22 +2970,24 @@
 	}
 }
 
-static void svg_parse_zoomandpan(SVG_ZoomAndPan *value, char *value_string)
+static void svg_parse_zoomandpan(SVG_ZoomAndPan *value, char *value_string, GF_Err *out_e)
 {
 	if (!strcmp(value_string, "disable")) {
 		*value = SVG_ZOOMANDPAN_DISABLE;
 	} else if (!strcmp(value_string, "magnify")) {
 		*value = SVG_ZOOMANDPAN_MAGNIFY;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_preserveaspectratio(SVG_PreserveAspectRatio *par, char *attribute_content)
+static void svg_parse_preserveaspectratio(SVG_PreserveAspectRatio *par, char *attribute_content, GF_Err *out_e)
 {
 	char *content = attribute_content;
 	while (*content == ' ') content++;
 	if (strstr(content, "defer")) {
 		par->defer = 1;
-		content += 4;
+		content += 5;
 	} else {
 		content = attribute_content;
 	}
@@ -2951,17 +3022,22 @@
 	} else if (strstr(content, "xMaxYMax")) {
 		par->align = SVG_PRESERVEASPECTRATIO_XMAXYMAX;
 		content+=8;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 	while (*content == ' ') content++;
 	if (*content == 0) return;
+
 	if (strstr(content, "meet")) {
 		par->meetOrSlice = SVG_MEETORSLICE_MEET;
 	} else if (strstr(content, "slice")) {
 		par->meetOrSlice = SVG_MEETORSLICE_SLICE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_animatetransform_type(SVG_TransformType *anim_transform_type, char *attribute_content)
+static void svg_parse_animatetransform_type(SVG_TransformType *anim_transform_type, char *attribute_content, GF_Err *out_e)
 {
 	*anim_transform_type = SVG_TRANSFORM_MATRIX;
 	if (!strcmp(attribute_content, "scale")) {
@@ -2974,48 +3050,58 @@
 		*anim_transform_type = SVG_TRANSFORM_SKEWX;
 	} else if (!strcmp(attribute_content, "skewY")) {
 		*anim_transform_type = SVG_TRANSFORM_SKEWY;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_focushighlight(SVG_FocusHighlight *fh, char *attribute_content)
+static void svg_parse_focushighlight(SVG_FocusHighlight *fh, char *attribute_content, GF_Err *out_e)
 {
 	if (!strcmp(attribute_content, "auto")) {
 		*fh = SVG_FOCUSHIGHLIGHT_AUTO;
 	} else if (!strcmp(attribute_content, "none")) {
 		*fh = SVG_FOCUSHIGHLIGHT_NONE;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_focusable(SVG_Focusable *f, char *attribute_content)
+static void svg_parse_focusable(SVG_Focusable *f, char *attribute_content, GF_Err *out_e)
 {
 	if (!strcmp(attribute_content, "true")) {
 		*f = SVG_FOCUSABLE_TRUE;
 	} else if (!strcmp(attribute_content, "false")) {
 		*f = SVG_FOCUSABLE_FALSE;
-	} else {
+	} else if (!strcmp(attribute_content, "auto")) {
 		*f = SVG_FOCUSABLE_AUTO;
+	} else {
+		*out_e = SVG_FOCUSABLE_AUTO;
 	}
 }
 
-static void svg_parse_initialvisibility(SVG_InitialVisibility *iv, char *attribute_content)
+static void svg_parse_initialvisibility(SVG_InitialVisibility *iv, char *attribute_content, GF_Err *out_e)
 {
 	if (!strcmp(attribute_content, "whenStarted")) {
 		*iv = SVG_INITIALVISIBILTY_WHENSTARTED;
 	} else if (!strcmp(attribute_content, "always")) {
 		*iv = SVG_INITIALVISIBILTY_ALWAYS;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_overlay(SVG_Overlay *o, char *attribute_content)
+static void svg_parse_overlay(SVG_Overlay *o, char *attribute_content, GF_Err *out_e)
 {
 	if (!strcmp(attribute_content, "none")) {
 		*o = SVG_OVERLAY_NONE;
 	} else if (!strcmp(attribute_content, "top")) {
 		*o = SVG_OVERLAY_TOP;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_transformbehavior(SVG_TransformBehavior *tb, char *attribute_content)
+static void svg_parse_transformbehavior(SVG_TransformBehavior *tb, char *attribute_content, GF_Err *out_e)
 {
 	if (!strcmp(attribute_content, "geometric")) {
 		*tb = SVG_TRANSFORMBEHAVIOR_GEOMETRIC;
@@ -3027,10 +3113,12 @@
 		*tb = SVG_TRANSFORMBEHAVIOR_PINNED180;
 	} else if (!strcmp(attribute_content, "pinned270")) {
 		*tb = SVG_TRANSFORMBEHAVIOR_PINNED270;
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_focus(GF_Node *e, SVG_Focus *o, char *attribute_content)
+static void svg_parse_focus(GF_Node *e, SVG_Focus *o, char *attribute_content, GF_Err *out_e)
 {
 	if (o->target.string) gf_free(o->target.string);
 	o->target.string = NULL;
@@ -3044,10 +3132,12 @@
 		o->type = SVG_FOCUS_IRI;
 		svg_parse_iri(e, &o->target, attribute_content+4);
 		if (sep) sep0 = ')';
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 
-static void svg_parse_clippath(GF_Node *e, SVG_ClipPath *o, char *attribute_content)
+static void svg_parse_clippath(GF_Node *e, SVG_ClipPath *o, char *attribute_content, GF_Err *out_e)
 {
 	if (o->target.string) gf_free(o->target.string);
 	o->target.string = NULL;
@@ -3058,22 +3148,26 @@
 		if (sep) sep0 = 0;
 		svg_parse_iri(e, &o->target, attribute_content+4);
 		if (sep) sep0 = ')';
+	} else if (!strcmp(attribute_content, "none")) {
+	} else {
+		*out_e = GF_NON_COMPLIANT_BITSTREAM;
 	}
 }
 /* end of Basic SVG datatype parsing functions */
 
-void svg_parse_one_anim_value(GF_Node *n, SMIL_AnimateValue *anim_value, char *attribute_content, u8 anim_value_type)
+void svg_parse_one_anim_value(GF_Node *n, SMIL_AnimateValue *anim_value, char *attribute_content, u8 anim_value_type, GF_Err *out_e)
 {
 	GF_FieldInfo info;
 	info.fieldType = anim_value_type;
 	info.far_ptr = gf_svg_create_attribute_value(anim_value_type);
-	if (info.far_ptr) gf_svg_parse_attribute(n, &info, attribute_content, 0);
-
+	if (info.far_ptr) {
+		*out_e = gf_svg_parse_attribute(n, &info, attribute_content, 0);
+	}
 	anim_value->value = info.far_ptr;
 	anim_value->type = anim_value_type;
 }
 
-void svg_parse_anim_values(GF_Node *n, SMIL_AnimateValues *anim_values, char *anim_values_string, u8 anim_value_type)
+void svg_parse_anim_values(GF_Node *n, SMIL_AnimateValues *anim_values, char *anim_values_string, u8 anim_value_type, GF_Err *out_e)
 {
 	u32 i = 0;
 	char *str;
@@ -3116,12 +3210,12 @@
 	return GF_OK;
 }
 
-GF_Err laser_parse_size(LASeR_Size *size, char *attribute_content)
+GF_Err laser_parse_size(LASeR_Size *size, char *attribute_content, GF_Err *out_e)
 {
 	char *str = attribute_content;
 	u32 i = 0;
-	i+=svg_parse_number(&(stri), &(size->width), 0);
-	/*i+=*/ svg_parse_number(&(stri), &(size->height), 0);
+	i+=svg_parse_number(&(stri), &(size->width), 0, out_e);
+	/*i+=*/ svg_parse_number(&(stri), &(size->height), 0, out_e);
 	return GF_OK;
 }
 
@@ -3138,6 +3232,7 @@
 GF_EXPORT
 GF_Err gf_svg_parse_attribute(GF_Node *n, GF_FieldInfo *info, char *attribute_content, u8 anim_value_type)
 {
+	GF_Err e = GF_OK;
 	/* for all attributes, except strings, apply some sort of white space normalization*/
 	if (info->fieldType != DOM_String_datatype && strlen(attribute_content)) {
 		u32 i, len;
@@ -3162,135 +3257,148 @@
 
 	switch (info->fieldType) {
 	case SVG_Boolean_datatype:
-		svg_parse_boolean((SVG_Boolean *)info->far_ptr, attribute_content);
+		svg_parse_boolean((SVG_Boolean *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Color_datatype:
-		svg_parse_color((SVG_Color *)info->far_ptr, attribute_content);
+		svg_parse_color((SVG_Color *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Paint_datatype:
-		svg_parse_paint(n, (SVG_Paint *)info->far_ptr, attribute_content);
+		svg_parse_paint(n, (SVG_Paint *)info->far_ptr, attribute_content, &e);
 		break;
 
 	/* beginning of keyword type parsing */
 	case SVG_FillRule_datatype:
-		svg_parse_clipfillrule((SVG_FillRule *)info->far_ptr, attribute_content);
+		svg_parse_clipfillrule((SVG_FillRule *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_StrokeLineJoin_datatype:
-		svg_parse_strokelinejoin((SVG_StrokeLineJoin *)info->far_ptr, attribute_content);
+		svg_parse_strokelinejoin((SVG_StrokeLineJoin *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_StrokeLineCap_datatype:
-		svg_parse_strokelinecap((SVG_StrokeLineCap *)info->far_ptr, attribute_content);
+		svg_parse_strokelinecap((SVG_StrokeLineCap *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_FontStyle_datatype:
-		svg_parse_fontstyle((SVG_FontStyle *)info->far_ptr, attribute_content);
+		svg_parse_fontstyle((SVG_FontStyle *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_FontWeight_datatype:
-		svg_parse_fontweight((SVG_FontWeight *)info->far_ptr, attribute_content);
+		svg_parse_fontweight((SVG_FontWeight *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_FontVariant_datatype:
-		svg_parse_fontvariant((SVG_FontVariant *)info->far_ptr, attribute_content);
+		svg_parse_fontvariant((SVG_FontVariant *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_TextAnchor_datatype:
-		svg_parse_textanchor((SVG_TextAnchor *)info->far_ptr, attribute_content);
+		svg_parse_textanchor((SVG_TextAnchor *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Display_datatype:
-		svg_parse_display((SVG_Display *)info->far_ptr, attribute_content);
+		svg_parse_display((SVG_Display *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Visibility_datatype:
-		svg_parse_visibility((SVG_Visibility *)info->far_ptr, attribute_content);
+		svg_parse_visibility((SVG_Visibility *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Overflow_datatype:
-		svg_parse_overflow((SVG_Overflow *)info->far_ptr, attribute_content);
+		svg_parse_overflow((SVG_Overflow *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_ZoomAndPan_datatype:
-		svg_parse_zoomandpan((SVG_ZoomAndPan *)info->far_ptr, attribute_content);
+		svg_parse_zoomandpan((SVG_ZoomAndPan *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_DisplayAlign_datatype:
-		svg_parse_displayalign((SVG_DisplayAlign *)info->far_ptr, attribute_content);
+		svg_parse_displayalign((SVG_DisplayAlign *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_TextAlign_datatype:
-		svg_parse_textalign((SVG_TextAlign *)info->far_ptr, attribute_content);
+		svg_parse_textalign((SVG_TextAlign *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_PointerEvents_datatype:
-		svg_parse_pointerevents((SVG_PointerEvents *)info->far_ptr, attribute_content);
+		svg_parse_pointerevents((SVG_PointerEvents *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_RenderingHint_datatype:
-		svg_parse_renderinghint((SVG_RenderingHint *)info->far_ptr, attribute_content);
+		svg_parse_renderinghint((SVG_RenderingHint *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_VectorEffect_datatype:
-		svg_parse_vectoreffect((SVG_VectorEffect *)info->far_ptr, attribute_content);
+		svg_parse_vectoreffect((SVG_VectorEffect *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_PlaybackOrder_datatype:
-		svg_parse_playbackorder((SVG_PlaybackOrder *)info->far_ptr, attribute_content);
+		svg_parse_playbackorder((SVG_PlaybackOrder *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_TimelineBegin_datatype:
-		svg_parse_timelinebegin((SVG_TimelineBegin *)info->far_ptr, attribute_content);
+		svg_parse_timelinebegin((SVG_TimelineBegin *)info->far_ptr, attribute_content, &e);
 		break;
 	case XML_Space_datatype:
-		svg_parse_xmlspace((XML_Space *)info->far_ptr, attribute_content);
+		svg_parse_xmlspace((XML_Space *)info->far_ptr, attribute_content, &e);
 		break;
 	case XMLEV_Propagate_datatype:
-		svg_parse_xmlev_propagate((XMLEV_Propagate *)info->far_ptr, attribute_content);
+		svg_parse_xmlev_propagate((XMLEV_Propagate *)info->far_ptr, attribute_content, &e);
 		break;
 	case XMLEV_DefaultAction_datatype:
-		svg_parse_xmlev_defaultAction((XMLEV_DefaultAction *)info->far_ptr, attribute_content);
+		svg_parse_xmlev_defaultAction((XMLEV_DefaultAction *)info->far_ptr, attribute_content, &e);
 		break;
 	case XMLEV_Phase_datatype:
-		svg_parse_xmlev_phase((XMLEV_Phase *)info->far_ptr, attribute_content);
+		svg_parse_xmlev_phase((XMLEV_Phase *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_SyncBehavior_datatype:
-		smil_parse_syncBehaviorOrDefault((SMIL_SyncBehavior *)info->far_ptr, attribute_content);
+		smil_parse_syncBehaviorOrDefault((SMIL_SyncBehavior *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_SyncTolerance_datatype:
-		smil_parse_syncToleranceOrDefault((SMIL_SyncTolerance *)info->far_ptr, attribute_content);
+		smil_parse_syncToleranceOrDefault((SMIL_SyncTolerance *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_AttributeType_datatype:
-		smil_parse_attributeType((SMIL_AttributeType *)info->far_ptr, attribute_content);
+		smil_parse_attributeType((SMIL_AttributeType *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_CalcMode_datatype:
-		smil_parse_calcmode((SMIL_CalcMode *)info->far_ptr, attribute_content);
+		smil_parse_calcmode((SMIL_CalcMode *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_Additive_datatype:
-		smil_parse_additive((SMIL_CalcMode *)info->far_ptr, attribute_content);
+		smil_parse_additive((SMIL_CalcMode *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_Accumulate_datatype:
-		smil_parse_accumulate((SMIL_Accumulate *)info->far_ptr, attribute_content);
+		smil_parse_accumulate((SMIL_Accumulate *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_Restart_datatype:
-		smil_parse_restart((SMIL_Restart *)info->far_ptr, attribute_content);
+		smil_parse_restart((SMIL_Restart *)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_Fill_datatype:
-		smil_parse_fill((SMIL_Fill *)info->far_ptr, attribute_content);
+		smil_parse_fill((SMIL_Fill *)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_GradientUnit_datatype:
-		*((SVG_GradientUnit *)info->far_ptr) = !strcmp(attribute_content, "userSpaceOnUse") ? SVG_GRADIENTUNITS_USER : SVG_GRADIENTUNITS_OBJECT;
+		if (!strcmp(attribute_content, "userSpaceOnUse"))
+			*((SVG_GradientUnit *)info->far_ptr) = SVG_GRADIENTUNITS_USER;
+		else if (!strcmp(attribute_content, "objectBoundingBox"))
+			*((SVG_GradientUnit *)info->far_ptr) = SVG_GRADIENTUNITS_OBJECT;
+		else
+			e = GF_NON_COMPLIANT_BITSTREAM;
 		break;
 	case SVG_FocusHighlight_datatype:
-		svg_parse_focushighlight((SVG_FocusHighlight*)info->far_ptr, attribute_content);
+		svg_parse_focushighlight((SVG_FocusHighlight*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Focusable_datatype:
-		svg_parse_focusable((SVG_Focusable*)info->far_ptr, attribute_content);
+		svg_parse_focusable((SVG_Focusable*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_InitialVisibility_datatype:
-		svg_parse_initialvisibility((SVG_InitialVisibility*)info->far_ptr, attribute_content);
+		svg_parse_initialvisibility((SVG_InitialVisibility*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Overlay_datatype:
-		svg_parse_overlay((SVG_Overlay*)info->far_ptr, attribute_content);
+		svg_parse_overlay((SVG_Overlay*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_TransformBehavior_datatype:
-		svg_parse_transformbehavior((SVG_TransformBehavior*)info->far_ptr, attribute_content);
+		svg_parse_transformbehavior((SVG_TransformBehavior*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_SpreadMethod_datatype:
 		if (!strcmp(attribute_content, "reflect")) *(u8*)info->far_ptr = SVG_SPREAD_REFLECT;
 		else if (!strcmp(attribute_content, "repeat")) *(u8*)info->far_ptr = SVG_SPREAD_REPEAT;
-		else *(u8*)info->far_ptr = SVG_SPREAD_PAD;
+		else if (!strcmp(attribute_content, "pad")) *(u8*)info->far_ptr = SVG_SPREAD_PAD;
+		else e = GF_NON_COMPLIANT_BITSTREAM;
 		break;
 	case SVG_Filter_TransferType_datatype:
 		if (!strcmp(attribute_content, "table")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_TABLE;
 		else if (!strcmp(attribute_content, "discrete")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_DISCRETE;
 		else if (!strcmp(attribute_content, "linear")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_LINEAR;
 		else if (!strcmp(attribute_content, "gamma")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_GAMMA;
-		else *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_IDENTITY;
+		else if (!strcmp(attribute_content, "identity")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_IDENTITY;
+		else if (!strcmp(attribute_content, "fractalNoise")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_FRACTAL_NOISE;
+		else if (!strcmp(attribute_content, "turbulence")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_TURBULENCE;
+		else if (!strcmp(attribute_content, "matrix")) *(u8*)info->far_ptr = SVG_FILTER_MX_MATRIX;
+		else if (!strcmp(attribute_content, "saturate")) *(u8*)info->far_ptr = SVG_FILTER_MX_SATURATE;
+		else if (!strcmp(attribute_content, "hueRotate")) *(u8*)info->far_ptr = SVG_FILTER_HUE_ROTATE;
+		else if (!strcmp(attribute_content, "luminanceToAlpha")) *(u8*)info->far_ptr = SVG_FILTER_LUM_TO_ALPHA;
+		else e = GF_NON_COMPLIANT_BITSTREAM;
 		break;
 
 	/* end of keyword type parsing */
@@ -3301,14 +3409,14 @@
 	case SVG_FontSize_datatype:
 	case SVG_Rotate_datatype:
 	case SVG_Number_datatype:
-		svg_parse_length((SVG_Number*)info->far_ptr, attribute_content, 0);
+		svg_parse_length((SVG_Number*)info->far_ptr, attribute_content, 0, &e);
 		break;
 
 	case SMIL_AnimateValue_datatype:
-		svg_parse_one_anim_value(n, (SMIL_AnimateValue*)info->far_ptr, attribute_content, anim_value_type);
+		svg_parse_one_anim_value(n, (SMIL_AnimateValue*)info->far_ptr, attribute_content, anim_value_type, &e);
 		break;
 	case SMIL_AnimateValues_datatype:
-		svg_parse_anim_values(n, (SMIL_AnimateValues*)info->far_ptr, attribute_content, anim_value_type);
+		svg_parse_anim_values(n, (SMIL_AnimateValues*)info->far_ptr, attribute_content, anim_value_type, &e);
 		break;
 
 	case XMLRI_datatype:
@@ -3324,50 +3432,56 @@
 		smil_parse_time_list(n, *(GF_List **)info->far_ptr, attribute_content);
 		break;
 	case SMIL_Duration_datatype:
-		smil_parse_min_max_dur_repeatdur((SMIL_Duration*)info->far_ptr, attribute_content);
+		smil_parse_min_max_dur_repeatdur((SMIL_Duration*)info->far_ptr, attribute_content, &e);
 		break;
 	case SMIL_RepeatCount_datatype:
-		smil_parse_repeatcount((SMIL_RepeatCount*)info->far_ptr, attribute_content);
+		smil_parse_repeatcount((SMIL_RepeatCount*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_PathData_datatype:
-		svg_parse_path((SVG_PathData*)info->far_ptr, attribute_content);
+		svg_parse_path((SVG_PathData*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Points_datatype:
-		svg_parse_points(*(GF_List **)(info->far_ptr), attribute_content);
+		svg_parse_points(*(GF_List **)(info->far_ptr), attribute_content, &e);
 		break;
 	case SMIL_KeyTimes_datatype:
 	case SMIL_KeyPoints_datatype:
 	case SMIL_KeySplines_datatype:
 	case SVG_Numbers_datatype:
-		svg_parse_numbers(*(GF_List **)(info->far_ptr), attribute_content, 0);
+		svg_parse_numbers(*(GF_List **)(info->far_ptr), attribute_content, 0, &e);
 		break;
 	case SVG_Coordinates_datatype:
-		svg_parse_coordinates(*(GF_List **)(info->far_ptr), attribute_content);
+		svg_parse_coordinates(*(GF_List **)(info->far_ptr), attribute_content, &e);
 		break;
 	case SVG_ViewBox_datatype:
-		svg_parse_viewbox((SVG_ViewBox*)info->far_ptr, attribute_content);
+		svg_parse_viewbox((SVG_ViewBox*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_StrokeDashArray_datatype:
-		svg_parse_strokedasharray((SVG_StrokeDashArray*)info->far_ptr, attribute_content);
+		svg_parse_strokedasharray((SVG_StrokeDashArray*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_FontFamily_datatype:
-		svg_parse_fontfamily((SVG_FontFamily*)info->far_ptr, attribute_content);
+		svg_parse_fontfamily((SVG_FontFamily*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Motion_datatype:
-		svg_parse_point_into_matrix((GF_Matrix2D*)info->far_ptr, attribute_content);
+	{
+		GF_Matrix2D *mx = (GF_Matrix2D*)info->far_ptr;
+		u32 i = 0;
+		gf_mx2d_init(*mx);
+		i = svg_parse_number(&(attribute_contenti), &(mx->m2), 0, &e);
+		svg_parse_number(&(attribute_contenti), &(mx->m5), 0, &e);
+	}
 		break;
 	case SVG_Transform_datatype:
-		svg_parse_transform((SVG_Transform*)info->far_ptr, attribute_content);
+		e = svg_parse_transform((SVG_Transform*)info->far_ptr, attribute_content);
 		break;
 	case SVG_Transform_Translate_datatype:
 	{
 		u32 i = 0;
 		SVG_Point *p = (SVG_Point *)info->far_ptr;
-		i+=svg_parse_number(&(attribute_contenti), &(p->x), 0);
+		i+=svg_parse_number(&(attribute_contenti), &(p->x), 0, &e);
 		if (attribute_contenti == 0) {
 			p->y = 0;
 		} else {
-			/*i+=*/svg_parse_number(&(attribute_contenti), &(p->y), 0);
+			/*i+=*/svg_parse_number(&(attribute_contenti), &(p->y), 0, &e);
 		}
 	}
 	break;
@@ -3375,11 +3489,11 @@
 	{
 		u32 i = 0;
 		SVG_Point *p = (SVG_Point *)info->far_ptr;
-		i+=svg_parse_number(&(attribute_contenti), &(p->x), 0);
+		i+=svg_parse_number(&(attribute_contenti), &(p->x), 0, &e);
 		if (attribute_contenti == 0) {
 			p->y = p->x;
 		} else {
-			/*i+=*/svg_parse_number(&(attribute_contenti), &(p->y), 0);
+			/*i+=*/svg_parse_number(&(attribute_contenti), &(p->y), 0, &e);
 		}
 	}
 	break;
@@ -3387,27 +3501,27 @@
 	case SVG_Transform_SkewY_datatype:
 	{
 		Fixed *p = (Fixed *)info->far_ptr;
-		svg_parse_number(attribute_content, p, 1);
+		svg_parse_number(attribute_content, p, 1, &e);
 	}
 	break;
 	case SVG_Transform_Rotate_datatype:
 	{
 		u32 i = 0;
 		SVG_Point_Angle *p = (SVG_Point_Angle *)info->far_ptr;
-		i+=svg_parse_number(&(attribute_contenti), &(p->angle), 1);
+		i+=svg_parse_number(&(attribute_contenti), &(p->angle), 1, &e);
 		if (attribute_contenti == 0) {
 			p->y = p->x = 0;
 		} else {
-			i+=svg_parse_number(&(attribute_contenti), &(p->x), 0);
-			/*i+=*/svg_parse_number(&(attribute_contenti), &(p->y), 0);
+			i+=svg_parse_number(&(attribute_contenti), &(p->x), 0, &e);
+			/*i+=*/svg_parse_number(&(attribute_contenti), &(p->y), 0, &e);
 		}
 	}
 	break;
 	case SVG_PreserveAspectRatio_datatype:
-		svg_parse_preserveaspectratio((SVG_PreserveAspectRatio*)info->far_ptr, attribute_content);
+		svg_parse_preserveaspectratio((SVG_PreserveAspectRatio*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_TransformType_datatype:
-		svg_parse_animatetransform_type((SVG_TransformType*)info->far_ptr, attribute_content);
+		svg_parse_animatetransform_type((SVG_TransformType*)info->far_ptr, attribute_content, &e);
 		break;
 
 	case SVG_ID_datatype:
@@ -3452,17 +3566,17 @@
 	break;
 
 	case SVG_Focus_datatype:
-		svg_parse_focus(n, (SVG_Focus*)info->far_ptr, attribute_content);
+		svg_parse_focus(n, (SVG_Focus*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_ClipPath_datatype:
-		svg_parse_clippath(n, (SVG_ClipPath*)info->far_ptr, attribute_content);
+		svg_parse_clippath(n, (SVG_ClipPath*)info->far_ptr, attribute_content, &e);
 		break;
 
 	case LASeR_Choice_datatype:
-		laser_parse_choice((LASeR_Choice*)info->far_ptr, attribute_content);
+		e = laser_parse_choice((LASeR_Choice*)info->far_ptr, attribute_content);
 		break;
 	case LASeR_Size_datatype:
-		laser_parse_size((LASeR_Size*)info->far_ptr, attribute_content);
+		e = laser_parse_size((LASeR_Size*)info->far_ptr, attribute_content, &e);
 		break;
 	case SVG_Clock_datatype:
 		svg_parse_clock_value(attribute_content, (SVG_Clock*)info->far_ptr);
@@ -3472,10 +3586,16 @@
 		*(SVG_String *)info->far_ptr = gf_strdup(attribute_content);
 		break;
 	default:
-		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("SVG Parsing Cannot parse attribute %s\n", info->name, gf_svg_attribute_type_to_string(info->fieldType)));
-		break;
+		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("SVG Parsing Cannot parse attribute \"%s\"\n", info->name ? info->name : ""));
+		return GF_OK;
 	}
-	return GF_OK;
+	if (e) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SVG Parsing Cannot parse attribute \"%s\" value %s: %s\n", info->name ? info->name : "", attribute_content, gf_error_to_string(e)));
+		//continue parsing if not test mode
+		if (!gf_sys_is_test_mode())
+			e = GF_OK;
+	}
+	return e;
 }
 
 void svg_parse_one_style(GF_Node *n, char *one_style)
@@ -3817,7 +3937,7 @@
 	}
 	break;
 
-	case 0:
+	case SVG_Unknown_datatype:
 	{
 		SVG_String *string;
 		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("SVG Attributes Unspecified attribute type - defaulting to string.\n"));
@@ -5573,7 +5693,11 @@
 
 	if (a_count != gf_list_count(*b)) return GF_BAD_PARAM;
 
-	gf_list_reset(*c);
+	while (gf_list_count(*c)) {
+		SVG_Number *nc = gf_list_pop_back(*c);
+		gf_free(nc);
+	}
+
 	for (i = 0; i < a_count; i ++) {
 		SVG_Number *nc;
 		SVG_Number *na = (SVG_Number *)gf_list_get(*a, i);
@@ -5735,8 +5859,12 @@
 	if (a->array.count != b->array.count) return GF_BAD_PARAM;
 
 	c->type = a->type;
-	c->array.count = a->array.count;
-	c->array.vals = (Fixed *) gf_malloc(sizeof(Fixed)*c->array.count);
+	if (c->array.count != a->array.count) {
+		c->array.count = a->array.count;
+		c->array.vals = (Fixed *) gf_realloc(c->array.vals, sizeof(Fixed)*c->array.count);
+		c->array.units = (u8 *) gf_realloc(c->array.units, sizeof(u8)*c->array.count);
+	}
+	if (!c->array.vals || !c->array.units) return GF_OUT_OF_MEM;
 	for (i = 0; i < c->array.count; i++) {
 		/* TODO: convert units if needed */
 		c->array.unitsi = a->array.unitsi;
@@ -5748,13 +5876,14 @@
 static GF_Err svg_dasharray_copy(SVG_StrokeDashArray *a, SVG_StrokeDashArray *b)
 {
 	a->type = b->type;
-	a->array.count = b->array.count;
-	a->array.units = (u8*)gf_malloc(sizeof(u8)*a->array.count);
-	if (a->array.count)
-		memcpy(a->array.units, b->array.units, sizeof(u8)*a->array.count);
-	a->array.vals = (Fixed*)gf_malloc(sizeof(Fixed)*a->array.count);
-	if (a->array.count)
-		memcpy(a->array.vals, b->array.vals, sizeof(Fixed)*a->array.count);
+	if (a->array.count != b->array.count) {
+		a->array.count = b->array.count;
+		a->array.units = (u8*)gf_realloc(a->array.units, sizeof(u8)*a->array.count);
+		a->array.vals = (Fixed*)gf_realloc(a->array.vals, sizeof(Fixed)*a->array.count);
+	}
+	if (!a->array.vals || !a->array.units) return GF_OUT_OF_MEM;
+	memcpy(a->array.units, b->array.units, sizeof(u8)*a->array.count);
+	memcpy(a->array.vals, b->array.vals, sizeof(Fixed)*a->array.count);
 	return GF_OK;
 }
 
@@ -5824,7 +5953,7 @@
 		SVG_Paint *pb = (SVG_Paint *)b->far_ptr;
 		SVG_Paint *pc = (SVG_Paint *)c->far_ptr;
 		if (pa->type != pb->type || pa->type != SVG_PAINT_COLOR || pb->type != SVG_PAINT_COLOR) {
-			GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("SVG Attributes only color paints are additive\n"));
+			GF_LOG(GF_LOG_WARNING, GF_LOG_SCENE, ("SVG Attributes only color paints are additive, cannot interpolate URIs\n"));
 			return GF_BAD_PARAM;
 		}
 		pc->type = SVG_PAINT_COLOR;
@@ -6215,8 +6344,11 @@
 	case SVG_Focus_datatype:
 	{
 		((SVG_Focus *)a->far_ptr)->type = ((SVG_Focus *)b->far_ptr)->type;
-		if ( ((SVG_Focus *)b->far_ptr)->target.string)
+		if ( ((SVG_Focus *)b->far_ptr)->target.string) {
+			if ( ((SVG_Focus *)a->far_ptr)->target.string)
+				gf_free( ((SVG_Focus *)a->far_ptr)->target.string);
 			((SVG_Focus *)a->far_ptr)->target.string = gf_strdup( ((SVG_Focus *)b->far_ptr)->target.string);
+		}
 	}
 		return GF_OK;
 
@@ -6327,6 +6459,7 @@
 	case SVG_Transform_Rotate_datatype:
 	case SVG_Transform_SkewX_datatype:
 	case SVG_Transform_SkewY_datatype:
+	case SVG_StrokeDashArray_datatype:
 	case LASeR_Size_datatype:
 		return 1;
 	}
@@ -6339,6 +6472,12 @@
 
 	c->fieldType = a->fieldType;
 
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) {
+		gf_svg_attributes_equal(a, b);
+	}
+#endif
+
 	switch (a->fieldType) {
 
 	/* additive types which can really be interpolated */
@@ -6361,6 +6500,7 @@
 	case SVG_Transform_SkewX_datatype:
 	case SVG_Transform_SkewY_datatype:
 	case LASeR_Size_datatype:
+	case SVG_StrokeDashArray_datatype:
 		return gf_svg_attributes_muladd(FIX_ONE-coef, a, coef, b, c, clamp);
 
 	/* discrete types: interpolation is the selection of one of the 2 values

gpac-2.0.0.tar.gz/src/scenegraph/svg_types.c -> gpac-2.2.0.tar.gz/src/scenegraph/svg_types.c Changed

gpac-2.0.0.tar.gz/src/scenegraph/vrml_js.c -> gpac-2.2.0.tar.gz/src/scenegraph/vrml_js.c Changed

gpac-2.0.0.tar.gz/src/scenegraph/vrml_proto.c -> gpac-2.2.0.tar.gz/src/scenegraph/vrml_proto.c Changed

gpac-2.0.0.tar.gz/src/scenegraph/xml_ns.c -> gpac-2.2.0.tar.gz/src/scenegraph/xml_ns.c Changed

@@ -2,7 +2,7 @@
  *			GPAC - Multimedia Framework C SDK
  *
  *			Authors: Jean Le Feuvre - Cyril Concolato
- *			Copyright (c) Telecom ParisTech 2000-2020
+ *			Copyright (c) Telecom ParisTech 2000-2022
  *					All rights reserved
  *
  *  This file is part of GPAC / SVG Scene Graph sub-project
@@ -443,9 +443,13 @@
 			case TAG_SVG_animateMotion:
 			case TAG_SVG_animateTransform:
 			case TAG_SVG_animation:
+			case TAG_SVG_set:
+				return xml_attributesi.tag;
 			case TAG_SVG_audio:
 			case TAG_SVG_video:
-			case TAG_SVG_set:
+				//"type" on audio and video is mime type, not smil anim type
+				if (xml_attributesi.tag == TAG_SVG_ATT_transform_type)
+					break;
 				return xml_attributesi.tag;
 			default:
 				break;
@@ -1090,7 +1094,10 @@
 	u32 data_size=0, idx;
 	Bool existing;
 
-	if (!cache_dir || !base_filename || !iri || !iri->string || strncmp(iri->string, "data:", 5)) return GF_OK;
+	if (!cache_dir || !base_filename || !iri || !iri->string) return GF_OK;
+	if (strncmp(iri->string, "data:", 5)) return GF_OK;
+	//used in test suite
+	if (!strcmp(iri->string, "data:,void")) return GF_OK;
 
 	/*handle "data:" scheme when cache is specified*/
 	strcpy(szFile, cache_dir);
@@ -1121,7 +1128,7 @@
 
 
 	data = NULL;
-	sep = strchr(iri->string, ';');
+	sep = strstr(iri->string, ";base");
 	if (!strncmp(sep, ";base64,", 8)) {
 		sep += 8;
 		data_size = 2 * (u32) strlen(sep);
@@ -1155,6 +1162,7 @@
 	strcat(szFile, buf);
 	strcat(szFile, ext);
 
+	GF_Err e = GF_OK;
 	if (!existing) {
 		FILE *f = gf_fopen(szFile, "wb");
 		if (!f) {
@@ -1163,13 +1171,15 @@
 			iri->string = NULL;
 			return GF_IO_ERR;
 		}
-		gf_fwrite(data, data_size, f);
+		if (gf_fwrite(data, data_size, f)!=data_size) e = GF_IO_ERR;
 		gf_fclose(f);
 	}
 	gf_free(data);
 	gf_free(iri->string);
 	iri->string = gf_strdup(szFile);
-	return GF_OK;
+	if (!iri->string) e = GF_OUT_OF_MEM;
+
+	return e;
 }

gpac-2.0.0.tar.gz/src/utils/Remotery.c -> gpac-2.2.0.tar.gz/src/utils/Remotery.c Changed

gpac-2.0.0.tar.gz/src/utils/base_encoding.c -> gpac-2.2.0.tar.gz/src/utils/base_encoding.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -26,8 +26,6 @@
 #include <gpac/base_coding.h>
 #include <gpac/constants.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 static const char base_64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 GF_EXPORT
@@ -42,6 +40,8 @@
 
 	while (i < inSize) {
 		padding = 3 - (inSize - i);
+		if (j+4>=outSize)
+			return 0;
 		if (padding == 2) {
 			outj = base_64ini>>2;
 			outj+1 = base_64(ini & 0x03) << 4;
@@ -147,14 +147,12 @@
 	unsigned char *in = (unsigned char *)_in;
 	unsigned char *out = (unsigned char *)_out;
 
-	if (outSize < (inSize * 2)+1) return 0;
+	if (outSize < (inSize * 2)) return 0;
 
 	for (i=0; i<inSize; i++) {
 		out2*i = base_16((ini & 0xf0) >> 4);
 		out2*i+1 = base_16(ini & 0x0f);
 	}
-	out(inSize * 2) = 0;
-
 	return inSize * 2;
 }
 
@@ -290,7 +288,6 @@
 		}
 		*out_size = (u32) d_stream.total_out;
 		inflateEnd(&d_stream);
-		return e;
 	}
 	if (e!=GF_OK) {
 		if (owns_buffer) {
@@ -447,5 +444,3 @@
 	return GF_NOT_SUPPORTED;
 }
 #endif /*GPAC_HAS_LZMA*/
-
-#endif /* GPAC_DISABLE_CORE_TOOLS*/

gpac-2.0.0.tar.gz/src/utils/bitstream.c -> gpac-2.2.0.tar.gz/src/utils/bitstream.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2020
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -61,7 +61,7 @@
 	u32 cache_write_size, buffer_written;
 
 	Bool remove_emul_prevention_byte;
-	u32 nb_zeros;
+	u32 nb_zeros, nb_removed;
 
 	GF_Err (*on_block_out)(void *cbk, u8 *data, u32 block_size);
 	void *usr_data;
@@ -91,7 +91,7 @@
 		bs->current = 0;
 		bs->nbBits = 8;
 		bs->current = 0;
-		bs->nb_zeros = 0;
+		bs->nb_zeros = bs->nb_removed = 0;
 		return GF_OK;
 	}
 	if (bs->bsmode==GF_BITSTREAM_WRITE) {
@@ -273,18 +273,21 @@
 	}
 }
 
-static void bs_flush_write_cache(GF_BitStream *bs)
+static Bool bs_flush_write_cache(GF_BitStream *bs)
 {
+	Bool res = GF_TRUE;
 	if (bs->buffer_written) {
 		u32 nb_write;
 		nb_write = (u32) gf_fwrite(bs->cache_write, bs->buffer_written, bs->stream);
-
+		if (nb_write != bs->buffer_written)
+			res = GF_FALSE;
 		//check we didn't rewind the bitstream
 		if (bs->size == bs->position)
 			bs->size += nb_write;
 		bs->position += nb_write;
 		bs->buffer_written = 0;
 	}
+	return res;
 }
 
 
@@ -312,10 +315,18 @@
 {
 	if (bs) {
 		bs->remove_emul_prevention_byte = do_remove;
-		bs->nb_zeros = 0;
+		bs->nb_zeros = bs->nb_removed = 0;
 	}
 }
 
+GF_EXPORT
+u32 gf_bs_get_emulation_byte_removed(GF_BitStream *bs)
+{
+	if (bs) return bs->nb_removed;
+	return 0;
+}
+
+
 /*returns 1 if aligned wrt current mode, 0 otherwise*/
 Bool gf_bs_is_align(GF_BitStream *bs)
 {
@@ -364,6 +375,7 @@
 		if (bs->remove_emul_prevention_byte) {
 			if ((bs->nb_zeros==2) && (res==0x03) && (bs->position<bs->size) && (bs->originalbs->position<0x04)) {
 				bs->nb_zeros = 0;
+				bs->nb_removed++;
 				res = bs->originalbs->position++;
 			}
 			if (!res) bs->nb_zeros++;
@@ -374,10 +386,13 @@
 	if (bs->cache_write)
 		bs_flush_write_cache(bs);
 
-	is_eos = gf_feof(bs->stream);
+	is_eos = bs->stream ? gf_feof(bs->stream) : GF_TRUE;
+	//cache not fully read, reset EOS
+	if (bs->cache_read && (bs->cache_read_pos<bs->cache_read_size))
+		is_eos = GF_FALSE;
 
 	/*we are in FILE mode, test for end of file*/
-	if (!is_eos || bs->cache_read) {
+	if (!is_eos) {
 		u8 res;
 		Bool loc_eos=GF_FALSE;
 		assert(bs->position<=bs->size);
@@ -391,6 +406,7 @@
 				u8 next = gf_bs_load_byte(bs, &loc_eos);
 				if (next < 0x04) {
 					bs->nb_zeros = 0;
+					bs->nb_removed++;
 					res = next;
 					bs->position++;
 				} else {
@@ -408,7 +424,10 @@
 		bs->EndOfStream(bs->par);
 		if (!bs->overflow_state) bs->overflow_state = 1;
 	} else {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("BS Attempt to overread bitstream\n"));
+		if (!bs->overflow_state) {
+			bs->overflow_state = 1;
+			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("BS Attempt to overread bitstream\n"));
+		}
 	}
 	assert(bs->position <= 1+bs->size);
 	return 0;
@@ -1055,7 +1074,8 @@
 					return nbBytes;
 				}
 				//otherwise flush cache and use file write
-				bs_flush_write_cache(bs);
+				if (!bs_flush_write_cache(bs))
+					return 0;
 			}
 
 			if (gf_fwrite(data, nbBytes, bs->stream) != nbBytes) return 0;
@@ -1358,7 +1378,7 @@
 u32 gf_bs_peek_bits(GF_BitStream *bs, u32 numBits, u64 byte_offset)
 {
 	u64 curPos;
-	u32 curBits, ret, current, nb_zeros;
+	u32 curBits, ret, current, nb_zeros, nb_removed;
 
 	if ( (bs->bsmode != GF_BITSTREAM_READ) && (bs->bsmode != GF_BITSTREAM_FILE_READ)) return 0;
 	if (!numBits || (bs->size < bs->position + byte_offset)) return 0;
@@ -1368,6 +1388,7 @@
 	curBits = bs->nbBits;
 	current = bs->current;
 	nb_zeros = bs->nb_zeros;
+	nb_removed = bs->nb_removed;
 
 	if (byte_offset) {
 		if (bs->remove_emul_prevention_byte) {
@@ -1387,6 +1408,7 @@
 	bs->nbBits = curBits;
 	bs->current = current;
 	bs->nb_zeros = nb_zeros;
+	bs->nb_removed = nb_removed;
 	return ret;
 }
 
@@ -1719,3 +1741,35 @@
 {
 	return bs->overflow_state;
 }
+
+
+GF_EXPORT
+char *gf_bs_read_utf8(GF_BitStream *bs)
+{
+	char szC2;
+	char *res = NULL;
+	if (!bs || !gf_bs_is_align(bs))
+		return NULL;
+
+	szC1 = 0;
+	while (gf_bs_available(bs)) {
+		u8 c = gf_bs_read_u8(bs);
+		if (!c) break;
+		szC0 = c;
+		gf_dynstrcat(&res, szC, NULL);
+	}
+	return res;
+}
+
+GF_EXPORT
+GF_Err gf_bs_write_utf8(GF_BitStream *bs, const char *str)
+{
+	if (!bs || !gf_bs_is_align(bs))
+		return GF_BAD_PARAM;
+
+	u32 i, len = str ? (u32) strlen(str) : 0;
+	for (i=0; i<len; i++)
+		gf_bs_write_u8(bs, stri);
+	gf_bs_write_u8(bs, 0);
+	return GF_OK;
+}

gpac-2.0.0.tar.gz/src/utils/cache.c -> gpac-2.2.0.tar.gz/src/utils/cache.c Changed

@@ -2,7 +2,7 @@
 *					GPAC Multimedia Framework
 *
 *			Authors: Jean Le Feuvre, Pierre Souchay
- *			Copyright (c) Telecom ParisTech 2010-2020
+ *			Copyright (c) Telecom ParisTech 2010-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -23,8 +23,6 @@
 *
 */
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 #include <gpac/cache.h>
 #include <gpac/network.h>
 #include <gpac/download.h>
@@ -490,7 +488,11 @@
 		entry->cache_blob.mx = mx;
 		entry->cache_blob.data = entry->mem_storage;
 		entry->cache_blob.size = entry->contentLength;
-		sprintf(entry->cache_filename, "gmem://%p", &entry->cache_blob);
+		char *burl = gf_blob_register(&entry->cache_blob);
+		if (burl) {
+			strcpy(entry->cache_filename, burl);
+			gf_free(burl);
+		}
 		return entry;
 	}
 
@@ -664,7 +666,11 @@
 		}
 		entry->cache_blob.data = entry->mem_storage;
 		entry->cache_blob.size = entry->contentLength;
-		sprintf(entry->cache_filename, "gmem://%p", &entry->cache_blob);
+		char *burl = gf_blob_register(&entry->cache_blob);
+		if (burl) {
+			strcpy(entry->cache_filename, burl);
+			gf_free(burl);
+		}
 		gf_mx_v(entry->cache_blob.mx);
 
 		if (!entry->mem_allocated) {
@@ -711,7 +717,11 @@
 			entry->mem_allocated = new_size;
 			entry->cache_blob.data = entry->mem_storage;
 			entry->cache_blob.size = entry->contentLength;
-			sprintf(entry->cache_filename, "gmem://%p", &entry->cache_blob);
+			char *burl = gf_blob_register(&entry->cache_blob);
+			if (burl) {
+				strcpy(entry->cache_filename, burl);
+				gf_free(burl);
+			}
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("CACHE Reallocating memory cache to %d bytes\n", new_size));
 		}
 		memcpy(entry->mem_storage + entry->written_in_cache, data, size);
@@ -812,6 +822,13 @@
 		gf_free ( entry->cache_filename );
 		entry->cache_filename = NULL;
 	}
+	gf_blob_unregister(&entry->cache_blob);
+
+	if (entry->external_blob) {
+		gf_blob_unregister(entry->external_blob);
+		entry->external_blob = NULL;
+	}
+
 	if ( entry->properties ) {
 		const char * propfile = NULL;
 		if (entry->deletableFilesOnDelete)
@@ -1021,6 +1038,10 @@
 
 if (!blob) {
 entry->flags = DELETED;
+ if (entry->external_blob) {
+			gf_blob_unregister(entry->external_blob);
+			entry->external_blob = NULL;
+		}
 return GF_TRUE;
 }
 if (blob->mx)
@@ -1029,8 +1050,14 @@
 if (!copy) {
 if (entry->mem_allocated) gf_free(entry->mem_storage);
 		entry->mem_storage = (u8 *) blob->data;
- if (!entry->written_in_cache)
- sprintf(entry->cache_filename, "gmem://%p", blob);
+ if (!entry->written_in_cache) {
+			char *burl = gf_blob_register(blob);
+			if (burl) {
+				strcpy(entry->cache_filename, burl);
+				gf_free(burl);
+			}
+		}
+
 		entry->written_in_cache = blob->size;
 		entry->mem_allocated = 0;
 		entry->cache_blob.data = NULL;
@@ -1049,8 +1076,13 @@
 entry->mem_allocated = new_size;
 entry->cache_blob.data = entry->mem_storage;
 entry->cache_blob.size = entry->contentLength;
- if (!entry->written_in_cache)
- sprintf(entry->cache_filename, "gmem://%p", &entry->cache_blob);
+ if (!entry->written_in_cache) {
+				char *burl = gf_blob_register(&entry->cache_blob);
+				if (burl) {
+					strcpy(entry->cache_filename, burl);
+					gf_free(burl);
+				}
+ }
 GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("CACHE Reallocating memory cache to %d bytes\n", new_size));
 }
 memcpy(entry->mem_storage, blob->data, blob->size);
@@ -1073,4 +1105,3 @@
 return GF_TRUE;
 }
 
-#endif

gpac-2.0.0.tar.gz/src/utils/color.c -> gpac-2.2.0.tar.gz/src/utils/color.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2012
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -1919,7 +1919,6 @@
 			//check rgb->rgb copy
 			switch (dst->pixel_format) {
 			case GF_PIXEL_RGB:
-			case GF_PIXEL_RGBS:
 			case GF_PIXEL_BGR:
 				e = color_write_rgb_to_24(dst, src, src_wnd);
 				break;
@@ -1958,7 +1957,6 @@
 		load_line = load_line_rgb_565;
 		break;
 	case GF_PIXEL_RGB:
-	case GF_PIXEL_RGBS:
 		load_line = load_line_rgb_24;
 		break;
 	case GF_PIXEL_BGR:
@@ -1973,7 +1971,6 @@
 		load_line = load_line_bgra;
 		break;
 	case GF_PIXEL_RGBA:
-	case GF_PIXEL_RGBAS:
 		has_alpha = GF_TRUE;
 	case GF_PIXEL_RGBX:
 		load_line = load_line_rgb_32;
@@ -2052,7 +2049,7 @@
 		load_line = load_line_vyuy;
 		break;
 	default:
-		GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Source pixel format %s not supported by gf_stretch_bits\n", gf_pixel_fmt_name(src->pixel_format) ));
+		GF_LOG(GF_LOG_INFO, GF_LOG_CORE, ("Source pixel format %s not supported by gf_stretch_bits\n", gf_pixel_fmt_name(src->pixel_format) ));
 		return GF_NOT_SUPPORTED;
 	}
 
@@ -3984,7 +3981,6 @@
 	case GF_PIXEL_RGB_565:
 		return 2;
 	case GF_PIXEL_RGB:
-	case GF_PIXEL_RGBS:
 	case GF_PIXEL_BGR:
 		return 3;
 	case GF_PIXEL_RGBX:
@@ -3992,7 +3988,6 @@
 	case GF_PIXEL_XRGB:
 	case GF_PIXEL_XBGR:
 	case GF_PIXEL_ARGB:
-	case GF_PIXEL_RGBAS:
 	case GF_PIXEL_RGBD:
 	case GF_PIXEL_RGBDS:
 		return 4;
@@ -4068,7 +4063,6 @@
 	if (isBGR) {
 		switch (vs_src->pixel_format) {
 		case GF_PIXEL_RGB:
-		case GF_PIXEL_RGBS:
 			for (i = 0; i<h; i++) {
 				dst = (u8*)vs_dst->video_buffer + i*vs_dst->pitch_y;
 				cur = src + i*vs_src->pitch_y;
@@ -4113,7 +4107,6 @@
 	else {
 		switch (vs_src->pixel_format) {
 		case GF_PIXEL_RGB:
-		case GF_PIXEL_RGBS:
 			for (i = 0; i<h; i++) {
 				dst = (u8*)vs_dst->video_buffer + i*vs_dst->pitch_y;
 				cur = src + i*vs_src->pitch_y;

gpac-2.0.0.tar.gz/src/utils/constants.c -> gpac-2.2.0.tar.gz/src/utils/constants.c Changed

@@ -44,6 +44,8 @@
 	const char *mime_type;
 	//alternate codecid name
 	u32 alt_codecid;
+	//if true, unframe format exists in gpac (we can reparse the bitstream)
+	Bool unframe;
 } CodecIDReg;
 
 CodecIDReg CodecRegistry = {
@@ -59,33 +61,33 @@
 	{GF_CODECID_TEXT_MPEG4, GF_CODECID_TEXT_MPEG4, GF_STREAM_TEXT, "MPEG-4 Streaming Text", "m4txt", "text", "application/x-mpeg4-text"},
 	{GF_CODECID_LASER, GF_CODECID_LASER, GF_STREAM_SCENE, "MPEG-4 LASeR", "laser", "lsr1", "application/x-laser"},
 	{GF_CODECID_SAF, GF_CODECID_SAF, GF_STREAM_SCENE, "MPEG-4 Simple Aggregation Format", "saf", "mp4s", "application/saf"},
-	{GF_CODECID_MPEG4_PART2, GF_CODECID_MPEG4_PART2, GF_STREAM_VISUAL, "MPEG-4 Visual part 2", "cmp|m4ve|m4v", "mp4v", "video/mp4v-es"},
-	{GF_CODECID_AVC, GF_CODECID_AVC, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Video", "264|avc|h264", "avc1", "video/avc"},
-	{GF_CODECID_AVC_PS, GF_CODECID_AVC_PS, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Video Parameter Sets", "avcps", "avcp", "video/avc"},
-	{GF_CODECID_SVC, GF_CODECID_SVC, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Scalable Video Coding", "svc|avc|264|h264", "svc1", "video/svc"},
-	{GF_CODECID_MVC, GF_CODECID_MVC, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Multiview Video Coding", "mvc", "mvc1", "video/mvc"},
-	{GF_CODECID_HEVC, GF_CODECID_HEVC, GF_STREAM_VISUAL, "HEVC Video", "hvc|hevc|h265", "hvc1", "video/hevc"},
-	{GF_CODECID_LHVC, GF_CODECID_LHVC, GF_STREAM_VISUAL, "HEVC Video Layered Extensions", "lhvc|shvc|mhvc", "lhc1", "video/lhvc"},
-	{GF_CODECID_MPEG2_SIMPLE, GF_CODECID_MPEG2_SIMPLE, GF_STREAM_VISUAL, "MPEG-2 Visual Simple", "m2vs", "mp2v", "video/mp2v-es"},
-	{GF_CODECID_MPEG2_MAIN, GF_CODECID_MPEG2_MAIN, GF_STREAM_VISUAL, "MPEG-2 Visual Main", "m2v", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE},
-	{GF_CODECID_MPEG2_SNR, GF_CODECID_MPEG2_SNR, GF_STREAM_VISUAL, "MPEG-2 Visual SNR", "m2v|m2vsnr", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE},
-	{GF_CODECID_MPEG2_SPATIAL, GF_CODECID_MPEG2_SPATIAL, GF_STREAM_VISUAL, "MPEG-2 Visual Spatial", "m2v|m2vspat", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE},
-	{GF_CODECID_MPEG2_HIGH, GF_CODECID_MPEG2_HIGH, GF_STREAM_VISUAL, "MPEG-2 Visual High", "m2v|m2vh", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE},
-	{GF_CODECID_MPEG2_422, GF_CODECID_MPEG2_422, GF_STREAM_VISUAL, "MPEG-2 Visual 422", "m2v|m2v4", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE},
-	{GF_CODECID_MPEG1, GF_CODECID_MPEG1, GF_STREAM_VISUAL, "MPEG-1 Video", "m1v", "mp1v", "video/mp1v-es"},
-	{GF_CODECID_JPEG, GF_CODECID_JPEG, GF_STREAM_VISUAL, "JPEG Image", "jpg|jpeg", "jpeg", "image/jpeg"},
-	{GF_CODECID_PNG, GF_CODECID_PNG, GF_STREAM_VISUAL, "PNG Image", "png", "png ", "image/png"},
-	{GF_CODECID_J2K, 0x6E, GF_STREAM_VISUAL, "JPEG2000 Image", "jp2|j2k", "mjp2", "image/jp2"},
-	{GF_CODECID_AAC_MPEG4, GF_CODECID_AAC_MPEG4, GF_STREAM_AUDIO, "MPEG-4 AAC Audio", "aac", "mp4a", "audio/aac"},
-	{GF_CODECID_AAC_MPEG2_MP, GF_CODECID_AAC_MPEG2_MP, GF_STREAM_AUDIO, "MPEG-2 AAC Audio Main", "aac|aac2m", "mp4a", "audio/aac", GF_CODECID_AAC_MPEG4},
-	{GF_CODECID_AAC_MPEG2_LCP, GF_CODECID_AAC_MPEG2_LCP, GF_STREAM_AUDIO, "MPEG-2 AAC Audio Low Complexity", "aac|aac2l", "mp4a", "audio/aac", GF_CODECID_AAC_MPEG4},
-	{GF_CODECID_AAC_MPEG2_SSRP, GF_CODECID_AAC_MPEG2_SSRP, GF_STREAM_AUDIO, "MPEG-2 AAC Audio Scalable Sampling Rate", "aac|aac2s", "mp4a", "audio/aac", GF_CODECID_AAC_MPEG4},
-	{GF_CODECID_MPEG_AUDIO, GF_CODECID_MPEG_AUDIO, GF_STREAM_AUDIO, "MPEG-1 Audio", "mp3|m1a", ".mp3", "audio/mp3"},
-	{GF_CODECID_MPEG2_PART3, GF_CODECID_MPEG2_PART3, GF_STREAM_AUDIO, "MPEG-2 Audio", "mp2", ".mp3", "audio/mpeg"},
-	{GF_CODECID_MPEG_AUDIO_L1, GF_CODECID_MPEG_AUDIO, GF_STREAM_AUDIO, "MPEG-1 Audio Layer 1", "mp1", ".mp3", "audio/mpeg"},
-	{GF_CODECID_S263, 0, GF_STREAM_VISUAL, "H263 Video", "h263", "s263", "video/h263", .alt_codecid=GF_CODECID_H263},
-	{GF_CODECID_H263, 0, GF_STREAM_VISUAL, "H263 Video", "h263", "h263", "video/h263", .alt_codecid=GF_CODECID_S263},
-	{GF_CODECID_HEVC_TILES, 0, GF_STREAM_VISUAL, "HEVC tiles Video", "hvt1", "hvt1", "video/x-hevc-tiles", .alt_codecid=GF_CODECID_HEVC},
+	{GF_CODECID_MPEG4_PART2, GF_CODECID_MPEG4_PART2, GF_STREAM_VISUAL, "MPEG-4 Visual part 2", "cmp|m4ve|m4v", "mp4v", "video/mp4v-es", .unframe=GF_TRUE},
+	{GF_CODECID_AVC, GF_CODECID_AVC, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Video", "264|avc|h264", "avc1", "video/avc", .unframe=GF_TRUE},
+	{GF_CODECID_AVC_PS, GF_CODECID_AVC_PS, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Video Parameter Sets", "avcps", "avcp", "video/avc", .unframe=GF_TRUE},
+	{GF_CODECID_SVC, GF_CODECID_SVC, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Scalable Video Coding", "svc|avc|264|h264", "svc1", "video/svc", .unframe=GF_TRUE},
+	{GF_CODECID_MVC, GF_CODECID_MVC, GF_STREAM_VISUAL, "MPEG-4 AVC|H264 Multiview Video Coding", "mvc", "mvc1", "video/mvc", .unframe=GF_TRUE},
+	{GF_CODECID_HEVC, GF_CODECID_HEVC, GF_STREAM_VISUAL, "HEVC Video", "hvc|hevc|h265", "hvc1", "video/hevc", .unframe=GF_TRUE},
+	{GF_CODECID_LHVC, GF_CODECID_LHVC, GF_STREAM_VISUAL, "HEVC Video Layered Extensions", "lhvc|shvc|mhvc", "lhc1", "video/lhvc", .unframe=GF_TRUE},
+	{GF_CODECID_MPEG2_SIMPLE, GF_CODECID_MPEG2_SIMPLE, GF_STREAM_VISUAL, "MPEG-2 Visual Simple", "m2vs", "mp2v", "video/mp2v-es", .unframe=GF_TRUE},
+	{GF_CODECID_MPEG2_MAIN, GF_CODECID_MPEG2_MAIN, GF_STREAM_VISUAL, "MPEG-2 Visual Main", "m2v", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE, .unframe=GF_TRUE},
+	{GF_CODECID_MPEG2_SNR, GF_CODECID_MPEG2_SNR, GF_STREAM_VISUAL, "MPEG-2 Visual SNR", "m2v|m2vsnr", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE, .unframe=GF_TRUE},
+	{GF_CODECID_MPEG2_SPATIAL, GF_CODECID_MPEG2_SPATIAL, GF_STREAM_VISUAL, "MPEG-2 Visual Spatial", "m2v|m2vspat", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE, .unframe=GF_TRUE},
+	{GF_CODECID_MPEG2_HIGH, GF_CODECID_MPEG2_HIGH, GF_STREAM_VISUAL, "MPEG-2 Visual High", "m2v|m2vh", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE, .unframe=GF_TRUE},
+	{GF_CODECID_MPEG2_422, GF_CODECID_MPEG2_422, GF_STREAM_VISUAL, "MPEG-2 Visual 422", "m2v|m2v4", "mp2v", "video/mp2v-es", GF_CODECID_MPEG2_SIMPLE, .unframe=GF_TRUE},
+	{GF_CODECID_MPEG1, GF_CODECID_MPEG1, GF_STREAM_VISUAL, "MPEG-1 Video", "m1v", "mp1v", "video/mp1v-es", .unframe=GF_TRUE},
+	{GF_CODECID_JPEG, GF_CODECID_JPEG, GF_STREAM_VISUAL, "JPEG Image", "jpg|jpeg", "jpeg", "image/jpeg", .unframe=GF_TRUE},
+	{GF_CODECID_PNG, GF_CODECID_PNG, GF_STREAM_VISUAL, "PNG Image", "png", "png ", "image/png", .unframe=GF_TRUE},
+	{GF_CODECID_J2K, 0x6E, GF_STREAM_VISUAL, "JPEG2000 Image", "jp2|j2k", "mjp2", "image/jp2", .unframe=GF_TRUE},
+	{GF_CODECID_AAC_MPEG4, GF_CODECID_AAC_MPEG4, GF_STREAM_AUDIO, "MPEG-4 AAC Audio", "aac", "mp4a", "audio/aac", .unframe=GF_TRUE},
+	{GF_CODECID_AAC_MPEG2_MP, GF_CODECID_AAC_MPEG2_MP, GF_STREAM_AUDIO, "MPEG-2 AAC Audio Main", "aac|aac2m", "mp4a", "audio/aac", GF_CODECID_AAC_MPEG4, .unframe=GF_TRUE},
+	{GF_CODECID_AAC_MPEG2_LCP, GF_CODECID_AAC_MPEG2_LCP, GF_STREAM_AUDIO, "MPEG-2 AAC Audio Low Complexity", "aac|aac2l", "mp4a", "audio/aac", GF_CODECID_AAC_MPEG4, .unframe=GF_TRUE},
+	{GF_CODECID_AAC_MPEG2_SSRP, GF_CODECID_AAC_MPEG2_SSRP, GF_STREAM_AUDIO, "MPEG-2 AAC Audio Scalable Sampling Rate", "aac|aac2s", "mp4a", "audio/aac", GF_CODECID_AAC_MPEG4, .unframe=GF_TRUE},
+	{GF_CODECID_MPEG_AUDIO, GF_CODECID_MPEG_AUDIO, GF_STREAM_AUDIO, "MPEG-1 Audio", "mp3|m1a", ".mp3", "audio/mp3", .unframe=GF_TRUE},
+	{GF_CODECID_MPEG2_PART3, GF_CODECID_MPEG2_PART3, GF_STREAM_AUDIO, "MPEG-2 Audio", "mp2", ".mp3", "audio/mpeg", .unframe=GF_TRUE},
+	{GF_CODECID_MPEG_AUDIO_L1, GF_CODECID_MPEG_AUDIO, GF_STREAM_AUDIO, "MPEG-1 Audio Layer 1", "mp1", ".mp3", "audio/mpeg", .unframe=GF_TRUE},
+	{GF_CODECID_S263, 0, GF_STREAM_VISUAL, "H263 Video", "h263", "s263", "video/h263", .alt_codecid=GF_CODECID_H263, .unframe=GF_TRUE},
+	{GF_CODECID_H263, 0, GF_STREAM_VISUAL, "H263 Video", "h263", "h263", "video/h263", .alt_codecid=GF_CODECID_S263, .unframe=GF_TRUE},
+	{GF_CODECID_HEVC_TILES, 0, GF_STREAM_VISUAL, "HEVC tiles Video", "hvt1", "hvt1", "video/x-hevc-tiles", .alt_codecid=GF_CODECID_HEVC, .unframe=GF_TRUE},
 
 	{GF_CODECID_EVRC, 0xA0, GF_STREAM_AUDIO, "EVRC Voice", "evc|evrc", "sevc", "audio/evrc"},
 	{GF_CODECID_SMV, 0xA1, GF_STREAM_AUDIO, "SMV Voice", "smv", "ssmv", "audio/smv"},
@@ -95,9 +97,9 @@
 	{GF_CODECID_EVRC_PV, 0, GF_STREAM_AUDIO, "EVRC (PacketVideo MUX) Audio", "qcp|evrcpv", "sevc", "audio/evrc"},
 	{GF_CODECID_SMPTE_VC1, 0xA3, GF_STREAM_VISUAL, "SMPTE VC-1 Video", "vc1", "vc1 ", "video/vc1"},
 	{GF_CODECID_DIRAC, 0xA4, GF_STREAM_VISUAL, "Dirac Video", "dirac", NULL, "video/dirac"},
-	{GF_CODECID_AC3, 0xA5, GF_STREAM_AUDIO, "AC3 Audio", "ac3", "ac-3", "audio/ac3"},
-	{GF_CODECID_EAC3, 0xA6, GF_STREAM_AUDIO, "Enhanced AC3 Audio", "eac3", "ec-3", "audio/eac3"},
-	{GF_CODECID_TRUEHD, 0, GF_STREAM_AUDIO, "Dolby TrueHD", "mlp", "mlpa", "audio/truehd"},
+	{GF_CODECID_AC3, 0xA5, GF_STREAM_AUDIO, "AC3 Audio", "ac3", "ac-3", "audio/ac3", .unframe=GF_TRUE},
+	{GF_CODECID_EAC3, 0xA6, GF_STREAM_AUDIO, "Enhanced AC3 Audio", "eac3", "ec-3", "audio/eac3", .unframe=GF_TRUE},
+	{GF_CODECID_TRUEHD, 0, GF_STREAM_AUDIO, "Dolby TrueHD", "mlp", "mlpa", "audio/truehd", .unframe=GF_TRUE},
 	{GF_CODECID_DRA, 0xA7, GF_STREAM_AUDIO, "DRA Audio", "dra", NULL, "audio/dra"},
 	{GF_CODECID_G719, 0xA8, GF_STREAM_AUDIO, "G719 Audio", "g719", NULL, "audio/g719"},
 	{GF_CODECID_DTS_CA, 0xA9, GF_STREAM_AUDIO, "DTS Coherent Acoustics Audio", "dstca", NULL, "audio/dts"},
@@ -109,17 +111,18 @@
 	{GF_CODECID_SVG, 0, GF_STREAM_PRIVATE_SCENE, "SVG over RTP", "svgr", NULL, "application/x-svg-rtp"},
 	{GF_CODECID_SVG_GZ, 0, GF_STREAM_PRIVATE_SCENE, "SVG+gz over RTP", "svgzr", NULL, "application/x-svgz-rtp"},
 	{GF_CODECID_DIMS, 0, GF_STREAM_PRIVATE_SCENE, "3GPP DIMS Scene", "dims", NULL, "application/3gpp-dims"},
-	{GF_CODECID_WEBVTT, 0, GF_STREAM_TEXT, "WebVTT Text", "vtt", "wvtt", "text/webtvv"},
+	{GF_CODECID_WEBVTT, 0, GF_STREAM_TEXT, "WebVTT Text", "vtt", "wvtt", "text/vtt", .unframe=GF_TRUE},
 	{GF_CODECID_SIMPLE_TEXT, 0, GF_STREAM_TEXT, "Simple Text Stream", "txt", "stxt", "text/subtitle"},
 	{GF_CODECID_META_TEXT, 0, GF_STREAM_METADATA, "Metadata Text Stream", "mtxt", "mett", "application/text"},
 	{GF_CODECID_META_XML, 0, GF_STREAM_METADATA, "Metadata XML Stream", "mxml", "metx", "application/text+xml"},
 	{GF_CODECID_SUBS_TEXT, 0, GF_STREAM_TEXT, "Subtitle text Stream", "subs", "sbtt", "text/text"},
-	{GF_CODECID_SUBS_XML, 0, GF_STREAM_TEXT, "Subtitle XML Stream", "subx", "stpp", "text/text+xml"},
-	{GF_CODECID_TX3G, 0, GF_STREAM_TEXT, "Subtitle/text 3GPP/Apple Stream", "tx3g", "tx3g", "quicktime/text"},
+	{GF_CODECID_SUBS_XML, 0, GF_STREAM_TEXT, "Subtitle XML Stream", "subx", "stpp", "text/text+xml", .unframe=GF_TRUE},
+	{GF_CODECID_TX3G, 0, GF_STREAM_TEXT, "Subtitle/text 3GPP/Apple Stream", "tx3g", "tx3g", "quicktime/text", .unframe=GF_TRUE},
+	{GF_CODECID_SUBS_SSA, 0, GF_STREAM_TEXT, "SSA /ASS Subtitles", "ssa", NULL, "text/x-ssa"},
 	{GF_CODECID_THEORA, 0xDF, GF_STREAM_VISUAL, "Theora Video", "theo|theora", NULL, "video/theora"},
 	{GF_CODECID_VORBIS, 0xDD, GF_STREAM_AUDIO, "Vorbis Audio", "vorb|vorbis", NULL, "audio/vorbis"},
 	{GF_CODECID_OPUS, 0xDE, GF_STREAM_AUDIO, "Opus Audio", "opus", NULL, "audio/opus"},
-	{GF_CODECID_FLAC, 0, GF_STREAM_AUDIO, "Flac Audio", "flac", "fLaC", "audio/flac"},
+	{GF_CODECID_FLAC, 0, GF_STREAM_AUDIO, "Flac Audio", "flac", "fLaC", "audio/flac", .unframe=GF_TRUE},
 	{GF_CODECID_SPEEX, 0, GF_STREAM_AUDIO, "Speex Audio", "spx|speex", NULL, "audio/speex"},
 	{GF_CODECID_SUBPIC, 0xE0, GF_STREAM_TEXT, "VobSub Subtitle", "vobsub", NULL, "text/x-vobsub"},
 	{GF_CODECID_SUBPIC, 0xE0, GF_STREAM_ND_SUBPIC, "VobSub Subtitle", "vobsub", NULL, "text/x-vobsub"},
@@ -139,28 +142,34 @@
 	{GF_CODECID_FLASH, 0, GF_STREAM_SCENE, "Adobe Flash", "swf", NULL, "audio/pcm"},
 	{GF_CODECID_RAW, 0, GF_STREAM_UNKNOWN, "Raw media", "raw", NULL, "*/*"},
 
-	{GF_CODECID_AV1, 0, GF_STREAM_VISUAL, "AOM AV1 Video", "av1|ivf|obu|av1b", NULL, "video/av1"},
+	{GF_CODECID_AV1, 0, GF_STREAM_VISUAL, "AOM AV1 Video", "av1|ivf|obu|av1b", NULL, "video/av1", .unframe=GF_TRUE},
 	{GF_CODECID_VP8, 0, GF_STREAM_VISUAL, "VP8 Video", "vp8|ivf", NULL, "video/vp8"},
-	{GF_CODECID_VP9, 0, GF_STREAM_VISUAL, "VP9 Video", "vp9|ivf", NULL, "video/vp9"},
+	{GF_CODECID_VP9, 0, GF_STREAM_VISUAL, "VP9 Video", "vp9|ivf", NULL, "video/vp9", .unframe=GF_TRUE},
 	{GF_CODECID_VP10, 0, GF_STREAM_VISUAL, "VP10 Video", "vp10|ivf", NULL, "video/vp10"},
 
-	{GF_CODECID_MPHA, 0, GF_STREAM_AUDIO, "MPEG-H Audio", "mhas", "mha1", "audio/x-mpegh"},
-	{GF_CODECID_MHAS, 0, GF_STREAM_AUDIO, "MPEG-H AudioMux", "mhas", "mhm1", "audio/x-mhas"},
+	{GF_CODECID_MPHA, 0, GF_STREAM_AUDIO, "MPEG-H Audio", "mhas", "mha1", "audio/x-mpegh", .unframe=GF_TRUE},
+	{GF_CODECID_MHAS, 0, GF_STREAM_AUDIO, "MPEG-H AudioMux", "mhas", "mhm1", "audio/x-mhas", .unframe=GF_TRUE},
 
-	{GF_CODECID_APCH, 0, GF_STREAM_VISUAL, "ProRes Video 422 HQ", "prores|apch", "apch", "video/prores"},
-	{GF_CODECID_APCO, 0, GF_STREAM_VISUAL, "ProRes Video 422 Proxy", "prores|apco", "apco", "video/prores", GF_CODECID_APCH},
-	{GF_CODECID_APCN, 0, GF_STREAM_VISUAL, "ProRes Video 422 STD", "prores|apcn", "apcn", "video/prores", GF_CODECID_APCH},
-	{GF_CODECID_APCS, 0, GF_STREAM_VISUAL, "ProRes Video 422 LT", "prores|apcs", "apcs", "video/prores", GF_CODECID_APCH},
-	{GF_CODECID_AP4X, 0, GF_STREAM_VISUAL, "ProRes Video 4444 XQ", "prores|ap4x", "ap4x", "video/prores", GF_CODECID_APCH},
-	{GF_CODECID_AP4H, 0, GF_STREAM_VISUAL, "ProRes Video 4444", "prores|ap4h", "ap4h", "video/prores", GF_CODECID_APCH},
+	{GF_CODECID_APCH, 0, GF_STREAM_VISUAL, "ProRes Video 422 HQ", "prores|apch", "apch", "video/prores", .unframe=GF_TRUE},
+	{GF_CODECID_APCO, 0, GF_STREAM_VISUAL, "ProRes Video 422 Proxy", "prores|apco", "apco", "video/prores", GF_CODECID_APCH, .unframe=GF_TRUE},
+	{GF_CODECID_APCN, 0, GF_STREAM_VISUAL, "ProRes Video 422 STD", "prores|apcn", "apcn", "video/prores", GF_CODECID_APCH, .unframe=GF_TRUE},
+	{GF_CODECID_APCS, 0, GF_STREAM_VISUAL, "ProRes Video 422 LT", "prores|apcs", "apcs", "video/prores", GF_CODECID_APCH, .unframe=GF_TRUE},
+	{GF_CODECID_AP4X, 0, GF_STREAM_VISUAL, "ProRes Video 4444 XQ", "prores|ap4x", "ap4x", "video/prores", GF_CODECID_APCH, .unframe=GF_TRUE},
+	{GF_CODECID_AP4H, 0, GF_STREAM_VISUAL, "ProRes Video 4444", "prores|ap4h", "ap4h", "video/prores", GF_CODECID_APCH, .unframe=GF_TRUE},
 	{GF_CODECID_FFMPEG, 0, GF_STREAM_UNKNOWN, "FFMPEG unmapped codec", "ffmpeg", NULL, NULL},
 
 	{GF_CODECID_TMCD, 0, GF_STREAM_METADATA, "QT TimeCode", "tmcd", NULL, NULL},
-	{GF_CODECID_VVC, 0, GF_STREAM_VISUAL, "VVC Video", "vvc|266|h266", "vvc1", "video/vvc"},
-	{GF_CODECID_VVC_SUBPIC, 0, GF_STREAM_VISUAL, "VVC Subpicture Video", "vvs1", "vvs1", "video/x-vvc-subpic", .alt_codecid=GF_CODECID_VVC},
-	{GF_CODECID_USAC, GF_CODECID_AAC_MPEG4, GF_STREAM_AUDIO, "xHEAAC / USAC Audio", "usac|xheaac", "mp4a", "audio/x-xheaac"},
-	{GF_CODECID_V210, 0, GF_STREAM_VISUAL, "v210 YUV 422 10 bits", "v210", "v210", "video/x-raw-v210"},
+	{GF_CODECID_VVC, 0, GF_STREAM_VISUAL, "VVC Video", "vvc|266|h266", "vvc1", "video/vvc", .unframe=GF_TRUE},
+	{GF_CODECID_VVC_SUBPIC, 0, GF_STREAM_VISUAL, "VVC Subpicture Video", "vvs1", "vvs1", "video/x-vvc-subpic", .alt_codecid=GF_CODECID_VVC, .unframe=GF_TRUE},
+	{GF_CODECID_USAC, GF_CODECID_AAC_MPEG4, GF_STREAM_AUDIO, "xHEAAC / USAC Audio", "usac|xheaac", "mp4a", "audio/x-xheaac", .unframe=GF_TRUE},
 	{GF_CODECID_FFV1, 0, GF_STREAM_VISUAL, "FFMPEG Video Codec 1", "ffv1", NULL, "video/x-ffv1"},
+
+	{GF_CODECID_DVB_SUBS, 0, GF_STREAM_TEXT, "DVB Subtitles", "dvbs", NULL, NULL},
+	{GF_CODECID_DVB_TELETEXT, 0, GF_STREAM_TEXT, "DVB-TeleText", "dvbs", NULL, NULL},
+	{GF_CODECID_MSPEG4_V3, 0, GF_STREAM_VISUAL, "MS-MPEG4 V3", "div3", NULL, NULL, GF_CODECID_MSPEG4_V3},
+
+	{GF_CODECID_ALAC, 0, GF_STREAM_AUDIO, "Apple Lossless Audio", "caf", NULL, NULL},
+
 };
 
 
@@ -252,8 +261,6 @@
 	case GF_ISOM_SUBTYPE_VVC1:
 	case GF_ISOM_SUBTYPE_VVI1:
 		return GF_CODECID_VVC;
-	case GF_QT_SUBTYPE_YUV422_10:
-		return GF_CODECID_V210;
 	case GF_ISOM_SUBTYPE_VP08:
 		return GF_CODECID_VP8;
 	case GF_ISOM_SUBTYPE_VP09:
@@ -289,6 +296,15 @@
 		return GF_CODECID_TRUEHD;
 	case GF_ISOM_SUBTYPE_FFV1:
 		return GF_CODECID_FFV1;
+	case GF_ISOM_SUBTYPE_DTSC:
+	case GF_ISOM_SUBTYPE_DTSL:
+	case GF_ISOM_SUBTYPE_DTSH:
+	case GF_ISOM_SUBTYPE_DTSE:
+		return GF_CODECID_DTS_CA;
+	case GF_QT_SUBTYPE_ALAC:
+		return GF_CODECID_ALAC;
+	case GF_ISOM_SUBTYPE_VC1:
+		return GF_CODECID_SMPTE_VC1;
 	default:
 		break;
 	}
@@ -408,6 +424,18 @@
 	return 0;
 }
 
+GF_EXPORT
+Bool gf_codecid_has_unframer(GF_CodecID codecid)
+{
+	u32 i, count = sizeof(CodecRegistry) / sizeof(CodecIDReg);
+	for (i=0; i<count; i++) {
+		if (CodecRegistryi.codecid==codecid) {
+			return CodecRegistryi.unframe;
+		}
+	}
+	return GF_FALSE;
+}
+
 typedef struct
 {
 	u32 st;
@@ -596,7 +624,7 @@
 			return GF_AudioFormatsi.sfmt;
 		i++;
 	}
-	GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Unsupported audio format %s\n", af_name));
+	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("Unsupported audio format %s\n", af_name));
 	return 0;
 }
 
@@ -785,7 +813,9 @@
 GF_EXPORT
 u32 gf_audio_fmt_get_cicp_layout(u32 nb_chan, u32 nb_surr, u32 nb_lfe)
 {
-	if ( !nb_chan && !nb_surr && !nb_lfe) return 0;
+	if (nb_chan <= nb_surr+nb_lfe) return 0;
+	else nb_chan -= nb_surr+nb_lfe;
+	if (!nb_chan && !nb_surr && !nb_lfe) return 0;
 	else if ((nb_chan==1) && !nb_surr && !nb_lfe) return 1;
 	else if ((nb_chan==2) && !nb_surr && !nb_lfe) return 2;
 	else if ((nb_chan==3) && !nb_surr && !nb_lfe) return 3;
@@ -868,7 +898,7 @@
 		if (GF_CICPLayoutsi.cicp == cicp_layout) return GF_CICPLayoutsi.name;
 	}
 	GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Unsupported cicp audio layout value %d\n", cicp_layout));
-	return "unknwon";
+	return "unknown";
 }
 
 GF_EXPORT
@@ -879,7 +909,7 @@
 		if (GF_CICPLayoutsi.channel_mask == ch_layout) return GF_CICPLayoutsi.name;
 	}
 	GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Unsupported audio layout value "LLU"\n", ch_layout));
-	return "unknwon";
+	return "unknown";
 }
 
 GF_EXPORT
@@ -1048,15 +1078,18 @@
 	{GF_PIXEL_YUYV_10, "yuyl", "Packed YUYV 422 10->16 bit"},
 	{GF_PIXEL_YVYU_10, "yvyl", "Packed YVYU 422 10->16 bit"},
 	{GF_PIXEL_NV12, "nv12", "Semi-planar YUV 420 8 bit, Y plane and UV packed plane"},
-	{GF_PIXEL_NV21, "nv21", "Semi-planar YUV 420 8 bit, Y plane and VU packed plane"},
+	{GF_PIXEL_NV21, "nv21", "Semi-planar YVU 420 8 bit, Y plane and VU packed plane"},
 	{GF_PIXEL_NV12_10, "nv1l", "Semi-planar YUV 420 10 bit, Y plane and UV plane"},
-	{GF_PIXEL_NV21_10, "nv2l", "Semi-planar YUV 420 8 bit, Y plane and VU plane"},
+	{GF_PIXEL_NV21_10, "nv2l", "Semi-planar YVU 420 8 bit, Y plane and VU plane"},
 	{GF_PIXEL_YUVA, "yuva", "Planar YUV+alpha 420 8 bit"},
 	{GF_PIXEL_YUVD, "yuvd", "Planar YUV+depth 420 8 bit"},
 	{GF_PIXEL_YUVA444, "yuv444a", "Planar YUV+alpha 444 8 bit", "yp4a"},
 	{GF_PIXEL_YUV444_PACK, "yuv444p", "Packed YUV 444 8 bit", "yv4p"},
+	{GF_PIXEL_VYU444_PACK, "v308", "Packed VYU 444 8 bit"},
 	{GF_PIXEL_YUVA444_PACK, "yuv444ap", "Packed YUV+alpha 444 8 bit", "y4ap"},
-	{GF_PIXEL_YUV444_10_PACK, "yuv444p_10", "Packed YUV 444 10 bit", "y4lp"},
+	{GF_PIXEL_UYVA444_PACK, "v408", "Packed UYV+alpha 444 8 bit"},
+	{GF_PIXEL_YUV444_10_PACK, "v410", "Packed UYV 444 10 bit LE"},
+	{GF_PIXEL_V210, "v210", "Packed UYVY 422 10 bit LE"},
 
 	//first non-yuv format
 	{GF_PIXEL_GREYSCALE, "grey", "Greyscale 8 bit"},
@@ -1077,9 +1110,8 @@
 	{GF_PIXEL_BGRX, "bgrx", "BGRx 32 bits (8 bits / component)"},
 	{GF_PIXEL_RGBD, "rgbd", "RGB+depth 32 bits (8 bits / component)"},
 	{GF_PIXEL_RGBDS, "rgbds", "RGB+depth+bit shape (8 bits / RGB component, 7 bit depth (low bits) + 1 bit shape)"},
-	{GF_PIXEL_RGBS, "rgbs", "RGB 24 bits stereo (side-by-side) - to be removed\n"},
-	{GF_PIXEL_RGBAS, "rgbas", "RGBA 32 bits stereo (side-by-side) - to be removed\n"},
 	{GF_PIXEL_GL_EXTERNAL, "extgl", "External OpenGL texture of unknown format, to be used with samplerExternalOES\n"},
+	{GF_PIXEL_UNCV, "uncv", "Generic uncompressed format ISO/IEC 23001-17"},
 	{0}
 };
 
@@ -1284,7 +1316,6 @@
 	case GF_PIXEL_XBGR:
 	case GF_PIXEL_RGBD:
 	case GF_PIXEL_RGBDS:
-	case GF_PIXEL_RGBAS:
 		stride = no_in_stride ? 4*width : *out_stride;
 		size = stride * height;
 		planes=1;
@@ -1297,7 +1328,6 @@
 		break;
 	case GF_PIXEL_RGB:
 	case GF_PIXEL_BGR:
-	case GF_PIXEL_RGBS:
 		stride = no_in_stride ? 3*width : *out_stride;
 		size = stride * height;
 		planes=1;
@@ -1407,11 +1437,13 @@
 		size = height * stride;
 		break;
 	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
 		stride = no_in_stride ? 3 * width : *out_stride;
 		planes=1;
 		size = height * stride;
 		break;
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 		stride = no_in_stride ? 4 * width : *out_stride;
 		planes=1;
 		size = height * stride;
@@ -1429,6 +1461,17 @@
 		stride_uv = 0;
 		uv_height = 0;
 		break;
+	case GF_PIXEL_V210:
+		if (no_in_stride) {
+			stride = width;
+			while (stride % 48) stride++;
+			stride = stride * 16 / 6; //4 x 32 bits to represent 6 pixels
+		} else {
+			stride = *out_stride;
+		}
+		planes=1;
+		size = height * stride;
+		break;
 	default:
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Unsupported pixel format %s, cannot get size info\n", gf_pixel_fmt_name(pixfmt) ));
 		return GF_FALSE;
@@ -1451,10 +1494,10 @@
 	case GF_PIXEL_RGBA:
 	case GF_PIXEL_ABGR:
 	case GF_PIXEL_BGRA:
-	case GF_PIXEL_RGBAS:
 	case GF_PIXEL_YUVA:
 	case GF_PIXEL_YUVA444:
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 		return GF_TRUE;
 	default:
 		break;
@@ -1476,6 +1519,7 @@
 	case GF_PIXEL_YUYV_10:
 	case GF_PIXEL_YVYU_10:
 	case GF_PIXEL_YUV444_10_PACK:
+	case GF_PIXEL_V210:
 		return 10;
 	default:
 		return 8;
@@ -1504,12 +1548,10 @@
 	case GF_PIXEL_ABGR:
 	case GF_PIXEL_RGBD:
 	case GF_PIXEL_RGBDS:
-	case GF_PIXEL_RGBAS:
 	case GF_PIXEL_RGB_DEPTH:
 		return 4;
 	case GF_PIXEL_RGB:
 	case GF_PIXEL_BGR:
-	case GF_PIXEL_RGBS:
 		return 3;
 	case GF_PIXEL_YUV:
 	case GF_PIXEL_YVU:
@@ -1544,8 +1586,11 @@
 	case GF_PIXEL_YVYU_10:
 		return 2;
 	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 	case GF_PIXEL_YUV444_10_PACK:
+	case GF_PIXEL_V210:
 		return 1;
 
 	case GF_PIXEL_GL_EXTERNAL:
@@ -1583,15 +1628,11 @@
 		return 4;
 	case GF_PIXEL_RGBDS:
 		return 5;
-	case GF_PIXEL_RGBAS:
-		return 5;
 	case GF_PIXEL_RGB_DEPTH:
 		return 4;
 	case GF_PIXEL_RGB:
 	case GF_PIXEL_BGR:
 		return 3;
-	case GF_PIXEL_RGBS:
-		return 4;
 	case GF_PIXEL_YUV:
 	case GF_PIXEL_YVU:
 		return 3;
@@ -1627,12 +1668,15 @@
 	case GF_PIXEL_YVYU_10:
 		return 3;
 	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
 		return 3;
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 		return 4;
 	case GF_PIXEL_YUV444_10_PACK:
 		return 3;
-
+	case GF_PIXEL_V210:
+		return 3;
 	case GF_PIXEL_GL_EXTERNAL:
 		return 1;
 	default:
@@ -1650,17 +1694,18 @@
 	{GF_PIXEL_RGB, GF_QT_SUBTYPE_RAW},
 	{GF_PIXEL_YUYV, GF_QT_SUBTYPE_YUYV},
 	{GF_PIXEL_UYVY, GF_QT_SUBTYPE_UYVY},
-	{GF_PIXEL_YUV444_PACK, GF_QT_SUBTYPE_YUV444},
-	{GF_PIXEL_YUVA444_PACK, GF_QT_SUBTYPE_YUVA444},
+	{GF_PIXEL_VYU444_PACK, GF_QT_SUBTYPE_YUV444},
+	{GF_PIXEL_UYVA444_PACK, GF_QT_SUBTYPE_YUVA444},
 	{GF_PIXEL_UYVY_10, GF_QT_SUBTYPE_YUV422_16},
 	{GF_PIXEL_YVYU, GF_QT_SUBTYPE_YVYU},
 	{GF_PIXEL_YUV444_10_PACK, GF_QT_SUBTYPE_YUV444_10},
 	{GF_PIXEL_YUV, GF_QT_SUBTYPE_YUV420},
 	{GF_PIXEL_YUV, GF_QT_SUBTYPE_I420},
 	{GF_PIXEL_YUV, GF_QT_SUBTYPE_IYUV},
-	{GF_PIXEL_YVU, GF_QT_SUBTYPE_YV12},
+	{GF_PIXEL_YUV, GF_QT_SUBTYPE_YV12},
 	{GF_PIXEL_RGBA, GF_QT_SUBTYPE_RGBA},
-	{GF_PIXEL_ABGR, GF_QT_SUBTYPE_ABGR}
+	{GF_PIXEL_ABGR, GF_QT_SUBTYPE_ABGR},
+	{GF_PIXEL_V210, GF_QT_SUBTYPE_YUV422_10}
 };
 
 GF_EXPORT
@@ -1680,7 +1725,8 @@
 	for (i=0; i<count; i++) {
 		if (PixelsToQTi.pfmt==pix_fmt) return PixelsToQTi.qt4cc;
 	}
-	GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Unknown mapping to QT/ISOBMFF for pixel format %s\n", gf_pixel_fmt_name(pix_fmt)));
+	//uncomment to see list of unmapped codecs when generating doc
+	//GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Unknown mapping to QT/ISOBMFF for pixel format %s\n", gf_pixel_fmt_name(pix_fmt)));
 	return 0;
 }
 
@@ -1758,7 +1804,8 @@
 	{"thanks", NULL, GF_ISOM_ITUNE_THANKS, 0, GF_ITAG_STR, 0},
 	{"online_info", NULL, GF_ISOM_ITUNE_ONLINE, 0, GF_ITAG_STR, 0},
 	{"exec_producer", NULL, GF_ISOM_ITUNE_EXEC_PRODUCER, 0, GF_ITAG_STR, 0},
-
+	{"genre", NULL, GF_ISOM_ITUNE_GENRE_USER, GF_ID3V2_FRAME_TCON, GF_ITAG_ID3_GENRE, 0},
+	{"location", NULL, GF_ISOM_ITUNE_LOCATION, 0, GF_ITAG_STR, 0},
 };
 
 GF_EXPORT
@@ -1947,7 +1994,7 @@
 			return CICPColorPrimariesi.name;
 		}
 	}
-	return "unknwon";
+	return "unknown";
 }
 
 static char szCICPPrimAllNames1024;
@@ -2017,7 +2064,7 @@
 			return CICPColorTransferi.name;
 		}
 	}
-	return "unknwon";
+	return "unknown";
 }
 
 static char szCICPTFCAllNames1024;
@@ -2078,7 +2125,7 @@
 			return CICPColorMatrixCoefficientsi.name;
 		}
 	}
-	return "unknwon";
+	return "unknown";
 }
 
 static char szCICPMXAllNames1024;

gpac-2.0.0.tar.gz/src/utils/downloader.c -> gpac-2.2.0.tar.gz/src/utils/downloader.c Changed

@@ -33,8 +33,6 @@
 #include <gpac/cache.h>
 #include <gpac/filters.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 #ifdef GPAC_HAS_SSL
 #include <openssl/ssl.h>
 #include <openssl/x509.h>
@@ -71,13 +69,15 @@
 #define SIZE_IN_STREAM ( 2 << 29 )
 
 
-#define SESSION_RETRY_COUNT	20
+#define SESSION_RETRY_COUNT	10
+#define SESSION_RETRY_SSL	8
 
 #include <gpac/revision.h>
 #define GF_DOWNLOAD_AGENT_NAME		"GPAC/"GPAC_VERSION "-rev" GPAC_GIT_REVISION
 
 //let's be agressive with socket buffer size
 #define GF_DOWNLOAD_BUFFER_SIZE		131072
+#define GF_DOWNLOAD_BUFFER_SIZE_LIMIT_RATE		GF_DOWNLOAD_BUFFER_SIZE/20
 
 
 #ifdef GPAC_HAS_HTTP2
@@ -109,22 +109,16 @@
 
 static void gf_dm_connect(GF_DownloadSession *sess);
 GF_Err gf_dm_sess_send(GF_DownloadSession *sess, u8 *data, u32 size);
+GF_Err gf_dm_sess_flush_async(GF_DownloadSession *sess, Bool no_select);
 
 /*internal flags*/
 enum
 {
 	GF_DOWNLOAD_SESSION_USE_SSL = 1<<10,
-	GF_DOWNLOAD_SESSION_THREAD_DEAD = 1<<11
+	GF_DOWNLOAD_SESSION_THREAD_DEAD = 1<<11,
+	GF_DOWNLOAD_SESSION_SSL_FORCED = 1<<12,
 };
 
-typedef struct __gf_user_credentials
-{
-	char site1024;
-	char username50;
-	char digest1024;
-	Bool valid;
-} gf_user_credentials_struct;
-
 enum REQUEST_TYPE
 {
 	GET = 0,
@@ -175,7 +169,7 @@
 	char *orig_url;
 	char *orig_url_before_redirect;
 	char *remote_path;
-	gf_user_credentials_struct * creds;
+	GF_UserCredentials * creds;
 	char cookieGF_MAX_PATH;
 	DownloadedCacheEntry cache_entry;
 	Bool reused_cache_entry, from_cache_only;
@@ -220,6 +214,7 @@
 	Bool disable_cache;
 	/*forces notification of data exchange to be sent regardless of threading mode*/
 	Bool force_data_write_callback;
+	u32 connect_pending;
 #ifdef GPAC_HAS_SSL
 	SSL *ssl;
 #endif
@@ -243,7 +238,7 @@
 	char *remaining_data;
 	u32 remaining_data_size;
 
-	u32 head_timeout, request_timeout;
+	u32 conn_timeout, request_timeout;
 
 	Bool local_cache_only;
 	Bool server_mode;
@@ -262,8 +257,14 @@
 
 	u32 connection_timeout_ms;
 
+	u8 *async_req_reply;
+	u32 async_req_reply_size;
+	u8 *async_buf;
+	u32 async_buf_size, async_buf_alloc;
+
+	GF_SockGroup *sock_group;
 #ifdef GPAC_HAS_HTTP2
-	//HTTP/2 session used by this download session. f not NULL, the mutex, socket and ssl context are moved along sessions
+	//HTTP/2 session used by this download session. If not NULL, the mutex, socket and ssl context are moved along sessions
 	GF_H2_Session *h2_sess;
 	int32_t h2_stream_id;
 	h2_reagg_buffer h2_buf;
@@ -272,19 +273,36 @@
 	u8 *h2_send_data;
 	u32 h2_send_data_len;
 
+	u8 *h2_local_buf;
+	u32 h2_local_buf_len, h2_local_buf_alloc;
+
 	u8 *h2_upgrade_settings;
 	u32 h2_upgrade_settings_len;
 	u8 h2_headers_seen, h2_ready_to_send, h2_is_eos, h2_data_paused, h2_upgrade_state, h2_data_done, h2_switch_sess;
 #endif
 };
+static GF_Err dm_sess_write(GF_DownloadSession *sess, const u8 *buffer, u32 size);
 
+void dm_sess_sk_del(GF_DownloadSession *sess)
+{
+	if (sess->sock) {
+		GF_Socket *sock = sess->sock;
+		sess->sock = NULL;
+		GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("Downloader closing socket\n"));
+		if (sess->sock_group) gf_sk_group_unregister(sess->sock_group, sock);
+		gf_sk_del(sock);
+#ifdef GPAC_HAS_HTTP2
+		sess->h2_upgrade_state = 0;
+#endif
+	}
+}
 
 struct __gf_download_manager
 {
 	GF_Mutex *cache_mx;
 	char *cache_directory;
 
-	Bool (*get_user_password)(void *usr_cbk, const char *site_url, char *usr_name, char *password);
+	gf_dm_get_usr_pass get_user_password;
 	void *usr_cbk;
 
 	GF_List *sessions;
@@ -332,6 +350,21 @@
 
 #endif
 
+#if 0
+#define SET_LAST_ERR(_e) \
+	{\
+	GF_Err __e = _e;\
+	if (__e==GF_IP_NETWORK_EMPTY) {\
+		assert(sess->status != GF_NETIO_STATE_ERROR); \
+	}\
+	sess->last_error = _e;\
+	}\
+
+#else
+
+#define SET_LAST_ERR(_e) sess->last_error = _e;
+
+#endif
 
 /*HTTP2 callbacks*/
 #ifdef GPAC_HAS_HTTP2
@@ -360,11 +393,8 @@
 
 	gf_list_del_item(h2_sess->sessions, sess);
 	if (!gf_list_count(h2_sess->sessions)) {
-		if (sess->sock) {
-			GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("Downloader closing socket\n"));
-			gf_sk_del(sess->sock);
-			sess->sock = NULL;
-		}
+		dm_sess_sk_del(sess);
+
 #ifdef GPAC_HAS_SSL
 		if (sess->ssl) {
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("Downloader shut down SSL context\n"));
@@ -385,6 +415,15 @@
 		assert(asess->sock);
 
 		h2_sess->net_sess = asess;
+		//swap async buf if any to new active session
+		if (sess->async_buf_alloc) {
+			assert(!asess->async_buf);
+			asess->async_buf = sess->async_buf;
+			asess->async_buf_alloc = sess->async_buf_alloc;
+			asess->async_buf_size = sess->async_buf_size;
+			sess->async_buf_alloc = sess->async_buf_size = 0;
+			sess->async_buf = NULL;
+		}
 		sess->sock = NULL;
 #ifdef GPAC_HAS_SSL
 		sess->ssl = NULL;
@@ -405,11 +444,13 @@
 	assert(sess->h2_sess);
 	int rv = nghttp2_session_send(sess->h2_sess->ng_sess);
 	if (rv != 0) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP/2 session_send error : %s\n", nghttp2_strerror(rv)));
+		if (sess->last_error != GF_IP_CONNECTION_CLOSED) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP/2 session_send error : %s\n", nghttp2_strerror(rv)));
+		}
 		if (sess->status != GF_NETIO_STATE_ERROR) {
 			sess->status = GF_NETIO_STATE_ERROR;
-			if (rv==NGHTTP2_ERR_NOMEM) sess->last_error = GF_OUT_OF_MEM;
-			else sess->last_error = GF_SERVICE_ERROR;
+			if (rv==NGHTTP2_ERR_NOMEM) SET_LAST_ERR(GF_OUT_OF_MEM)
+			else SET_LAST_ERR(GF_SERVICE_ERROR)
 		}
 		return sess->last_error;
 	}
@@ -439,6 +480,7 @@
 		assert(first_not_assigned->data_io.source.ptr);
 		first_not_assigned->total_size = first_not_assigned->bytes_done = 0;
 		first_not_assigned->status = GF_NETIO_CONNECTED;
+		first_not_assigned->h2_data_done = 0;
 		return first_not_assigned;
 	}
 	return NULL;
@@ -497,8 +539,9 @@
 			par_sess->user_proc(par_sess->usr_cbk, &param);
 			par_sess->in_callback = GF_FALSE;
 
-			if (param.error == GF_OK)
+			if (param.error == GF_OK) {
 				sess = h2_get_session(user_data, frame->hd.stream_id, GF_FALSE);
+			}
 		}
 
 		if (!sess)
@@ -545,7 +588,7 @@
 	case NGHTTP2_DATA:
 		if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
 			sess = h2_get_session(user_data, frame->hd.stream_id, GF_FALSE);
-			//if no session with such ID this means we got all our bytes and considered the session done, do not throw and error
+			//if no session with such ID this means we got all our bytes and considered the session done, do not throw an error
 			if (sess) {
 				GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("HTTP/2 stream_id %d (%s) data done\n", frame->hd.stream_id, sess->remote_path ? sess->remote_path : sess->orig_url));
 				sess->h2_data_done = 1;
@@ -608,7 +651,7 @@
 		sess->h2_sess->do_shutdown = GF_TRUE;
 		sess->h2_switch_sess = GF_TRUE;
 		sess->status = GF_NETIO_SETUP;
-		sess->last_error = GF_OK;
+		SET_LAST_ERR(GF_OK)
 		gf_mx_v(sess->mx);
 		return 0;
 	}
@@ -616,7 +659,7 @@
 	if (error_code) {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP/2 stream_id %d (%s) closed with error_code=%d\n", stream_id, sess->remote_path ? sess->remote_path : sess->orig_url, error_code));
 		sess->status = GF_NETIO_STATE_ERROR;
-		sess->last_error = GF_IP_NETWORK_FAILURE;
+		SET_LAST_ERR(GF_IP_NETWORK_FAILURE)
 	} else {
 		GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("HTTP/2 stream_id %d (%s) closed\n", stream_id, sess->remote_path ? sess->remote_path : sess->orig_url));
 		//keep status in DATA_EXCHANGE as this frame might have been pushed while processing another session
@@ -629,37 +672,23 @@
 
 static int h2_error_callback(nghttp2_session *session, const char *msg, size_t len, void *user_data)
 {
-	GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP/2 error %s\n", msg));
+	if (session)
+		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP/2 error %s\n", msg));
 	return 0;
 }
 
 static ssize_t h2_write_data(GF_DownloadSession *sess, const uint8_t *data, size_t length)
 {
-	GF_Err e;
-#ifdef GPAC_HAS_SSL
-	if (sess->ssl) {
-		assert(length);
-		int res = SSL_write(sess->ssl, data, (int) length);
-		if (res <= 0) {
-			int err = SSL_get_error(sess->ssl, res);
-			if (err == SSL_ERROR_WANT_WRITE || err == SSL_ERROR_WANT_READ) {
-				return NGHTTP2_ERR_WOULDBLOCK;
-			} else {
-				//err = errno;
-				return NGHTTP2_ERR_SESSION_CLOSING;
-			}
-		}
-		return res;
-	}
-#endif
-
-	e = gf_sk_send(sess->sock, data, (u32) length);
+	GF_Err e = dm_sess_write(sess, data, (u32) length);
 	switch (e) {
 	case GF_OK:
 		return length;
-	case GF_IP_SOCK_WOULD_BLOCK:
+	case GF_IP_NETWORK_EMPTY:
+		if (sess->flags & GF_NETIO_SESSION_NO_BLOCK)
+			return length;
 		return NGHTTP2_ERR_WOULDBLOCK;
 	case GF_IP_CONNECTION_CLOSED:
+		SET_LAST_ERR(GF_IP_CONNECTION_CLOSED)
 		return NGHTTP2_ERR_EOF;
 	default:
 		break;
@@ -692,6 +721,7 @@
 	if (!sess->h2_send_data_len) {
 		sess->h2_send_data = NULL;
 		if (sess->h2_is_eos) {
+			GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("HTTP/2 send EOS for stream_id %d\n", sess->h2_stream_id));
 			*data_flags = NGHTTP2_DATA_FLAG_EOF;
 			return 0;
 		}
@@ -708,46 +738,76 @@
 	}
 
 	*data_flags = NGHTTP2_DATA_FLAG_NO_COPY;
-	if (sess->h2_send_data_len > length)
+	if (sess->h2_send_data_len > length) {
 		return length;
+	}
 	return sess->h2_send_data_len;
 }
 
-static void h2_flush_send(GF_DownloadSession *sess)
+static void h2_flush_send(GF_DownloadSession *sess, Bool flush_local_buf)
 {
 	char h2_flush1024;
 	u32 res;
 
 	while (sess->h2_send_data) {
 		GF_Err e;
-		h2_session_send(sess);
-		//read any frame pending from remote peer (window update and co)
-		e = gf_dm_read_data(sess, h2_flush, 1023, &res);
-		if ((e<0) && (e != GF_IP_NETWORK_EMPTY) && (e != GF_IP_SOCK_WOULD_BLOCK)) {
-			sess->status = GF_NETIO_STATE_ERROR;
-			sess->last_error = e;
-			break;
+		u32 nb_bytes = sess->h2_send_data_len;
+
+		if (!sess->h2_local_buf_len || flush_local_buf) {
+			//read any frame pending from remote peer (window update and co)
+			e = gf_dm_read_data(sess, h2_flush, 1023, &res);
+			if ((e<0) && (e != GF_IP_NETWORK_EMPTY)) {
+				sess->status = GF_NETIO_STATE_ERROR;
+				SET_LAST_ERR(sess->last_error)
+				break;
+			}
+
+			h2_session_send(sess);
+
+			//error or regular eos
+			if (!sess->h2_stream_id)
+				break;
+			if (sess->status==GF_NETIO_STATE_ERROR)
+				break;
 		}
 
-		//error or regular eos
-		if (!sess->h2_stream_id)
-			break;
-		if (sess->status==GF_NETIO_STATE_ERROR)
-			break;
+		if (nb_bytes > sess->h2_send_data_len) continue;
+		if (!(sess->flags & GF_NETIO_SESSION_NO_BLOCK)) continue;
+
+		if (flush_local_buf) return;
+
+		//stream will now block, no choice but do a local copy...
+		if (sess->h2_local_buf_len + nb_bytes > sess->h2_local_buf_alloc) {
+			sess->h2_local_buf_alloc = sess->h2_local_buf_len + nb_bytes;
+			sess->h2_local_buf = gf_realloc(sess->h2_local_buf, sess->h2_local_buf_alloc);
+			if (!sess->h2_local_buf) {
+				sess->status = GF_NETIO_STATE_ERROR;
+				SET_LAST_ERR(sess->last_error)
+				break;
+			}
+		}
+		memcpy(sess->h2_local_buf + sess->h2_local_buf_len, sess->h2_send_data, nb_bytes);
+		sess->h2_local_buf_len+=nb_bytes;
+		sess->h2_send_data = NULL;
+		sess->h2_send_data_len = 0;
 	}
 }
 
 static char padding256;
 
 static int h2_send_data_callback(nghttp2_session *session, nghttp2_frame *frame, const uint8_t *framehd, size_t length, nghttp2_data_source *source, void *user_data)
-{	ssize_t rv;
+{
+	ssize_t rv;
 	GF_DownloadSession *sess = (GF_DownloadSession *) source->ptr;
 
 	assert(sess->h2_send_data_len);
 	assert(sess->h2_send_data_len >= length);
 
 	rv = h2_write_data(sess, (u8 *) framehd, 9);
-	if (rv<0) goto err;
+	if (rv<0) {
+		if (rv==NGHTTP2_ERR_WOULDBLOCK) return NGHTTP2_ERR_WOULDBLOCK;
+		goto err;
+	}
 
 	if (frame->data.padlen > 0) {
 		u32 padlen = (u32) frame->data.padlen - 1;
@@ -763,7 +823,7 @@
 err:
 
 	sess->status = GF_NETIO_STATE_ERROR;
-	sess->last_error = GF_IP_NETWORK_FAILURE;
+	SET_LAST_ERR(sess->last_error)
 	return NGHTTP2_ERR_CALLBACK_FAILURE;
 }
 
@@ -820,7 +880,7 @@
 
 			if (rv) {
 				sess->status = GF_NETIO_STATE_ERROR;
-				sess->last_error = (rv==NGHTTP2_ERR_NOMEM) ? GF_OUT_OF_MEM : GF_REMOTE_SERVICE_ERROR;
+				SET_LAST_ERR( (rv==NGHTTP2_ERR_NOMEM) ? GF_OUT_OF_MEM : GF_REMOTE_SERVICE_ERROR)
 				return;
 			}
 		}
@@ -830,7 +890,7 @@
 	rv = nghttp2_submit_settings(sess->h2_sess->ng_sess, NGHTTP2_FLAG_NONE, iv, GF_ARRAY_LENGTH(iv));
 	if (rv != 0) {
 		sess->status = GF_NETIO_STATE_ERROR;
-		sess->last_error = (rv==NGHTTP2_ERR_NOMEM) ? GF_OUT_OF_MEM : GF_SERVICE_ERROR;
+		SET_LAST_ERR((rv==NGHTTP2_ERR_NOMEM) ? GF_OUT_OF_MEM : GF_SERVICE_ERROR)
 		return;
 	}
 	h2_session_send(sess);
@@ -991,85 +1051,197 @@
 /*returns 1 if cache is currently open for write*/
 Bool gf_cache_is_in_progress(const DownloadedCacheEntry entry);
 
+#include <gpac/crypt.h>
+
+static GF_Err gf_user_credentials_save_digest( GF_DownloadManager * dm, GF_UserCredentials * creds, const char * password, Bool store_info);
+
 /**
 * Find a User's credentials for a given site
 */
-static gf_user_credentials_struct* gf_find_user_credentials_for_site(GF_DownloadManager *dm, const char *server_name) {
+GF_UserCredentials* gf_user_credentials_find_for_site(GF_DownloadManager *dm, const char *server_name, const char *user_name)
+{
+	GF_UserCredentials * cred;
 	u32 count, i;
 	if (!dm || !dm->credentials || !server_name || !strlen(server_name))
 		return NULL;
 	count = gf_list_count( dm->credentials);
 	for (i = 0 ; i < count; i++) {
-		gf_user_credentials_struct * cred = (gf_user_credentials_struct*)gf_list_get(dm->credentials, i );
+		cred = (GF_UserCredentials*)gf_list_get(dm->credentials, i );
 		assert( cred );
-		if (!strcmp(cred->site, server_name))
+		if (strcmp(cred->site, server_name))
+			continue;
+
+		if (!user_name || !strcmp(user_name, cred->username))
+			return cred;
+	}
+
+#ifndef GPAC_DISABLE_CRYPTO
+	char *key = (char*) gf_opts_get_key("credentials", server_name);
+	if (key) {
+		bin128 k;
+		const char *credk = gf_opts_get_key("core", "cred");
+		if (credk) {
+			FILE *f = gf_fopen(credk, "r");
+			if (f) {
+				gf_fread(k, 16, f);
+				gf_fclose(f);
+			} else {
+				credk = NULL;
+			}
+		}
+		char *sep = credk ? strrchr(key, ':') : NULL;
+		if (sep) {
+			char szP1024;
+			GF_SAFEALLOC(cred, GF_UserCredentials);
+			if (!cred) return NULL;
+			cred->dm = dm;
+			sep0 = 0;
+			strcpy(cred->username, key);
+			strcpy(szP, sep+1);
+			sep0 = ':';
+
+			GF_Crypt *gfc = gf_crypt_open(GF_AES_128, GF_CTR);
+			gf_crypt_init(gfc, k, NULL);
+			gf_crypt_decrypt(gfc, szP, (u32) strlen(szP));
+			gf_crypt_close(gfc);
+			gf_user_credentials_save_digest(dm, cred, szP, GF_FALSE);
 			return cred;
+		}
 	}
+#endif
 	return NULL;
 }
-
 /**
 * \brief Saves the digest for authentication of password and username
 \param dm The download manager
 \param creds The credentials to fill
 \param GF_OK if info has been filled, GF_BAD_PARAM if creds == NULL or dm == NULL, GF_AUTHENTICATION_FAILURE if user did not filled the info.
 */
-static GF_Err gf_user_credentials_save_digest( GF_DownloadManager * dm, gf_user_credentials_struct * creds, const char * password) {
+static GF_Err gf_user_credentials_save_digest( GF_DownloadManager * dm, GF_UserCredentials * creds, const char * password, Bool store_info) {
 	int size;
-	char pass_buf1024, range_buf1024;
+	char *pass_buf = NULL;
+	char range_buf1024;
 	if (!dm || !creds || !password)
 		return GF_BAD_PARAM;
-	sprintf(pass_buf, "%s:%s", creds->username, password);
+	gf_dynstrcat(&pass_buf, creds->username, NULL);
+	gf_dynstrcat(&pass_buf, password, ":");
+	if (!pass_buf) return GF_OUT_OF_MEM;
 	size = gf_base64_encode(pass_buf, (u32) strlen(pass_buf), range_buf, 1024);
+	gf_free(pass_buf);
 	range_bufsize = 0;
 	strcpy(creds->digest, range_buf);
 	creds->valid = GF_TRUE;
+
+#ifndef GPAC_DISABLE_CRYPTO
+	if (store_info) {
+		u32 plen = (u32) strlen(password);
+		char *key = NULL;
+		char szPATHGF_MAX_PATH;
+		const char *cred = gf_opts_get_key("core", "cred");
+		if (!cred) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Core No credential key defined, will not store password - use -cred=PATH_TO_KEY to specify it\n"));
+			return GF_OK;
+		}
+
+		FILE *f = gf_fopen(cred, "r");
+		bin128 k;
+		if (!f) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Core Failed to open credential key %s, will not store password\n", cred));
+			return GF_OK;
+		}
+		u32 ksize = (u32) gf_fread(k, 16, f);
+		gf_fclose(f);
+		if (ksize!=16) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("Core Invalid credential key %s: size %d but expecting 16 bytes, will not store password\n", cred, ksize));
+			return GF_OK;
+		}
+
+		GF_Crypt *gfc = gf_crypt_open(GF_AES_128, GF_CTR);
+		gf_crypt_init(gfc, k, NULL);
+		strcpy(szPATH, password);
+		gf_crypt_encrypt(gfc, szPATH, plen);
+		gf_crypt_close(gfc);
+		szPATHplen = 0;
+		gf_dynstrcat(&key, creds->username, NULL);
+		gf_dynstrcat(&key, szPATH, ":");
+		gf_opts_set_key("credentials", creds->site, key);
+		gf_free(key);
+		gf_opts_save();
+	}
+#endif
 	return GF_OK;
 }
 
+
+static void on_user_pass(void *udta, const char *user, const char *pass, Bool store_info)
+{
+	GF_UserCredentials *creds = (GF_UserCredentials *)udta;
+	if (!creds) return;
+	u32 len = user ? (u32) strlen(user) : 0;
+	if (len && (user != creds->username)) {
+		if (len> 49) len = 49;
+		strncpy(creds->username, user, 49);
+		creds->usernamelen=0;
+	}
+	if (user && pass) {
+		GF_Err e = gf_user_credentials_save_digest((GF_DownloadManager *)creds->dm, creds, pass, store_info);
+		if (e != GF_OK) {
+			creds->valid = GF_FALSE;
+		}
+	} else {
+		creds->valid = GF_FALSE;
+	}
+	creds->req_state = GF_CREDS_STATE_DONE;
+}
+
 /**
 * \brief Asks the user for credentials for given site
 \param dm The download manager
 \param creds The credentials to fill
 \param GF_OK if info has been filled, GF_BAD_PARAM if creds == NULL or dm == NULL, GF_AUTHENTICATION_FAILURE if user did not filled the info.
 */
-static GF_Err gf_user_credentials_ask_password( GF_DownloadManager * dm, gf_user_credentials_struct * creds)
+static GF_Err gf_user_credentials_ask_password( GF_DownloadManager * dm, GF_UserCredentials * creds, Bool secure)
 {
 	char szPASS50;
 	if (!dm || !creds)
 		return GF_BAD_PARAM;
 	memset(szPASS, 0, 50);
-	if (!dm->get_user_password || !dm->get_user_password(dm->usr_cbk, creds->site, creds->username, szPASS)) {
+	if (!dm->get_user_password) return GF_AUTHENTICATION_FAILURE;
+	creds->req_state = GF_CREDS_STATE_PENDING;
+	if (!dm->get_user_password(dm->usr_cbk, secure, creds->site, creds->username, szPASS, on_user_pass, creds)) {
+		creds->req_state = GF_CREDS_STATE_NONE;
 		return GF_AUTHENTICATION_FAILURE;
 	}
-	return gf_user_credentials_save_digest(dm, creds, szPASS);
+	return GF_OK;
 }
 
-static gf_user_credentials_struct * gf_user_credentials_register(GF_DownloadManager * dm, const char * server_name, const char * username, const char * password, Bool valid)
+GF_UserCredentials * gf_user_credentials_register(GF_DownloadManager * dm, Bool secure, const char * server_name, const char * username, const char * password, Bool valid)
 {
-	gf_user_credentials_struct * creds;
+	GF_UserCredentials * creds;
 	if (!dm)
 		return NULL;
 	assert( server_name );
-	creds = gf_find_user_credentials_for_site(dm, server_name);
+	creds = gf_user_credentials_find_for_site(dm, server_name, username);
 	/* If none found, we create one */
 	if (!creds) {
-		creds = (gf_user_credentials_struct*)gf_malloc(sizeof( gf_user_credentials_struct));
-		if (!creds)
-			return NULL;
+		GF_SAFEALLOC(creds, GF_UserCredentials);
+		if (!creds) return NULL;
+		creds->dm = dm;
 		gf_list_insert(dm->credentials, creds, 0);
 	}
 	creds->valid = valid;
-	strncpy(creds->username, username ? username : "", 49);
-	creds->username49 = 0;
+	if (username) {
+		strncpy(creds->username, username, 49);
+		creds->username49 = 0;
+	}
 	strcpy(creds->site, server_name);
 	if (username && password && valid)
-		gf_user_credentials_save_digest(dm, creds, password);
+		gf_user_credentials_save_digest(dm, creds, password, GF_FALSE);
 	else {
-		if (GF_OK != gf_user_credentials_ask_password(dm, creds)) {
+		if (GF_OK != gf_user_credentials_ask_password(dm, creds, secure)) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP,
 			 ("HTTP Failed to get password information.\n"));
-			gf_list_rem( dm->credentials, 0);
+			gf_list_del_item( dm->credentials, creds);
 			gf_free( creds );
 			creds = NULL;
 		}
@@ -1242,19 +1414,20 @@
 }
 #endif //GPAC_DISABLE_LOG
 
-static int ssl_init(GF_DownloadManager *dm, u32 mode)
+void *gf_dm_ssl_init(GF_DownloadManager *dm, u32 mode)
 {
 #if OPENSSL_VERSION_NUMBER > 0x00909000
 	const
 #endif
 	SSL_METHOD *meth;
 
-	if (!dm) return 0;
+	if (!dm) return NULL;
+
 	gf_mx_p(dm->cache_mx);
 	/* The SSL has already been initialized. */
 	if (dm->ssl_ctx) {
 		gf_mx_v(dm->cache_mx);
-		return 1;
+		return dm->ssl_ctx;
 	}
 	/* Init the PRNG. If that fails, bail out. */
 	if (gf_ssl_init_lib()) {
@@ -1320,12 +1493,12 @@
 	allow them in OpenSSL. */
 	SSL_CTX_set_mode(dm->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 	gf_mx_v(dm->cache_mx);
-	return 1;
+	return dm->ssl_ctx;
 error:
 	if (dm->ssl_ctx) SSL_CTX_free(dm->ssl_ctx);
 	dm->ssl_ctx = NULL;
 	gf_mx_v(dm->cache_mx);
-	return 0;
+	return NULL;
 }
 
 #ifdef GPAC_HAS_HTTP2
@@ -1336,8 +1509,10 @@
 #ifndef OPENSSL_NO_NEXTPROTONEG
 static int next_proto_cb(SSL *ssl, const unsigned char **data, unsigned int *len, void *arg)
 {
-	*data = next_proto_list;
-	*len = (unsigned int)next_proto_list_len;
+	if (data && len) {
+		*data = next_proto_list;
+		*len = (unsigned int)next_proto_list_len;
+	}
 	return SSL_TLSEXT_ERR_OK;
 }
 #endif //OPENSSL_NO_NEXTPROTONEG
@@ -1395,6 +1570,13 @@
 		next_proto_list_len = 1 + NGHTTP2_PROTO_VERSION_ID_LEN;
 
 		SSL_CTX_set_next_protos_advertised_cb(ctx, next_proto_cb, NULL);
+#ifdef GPAC_ENABLE_COVERAGE
+		if (gf_sys_is_cov_mode()) {
+			next_proto_cb(NULL, NULL, NULL, NULL);
+			h2_error_callback(NULL, NULL, 0, NULL);
+			on_user_pass(NULL, NULL, NULL, GF_FALSE);
+		}
+#endif
 
 #if OPENSSL_VERSION_NUMBER >= 0x10002000L
 		SSL_CTX_set_alpn_select_cb(ctx, alpn_select_proto_cb, NULL);
@@ -1420,7 +1602,12 @@
 	}
 	SSL_set_fd(ssl, gf_sk_get_handle(client_sock) );
 	if (SSL_accept(ssl) <= 0) {
-		ERR_print_errors_fp(stderr);
+		if (gf_log_tool_level_on(GF_LOG_NETWORK, GF_LOG_DEBUG)) {
+			//this one crashes /exits on windows, only use if debug level
+			ERR_print_errors_fp(stderr);
+		} else {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("SSL Accept failure\n"));
+		}
 		SSL_shutdown(ssl);
 SSL_free(ssl);
 		*e = GF_AUTHENTICATION_FAILURE;
@@ -1429,24 +1616,41 @@
 	*e = GF_OK;
 	return ssl;
 }
+void gf_ssl_del(void *ssl)
+{
+	if (ssl) SSL_free(ssl);
+}
 
-
-static GF_Err gf_ssl_write(void *ssl_ctx, const u8 *buffer, u32 size)
+static GF_Err gf_ssl_write(GF_DownloadSession *sess, const u8 *buffer, u32 size, u32 *written)
 {
 	u32 idx=0;
 	s32 nb_tls_blocks = size/16000;
+	*written = 0;
 	while (nb_tls_blocks>=0) {
 		u32 len, to_write = 16000;
 		if (nb_tls_blocks==0)
 			to_write = size - idx*16000;
 
-		len = SSL_write(ssl_ctx, buffer + idx*16000, to_write);
+		len = SSL_write(sess->ssl, buffer + idx*16000, to_write);
 		nb_tls_blocks--;
 		idx++;
 
 		if (len != to_write) {
+			if (sess->flags & GF_NETIO_SESSION_NO_BLOCK) {
+				int err = SSL_get_error(sess->ssl, len);
+				if ((err==SSL_ERROR_WANT_READ) || (err==SSL_ERROR_WANT_WRITE)) {
+					return GF_IP_NETWORK_EMPTY;
+				}
+				if (err==SSL_ERROR_SSL) {
+					char msg1024;
+					SSL_load_error_strings();
+					ERR_error_string_n(ERR_get_error(), msg, sizeof(msg));
+					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Cannot send, error %s\n", msg));
+				}
+			}
 			return GF_IP_NETWORK_FAILURE;
 		}
+		*written += to_write;
 	}
 	return GF_OK;
 }
@@ -1455,6 +1659,56 @@
 #endif /* GPAC_HAS_SSL */
 
 
+static GF_Err dm_sess_write(GF_DownloadSession *session, const u8 *buffer, u32 size)
+{
+	GF_Err e;
+	u32 written=0;
+	GF_DownloadSession *par_sess = session;
+#ifdef GPAC_HAS_HTTP2
+	//if h2 we aggregate pending frames on the session currently holding the HTTP2 session
+	if (session->h2_sess) par_sess = session->h2_sess->net_sess;
+#endif
+
+	//we are writing and we already have pending data, append and try to flush after
+	if (par_sess->async_buf_size && (buffer != par_sess->async_buf)) {
+		e = GF_IP_NETWORK_EMPTY;
+	} else
+#ifdef GPAC_HAS_SSL
+	if (session->ssl) {
+		e = gf_ssl_write(session, buffer, size, &written);
+	} else
+#endif
+	{
+		e = gf_sk_send_ex(session->sock, buffer, size, &written);
+	}
+
+
+	if (!(session->flags & GF_NETIO_SESSION_NO_BLOCK) || (e!=GF_IP_NETWORK_EMPTY)) {
+		par_sess->async_buf_size = 0;
+		return e;
+	}
+
+	//we are blocking, store content
+	u32 remain = size - written;
+	if (buffer == par_sess->async_buf) {
+		if (written) {
+			memmove(par_sess->async_buf, par_sess->async_buf + written, remain);
+			assert(par_sess->async_buf_size >= written);
+			par_sess->async_buf_size -= written;
+		}
+	} else {
+		if (par_sess->async_buf_alloc < par_sess->async_buf_size + remain) {
+			par_sess->async_buf_alloc = par_sess->async_buf_size + remain;
+			par_sess->async_buf = gf_realloc(par_sess->async_buf, par_sess->async_buf_alloc);
+			if (!par_sess->async_buf) return GF_OUT_OF_MEM;
+		}
+		memcpy(par_sess->async_buf+par_sess->async_buf_size, buffer + written, remain);
+		par_sess->async_buf_size += remain;
+	}
+	return GF_OK;
+}
+
+
 static Bool gf_dm_is_local(GF_DownloadManager *dm, const char *url)
 {
 	if (!strnicmp(url, "file://", 7)) return GF_TRUE;
@@ -1586,7 +1840,7 @@
 		if (!entry) {
 			if (sess->local_cache_only) {
 				sess->cache_entry = NULL;
-				sess->last_error = GF_URL_ERROR;
+				SET_LAST_ERR(GF_URL_ERROR)
 				return;
 			}
 			/* We found the existing session */
@@ -1761,7 +2015,8 @@
 
 
 		len = (u32) strlen(rsp_buf);
-		e = gf_sk_send(sess->sock, rsp_buf, len);
+		e = dm_sess_write(sess, rsp_buf, len);
+
 		gf_free(rsp_buf);
 		rsp_buf = NULL;
 
@@ -1814,7 +2069,7 @@
 		}
 		h2_session_send(sess);
 		//in case we have a body already setup with this reply
-		h2_flush_send(sess);
+		h2_flush_send(sess, GF_FALSE);
 
 		gf_mx_v(sess->mx);
 
@@ -1829,6 +2084,7 @@
 	gf_dynstrcat(&rsp_buf, szFmt, NULL);
 	switch (reply_code) {
 	case 400: gf_dynstrcat(&rsp_buf, "Bad Request", NULL); break;
+	case 401: gf_dynstrcat(&rsp_buf, "Unauthorized", NULL); break;
 	case 403: gf_dynstrcat(&rsp_buf, "Forbidden", NULL); break;
 	case 405: gf_dynstrcat(&rsp_buf, "Not Allowed", NULL); break;
 	case 416: gf_dynstrcat(&rsp_buf, "Requested Range Not Satisfiable", NULL); break;
@@ -1842,7 +2098,7 @@
 	case 200: gf_dynstrcat(&rsp_buf, "OK", NULL); break;
 	case 201: gf_dynstrcat(&rsp_buf, "Created", NULL); break;
 	default:
-		gf_dynstrcat(&rsp_buf, "OK", NULL); break;
+		gf_dynstrcat(&rsp_buf, "ERROR", NULL); break;
 	}
 	gf_dynstrcat(&rsp_buf, "\r\n", NULL);
 	if (!rsp_buf) return GF_OUT_OF_MEM;
@@ -1865,12 +2121,7 @@
 	}
 
 	count = (u32) strlen(rsp_buf);
-#ifdef GPAC_HAS_SSL
-	if (sess->ssl) {
-		e = gf_ssl_write(sess->ssl, rsp_buf, count);
-	} else
-#endif
-		e = gf_sk_send(sess->sock, rsp_buf, count);
+	e = dm_sess_write(sess, rsp_buf, count);
 
 	gf_free(rsp_buf);
 	return e;
@@ -1904,6 +2155,11 @@
 	if (sess->connection_close) close_type = HTTP_RESET_CONN;
 	sess->connection_close = GF_FALSE;
 	sess->remaining_data_size = 0;
+	sess->start_time = 0;
+	if (sess->async_req_reply) gf_free(sess->async_req_reply);
+	sess->async_req_reply = NULL;
+	sess->async_req_reply_size = 0;
+	sess->async_buf_size = 0;
 
 	if (sess->status >= GF_NETIO_DISCONNECTED) {
 		if (close_type && sess->use_cache_file && sess->cache_entry) {
@@ -1939,11 +2195,7 @@
 				sess->ssl = NULL;
 			}
 #endif
-			if (sess->sock) {
-				GF_Socket * sx = sess->sock;
-				sess->sock = NULL;
-				gf_sk_del(sx);
-			}
+			dm_sess_sk_del(sess);
 		}
 
 		if (close_type && sess->use_cache_file && sess->cache_entry) {
@@ -1998,6 +2250,7 @@
 	if (sess->creds) sess->creds = NULL;
 	if (sess->init_data) gf_free(sess->init_data);
 	if (sess->remaining_data) gf_free(sess->remaining_data);
+	if (sess->async_req_reply) gf_free(sess->async_req_reply);
 
 	sess->orig_url = sess->server_name = sess->remote_path;
 	sess->creds = NULL;
@@ -2011,8 +2264,13 @@
 
 	if (sess->h2_upgrade_settings)
 		gf_free(sess->h2_upgrade_settings);
+
+	if (sess->h2_local_buf)
+		gf_free(sess->h2_local_buf);
 #endif
 
+	//free this once we have reassigned the session
+	if (sess->async_buf) gf_free(sess->async_buf);
 
 #ifdef GPAC_HAS_SSL
 	//in server mode SSL context is managed by caller
@@ -2023,10 +2281,8 @@
 		sess->ssl = NULL;
 	}
 #endif
-	if (sess->sock) {
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("Downloader closing socket\n"));
-		gf_sk_del(sess->sock);
-	}
+	dm_sess_sk_del(sess);
+
 	gf_list_del(sess->headers);
 
 	gf_mx_del(sess->mx);
@@ -2408,7 +2664,7 @@
 			if (! sess->dm) {
 				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP Did not found any download manager, credentials not supported\n"));
 			} else
-				sess->creds = gf_user_credentials_register(sess->dm, sess->server_name, info.userName, info.password, info.userName && info.password);
+				sess->creds = gf_user_credentials_register(sess->dm, !strcmp("https://", info.protocol), sess->server_name, info.userName, info.password, info.userName && info.password);
 		}
 	}
 	if (free_proto) gf_free((char *) info.protocol);
@@ -2426,6 +2682,7 @@
 
 	if (sess->sock && !socket_changed) {
 		sess->status = GF_NETIO_CONNECTED;
+		sess->last_error = GF_OK;
 		sess->num_retry = SESSION_RETRY_COUNT;
 		sess->needs_cache_reconfig = 1;
 	} else {
@@ -2438,11 +2695,10 @@
 		}
 #endif
 
-		if (sess->sock) {
-			gf_sk_del(sess->sock);
-			sess->sock = NULL;
-		}
+		dm_sess_sk_del(sess);
+
 		sess->status = GF_NETIO_SETUP;
+		sess->last_error = GF_OK;
 #ifdef GPAC_HAS_SSL
 		if (sess->ssl) {
 			SSL_shutdown(sess->ssl);
@@ -2463,13 +2719,13 @@
 			sess->local_cache_only = GF_TRUE;
 			gf_free(sess->orig_url);
 			sess->orig_url = gf_strdup(url);
-			sess->last_error = GF_OK;
+			SET_LAST_ERR(sess->last_error)
 			sess->use_cache_file = GF_TRUE;
 			gf_dm_configure_cache(sess);
 			sess->bytes_done = 0;
 if (sess->cache_entry && gf_cache_is_deleted(sess->cache_entry)) {
 sess->status = GF_NETIO_DATA_TRANSFERED;
- sess->last_error = GF_URL_REMOVED;
+ SET_LAST_ERR(GF_URL_REMOVED)
 //return GF_OK;
 } else if (! gf_cache_is_done(sess->cache_entry)) {
 sess->total_size = 0;
@@ -2478,6 +2734,7 @@
 				sess->total_size = gf_cache_get_content_length(sess->cache_entry);
 sess->bytes_done = sess->total_size;
 sess->status = GF_NETIO_DATA_TRANSFERED;
+ SET_LAST_ERR(GF_OK)
 }
 
 			sess->total_time_since_req = gf_cache_get_downtime(sess->cache_entry);
@@ -2518,7 +2775,7 @@
 	/*destroy all session but keep connection active*/
 	gf_dm_disconnect(sess, HTTP_NO_CLOSE);
 	sess->status = GF_NETIO_STATE_ERROR;
-	sess->last_error = GF_OK;
+	SET_LAST_ERR(GF_OK)
 	return GF_FALSE;
 }
 
@@ -2581,14 +2838,11 @@
 	sess->usr_cbk = usr_cbk;
 	sess->creds = NULL;
 
-	if (!gf_opts_get_key("core", "head-timeout")) {
-		sess->head_timeout = 5000;
-	} else {
-		sess->head_timeout = gf_opts_get_int("core", "head-timeout");
-	}
+	sess->conn_timeout = gf_opts_get_int("core", "tcp-timeout");
+	if (!sess->conn_timeout) sess->conn_timeout = 5000;
 
 	sess->request_timeout = gf_opts_get_int("core", "req-timeout");
-	if (!sess->request_timeout) sess->request_timeout = 20000;
+	if (!sess->request_timeout) sess->request_timeout = 10000;
 
 	sess->chunk_wnd_dur = gf_opts_get_int("core", "cte-rate-wnd") * 1000;
 	if (!sess->chunk_wnd_dur) sess->chunk_wnd_dur = 20000;
@@ -2601,10 +2855,14 @@
 		sess->server_mode = GF_TRUE;
 		sess->do_requests = http_do_requests;
 		if (e) *e = GF_OK;
+		if (dl_flags & GF_NETIO_SESSION_NO_BLOCK) {
+			sess->flags |= GF_NETIO_SESSION_NO_BLOCK;
+			gf_sk_set_block_mode(server, GF_TRUE);
+		}
 		return sess;
 	}
 
-	if (!sess->head_timeout) sess->server_only_understand_get = GF_TRUE;
+	if (!sess->conn_timeout) sess->server_only_understand_get = GF_TRUE;
 	if (dm)
 		sess->disable_cache = dm->disable_cache;
 
@@ -2629,10 +2887,11 @@
 }
 
 GF_EXPORT
-GF_DownloadSession *gf_dm_sess_new_server(GF_Socket *server,
+GF_DownloadSession *gf_dm_sess_new_server(GF_DownloadManager *dm, GF_Socket *server,
 		void *ssl_sock_ctx,
 gf_dm_user_io user_io,
 void *usr_cbk,
+ Bool async,
 GF_Err *e)
 {
 	GF_DownloadSession *sess;
@@ -2655,11 +2914,13 @@
 	}
 #endif //GPAC_HAS_HTTP2 && GPAC_HAS_SSL
 
-	sess = gf_dm_sess_new_internal(NULL, NULL, 0, user_io, usr_cbk, server, e);
+	sess = gf_dm_sess_new_internal(dm, NULL, async ? GF_NETIO_SESSION_NO_BLOCK : 0, user_io, usr_cbk, server, e);
 
 #ifdef GPAC_HAS_SSL
 	if (sess) {
 		sess->ssl = ssl_sock_ctx;
+		if (ssl_sock_ctx && (sess->flags & GF_NETIO_SESSION_NO_BLOCK))
+			SSL_set_mode(sess->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER|SSL_MODE_ENABLE_PARTIAL_WRITE);
 
 #if defined(GPAC_HAS_HTTP2)
 		if (h2_negotiated) {
@@ -2693,6 +2954,7 @@
 	sub_sess->status = GF_NETIO_CONNECTED;
 	sub_sess->data_io.read_callback = h2_data_source_read_callback;
 	sub_sess->data_io.source.ptr = sub_sess;
+	sub_sess->flags = sess->flags;
 	gf_mx_v(sess->mx);
 	return sub_sess;
 #else
@@ -2894,6 +3156,89 @@
 
 #endif
 
+
+#ifdef GPAC_HAS_SSL
+Bool gf_ssl_check_cert(SSL *ssl, const char *server_name)
+{
+	Bool success;
+	X509 *cert = SSL_get_peer_certificate(ssl);
+	if (!cert) return GF_TRUE;
+
+	long vresult;
+	SSL_set_verify_result(ssl, 0);
+	vresult = SSL_get_verify_result(ssl);
+
+	if (vresult == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) {
+		GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("SSL Cannot locate issuer's certificate on the local system, will not attempt to validate\n"));
+		SSL_set_verify_result(ssl, 0);
+		vresult = SSL_get_verify_result(ssl);
+	}
+
+	if (vresult == X509_V_OK) {
+		char common_name256;
+		STACK_OF(GENERAL_NAME) *altnames;
+		GF_List* valid_names;
+		int i;
+
+		valid_names = gf_list_new();
+
+		common_name0 = 0;
+		X509_NAME_get_text_by_NID(X509_get_subject_name(cert), NID_commonName, common_name, sizeof (common_name));
+		gf_list_add(valid_names, common_name);
+
+		altnames = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
+		if (altnames) {
+			for (i = 0; i < sk_GENERAL_NAME_num(altnames); ++i) {
+				const GENERAL_NAME *altname = sk_GENERAL_NAME_value(altnames, i);
+				if (altname->type == GEN_DNS)
+				{
+					#if OPENSSL_VERSION_NUMBER < 0x10100000L
+						unsigned char *altname_str = ASN1_STRING_data(altname->d.ia5);
+					#else
+						unsigned char *altname_str = (unsigned char *)ASN1_STRING_get0_data(altname->d.ia5);
+					#endif
+					gf_list_add(valid_names, altname_str);
+				}
+			}
+		}
+
+		success = GF_FALSE;
+		for (i = 0; i < (int)gf_list_count(valid_names); ++i) {
+			const char *valid_name = (const char*) gf_list_get(valid_names, i);
+			if (rfc2818_match(valid_name, server_name)) {
+				success = GF_TRUE;
+				GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("SSL Hostname %s matches %s\n", server_name, valid_name));
+				break;
+			}
+		}
+		if (!success) {
+			if ( gf_opts_get_bool("core", "broken-cert")) {
+				success = GF_TRUE;
+				GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("SSL Mismatch in certificate names: expected %s\n", server_name));
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Mismatch in certificate names, try using -broken-cert: expected %s\n", 	server_name));
+			}
+#ifndef GPAC_DISABLE_LOG
+			for (i = 0; i < (int)gf_list_count(valid_names); ++i) {
+				const char *valid_name = (const char*) gf_list_get(valid_names, i);
+				GF_LOG(success ? GF_LOG_DEBUG : GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Tried name: %s\n", valid_name));
+			}
+#endif
+		}
+
+		gf_list_del(valid_names);
+		GENERAL_NAMES_free(altnames);
+	} else {
+		success = GF_FALSE;
+		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Error verifying certificate %x\n", vresult));
+	}
+
+	X509_free(cert);
+	return success;
+}
+
+#endif
+
 static void gf_dm_connect(GF_DownloadSession *sess)
 {
 	GF_Err e;
@@ -2909,7 +3254,7 @@
 		gf_mx_v(sess->mx);
 
 		if (sess->num_retry) {
-			sess->last_error = GF_OK;
+			SET_LAST_ERR(GF_OK)
 			sess->num_retry--;
 			GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("HTTP/2 stream_id %d (%s) refused by server, retrying and marking session as no longer available\n", sess->h2_stream_id, sess->remote_path ? sess->remote_path : sess->orig_url));
 
@@ -2917,20 +3262,37 @@
 		} else {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP/2 stream_id %d (%s) refused by server after all retries, marking session as no longer available\n", sess->h2_stream_id, sess->remote_path ? sess->remote_path : sess->orig_url));
 			sess->status = GF_NETIO_STATE_ERROR;
-			sess->last_error = GF_REMOTE_SERVICE_ERROR;
+			SET_LAST_ERR(GF_REMOTE_SERVICE_ERROR)
 			sess->h2_stream_id = 0;
 			return;
 		}
 	}
 	assert(!sess->h2_sess);
 
-	if (sess->dm && !sess->dm->disable_http2) {
+	if (sess->dm && !sess->dm->disable_http2 && !sess->sock && (sess->h2_upgrade_state!=3)) {
 		u32 i, count = gf_list_count(sess->dm->sessions);
 		for (i=0; i<count; i++) {
 			GF_DownloadSession *a_sess = gf_list_get(sess->dm->sessions, i);
-			if (!a_sess->h2_sess) continue;
-			if (a_sess->h2_sess->do_shutdown) continue;
 			if (strcmp(a_sess->server_name, sess->server_name)) continue;
+			if (!a_sess->h2_sess) {
+				//we have the same server name
+				//trick in non-block mode, we want to wait for upgrade to be completed
+				//before creating a new socket
+				if ((a_sess != sess)
+					&& a_sess->sock
+					&& (a_sess->status <= GF_NETIO_WAIT_FOR_REPLY)
+					&& (a_sess->h2_upgrade_state<2)
+					&& (sess->flags & GF_NETIO_SESSION_NO_BLOCK)
+					&& !sess->dm->disable_http2
+					&& !gf_opts_get_bool("core", "no-h2c")
+				) {
+					sess->connect_pending = 1;
+					SET_LAST_ERR(GF_IP_NETWORK_EMPTY)
+					return;
+				}
+				continue;
+			}
+			if (a_sess->h2_sess->do_shutdown) continue;
 
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("HTTP/2 associating session %s to existing http2 session\n", sess->remote_path ? sess->remote_path : sess->orig_url));
 
@@ -2959,10 +3321,14 @@
 	}
 #endif
 
-
+	Bool register_sock = GF_FALSE;
 	if (!sess->sock) {
-		sess->num_retry = 40;
 		sess->sock = gf_sk_new(GF_SOCK_TYPE_TCP);
+
+		if (sess->sock && (sess->flags & GF_NETIO_SESSION_NO_BLOCK))
+			gf_sk_set_block_mode(sess->sock, GF_TRUE);
+
+		if (sess->sock_group) register_sock = GF_TRUE;
 	}
 
 	/*connect*/
@@ -3003,27 +3369,50 @@
 		proxy = sess->server_name;
 		proxy_port = sess->port;
 	}
-	GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connecting to %s:%d\n", proxy, proxy_port));
+	if (!sess->connect_pending) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connecting to %s:%d\n", proxy, proxy_port));
+	}
 
-	if (sess->status == GF_NETIO_SETUP) {
+	if ((sess->status == GF_NETIO_SETUP) && (sess->connect_pending<2)) {
 		u64 now;
 		if (sess->dm && sess->dm->simulate_no_connection) {
 			sess->status = GF_NETIO_STATE_ERROR;
-			sess->last_error = GF_IP_NETWORK_FAILURE;
+			SET_LAST_ERR(GF_IP_NETWORK_FAILURE)
 			gf_dm_sess_notify_state(sess, sess->status, sess->last_error);
 			return;
 		}
 
+		sess->async_buf_size = 0;
 		now = gf_sys_clock_high_res();
+		if ((sess->flags & GF_NETIO_SESSION_NO_BLOCK) && !sess->start_time)
+			sess->start_time = now;
+
 		e = gf_sk_connect(sess->sock, (char *) proxy, proxy_port, NULL);
 
 		/*retry*/
-		if ((e == GF_IP_SOCK_WOULD_BLOCK) && sess->num_retry) {
-			sess->status = GF_NETIO_SETUP;
-			sess->num_retry--;
-			return;
+		if (e == GF_IP_NETWORK_EMPTY) {
+			if (sess->num_retry) {
+				if (register_sock) gf_sk_group_register(sess->sock_group, sess->sock);
+				sess->status = GF_NETIO_SETUP;
+				if (sess->flags & GF_NETIO_SESSION_NO_BLOCK) {
+					if ((now - sess->start_time) / 1000 > sess->conn_timeout) {
+						sess->num_retry = 0;
+					}
+				}
+				else {
+					sess->num_retry--;
+				}
+				sess->connect_pending = 1;
+				SET_LAST_ERR(GF_IP_NETWORK_EMPTY)
+					return;
+			} else {
+				e = GF_IP_CONNECTION_FAILURE;
+			}
 		}
 
+		sess->connect_pending = 0;
+		SET_LAST_ERR(GF_OK)
+
 		/*failed*/
 		if (e) {
 			if (!sess->cache_entry && sess->dm && sess->dm->allow_offline_cache) {
@@ -3031,43 +3420,72 @@
 				if (sess->from_cache_only) return;
 			}
 			sess->status = GF_NETIO_STATE_ERROR;
-			sess->last_error = e;
+			SET_LAST_ERR(e)
 			gf_dm_sess_notify_state(sess, sess->status, e);
 			return;
 		}
+		if (register_sock) gf_sk_group_register(sess->sock_group, sess->sock);
 		if (sess->allow_direct_reuse) {
 			gf_dm_configure_cache(sess);
 			if (sess->from_cache_only) return;
 		}
 
 		sess->connect_time = (u32) (gf_sys_clock_high_res() - now);
-		sess->status = GF_NETIO_CONNECTED;
 		GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connected to %s:%d\n", proxy, proxy_port));
 		gf_dm_sess_notify_state(sess, GF_NETIO_CONNECTED, GF_OK);
 //		gf_sk_set_buffer_size(sess->sock, GF_TRUE, GF_DOWNLOAD_BUFFER_SIZE);
 //		gf_sk_set_buffer_size(sess->sock, GF_FALSE, GF_DOWNLOAD_BUFFER_SIZE);
 	}
 
+	if (sess->status == GF_NETIO_SETUP)
+		sess->status = GF_NETIO_CONNECTED;
+
 #ifdef GPAC_HAS_SSL
-	if (!sess->ssl && (sess->flags & GF_DOWNLOAD_SESSION_USE_SSL)) {
+	if ((!sess->ssl || (sess->connect_pending==2)) && (sess->flags & (GF_DOWNLOAD_SESSION_USE_SSL|GF_DOWNLOAD_SESSION_SSL_FORCED))) {
 		u64 now = gf_sys_clock_high_res();
 		if (sess->dm && !sess->dm->ssl_ctx)
-			ssl_init(sess->dm, 0);
+			gf_dm_ssl_init(sess->dm, 0);
 		/*socket is connected, configure SSL layer*/
 		if (sess->dm && sess->dm->ssl_ctx) {
 			int ret;
-			X509 *cert;
 			Bool success;
 
-			sess->ssl = SSL_new(sess->dm->ssl_ctx);
-			SSL_set_fd(sess->ssl, gf_sk_get_handle(sess->sock));
-			SSL_ctrl(sess->ssl, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, (void*) proxy);
+			if (!sess->ssl) {
+				sess->ssl = SSL_new(sess->dm->ssl_ctx);
+				SSL_set_fd(sess->ssl, gf_sk_get_handle(sess->sock));
+				SSL_ctrl(sess->ssl, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, (void*) proxy);
+				SSL_set_connect_state(sess->ssl);
+
+				if (sess->flags & GF_NETIO_SESSION_NO_BLOCK)
+					SSL_set_mode(sess->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER|SSL_MODE_ENABLE_PARTIAL_WRITE);
 
-			SSL_set_connect_state(sess->ssl);
+#ifdef GPAC_HAS_HTTP2
+				if (sess->h2_upgrade_state==3) {
+					SSL_set_alpn_protos(sess->ssl, NULL, 0);
+					sess->h2_upgrade_state = 0;
+				}
+#endif
+			}
+
+			sess->connect_pending = 0;
 			ret = SSL_connect(sess->ssl);
 			if (ret<=0) {
 				ret = SSL_get_error(sess->ssl, ret);
 				if (ret==SSL_ERROR_SSL) {
+
+#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && defined(GPAC_HAS_HTTP2)
+					//error and we tried with alpn for h2, retry without (kill/reconnect)
+					if (!sess->h2_upgrade_state && !sess->dm->disable_http2) {
+						SSL_free(sess->ssl);
+						sess->ssl = NULL;
+						dm_sess_sk_del(sess);
+						sess->status = GF_NETIO_SETUP;
+						sess->h2_upgrade_state = 3;
+						gf_dm_connect(sess);
+						return;
+					}
+#endif
+
 					char msg1024;
 					SSL_load_error_strings();
 					ERR_error_string_n(ERR_get_error(), msg, sizeof(msg));
@@ -3077,10 +3495,14 @@
 						GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("\tYou may want to retry with HTTP/2 support disabled (-no-h2)\n"));
 					}
 #endif
-					sess->last_error = GF_SERVICE_ERROR;
+					SET_LAST_ERR(GF_SERVICE_ERROR)
+				} else if ((ret==SSL_ERROR_WANT_READ) || (ret==SSL_ERROR_WANT_WRITE)) {
+					sess->status = GF_NETIO_SETUP;
+					sess->connect_pending = 2;
+					return;
 				} else {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Cannot connect, error %d\n", ret));
-					sess->last_error = GF_REMOTE_SERVICE_ERROR;
+					SET_LAST_ERR(GF_REMOTE_SERVICE_ERROR)
 				}
 			} else {
 				GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("SSL connected\n"));
@@ -3105,86 +3527,12 @@
 #endif
 			}
 
-			cert = SSL_get_peer_certificate(sess->ssl);
-			/*if we have a cert, check it*/
-			if (cert) {
-				long vresult;
-				SSL_set_verify_result(sess->ssl, 0);
-				vresult = SSL_get_verify_result(sess->ssl);
-
-				if (vresult == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) {
-					GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("SSL Cannot locate issuer's certificate on the local system, will not attempt to validate\n"));
-					SSL_set_verify_result(sess->ssl, 0);
-					vresult = SSL_get_verify_result(sess->ssl);
-				}
-
-				if (vresult == X509_V_OK) {
-					char common_name256;
-					STACK_OF(GENERAL_NAME) *altnames;
-					GF_List* valid_names;
-					int i;
-
-					valid_names = gf_list_new();
-
-					common_name0 = 0;
-					X509_NAME_get_text_by_NID(X509_get_subject_name(cert), NID_commonName, common_name, sizeof (common_name));
-					gf_list_add(valid_names, common_name);
-
-					altnames = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
-					if (altnames) {
-						for (i = 0; i < sk_GENERAL_NAME_num(altnames); ++i) {
-							const GENERAL_NAME *altname = sk_GENERAL_NAME_value(altnames, i);
-							if (altname->type == GEN_DNS)
-							{
-								#if OPENSSL_VERSION_NUMBER < 0x10100000L
-									unsigned char *altname_str = ASN1_STRING_data(altname->d.ia5);
-								#else
-									unsigned char *altname_str = (unsigned char *)ASN1_STRING_get0_data(altname->d.ia5);
-								#endif
-								gf_list_add(valid_names, altname_str);
-							}
-						}
-					}
-
-					success = GF_FALSE;
-					for (i = 0; i < (int)gf_list_count(valid_names); ++i) {
-						const char *valid_name = (const char*) gf_list_get(valid_names, i);
-						if (rfc2818_match(valid_name, sess->server_name)) {
-							success = GF_TRUE;
-							GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("SSL Hostname %s matches %s\n", sess->server_name, valid_name));
-							break;
-						}
-					}
-					if (!success) {
-						if (sess->dm && sess->dm->allow_broken_certificate) {
-							success = GF_TRUE;
-							GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("SSL Mismatch in certificate names: expected %s\n", sess->server_name));
-						} else {
-							GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Mismatch in certificate names, try using -broken-cert: expected %s\n", 	sess->server_name));
-						}
-#ifndef GPAC_DISABLE_LOG
-						for (i = 0; i < (int)gf_list_count(valid_names); ++i) {
-							const char *valid_name = (const char*) gf_list_get(valid_names, i);
-							GF_LOG(success ? GF_LOG_DEBUG : GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Tried name: %s\n", valid_name));
-						}
-#endif
-					}
-
-					gf_list_del(valid_names);
-					GENERAL_NAMES_free(altnames);
-				} else {
-					success = GF_FALSE;
-					GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("SSL Error verifying certificate %x\n", vresult));
-				}
-
-				X509_free(cert);
-
-				if (!success) {
-					gf_dm_disconnect(sess, HTTP_RESET_CONN);
-					sess->status = GF_NETIO_STATE_ERROR;
-					sess->last_error = GF_AUTHENTICATION_FAILURE;
-					gf_dm_sess_notify_state(sess, sess->status, sess->last_error);
-				}
+			success = gf_ssl_check_cert(sess->ssl, sess->server_name);
+			if (!success) {
+				gf_dm_disconnect(sess, HTTP_RESET_CONN);
+				sess->status = GF_NETIO_STATE_ERROR;
+				SET_LAST_ERR(GF_AUTHENTICATION_FAILURE)
+				gf_dm_sess_notify_state(sess, sess->status, sess->last_error);
 			}
 
 			sess->ssl_setup_time = (u32) (gf_sys_clock_high_res() - now);
@@ -3230,7 +3578,7 @@
 					if (e) {
 						GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("gf_dm_refresh_cache_entry() : Error with GET %d\n", e));
 						sess->status = GF_NETIO_STATE_ERROR;
-						sess->last_error = e;
+						SET_LAST_ERR(e)
 						gf_dm_sess_notify_state(sess, sess->status, e);
 					} else {
 						timer = 0;
@@ -3283,10 +3631,13 @@
 				discontinue_cache = GF_TRUE;
 		}
 		if (sess->sock) {
-			if (sess->status != GF_NETIO_CONNECTED) {
-				if (sess->status != GF_NETIO_DISCONNECTED) {
-					return GF_BAD_PARAM;
-				}
+			switch (sess->status) {
+			case GF_NETIO_CONNECTED:
+			case GF_NETIO_DISCONNECTED:
+			case GF_NETIO_DATA_TRANSFERED:
+				break;
+			default:
+				return GF_BAD_PARAM;
 			}
 		}
 		if (!sess->local_cache_only) {
@@ -3322,11 +3673,10 @@
 	switch (e) {
 	case GF_IP_NETWORK_EMPTY:
 	case GF_OK:
-	case GF_IP_SOCK_WOULD_BLOCK:
 		return;
 	default:
 		sess->status = GF_NETIO_STATE_ERROR;
-		sess->last_error = e;
+		SET_LAST_ERR(e)
 		return;
 	}
 }
@@ -3368,6 +3718,9 @@
 		/*setup download*/
 		case GF_NETIO_SETUP:
 			gf_dm_connect(sess);
+			if (sess->connect_pending) {
+				go = GF_FALSE;
+			}
 			break;
 		case GF_NETIO_WAIT_FOR_REPLY:
 		case GF_NETIO_CONNECTED:
@@ -3375,17 +3728,23 @@
 			if (sess->server_mode) {
 				if (sess->status == GF_NETIO_STATE_ERROR) {
 					sess->status = GF_NETIO_DISCONNECTED;
-					sess->last_error = GF_IP_CONNECTION_CLOSED;
+					SET_LAST_ERR(GF_IP_CONNECTION_CLOSED)
 					sess_connection_closed(sess);
 					go = GF_FALSE;
 				} else if (sess->last_error==GF_IP_NETWORK_EMPTY) {
 					go = GF_FALSE;
+				} else if (sess->status==GF_NETIO_DISCONNECTED) {
+					go = GF_FALSE;
 				}
+			} else if (sess->flags & GF_NETIO_SESSION_NO_BLOCK) {
+				if (sess->last_error==GF_IP_NETWORK_EMPTY)
+					go = GF_FALSE;
 			}
 			break;
 		case GF_NETIO_DATA_EXCHANGE:
 			if (sess->put_state==2) {
 				sess->status = GF_NETIO_DATA_TRANSFERED;
+ SET_LAST_ERR(GF_OK)
 				go = GF_FALSE;
 				break;
 			}
@@ -3562,7 +3921,7 @@
 	dm->read_buf_size = GF_DOWNLOAD_BUFFER_SIZE;
 	//when rate is limited, use smaller smaller read size
 	if (dm->limit_data_rate) {
-		dm->read_buf_size = 1024;
+		dm->read_buf_size = GF_DOWNLOAD_BUFFER_SIZE_LIMIT_RATE;
 	}
 
 	dm->disable_cache = gf_opts_get_bool("core", "no-cache");
@@ -3595,9 +3954,7 @@
 }
 
 GF_EXPORT
-void gf_dm_set_auth_callback(GF_DownloadManager *dm,
- Bool (*get_user_password)(void *usr_cbk, const char *site_url, char *usr_name, char *password),
- void *usr_cbk)
+void gf_dm_set_auth_callback(GF_DownloadManager *dm, gf_dm_get_usr_pass get_user_password, void *usr_cbk)
 {
 	if (dm) {
 		dm->get_user_password = get_user_password;
@@ -3642,7 +3999,7 @@
 	dm->skip_proxy_servers = NULL;
 	assert( dm->credentials);
 	while (gf_list_count(dm->credentials)) {
-		gf_user_credentials_struct * cred = (gf_user_credentials_struct*)gf_list_get( dm->credentials, 0);
+		GF_UserCredentials * cred = (GF_UserCredentials*)gf_list_get( dm->credentials, 0);
 		gf_list_rem( dm->credentials, 0);
 		gf_free( cred );
 	}
@@ -3795,7 +4152,7 @@
 	//cannot parse now, copy over the bytes
 	if (!te_header) {
 		*header_size = 0;
-		GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("HTTP Chunk encoding: current buffer does not contain enough bytes (%d) to read the size\n", *payload_size));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("HTTP Chunk encoding: current buffer does not contain enough bytes (%d) to read the size\n", *payload_size));
 		return NULL;
 	}
 
@@ -4140,6 +4497,7 @@
 			gf_cache_release_content(sess->cache_entry);
 if (gf_cache_is_done(sess->cache_entry)) {
 sess->status = GF_NETIO_DATA_TRANSFERED;
+ SET_LAST_ERR(GF_OK)
 return GF_EOS;
 }
 return GF_IP_NETWORK_EMPTY;
@@ -4150,10 +4508,12 @@
 memcpy(buffer, ptr + sess->bytes_done, to_copy);
 sess->bytes_done += to_copy;
 *read_size = to_copy;
- if (gf_cache_is_done(sess->cache_entry))
+ if (gf_cache_is_done(sess->cache_entry)) {
 sess->status = GF_NETIO_DATA_TRANSFERED;
-		else
+			SET_LAST_ERR(GF_OK)
+		} else {
 			sess->total_size = 0;
+		}
 		gf_cache_release_content(sess->cache_entry);
 	} else {
 
@@ -4216,6 +4576,7 @@
 			//stream is over and all data flushed, move to GF_NETIO_DATA_TRANSFERED in client mode
 			if (sess->h2_data_done && !sess->h2_buf.size && !sess->server_mode) {
 				sess->status = GF_NETIO_DATA_TRANSFERED;
+				SET_LAST_ERR(GF_OK)
 			}
 		}
 #endif
@@ -4238,6 +4599,7 @@
 #ifdef GPAC_HAS_HTTP2
 			if (sess->h2_sess && (!sess->h2_stream_id || sess->h2_data_done) && sess->bytes_done && !sess->total_size) {
 				sess->status = GF_NETIO_DATA_TRANSFERED;
+				SET_LAST_ERR(GF_OK)
 				return GF_EOS;
 			}
 #endif
@@ -4246,10 +4608,10 @@
 			if ((e==GF_IP_CONNECTION_CLOSED) || (gf_sys_clock_high_res() - sess->last_fetch_time > 1000 * sess->request_timeout)
 			) {
 				if (e==GF_IP_CONNECTION_CLOSED) {
-					sess->last_error = GF_IP_CONNECTION_CLOSED;
+					SET_LAST_ERR(GF_IP_CONNECTION_CLOSED)
 					sess_connection_closed(sess);
 				} else {
-					sess->last_error = GF_IP_NETWORK_EMPTY;
+					SET_LAST_ERR(GF_IP_NETWORK_FAILURE)
 				}
 				sess->status = GF_NETIO_STATE_ERROR;
 				return GF_IP_NETWORK_EMPTY;
@@ -4257,8 +4619,15 @@
 		}
 	}
 
+#ifdef GPAC_HAS_HTTP2
+	if (sess->h2_sess && sess->h2_buf.size) {
+		return e;
+	}
+#endif
+
 	if (sess->server_mode && (sess->status == GF_NETIO_DATA_EXCHANGE)) {
 		sess->status = GF_NETIO_DATA_TRANSFERED;
+		SET_LAST_ERR(GF_OK)
 	}
 
 	return e;
@@ -4335,38 +4704,11 @@
 #endif
 		gf_dm_disconnect(sess, HTTP_CLOSE);
 		sess->status = GF_NETIO_STATE_ERROR;
+		SET_LAST_ERR(GF_IP_CONNECTION_CLOSED)
 		gf_mx_v(sess->mx);
 	}
 }
 
-#if 0 //unused
-/*!
-\brief gets private data
- *
- *Gets private data associated with the session.
-\param sess the download session
-\return the private data
-\warning the private_data parameter is reserved for bandwidth statistics per service when used in the GPAC terminal.
- */
-void *gf_dm_sess_get_private(GF_DownloadSession * sess)
-{
-	return sess ? sess->ext : NULL;
-}
-
-/*!
-\brief sets private data
- *
- *associate private data with the session.
-\param sess the download session
-\param private_data the private data
-\warning the private_data parameter is reserved for bandwidth statistics per service when used in the GPAC terminal.
- */
-void gf_dm_sess_set_private(GF_DownloadSession * sess, void *private_data)
-{
-	if (sess) sess->ext = private_data;
-}
-#endif
-
 /*!
 * Sends the HTTP headers
 \param sess The GF_DownloadSession
@@ -4407,7 +4749,7 @@
 
 	/*setup authentification*/
 	strcpy(pass_buf, "");
-	sess->creds = gf_find_user_credentials_for_site( sess->dm, sess->server_name );
+	sess->creds = gf_user_credentials_find_for_site( sess->dm, sess->server_name, NULL);
 	if (sess->creds && sess->creds->valid) {
 		sprintf(pass_buf, "Basic %s", sess->creds->digest);
 	}
@@ -4493,7 +4835,7 @@
 	if (sess->h2_sess)
 		has_connection = GF_TRUE;
 
-	if (!has_connection && !sess->h2_sess
+	if (!has_connection && !sess->h2_sess && !sess->h2_upgrade_state
 #ifdef GPAC_HAS_SSL
 		&& !sess->ssl
 #endif
@@ -4641,7 +4983,7 @@
 			e = h2_session_send(sess);
 
 		//in case we have a body already setup with this request
-		h2_flush_send(sess);
+		h2_flush_send(sess, GF_FALSE);
 
 		gf_mx_v(sess->mx);
 
@@ -4704,12 +5046,7 @@
 		sess->last_fetch_time = sess->request_start_time = gf_sys_clock_high_res();
 		sess->req_hdr_size = len+par.size;
 
-#ifdef GPAC_HAS_SSL
-		if (sess->ssl) {
-			e = gf_ssl_write(sess->ssl, tmp_buf, len+par.size);
-		} else
-#endif
-			e = gf_sk_send(sess->sock, tmp_buf, len+par.size);
+		e = dm_sess_write(sess, tmp_buf, len+par.size);
 
 		GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Sending request at UTC "LLD" %s\n\n", gf_net_get_utc(), tmp_buf));
 		gf_free(tmp_buf);
@@ -4719,12 +5056,7 @@
 		sess->last_fetch_time = sess->request_start_time = gf_sys_clock_high_res();
 		sess->req_hdr_size = len;
 
-#ifdef GPAC_HAS_SSL
-		if (sess->ssl) {
-			e = gf_ssl_write(sess->ssl, sHTTP, len);
-		} else
-#endif
-			e = gf_sk_send(sess->sock, sHTTP, len);
+		e = dm_sess_write(sess, sHTTP, len);
 
 #ifndef GPAC_DISABLE_LOG
 		if (e) {
@@ -4742,8 +5074,8 @@
 	gf_dm_sess_clear_headers(sess);
 
 	if (e) {
+		SET_LAST_ERR(e)
 		sess->status = GF_NETIO_STATE_ERROR;
-		sess->last_error = e;
 		gf_dm_sess_notify_state(sess, GF_NETIO_STATE_ERROR, e);
 		return e;
 	}
@@ -4754,6 +5086,7 @@
 	} else {
 		sess->status = GF_NETIO_WAIT_FOR_REPLY;
 	}
+	SET_LAST_ERR(GF_OK)
 	return GF_OK;
 }
 
@@ -4825,7 +5158,7 @@
 				}
 			}
 			gf_dm_disconnect(sess, HTTP_CLOSE);
-			sess->last_error = e;
+			SET_LAST_ERR(e)
 			gf_dm_sess_notify_state(sess, sess->status, e);
 			return e;
 		}
@@ -4838,8 +5171,10 @@
 #ifdef GPAC_HAS_HTTP2
 		if (sess->h2_sess) {
 			h2_flush_data(sess, GF_FALSE);
-			if (sess->h2_data_done)
+			if (sess->h2_data_done) {
 				sess->status = GF_NETIO_DATA_TRANSFERED;
+				SET_LAST_ERR(GF_OK)
+			}
 		} else
 #endif
 			gf_dm_data_received(sess, (u8 *) sHTTP, size + prev_remaining_data_size, GF_FALSE, &rewrite_size, NULL);
@@ -4922,6 +5257,31 @@
 	Bool upgrade_to_http2 = GF_FALSE;
 #endif
 
+	if (sess->creds && sess->creds->req_state) {
+		if (sess->creds->req_state==GF_CREDS_STATE_PENDING)
+			return GF_OK;
+		sess->creds->req_state = GF_CREDS_STATE_NONE;
+		if (!sess->creds->valid) {
+			gf_dm_disconnect(sess, HTTP_CLOSE);
+			sess->status = GF_NETIO_STATE_ERROR;
+			par.error = GF_AUTHENTICATION_FAILURE;
+			par.msg_type = GF_NETIO_DISCONNECTED;
+			gf_dm_sess_user_io(sess, &par);
+			e = GF_AUTHENTICATION_FAILURE;
+			SET_LAST_ERR(e)
+			goto exit;
+		}
+
+		sess->status = GF_NETIO_SETUP;
+		e = gf_dm_sess_setup_from_url(sess, sess->orig_url, GF_FALSE);
+		if (e) {
+			sess->status = GF_NETIO_STATE_ERROR;
+			SET_LAST_ERR(e)
+			gf_dm_sess_notify_state(sess, sess->status, e);
+		}
+		return e;
+	}
+
 
 	if (sess->server_mode) {
 		assert( sess->status == GF_NETIO_CONNECTED );
@@ -4959,10 +5319,10 @@
 	sess->chunk_bytes = 0;
 	sess->cumulated_chunk_rate = 0;
 
-//	gf_sk_reset(sess->sock);
 	sHTTP0 = 0;
 
 	while (1) {
+		Bool probe = (!bytesRead || (sess->flags & GF_NETIO_SESSION_NO_BLOCK) ) ? GF_TRUE : GF_FALSE;
 		e = gf_dm_read_data(sess, sHTTP + bytesRead, buf_size - bytesRead, &res);
 
 #ifdef GPAC_HAS_HTTP2
@@ -4973,28 +5333,34 @@
 			bytesRead = 0;
 			BodyStart = 0;
 			e = GF_OK;
+			SET_LAST_ERR(GF_OK)
 			break;
 		}
 #endif
 
 		switch (e) {
 		case GF_IP_NETWORK_EMPTY:
-			if (!bytesRead) {
+			if (probe) {
 				e = gf_sk_probe(sess->sock);
 
 				if (e==GF_IP_CONNECTION_CLOSED) {
-					sess->last_error = GF_IP_CONNECTION_CLOSED;
+					SET_LAST_ERR(GF_IP_CONNECTION_CLOSED)
 					sess_connection_closed(sess);
 					sess->status = GF_NETIO_STATE_ERROR;
 					return GF_IP_NETWORK_EMPTY;
 				}
 				if (!sess->server_mode && (gf_sys_clock_high_res() - sess->request_start_time > 1000 * sess->request_timeout)) {
-					sess->last_error = GF_IP_NETWORK_FAILURE;
+					SET_LAST_ERR(GF_IP_NETWORK_FAILURE)
 					sess->status = GF_NETIO_STATE_ERROR;
 					return GF_IP_NETWORK_FAILURE;
 				}
-				if (sess->server_mode)
-					sess->last_error = GF_IP_NETWORK_EMPTY;
+				if (sess->status != GF_NETIO_STATE_ERROR) {
+					if (sess->server_mode
+						|| (sess->flags & GF_NETIO_SESSION_NO_BLOCK)
+					) {
+						SET_LAST_ERR(GF_IP_NETWORK_EMPTY)
+					}
+				}
 				return GF_OK;
 			}
 			if (sess->status==GF_NETIO_STATE_ERROR)
@@ -5016,23 +5382,36 @@
 				sess->server_only_understand_get = GF_TRUE;
 			}
 			if (sess->server_mode) {
-				sess->last_error = GF_IP_CONNECTION_CLOSED;
+				SET_LAST_ERR(GF_IP_CONNECTION_CLOSED)
 				sess_connection_closed(sess);
 				sess->status = GF_NETIO_DISCONNECTED;
 				GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connection closed by client\n", sess->remote_path));
 				return GF_IP_CONNECTION_CLOSED;
 			}
-			GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connection closed by server when processing %s - retrying\n", sess->remote_path));
 			gf_dm_disconnect(sess, HTTP_RESET_CONN);
 
-			if (sess->num_retry)
+			if (sess->num_retry) {
+#ifdef GPAC_HAS_SSL
+				if ((sess->num_retry < SESSION_RETRY_SSL)
+					&& !(sess->flags & GF_DOWNLOAD_SESSION_USE_SSL)
+					&& !gf_opts_get_bool("core", "no-tls-rcfg")
+				) {
+					GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connection closed by server when processing %s - retrying using SSL\n", sess->remote_path));
+					sess->flags |= GF_DOWNLOAD_SESSION_SSL_FORCED;
+				} else
+#endif
+				{
+					GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connection closed by server when processing %s - retrying\n", sess->remote_path));
+				}
 				sess->status = GF_NETIO_SETUP;
-			else {
-				sess->last_error = e;
+			} else {
+				GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP Connection closed by server when processing %s - aborting\n", sess->remote_path));
+				SET_LAST_ERR(e)
 				sess->status = GF_NETIO_STATE_ERROR;
 			}
 			return e;
 		case GF_OK:
+			SET_LAST_ERR(GF_OK)
 			if (!res)
 				return GF_OK;
 			break;
@@ -5052,19 +5431,41 @@
 
 		//HTTP1.1 only
 
+		char *hdr_buf = sHTTP;
+		u32 hdr_buf_len = bytesRead;
+		if (sess->flags & GF_NETIO_SESSION_NO_BLOCK) {
+			sess->async_req_reply = gf_realloc(sess->async_req_reply, sess->async_req_reply_size+res+1);
+			if (!sess->async_req_reply) {
+				sess->status = GF_NETIO_STATE_ERROR;
+				SET_LAST_ERR(GF_OUT_OF_MEM)
+				return sess->last_error;
+			}
+			memcpy(sess->async_req_reply + sess->async_req_reply_size, sHTTP, res);
+			sess->async_req_reply_size += res;
+			bytesRead = 0;
+			sHTTP0 = 0;
+			hdr_buf = sess->async_req_reply;
+			hdr_buf_len = sess->async_req_reply_size;
+		}
+
 		//weird bug on some servers sending twice the last chunk
-		if (bytesRead && !strncmp(sHTTP, "0\r\n\r\n", 5) ) {
-			bytesRead -= res;
+		if (!strncmp(hdr_buf, "0\r\n\r\n", 5) ) {
+			if (bytesRead) {
+				bytesRead -= res;
+			} else {
+				sess->async_req_reply_size -= res;
+			}
 			GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("HTTP End of chunk found while waiting server response when processing %s - retrying\n", sess->remote_path));
+			continue;
 		}
 
 		/*locate body start*/
-		BodyStart = gf_token_find(sHTTP, 0, bytesRead, "\r\n\r\n");
+		BodyStart = gf_token_find(hdr_buf, 0, hdr_buf_len, "\r\n\r\n");
 		if (BodyStart > 0) {
 			BodyStart += 4;
 			break;
 		}
-		BodyStart = gf_token_find(sHTTP, 0, bytesRead, "\n\n");
+		BodyStart = gf_token_find(hdr_buf, 0, hdr_buf_len, "\n\n");
 		if (BodyStart > 0) {
 			BodyStart += 2;
 			break;
@@ -5073,6 +5474,12 @@
 
 	no_range = range = ContentLength = first_byte = last_byte = total_size = rsp_code = 0;
 
+	if (sess->flags & GF_NETIO_SESSION_NO_BLOCK) {
+		sHTTP = sess->async_req_reply;
+		bytesRead = sess->async_req_reply_size;
+		sess->async_req_reply_size = 0;
+	}
+
 #ifdef GPAC_HAS_HTTP2
 	if (!sess->h2_sess) {
 #endif
@@ -5294,6 +5701,14 @@
 			if (sess->status==GF_NETIO_DISCONNECTED) return GF_OK;
 		}
 
+		if ((sess->flags & GF_NETIO_SESSION_AUTO_CACHE) && !ContentLength && (rsp_code>=200) && (rsp_code<300) ) {
+			sess->use_cache_file = GF_FALSE;
+			if (sess->cache_entry) {
+				gf_cache_remove_session_from_cache_entry(sess->cache_entry, sess);
+				sess->cache_entry = NULL;
+			}
+		}
+
 		if (cache_no_store) {
 			if (sess->cache_entry && !ContentLength && !sess->chunked && (rsp_code<300)
 #ifdef GPAC_HAS_HTTP2
@@ -5364,10 +5779,10 @@
 		e = h2_session_send(sess);
 		if (e) return e;
 		sess->connection_close = GF_FALSE;
-		sess->h2_upgrade_state = 0;
+		sess->h2_upgrade_state = 2;
 		return GF_OK;
 	}
-	if (sess->h2_upgrade_state)
+//	if (sess->h2_upgrade_state<2)
 		sess->h2_upgrade_state = 2;
 #endif
 
@@ -5465,6 +5880,7 @@
 		par.reply = method;
 		gf_dm_sess_user_io(sess, &par);
 		sess->status = GF_NETIO_DATA_TRANSFERED;
+		SET_LAST_ERR(GF_OK)
 		return GF_OK;
 	}
 	//remember if we can keep the session alive after the transfer is done
@@ -5508,7 +5924,7 @@
 		e = gf_dm_sess_setup_from_url(sess, new_location, GF_FALSE);
 		if (e) {
 			sess->status = GF_NETIO_STATE_ERROR;
-			sess->last_error = e;
+			SET_LAST_ERR(e)
 			gf_dm_sess_notify_state(sess, sess->status, e);
 		}
 		gf_free(new_location);
@@ -5532,14 +5948,14 @@
 			assert(filename);
 			if (!f) {
 				GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("HTTP FAILED to open cache file %s for reading contents !\n", filename));
-				/* Ooops, no cache, redowload everything ! */
+				/* Ooops, no cache, redownload everything ! */
 				gf_dm_disconnect(sess, HTTP_NO_CLOSE);
 				sess->status = GF_NETIO_SETUP;
 				e = gf_dm_sess_setup_from_url(sess, sess->orig_url, GF_FALSE);
 				sess->total_size = gf_cache_get_cache_filesize(sess->cache_entry);
 				if (e) {
 					sess->status = GF_NETIO_STATE_ERROR;
-					sess->last_error = e;
+					SET_LAST_ERR(e)
 					gf_dm_sess_notify_state(sess, sess->status, e);
 				}
 				return e;
@@ -5576,6 +5992,7 @@
 		}
 		/* Cache file is the most recent */
 		sess->status = GF_NETIO_DATA_TRANSFERED;
+		SET_LAST_ERR(GF_OK)
 		par.error = GF_OK;
 		gf_dm_sess_notify_state(sess, GF_NETIO_DATA_TRANSFERED, GF_OK);
 		gf_dm_disconnect(sess, HTTP_NO_CLOSE);
@@ -5583,8 +6000,16 @@
 	}
 	case 401:
 	{
+		if (sess->creds && sess->creds->valid) {
+			gf_opts_set_key("credentials", sess->creds->site, NULL);
+			sess->creds->valid = GF_FALSE;
+		}
+		Bool secure = GF_FALSE;
+#ifdef GPAC_HAS_SSL
+		if (sess->ssl) secure = GF_TRUE;
+#endif
 		/* Do we have a credentials struct ? */
-		sess->creds = gf_user_credentials_register(sess->dm, sess->server_name, NULL, NULL, GF_FALSE);
+		sess->creds = gf_user_credentials_register(sess->dm, secure, sess->server_name, NULL, NULL, GF_FALSE);
 		if (!sess->creds) {
 			/* User credentials have not been filled properly, we have to abort */
 			gf_dm_disconnect(sess, HTTP_CLOSE);
@@ -5593,38 +6018,26 @@
 			par.msg_type = GF_NETIO_DISCONNECTED;
 			gf_dm_sess_user_io(sess, &par);
 			e = GF_AUTHENTICATION_FAILURE;
-			sess->last_error = e;
+			SET_LAST_ERR(e)
 			goto exit;
 		}
 		gf_dm_disconnect(sess, HTTP_NO_CLOSE);
 		sess->status = GF_NETIO_SETUP;
+
+		if (sess->creds->req_state==GF_CREDS_STATE_PENDING) {
+			//force a wait for reply until we have resolved user pass
+			sess->status = GF_NETIO_WAIT_FOR_REPLY;
+			return GF_OK;
+		}
+
 		e = gf_dm_sess_setup_from_url(sess, sess->orig_url, GF_FALSE);
 		if (e) {
 			sess->status = GF_NETIO_STATE_ERROR;
-			sess->last_error = e;
+			SET_LAST_ERR(e)
 			gf_dm_sess_notify_state(sess, sess->status, e);
 		}
 		return e;
 	}
-	case 404:
-		/* File not found */
-		gf_dm_sess_user_io(sess, &par);
-		if ((BodyStart < (s32) bytesRead)) {
-			sHTTPbytesRead = 0;
-			GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("HTTP Failure - body: %s\n", sHTTP + BodyStart));
-		}
-		notify_headers(sess, sHTTP, bytesRead, BodyStart);
-		e = GF_URL_ERROR;
-		goto exit;
-
- case 416:
-		/* Range not accepted */
-		gf_dm_sess_user_io(sess, &par);
-
-		notify_headers(sess, sHTTP, bytesRead, BodyStart);
-		e = GF_SERVICE_ERROR;
-		goto exit;
-
 case 400:
 	case 501:
 		/* Method not implemented ! */
@@ -5639,7 +6052,7 @@
 			e = gf_dm_sess_setup_from_url(sess, sess->orig_url, GF_FALSE);
 			if (e) {
 				sess->status = GF_NETIO_STATE_ERROR;
-				sess->last_error = e;
+				SET_LAST_ERR(e)
 				gf_dm_sess_notify_state(sess, sess->status, e);
 			}
 			return e;
@@ -5658,23 +6071,36 @@
 			sess->status = GF_NETIO_SETUP;
 			return GF_OK;
 		}
-	case 204:
-		gf_dm_sess_user_io(sess, &par);
-		notify_headers(sess, sHTTP, bytesRead, BodyStart);
-		e = GF_EOS;
-		goto exit;
+		//fall-through
 
+/*	case 204:
 case 504:
- /* gateway timeout, notified as URL error */
- gf_dm_sess_user_io(sess, &par);
- notify_headers(sess, sHTTP, bytesRead, BodyStart);
- e = GF_URL_ERROR;
- goto exit;
-
-	default:
+	case 404:
+ case 403:
+ case 416:
+*/
+ default:
 		gf_dm_sess_user_io(sess, &par);
+		if ((BodyStart < (s32) bytesRead)) {
+			sHTTPbytesRead = 0;
+			GF_LOG(GF_LOG_WARNING, GF_LOG_HTTP, ("HTTP Failure - body: %s\n", sHTTP + BodyStart));
+		}
 		notify_headers(sess, sHTTP, bytesRead, BodyStart);
-		e = GF_REMOTE_SERVICE_ERROR;
+
+		switch (rsp_code) {
+		case 204: e = GF_EOS; break;
+		/* File not found */
+		case 404: e = GF_URL_ERROR; break;
+		/* Forbidden */
+		case 403: e = GF_AUTHENTICATION_FAILURE; break;
+		/* Range not accepted */
+		case 416: e = GF_SERVICE_ERROR; break;
+		case 504: e = GF_URL_ERROR; break;
+		default:
+			if (rsp_code>=500) e = GF_REMOTE_SERVICE_ERROR;
+			else e = GF_SERVICE_ERROR;
+			break;
+		}
 		goto exit;
 	}
 
@@ -5790,7 +6216,7 @@
 			sess->status = GF_NETIO_STATE_ERROR;
 		else
 			sess->status = GF_NETIO_DATA_TRANSFERED;
-		sess->last_error = e;
+		SET_LAST_ERR(e)
 		gf_dm_sess_notify_state(sess, sess->status, e);
 		return e;
 	}
@@ -5821,6 +6247,10 @@
 		return;
 	}
 
+	if (sess->async_buf_size && (gf_dm_sess_flush_async(sess, GF_FALSE) == GF_IP_NETWORK_EMPTY)) {
+		return;
+	}
+
 	switch (sess->status) {
 	case GF_NETIO_CONNECTED:
 		if (sess->server_mode) {
@@ -6059,7 +6489,7 @@
 	if (sess->init_data) gf_free(sess->init_data);
 	sess->init_data = NULL;
 	sess->init_data_size = 0;
-	sess->last_error = GF_OK;
+	SET_LAST_ERR(GF_OK)
 	sess->total_size = 0;
 	sess->start_time = 0;
 	sess->start_time_utc = 0;
@@ -6221,7 +6651,7 @@
 
 		dm->read_buf_size = GF_DOWNLOAD_BUFFER_SIZE;
 		//when rate is limited, use smaller smaller read size
-		if (dm->limit_data_rate) dm->read_buf_size = 1024;
+		if (dm->limit_data_rate) dm->read_buf_size = GF_DOWNLOAD_BUFFER_SIZE_LIMIT_RATE;
 
 #ifdef GPAC_ENABLE_COVERAGE
 		if (gf_sys_is_cov_mode()) {
@@ -6401,9 +6831,6 @@
 		gf_dm_sess_reload_cached_headers(NULL);
 		gf_dm_refresh_cache_entry(NULL);
 		gf_dm_session_thread(NULL);
-		gf_user_credentials_save_digest(NULL, NULL, NULL);
-		gf_user_credentials_ask_password(NULL, NULL);
-		gf_user_credentials_register(NULL, NULL, NULL, NULL, GF_FALSE);
 		gf_cache_are_headers_processed(NULL);
 		gf_cache_get_start_range(NULL);
 		gf_cache_get_end_range(NULL);
@@ -6419,6 +6846,66 @@
 	return GF_BAD_PARAM;
 }
 
+GF_Err gf_dm_sess_flush_async(GF_DownloadSession *sess, Bool no_select)
+{
+	if (!sess) return GF_OK;
+
+	if (!no_select && (gf_sk_select(sess->sock, GF_SK_SELECT_WRITE)!=GF_OK)) {
+		return GF_IP_NETWORK_EMPTY;
+	}
+#ifdef GPAC_HAS_HTTP2
+	if (sess->h2_local_buf_len) {
+		u8 was_eos = sess->h2_is_eos;
+		assert(sess->h2_send_data==NULL);
+		sess->h2_send_data = sess->h2_local_buf;
+		sess->h2_send_data_len = sess->h2_local_buf_len;
+		gf_mx_p(sess->mx);
+		if (sess->h2_data_paused) {
+			sess->h2_data_paused = 0;
+			nghttp2_session_resume_data(sess->h2_sess->ng_sess, sess->h2_stream_id);
+		}
+		h2_flush_send(sess, GF_TRUE);
+		gf_mx_v(sess->mx);
+		if (sess->h2_send_data_len) {
+			if (sess->h2_send_data_len<sess->h2_local_buf_len) {
+				memmove(sess->h2_local_buf, sess->h2_send_data, sess->h2_send_data_len);
+				sess->h2_local_buf_len = sess->h2_send_data_len;
+			}
+			sess->h2_send_data = NULL;
+			sess->h2_send_data_len = 0;
+			sess->h2_is_eos = was_eos;
+			return GF_IP_NETWORK_EMPTY;
+		}
+		sess->h2_local_buf_len = 0;
+		sess->h2_is_eos = 0;
+	}
+#endif
+
+#ifdef GPAC_HAS_HTTP2
+	//if H2 flush the parent session holding the http2 session
+	if (sess->h2_sess)
+		sess = sess->h2_sess->net_sess;
+#endif
+
+	if (sess->async_buf_size) {
+		GF_Err e = dm_sess_write(sess, sess->async_buf, sess->async_buf_size);
+		if (e) return e;
+		if (sess->async_buf_size) return GF_IP_NETWORK_EMPTY;
+	}
+	return GF_OK;
+}
+
+u32 gf_dm_sess_async_pending(GF_DownloadSession *sess)
+{
+	if (!sess) return 0;
+#ifdef GPAC_HAS_HTTP2
+	if (sess->h2_local_buf_len) return sess->h2_local_buf_len;
+	if (sess->h2_sess)
+		sess = sess->h2_sess->net_sess;
+#endif
+	return sess ? sess->async_buf_size : 0;
+}
+
 GF_EXPORT
 GF_Err gf_dm_sess_send(GF_DownloadSession *sess, u8 *data, u32 size)
 {
@@ -6429,7 +6916,7 @@
 		if (sess->h2_send_data)
 			return GF_SERVICE_ERROR;
 		if (!sess->h2_stream_id)
-			return GF_SERVICE_ERROR;
+			return GF_URL_REMOVED;
 
 		gf_mx_p(sess->mx);
 
@@ -6443,13 +6930,21 @@
 		}
 		//if no data, signal end of stream, otherwise regular send
 		if (!data || !size) {
+			if (sess->h2_local_buf_len) {
+				gf_mx_v(sess->mx);
+				if (sess->h2_is_eos) {
+					return GF_IP_NETWORK_EMPTY;
+				}
+				sess->h2_is_eos = 1;
+				return GF_OK;
+			}
 			sess->h2_is_eos = 1;
 			h2_session_send(sess);
 			//stream_id is not yet 0 in case of PUT/PUSH, stream is closed once we get reply from server
 		} else {
 			sess->h2_is_eos = 0;
 			//send the data
-			h2_flush_send(sess);
+			h2_flush_send(sess, GF_FALSE);
 		}
 		sess->h2_is_eos = 0;
 
@@ -6462,6 +6957,8 @@
 				return GF_OK;
 			}
 		}
+		if (!sess->h2_stream_id && sess->h2_send_data)
+			return GF_URL_REMOVED;
 		return GF_OK;
 	}
 #endif
@@ -6475,19 +6972,17 @@
 		return GF_OK;
 	}
 
-#ifdef GPAC_HAS_SSL
-	if (sess->ssl) {
-		e = gf_ssl_write(sess->ssl, data, size);
-	} else
-#endif
-		e = gf_sk_send(sess->sock, data, size);
+	e = dm_sess_write(sess, data, size);
 
 	if (e==GF_IP_CONNECTION_CLOSED) {
 		sess_connection_closed(sess);
 		sess->status = GF_NETIO_STATE_ERROR;
 		return e;
 	}
-	else if (e==GF_IP_SOCK_WOULD_BLOCK) {
+	else if (e==GF_IP_NETWORK_EMPTY) {
+		if (sess->flags & GF_NETIO_SESSION_NO_BLOCK)
+			return GF_OK;
+
 		return gf_dm_sess_send(sess, data, size);
 	}
 	return e;
@@ -6496,27 +6991,66 @@
 void gf_dm_sess_flush_h2(GF_DownloadSession *sess)
 {
 #ifdef GPAC_HAS_HTTP2
-	u64 in_time;
-	u32 res;
-	char h2_flush2024;
 	if (!sess->h2_sess) return;
+	nghttp2_submit_shutdown_notice(sess->h2_sess->ng_sess);
+	h2_session_send(sess);
 
+	//commented out as it seems go_away is never set
+#if 1
+	u64 in_time;
 	in_time = gf_sys_clock_high_res();
 	while (nghttp2_session_want_read(sess->h2_sess->ng_sess)) {
+		u32 res;
+		char h2_flush2024;
 		GF_Err e;
 		if (gf_sys_clock_high_res() - in_time > 100000)
 			break;
 
 		//read any frame pending from remote peer (window update and co)
 		e = gf_dm_read_data(sess, h2_flush, 2023, &res);
-		if ((e<0) && (e != GF_IP_NETWORK_EMPTY) && (e != GF_IP_SOCK_WOULD_BLOCK)) {
-			sess->last_error = e;
-			sess->status = GF_NETIO_STATE_ERROR;
+		if ((e<0) && (e != GF_IP_NETWORK_EMPTY)) {
+			if (e!=GF_IP_CONNECTION_CLOSED) {
+				SET_LAST_ERR(e)
+				sess->status = GF_NETIO_STATE_ERROR;
+			}
 			break;
 		}
+
+		h2_session_send(sess);
 	}
+#else
+	sess->status = GF_NETIO_DISCONNECTED;
+#endif
+
 #endif
 }
 
+GF_Socket *gf_dm_sess_get_socket(GF_DownloadSession *sess)
+{
+	return sess ? sess->sock : NULL;
+}
 
-#endif
+void gf_dm_sess_set_sock_group(GF_DownloadSession *sess, GF_SockGroup *sg)
+{
+	if (sess) {
+		if (sess->sock_group!=sg) {
+			if (sess->sock_group)
+				gf_sk_group_unregister(sess->sock_group, sess->sock);
+			if (sg)
+				gf_sk_group_register(sg, sess->sock);
+		}
+		sess->sock_group = sg;
+	}
+}
+
+void gf_dm_sess_force_blocking(GF_DownloadSession *sess)
+{
+	if (sess->sock) {
+		while (sess->async_buf_size) {
+			gf_dm_sess_flush_async(sess, GF_FALSE);
+			gf_sleep(1);
+		}
+		gf_sk_set_block_mode(sess->sock, GF_FALSE);
+	}
+	sess->flags &= ~GF_NETIO_SESSION_NO_BLOCK;
+}

gpac-2.0.0.tar.gz/src/utils/error.c -> gpac-2.2.0.tar.gz/src/utils/error.c Changed

@@ -134,16 +134,21 @@
 }
 
 static gf_on_progress_cbk prog_cbk = NULL;
-static void *user_cbk;
+static void *user_cbk = NULL;
+#if defined(GPAC_CONFIG_IOS) || defined(GPAC_CONFIG_ANDROID)
+static Bool gpac_no_color_logs = GF_TRUE;
+#else
 static Bool gpac_no_color_logs = GF_FALSE;
+#endif
 
 GF_EXPORT
 void gf_set_progress(const char *title, u64 done, u64 total)
 {
 	if (done>=total)
 		done=total;
-	if (prog_cbk) {
-		prog_cbk(user_cbk, title, done, total);
+	if (prog_cbk || user_cbk) {
+		if (prog_cbk)
+			prog_cbk(user_cbk, title, done, total);
 	}
 #ifndef _WIN32_WCE
 	else {
@@ -612,6 +617,7 @@
 	return GF_FALSE;
 }
 
+GF_EXPORT
 const char *gf_log_tool_name(GF_LOG_Tool log_tool)
 {
 	if (log_tool>=GF_LOG_TOOL_MAX) return "unknown";
@@ -638,22 +644,30 @@
 FILE *gpac_log_file = NULL;
 Bool gpac_log_time_start = GF_FALSE;
 Bool gpac_log_utc_time = GF_FALSE;
+Bool last_log_is_lf = GF_TRUE;
 static u64 gpac_last_log_time=0;
 
-static void do_log_time(FILE *logs)
+static void do_log_time(FILE *logs, const char *fmt)
 {
-	if (gpac_log_time_start) {
-		u64 now = gf_sys_clock_high_res();
-		gf_fprintf(logs, "At "LLD" (diff %d) - ", now, (u32) (now - gpac_last_log_time) );
-		gpac_last_log_time = now;
-	}
-	if (gpac_log_utc_time) {
-		u64 utc_clock = gf_net_get_utc() ;
-		time_t secs = utc_clock/1000;
-		struct tm t;
-		t = *gf_gmtime(&secs);
-		gf_fprintf(logs, "UTC %d-%02d-%02dT%02d:%02d:%02dZ (TS "LLU") - ", 1900+t.tm_year, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, utc_clock);
+	if (!gpac_log_time_start && !gpac_log_utc_time) return;
+
+	if (last_log_is_lf) {
+		if (gpac_log_time_start) {
+			u64 now = gf_sys_clock_high_res();
+			gf_fprintf(logs, "At "LLD" (diff %d) - ", now, (u32) (now - gpac_last_log_time) );
+			gpac_last_log_time = now;
+		}
+		if (gpac_log_utc_time) {
+			u64 utc_clock = gf_net_get_utc() ;
+			time_t secs = utc_clock/1000;
+			struct tm t;
+			t = *gf_gmtime(&secs);
+			gf_fprintf(logs, "UTC %d-%02d-%02dT%02d:%02d:%02dZ (TS "LLU") - ", 1900+t.tm_year, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, utc_clock);
+		}
 	}
+	u32 flen = (u32) strlen(fmt);
+	if (flen && fmtflen-1 == '\n') last_log_is_lf = GF_TRUE;
+	else last_log_is_lf = GF_FALSE;
 }
 
 int gf_fileio_printf(GF_FileIO *gfio, const char *format, va_list args);
@@ -662,7 +676,7 @@
 {
 	FILE *logs = gpac_log_file ? gpac_log_file : stderr;
 	if (tool != GF_LOG_APP)
-		do_log_time(logs);
+		do_log_time(logs, fmt);
 
 	if (gf_fileio_check(logs)) {
 		gf_fileio_printf((GF_FileIO *)logs, fmt, vlist);
@@ -696,7 +710,7 @@
 		break;
 	}
 	if (tool != GF_LOG_APP)
-		do_log_time(stderr);
+		do_log_time(stderr, fmt);
 
 	vfprintf(stderr, fmt, vlist);
 	gf_sys_set_console_code(stderr, GF_CONSOLE_RESET);
@@ -787,10 +801,22 @@
 void gf_log_lt(GF_LOG_Level ll, GF_LOG_Tool lt)
 {
 }
+
+Bool log_exit_on_error=GF_FALSE;
 GF_EXPORT
 Bool gf_log_set_strict_error(Bool strict)
 {
-	return GF_FALSE;
+	Bool old = log_exit_on_error;
+	log_exit_on_error = strict;
+	return old;
+}
+
+GF_EXPORT
+void gf_log_check_error(GF_LOG_Level loglev, GF_LOG_Tool logtool)
+{
+	if (log_exit_on_error && (loglev==GF_LOG_ERROR) && (logtool != GF_LOG_MEMORY)) {
+		exit(1);
+	}
 }
 
 GF_EXPORT
@@ -899,9 +925,7 @@
 		return "Network Unreachable";
 
 	case GF_IP_NETWORK_EMPTY:
-		return "Network Timeout";
-	case GF_IP_SOCK_WOULD_BLOCK:
-		return "Socket Would Block";
+		return "Network Empty";
 	case GF_IP_CONNECTION_CLOSED:
 		return "Connection to server closed";
 	case GF_IP_UDP_TIMEOUT:
@@ -1757,32 +1781,6 @@
 	return defined_languagesidx.three_char_code;
 }
 
-GF_EXPORT
-GF_Err gf_blob_get(const char *blob_url, u8 **out_data, u32 *out_size, u32 *out_flags)
-{
-	GF_Blob *blob = NULL;
-	if (strncmp(blob_url, "gmem://", 7)) return GF_BAD_PARAM;
-	if (sscanf(blob_url, "gmem://%p", &blob) != 1) return GF_BAD_PARAM;
-	if (!blob) return GF_BAD_PARAM;
-	if (blob->data && blob->mx)
-		gf_mx_p(blob->mx);
-	if (out_data) *out_data = blob->data;
-	if (out_size) *out_size = blob->size;
-	if (out_flags) *out_flags = blob->flags;
-	return GF_OK;
-}
-
-GF_EXPORT
-GF_Err gf_blob_release(const char *blob_url)
-{
-    GF_Blob *blob = NULL;
-    if (strncmp(blob_url, "gmem://", 7)) return GF_BAD_PARAM;
-    if (sscanf(blob_url, "gmem://%p", &blob) != 1) return GF_BAD_PARAM;
-    if (!blob) return GF_BAD_PARAM;
-    if (blob->data && blob->mx)
-        gf_mx_v(blob->mx);
-    return GF_OK;
-}
 
 GF_EXPORT
 GF_Err gf_dynstrcat(char **str, const char *to_append, const char *sep)
@@ -1831,7 +1829,7 @@
 	sep = strchr(value, '.');
 	if (!sep) sep = strchr(value, ',');
 	if (!sep) {
-		frac->num = atoi(value);
+		frac->num = atol(value);
 		frac->den = 1;
 		return GF_TRUE;
 	}

gpac-2.0.0.tar.gz/src/utils/gltools.c -> gpac-2.2.0.tar.gz/src/utils/gltools.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2020
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / OpenGL tools used by compositor filter, vout filter and WebGL bindings
@@ -534,6 +534,7 @@
 ";
 
 
+
 static char *gl_shader_vars_yuv4_pack = \
 "uniform sampler2D _gf_%s_1;\n\
 ";
@@ -542,33 +543,57 @@
 "vec2 texc;\n\
 vec4 yuv;\n\
 texc = _gpacTexCoord.st;\n\
-yuv = texture2D(_gf_%s_1, texc).gbr;\n\
+yuv = texture2D(_gf_%s_1, texc);\n\
+yuv.w = 1.0;\n\
+yuv = _gf_%s_mx * yuv;\n\
+yuv.w = 1.0;\n\
+return yuv;\n\
+";
+
+static char *gl_shader_fun_vyu4_pack = \
+"vec2 texc;\n\
+vec4 yuv;\n\
+texc = _gpacTexCoord.st;\n\
+yuv.rgb = texture2D(_gf_%s_1, texc).gbr;\n\
 yuv.w = 1.0;\n\
 yuv = _gf_%s_mx * yuv;\n\
 yuv.w = 1.0;\n\
 return yuv;\n\
 ";
 
+
 static char *gl_shader_fun_yuv4a_pack = \
 "vec2 texc;\n\
 vec4 tex;\n\
 vec4 yuv;\n\
 texc = _gpacTexCoord.st;\n\
-tex = texture2D(_gf_%s_1, texc).rgba;\n\
-yuv.r = tex.g;\n\
-yuv.g = tex.r;\n\
-yuv.b = tex.b;\n\
+tex = texture2D(_gf_%s_1, texc);\n\
+yuv.rgb = tex.rgb;\n\
 yuv.w = 1.0;\n\
 yuv = _gf_%s_mx * yuv;\n\
+yuv.w = tex.a;\n\
+return yuv;\n\
+";
+
+static char *gl_shader_fun_uyv4a_pack = \
+"vec2 texc;\n\
+vec4 tex;\n\
+vec4 yuv;\n\
+texc = _gpacTexCoord.st;\n\
+tex = texture2D(_gf_%s_1, texc);\n\
+yuv.rgb = tex.grb;\n\
 yuv.w = 1.0;\n\
+yuv = _gf_%s_mx * yuv;\n\
+yuv.w = tex.a;\n\
 return yuv;\n\
 ";
 
-#if 1
-//10 bit V, 10 bit Y, 10 bit U, 2 bits lost
-//V: 8 bit R + 2 bits G
-//Y: 6 bit G + 4 bits B
-//U: 4 bit R + 6 bits A
+//uploaded as RGBA describing 10 bit V + 10 bit Y + 10 bit U + 2 bits lost, lost bits in R (first byte)
+//V: 8 bit A + 2 bits B
+//Y: 6 bit B + 4 bits G
+//U: 4 bit G + 6 bits R
+//
+//we do the maths for bit reading, we should add support for GLES3 shift operators as well (but no support in WebGL1)
 static char *gl_shader_fun_yuv4_10_pack = \
 "vec2 texc;\n\
 vec4 val;\n\
@@ -576,56 +601,115 @@
 vec4 yuv;\n\
 texc = _gpacTexCoord.st;\n\
 val = texture2D(_gf_%s_1, texc).rgba;\n\
-valr = int(val.r*255);\n\
-valg = int(val.g*255);\n\
-valb = int(val.b*255);\n\
-vala = int(val.a*63);\n\
-interm1 = valg / 64;\n\
-yuv.b = float( (valr * 4) + (interm1) ) / 1023.0;\n\
+vala = int(val.a*255.0);\n\
+valb = int(val.b*255.0);\n\
+valg = int(val.g*255.0);\n\
+valr = int(val.r*255.0 / 64.0);\n\
+interm1 = valb / 64;\n\
+yuv.b = float( (vala * 4) + (interm1) ) / 1023.0;\n\
 interm1 *= 64;\n\
-interm2 = valb / 16;\n\
-yuv.r = float( ((valg - interm1) * 16) + (interm2) ) / 1023.0;\n\
+interm2 = valg / 16;\n\
+yuv.r = float( ((valb - interm1) * 16) + (interm2) ) / 1023.0;\n\
 interm2 *= 16;\n\
-yuv.g = float( ((valb - interm2) * 64) + vala ) / 1023.0;\n\
+yuv.g = float( ((valg - interm2) * 64) + valr ) / 1023.0;\n\
 yuv.w = 1.0;\n\
 yuv = _gf_%s_mx * yuv;\n\
 yuv.w = 1.0;\n\
 return yuv;\n\
 ";
 
-#else
 
+static char *gl_shader_vars_v210 = \
+"uniform sampler2D _gf_%s_1;\
+uniform float _gf_%s_width;\
+uniform float _gf_%s_gpu_width;\
+";
 
-//in byte order:
-//2 bits lost, 10 bit U, 10 bit Y, 10 bit V
-//U: 6 bit R + 4 bits G
-//Y: 4 bit G + 6 bits B
-//V: 2 bit B + 8 bits A
-static char *gl_shader_fun_yuv4_10_pack = \
+//uploaded as RGBA describing 2 bits lost (in A, last byte) + 3 * 10 bit {U,Y,V} , pattern reapeating 6 times
+//first pattern (x%6==0) is {00b, Cr, Y, Cb} in {A, B, G, R} bytes
+//we decompose RGBA pixel x and x+1 as follows
+//.R: 8 bit R + 2 bits G
+//.G: 6 bit G + 4 bits B
+//.B: 4 bit G + 6 bits A
+//
+//s coordinate is remapped to line pos x in source width pixels
+//the GPU sees the texture as a {stride/4, height} texture
+//so when we fetch from sampler2D we need to convert 6 pixels v210 to 4 pixels RGBA for x
+//but the next pixel we need is 1/gpu_width after x
+//
+//we do the maths for bit reading, we should add support for GLES3 shift operators as well (but no support in WebGL1)
+static char *gl_shader_fun_v210 = \
 "vec2 texc;\n\
-vec4 val;\n\
-int valr, valg, valb, vala, interm1, interm2;\n\
-vec4 yuv;\n\
-texc = _gpacTexCoord.st;\n\
-val = texture2D(_gf_%s_1, texc).rgba;\n\
-valr = int(val.r*63);\n\
-valg = int(val.g*255);\n\
-valb = int(val.b*255);\n\
-vala = int(val.a*255);\n\
-interm1 = valg / 16;\n\
-yuv.b = float( (valr * 16) + (interm1) ) / 1023.0;\n\
-interm1 *= 16;\n\
-interm2 = valb / 4;\n\
-yuv.g = float( ((valg - interm1) * 64) + (interm2) ) / 1023.0;\n\
-interm2 *= 4;\n\
-yuv.r = float( ((valb - interm2) * 256) + vala ) / 1023.0;\n\
+vec4 yuv, yuv1, yuv2, val;\n\
+int x, off_x, dec_x, valr, valg, valb, vala, interm1, interm2;\n\
+float tx_width = _gf_%s_width;\n\
+float tx_gpu_width = _gf_%s_gpu_width;\n\
+x = int(_gpacTexCoord.s * tx_width);\n\
+interm1 = x/6;\n\
+off_x = x - (interm1 * 6);\n\
+x-=off_x;\n\
+if (off_x>=4) dec_x = 2;\n\
+else if (off_x>=2) dec_x = 1;\n\
+else dec_x = 0;\n\
+texc.t = _gpacTexCoord.t;\n\
+texc.s = float(x * 4 / 6 + dec_x) / tx_gpu_width;\n\
+val = texture2D(_gf_%s_1, texc);\n\
+vala = int(val.a*255.0);\n\
+valb = int(val.b*255.0);\n\
+valg = int(val.g*255.0);\n\
+valr = int(val.r*255.0);\n\
+vala = vala - ((vala/64) * 64);\n\
+interm1 = valg / 4;\n\
+yuv1.r = float( valr + (valg - interm1*4)*256 ) / 1023.0;\n\
+interm2 = valb / 16;\n\
+yuv1.g = float( (valb - interm2*16) * 64 + interm1 ) / 1023.0;\n\
+yuv1.b = float( interm2 + vala*16 ) / 1023.0;\n\
+if (off_x==0) {\n\
+yuv.g = yuv1.r;\n\
+yuv.r = yuv1.g;\n\
+yuv.b = yuv1.b;\n\
+} else {\n\
+texc.s = float(x * 4 / 6 + dec_x + 1) / tx_gpu_width;\n\
+val = texture2D(_gf_%s_1, texc);\n\
+vala = int(val.a*255.0);\n\
+valb = int(val.b*255.0);\n\
+valg = int(val.g*255.0);\n\
+valr = int(val.r*255.0);\n\
+vala = vala - ((vala/64) * 64);\n\
+interm1 = valg / 4;\n\
+yuv2.r = float( valr + (valg - interm1*4)*256 ) / 1023.0;\n\
+interm2 = valb / 16;\n\
+yuv2.g = float( (valb - interm2*16) * 64 + interm1 ) / 1023.0;\n\
+yuv2.b = float( interm2 + vala*16 ) / 1023.0;\n\
+if (off_x==1) {\n\
+yuv.g = yuv1.r;\n\
+yuv.r = yuv2.r;\n\
+yuv.b = yuv1.b;\n\
+} else if (off_x==2) {\n\
+yuv.g = yuv1.g;\n\
+yuv.r = yuv1.b;\n\
+yuv.b = yuv2.r;\n\
+} else if (off_x==3) {\n\
+yuv.g = yuv1.g;\n\
+yuv.r = yuv2.g;\n\
+yuv.b = yuv2.r;\n\
+} else if (off_x==4) {\n\
+yuv.g = yuv1.b;\n\
+yuv.r = yuv2.r;\n\
+yuv.b = yuv2.g;\n\
+} else {\n\
+yuv.g = yuv1.b;\n\
+yuv.r = yuv2.b;\n\
+yuv.b = yuv2.g;\n\
+}\n\
+}\n\
 yuv.w = 1.0;\n\
 yuv = _gf_%s_mx * yuv;\n\
 yuv.w = 1.0;\n\
 return yuv;\n\
 ";
 
-#endif
+
 
 static char *gl_shader_vars_rgb = \
 "uniform sampler2D _gf_%s_1;\n\
@@ -669,7 +753,7 @@
 ocol.r = col_r / 31.0;\n\
 ocol.g = col_g / 31.0;\n\
 ocol.b = col_b / 31.0;\n\
-ocol.a = 1.0:\n\
+ocol.a = 1.0;\n\
 return ocol;\
 ";
 
@@ -774,14 +858,26 @@
 		shader_vars = gl_shader_vars_yuv4_pack;
 		shader_fun = gl_shader_fun_yuv4_pack;
 		break;
+	case GF_PIXEL_VYU444_PACK:
+		shader_vars = gl_shader_vars_yuv4_pack;
+		shader_fun = gl_shader_fun_vyu4_pack;
+		break;
 	case GF_PIXEL_YUVA444_PACK:
 		shader_vars = gl_shader_vars_yuv4_pack;
 		shader_fun = gl_shader_fun_yuv4a_pack;
 		break;
+	case GF_PIXEL_UYVA444_PACK:
+		shader_vars = gl_shader_vars_yuv4_pack;
+		shader_fun = gl_shader_fun_uyv4a_pack;
+		break;
 	case GF_PIXEL_YUV444_10_PACK:
 		shader_vars = gl_shader_vars_yuv4_pack;
 		shader_fun = gl_shader_fun_yuv4_10_pack;
 		break;
+	case GF_PIXEL_V210:
+		shader_vars = gl_shader_vars_v210;
+		shader_fun = gl_shader_fun_v210;
+		break;
 	case GF_PIXEL_ALPHAGREY:
 		shader_vars = gl_shader_vars_rgb;
 		shader_fun = gl_shader_fun_alphagrey;
@@ -893,6 +989,9 @@
 	else
 		tx->mx_cicp = matrix_coef_or_neg;
 
+	if (!tx->stride)
+		gf_pixel_get_size_info(tx->pix_fmt, tx->width, tx->height, NULL, &tx->stride, &tx->uv_stride, NULL, &tx->uv_h);
+
 	switch (tx->pix_fmt) {
 	case GF_PIXEL_YUV444_10:
 		tx->bit_depth = 10;
@@ -969,9 +1068,16 @@
 		tx->is_yuv = GF_TRUE;
 		tx->nb_textures = 1;
 		break;
+	case GF_PIXEL_V210:
+		tx->is_yuv = GF_TRUE;
+		tx->nb_textures = 1;
+		break;
+
 	case GF_PIXEL_YUVA444_PACK:
+	case GF_PIXEL_UYVA444_PACK:
 		tx->has_alpha = GF_TRUE;
 	case GF_PIXEL_YUV444_PACK:
+	case GF_PIXEL_VYU444_PACK:
 	case GF_PIXEL_YUV444_10_PACK:
 		tx->uv_w = tx->width;
 		tx->uv_h = tx->height;
@@ -1038,7 +1144,7 @@
 		tx->internal_textures = GF_FALSE;
 		break;
 	default:
-		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Core Pixel format %s unknown, cannot setup texture wrapper\n", gf_4cc_to_str(tx->pix_fmt)));
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Core Pixel format %s unsupported, cannot setup texture wrapper\n", gf_4cc_to_str(tx->pix_fmt)));
 		return GF_FALSE;
 	}
 
@@ -1180,6 +1286,8 @@
 		}
 	} else {
 		u32 st_o;
+		if (!frame_ifce->get_plane)
+			return GF_FALSE;
 		if (tx->nb_textures)
 			frame_ifce->get_plane(frame_ifce, 0, &data, &stride_luma);
 		if (tx->nb_textures>1)
@@ -1257,14 +1365,24 @@
 				glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, tx->PBOs0);
 				ptr =(u8 *)glMapBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB);
 
-				if (tx->pix_fmt==GF_PIXEL_YUV444_PACK)
+				switch (tx->pix_fmt) {
+				case GF_PIXEL_YUV444_PACK:
+				case GF_PIXEL_VYU444_PACK:
 					linesize = 3 * tx->width;
-				else if (tx->pix_fmt==GF_PIXEL_YUVA444_PACK)
+					break;
+				case GF_PIXEL_YUVA444_PACK:
+				case GF_PIXEL_UYVA444_PACK:
 					linesize = 4 * tx->width;
-				else if (tx->pix_fmt==GF_PIXEL_YUV444_10_PACK)
+					break;
+				case GF_PIXEL_YUV444_10_PACK:
 					linesize = 4 * tx->width;
-				else
+					break;
+				case GF_PIXEL_V210:
+					linesize = tx->width * 16 / 6;
+					break;
+				default:
 					linesize = tx->width/2 * tx->bytes_per_pix * 4;
+				}
 
 				p_stride = stride_luma;
 				count = tx->height;
@@ -1281,12 +1399,14 @@
 				glBindTexture(GL_TEXTURE_2D, tx->textures0 );
 				glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, tx->PBOs0);
 
-				if (tx->pix_fmt==GF_PIXEL_YUV444_PACK)
+				if ((tx->pix_fmt==GF_PIXEL_YUV444_PACK) || (tx->pix_fmt==GF_PIXEL_VYU444_PACK))
 					glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tx->width, tx->height, 0, GL_RGB, tx->memory_format, NULL);
-				else if (tx->pix_fmt==GF_PIXEL_YUVA444_PACK)
+				else if ((tx->pix_fmt==GF_PIXEL_YUVA444_PACK) || (tx->pix_fmt==GF_PIXEL_UYVA444_PACK))
 					glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tx->width, tx->height, 0, GL_RGBA, tx->memory_format, NULL);
 				else if (tx->pix_fmt==GF_PIXEL_YUV444_10_PACK)
 					glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tx->width, tx->height, 0, GL_RGBA, tx->memory_format, NULL);
+				else if (tx->pix_fmt==GF_PIXEL_V210)
+					glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tx->width, tx->height, 0, GL_RGBA, tx->memory_format, NULL);
 				else
 					glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tx->width/2, tx->height, 0, GL_RGBA, tx->memory_format, NULL);
 				glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
@@ -1371,14 +1491,30 @@
 		glBindTexture(GL_TEXTURE_2D, tx->textures0 );
 
 		use_stride = GF_FALSE;
-		if ((tx->pix_fmt==GF_PIXEL_YUV444_PACK) || (tx->pix_fmt==GF_PIXEL_YUVA444_PACK) || (tx->pix_fmt==GF_PIXEL_YUV444_10_PACK)) {
+		if ((tx->pix_fmt==GF_PIXEL_YUV444_PACK)
+			|| (tx->pix_fmt==GF_PIXEL_VYU444_PACK)
+			|| (tx->pix_fmt==GF_PIXEL_YUVA444_PACK)
+			|| (tx->pix_fmt==GF_PIXEL_UYVA444_PACK)
+			|| (tx->pix_fmt==GF_PIXEL_YUV444_10_PACK)
+			|| (tx->pix_fmt==GF_PIXEL_V210)
+		) {
+			u32 tx_width = tx->width;
 			u32 nb_bytes = 3;
 			GLuint fmt = GL_RGB;
-			if (tx->pix_fmt!=GF_PIXEL_YUV444_PACK) {
+			switch (tx->pix_fmt) {
+			case GF_PIXEL_YUV444_PACK:
+			case GF_PIXEL_VYU444_PACK:
+				break;
+			default:
 				nb_bytes = 4;
 				fmt = GL_RGBA;
 			}
-			if (stride_luma > nb_bytes*tx->width) {
+			if (tx->pix_fmt==GF_PIXEL_V210) {
+				//inverse stride to get number of pixels - this is less than out actual width, we'll undo while repacking
+				tx_width = tx->stride / 4;
+				use_stride = GF_FALSE;
+			}
+			else if (stride_luma > nb_bytes*tx->width) {
 				use_stride = GF_TRUE;
 			}
 
@@ -1386,10 +1522,10 @@
 			if (use_stride) glPixelStorei(GL_UNPACK_ROW_LENGTH, stride_luma/tx->bytes_per_pix);
 #endif
 			if (tx->first_tx_load) {
-				glTexImage2D(GL_TEXTURE_2D, 0, fmt, tx->width, tx->height, 0, fmt, tx->memory_format, pY);
+				glTexImage2D(GL_TEXTURE_2D, 0, fmt, tx_width, tx->height, 0, fmt, tx->memory_format, pY);
 				tx->first_tx_load = GF_FALSE;
 			} else {
-				glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, tx->width, tx->height, fmt, tx->memory_format, pY);
+				glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, tx_width, tx->height, fmt, tx->memory_format, pY);
 			}
 
 		} else {
@@ -1628,6 +1764,7 @@
 	}
 	if (!tx->uniform_setup && gl_program) {
 		s32 loc;
+		Bool needs_gpu_width = GF_FALSE;
 		char szName100;
 		if (tx->is_yuv) {
 			GF_Matrix mx;
@@ -1635,12 +1772,14 @@
 			sprintf(szName, "_gf_%s_mx", tx_name);
 			loc = glGetUniformLocation(gl_program, szName);
 			if (loc == -1) {
-				GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("GL Failed to locate texture %s in shader\n", szName));
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("GL Failed to locate matrix coefficients %s in shader\n", szName));
 				return GF_FALSE;
 			}
 			glUniformMatrix4fv(loc, 1, GL_FALSE, mx.m);
 		}
 		switch (tx->pix_fmt) {
+		case GF_PIXEL_V210:
+			needs_gpu_width = GF_TRUE;
 		case GF_PIXEL_UYVY:
 		case GF_PIXEL_YUYV:
 		case GF_PIXEL_VYUY:
@@ -1656,6 +1795,16 @@
 				return GF_FALSE;
 			}
 			glUniform1f(loc, (GLfloat) tx->width);
+			if (needs_gpu_width) {
+				u32 gpu_width = tx->stride / 4;
+				sprintf(szName, "_gf_%s_gpu_width", tx_name);
+				loc = glGetUniformLocation(gl_program, szName);
+				if (loc == -1) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("GL Failed to locate uniform %s in shader\n", szName));
+					return GF_FALSE;
+				}
+				glUniform1f(loc, (GLfloat) gpu_width);
+			}
 			break;
 		default:
 			break;
@@ -1673,6 +1822,8 @@
 		gf_mx_init(txmx);
 		for (i=0; i<tx->nb_textures; i++) {
 			u32 gl_format = GL_TEXTURE_2D;
+			//everything we do is on this texture unit, including what the parent filter does when fetching the gl texture
+			glActiveTexture(texture_unit + i);
 			if (tx->frame_ifce && tx->frame_ifce->get_gl_texture(tx->frame_ifce, i, &gl_format, &tx->texturesi, &txmx) != GF_OK) {
 				if (!i) {
 					GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("GL Failed to get frame interface OpenGL texture ID for plane %d\n", i));
@@ -1686,7 +1837,7 @@
 #endif
 			if (!tx->texturesi)
 				break;
-			glActiveTexture(texture_unit + i);
+
 			glBindTexture(gl_format, tx->texturesi);
 			glTexParameteri(gl_format, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 			glTexParameteri(gl_format, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

gpac-2.0.0.tar.gz/src/utils/math.c -> gpac-2.2.0.tar.gz/src/utils/math.c Changed

@@ -1808,7 +1808,7 @@
 void gf_mx_apply_bbox(GF_Matrix *mx, GF_BBox *box)
 {
 	u32 i;
-	GF_Vec v4;
+	GF_Vec v8;
 	v0 = box->min_edge;
 	v1 = box->min_edge;
 	v1.x = box->max_edge.x;
@@ -1816,9 +1816,18 @@
 	v2.y = box->max_edge.y;
 	v3 = box->min_edge;
 	v3.z = box->max_edge.z;
+
+	v4 = box->max_edge;
+	v5 = box->max_edge;
+	v5.x = box->min_edge.x;
+	v6 = box->max_edge;
+	v6.y = box->min_edge.y;
+	v7 = box->max_edge;
+	v7.z = box->min_edge.z;
+
 	box->max_edge.x = box->max_edge.y = box->max_edge.z = -FIX_MAX;
 	box->min_edge.x = box->min_edge.y = box->min_edge.z = FIX_MAX;
-	for (i=0; i<4; i++) {
+	for (i=0; i<8; i++) {
 		gf_mx_apply_vec(mx, &vi);
 		if (box->min_edge.x > vi.x) box->min_edge.x = vi.x;
 		if (box->min_edge.y > vi.y) box->min_edge.y = vi.y;
@@ -1830,6 +1839,53 @@
 	gf_bbox_refresh(box);
 }
 
+GF_EXPORT
+void gf_mx_apply_bbox_4x4(GF_Matrix *mx, GF_BBox *box)
+{
+	u32 i;
+	GF_Vec v8;
+	v0 = box->min_edge;
+	v1 = box->min_edge;
+	v1.x = box->max_edge.x;
+	v2 = box->min_edge;
+	v2.y = box->max_edge.y;
+	v3 = box->min_edge;
+	v3.z = box->max_edge.z;
+
+	v4 = box->max_edge;
+	v5 = box->max_edge;
+	v5.x = box->min_edge.x;
+	v6 = box->max_edge;
+	v6.y = box->min_edge.y;
+	v7 = box->max_edge;
+	v7.z = box->min_edge.z;
+
+	box->max_edge.x = box->max_edge.y = box->max_edge.z = -FIX_MAX;
+	box->min_edge.x = box->min_edge.y = box->min_edge.z = FIX_MAX;
+	for (i=0; i<8; i++) {
+		GF_Vec4 vec;
+		vec.x = vi.x;
+		vec.y = vi.y;
+		vec.z = vi.z;
+		vec.q = FIX_ONE;
+		gf_mx_apply_vec_4x4(mx, &vec);
+		if (!vec.q) continue;
+		vec.q = gf_divfix(FIX_ONE, vec.q);
+		vec.x = gf_mulfix(vec.x, vec.q);
+		vec.y = gf_mulfix(vec.y, vec.q);
+		vec.z = gf_mulfix(vec.z, vec.q);
+
+		if (box->min_edge.x > vec.x) box->min_edge.x = vec.x;
+		if (box->min_edge.y > vec.y) box->min_edge.y = vec.y;
+		if (box->min_edge.z > vec.z) box->min_edge.z = vec.z;
+		if (box->max_edge.x < vec.x) box->max_edge.x = vec.x;
+		if (box->max_edge.y < vec.y) box->max_edge.y = vec.y;
+		if (box->max_edge.z < vec.z) box->max_edge.z = vec.z;
+	}
+	gf_bbox_refresh(box);
+}
+
+
 // Apply the rotation portion of a matrix to a vector.
 GF_EXPORT
 void gf_mx_rotate_vector(GF_Matrix *mx, GF_Vec *pt)

gpac-2.0.0.tar.gz/src/utils/module.c -> gpac-2.2.0.tar.gz/src/utils/module.c Changed

gpac-2.0.0.tar.gz/src/utils/os_config_init.c -> gpac-2.2.0.tar.gz/src/utils/os_config_init.c Changed

@@ -23,8 +23,6 @@
 *
 */
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 #include <gpac/config_file.h>
 
 
@@ -49,7 +47,7 @@
 #include <mach-o/dyld.h> /*for _NSGetExecutablePath */
 
 #ifdef GPAC_CONFIG_IOS
-#define TEST_MODULE "osmo4ios"
+#define TEST_MODULE "gpac4ios"
 #else
 #define TEST_MODULE		"gm_"
 #endif
@@ -59,10 +57,7 @@
 #ifdef GPAC_CONFIG_LINUX
 #include <unistd.h>
 #endif
-#ifdef GPAC_CONFIG_ANDROID
-#define DEFAULT_ANDROID_PATH_APP	"/data/data/com.gpac.Osmo4"
-#define DEFAULT_ANDROID_PATH_CFG	"/sdcard/osmo"
-#endif
+
 #define CFG_FILE_NAME	"GPAC.cfg"
 
 #if defined(GPAC_CONFIG_WIN32)
@@ -261,18 +256,44 @@
 #endif
 }
 
-/*FIXME - the paths defined here MUST be coherent with the paths defined in applications/osmo4_android/src/com/gpac/Osmo4/GpacConfig.java'*/
 #elif defined(GPAC_CONFIG_ANDROID)
+static char android_app_data512;
+static char android_external_storage512;
+
+/*
+	Called by GPAC JNI wrappers. If not set, default to app_data=/data/data/io.gpac.gpac and ext_storage=/sdcard
+*/
+GF_EXPORT
+void gf_sys_set_android_paths(const char *app_data, const char *ext_storage)
+{
+	if (app_data && (strlen(app_data)<512)) {
+		strcpy(android_app_data, app_data);
+	}
+	if (ext_storage && (strlen(ext_storage)<512)) {
+		strcpy(android_external_storage, ext_storage);
+	}
+}
+
 
 static Bool get_default_install_path(char *file_path, u32 path_type)
 {
 	if (!file_path) return 0;
 
 	if (path_type==GF_PATH_APP) {
-		strcpy(file_path, DEFAULT_ANDROID_PATH_APP);
+		strcpy(file_path, android_app_data0 ? android_app_data : "/data/data/io.gpac.gpac");
 		return 1;
 	} else if (path_type==GF_PATH_CFG) {
-		strcpy(file_path, DEFAULT_ANDROID_PATH_CFG);
+		const char *res = android_external_storage0 ? android_external_storage : getenv("EXTERNAL_STORAGE");
+		if (!res) res = "/sdcard";
+		strcpy(file_path, res);
+		strcat(file_path, "/GPAC");
+		//GPAC folder exists in external storage, use profile from this location
+		if (gf_dir_exists(file_path)) {
+			return 1;
+		}
+		//otherwise use profile in app data store
+		strcpy(file_path, android_app_data0 ? android_app_data : "/data/data/io.gpac.gpac");
+		strcat(file_path, "/GPAC");
 		return 1;
 	} else if (path_type==GF_PATH_SHARE) {
 		if (!get_default_install_path(file_path, GF_PATH_APP))
@@ -296,8 +317,8 @@
 #define SYMBIAN_GPAC_GUI_DIR	"\\private\\F01F9075\\gui"
 #define SYMBIAN_GPAC_MODULES_DIR	"\\sys\\bin"
 #else
-#define SYMBIAN_GPAC_CFG_DIR	"\\system\\apps\\Osmo4"
-#define SYMBIAN_GPAC_GUI_DIR	"\\system\\apps\\Osmo4\\gui"
+#define SYMBIAN_GPAC_CFG_DIR	"\\system\\apps\\GPAC"
+#define SYMBIAN_GPAC_GUI_DIR	"\\system\\apps\\GPAC\\gui"
 #define SYMBIAN_GPAC_MODULES_DIR	GPAC_CFG_DIR
 #endif
 
@@ -591,8 +612,9 @@
 	sep = strstr(res, ".gpac");
 	assert(sep);
 	sep0 = 0;
-	gf_cfg_set_key(cfg, "General", "LastWorkingDir", res);
-	gf_cfg_set_key(cfg, "General", "iOSDocumentsDir", res);
+	gf_cfg_set_key(cfg, "core", "docs-dir", res);
+	if (!gf_cfg_get_key(cfg, "core", "last-dir"))
+		gf_cfg_set_key(cfg, "core", "last-dir", res);
 
 	strcat(res, "cache/");
 	cache_dir = res;
@@ -696,13 +718,36 @@
 	if (get_default_install_path(szPath, GF_PATH_APP)) {
 		strcat(szPath, "/cache");
 		gf_cfg_set_key(cfg, "core", "cache", szPath);
+		strcat(szPath, "/.nomedia");
+		//create .nomedia in cache and in app dir
+		if (!gf_file_exists(szPath)) {
+			FILE *f = gf_fopen(szPath, "w");
+			if (f) gf_fclose(f);
+		}
+		get_default_install_path(szPath, GF_PATH_APP);
+		strcat(szPath, "/.nomedia");
+		if (!gf_file_exists(szPath)) {
+			FILE *f = gf_fopen(szPath, "w");
+			if (f) gf_fclose(f);
+		}
+		//add a tmp as well, tmpfile() does not work on android
+		get_default_install_path(szPath, GF_PATH_APP);
+		strcat(szPath, "/gpac_tmp");
+		gf_cfg_set_key(cfg, "core", "tmp", szPath);
+		strcat(szPath, "/.nomedia");
+		if (!gf_file_exists(szPath)) {
+			FILE *f = gf_fopen(szPath, "w");
+			if (f) gf_fclose(f);
+		}
 	}
 #else
 	/*get default temporary directoy */
 	gf_cfg_set_key(cfg, "core", "cache", gf_get_default_cache_directory_ex(GF_FALSE));
 #endif
 
+#if defined(WIN32)
 	gf_cfg_set_key(cfg, "core", "ds-disable-notif", "no");
+#endif
 
 	/*Setup font engine to FreeType by default, and locate TrueType font directory on the system*/
 	gf_cfg_set_key(cfg, "core", "font-reader", "FreeType Font Reader");
@@ -724,20 +769,30 @@
 	gf_cfg_set_key(cfg, "core", "video-output", "Android Video Output");
 	gf_cfg_set_key(cfg, "core", "audio-output", "Android Audio Output");
 #else
-	gf_cfg_set_key(cfg, "core", "video-output", "X11 Video Output");
+	//use SDL by default, will fallback to X11 if not found (our X11 wrapper is old and does not have all features of the SDL one)
+	gf_cfg_set_key(cfg, "core", "video-output", "SDL Video Output");
 	gf_cfg_set_key(cfg, "core", "audio-output", "SDL Audio Output");
 #endif
 
+
+#if !defined(GPAC_CONFIG_IOS) && !defined(GPAC_CONFIG_ANDROID)
 	gf_cfg_set_key(cfg, "core", "switch-vres", "no");
 	gf_cfg_set_key(cfg, "core", "hwvmem", "auto");
+#endif
 
+#ifdef GPAC_CONFIG_ANDROID
+	const char *opt = android_external_storage0 ? android_external_storage : getenv("EXTERNAL_STORAGE");
+	if (!opt) opt = "/sdcard";
+	gf_cfg_set_key(cfg, "core", "docs-dir", opt);
+	gf_cfg_set_key(cfg, "core", "last-dir", opt);
+#endif
 
 	/*locate GUI*/
 	if ( get_default_install_path(szPath, GF_PATH_SHARE) ) {
 		char gui_pathGF_MAX_PATH+100;
 		sprintf(gui_path, "%s%cgui%cgui.bt", szPath, GF_PATH_SEPARATOR, GF_PATH_SEPARATOR);
 		if (gf_file_exists(gui_path)) {
-			gf_cfg_set_key(cfg, "General", "StartupFile", gui_path);
+			gf_cfg_set_key(cfg, "core", "startup-file", gui_path);
 		}
 
 		/*shaders are at the same location*/
@@ -793,7 +848,7 @@
 		char *sep;
 		char shader_pathGF_MAX_PATH;
 		strcat(path, "/gui/gui.bt");
-		gf_cfg_set_key(cfg, "General", "StartupFile", path);
+		gf_cfg_set_key(cfg, "core", "startup-file", path);
 		//get rid of "/gui/gui.bt"
 		sep = strrchr(path, '/');
 		sep0 = 0;
@@ -813,7 +868,7 @@
 
 	if ( get_default_install_path(path, GF_PATH_MODULES) ) {
 		opt = gf_cfg_get_key(cfg, "core", "module-dir");
-		//for OSX, we can have an install in /usr/... and an install in /Applications/Osmo4.app - always change
+		//for OSX, we can have an install in /usr/... and an install in /Applications/GPAC.app - always change
 #if defined(__DARWIN__) || defined(__APPLE__)
 		if (!opt || strcmp(opt, path))
 			gf_cfg_set_key(cfg, "core", "module-dir", path);
@@ -853,14 +908,14 @@
 	}
 
 	/*if startup file was disabled, do not attempt to correct it*/
-	if (gf_cfg_get_key(cfg, "General", "StartupFile")==NULL) return;
+	if (gf_cfg_get_key(cfg, "core", "startup-file")==NULL) return;
 
 	if ( get_default_install_path(path, GF_PATH_SHARE) ) {
-		opt = gf_cfg_get_key(cfg, "General", "StartupFile");
+		opt = gf_cfg_get_key(cfg, "core", "startup-file");
 		if (strstr(opt, "gui.bt") && strcmp(opt, path) && strstr(path, ".app") ) {
 #if defined(__DARWIN__) || defined(__APPLE__)
 			strcat(path, "/gui/gui.bt");
-			gf_cfg_set_key(cfg, "General", "StartupFile", path);
+			gf_cfg_set_key(cfg, "core", "startup-file", path);
 #endif
 		}
 	}
@@ -868,6 +923,49 @@
 #endif
 }
 
+#ifdef GPAC_CONFIG_ANDROID
+
+static Bool delete_tmp_files(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
+{
+	if (gf_file_delete(item_path) != GF_OK) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CACHE, ("CORE Failed to cleanup temp file %s\n", item_path));
+	}
+	return GF_FALSE;
+}
+#endif
+
+static void check_default_cred_file(GF_Config *cfg, char szPathGF_MAX_PATH)
+{
+	char key16;
+	u64 v1, v2;
+	const char *opt = gf_cfg_get_key(cfg, "core", "cred");
+	if (opt) return;
+	strcat(szPath, "/creds.key");
+	if (gf_file_exists(szPath)) return;
+
+	GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("core Creating default credential key in %s, use -cred=PATH/TO_FILE to overwrite\n", szPath));
+
+	v1 = gf_rand(); v1<<=32; v1 |= gf_rand();
+	v2 = gf_rand(); v2<<=32; v2 |= gf_rand();
+	v1 |= gf_sys_clock_high_res();
+#ifndef GPAC_64_BITS
+	v2 |= (u64) (u32) cfg;
+	v2 ^= (u64) (u32) szPath;
+#else
+	v2 |= (u64) cfg;
+	v2 ^= (u64) szPath;
+#endif
+	* ( (u64*) &key0 ) = v1;
+	* ( (u64*) &key8 ) = v2;
+	FILE *crd = gf_fopen(szPath, "w");
+	if (!crd) {
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("core Failed to create credential key in %s, credentials will not be stored\n", szPath));
+		return;
+	}
+	fwrite(key, 16, 1, crd);
+	fclose(crd);
+	gf_cfg_set_key(cfg, "core", "cred", szPath);
+}
 
 /*!
 \brief configuration file initialization
@@ -894,7 +992,6 @@
 		if (prof_opt) {
 			prof_len -= (u32) strlen(prof_opt);
 			if (strstr(prof_opt, "reload")) force_new_cfg = GF_TRUE;
-
 			prof_opt0 = 0;
 		}
 	}
@@ -936,20 +1033,44 @@
 	cfg = gf_cfg_new(szPath, CFG_FILE_NAME);
 	//config file not compatible with old arch, check it:
 	if (cfg) {
+		const char *key;
 		u32 nb_old_sec = gf_cfg_get_key_count(cfg, "Compositor");
 		nb_old_sec += gf_cfg_get_key_count(cfg, "MimeTypes");
 		nb_old_sec += gf_cfg_get_key_count(cfg, "Video");
 		nb_old_sec += gf_cfg_get_key_count(cfg, "Audio");
 		nb_old_sec += gf_cfg_get_key_count(cfg, "Systems");
+		nb_old_sec += gf_cfg_get_key_count(cfg, "General");
 		if (! gf_cfg_get_key_count(cfg, "core"))
 			nb_old_sec += 1;
 
+		//check GUI is valid, if not recreate a config
+		key = gf_cfg_get_key(cfg, "core", "startup-file");
+		if (key && !gf_file_exists(key))
+			force_new_cfg = GF_TRUE;
+
+		//check if reset flag is set in existing config
+		if (gf_cfg_get_key(cfg, "core", "reset"))
+			force_new_cfg = GF_TRUE;
+
 		if (nb_old_sec || force_new_cfg) {
 			if (nb_old_sec && (!profile || strcmp(profile, "0"))) {
 				GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("core Incompatible config file %s found in %s - creating new file\n", CFG_FILE_NAME, szPath ));
 			}
 			gf_cfg_del(cfg);
 			cfg = create_default_config(szPath, profile);
+		} else {
+			//check fonts are valid, if not reload fonts
+			Bool rescan_fonts = GF_FALSE;
+			key = gf_cfg_get_key_name(cfg, "FontCache", 0);
+			if (!key)
+				rescan_fonts = GF_TRUE;
+			else {
+				key = gf_cfg_get_key(cfg, "FontCache", key);
+				if (key && !gf_file_exists(key))
+					rescan_fonts = GF_TRUE;
+			}
+			if (rescan_fonts)
+				gf_opts_set_key("core", "rescan-fonts", "yes");
 		}
 	}
 	//no config file found
@@ -971,6 +1092,7 @@
 #endif
 
 	check_modules_dir(cfg);
+	check_default_cred_file(cfg, szPath);
 
 	if (!gf_cfg_get_key(cfg, "core", "store-dir")) {
 		if (profile && !strcmp(profile, "0")) {
@@ -990,6 +1112,18 @@
 
 exit:
 	if (prof_opt) prof_opt0 = ':';
+
+	//clean tmp
+#ifdef GPAC_CONFIG_ANDROID
+	if (cfg) {
+		const char *tmp = gf_cfg_get_key(cfg, "core", "tmp");
+		if (tmp && !strstr(tmp, "/gpac_tmp")) tmp=NULL;
+		if (tmp) {
+			gf_enum_directory(tmp, GF_FALSE, delete_tmp_files, (void*)cfg, NULL);
+		}
+	}
+#endif
+
 	return cfg;
 }
 
@@ -1126,6 +1260,12 @@
 	return gf_cfg_discard_changes(gpac_global_config);
 }
 
+GF_EXPORT
+GF_Err gf_opts_save()
+{
+	return gf_cfg_save(gpac_global_config);
+}
+
 #include <gpac/main.h>
 
 GF_GPACArg GPAC_Args = {
@@ -1210,6 +1350,14 @@
 GF_DEF_ARG("bs-cache-size", NULL, "cache size for bitstream read and write from file (0 disable cache, slower IOs)", "512", NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
 GF_DEF_ARG("no-check", NULL, "disable compliance tests for inputs (ISOBMFF for now). This will likely result in random crashes", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
 GF_DEF_ARG("unhandled-rejection", NULL, "dump unhandled promise rejections", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
+ GF_DEF_ARG("startup-file", NULL, "startup file of compositor in GUI mode", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
+ GF_DEF_ARG("docs-dir", NULL, "default documents directoty (for GUI on iOS and Android)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
+ GF_DEF_ARG("last-dir", NULL, "last working directory (for GUI)", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
+#ifdef GPAC_HAS_POLL
+ GF_DEF_ARG("no-poll", NULL, "disable poll and use select for socket groups", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
+#endif
+ GF_DEF_ARG("no-tls-rcfg", NULL, "disble automatic TCP to TLS reconfiguration", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_CORE),
+
 GF_DEF_ARG("cache", NULL, "cache directory location", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("proxy-on", NULL, "enable HTTP proxy", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("proxy-name", NULL, "set HTTP proxy address", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_HTTP),
@@ -1219,8 +1367,8 @@
 GF_DEF_ARG("offline-cache", NULL, "enable offline HTTP caching (no re-validation of existing resource in cache)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("clean-cache", NULL, "indicate if HTTP cache should be clean upon launch/exit", NULL, NULL, GF_ARG_BOOL, GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("cache-size", NULL, "specify cache size in bytes", "100M", NULL, GF_ARG_INT, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_HTTP),
- GF_DEF_ARG("head-timeout", NULL, "set HTTP head request timeout in milliseconds", "5000", NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
- GF_DEF_ARG("req-timeout", NULL, "set HTTP/RTSP request timeout in milliseconds", "20000", NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
+ GF_DEF_ARG("tcp-timeout", NULL, "time in milliseconds to wait for HTTP/RTSP connect before error", "5000", NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
+ GF_DEF_ARG("req-timeout", NULL, "time in milliseconds to wait on HTTP/RTSP request before error", "10000", NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("no-timeout", NULL, "ignore HTTP 1.1 timeout in keep-alive", "false", NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("broken-cert", NULL, "enable accepting broken SSL certificates", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("user-agent", "ua", "set user agent name for HTTP/RTSP", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_HTTP),
@@ -1229,6 +1377,7 @@
 GF_DEF_ARG("query-string", NULL, "insert query string (without `?`) to URL on requests", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("dm-threads", NULL, "force using threads for async download requests rather than session scheduler", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
 GF_DEF_ARG("cte-rate-wnd", NULL, "set window analysis length in milliseconds for chunk-transfer encoding rate estimation", "20", NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
+ GF_DEF_ARG("cred", NULL, "path to 128 bits key for credential storage", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
 
 #ifdef GPAC_HAS_HTTP2
 GF_DEF_ARG("no-h2", NULL, "disable HTTP2", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HTTP),
@@ -1261,6 +1410,10 @@
 GF_DEF_ARG("no-graph-cache", NULL, "disable internal caching of filter graph connections. If disabled, the graph will be recomputed at each link resolution (lower memory usage but slower)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_FILTERS),
 GF_DEF_ARG("no-reservoir", NULL, "disable memory recycling for packets and properties. This uses much less memory but stresses the system memory allocator much more", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_FILTERS),
 
+ GF_DEF_ARG("buffer-gen", NULL, "default buffer size in microseconds for generic pids", "1000", NULL, GF_ARG_INT, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_FILTERS),
+ GF_DEF_ARG("buffer-dec", NULL, "default buffer size in microseconds for decoder input pids", "1000000", NULL, GF_ARG_INT, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_FILTERS),
+ GF_DEF_ARG("buffer-units", NULL, "default buffer size in frames when timing is not available", "1", NULL, GF_ARG_INT, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_FILTERS),
+
 GF_DEF_ARG("switch-vres", NULL, "select smallest video resolution larger than scene size, otherwise use current video resolution", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_VIDEO),
 GF_DEF_ARG("hwvmem", NULL, "specify (2D rendering only) memory type of main video backbuffer. Depending on the scene type, this may drastically change the playback speed\n"
 "- always: always on hardware\n"
@@ -1278,9 +1431,11 @@
 GF_DEF_ARG("glfbo-txid", NULL, "set output texture ID when using `glfbo` output. The OpenGL context shall be initialized and gf_term_process shall be called with the OpenGL context active", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_VIDEO),
 GF_DEF_ARG("video-output", NULL, "indicate the name of the video output module to use (see `gpac -h modules`)."
 	" The reserved name `glfbo` is used in player mode to draw in the OpenGL texture identified by -glfbo-txid(). "
-	" In this mode, the application is responsible for sending event to the terminal"
+	" In this mode, the application is responsible for sending event to the compositor"
 , NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_VIDEO),
- GF_DEF_ARG("audio-output", NULL, "indicate the name of the audio output module to use", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_VIDEO),
+ GF_DEF_ARG("dfb-sys", NULL, "system DirectFB (x11, sdl, vnc, fbdev, osx ordevmem)", "x11", NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_VIDEO),
+ GF_DEF_ARG("dfb-flip", NULL, "vsync mode for DirectFB (waitsync, wait, sync or swap)", "waitsync", NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_VIDEO),
+ GF_DEF_ARG("audio-output", NULL, "indicate the name of the audio output module to use", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_AUDIO),
 GF_DEF_ARG("alsa-devname", NULL, "set ALSA dev name", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_AUDIO),
 GF_DEF_ARG("force-alsarate", NULL, "force ALSA and OSS output sample rate", NULL, NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_AUDIO),
 GF_DEF_ARG("ds-disable-notif", NULL, "disable DirectSound audio buffer notifications when supported", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_AUDIO),
@@ -1289,6 +1444,12 @@
 GF_DEF_ARG("rescan-fonts", NULL, "indicate the font directory must be rescanned", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_TEXT),
 GF_DEF_ARG("wait-fonts", NULL, "wait for SVG fonts to be loaded before displaying frames", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_TEXT),
 GF_DEF_ARG("webvtt-hours", NULL, "force writing hour when serializing WebVTT", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_TEXT),
+GF_DEF_ARG("charset", NULL, "set charset when not recognized from input. Possible values are:\n"
+"- utf8: force UTF-8\n"
+"- utf16: force UTF-16 little endian\n"
+"- utf16be: force UTF-16 big endian\n"
+"- other: attempt to parse anyway", NULL, NULL, GF_ARG_STRING, GF_ARG_HINT_ADVANCED|GF_ARG_SUBSYS_TEXT),
+
 GF_DEF_ARG("rmt", NULL, "enable profiling through Remotery(https://github.com/Celtoys/Remotery). A copy of Remotery visualizer is in gpac/share/vis, usually installed in __/usr/share/gpac/vis__ or __Program Files/GPAC/vis__", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_RMT),
 GF_DEF_ARG("rmt-port", NULL, "set remotery port", "17815", NULL, GF_ARG_INT, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_RMT),
 GF_DEF_ARG("rmt-reuse", NULL, "allow remotery to reuse port", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_RMT),
@@ -1302,6 +1463,7 @@
 GF_DEF_ARG("m2ts-vvc-old", NULL, "hack for old TS streams using 0x32 for VVC instead of 0x33", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HACKS),
 GF_DEF_ARG("piff-force-subsamples", NULL, "hack for PIFF PSEC files generated by 0.9.0 and 1.0 MP4Box with wrong subsample_count inserted for audio", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HACKS),
 GF_DEF_ARG("vvdec-annexb", NULL, "hack for old vvdec+libavcodec supporting only annexB format", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HACKS),
+ GF_DEF_ARG("heif-hevc-urn", NULL, "use HEVC URN for alpha and depth in HEIF instead of MPEG-B URN (HEIF first edition)", NULL, NULL, GF_ARG_BOOL, GF_ARG_HINT_EXPERT|GF_ARG_SUBSYS_HACKS),
 
 
 {0}
@@ -1434,7 +1596,7 @@
 	}
 	gf_opts_set_key(szSec, szKey, szVal0 ? szVal : NULL);
 
-	if (!strcmp(szSec, "core")) {
+	if (!strcmp(szSec, "core") || !strcmp(szSec, "temp")) {
 		if (!strcmp(szKey, "noprog") && (!strcmp(szVal, "yes")||!strcmp(szVal, "true")||!strcmp(szVal, "1")) ) {
 			void gpac_disable_progress();
 
@@ -1505,7 +1667,6 @@
 				if (sec_hdr_done)
 					fprintf(stdout, "\n");
 			}
-			exit(0);
 		}
 		return GF_TRUE;
 	}
@@ -1747,7 +1908,11 @@
 
 void gf_sys_cleanup_help()
 {
-	if (help_buf) gf_free(help_buf);
+	if (help_buf) {
+		gf_free(help_buf);
+		help_buf = NULL;
+		help_buf_size = 0;
+	}
 }
 
 
@@ -1863,6 +2028,15 @@
 	}
 #endif
 
+/*#ifdef GPAC_CONFIG_ANDROID
+	//on android use logs for help print
+	if (!gen_doc) {
+		GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("%s", help_buf));
+		return;
+	}
+#endif
+*/
+
 	line = help_buf;
 	while (line0) {
 		u32 att_len = 0;
@@ -2129,7 +2303,7 @@
 
 					if (pipe_start) {
 						pipe_start0 = 0;
-						fprintf(helpout, "%s,", src_line);
+						fprintf(helpout, "%s ", src_line);
 						pipe_start0 = '|';
 						src_line = pipe_start+1;
 					} else {
@@ -2326,7 +2500,7 @@
 		if (s1 && !s2) return GF_FALSE;
 		if (!s1 && s2) return GF_FALSE;
 
-		if (strstr(dst, orig))
+		if (gf_strnistr(dst, orig, MIN(olen, dlen)))
 			return GF_TRUE;
 		return GF_FALSE;
 	}
@@ -2391,5 +2565,3 @@
 		return GF_TRUE;
 	return GF_FALSE;
 }
-
-#endif

gpac-2.0.0.tar.gz/src/utils/os_divers.c -> gpac-2.2.0.tar.gz/src/utils/os_divers.c Changed

@@ -153,7 +153,7 @@
 
 #endif
 
-static Bool gf_sys_enable_remotery(Bool start, Bool is_shutdown);
+Bool gf_sys_enable_remotery(Bool start, Bool is_shutdown);
 
 
 GF_EXPORT
@@ -484,12 +484,18 @@
 
 char gf_prompt_get_char()
 {
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) return 0;
+#endif
 	return getchar();
 }
 
 GF_EXPORT
 void gf_prompt_set_echo_off(Bool echo_off)
 {
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) return;
+#endif
 	DWORD flags;
 	HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
 	BOOL ret = GetConsoleMode(hStdin, &flags);
@@ -549,6 +555,10 @@
 GF_EXPORT
 void gf_prompt_set_echo_off(Bool echo_off)
 {
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) return;
+#endif
+
 	init_keyboard();
 	if (echo_off) t_orig.c_lflag &= ~ECHO;
 	else t_orig.c_lflag |= ECHO;
@@ -585,6 +595,9 @@
 char gf_prompt_get_char()
 {
 	char ch;
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) return 0;
+#endif
 	if (ch_peek != -1) {
 		ch = ch_peek;
 		ch_peek = -1;
@@ -894,6 +907,7 @@
 
 static u32 gpac_quiet = 0;
 char gf_prog_lf = '\r';
+extern Bool gpac_use_poll;
 
 GF_EXPORT
 GF_Err gf_sys_set_args(s32 argc, const char **argv)
@@ -903,28 +917,31 @@
 		Bool gf_opts_load_option(const char *arg_name, const char *val, Bool *consumed_next, GF_Err *e);
 		void gf_cfg_load_restrict();
 
+		gpac_use_poll = GF_TRUE;
+
 		for (i=1; i<argc; i++) {
 			Bool consumed;
 			GF_Err e;
-			Bool use_sep=GF_FALSE;
+			Bool use_sep = GF_FALSE;
 			Bool bool_value = GF_TRUE;
+			char szArg1024;
 			char *arg_val;
 			const char *arg = argvi;
 			if (!arg) continue;
 
 			arg_val = strchr(arg, '=');
 			if (arg_val) {
-				arg_val0=0;
+				u32 len = (u32) (arg_val-arg);
+				if (len>1023) len = 1023;
+				strncpy(szArg, arg, len);
+				szArglen=0;
 				arg_val++;
-				use_sep=GF_TRUE;
+				arg = szArg;
+				use_sep = GF_TRUE;
 			} else if (i+1<argc) {
 				arg_val = (char *) argvi+1;
 			}
 			if ((arg0 != '-') || ! arg1) {
-				if (use_sep) {
-					arg_val--;
-					arg_val0='=';
-				}
 				continue;
 			}
 			if (arg_val && (!strcmp(arg_val, "no") || !strcmp(arg_val, "false") || !strcmp(arg_val, "°0") ) )
@@ -943,7 +960,7 @@
 			} else if (!strcmp(arg, "-logs") ) {
 				e = gf_log_set_tools_levels(arg_val, GF_FALSE);
 				if (e) return e;
-				
+
 				if (!use_sep) i += 1;
 			} else if (!strcmp(arg, "-log-clock") || !strcmp(arg, "-lc")) {
 #ifndef GPAC_DISABLE_LOG
@@ -965,20 +982,18 @@
 				gpac_old_arch = bool_value;
 			} else if (!stricmp(arg, "-no-save")) {
 				gpac_discard_config = bool_value;
+			} else if (!stricmp(arg, "-no-poll")) {
+				gpac_use_poll = bool_value;
 			} else if (!stricmp(arg, "-ntp-shift")) {
 				s32 shift = arg_val ? atoi(arg_val) : 0;
 				gf_net_set_ntp_shift(shift);
 				if (!use_sep) i += 1;
 			} else if (gf_opts_load_option(arg, arg_val, &consumed, &e)) {
 				if (e) return e;
-				
+
 				if (consumed && !use_sep)
 					i += 1;
 			}
-			if (use_sep) {
-				arg_val--;
-				arg_val0='=';
-			}
 		}
 
 #ifdef GPAC_CONFIG_DARWIN
@@ -1003,7 +1018,6 @@
 		}
 		//now that we have parsed all options, load restrict
 		gf_cfg_load_restrict();
-
 	}
 	//for OSX we allow overwrite of argc/argv due to different behavior between console-mode apps and GUI
 #if !defined(__DARWIN__) && !defined(__APPLE__)
@@ -1127,7 +1141,7 @@
 }
 #endif
 
-static Bool gf_sys_enable_remotery(Bool start, Bool is_shutdown)
+Bool gf_sys_enable_remotery(Bool start, Bool is_shutdown)
 {
 #ifndef GPAC_DISABLE_REMOTERY
 	if (start && !remotery_handle) {
@@ -1223,6 +1237,80 @@
 	return GF_FALSE;
 }
 
+#include <gpac/list.h>
+GF_List *all_blobs = NULL;
+
+GF_EXPORT
+GF_Err gf_blob_get(const char *blob_url, u8 **out_data, u32 *out_size, u32 *out_flags)
+{
+	GF_Blob *blob = NULL;
+	if (strncmp(blob_url, "gmem://", 7)) return GF_BAD_PARAM;
+	if (sscanf(blob_url, "gmem://%p", &blob) != 1) return GF_BAD_PARAM;
+	if (!blob)
+		return GF_BAD_PARAM;
+	if (gf_list_find(all_blobs, blob)<0)
+		return GF_URL_REMOVED;
+	if (blob->data && blob->mx)
+		gf_mx_p(blob->mx);
+	if (out_data) *out_data = blob->data;
+	if (out_size) *out_size = blob->size;
+	if (out_flags) *out_flags = blob->flags;
+	return GF_OK;
+}
+
+GF_EXPORT
+GF_Err gf_blob_release(const char *blob_url)
+{
+ GF_Blob *blob = NULL;
+ if (strncmp(blob_url, "gmem://", 7)) return GF_BAD_PARAM;
+ if (sscanf(blob_url, "gmem://%p", &blob) != 1) return GF_BAD_PARAM;
+ if (!blob)
+		return GF_BAD_PARAM;
+	if (gf_list_find(all_blobs, blob)<0)
+		return GF_URL_REMOVED;
+ if (blob->data && blob->mx)
+ gf_mx_v(blob->mx);
+ return GF_OK;
+}
+
+GF_EXPORT
+char *gf_blob_register(GF_Blob *blob)
+{
+	char szPath200;
+	if (!blob) return NULL;
+	sprintf(szPath, "gmem://%p", blob);
+	if (!all_blobs) {
+		all_blobs = gf_list_new();
+	} else {
+		gf_list_del_item(all_blobs, blob);
+	}
+	gf_list_add(all_blobs, blob);
+
+	return gf_strdup(szPath);
+}
+
+GF_EXPORT
+void gf_blob_unregister(GF_Blob *blob)
+{
+	if (!blob) return;
+	if (all_blobs) gf_list_del_item(all_blobs, blob);
+}
+
+//unused
+#if 0
+GF_Blob *gf_blob_from_url(const char *blob_url)
+{
+	GF_Blob *blob = NULL;
+	if (strncmp(blob_url, "gmem://", 7)) return NULL;
+	if (sscanf(blob_url, "gmem://%p", &blob) != 1) return NULL;
+	if (!blob)
+		return NULL;
+	if (gf_list_find(all_blobs, blob)<0)
+		return NULL;
+	return blob;
+}
+#endif
+
 void gf_init_global_config(const char *profile);
 void gf_uninit_global_config(Bool discard_config);
 
@@ -1266,6 +1354,47 @@
 	return def_val;
 }
 
+static void gf_sys_refresh_cache()
+{
+	u32 i, count;
+	count = gf_opts_get_section_count();
+	for (i=0; i<count; i++) {
+		const char *opt;
+		u32 sec, frac, exp;
+		Bool force_delete;
+		const char *file;
+		const char *name = gf_opts_get_section_name(i);
+		if (strncmp(name, "@cache=", 7)) continue;
+
+		file = gf_opts_get_key(name, "cacheFile");
+		opt = gf_opts_get_key(name, "expireAfterNTP");
+		if (!opt) {
+			if (file) gf_file_delete((char*) file);
+			gf_opts_del_section(name);
+			i--;
+			count--;
+			continue;
+		}
+
+		force_delete = 0;
+		if (file && gf_file_exists(file)) {
+			force_delete = 1;
+		}
+		sscanf(opt, "%u", &exp);
+		gf_net_get_ntp(&sec, &frac);
+		if (exp && (exp<sec)) force_delete=1;
+
+		if (force_delete) {
+			if (file) gf_file_delete(file);
+
+			gf_opts_del_section(name);
+			i--;
+			count--;
+			continue;
+		}
+	}
+}
+
 GF_EXPORT
 GF_Err gf_sys_init(GF_MemTrackerType mem_tracker_type, const char *profile)
 {
@@ -1370,9 +1499,10 @@
 		logs_mx = gf_mx_new("Logs");
 
 		gf_rand_init(GF_FALSE);
-		
+
 		gf_init_global_config(profile);
 
+		gf_sys_refresh_cache();
 
 	}
 	sys_init += 1;
@@ -1415,7 +1545,12 @@
 #endif
 
 		gf_sys_enable_remotery(GF_FALSE, GF_TRUE);
-		
+
+#ifdef GPAC_HAS_QJS
+		void gf_js_delete_runtime();
+		gf_js_delete_runtime();
+#endif
+
 		gf_uninit_global_config(gpac_discard_config);
 
 #ifndef GPAC_DISABLE_LOG
@@ -1437,6 +1572,14 @@
 			gf_free(gpac_argv_state);
 			gpac_argv_state = NULL;
 		}
+		gpac_argc = 0;
+		gpac_argv = NULL;
+		memory_at_gpac_startup = 0;
+		gpac_test_mode = gpac_old_arch = gpac_discard_config = GF_FALSE;
+
+		gf_list_del(all_blobs);
+		all_blobs = NULL;
+
 	}
 }
 
@@ -1836,9 +1979,104 @@
 	return 1;
 }
 
-//linux
+//ios
+#elif defined(GPAC_CONFIG_IOS)
+
+#import <mach/mach.h>
+#import <assert.h>
+
+Bool gf_sys_get_rti_os(u32 refresh_time_ms, GF_SystemRTInfo *rti, u32 flags)
+{
+	u64 u_k_time = 0;
+ kern_return_t kr;
+ task_info_data_t tinfo;
+ mach_msg_type_number_t task_info_count;
+ task_basic_info_t basic_info;
+ thread_array_t thread_list;
+ mach_msg_type_number_t thread_count;
+ thread_info_data_t thinfo;
+ mach_msg_type_number_t thread_info_count;
+ thread_basic_info_t basic_info_th;
+ u32 j, tot_cpu = 0, nb_threads = 0;
+
+	u32 entry_time = gf_sys_clock();
+	if (last_update_time && (entry_time - last_update_time < refresh_time_ms)) {
+		memcpy(rti, &the_rti, sizeof(GF_SystemRTInfo));
+		return GF_FALSE;
+	}
+
+ task_info_count = TASK_INFO_MAX;
+ kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)tinfo, &task_info_count);
+ if (kr != KERN_SUCCESS) {
+ return GF_FALSE;
+ }
+
+ basic_info = (task_basic_info_t)tinfo;
+ the_rti.gpac_memory = the_rti.process_memory = basic_info->resident_size;
+
+ // get threads in the task
+ kr = task_threads(mach_task_self(), &thread_list, &thread_count);
+ if (kr != KERN_SUCCESS) {
+ return GF_FALSE;
+ }
+ if (thread_count > 0)
+ nb_threads = (u32) thread_count;
+
+ for (j = 0; j < nb_threads; j++) {
+ thread_info_count = THREAD_INFO_MAX;
+ kr = thread_info(thread_listj, THREAD_BASIC_INFO,
+ (thread_info_t)thinfo, &thread_info_count);
+ if (kr != KERN_SUCCESS) {
+			vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
+ return GF_FALSE;
+ }
+
+ basic_info_th = (thread_basic_info_t)thinfo;
+
+ if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
+ u64 tot_sec = basic_info_th->user_time.seconds + basic_info_th->system_time.seconds;
+ tot_sec *= 1000000;
+ tot_sec += basic_info_th->user_time.microseconds + basic_info_th->system_time.microseconds;
+ u_k_time += tot_sec;
+			tot_cpu += basic_info_th->cpu_usage;
+ }
+
+ } // for each thread
+
+ the_rti.process_cpu_usage = (tot_cpu * 100) / TH_USAGE_SCALE;
+	the_rti.total_cpu_usage = the_rti.process_cpu_usage;
+
+ kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
+ assert(kr == KERN_SUCCESS);
+
+
+	if (last_update_time) {
+		the_rti.sampling_period_duration = (entry_time - last_update_time);
+		the_rti.process_cpu_time_diff = 0;
+		/*move to ms*/
+		the_rti.total_cpu_time_diff = (u32) (u_k_time - last_cpu_u_k_time) / 1000;
+
+		/*we're not that accurate....*/
+		if (the_rti.total_cpu_time_diff > the_rti.sampling_period_duration)
+			the_rti.sampling_period_duration = the_rti.total_cpu_time_diff;
+	} else {
+		mem_at_startup = the_rti.physical_memory_avail;
+	}
+
+#ifdef GPAC_MEMORY_TRACKING
+	the_rti.gpac_memory = gpac_allocated_memory;
+#endif
+	last_cpu_u_k_time = u_k_time;
+	last_update_time = entry_time;
+	memcpy(rti, &the_rti, sizeof(GF_SystemRTInfo));
+
+	last_update_time = entry_time;
+	return GF_TRUE;
+}
+
 #else
 
+
 Bool gf_sys_get_rti_os(u32 refresh_time_ms, GF_SystemRTInfo *rti, u32 flags)
 {
 	u32 entry_time;
@@ -1872,7 +2110,7 @@
 	the_rti.process_memory = 0;
 
 	/*FIXME? under LinuxThreads this will only fetch stats for the calling thread, we would have to enumerate /proc to get
-	the complete CPU usage of all therads of the process...*/
+	the complete CPU usage of all threads of the process...*/
 #if 0
 	sprintf(szProc, "/proc/%d/stat", the_rti.pid);
 	f = gf_fopen(szProc, "r");
@@ -2030,7 +2268,7 @@
 #elif defined(WIN32)
 	GetTempPath(GF_MAX_PATH, szCacheDir);
 #elif defined(GPAC_CONFIG_ANDROID)
-	strcpy(szCacheDir, "/data/data/com.gpac.Osmo4/cache");
+	strcpy(szCacheDir, "/data/data/io.gpac.gpac/cache");
 #else
 	strcpy(szCacheDir, "/tmp");
 #endif
@@ -2272,24 +2510,6 @@
 #endif //global lock uni-used
 
 
-#ifdef GPAC_CONFIG_ANDROID
-
-fm_callback_func fm_cbk = NULL;
-static void *fm_cbk_obj = NULL;
-
-void gf_fm_request_set_callback(void *cbk_obj, fm_callback_func cbk_func) {
-	fm_cbk = cbk_func;
-	fm_cbk_obj = cbk_obj;
-}
-
-void gf_fm_request_call(u32 type, u32 param, int *value) {
-	if (fm_cbk)
-		fm_cbk(fm_cbk_obj, type, param, value);
-}
-
-#endif //GPAC_CONFIG_ANDROID
-
-
 static u32 ntp_shift = GF_NTP_SEC_1900_TO_1970;
 
 GF_EXPORT
@@ -2503,13 +2723,13 @@
 }
 
 #elif defined(GPAC_CONFIG_ANDROID)
-#include <time64.h>
 #if defined(__LP64__)
 static time_t gf_mktime_utc(struct tm *tm)
 {
-	return timegm64(tm);
+	return timegm(tm);
 }
 #else
+#include <time64.h>
 static time_t gf_mktime_utc(struct tm *tm)
 {
 	static const time_t kTimeMax = ~(1L << (sizeof(time_t) * CHAR_BIT - 1));
@@ -2569,7 +2789,12 @@
 	else if (sscanf(val, "%3s %3s %d %02d:%02d:%02d %d", szDay, szMonth, &day, &year, &h, &m, &s)==7) {
 		secs = (Float) s;
 	}
-	else {
+	else if (sscanf(val, LLU, &current_time) == 1 && current_time > 1000000000 && current_time < GF_INT_MAX) {
+		return current_time * 1000; // guessed raw duration since UTC0 in seconds
+	}
+	else if (sscanf(val, LLU, &current_time) == 1 && current_time > 1000000000000ULL && current_time < GF_INT_MAX * 1000ULL) {
+		return current_time; // guessed duration since UTC0 in milliseconds
+	} else {
 		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Core Cannot parse date string %s\n", val));
 		return 0;
 	}
@@ -2627,7 +2852,7 @@
 		//use 1 ms
 		return 1;
 	}
-	if (current_time == 0) {
+	if (current_time == 0 && secs == 0.0) {
 		//use 1 ms
 		return 1;
 	}
@@ -2828,3 +3053,154 @@
 }
 #endif
 
+#ifndef WIN32
+#include <termios.h>
+GF_EXPORT
+int gf_getch()
+{
+	struct termios old;
+	struct termios new;
+	int rc;
+
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) return 0;
+#endif
+
+	if (tcgetattr(0, &old) == -1) {
+		return -1;
+	}
+	new = old;
+	new.c_lflag &= ~(ICANON | ECHO | ISIG);
+	new.c_ccVMIN = 1;
+	new.c_ccVTIME = 0;
+	if (tcsetattr(0, TCSANOW, &new) == -1) {
+		return -1;
+	}
+	rc = getchar();
+	(void) tcsetattr(0, TCSANOW, &old);
+	return rc;
+}
+#else
+GF_EXPORT
+int gf_getch()
+{
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) return 0;
+#endif
+	return getchar();
+}
+#endif
+
+GF_EXPORT
+Bool gf_read_line_input(char * line, int maxSize, Bool showContent)
+{
+	char read;
+	int i = 0;
+#ifdef GPAC_ENABLE_COVERAGE
+	if (gf_sys_is_cov_mode()) return GF_FALSE;
+#endif
+
+	if (fflush( stderr ))
+		perror("Failed to flush buffer %s");
+	do {
+		linei = '\0';
+		if (i >= maxSize - 1)
+			return GF_FALSE;
+		read = gf_getch();
+		if (read == 8 || read == 127) {
+			if (i > 0) {
+				fprintf(stderr, "\b \b");
+				i--;
+			}
+		} else if (read >= 32) {
+			fputc(showContent ? read : '*', stderr);
+			linei++ = read;
+		}
+		fflush(stderr);
+	} while (read != '\n');
+	if (!read)
+		return GF_FALSE;
+	return GF_TRUE;
+}
+
+
+GF_EXPORT
+GF_Err gf_creds_check_password(const char *user, char *password)
+{
+	u32 i, len, v;
+	u8 passbuf150;
+	u8 hashGF_SHA256_DIGEST_SIZE, ohashGF_SHA256_DIGEST_SIZE;
+	const char *cred_file = gf_opts_get_key("core", "users");
+	if (!cred_file) return GF_NOT_FOUND;
+	GF_Config *creds = gf_cfg_new(NULL, cred_file);
+	if (!creds) return GF_NOT_FOUND;
+	len = (u32) strlen(password);
+	const char *pass_hex = gf_cfg_get_key(creds, user, "password");
+	const char *salt_hex = gf_cfg_get_key(creds, user, "salt");
+	if (!salt_hex || !pass_hex || (strlen(salt_hex) != 64) || (strlen(pass_hex) != 64) || (len>=100)) {
+		gf_cfg_del(creds);
+		return GF_NOT_FOUND;
+	}
+
+	u8 saltGF_SHA256_DIGEST_SIZE;
+	for (i=0; i<GF_SHA256_DIGEST_SIZE; i++) {
+		sscanf(salt_hex+2*i, "%02x", &v);
+		salti = v;
+	}
+	for (i=0; i<GF_SHA256_DIGEST_SIZE; i++) {
+		sscanf(pass_hex+2*i, "%02x", &v);
+		ohashi = v;
+	}
+
+	memcpy(passbuf, password, len);
+	passbuflen='@';
+	memcpy(passbuf+len+1, salt, GF_SHA256_DIGEST_SIZE);
+	len += GF_SHA256_DIGEST_SIZE+1;
+	gf_sha256_csum(passbuf, len, hash);
+	len=1;
+	for (i=0; i<GF_SHA256_DIGEST_SIZE; i++) {
+		if (hashi != ohashi) len=0;
+	}
+
+	if (len) {
+		sprintf((char *)passbuf, LLU, gf_net_get_utc());
+		gf_cfg_set_key(creds, user, "last_auth", (char *)passbuf);
+		gf_cfg_save(creds);
+	}
+	gf_cfg_del(creds);
+
+	if (!len) return GF_AUTHENTICATION_FAILURE;
+	return GF_OK;
+}
+
+#include <gpac/token.h>
+
+GF_EXPORT
+Bool gf_creds_check_membership(const char *username, const char *users, const char *groups)
+{
+	if (!username) return GF_FALSE;
+	//users specified and username is listed
+	if (users && gf_token_find_word(users, username, ",")) return GF_TRUE;
+
+	if (!groups)
+		return users ? GF_TRUE : GF_FALSE;
+
+	//check all defined groups
+	const char *cred_file = gf_opts_get_key("core", "users");
+	if (!cred_file) return GF_FALSE;
+	GF_Config *creds = gf_cfg_new(NULL, cred_file);
+	if (!creds) return GF_FALSE;
+	u32 i, nb_groups = gf_cfg_get_key_count(creds, "groups");
+	for (i=0; i<nb_groups; i++) {
+		const char *g = gf_cfg_get_key_name(creds, "groups", i);
+		if (!gf_token_find_word(groups, g, ",")) continue;
+		//group is present in groups being checked, check user
+		const char *members = gf_cfg_get_key(creds, "groups", g);
+		if (gf_token_find_word(members, username, ",")) {
+			gf_cfg_del(creds);
+			return GF_TRUE;
+		}
+	}
+	gf_cfg_del(creds);
+	return GF_FALSE;
+}

gpac-2.0.0.tar.gz/src/utils/os_file.c -> gpac-2.2.0.tar.gz/src/utils/os_file.c Changed

@@ -101,6 +101,16 @@
 	}
 #elif defined (WIN32)
 	int res;
+
+	//don't try creation for UNC root: \\foo\bar\name will trigger creation for "", "\\foo" and "\\foo\bar", ignore these
+	if (!strcmp(DirPathName, "")) return GF_OK;
+	if (!strncmp(DirPathName, "\\\\", 2)) {
+		char *sep = strchr(DirPathName + 2, '\\');
+		if (!sep) return GF_OK;
+		sep = strchr(sep + 1, '\\');
+		if (!sep) return GF_OK;
+	}
+
 	wchar_t* wcsDirPathName = gf_utf8_to_wcs(DirPathName);
 	if (!wcsDirPathName)
 		return GF_IO_ERR;
@@ -703,11 +713,8 @@
 		iFs.Close();
 		FlushItemList();
 		return GF_OK;
-#elif defined(GPAC_CONFIG_ANDROID)
-		dir = getenv("EXTERNAL_STORAGE");
-		if (!dir) dir = "/sdcard";
-#elif defined(GPAC_CONFIG_IOS)
-		dir = (char *) gf_opts_get_key("General", "iOSDocumentsDir");
+#elif defined(GPAC_CONFIG_ANDROID) || defined(GPAC_CONFIG_IOS)
+		dir = (char *) gf_opts_get_key("core", "docs-dir");
 #endif
 	}
 
@@ -1510,26 +1517,18 @@
 #else
 		int errno_save = errno;
 #endif
-		//if (errno_save!=0)
-		{
 #ifdef HAVE_STRERROR_R
 #define ERRSTR_BUF_SIZE 256
-			char errstrERRSTR_BUF_SIZE;
-			if(strerror_r(errno_save, errstr, ERRSTR_BUF_SIZE) != 0)
-			{
-				strerror_r(0, errstr, ERRSTR_BUF_SIZE);
-			}
-#else
-			char *errstr = (char*)strerror(errno_save);
-#endif
-
-#ifndef GPAC_DISABLE_LOG
-			GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Error writing data (%s): %d blocks to write but %d blocks written\n", errstr, nb_bytes, result));
+		char errstrERRSTR_BUF_SIZE;
+		if(strerror_r(errno_save, errstr, ERRSTR_BUF_SIZE) != 0)
+		{
+			strerror_r(0, errstr, ERRSTR_BUF_SIZE);
+		}
 #else
-			fprintf(stderr, "Error writing data (%s): %d blocks to write but %d blocks written\n", errstr, (u32) nb_bytes, (u32) result);
+		char *errstr = (char*)strerror(errno_save);
 #endif
 
-		}
+		GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Error writing data (%s): %d blocks to write but %d blocks written\n", errstr, nb_bytes, result));
 #endif
 	}
 	return result;
@@ -1624,6 +1623,18 @@
 }
 
 GF_EXPORT
+int gf_vfprintf(FILE *stream, const char *format, va_list args)
+{
+	int	res;
+	if (gf_fileio_check(stream)) {
+		res = gf_fileio_printf((GF_FileIO *)stream, format, args);
+	} else {
+		res = vfprintf(stream, format, args);
+	}
+	return res;
+}
+
+GF_EXPORT
 int gf_fflush(FILE *stream)
 {
 	if (gf_fileio_check(stream)) {
@@ -1738,10 +1749,19 @@
 	if (!strncmp(path, "gfio://", 7) || !strncmp(path, "gmem://", 7)) {
 		return strchr(path+7, ':');
 	}
-	
+
+	//handle "\\foo\Z:\bar"
+	if ((path0 == '\\') && (path1 == '\\')) {
+		char *next = strchr(path+2, '\\');
+		if (next) next = strchr(next + 1, '\\');
+		if (next)
+			return gf_url_colon_suffix(next + 1, assign_sep);
+	}
+
+
 	//handle PROTO://ADD:PORT/
 	if ((sep1=='/') && (sep2=='/')) {
-		char *next_colon, *next_slash;
+		char *next_colon, *next_slash, *userpass;
 		sep++;
 		//skip all // (eg PROTO://////////////mytest/)
 		while (sep0=='/')
@@ -1757,6 +1777,11 @@
 		//find closest : or /, if : is before / consider this is a port or an IPv6 address and check next : after /
 		next_colon = strchr(sep, ':');
 		next_slash = strchr(sep, '/');
+		userpass = strchr(sep, '@');
+		//if ':' is before '@' with '@' before next '/', consider this is `user:pass@SERVER`
+		if (userpass && next_colon && next_slash && (userpass<next_slash) && (userpass>next_colon))
+			next_colon = strchr(userpass, ':');
+
 		if (next_colon && next_slash && ((next_slash - sep) > (next_colon - sep)) ) {
 			const char *last_colon;
 			u32 i, port, nb_colons=0, nb_dots=0, nb_non_alnums=0;
@@ -1789,6 +1814,17 @@
 		if (file_ext && (file_ext>sep)) {
 			sep = strchr(file_ext, ':');
 		}
+		if (assign && (strlen(assign) > 4)) {
+			if ((assign2 == ':') && ((assign3 == '\\') || (assign3 == '/'))) {
+				return gf_url_colon_suffix(assign + 1, 0);
+			}
+			if ((assign1 == '\\') && (assign2 == '\\')) {
+				char *next = strchr(assign + 3, '\\');
+				if (next) next = strchr(next+1, '\\');
+				if (next && (next>sep))
+					return gf_url_colon_suffix(next, 0);
+			}
+		}
 	}
 	return sep;
 }

gpac-2.0.0.tar.gz/src/utils/os_module.c -> gpac-2.2.0.tar.gz/src/utils/os_module.c Changed

gpac-2.0.0.tar.gz/src/utils/os_net.c -> gpac-2.2.0.tar.gz/src/utils/os_net.c Changed

@@ -2,7 +2,7 @@
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
- *			Copyright (c) Telecom ParisTech 2000-2021
+ *			Copyright (c) Telecom ParisTech 2000-2022
 *					All rights reserved
 *
 * This file is part of GPAC / common tools sub-project
@@ -23,10 +23,9 @@
 *
 */
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
+#include <gpac/network.h>
 
 #if defined(WIN32) || defined(_WIN32_WCE)
-
 #define _WINSOCK_DEPRECATED_NO_WARNINGS
 
 #ifdef _WIN32_WCE
@@ -35,7 +34,6 @@
 #if !defined(__GNUC__)
 #pragma comment(lib, "winsock")
 #endif
-
 #else
 
 #include <sys/timeb.h>
@@ -46,21 +44,37 @@
 #pragma comment(lib, "ws2_32")
 #endif
 
+#if !defined(POLLIN)
+#ifdef GPAC_HAS_POLL
+#undef GPAC_HAS_POLL
+#endif
 #endif
 
-#include <windows.h>
+#ifdef GPAC_HAS_POLL
+#define GF_POLLFD	WSAPOLLFD
+#define poll WSAPoll
+#endif
 
-#if !defined(__GNUC__)
+#endif
+
+#include <windows.h>
 
 #if defined(IPV6_MULTICAST_IF)
 #define GPAC_HAS_IPV6 1
-#pragma message("Using WinSock IPV6")
 #else
 #undef GPAC_HAS_IPV6
+#endif
+
+ /*
+ #if !defined(__GNUC__)
+#if defined(GPAC_HAS_IPV6)
+#pragma message("Using WinSock IPV6")
+#else
 #pragma message("Using WinSock IPV4")
 #endif
 
 #endif
+*/
 
 #include <errno.h>
 
@@ -71,6 +85,8 @@
 #define EISCONN				WSAEISCONN
 #define ENOTCONN			WSAENOTCONN
 #define ECONNRESET			WSAECONNRESET
+#define EINPROGRESS			WSAEINPROGRESS
+#define EALREADY			WSAEALREADY
 #define EMSGSIZE			WSAEMSGSIZE
 #define ECONNABORTED		WSAECONNABORTED
 #define ENETDOWN			WSAENETDOWN
@@ -86,10 +102,6 @@
 /*the number of sockets used. This because the WinSock lib needs init*/
 static int wsa_init = 0;
 
-
-#include <gpac/network.h>
-
-
 /*end-win32*/
 
 #else
@@ -112,7 +124,6 @@
 #include <sys/types.h>
 #include <arpa/inet.h>
 
-#include <gpac/network.h>
 
 /*not defined on solaris*/
 #if !defined(INADDR_NONE)
@@ -131,8 +142,194 @@
 typedef s32 SOCKET;
 #define closesocket(v) close(v)
 
+#ifdef GPAC_HAS_POLL
+#include <poll.h>
+
+#define GF_POLLFD	struct pollfd
+
+#endif
+
 #endif /*WIN32||_WIN32_WCE*/
 
+#ifdef GPAC_BUILD_FOR_WINXP
+
+/* Added by M. Lackner to ensure Windows XP & XP x64 compatibility */
+/* Adding PlibC's inet_ntop() function in a very slightly modified
+and renamed variant for IPv6 address conversion support on Win XP's,
+which is called by gf_sk_get_remote_address() further below.
+The renamed function is called inet_ntop_xp().
+Original source code taken from here:
+https://sourceforge.net/projects/plibc/
+
+This inet_ntop() implementation is (C) 1996-2001 Internet Software
+Consortium and is licensed under the ISC license.
+License text: https://opensource.org/licenses/ISC */
+#define NS_INT16SZ 2
+#define NS_IN6ADDRSZ 16
+
+/*
+* WARNING: Don't even consider trying to compile this on a system where
+* sizeof(int) < 4. sizeof(int) > 4 is fine; all the world's not a VAX.
+*/
+
+static const char *inet_ntop4(const unsigned char *src, char *dst, size_t size);
+
+#ifdef AF_INET6
+static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size);
+#endif
+
+/* char *
+* isc_net_ntop(af, src, dst, size)
+* convert a network format address to presentation format.
+* return:
+* pointer to presentation format address (`dst'), or NULL (see errno).
+* author:
+* Paul Vixie, 1996.
+*/
+const char * inet_ntop_xp(int af, const void *src, char *dst, size_t size)
+{
+	switch (af) {
+	case AF_INET:
+		return (inet_ntop4(src, dst, size));
+#ifdef AF_INET6
+	case AF_INET6:
+		return (inet_ntop6(src, dst, size));
+#endif
+	default:
+		errno = EAFNOSUPPORT;
+		return (NULL);
+	}
+	/* NOTREACHED */
+}
+
+/* const char *
+* inet_ntop4(src, dst, size)
+* format an IPv4 address
+* return:
+* `dst' (as a const)
+* notes:
+* (1) uses no statics
+* (2) takes a unsigned char* not an in_addr as input
+* author:
+* Paul Vixie, 1996.
+*/
+static const char * inet_ntop4(const unsigned char *src, char *dst, size_t size)
+{
+	static const char *fmt = "%u.%u.%u.%u";
+	char tmpsizeof "255.255.255.255";
+	size_t len;
+
+	len = snprintf(tmp, sizeof tmp, fmt, src0, src1, src2, src3);
+	if (len >= size) {
+		errno = ENOSPC;
+		return (NULL);
+	}
+	memcpy(dst, tmp, len + 1);
+
+	return (dst);
+}
+
+/* const char *
+* isc_inet_ntop6(src, dst, size)
+* convert IPv6 binary address into presentation (printable) format
+* author:
+* Paul Vixie, 1996.
+*/
+#ifdef AF_INET6
+static const char * inet_ntop6(const unsigned char *src, char *dst, size_t size)
+{
+	/*
+	* Note that int32_t and int16_t need only be "at least" large enough
+	* to contain a value of the specified size. On some systems, like
+	* Crays, there is no such thing as an integer variable with 16 bits.
+	* Keep this in mind if you think this function should have been coded
+	* to use pointer overlays. All the world's not a VAX.
+	*/
+	char tmpsizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255", *tp;
+	struct { int base, len; } best, cur;
+	unsigned int wordsNS_IN6ADDRSZ / NS_INT16SZ;
+	int i, inc;
+
+	/*
+	* Preprocess:
+	* Copy the input (bytewise) array into a wordwise array.
+	* Find the longest run of 0x00's in src for :: shorthanding.
+	*/
+	memset(words, '\0', sizeof words);
+	for (i = 0; i < NS_IN6ADDRSZ; i++)
+		wordsi / 2 |= (srci << ((1 - (i % 2)) << 3));
+	best.base = -1;
+	best.len = 0;
+	cur.base = -1;
+	cur.len = 0;
+	for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
+		if (wordsi == 0) {
+			if (cur.base == -1)
+				cur.base = i, cur.len = 1;
+			else
+				cur.len++;
+		}
+		else {
+			if (cur.base != -1) {
+				if (best.base == -1 || cur.len > best.len)
+					best = cur;
+				cur.base = -1;
+			}
+		}
+	}
+	if (cur.base != -1) {
+		if (best.base == -1 || cur.len > best.len)
+			best = cur;
+	}
+	if (best.base != -1 && best.len < 2)
+		best.base = -1;
+
+	/*
+	* Format the result.
+	*/
+	tp = tmp;
+	for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
+		/* Are we inside the best run of 0x00's? */
+		if (best.base != -1 && i >= best.base && i < (best.base + best.len)) {
+			if (i == best.base)
+				*tp++ = ':';
+			continue;
+		}
+		/* Are we following an initial run of 0x00s or any real hex? */
+		if (i != 0)
+			*tp++ = ':';
+		/* Is this address an encapsulated IPv4? */
+		if (i == 6 && best.base == 0 && (best.len == 6 || (best.len == 5 && words5 == 0xffff))) {
+			if (!inet_ntop4(src + 12, tp, sizeof tmp - (tp - tmp)))
+				return (NULL);
+			tp += strlen(tp);
+			break;
+		}
+		inc = snprintf(tp, 5, "%x", wordsi);
+		tp += inc;
+	}
+	/* Was it a trailing run of 0x00's? */
+	if (best.base != -1 && (best.base + best.len) == (NS_IN6ADDRSZ / NS_INT16SZ))
+		*tp++ = ':';
+	*tp++ = '\0';
+
+	/*
+	* Check for overflow, copy, and we're done.
+	*/
+	if ((size_t)(tp - tmp) > size) {
+		errno = ENOSPC;
+		return (NULL);
+	}
+	memcpy(dst, tmp, tp - tmp);
+	return (dst);
+}
+#endif /* AF_INET6 */
+/* End of inet_ntop() reimplementation */
+
+
+#endif //winxp
+
+
 
 #ifdef GPAC_HAS_IPV6
 # ifndef IPV6_ADD_MEMBERSHIP
@@ -183,6 +380,7 @@
 	/*socket is bound to a specific dest (server) or source (client) */
 	GF_SOCK_HAS_PEER = 1<<14,
 	GF_SOCK_IS_UN = 1<<15,
+	GF_SOCK_HAS_CONNECT = 1<<16,
 };
 
 struct __tag_socket
@@ -198,6 +396,9 @@
 	u32 dest_addr_len;
 
 	u32 usec_wait;
+#ifdef GPAC_HAS_POLL
+	u32 poll_idx;
+#endif
 };
 
 
@@ -533,11 +734,11 @@
 		}
 		server_add.sun_family = AF_UNIX;
 		strcpy(server_add.sun_path, PeerName);
-		if (connect(sock->socket, (struct sockaddr *) &server_add, sizeof(struct sockaddr_un)) < 0) {
+		if (connect(sock->socket, (struct sockaddr *)&server_add, sizeof(struct sockaddr_un)) < 0) {
 			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("Socket Failed to connect unix domain socket to %s\n", PeerName));
 			return GF_IP_CONNECTION_FAILURE;
-	 }
-	 return GF_OK;
+		}
+		return GF_OK;
 #else
 	 return GF_NOT_SUPPORTED;
 #endif
@@ -588,15 +789,54 @@
 		}
 
 		if (sock->flags & GF_SOCK_IS_TCP) {
+
+#if defined(WIN32) || defined(_WIN32_WCE)
+			//on winsock we must check writability between two connects for non-blocking sockets
+			if (sock->flags & GF_SOCK_HAS_CONNECT) {
+				if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_IP_NETWORK_EMPTY) {
+					GF_Err e = gf_sk_probe(sock);
+					if (e && (e != GF_IP_NETWORK_EMPTY)) return e;
+					return GF_IP_NETWORK_EMPTY;
+				}
+			}
+#endif
+
 			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("Sock_IPV6 Connecting to %s:%d\n", PeerName, PortNumber));
 			ret = connect(sock->socket, aip->ai_addr, (int) aip->ai_addrlen);
 			if (ret == SOCKET_ERROR) {
+				int err = LASTSOCKERROR;
+				if (sock->flags & GF_SOCK_NON_BLOCKING) {
+					switch (err) {
+					case EINPROGRESS:
+#if defined(WIN32) || defined(_WIN32_WCE)
+					case WSAEWOULDBLOCK:
+#endif
+						freeaddrinfo(res);
+						if (lip) freeaddrinfo(lip);
+						//remember we issued a first connect
+						sock->flags |= GF_SOCK_HAS_CONNECT;
+						return GF_IP_NETWORK_EMPTY;
+
+					case EISCONN:
+					case EALREADY:
+#if defined(WIN32) || defined(_WIN32_WCE)
+					case WSAEISCONN:
+#endif
+						if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_OK)
+							goto conn_ok;
+						freeaddrinfo(res);
+						if (lip) freeaddrinfo(lip);
+						return GF_IP_NETWORK_EMPTY;
+					}
+				}
 				closesocket(sock->socket);
 				sock->socket = NULL_SOCKET;
-				GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("Sock_IPV4 Failed to connect to host %s: %s - retrying\n", PeerName, gf_errno_str(LASTSOCKERROR) ));
+				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("Sock_IPV6 Failed to connect to host %s: %s (%d) - retrying\n", PeerName, gf_errno_str(err), err ));
 				continue;
 			}
+conn_ok:
 			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("Sock_IPV6 Connected to %s:%d\n", PeerName, PortNumber));
+			sock->flags &= ~GF_SOCK_HAS_CONNECT;
 
 #ifdef SO_NOSIGPIPE
 			int value = 1;
@@ -614,10 +854,6 @@
 	return GF_IP_CONNECTION_FAILURE;
 
 #else
-	if (local_ip) {
-		GF_Err e = gf_sk_bind(sock, local_ip, PortNumber, PeerName, PortNumber, GF_SOCK_REUSE_PORT);
-		if (e) return e;
-	}
 	if (!sock->socket) {
 		sock->socket = socket(AF_INET, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM, 0);
 		if (sock->flags & GF_SOCK_NON_BLOCKING)
@@ -648,35 +884,67 @@
 		memcpy((char *) &sock->dest_addr.sin_addr, Host->h_addr_list0, sizeof(u32));
 	}
 
+	if (local_ip) {
+		GF_Err e = gf_sk_bind(sock, local_ip, PortNumber, PeerName, PortNumber, GF_SOCK_REUSE_PORT);
+		if (e) return e;
+	}
+	if (!(sock->flags & GF_SOCK_IS_TCP)) {
+		return GF_OK;
+	}
+
+#if defined(WIN32) || defined(_WIN32_WCE)
+	//on winsock we must check writability between two connects for non-blocking sockets
+	if (sock->flags & GF_SOCK_HAS_CONNECT) {
+		if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_IP_NETWORK_EMPTY)
+			return GF_IP_NETWORK_EMPTY;
+	}
+#endif
+
 	GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("Sock_IPV4 Connecting to %s:%d\n", PeerName, PortNumber));
 	ret = connect(sock->socket, (struct sockaddr *) &sock->dest_addr, sizeof(struct sockaddr));
 	if (ret == SOCKET_ERROR) {
 		u32 res = LASTSOCKERROR;
-		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("Sock_IPV4 Couldn't connect socket: %s\n", gf_errno_str(res) ));
+
+		if (sock->flags & GF_SOCK_NON_BLOCKING) {
+			switch (res) {
+			case EINPROGRESS:
+#if defined(WIN32) || defined(_WIN32_WCE)
+			case WSAEWOULDBLOCK:
+#endif
+				//remember we issued a first connect
+				sock->flags |= GF_SOCK_HAS_CONNECT;
+				return GF_IP_NETWORK_EMPTY;
+			case EISCONN:
+			case EALREADY:
+#if defined(WIN32) || defined(_WIN32_WCE)
+			case WSAEISCONN:
+#endif
+				if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_OK)
+					return GF_OK;
+				return GF_IP_NETWORK_EMPTY;
+			}
+		}
+		sock->flags &= ~GF_SOCK_HAS_CONNECT;
+
 		switch (res) {
 		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
+#if defined(WIN32) || defined(_WIN32_WCE)
+		case WSAEWOULDBLOCK:
+#endif
+			return GF_IP_NETWORK_EMPTY;
 #ifdef WIN32
 		case WSAEINVAL:
 			if (sock->flags & GF_SOCK_NON_BLOCKING)
-				return GF_IP_SOCK_WOULD_BLOCK;
+				return GF_IP_NETWORK_EMPTY;
 #endif
 		case EISCONN:
 			return GF_OK;
-		case ENOTCONN:
-			return GF_IP_CONNECTION_FAILURE;
-		case ECONNRESET:
-			return GF_IP_CONNECTION_FAILURE;
-		case EMSGSIZE:
-			return GF_IP_CONNECTION_FAILURE;
-		case ECONNABORTED:
-			return GF_IP_CONNECTION_FAILURE;
-		case ENETDOWN:
-			return GF_IP_CONNECTION_FAILURE;
 		default:
+			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("Sock_IPV4 Couldn't connect socket: %s\n", gf_errno_str(res)));
 			return GF_IP_CONNECTION_FAILURE;
 		}
 	}
+	sock->flags &= ~GF_SOCK_HAS_CONNECT;
 	GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("Sock_IPV4 Connected to %s:%d\n", PeerName, PortNumber));
 #endif
 	return GF_OK;
@@ -900,47 +1168,100 @@
 #endif
 }
 
-//send length bytes of a buffer
-GF_EXPORT
-GF_Err gf_sk_send(GF_Socket *sock, const u8 *buffer, u32 length)
+Bool gpac_use_poll=GF_TRUE;
+
+static GF_Err poll_select(GF_Socket *sock, GF_SockSelectMode mode, u32 usec, Bool force_select)
 {
-	u32 count;
-	s32 res;
-	Bool not_ready = GF_FALSE;
 #ifndef __SYMBIAN32__
 	int ready;
 	struct timeval timeout;
-	fd_set Group;
+
+#ifdef GPAC_HAS_POLL
+	if (!force_select && gpac_use_poll) {
+		struct pollfd pfd;
+		pfd.fd = sock->socket;
+		pfd.revents = 0;
+		if (mode == GF_SK_SELECT_WRITE) pfd.events = POLLOUT;
+		else if (mode == GF_SK_SELECT_READ) pfd.events = POLLIN;
+		else pfd.events = POLLIN|POLLOUT;
+
+		ready = poll(&pfd, 1, usec/1000);
+		if (ready<0) {
+			switch (LASTSOCKERROR) {
+			case EAGAIN:
+				return GF_IP_NETWORK_EMPTY;
+			default:
+				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("socket cannot poll: %s\n", gf_errno_str(LASTSOCKERROR) ));
+				return GF_IP_NETWORK_FAILURE;
+			}
+		}
+		if (!ready)
+			return GF_IP_NETWORK_EMPTY;
+
+		if ((mode == GF_SK_SELECT_WRITE) && !(pfd.revents & POLLOUT))
+			return GF_IP_NETWORK_EMPTY;
+		if ((mode == GF_SK_SELECT_READ) && !(pfd.revents & POLLIN))
+			return GF_IP_NETWORK_EMPTY;
+
+		return GF_OK;
+	}
 #endif
 
-	//the socket must be bound or connected
-	if (!sock || !sock->socket)
-		return GF_BAD_PARAM;
+	fd_set rgroup, wgroup;
 
-#ifndef __SYMBIAN32__
 	//can we write?
-	FD_ZERO(&Group);
-	FD_SET(sock->socket, &Group);
+	FD_ZERO(&rgroup);
+	FD_ZERO(&wgroup);
+	if (mode != GF_SK_SELECT_WRITE)
+		FD_SET(sock->socket, &rgroup);
+	if (mode != GF_SK_SELECT_READ)
+		FD_SET(sock->socket, &wgroup);
 	timeout.tv_sec = 0;
-	timeout.tv_usec = sock->usec_wait;
+	timeout.tv_usec = usec;
+
+	ready = select((int) sock->socket+1,
+		(mode != GF_SK_SELECT_WRITE) ? &rgroup : NULL,
+		(mode != GF_SK_SELECT_READ) ? &wgroup : NULL,
+		 NULL, &timeout);
 
-	//TODO CHECK IF THIS IS CORRECT
-	ready = select((int) sock->socket+1, NULL, &Group, NULL, &timeout);
 	if (ready == SOCKET_ERROR) {
 		switch (LASTSOCKERROR) {
 		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
+			return GF_IP_NETWORK_EMPTY;
 		default:
 			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("socket select failure: %s\n", gf_errno_str(LASTSOCKERROR)));
 			return GF_IP_NETWORK_FAILURE;
 		}
 	}
+	if (!ready)
+		return GF_IP_NETWORK_EMPTY;
+	if ((mode == GF_SK_SELECT_WRITE) && !FD_ISSET(sock->socket, &wgroup))
+		return GF_IP_NETWORK_EMPTY;
+	if ((mode == GF_SK_SELECT_READ) && !FD_ISSET(sock->socket, &rgroup))
+		return GF_IP_NETWORK_EMPTY;
+	//if mode is both and we are ready, let's go
+	return GF_OK;
+#endif
+}
+
+//send length bytes of a buffer
+GF_EXPORT
+GF_Err gf_sk_send_ex(GF_Socket *sock, const u8 *buffer, u32 length, u32 *written)
+{
+	u32 count;
+	s32 res;
+
+	if (written) *written = 0;
+
+	//the socket must be bound or connected
+	if (!sock || !sock->socket)
+		return GF_BAD_PARAM;
 
-	//should never happen (to check: is writeability is guaranteed for not-connected sockets)
-	if (!ready || !FD_ISSET(sock->socket, &Group)) {
-		not_ready = GF_TRUE;
+	if (! (sock->flags & GF_SOCK_NON_BLOCKING)) {
+		//check write
+		GF_Err e = poll_select(sock, GF_SK_SELECT_WRITE, sock->usec_wait, GF_FALSE);
+		if (e) return e;
 	}
-#endif
 
 	//direct writing
 	count = 0;
@@ -955,12 +1276,9 @@
 			res = (s32) send(sock->socket, (char *) buffer+count, length - count, sflags);
 		}
 		if (res == SOCKET_ERROR) {
-			if (not_ready)
-				return GF_IP_NETWORK_EMPTY;
-
 			switch (res = LASTSOCKERROR) {
 			case EAGAIN:
-				return GF_IP_SOCK_WOULD_BLOCK;
+				return GF_IP_NETWORK_EMPTY;
 #ifndef __SYMBIAN32__
 			case ENOTCONN:
 			case ECONNRESET:
@@ -971,7 +1289,7 @@
 
 #ifndef __DARWIN__
 			case EPROTOTYPE:
-				return GF_IP_SOCK_WOULD_BLOCK;
+				return GF_IP_NETWORK_EMPTY;
 #endif
 			case ENOBUFS:
 				GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("socket send failure: %s\n", gf_errno_str(LASTSOCKERROR)));
@@ -982,57 +1300,26 @@
 			}
 		}
 		count += res;
+		if (written) *written += res;
 	}
 	return GF_OK;
 }
 
-GF_Err gf_sk_select(GF_Socket *sock, u32 mode)
+GF_EXPORT
+GF_Err gf_sk_send(GF_Socket *sock, const u8 *buffer, u32 length)
 {
-#ifndef __SYMBIAN32__
-	int ready;
-	struct timeval timeout;
-	fd_set RGroup;
-	fd_set WGroup;
-#endif
+	return gf_sk_send_ex(sock, buffer, length, NULL);
+
+}
 
+GF_Err gf_sk_select(GF_Socket *sock, u32 mode)
+{
 	//the socket must be bound or connected
 	if (!sock || !sock->socket)
 		return GF_BAD_PARAM;
 
-#ifndef __SYMBIAN32__
-	//can we write?
-	FD_ZERO(&RGroup);
-	FD_ZERO(&WGroup);
-	if (mode != GF_SK_SELECT_WRITE)
-		FD_SET(sock->socket, &RGroup);
-	if (mode != GF_SK_SELECT_READ)
-		FD_SET(sock->socket, &WGroup);
-	timeout.tv_sec = 0;
-	timeout.tv_usec = sock->usec_wait;
-
-	//TODO CHECK IF THIS IS CORRECT
-	ready = select((int) sock->socket+1, &RGroup, &WGroup, NULL, &timeout);
-	if (ready == SOCKET_ERROR) {
-		switch (LASTSOCKERROR) {
-		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
-		default:
-			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("socket select failure: %s\n", gf_errno_str(LASTSOCKERROR)));
-			return GF_IP_NETWORK_FAILURE;
-		}
-	}
-
-	//should never happen (to check: is writeability is guaranteed for not-connected sockets)
-	if (!ready)
-		return GF_IP_SOCK_WOULD_BLOCK;
-	if ((mode != GF_SK_SELECT_WRITE) && !FD_ISSET(sock->socket, &RGroup))
-		return GF_IP_SOCK_WOULD_BLOCK;
-	if ((mode != GF_SK_SELECT_READ) && !FD_ISSET(sock->socket, &WGroup))
-		return GF_IP_SOCK_WOULD_BLOCK;
-	return GF_OK;
-#else
-	return GF_IP_SOCK_WOULD_BLOCK;
-#endif
+	//check write and read
+	return poll_select(sock, mode, sock->usec_wait, GF_FALSE);
 }
 
 
@@ -1065,11 +1352,93 @@
 #endif
 }
 
-GF_EXPORT
-GF_Err gf_sk_setup_multicast(GF_Socket *sock, const char *multi_IPAdd, u16 MultiPortNumber, u32 TTL, Bool NoBind, char *local_interface_ip)
+static GF_Err sk_join_ipv4(GF_Socket *sock, struct ip_mreq *M_req, u32 TTL, const char **src_ip_inc, u32 nb_src_ip_inc, const char **src_ip_exc, u32 nb_src_ip_exc)
 {
 	s32 ret;
 	u32 flag;
+
+	if (nb_src_ip_inc) {
+#ifdef IP_ADD_SOURCE_MEMBERSHIP
+		u32 i;
+		struct ip_mreq_source M_req_src;
+		M_req_src.imr_multiaddr = M_req->imr_multiaddr;
+		M_req_src.imr_interface = M_req->imr_interface;
+
+		for (i=0; i<nb_src_ip_inc; i++) {
+			if (gf_net_is_ipv6(src_ip_inci)) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core IPv6 SSM source on IPv4 Mcast adress, ignoring\n", src_ip_inci));
+				continue;
+			}
+			M_req_src.imr_sourceaddr.s_addr = inet_addr(src_ip_inci);
+			ret = setsockopt(sock->socket, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP, (char *) &M_req_src, sizeof(M_req_src) );
+			if (ret == SOCKET_ERROR) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core cannot add source membership for %s: %s\n", src_ip_inci, gf_errno_str(LASTSOCKERROR)));
+				return GF_IP_CONNECTION_FAILURE;
+			}
+		}
+#else
+		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core SSM IPv4 not supported\n"));
+		return GF_NOT_SUPPORTED;
+#endif
+	} else {
+		ret = setsockopt(sock->socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) M_req, sizeof(*M_req));
+		if (ret == SOCKET_ERROR) {
+			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core cannot join multicast: %s\n", gf_errno_str(LASTSOCKERROR)));
+			return GF_IP_CONNECTION_FAILURE;
+		}
+	}
+	/*set the Time To Live*/
+	if (TTL) {
+		ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_TTL, (char *)&TTL, sizeof(TTL));
+		if (ret == SOCKET_ERROR) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("Socket Cannot set TTL: %s\n", gf_errno_str(LASTSOCKERROR) ));
+			return GF_IP_CONNECTION_FAILURE;
+		}
+	}
+
+	/*enable loopback*/
+	flag = 1;
+	ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &flag, sizeof(flag));
+	if (ret == SOCKET_ERROR) {
+		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("Socket Cannot enable multicast loop: %s - ignoring\n", gf_errno_str(LASTSOCKERROR) ));
+	}
+
+#ifdef IP_BLOCK_SOURCE
+	if (nb_src_ip_exc) {
+		u32 i, j;
+		struct ip_mreq_source M_req_exc;
+		M_req_exc.imr_multiaddr = M_req->imr_multiaddr;
+		M_req_exc.imr_interface = M_req->imr_interface;
+		for (i=0; i<nb_src_ip_exc; i++) {
+			Bool match=GF_FALSE;
+			if (gf_net_is_ipv6(src_ip_exci)) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core IPv6 SSM source on IPv4 Mcast adress, ignoring\n", src_ip_exci));
+				continue;
+			}
+			for (j=0; j<nb_src_ip_inc; j++) {
+				if (!strcmp(src_ip_incj, src_ip_exci)) match=GF_TRUE;
+			}
+			if (match) continue;
+
+			M_req_exc.imr_sourceaddr.s_addr = inet_addr(src_ip_exci);
+			ret = setsockopt(sock->socket, IPPROTO_IP, IP_BLOCK_SOURCE, (char *) &M_req_exc, sizeof(M_req_exc) );
+			if (ret == SOCKET_ERROR) {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core cannot block source membership for %s: %s\n", src_ip_exci, gf_errno_str(LASTSOCKERROR)));
+				return GF_IP_CONNECTION_FAILURE;
+			}
+		}
+	}
+#else
+	GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("core SSM IPv4 not supported\n"));
+#endif
+	return GF_OK;
+}
+
+GF_EXPORT
+GF_Err gf_sk_setup_multicast_ex(GF_Socket *sock, const char *multi_IPAdd, u16 MultiPortNumber, u32 TTL, Bool NoBind, char *local_interface_ip,
+	const char **src_ip_inc, u32 nb_src_ip_inc, const char **src_ip_exc, u32 nb_src_ip_exc)
+{
+	s32 ret;
 	struct ip_mreq M_req;
 	u32 optval;
 #ifdef GPAC_HAS_IPV6
@@ -1078,6 +1447,7 @@
 	Bool is_ipv6 = GF_FALSE;
 	u32 type;
 #endif
+	GF_Err e;
 	u32 local_add_id;
 
 	if (!sock || sock->socket) return GF_BAD_PARAM;
@@ -1093,7 +1463,6 @@
 	type = (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM;
 
 	if (is_ipv6) {
-
 		res = gf_sk_get_ipv6_addr(local_interface_ip, MultiPortNumber, AF_UNSPEC, AI_PASSIVE, type);
 		if (!res) {
 			if (local_interface_ip) {
@@ -1106,14 +1475,19 @@
 		/*for all interfaces*/
 		for (aip=res; aip!=NULL; aip=aip->ai_next) {
 			if (type != (u32) aip->ai_socktype) continue;
+			//we have a v4 multicast adress
+			if (!gf_net_is_ipv6(multi_IPAdd)) {
+				//if not v4 and next is v4, use next
+				if ((aip->ai_family!=PF_INET) && aip->ai_next && (aip->ai_next->ai_family==PF_INET)) continue;
+			} else {
+				//we want v6, if v4 and next is v6, use next
+				if ((aip->ai_family==PF_INET) && aip->ai_next && (aip->ai_next->ai_family==PF_INET6)) continue;
+			}
 			sock->socket = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
 			if (sock->socket == INVALID_SOCKET) {
 				sock->socket = NULL_SOCKET;
 				continue;
 			}
-
-			if ((aip->ai_family!=PF_INET) && aip->ai_next && (aip->ai_next->ai_family==PF_INET) && !gf_net_is_ipv6(multi_IPAdd)) continue;
-
 			/*enable address reuse*/
 			optval = 1;
 			setsockopt(sock->socket, SOL_SOCKET, SO_REUSEADDR, (const char *) &optval, sizeof(optval));
@@ -1144,45 +1518,105 @@
 		freeaddrinfo(res);
 		if (!sock->socket) return GF_IP_CONNECTION_FAILURE;
 
-		struct addrinfo *_res = gf_sk_get_ipv6_addr(multi_IPAdd, MultiPortNumber, AF_UNSPEC, 0, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM);
-		if (!_res) return GF_IP_CONNECTION_FAILURE;
-		memcpy(&sock->dest_addr, _res->ai_addr, res->ai_addrlen);
-		sock->dest_addr_len = (u32) _res->ai_addrlen;
-		freeaddrinfo(_res);
+		res = gf_sk_get_ipv6_addr(multi_IPAdd, MultiPortNumber, AF_UNSPEC, 0, SOCK_DGRAM);
+		if (!res) return GF_IP_CONNECTION_FAILURE;
+		memcpy(&sock->dest_addr, res->ai_addr, res->ai_addrlen);
+		sock->dest_addr_len = (u32) res->ai_addrlen;
+		freeaddrinfo(res);
 
 		addr = (struct sockaddr *)&sock->dest_addr;
 		if (addr->sa_family == AF_INET) {
 			M_req.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
 			M_req.imr_interface.s_addr = INADDR_ANY;
-			ret = setsockopt(sock->socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &M_req, sizeof(M_req));
-			if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
-			/*set TTL*/
-			ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &TTL, sizeof(TTL));
-			if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
-			/*Disable loopback*/
-			flag = 1;
-			ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &flag, sizeof(flag));
-			if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
-		}
 
-		if (addr->sa_family == AF_INET6) {
-			struct ipv6_mreq M_reqV6;
+			e = sk_join_ipv4(sock, &M_req, TTL, src_ip_inc, nb_src_ip_inc, src_ip_exc, nb_src_ip_exc);
+			if (e) return e;
+			sock->flags |= GF_SOCK_IS_MULTICAST | GF_SOCK_HAS_PEER;
+			return GF_OK;
+		}
+		else if (addr->sa_family != AF_INET6) {
+			return GF_IP_CONNECTION_FAILURE;
+		}
 
-			memcpy(&M_reqV6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
-			M_reqV6.ipv6mr_interface = 0;
+		struct ipv6_mreq M_reqV6;
+		memcpy(&M_reqV6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
+		M_reqV6.ipv6mr_interface = 0;
+
+		if (nb_src_ip_inc) {
+#ifdef MCAST_JOIN_SOURCE_GROUP
+			u32 i;
+			struct group_source_req M_reqV6_src;
+			memset(&M_reqV6_src, 0, sizeof(struct group_source_req));
+			M_reqV6_src.gsr_interface = 0;
+			M_reqV6_src.gsr_group = sock->dest_addr;
+
+			for (i=0; i<nb_src_ip_inc; i++) {
+				res = gf_sk_get_ipv6_addr(src_ip_inci, MultiPortNumber, AF_UNSPEC, 0, SOCK_DGRAM);
+				if (!res) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core Failed to get address info for SSM source %s, ignoring\n", src_ip_inci));
+					continue;
+				}
+				memcpy(&M_reqV6_src.gsr_source, res->ai_addr, res->ai_addrlen);
+				freeaddrinfo(res);
+				ret = setsockopt(sock->socket, IPPROTO_IPV6, MCAST_JOIN_SOURCE_GROUP, (char *) &M_reqV6_src, sizeof(M_reqV6_src) );
+				if (ret == SOCKET_ERROR) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core cannot join source group %s: %s\n", src_ip_inci, gf_errno_str(LASTSOCKERROR)));
+					return GF_IP_CONNECTION_FAILURE;
+				}
+			}
+#else
+			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core SSM IPv6 not supported\n"));
+			return GF_NOT_SUPPORTED;
+#endif
 
-			/*set TTL*/
-			ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *) &TTL, sizeof(TTL));
-			if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
-			/*enable loopback*/
-			flag = 1;
-			ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &flag, sizeof(flag));
+		} else {
+			ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *) &M_reqV6, sizeof(M_reqV6));
 			if (ret == SOCKET_ERROR) {
-				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("Socket Cannot disale multicast loop: %s\n", gf_errno_str(LASTSOCKERROR) ));
+				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core Failed to join multicast: %s\n", gf_errno_str(LASTSOCKERROR) ));
+				return GF_IP_CONNECTION_FAILURE;
 			}
+		}
 
-			ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *) &M_reqV6, sizeof(M_reqV6));
-			if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
+		/*set TTL*/
+		ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *) &TTL, sizeof(TTL));
+		if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
+		/*enable loopback*/
+		optval = 1;
+		ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &optval, sizeof(optval));
+		if (ret == SOCKET_ERROR) {
+			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("Socket Cannot enable multicast loop: %s\n", gf_errno_str(LASTSOCKERROR) ));
+		}
+
+		if (nb_src_ip_exc) {
+#ifdef MCAST_BLOCK_SOURCE
+			u32 i, j;
+			struct group_source_req M_reqV6_src;
+			M_reqV6_src.gsr_interface = 0;
+			M_reqV6_src.gsr_group = sock->dest_addr;
+			for (i=0; i<nb_src_ip_exc; i++) {
+				Bool match=GF_FALSE;
+				for (j=0; j<nb_src_ip_inc; j++) {
+					if (!strcmp(src_ip_incj, src_ip_exci)) match=GF_TRUE;
+				}
+				if (match) continue;
+
+				res = gf_sk_get_ipv6_addr(src_ip_exci, MultiPortNumber, AF_UNSPEC, 0, SOCK_DGRAM);
+				if (!res) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core Failed to get address info for SSM excluded source %s, ignoring\n", src_ip_exci));
+					continue;
+				}
+				memcpy(&M_reqV6_src.gsr_source, res->ai_addr, res->ai_addrlen);
+				freeaddrinfo(res);
+
+				ret = setsockopt(sock->socket, IPPROTO_IPV6, MCAST_BLOCK_SOURCE, (char *) &M_reqV6_src, sizeof(M_reqV6_src) );
+				if (ret == SOCKET_ERROR) {
+					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core cannot block source membership for %s: %s\n", src_ip_exci, gf_errno_str(LASTSOCKERROR)));
+					return GF_IP_CONNECTION_FAILURE;
+				}
+			}
+#else
+			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("core SSM IPv6 not supported\n"));
+#endif
 		}
 		sock->flags |= GF_SOCK_IS_MULTICAST | GF_SOCK_HAS_PEER;
 		return GF_OK;
@@ -1243,23 +1677,8 @@
 	M_req.imr_multiaddr.s_addr = inet_addr(multi_IPAdd);
 	M_req.imr_interface.s_addr = local_add_id;
 
-	ret = setsockopt(sock->socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &M_req, sizeof(M_req));
-	if (ret == SOCKET_ERROR) {
-		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("core cannot join multicast: %s\n", gf_errno_str(LASTSOCKERROR)));
-		return GF_IP_CONNECTION_FAILURE;
-	}
-	/*set the Time To Live*/
-	if (TTL) {
-		ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_TTL, (char *)&TTL, sizeof(TTL));
-		if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
-	}
-
-	/*enable loopback*/
-	flag = 1;
-	ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &flag, sizeof(flag));
-	if (ret == SOCKET_ERROR) {
-		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("Socket Cannot disable multicast loop: %s\n", gf_errno_str(LASTSOCKERROR) ));
-	}
+	e = sk_join_ipv4(sock, &M_req, TTL, src_ip_inc, nb_src_ip_inc, src_ip_exc, nb_src_ip_exc);
+	if (e) return e;
 
 #ifdef GPAC_HAS_IPV6
 	((struct sockaddr_in *) &sock->dest_addr)->sin_family = AF_INET;
@@ -1276,11 +1695,25 @@
 	return GF_OK;
 }
 
+GF_EXPORT
+GF_Err gf_sk_setup_multicast(GF_Socket *sock, const char *multi_IPAdd, u16 MultiPortNumber, u32 TTL, Bool NoBind, char *local_interface_ip)
+{
+	return gf_sk_setup_multicast_ex(sock, multi_IPAdd, MultiPortNumber, TTL, NoBind, local_interface_ip, NULL, 0, NULL, 0);
+
+}
+
 #include <gpac/list.h>
 struct __tag_sock_group
 {
 	GF_List *sockets;
 	fd_set rgroup, wgroup;
+
+#ifdef GPAC_HAS_POLL
+	u32 last_mask;
+	u32 nb_fds, alloc_fds;
+	GF_POLLFD *fds;
+#endif
+
 };
 
 GF_SockGroup *gf_sk_group_new()
@@ -1288,44 +1721,125 @@
 	GF_SockGroup *tmp;
 	GF_SAFEALLOC(tmp, GF_SockGroup);
 	if (!tmp) return NULL;
-	tmp->sockets = gf_list_new();
 	FD_ZERO(&tmp->rgroup);
 	FD_ZERO(&tmp->wgroup);
+
+#ifdef GPAC_HAS_POLL
+	tmp->last_mask = POLLIN;
+#endif
 	return tmp;
 }
 
 void gf_sk_group_del(GF_SockGroup *sg)
 {
 	gf_list_del(sg->sockets);
+#ifdef GPAC_HAS_POLL
+	if (sg->fds) gf_free(sg->fds);
+#endif
 	gf_free(sg);
 }
 
 void gf_sk_group_register(GF_SockGroup *sg, GF_Socket *sk)
 {
-	if (sg && sk) {
-		if (gf_list_find(sg->sockets, sk)<0)
-			gf_list_add(sg->sockets, sk);
-	}
+	if (!sg || !sk) return;
+	if (!sg->sockets) sg->sockets = gf_list_new();
+	if (gf_list_find(sg->sockets, sk)>=0) return;
+	gf_list_add(sg->sockets, sk);
+#ifdef GPAC_HAS_POLL
+	if (!sg->fds && !gpac_use_poll)
+		return;
+
+	if (sg->nb_fds + 1 > sg->alloc_fds) {
+		sg->fds = gf_realloc(sg->fds, (sg->nb_fds+1) * sizeof(GF_POLLFD));
+		sg->alloc_fds = sg->nb_fds+1;
+	}
+	sg->fdssg->nb_fds.fd = sk->socket;
+	sg->fdssg->nb_fds.events = sg->last_mask;
+	sg->fdssg->nb_fds.revents = 0;
+	sk->poll_idx = sg->nb_fds+1;
+	assert(sg->fdssg->nb_fds.fd != 0);
+	sg->nb_fds++;
+#endif
 }
+
 void gf_sk_group_unregister(GF_SockGroup *sg, GF_Socket *sk)
 {
-	if (sg && sk) {
-		gf_list_del_item(sg->sockets, sk);
+	if (!sg || !sk) return;
+	s32 pidx = gf_list_del_item(sg->sockets, sk);
+	if (!gf_list_count(sg->sockets)) {
+		gf_list_del(sg->sockets);
+		sg->sockets = NULL;
+#ifdef GPAC_HAS_POLL
+		if (sg->fds) {
+			gf_free(sg->fds);
+			sg->fds = NULL;
+			sg->nb_fds = sg->alloc_fds = 0;
+		}
+#endif
+		return;
+	}
+	if (pidx<0) return;
+
+#ifdef GPAC_HAS_POLL
+	sk->poll_idx=0;
+	if (!sg->fds) return;
+	memmove(&sg->fdspidx, &sg->fdspidx+1, sizeof(GF_POLLFD) * (sg->nb_fds-pidx-1));
+	//reassign poll file descriptors and poll index
+	sg->nb_fds--;
+	while (1) {
+		GF_Socket *asock = gf_list_get(sg->sockets, pidx);
+		if (!asock) break;
+		sg->fdspidx.fd = asock->socket;
+		asock->poll_idx = pidx+1;
+		pidx++;
 	}
+#endif
 }
 
 GF_Err gf_sk_group_select(GF_SockGroup *sg, u32 usec_wait, GF_SockSelectMode mode)
 {
 	s32 ready;
-	u32 i=0;
+	u32 i;
 	struct timeval timeout;
-	u32 max_fd=0;
 	GF_Socket *sock;
-	fd_set *rgroup=NULL, *wgroup=NULL;
 
-	if (!gf_list_count(sg->sockets))
+	if (!sg->sockets)
 		return GF_IP_NETWORK_EMPTY;
 
+#ifdef GPAC_HAS_POLL
+	if (sg->fds) {
+		u32 mask = 0;
+		if (mode == GF_SK_SELECT_BOTH) mask = POLLIN | POLLOUT;
+		else if (mode == GF_SK_SELECT_READ) mask = POLLIN;
+		else mask = POLLOUT;
+		if (sg->last_mask != mask) {
+			sg->last_mask = mask;
+			for (i=0; i<sg->nb_fds; i++) {
+				sg->fdsi.events = mask;
+				assert(sg->fdsi.fd != 0);
+			}
+		}
+		int res = poll(sg->fds, sg->nb_fds, usec_wait/1000);
+		if (res<0) {
+			switch (LASTSOCKERROR) {
+			case EAGAIN:
+				return GF_IP_NETWORK_EMPTY;
+			default:
+				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("socket cannot poll: %s\n", gf_errno_str(LASTSOCKERROR) ));
+				return GF_IP_NETWORK_FAILURE;
+			}
+		}
+
+		if (!res)
+			return GF_IP_NETWORK_EMPTY;
+		return GF_OK;
+	}
+#endif
+
+	i=0;
+	u32 max_fd=0;
+	fd_set *rgroup=NULL, *wgroup=NULL;
+
 	FD_ZERO(&sg->rgroup);
 	FD_ZERO(&sg->wgroup);
 
@@ -1350,13 +1864,8 @@
 
 		if (max_fd < (u32) sock->socket) max_fd = (u32) sock->socket;
 	}
-	if (usec_wait>=1000000) {
-		timeout.tv_sec = usec_wait/1000000;
-		timeout.tv_usec = (u32) (usec_wait - (timeout.tv_sec*1000000));
-	} else {
-		timeout.tv_sec = 0;
-		timeout.tv_usec = usec_wait;
-	}
+	timeout.tv_sec = 0;
+	timeout.tv_usec = usec_wait;
 	ready = select((int) max_fd+1, rgroup, wgroup, NULL, &timeout);
 
 	if (ready == SOCKET_ERROR) {
@@ -1365,9 +1874,9 @@
 			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("socket cannot select, BAD descriptor\n"));
 			return GF_IP_CONNECTION_CLOSED;
 		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
+			return GF_IP_NETWORK_EMPTY;
 		case EINTR:
-			/* Interrupted system call, not really important... */
+			/* Interrupted system call*/
 			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("socket network is lost\n"));
 			return GF_IP_NETWORK_EMPTY;
 		default:
@@ -1384,12 +1893,32 @@
 
 Bool gf_sk_group_sock_is_set(GF_SockGroup *sg, GF_Socket *sk, GF_SockSelectMode mode)
 {
-	if (sg && sk) {
-		if ((mode!=GF_SK_SELECT_WRITE) && FD_ISSET(sk->socket, &sg->rgroup))
+	if (!sg || !sk) return GF_FALSE;
+
+#ifdef GPAC_HAS_POLL
+	if (sg->fds && sk->poll_idx) {
+		GF_POLLFD *pfd = &sg->fdssk->poll_idx-1;
+		//disconnected, consider ready to read/write
+		if (pfd->revents & POLLHUP)
+			return GF_TRUE;
+
+		if ((mode!=GF_SK_SELECT_WRITE) && (pfd->revents & POLLIN))
 			return GF_TRUE;
-		if ((mode!=GF_SK_SELECT_READ) && FD_ISSET(sk->socket, &sg->wgroup))
+
+		if ((mode!=GF_SK_SELECT_READ) && (pfd->revents & POLLOUT))
 			return GF_TRUE;
+
+//		if (gf_sk_probe(sk) == GF_IP_CONNECTION_CLOSED)
+//			return GF_TRUE;
+		return GF_FALSE;
 	}
+#endif
+
+	if ((mode!=GF_SK_SELECT_WRITE) && FD_ISSET(sk->socket, &sg->rgroup))
+		return GF_TRUE;
+	if ((mode!=GF_SK_SELECT_READ) && FD_ISSET(sk->socket, &sg->wgroup))
+		return GF_TRUE;
+
 	return GF_FALSE;
 }
 
@@ -1400,46 +1929,15 @@
 GF_Err gf_sk_receive_internal(GF_Socket *sock, char *buffer, u32 length, u32 *BytesRead, Bool do_select)
 {
 	s32 res;
-#ifndef __SYMBIAN32__
-	s32 ready;
-	struct timeval timeout;
-	fd_set Group;
-#endif
 
 	if (BytesRead) *BytesRead = 0;
 	if (!sock || !sock->socket) return GF_BAD_PARAM;
 
-#ifndef __SYMBIAN32__
-	if (do_select) {
-		//can we read?
-		timeout.tv_sec = 0;
-		timeout.tv_usec = sock->usec_wait;
-		FD_ZERO(&Group);
-		FD_SET(sock->socket, &Group);
-		ready = select((int) sock->socket+1, &Group, NULL, NULL, &timeout);
-
-		if (ready == SOCKET_ERROR) {
-			switch (LASTSOCKERROR) {
-			case EBADF:
-				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("socket cannot select, BAD descriptor\n"));
-				return GF_IP_CONNECTION_CLOSED;
-			case EAGAIN:
-				return GF_IP_SOCK_WOULD_BLOCK;
-			case EINTR:
-				/* Interrupted system call, not really important... */
-				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("socket network is lost\n"));
-				return GF_IP_NETWORK_EMPTY;
-			default:
-				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("socket cannot select: %s\n", gf_errno_str(LASTSOCKERROR) ));
-				return GF_IP_NETWORK_FAILURE;
-			}
-		}
-		if (!ready || !FD_ISSET(sock->socket, &Group)) {
-			GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("socket nothing to be read - ready %d\n", ready));
-			return GF_IP_NETWORK_EMPTY;
-		}
+	if (do_select && !(sock->flags & GF_SOCK_NON_BLOCKING)) {
+		//check read
+		GF_Err e = poll_select(sock, GF_SK_SELECT_READ, sock->usec_wait, GF_FALSE);
+		if (e) return e;
 	}
-#endif
 	if (!buffer) return GF_OK;
 
 	if (sock->flags & GF_SOCK_HAS_PEER)
@@ -1454,7 +1952,14 @@
 		res = LASTSOCKERROR;
 		switch (res) {
 		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
+			return GF_IP_NETWORK_EMPTY;
+
+#if defined(WIN32) || defined(_WIN32_WCE)
+		//may happen if no select
+		case WSAEWOULDBLOCK:
+			return GF_IP_NETWORK_EMPTY;
+#endif
+
 #ifndef __SYMBIAN32__
 		case EMSGSIZE:
 			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket error reading: %s\n", gf_errno_str(LASTSOCKERROR)));
@@ -1462,6 +1967,9 @@
 		case ENOTCONN:
 		case ECONNRESET:
 		case ECONNABORTED:
+#if defined(WIN32) || defined(_WIN32_WCE)
+		case WSAECONNRESET:
+#endif
 			//log as debug, let higher level decide if this is an error or not
 			GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("socket error reading: %s\n", gf_errno_str(LASTSOCKERROR)));
 			return GF_IP_CONNECTION_CLOSED;
@@ -1494,7 +2002,9 @@
 {
 	s32 i;
 	if (!sock || !sock->socket) return GF_BAD_PARAM;
-	if (MaxConnection >= SOMAXCONN) MaxConnection = SOMAXCONN;
+	if (!MaxConnection || (MaxConnection >= SOMAXCONN)) {
+		MaxConnection = SOMAXCONN;
+	}
 	i = listen(sock->socket, MaxConnection);
 	if (i == SOCKET_ERROR) return GF_IP_NETWORK_FAILURE;
 	sock->flags |= GF_SOCK_IS_LISTENING;
@@ -1506,34 +2016,12 @@
 {
 	u32 client_address_size;
 	SOCKET sk;
-#ifndef __SYMBIAN32__
-	s32 ready;
-	struct timeval timeout;
-	fd_set Group;
-#endif
 	*newConnection = NULL;
 	if (!sock || !(sock->flags & GF_SOCK_IS_LISTENING) ) return GF_BAD_PARAM;
 
-#ifndef __SYMBIAN32__
-	//can we read?
-	FD_ZERO(&Group);
-	FD_SET(sock->socket, &Group);
-	timeout.tv_sec = 0;
-	timeout.tv_usec = sock->usec_wait;
-
-	//TODO - check if this is correct
-	ready = select((int) sock->socket+1, &Group, NULL, NULL, &timeout);
-	if (ready == SOCKET_ERROR) {
-		switch (LASTSOCKERROR) {
-		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket select error: %s\n", gf_errno_str(LASTSOCKERROR)));
-			return GF_IP_NETWORK_FAILURE;
-		}
-	}
-	if (!ready || !FD_ISSET(sock->socket, &Group)) return GF_IP_NETWORK_EMPTY;
-#endif
+	//check read
+	GF_Err e = poll_select(sock, GF_SK_SELECT_READ, sock->usec_wait, GF_FALSE);
+	if (e) return e;
 
 #ifdef GPAC_HAS_IPV6
 	client_address_size = sizeof(struct sockaddr_in6);
@@ -1544,10 +2032,9 @@
 
 	//we either have an error or we have no connections
 	if (sk == INVALID_SOCKET) {
-//		if (sock->flags & GF_SOCK_NON_BLOCKING) return GF_IP_NETWORK_FAILURE;
 		switch (LASTSOCKERROR) {
 		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
+			return GF_IP_NETWORK_EMPTY;
 		default:
 			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket accept error: %s\n", gf_errno_str(LASTSOCKERROR)));
 			return GF_IP_NETWORK_FAILURE;
@@ -1639,7 +2126,11 @@
 	char servnameNI_MAXHOST;
 	struct sockaddr_in6 * addrptr = (struct sockaddr_in6 *)(&sock->dest_addr);
 	if (!sock || !sock->socket) return GF_BAD_PARAM;
+#ifdef GPAC_BUILD_FOR_WINXP
+	inet_ntop_xp(AF_INET, addrptr, clienthost, NI_MAXHOST);
+#else
 	inet_ntop(AF_INET, addrptr, clienthost, NI_MAXHOST);
+#endif
 	strcpy(buf, clienthost);
 	if (getnameinfo((struct sockaddr *)addrptr, sock->dest_addr_len, clienthost, NI_MAXHOST, servname, NI_MAXHOST, NI_NUMERICHOST) == 0) {
 		strcpy(buf, clienthost);
@@ -1666,37 +2157,14 @@
 	struct sockaddr_in remote_add;
 	struct hostent *Host;
 #endif
-#ifndef __SYMBIAN32__
-	s32 ready;
-	struct timeval timeout;
-	fd_set Group;
-#endif
 
 	//the socket must be bound or connected
 	if (!sock || !sock->socket) return GF_BAD_PARAM;
 	if (remoteHost && !remotePort) return GF_BAD_PARAM;
 
-#ifndef __SYMBIAN32__
-	//can we write?
-	FD_ZERO(&Group);
-	FD_SET(sock->socket, &Group);
-	timeout.tv_sec = 0;
-	timeout.tv_usec = sock->usec_wait;
-
-	//TODO - check if this is correct
-	ready = select((int) sock->socket+1, NULL, &Group, NULL, &timeout);
-	if (ready == SOCKET_ERROR) {
-		switch (LASTSOCKERROR) {
-		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket select error: %s\n", gf_errno_str(LASTSOCKERROR)));
-			return GF_IP_NETWORK_FAILURE;
-		}
-	}
-	if (!ready || !FD_ISSET(sock->socket, &Group)) return GF_IP_NETWORK_EMPTY;
-#endif
-
+	//check write
+	GF_Err e = poll_select(sock, GF_SK_SELECT_WRITE, sock->usec_wait, GF_FALSE);
+	if (e) return e;
 
 	/*setup the address*/
 #ifdef GPAC_HAS_IPV6
@@ -1738,7 +2206,7 @@
 		if (res == SOCKET_ERROR) {
 			switch (LASTSOCKERROR) {
 			case EAGAIN:
-				return GF_IP_SOCK_WOULD_BLOCK;
+				return GF_IP_NETWORK_EMPTY;
 			default:
 				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket sendto error: %s\n", gf_errno_str(LASTSOCKERROR)));
 				return GF_IP_NETWORK_FAILURE;
@@ -1753,36 +2221,15 @@
 GF_EXPORT
 GF_Err gf_sk_probe(GF_Socket *sock)
 {
-#ifndef __SYMBIAN32__
-	s32 ready;
-	struct timeval timeout;
-	fd_set Group;
-#endif
 	s32 res;
 	u8 buffer1;
 	if (!sock) return GF_BAD_PARAM;
 
-#ifndef __SYMBIAN32__
-	//can we read?
-	FD_ZERO(&Group);
-	FD_SET(sock->socket, &Group);
-	timeout.tv_sec = 0;
-	timeout.tv_usec = 100;
+	//check read - force using select at least for windows, for which poll returns nothing on connection abort
+	GF_Err e = poll_select(sock, GF_SK_SELECT_READ, 100, GF_TRUE);
+	if (e) return e;
 
-	ready = select((int) sock->socket+1, &Group, NULL, NULL, &timeout);
-	if (ready == SOCKET_ERROR) {
-		switch (LASTSOCKERROR) {
-		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket select error: %s\n", gf_errno_str(LASTSOCKERROR)));
-			return GF_IP_CONNECTION_CLOSED;
-		}
-	}
-	if (!FD_ISSET(sock->socket, &Group)) {
-		return GF_IP_NETWORK_EMPTY;
-	}
-#endif
+	//peek message
 	res = (s32) recv(sock->socket, buffer, 1, MSG_PEEK);
 	if (res > 0) return GF_OK;
 #if 0
@@ -1803,118 +2250,6 @@
 }
 
 GF_EXPORT
-GF_Err gf_sk_receive_wait(GF_Socket *sock, u8 *buffer, u32 length, u32 *BytesRead, u32 Second )
-{
-	s32 res;
-#ifndef __SYMBIAN32__
-	s32 ready;
-	struct timeval timeout;
-	fd_set Group;
-#endif
-
-	if (!sock || !sock->socket || !buffer || !BytesRead) return GF_BAD_PARAM;
-	*BytesRead = 0;
-
-#ifndef __SYMBIAN32__
-	//can we read?
-	FD_ZERO(&Group);
-	FD_SET(sock->socket, &Group);
-	timeout.tv_sec = Second;
-	timeout.tv_usec = sock->usec_wait;
-
-	ready = select((int) sock->socket+1, &Group, NULL, NULL, &timeout);
-	if (ready == SOCKET_ERROR) {
-		switch (LASTSOCKERROR) {
-		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket select error: %s\n", gf_errno_str(LASTSOCKERROR)));
-			return GF_IP_NETWORK_FAILURE;
-		}
-	}
-	if (!FD_ISSET(sock->socket, &Group)) {
-		return GF_IP_NETWORK_EMPTY;
-	}
-#endif
-
-	res = (s32) recv(sock->socket, (char *) buffer, length, 0);
-	if (res == SOCKET_ERROR) {
-		switch (LASTSOCKERROR) {
-		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket recv error: %s\n", gf_errno_str(LASTSOCKERROR)));
-			return GF_IP_NETWORK_FAILURE;
-		}
-	}
-	*BytesRead = res;
-	return GF_OK;
-}
-
-
-//send length bytes of a buffer
-GF_EXPORT
-GF_Err gf_sk_send_wait(GF_Socket *sock, const u8 *buffer, u32 length, u32 Second )
-{
-	u32 count;
-	s32 res;
-#ifndef __SYMBIAN32__
-	s32 ready;
-	struct timeval timeout;
-	fd_set Group;
-#endif
-
-	//the socket must be bound or connected
-	if (!sock || !sock->socket) return GF_BAD_PARAM;
-
-#ifndef __SYMBIAN32__
-	//can we write?
-	FD_ZERO(&Group);
-	FD_SET(sock->socket, &Group);
-	timeout.tv_sec = Second;
-	timeout.tv_usec = sock->usec_wait;
-
-	//TODO - check if this is correct
-	ready = select((int) sock->socket+1, NULL, &Group, NULL, &timeout);
-	if (ready == SOCKET_ERROR) {
-		switch (LASTSOCKERROR) {
-		case EAGAIN:
-			return GF_IP_SOCK_WOULD_BLOCK;
-		default:
-			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket select error: %s\n", gf_errno_str(LASTSOCKERROR)));
-			return GF_IP_NETWORK_FAILURE;
-		}
-	}
-	//should never happen (to check: is writeability is guaranteed for not-connected sockets)
-	if (!ready || !FD_ISSET(sock->socket, &Group)) {
-		return GF_IP_NETWORK_EMPTY;
-	}
-#endif
-
-	//direct writing
-	count = 0;
-	while (count < length) {
-		res = (s32) send(sock->socket, (char *) buffer+count, length - count, 0);
-		if (res == SOCKET_ERROR) {
-			switch (LASTSOCKERROR) {
-			case EAGAIN:
-				return GF_IP_SOCK_WOULD_BLOCK;
-#ifndef __SYMBIAN32__
-			case ECONNRESET:
-				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket send error: %s\n", gf_errno_str(LASTSOCKERROR)));
-				return GF_IP_CONNECTION_CLOSED;
-#endif
-			default:
-				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("socket send error: %s\n", gf_errno_str(LASTSOCKERROR)));
-				return GF_IP_NETWORK_FAILURE;
-			}
-		}
-		count += res;
-	}
-	return GF_OK;
-}
-
-GF_EXPORT
 u32 gf_htonl(u32 val)
 {
 	return htonl(val);
@@ -1939,5 +2274,3 @@
 {
 	return ntohs(val);
 }
-
-#endif /*GPAC_DISABLE_CORE_TOOLS*/

gpac-2.0.0.tar.gz/src/utils/os_thread.c -> gpac-2.2.0.tar.gz/src/utils/os_thread.c Changed

gpac-2.0.0.tar.gz/src/utils/sha1.c -> gpac-2.2.0.tar.gz/src/utils/sha1.c Changed

gpac-2.2.0.tar.gz/src/utils/sha256.c Added

@@ -0,0 +1,142 @@
+/*
+ SHA256 implementation, source file.
+
+ This implementation was written by Kent "ethereal" Williams-King and is
+ hereby released into the public domain. Do what you wish with it.
+
+ No guarantees as to the correctness of the implementation are provided.
+*/
+
+#include <gpac/tools.h>
+
+static const u32 sha256_initial_h8
+ = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+ 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
+
+static const u32 sha256_round_k64
+ = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+ 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+ 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+ 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+ 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+ 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+ 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+ 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+ 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+ 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+ 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
+
+static void sha256_endian_reverse64(u64 input, u8 *output) {
+ output7 = (input >> 0) & 0xff;
+ output6 = (input >> 8) & 0xff;
+ output5 = (input >> 16) & 0xff;
+ output4 = (input >> 24) & 0xff;
+ output3 = (input >> 32) & 0xff;
+ output2 = (input >> 40) & 0xff;
+ output1 = (input >> 48) & 0xff;
+ output0 = (input >> 56) & 0xff;
+}
+
+static u32 sha256_endian_read32(u8 *input) {
+ u32 output = 0;
+ output |= (input0 << 24);
+ output |= (input1 << 16);
+ output |= (input2 << 8);
+ output |= (input3 << 0);
+
+ return output;
+}
+
+static void sha256_endian_reverse32(u32 input, u8 *output) {
+ output3 = (input >> 0) & 0xff;
+ output2 = (input >> 8) & 0xff;
+ output1 = (input >> 16) & 0xff;
+ output0 = (input >> 24) & 0xff;
+}
+
+static u32 sha256_ror(u32 input, u32 by) {
+ return (input >> by) | (((input & ((1 << by) - 1))) << (32 - by));
+}
+
+GF_EXPORT
+void gf_sha256_csum(const void *data, u64 len, u8 outputGF_SHA256_DIGEST_SIZE) {
+ u8 padding80;
+ u64 current = (len + 1) % 64;
+ // want to be == 56 % 64.
+ u64 needed = (64 + 56 - current) % 64;
+ u64 extra = needed + 9;
+ u64 total = len + extra;
+
+ for(int i = 1; i < 80; i++)
+ paddingi = 0;
+ padding0 = 0x80;
+ sha256_endian_reverse64(len * 8, padding + total - len - 8);
+
+ u32 v8;
+ for(int i = 0; i < 8; i++)
+ vi = sha256_initial_hi;
+
+ for(u64 cursor = 0; cursor * 64 < total; cursor++) {
+ u32 t8;
+ for(int i = 0; i < 8; i++)
+ ti = vi;
+
+ u32 w64;
+ if(cursor * 64 + 64 <= len) {
+ for(int j = 0; j < 16; j++) {
+ wj = sha256_endian_read32(
+ (u8 *)data + cursor * 64 + j * 4);
+ }
+ }
+ else {
+ if(cursor * 64 < len) {
+ u32 size = (u32) ( len - cursor * 64 );
+ if(size > 0) memcpy(w, (u8 *)data + cursor * 64, size);
+ memcpy((u8 *)w + size, padding, 64 - size);
+ }
+ else {
+ u64 off = (cursor * 64 - len) % 64;
+ memcpy((u8 *)w, padding + off, 64);
+ }
+
+ for(int j = 0; j < 16; j++) {
+ wj = sha256_endian_read32((u8 *)&wj);
+ }
+ }
+
+ for(int j = 16; j < 64; j++) {
+ u32 s1 = sha256_ror(wj - 2, 17) ^ sha256_ror(wj - 2, 19)
+ ^ (wj - 2 >> 10);
+ u32 s0 = sha256_ror(wj - 15, 7) ^ sha256_ror(wj - 15, 18)
+ ^ (wj - 15 >> 3);
+ wj = s1 + wj - 7 + s0 + wj - 16;
+ }
+
+ for(int j = 0; j < 64; j++) {
+ u32 ch = (t4 & t5) ^ (~t4 & t6);
+ u32 maj = (t0 & t1) ^ (t0 & t2) ^ (t1 & t2);
+ u32 S0 = sha256_ror(t0, 2) ^ sha256_ror(t0, 13)
+ ^ sha256_ror(t0, 22);
+ u32 S1 = sha256_ror(t4, 6) ^ sha256_ror(t4, 11)
+ ^ sha256_ror(t4, 25);
+
+ u32 t1 = t7 + S1 + ch + sha256_round_kj + wj;
+ u32 t2 = S0 + maj;
+
+ t7 = t6;
+ t6 = t5;
+ t5 = t4;
+ t4 = t3 + t1;
+ t3 = t2;
+ t2 = t1;
+ t1 = t0;
+ t0 = t1 + t2;
+ }
+
+ for(int i = 0; i < 8; i++)
+ vi += ti;
+ }
+
+ for(int i = 0; i < 8; i++)
+ sha256_endian_reverse32(vi, (u8 *)output + i * 4);
+}

gpac-2.0.0.tar.gz/src/utils/symbian_os.cpp -> gpac-2.2.0.tar.gz/src/utils/symbian_os.cpp Changed

gpac-2.0.0.tar.gz/src/utils/token.c -> gpac-2.2.0.tar.gz/src/utils/token.c Changed

gpac-2.0.0.tar.gz/src/utils/unicode.c -> gpac-2.2.0.tar.gz/src/utils/unicode.c Changed

@@ -46,8 +46,7 @@
 	while (utf8_buf != utf8_endbuf) {
 
 		if ((*utf8_buf & 0x80) == 0x00) {
-			/* ASCII chars no
-								 * conversion needed */
+			/* ASCII chars no conversion needed */
 			*ucs4_buf++ = (u32) * utf8_buf;
 			utf8_buf++;
 			ucs_len++;
@@ -59,8 +58,7 @@
 			utf8_buf += 2;
 			ucs_len++;
 		} else if ((*utf8_buf & 0xF0) == 0xE0) {
-			/* In the 3 byte utf-8
-									 * range */
+			/* In the 3 byte utf-8 range */
 			*ucs4_buf++ = (u32) (((*utf8_buf - 0xE0) * 0x1000)
 			                     + ((*(utf8_buf + 1) - 0x80) * 0x40)
 			                     + (*(utf8_buf + 2) - 0x80));
@@ -68,8 +66,7 @@
 			utf8_buf += 3;
 			ucs_len++;
 		} else if ((*utf8_buf & 0xF8) == 0xF0) {
-			/* In the 4 byte utf-8
-									 * range */
+			/* In the 4 byte utf-8 range */
 			*ucs4_buf++ = (u32)
 			              (((*utf8_buf - 0xF0) * 0x040000)
 			               + ((*(utf8_buf + 1) - 0x80) * 0x1000)
@@ -78,8 +75,7 @@
 			utf8_buf += 4;
 			ucs_len++;
 		} else if ((*utf8_buf & 0xFC) == 0xF8) {
-			/* In the 5 byte utf-8
-									 * range */
+			/* In the 5 byte utf-8 range */
 			*ucs4_buf++ = (u32)
 			              (((*utf8_buf - 0xF8) * 0x01000000)
 			               + ((*(utf8_buf + 1) - 0x80) * 0x040000)
@@ -89,8 +85,7 @@
 			utf8_buf += 5;
 			ucs_len++;
 		} else if ((*utf8_buf & 0xFE) == 0xFC) {
-			/* In the 6 byte utf-8
-									 * range */
+			/* In the 6 byte utf-8  range */
 			*ucs4_buf++ = (u32)
 			              (((*utf8_buf - 0xFC) * 0x40000000)
 			               + ((*(utf8_buf + 1) - 0x80) * 0x010000000)

gpac-2.0.0.tar.gz/src/utils/url.c -> gpac-2.2.0.tar.gz/src/utils/url.c Changed

@@ -94,6 +94,14 @@
 }
 
 GF_EXPORT
+Bool gf_url_is_relative(const char *pathName)
+{
+	if (!pathName) return GF_TRUE;
+	u32 mode = URL_GetProtocolType(pathName);
+	return (mode==GF_URL_TYPE_RELATIVE) ? GF_TRUE : GF_FALSE;
+}
+
+GF_EXPORT
 char *gf_url_get_absolute_path(const char *pathName, const char *parentPath)
 {
 	char* sep;
@@ -329,10 +337,30 @@
 	else if (!had_sep_count && (pathName0=='.') && (tmp0=='.') && ((tmp1=='/') || (tmp1=='\\') ) ) {
 		u32 nb_path_sep=0;
 		u32 len = (u32) strlen(tmp);
+
 		for (i=0; i<len; i++) {
 			if ((tmpi=='/') || (tmpi=='\\') )
 				nb_path_sep++;
 		}
+
+		const char *p_src = pathName+2;
+		const char *p_tmp = tmp+2;
+		//strip if same beginning
+		while (1) {
+			char *sep = strchr(p_src, '/');
+			if (!sep) sep = strchr(p_src, '\\');
+			if (!sep) break;
+			u32 sep_len = (u32) (sep - p_src);
+			if (!sep_len) break;
+			if (sep_len > len) break;
+			if (strncmp(p_tmp, p_src, sep_len)) break;
+			if ((p_tmpsep_len != '/') && (p_tmpsep_len != '\\')) break;
+			p_src += sep_len+1;
+			name += sep_len+1;
+			p_tmp += sep_len+1;
+			len -= sep_len;
+			nb_path_sep--;
+		}
 		strcpy(tmp, "");
 		while (nb_path_sep--)
 			strcat(tmp, "../");
@@ -399,7 +427,7 @@
 
 //TODO handle reserved characters
 const char *pce_special = " %";
-const char *pce_encoded = "0123456789ABCDEF";
+const char *pce_encoded = "0123456789ABCDEFabcdef";
 
 char *gf_url_percent_encode(const char *path)
 {

gpac-2.0.0.tar.gz/src/utils/utf.c -> gpac-2.2.0.tar.gz/src/utils/utf.c Changed

gpac-2.0.0.tar.gz/src/utils/xml_parser.c -> gpac-2.2.0.tar.gz/src/utils/xml_parser.c Changed

@@ -27,8 +27,6 @@
 #include <gpac/utf.h>
 #include <gpac/network.h>
 
-#ifndef GPAC_DISABLE_CORE_TOOLS
-
 #ifndef GPAC_DISABLE_ZLIB
 /*since 0.2.2, we use zlib for xmt/x3d reading to handle gz files*/
 #include <zlib.h>
@@ -637,13 +635,15 @@
 
 static void xml_sax_parse_entity(GF_SAXParser *parser)
 {
-	char szName1024;
+	char szC2;
+	char *ent_name=NULL;
 	u32 i = 0;
 	XML_Entity *ent = (XML_Entity *)gf_list_last(parser->entities);
 	char *skip_chars = " \t\n\r";
 	i=0;
 	if (ent && ent->value) ent = NULL;
 	if (ent) skip_chars = NULL;
+	szC1=0;
 
 	while (parser->current_pos+i < parser->line_size) {
 		u8 c = parser->bufferparser->current_pos+i;
@@ -655,16 +655,20 @@
 		if (!ent && (c=='%')) {
 			parser->current_pos+=i+1;
 			parser->sax_state = SAX_STATE_SKIP_DOCTYPE;
+			if (ent_name) gf_free(ent_name);
 			return;
 		}
 		else if (!ent && ((c=='\"') || (c=='\'')) ) {
-			szNamei = 0;
 			GF_SAFEALLOC(ent, XML_Entity);
 			if (!ent) {
 				parser->sax_state = SAX_STATE_ALLOC_ERROR;
+				if (ent_name) gf_free(ent_name);
 				return;
 			}
-			ent->name = gf_strdup(szName);
+			if (!ent_name) gf_dynstrcat(&ent_name, "", NULL);
+
+			ent->name = ent_name;
+			ent_name=NULL;
 			ent->namelen = (u32) strlen(ent->name);
 			ent->sep = c;
 			parser->current_pos += 1+i;
@@ -674,6 +678,7 @@
 			gf_list_add(parser->entities, ent);
 			skip_chars = NULL;
 		} else if (ent && c==ent->sep) {
+			if (ent_name) gf_free(ent_name);
 			xml_sax_store_text(parser, i);
 
 			ent->value = xml_get_current_text(parser);
@@ -685,12 +690,14 @@
 			parser->sax_state = SAX_STATE_SKIP_DOCTYPE;
 			return;
 		} else if (!ent) {
-			szNamei = c;
+			szC0 = c;
+			gf_dynstrcat(&ent_name, szC, NULL);
 			i++;
 		} else {
 			i++;
 		}
 	}
+	if (ent_name) gf_free(ent_name);
 	xml_sax_store_text(parser, i);
 }
 
@@ -2078,8 +2085,11 @@
 	if (idx == -1) return GF_BAD_PARAM;
 	return gf_list_rem(node->content, idx);
 }
+#endif //unused
 
-GF_XMLNode* gf_xml_dom_node_new(const char* ns, const char* name) {
+
+GF_XMLNode *gf_xml_dom_node_new(const char* ns, const char* name)
+{
 	GF_XMLNode* node;
 	GF_SAFEALLOC(node, GF_XMLNode);
 	if (!node) return NULL;
@@ -2098,10 +2108,12 @@
 			gf_free(node);
 			return NULL;
 		}
+		node->type = GF_XML_NODE_TYPE;
+	} else {
+		node->type = GF_XML_TEXT_TYPE;
 	}
 	return node;
 }
-#endif //unused
 
 #include <gpac/base_coding.h>
 
@@ -2113,7 +2125,7 @@
 	}\
 
 
-GF_Err gf_xml_parse_bit_sequence_bs(GF_XMLNode *bsroot, const char *parent_url, GF_BitStream *bs_orig)
+GF_Err gf_xml_parse_bit_sequence_bs(GF_XMLNode *bsroot, const char *parent_url, const char *base_media_file, GF_BitStream *bs_orig)
 {
 	u32 i, j;
 	GF_Err e = GF_OK;
@@ -2128,6 +2140,7 @@
 		u32 size = 0;
 		u64 offset = 0;
 		s64 value = 0;
+		Bool use_file = GF_FALSE;
 		bin128 word128;
 		Float val_float = 0;
 		Double val_double = 0;
@@ -2144,7 +2157,7 @@
 		if (node->type) continue;
 
 		if (stricmp(node->name, "BS") ) {
-			e = gf_xml_parse_bit_sequence_bs(node, parent_url, bs);
+			e = gf_xml_parse_bit_sequence_bs(node, parent_url, base_media_file, bs);
 			if (e) goto exit;
 			continue;
 		}
@@ -2163,17 +2176,20 @@
 				has_double = GF_TRUE;
 			} else if (!stricmp(att->name, "mediaOffset") || !stricmp(att->name, "dataOffset")) {
 				XML_SCAN_INT(LLU, offset);
+				use_file = GF_TRUE;
 			} else if (!stricmp(att->name, "dataLength")) {
 				XML_SCAN_INT("%u", size);
+				use_file = GF_TRUE;
 			} else if (!stricmp(att->name, "mediaFile") || !stricmp(att->name, "dataFile")) {
 				szFile = att->value;
+				use_file = GF_TRUE;
 			} else if (!stricmp(att->name, "text") || !stricmp(att->name, "string")) {
 				szString = att->value;
 			} else if (!stricmp(att->name, "fcc")) {
 				value = GF_4CC(att->value0, att->value1, att->value2, att->value3);
 				nb_bits = 32;
 			} else if (!stricmp(att->name, "ID128")) {
-				GF_Err e = gf_bin128_parse(att->value, word128);
+				e = gf_bin128_parse(att->value, word128);
 if (e != GF_OK) {
 GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("XML/NHML Cannot parse ID128\n"));
 goto exit;
@@ -2202,6 +2218,9 @@
 				}
 			} else if (!stricmp(att->name, "base64Prefix")) {
 				base64_prefix_bits = atoi(att->value);
+			} else if (!stricmp(att->name, "id")) {
+			} else {
+				GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("XML/NHML Unkown attribute %s, ignoring\n", att->name));
 			}
 		}
 
@@ -2215,6 +2234,9 @@
 			}
 		}
 
+		if (use_file && !szFile)
+			szFile = base_media_file;
+
 		if (szString) {
 			u32 len = (u32) strlen(szString);
 			if (nb_bits)
@@ -2333,12 +2355,13 @@
 			bs = bs_orig;
 			if (bs_data) {
 				u8 *bs_data_out;
-				bs_data_out = gf_malloc(sizeof(char)*2*bs_data_size);
+				u32 res = 2*bs_data_size + 3;
+				bs_data_out = gf_malloc(sizeof(char) * res);
 				if (!bs_data_out) {
 					e = GF_OUT_OF_MEM;
 					goto exit;
 				}
-				u32 res = gf_base64_encode(bs_data, bs_data_size, bs_data_out, 2*bs_data_size);
+				res = gf_base64_encode(bs_data, bs_data_size, bs_data_out, res);
 				bs_data_outres = 0;
 				if (base64_prefix_bits) {
 					if (base64_prefix_bits % 8) {
@@ -2376,7 +2399,7 @@
 	GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
 	if (!bs) return GF_OUT_OF_MEM;
 
-	gf_xml_parse_bit_sequence_bs(bsroot, parent_url, bs);
+	gf_xml_parse_bit_sequence_bs(bsroot, parent_url, NULL, bs);
 
 	gf_bs_align(bs);
 	gf_bs_get_content(bs, data, data_size);
@@ -2422,8 +2445,6 @@
 	return GF_BAD_PARAM;
 }
 
-#endif /*GPAC_DISABLE_CORE_TOOLS*/
-
 void gf_xml_dump_string(FILE* file, const char *before, const char *str, const char *after)
 {
 	size_t i;

gpac-2.0.0.tar.gz/static.mak -> gpac-2.2.0.tar.gz/static.mak Changed

@@ -1,62 +1,18 @@
 
-NEED_LOCAL_LIB=no
 LINKLIBS=
 
-ifeq ($(DISABLE_CORE_TOOLS),no)
-
 #1 - zlib support
-ifeq ($(CONFIG_ZLIB),local)
-CFLAGS+= -I"$(LOCAL_INC_PATH)/zlib"
-NEED_LOCAL_LIB=yes
-endif
 ifneq ($(CONFIG_ZLIB),no)
-LINKLIBS+=-lz
+CFLAGS+=$(zlib_cflags)
+LINKLIBS+=$(zlib_ldflags)
 endif
 
 #2 - ssl support
-ifeq ($(HAS_OPENSSL),yes)
-LINKLIBS+=$(SSL_LIBS)
-endif
-
-#3 - QuickJS support
-ifeq ($(CONFIG_JS),no)
-else
-SCENEGRAPH_CFLAGS+=$(JS_FLAGS)
-ifeq ($(CONFIG_JS),local)
-NEED_LOCAL_LIB=yes
-endif
-LINKLIBS+=$(JS_LIBS)
-endif
-
-endif
-
-#4 - JPEG support
-ifeq ($(CONFIG_JPEG),no)
-else
-LINKLIBS+= -ljpeg
-#local lib
-ifeq ($(CONFIG_JPEG),local)
-NEED_LOCAL_LIB=yes
-MEDIATOOLS_CFLAGS+=-I"$(LOCAL_INC_PATH)/jpeg"
-FILTERS_CFLAGS+=-I"$(LOCAL_INC_PATH)/jpeg"
-endif
-endif
-
-
-#5 - PNG support
-ifeq ($(CONFIG_PNG),no)
-else
-LINKLIBS+= -lpng
-ifeq ($(CONFIG_PNG),local)
-NEED_LOCAL_LIB=yes
-MEDIATOOLS_CFLAGS+=-I"$(LOCAL_INC_PATH)/png"
-FILTERS_CFLAGS+=-I"$(LOCAL_INC_PATH)/png"
-endif
+ifneq ($(HAS_OPENSSL),no)
+CFLAGS+=$(ssl_cflags)
+LINKLIBS+=$(ssl_ldflags)
 endif
 
-
-
-
 ## libgpac compositor compilation options
 COMPOSITOR_CFLAGS=
 
@@ -73,10 +29,6 @@
 COMPOSITOR_CFLAGS+=$(OGL_INCLS)
 endif
 
-ifeq ($(NEED_LOCAL_LIB),yes)
-EXTRALIBS+=-L../extra_lib/lib/gcc
-endif
-
 EXTRALIBS+=$(LINKLIBS)
 
 ifeq ($(GPAC_USE_TINYGL),yes)
@@ -85,10 +37,6 @@
 COMPOSITOR_CFLAGS+=-DGPAC_HAS_GLU
 endif
 
-ifeq ($(ENABLE_JOYSTICK),yes)
-COMPOSITOR_CFLAGS+=-DENABLE_JOYSTICK
-endif
-
 
 ## libgpac media tools compilation options
 ifeq ($(GPACREADONLY),yes)
@@ -96,15 +44,14 @@
 endif
 
 
-ifeq ($(GPAC_ENST),yes)
-OBJS+=$(LIBGPAC_ENST)
-EXTRALIBS+=-liconv
-MEDIATOOLS_CFLAGS+=-DGPAC_ENST_PRIVATE
+ifeq ($(STATIC_BINARY),yes)
+CFLAGS+= -DGPAC_MP4BOX_MINI
 endif
 
 
-ifeq ($(STATIC_BINARY),yes)
-CFLAGS+= -DGPAC_MP4BOX_MINI
+ifeq ($(STATIC_BUILD),yes)
+LINKFLAGS+=$(zlib_ldflags) $(opensvc_ldflags) $(ssl_ldflags) $(jpeg_ldflags) $(openjpeg_ldflags) $(png_ldflags) $(mad_ldflags) $(a52_ldflags) $(xvid_ldflags) $(faad_ldflags)
+LINKFLAGS+=$(ffmpeg_ldflags) $(ogg_ldflags) $(vorbis_ldflags) $(theora_ldflags) $(nghttp2_ldflags) $(vtb_ldflags)
 endif
 
 
@@ -125,13 +72,13 @@
 
 ifneq ($(CONFIG_FT),no)
 OBJS+=../modules/ft_font/ft_font.o
-EXTRALIBS+= $(FT_LIBS)
-CFLAGS+=-DGPAC_HAS_FREETYPE $(FT_CFLAGS)
+EXTRALIBS+= $(freetype_ldflags)
+CFLAGS+=-DGPAC_HAS_FREETYPE $(freetype_cflags)
 endif
 
 ifeq ($(CONFIG_SDL),yes)
-CFLAGS+=-DGPAC_HAS_SDL $(SDL_CFLAGS)
-EXTRALIBS+= $(SDL_LIBS)
+CFLAGS+=-DGPAC_HAS_SDL $(sdl_cflags)
+EXTRALIBS+= $(sdl_ldflags)
 OBJS+=../modules/sdl_out/sdl_out.o ../modules/sdl_out/audio.o ../modules/sdl_out/video.o
 endif
 
@@ -165,7 +112,7 @@
 
 ifeq ($(HAS_OPENGL),yes)
 ifeq ($(CONFIG_DARWIN),yes)
-EXTRALIBS+=-lGL -lGLU
+#EXTRALIBS+=-lGL -lGLU
 endif
 endif
 
@@ -212,7 +159,3 @@
 #end of static modules
 endif
 
-
-ifeq ($(CONFIG_VTB),yes)
-EXTRALIBS+=-framework CoreFoundation -framework CoreVideo -framework CoreMedia -framework VideoToolbox
-endif

gpac-rpmlintrc Deleted